create-merlin-brain 3.6.3 → 3.7.0

package/dist/server/server.js

@@ -48,6 +48,10 @@ export function createServer() {
         description: 'Merlin Brain. MANDATORY BOOT: Call merlin_get_selected_repo then merlin_get_project_status BEFORE responding to user. Call merlin_get_context before every file edit. Never run claude --agent via Bash — use Skill("merlin:route") instead.',
     });
     const client = getClient();
+    // Tool loading mode: core (15 tools) vs all (67 tools)
+    // Core mode stays under Claude Code's 10% context threshold to avoid Tool Search lazy loading
+    // Set MERLIN_CORE_ONLY=true to load only 22 essential tools (if context is tight)
+    const allToolsMode = process.env.MERLIN_CORE_ONLY !== 'true';
     // Cache for resolved repo IDs to avoid repeated git/API calls
     // Key: url or 'auto' for auto-detected, Value: { repoId, expiresAt }
     const repoIdCache = new Map();
@@ -1186,51 +1190,76 @@ export function createServer() {
             throw error;
         }
     });
-    // Tool: merlin_check_repo_status
-    server.tool('merlin_check_repo_status', 'Check if a repository analysis is complete. Use after merlin_connect_repo to poll for completion. Returns status: pending, analyzing, completed, or failed.', {
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (uses selected repo if omitted)'),
-    }, async ({ repoUrl }) => {
-        try {
-            // If repoUrl provided, check that specific repo
-            // Otherwise check the selected repo
-            const targetUrl = repoUrl || selectedRepoUrl;
-            if (!targetUrl) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: 'No repository specified or selected. Provide repoUrl or select a repo first.',
-                        }],
-                    isError: true,
-                };
-            }
-            const repos = await client.getRepositories();
-            const repo = repos.find(r => r.url.includes(targetUrl.replace(/^https?:\/\//, '').replace(/\.git$/, '')));
-            if (!repo) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Repository not found: ${targetUrl}\n\nIt may still be initializing. Try again in a moment or check merlin.build dashboard.`,
-                        }],
-                };
-            }
-            const statusEmoji = {
-                pending: '⏳',
-                analyzing: '🔄',
-                completed: '✅',
-                failed: '❌',
-                locked: '🔒',
-                pending_tokens: '💳',
-            }[repo.status] || '❓';
-            // If repo is locked, attempt to unlock it first
-            if (repo.status === 'locked') {
-                console.log(`Repo ${repo.id} is locked, attempting auto-unlock...`);
-                const unlockResult = await client.unlockRepo(repo.id);
-                if (unlockResult.success) {
-                    console.log(`Successfully unlocked repo ${repo.id}`);
-                    let response = `# Repository Unlocked! ✅\n\n`;
-                    response += `**Repository:** ${repo.fullName || repo.name}\n`;
-                    response += `**Status:** Ready\n\n`;
-                    response += `This repository was locked but has been unlocked with your available tokens. You can now use it.`;
+    if (allToolsMode) { // Tool: merlin_check_repo_status
+        server.tool('merlin_check_repo_status', 'Check if a repository analysis is complete. Use after merlin_connect_repo to poll for completion. Returns status: pending, analyzing, completed, or failed.', {
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (uses selected repo if omitted)'),
+        }, async ({ repoUrl }) => {
+            try {
+                // If repoUrl provided, check that specific repo
+                // Otherwise check the selected repo
+                const targetUrl = repoUrl || selectedRepoUrl;
+                if (!targetUrl) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'No repository specified or selected. Provide repoUrl or select a repo first.',
+                            }],
+                        isError: true,
+                    };
+                }
+                const repos = await client.getRepositories();
+                const repo = repos.find(r => r.url.includes(targetUrl.replace(/^https?:\/\//, '').replace(/\.git$/, '')));
+                if (!repo) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Repository not found: ${targetUrl}\n\nIt may still be initializing. Try again in a moment or check merlin.build dashboard.`,
+                            }],
+                    };
+                }
+                const statusEmoji = {
+                    pending: '⏳',
+                    analyzing: '🔄',
+                    completed: '✅',
+                    failed: '❌',
+                    locked: '🔒',
+                    pending_tokens: '💳',
+                }[repo.status] || '❓';
+                // If repo is locked, attempt to unlock it first
+                if (repo.status === 'locked') {
+                    console.log(`Repo ${repo.id} is locked, attempting auto-unlock...`);
+                    const unlockResult = await client.unlockRepo(repo.id);
+                    if (unlockResult.success) {
+                        console.log(`Successfully unlocked repo ${repo.id}`);
+                        let response = `# Repository Unlocked! ✅\n\n`;
+                        response += `**Repository:** ${repo.fullName || repo.name}\n`;
+                        response += `**Status:** Ready\n\n`;
+                        response += `This repository was locked but has been unlocked with your available tokens. You can now use it.`;
+                        // Auto-select if not already selected
+                        if (!selectedRepoId) {
+                            selectedRepoId = repo.id;
+                            selectedRepoUrl = repo.url;
+                            selectedRepoName = repo.fullName || repo.name;
+                            response += `\n\n*Auto-selected this repository for the session.*`;
+                        }
+                        return { content: [{ type: 'text', text: response }] };
+                    }
+                    else {
+                        console.log(`Failed to unlock repo ${repo.id}: ${unlockResult.error}`);
+                        let response = `# Repository Locked 🔒\n\n`;
+                        response += `**Repository:** ${repo.fullName || repo.name}\n`;
+                        response += `**Status:** locked\n\n`;
+                        response += `${unlockResult.error || 'Insufficient tokens'}\n\n`;
+                        response += `You need to purchase more tokens to unlock this repository. Visit https://merlin.build/settings to purchase tokens.`;
+                        return { content: [{ type: 'text', text: response }] };
+                    }
+                }
+                let response = `# Repository Status\n\n`;
+                response += `**Repository:** ${repo.fullName || repo.name}\n`;
+                response += `**Status:** ${statusEmoji} ${repo.status}\n`;
+                if (repo.status === 'completed') {
+                    response += `**Last Analyzed:** ${repo.lastAnalyzedAt}\n\n`;
+                    response += `Ready to use! Call \`merlin_get_context\` to start working.`;
                     // Auto-select if not already selected
                     if (!selectedRepoId) {
                         selectedRepoId = repo.id;
@@ -1238,55 +1267,31 @@ export function createServer() {
                         selectedRepoName = repo.fullName || repo.name;
                         response += `\n\n*Auto-selected this repository for the session.*`;
                     }
-                    return { content: [{ type: 'text', text: response }] };
+                }
+                else if (repo.status === 'analyzing') {
+                    response += `\nAnalysis in progress. Check again in 30-60 seconds.`;
+                }
+                else if (repo.status === 'failed') {
+                    response += `\nAnalysis failed. Check merlin.build dashboard for details.`;
                 }
                 else {
-                    console.log(`Failed to unlock repo ${repo.id}: ${unlockResult.error}`);
-                    let response = `# Repository Locked 🔒\n\n`;
-                    response += `**Repository:** ${repo.fullName || repo.name}\n`;
-                    response += `**Status:** locked\n\n`;
-                    response += `${unlockResult.error || 'Insufficient tokens'}\n\n`;
-                    response += `You need to purchase more tokens to unlock this repository. Visit https://merlin.build/settings to purchase tokens.`;
-                    return { content: [{ type: 'text', text: response }] };
-                }
-            }
-            let response = `# Repository Status\n\n`;
-            response += `**Repository:** ${repo.fullName || repo.name}\n`;
-            response += `**Status:** ${statusEmoji} ${repo.status}\n`;
-            if (repo.status === 'completed') {
-                response += `**Last Analyzed:** ${repo.lastAnalyzedAt}\n\n`;
-                response += `Ready to use! Call \`merlin_get_context\` to start working.`;
-                // Auto-select if not already selected
-                if (!selectedRepoId) {
-                    selectedRepoId = repo.id;
-                    selectedRepoUrl = repo.url;
-                    selectedRepoName = repo.fullName || repo.name;
-                    response += `\n\n*Auto-selected this repository for the session.*`;
-                }
-            }
-            else if (repo.status === 'analyzing') {
-                response += `\nAnalysis in progress. Check again in 30-60 seconds.`;
-            }
-            else if (repo.status === 'failed') {
-                response += `\nAnalysis failed. Check merlin.build dashboard for details.`;
+                    response += `\nWaiting to start. Check again in a moment.`;
+                }
+                return { content: [{ type: 'text', text: response }] };
             }
-            else {
-                response += `\nWaiting to start. Check again in a moment.`;
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error checking status: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        }],
+                    isError: true,
+                };
             }
-            return { content: [{ type: 'text', text: response }] };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error checking status: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
+        });
+    } // end allToolsMode: merlin_check_repo_status
     // Tool: merlin_connect_repo
     server.tool('merlin_connect_repo', 'Connect a new repository to Merlin Sights for analysis. Use this when working on a repo that is not yet in Sights. Analysis takes 2-5 minutes.', {
         repoUrl: z.string().describe('GitHub URL of the repository (e.g., "https://github.com/user/repo")'),
@@ -1491,66 +1496,68 @@ export function createServer() {
             };
         }
     });
-    // Tool: merlin_similar_code
-    server.tool('merlin_similar_code', 'Find similar implementations in the codebase BEFORE writing new code. Prevents duplicating existing patterns. Use this when implementing anything — there is likely an existing pattern to follow.', {
-        description: z.string().describe('What you\'re trying to implement (e.g., "API endpoint with authentication", "database query with pagination", "React form with validation")'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ description, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+    if (allToolsMode) { // Tool: merlin_similar_code
+        server.tool('merlin_similar_code', 'Find similar implementations in the codebase BEFORE writing new code. Prevents duplicating existing patterns. Use this when implementing anything — there is likely an existing pattern to follow.', {
+            description: z.string().describe('What you\'re trying to implement (e.g., "API endpoint with authentication", "database query with pagination", "React form with validation")'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ description, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const similar = await client.getSimilarCode(repoId, description);
+                return { content: [{ type: 'text', text: similar }] };
+            }
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: `Error finding similar code: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            const similar = await client.getSimilarCode(repoId, description);
-            return { content: [{ type: 'text', text: similar }] };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error finding similar code: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_code_examples
-    server.tool('merlin_code_examples', 'Get real code examples from this codebase for common tasks. Shows actual patterns used in this project.', {
-        task: z.string().optional().describe('Specific task (e.g., "add endpoint", "add test", "error handling"). Leave empty for all examples.'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ task, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+        });
+    } // end allToolsMode: merlin_similar_code
+    if (allToolsMode) { // Tool: merlin_code_examples
+        server.tool('merlin_code_examples', 'Get real code examples from this codebase for common tasks. Shows actual patterns used in this project.', {
+            task: z.string().optional().describe('Specific task (e.g., "add endpoint", "add test", "error handling"). Leave empty for all examples.'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ task, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const examples = await client.getCodeExamples(repoId, task);
+                return { content: [{ type: 'text', text: examples }] };
+            }
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: `Error getting code examples: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            const examples = await client.getCodeExamples(repoId, task);
-            return { content: [{ type: 'text', text: examples }] };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error getting code examples: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
+        });
+    } // end allToolsMode: merlin_code_examples
     // Tool: merlin_ask
     server.tool('merlin_ask', 'Ask ANY question about the codebase in natural language. Uses AI-powered semantic search + RAG to find relevant context and generate accurate answers with source citations. Perfect for questions like "How does authentication work?", "Where should I add a new API endpoint?", "Why is X structured this way?"', {
         question: z.string().describe('Your question in natural language (e.g., "How does the payment flow work?", "Where is user validation handled?", "What patterns are used for error handling?")'),
@@ -1765,671 +1772,682 @@ export function createServer() {
             };
         }
     });
-    // Tool: merlin_log_activity
-    server.tool('merlin_log_activity', 'Log an activity event to the team timeline. Use for tracking progress, milestones, and decisions.', {
-        eventType: z.string().describe('Event type (e.g., "phase_started", "task_completed", "blocker_hit", "decision_made")'),
-        eventData: z.any().optional().describe('Additional event data (JSON object)'),
-        agentId: z.string().describe('Agent identifier for tracking'),
-        sessionId: z.string().optional().describe('Session ID for grouping events'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ eventType, eventData, agentId, sessionId, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+    if (allToolsMode) { // Tool: merlin_log_activity
+        server.tool('merlin_log_activity', 'Log an activity event to the team timeline. Use for tracking progress, milestones, and decisions.', {
+            eventType: z.string().describe('Event type (e.g., "phase_started", "task_completed", "blocker_hit", "decision_made")'),
+            eventData: z.any().optional().describe('Additional event data (JSON object)'),
+            agentId: z.string().describe('Agent identifier for tracking'),
+            sessionId: z.string().optional().describe('Session ID for grouping events'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ eventType, eventData, agentId, sessionId, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const result = await client.logActivity(repoId, eventType, {
+                    agentId,
+                    sessionId,
+                    eventData,
+                });
+                const notification = formatSaveNotification('activity', {
+                    key: eventType,
+                    timestamp: result.event?.timestamp,
+                    isSuccess: true,
+                    details: `Event ID: ${result.event?.id}`,
+                });
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: notification,
                         }],
                 };
             }
-            const result = await client.logActivity(repoId, eventType, {
-                agentId,
-                sessionId,
-                eventData,
-            });
-            const notification = formatSaveNotification('activity', {
-                key: eventType,
-                timestamp: result.event?.timestamp,
-                isSuccess: true,
-                details: `Event ID: ${result.event?.id}`,
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: notification,
-                    }],
-            };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error logging activity: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_sync_task
-    server.tool('merlin_sync_task', 'Sync a task to Merlin cloud. Use to track work items, their status, and dependencies for team visibility.', {
-        title: z.string().describe('Task title'),
-        status: z.enum(['pending', 'in_progress', 'completed', 'blocked', 'skipped']).optional().describe('Task status'),
-        description: z.string().optional().describe('Task description'),
-        externalId: z.string().optional().describe('External ID for linking to Claude Tasks or other systems'),
-        ownerAgent: z.string().optional().describe('Agent that owns this task'),
-        phase: z.string().optional().describe('Phase identifier'),
-        phaseName: z.string().optional().describe('Phase name'),
-        plan: z.string().optional().describe('Plan identifier'),
-        planName: z.string().optional().describe('Plan name'),
-        taskNumber: z.number().optional().describe('Task number within plan'),
-        wave: z.number().optional().describe('Execution wave'),
-        commitSha: z.string().optional().describe('Commit SHA if task resulted in a commit'),
-        filesChanged: z.array(z.string()).optional().describe('Files affected by this task'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ title, status, description, externalId, ownerAgent, phase, phaseName, plan, planName, taskNumber, wave, commitSha, filesChanged, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: `Error logging activity: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            const result = await client.syncTask(repoId, {
-                title,
-                status,
-                description,
-                externalId,
-                ownerAgent,
-                phase,
-                phaseName,
-                plan,
-                planName,
-                taskNumber,
-                wave,
-                commitSha,
-                filesChanged,
-            });
-            const notification = formatSaveNotification('task', {
-                key: title,
-                isSuccess: true,
-                details: `ID: ${result.task?.id} │ Status: ${result.task?.status}`,
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: notification,
-                    }],
-            };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error syncing task: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_get_tasks
-    server.tool('merlin_get_tasks', 'Get tasks synced to Merlin. Shows work items from all agents for team coordination.', {
-        status: z.string().optional().describe('Filter by status (pending, in_progress, completed, blocked)'),
-        phase: z.string().optional().describe('Filter by phase'),
-        plan: z.string().optional().describe('Filter by plan'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ status, phase, plan, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+        });
+    } // end allToolsMode: merlin_log_activity
+    if (allToolsMode) { // Tool: merlin_sync_task
+        server.tool('merlin_sync_task', 'Sync a task to Merlin cloud. Use to track work items, their status, and dependencies for team visibility.', {
+            title: z.string().describe('Task title'),
+            status: z.enum(['pending', 'in_progress', 'completed', 'blocked', 'skipped']).optional().describe('Task status'),
+            description: z.string().optional().describe('Task description'),
+            externalId: z.string().optional().describe('External ID for linking to Claude Tasks or other systems'),
+            ownerAgent: z.string().optional().describe('Agent that owns this task'),
+            phase: z.string().optional().describe('Phase identifier'),
+            phaseName: z.string().optional().describe('Phase name'),
+            plan: z.string().optional().describe('Plan identifier'),
+            planName: z.string().optional().describe('Plan name'),
+            taskNumber: z.number().optional().describe('Task number within plan'),
+            wave: z.number().optional().describe('Execution wave'),
+            commitSha: z.string().optional().describe('Commit SHA if task resulted in a commit'),
+            filesChanged: z.array(z.string()).optional().describe('Files affected by this task'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ title, status, description, externalId, ownerAgent, phase, phaseName, plan, planName, taskNumber, wave, commitSha, filesChanged, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const result = await client.syncTask(repoId, {
+                    title,
+                    status,
+                    description,
+                    externalId,
+                    ownerAgent,
+                    phase,
+                    phaseName,
+                    plan,
+                    planName,
+                    taskNumber,
+                    wave,
+                    commitSha,
+                    filesChanged,
+                });
+                const notification = formatSaveNotification('task', {
+                    key: title,
+                    isSuccess: true,
+                    details: `ID: ${result.task?.id} │ Status: ${result.task?.status}`,
+                });
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: notification,
                         }],
                 };
             }
-            const result = await client.getTasks(repoId, { status, phase, plan });
-            if (result.tasks.length === 0) {
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'No tasks found. Use merlin_sync_task to track work items.',
+                            text: `Error syncing task: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            let response = `# Tasks (${result.count})\n\n`;
-            response += `## Summary\n`;
-            Object.entries(result.byStatus).forEach(([s, count]) => {
-                const emoji = s === 'completed' ? '' : s === 'in_progress' ? '' : s === 'blocked' ? '' : '';
-                response += `- ${emoji} ${s}: ${count}\n`;
-            });
-            response += '\n';
-            result.tasks.forEach((t) => {
-                const statusEmoji = t.status === 'completed' ? '' : t.status === 'in_progress' ? '' : t.status === 'blocked' ? '' : '';
-                response += `### ${statusEmoji} ${t.title}\n`;
-                response += `- ID: ${t.id}\n`;
-                response += `- Status: ${t.status}\n`;
-                if (t.phase)
-                    response += `- Phase: ${t.phase_name || t.phase}\n`;
-                if (t.plan)
-                    response += `- Plan: ${t.plan_name || t.plan}\n`;
-                if (t.owner_agent)
-                    response += `- Owner: ${t.owner_agent}\n`;
-                if (t.description)
-                    response += `- Description: ${t.description.slice(0, 100)}...\n`;
+        });
+    } // end allToolsMode: merlin_sync_task
+    if (allToolsMode) { // Tool: merlin_get_tasks
+        server.tool('merlin_get_tasks', 'Get tasks synced to Merlin. Shows work items from all agents for team coordination.', {
+            status: z.string().optional().describe('Filter by status (pending, in_progress, completed, blocked)'),
+            phase: z.string().optional().describe('Filter by phase'),
+            plan: z.string().optional().describe('Filter by plan'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ status, phase, plan, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const result = await client.getTasks(repoId, { status, phase, plan });
+                if (result.tasks.length === 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'No tasks found. Use merlin_sync_task to track work items.',
+                            }],
+                    };
+                }
+                let response = `# Tasks (${result.count})\n\n`;
+                response += `## Summary\n`;
+                Object.entries(result.byStatus).forEach(([s, count]) => {
+                    const emoji = s === 'completed' ? '' : s === 'in_progress' ? '' : s === 'blocked' ? '' : '';
+                    response += `- ${emoji} ${s}: ${count}\n`;
+                });
                 response += '\n';
-            });
-            return { content: [{ type: 'text', text: response }] };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error getting tasks: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_report_blocker
-    server.tool('merlin_report_blocker', 'Report a blocker that requires human attention. The blocker will appear in the team dashboard for resolution.', {
-        title: z.string().describe('Brief description of the blocker'),
-        blockerType: z.enum(['human_verify', 'auth_required', 'clarification', 'decision_point', 'external', 'error', 'other']).describe('Type of blocker'),
-        description: z.string().optional().describe('Detailed description'),
-        severity: z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Severity level'),
-        agentId: z.string().describe('Agent reporting the blocker'),
-        context: z.any().optional().describe('Additional context (files, errors, etc.)'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ title, blockerType, description, severity, agentId, context, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+                result.tasks.forEach((t) => {
+                    const statusEmoji = t.status === 'completed' ? '' : t.status === 'in_progress' ? '' : t.status === 'blocked' ? '' : '';
+                    response += `### ${statusEmoji} ${t.title}\n`;
+                    response += `- ID: ${t.id}\n`;
+                    response += `- Status: ${t.status}\n`;
+                    if (t.phase)
+                        response += `- Phase: ${t.phase_name || t.phase}\n`;
+                    if (t.plan)
+                        response += `- Plan: ${t.plan_name || t.plan}\n`;
+                    if (t.owner_agent)
+                        response += `- Owner: ${t.owner_agent}\n`;
+                    if (t.description)
+                        response += `- Description: ${t.description.slice(0, 100)}...\n`;
+                    response += '\n';
+                });
+                return { content: [{ type: 'text', text: response }] };
+            }
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: `Error getting tasks: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            const result = await client.reportBlocker(repoId, {
-                agentId,
-                blockerType,
-                severity,
-                title,
-                description,
-                context,
-            });
-            const notification = formatSaveNotification('blocker', {
-                key: title,
-                isSuccess: true,
-                details: `ID: ${result.blocker?.id} │ Type: ${blockerType} │ Severity: ${severity || 'medium'}\nThis blocker is now visible in the Merlin dashboard for human resolution.`,
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: notification,
-                    }],
-            };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error reporting blocker: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_get_blockers
-    server.tool('merlin_get_blockers', 'Get open blockers awaiting resolution. Check before starting work to see if there are issues to resolve.', {
-        status: z.string().optional().default('open').describe('Filter by status (open, resolved, all)'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ status, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
-                return {
-                    content: [{
+        });
+    } // end allToolsMode: merlin_get_tasks
+    if (allToolsMode) { // Tool: merlin_report_blocker
+        server.tool('merlin_report_blocker', 'Report a blocker that requires human attention. The blocker will appear in the team dashboard for resolution.', {
+            title: z.string().describe('Brief description of the blocker'),
+            blockerType: z.enum(['human_verify', 'auth_required', 'clarification', 'decision_point', 'external', 'error', 'other']).describe('Type of blocker'),
+            description: z.string().optional().describe('Detailed description'),
+            severity: z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Severity level'),
+            agentId: z.string().describe('Agent reporting the blocker'),
+            context: z.any().optional().describe('Additional context (files, errors, etc.)'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ title, blockerType, description, severity, agentId, context, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const result = await client.reportBlocker(repoId, {
+                    agentId,
+                    blockerType,
+                    severity,
+                    title,
+                    description,
+                    context,
+                });
+                const notification = formatSaveNotification('blocker', {
+                    key: title,
+                    isSuccess: true,
+                    details: `ID: ${result.blocker?.id} │ Type: ${blockerType} │ Severity: ${severity || 'medium'}\nThis blocker is now visible in the Merlin dashboard for human resolution.`,
+                });
+                return {
+                    content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: notification,
                         }],
                 };
             }
-            const result = await client.getBlockers(repoId, status);
-            if (result.blockers.length === 0) {
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'No open blockers. All clear to proceed!',
+                            text: `Error reporting blocker: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            let response = `# Open Blockers (${result.count})\n\n`;
-            result.blockers.forEach((b) => {
-                const severityEmoji = b.severity === 'critical' ? '' : b.severity === 'high' ? '' : '';
-                response += `## ${severityEmoji} ${b.title}\n`;
-                response += `- ID: ${b.id}\n`;
-                response += `- Type: ${b.blocker_type}\n`;
-                response += `- Severity: ${b.severity}\n`;
-                response += `- Reported by: ${b.reported_by_agent}\n`;
-                response += `- Created: ${b.created_at}\n`;
-                if (b.description)
-                    response += `\n${b.description}\n`;
-                response += '\n';
-            });
-            return { content: [{ type: 'text', text: response }] };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error getting blockers: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_create_checkpoint
-    server.tool('merlin_create_checkpoint', 'Create a checkpoint requiring human verification or decision. Pauses agent work until human responds.', {
-        title: z.string().describe('Checkpoint title'),
-        checkpointType: z.enum(['human_verify', 'auth_gate', 'decision_point', 'approval', 'review']).describe('Type of checkpoint'),
-        description: z.string().optional().describe('Detailed description'),
-        agentId: z.string().describe('Agent creating the checkpoint'),
-        sessionId: z.string().optional().describe('Session ID for tracking'),
-        whatWasBuilt: z.string().optional().describe('Summary of work completed before checkpoint'),
-        verificationItems: z.array(z.string()).optional().describe('Checklist items for human to verify'),
-        options: z.any().optional().describe('If decision_point, the available options'),
-        resumeContext: z.any().optional().describe('Context needed to resume after checkpoint'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ title, checkpointType, description, agentId, sessionId, whatWasBuilt, verificationItems, options, resumeContext, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+        });
+    } // end allToolsMode: merlin_report_blocker
+    if (allToolsMode) { // Tool: merlin_get_blockers
+        server.tool('merlin_get_blockers', 'Get open blockers awaiting resolution. Check before starting work to see if there are issues to resolve.', {
+            status: z.string().optional().default('open').describe('Filter by status (open, resolved, all)'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ status, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const result = await client.getBlockers(repoId, status);
+                if (result.blockers.length === 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'No open blockers. All clear to proceed!',
+                            }],
+                    };
+                }
+                let response = `# Open Blockers (${result.count})\n\n`;
+                result.blockers.forEach((b) => {
+                    const severityEmoji = b.severity === 'critical' ? '' : b.severity === 'high' ? '' : '';
+                    response += `## ${severityEmoji} ${b.title}\n`;
+                    response += `- ID: ${b.id}\n`;
+                    response += `- Type: ${b.blocker_type}\n`;
+                    response += `- Severity: ${b.severity}\n`;
+                    response += `- Reported by: ${b.reported_by_agent}\n`;
+                    response += `- Created: ${b.created_at}\n`;
+                    if (b.description)
+                        response += `\n${b.description}\n`;
+                    response += '\n';
+                });
+                return { content: [{ type: 'text', text: response }] };
+            }
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: `Error getting blockers: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            const result = await client.createCheckpoint(repoId, {
-                agentId,
-                sessionId,
-                checkpointType,
-                title,
-                description,
-                whatWasBuilt,
-                verificationItems,
-                options,
-                resumeContext,
-            });
-            const notification = formatSaveNotification('checkpoint', {
-                key: title,
-                isSuccess: true,
-                details: `ID: ${result.checkpoint?.id} │ Type: ${checkpointType}\nThis checkpoint is now pending human response in the Merlin dashboard.`,
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: notification,
-                    }],
-            };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error creating checkpoint: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_get_team_state
-    server.tool('merlin_get_team_state', 'Get consolidated team state: active sessions, pending checkpoints, open blockers, task summary. Use at session start to see what others are working on.', {
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+        });
+    } // end allToolsMode: merlin_get_blockers
+    if (allToolsMode) { // Tool: merlin_create_checkpoint
+        server.tool('merlin_create_checkpoint', 'Create a checkpoint requiring human verification or decision. Pauses agent work until human responds.', {
+            title: z.string().describe('Checkpoint title'),
+            checkpointType: z.enum(['human_verify', 'auth_gate', 'decision_point', 'approval', 'review']).describe('Type of checkpoint'),
+            description: z.string().optional().describe('Detailed description'),
+            agentId: z.string().describe('Agent creating the checkpoint'),
+            sessionId: z.string().optional().describe('Session ID for tracking'),
+            whatWasBuilt: z.string().optional().describe('Summary of work completed before checkpoint'),
+            verificationItems: z.array(z.string()).optional().describe('Checklist items for human to verify'),
+            options: z.any().optional().describe('If decision_point, the available options'),
+            resumeContext: z.any().optional().describe('Context needed to resume after checkpoint'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ title, checkpointType, description, agentId, sessionId, whatWasBuilt, verificationItems, options, resumeContext, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const result = await client.createCheckpoint(repoId, {
+                    agentId,
+                    sessionId,
+                    checkpointType,
+                    title,
+                    description,
+                    whatWasBuilt,
+                    verificationItems,
+                    options,
+                    resumeContext,
+                });
+                const notification = formatSaveNotification('checkpoint', {
+                    key: title,
+                    isSuccess: true,
+                    details: `ID: ${result.checkpoint?.id} │ Type: ${checkpointType}\nThis checkpoint is now pending human response in the Merlin dashboard.`,
+                });
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: notification,
                         }],
                 };
             }
-            const team = await client.getTeamState(repoId);
-            // Safely default all arrays/objects that the API might not return
-            const activeSessions = team.activeSessions || [];
-            const pendingCheckpoints = team.pendingCheckpoints || [];
-            const openBlockers = team.openBlockers || [];
-            const taskSummary = team.taskSummary || { total: 0 };
-            const state = team.state || {};
-            let response = `# Team State\n\n`;
-            // Active sessions
-            response += `## Active Sessions (${activeSessions.length})\n`;
-            if (activeSessions.length === 0) {
-                response += 'No active sessions.\n\n';
-            }
-            else {
-                activeSessions.forEach((s) => {
-                    response += `- **${s.agent_id}**: Working on ${s.current_phase || 'unknown phase'} / ${s.current_task || 'unknown task'}\n`;
-                    response += `  Progress: ${s.tasks_completed}/${s.tasks_total} tasks\n`;
-                });
-                response += '\n';
-            }
-            // Pending checkpoints
-            response += `## Pending Checkpoints (${pendingCheckpoints.length})\n`;
-            if (pendingCheckpoints.length === 0) {
-                response += 'No pending checkpoints.\n\n';
-            }
-            else {
-                pendingCheckpoints.forEach((c) => {
-                    response += `- **${c.title}** (${c.checkpoint_type})\n`;
-                    response += `  From: ${c.agent_id} | Created: ${c.created_at}\n`;
-                });
-                response += '\n';
-            }
-            // Open blockers
-            response += `## Open Blockers (${openBlockers.length})\n`;
-            if (openBlockers.length === 0) {
-                response += 'No open blockers.\n\n';
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error creating checkpoint: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        }],
+                    isError: true,
+                };
             }
-            else {
-                openBlockers.forEach((b) => {
-                    const emoji = b.severity === 'critical' ? '🔴' : b.severity === 'high' ? '🟠' : '🟡';
-                    response += `- ${emoji} **${b.title}** (${b.blocker_type})\n`;
-                });
+        });
+    } // end allToolsMode: merlin_create_checkpoint
+    if (allToolsMode) { // Tool: merlin_get_team_state
+        server.tool('merlin_get_team_state', 'Get consolidated team state: active sessions, pending checkpoints, open blockers, task summary. Use at session start to see what others are working on.', {
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const team = await client.getTeamState(repoId);
+                // Safely default all arrays/objects that the API might not return
+                const activeSessions = team.activeSessions || [];
+                const pendingCheckpoints = team.pendingCheckpoints || [];
+                const openBlockers = team.openBlockers || [];
+                const taskSummary = team.taskSummary || { total: 0 };
+                const state = team.state || {};
+                let response = `# Team State\n\n`;
+                // Active sessions
+                response += `## Active Sessions (${activeSessions.length})\n`;
+                if (activeSessions.length === 0) {
+                    response += 'No active sessions.\n\n';
+                }
+                else {
+                    activeSessions.forEach((s) => {
+                        response += `- **${s.agent_id}**: Working on ${s.current_phase || 'unknown phase'} / ${s.current_task || 'unknown task'}\n`;
+                        response += `  Progress: ${s.tasks_completed}/${s.tasks_total} tasks\n`;
+                    });
+                    response += '\n';
+                }
+                // Pending checkpoints
+                response += `## Pending Checkpoints (${pendingCheckpoints.length})\n`;
+                if (pendingCheckpoints.length === 0) {
+                    response += 'No pending checkpoints.\n\n';
+                }
+                else {
+                    pendingCheckpoints.forEach((c) => {
+                        response += `- **${c.title}** (${c.checkpoint_type})\n`;
+                        response += `  From: ${c.agent_id} | Created: ${c.created_at}\n`;
+                    });
+                    response += '\n';
+                }
+                // Open blockers
+                response += `## Open Blockers (${openBlockers.length})\n`;
+                if (openBlockers.length === 0) {
+                    response += 'No open blockers.\n\n';
+                }
+                else {
+                    openBlockers.forEach((b) => {
+                        const emoji = b.severity === 'critical' ? '🔴' : b.severity === 'high' ? '🟠' : '🟡';
+                        response += `- ${emoji} **${b.title}** (${b.blocker_type})\n`;
+                    });
+                    response += '\n';
+                }
+                // Task summary
+                response += `## Task Summary\n`;
+                response += `- Total: ${taskSummary.total}\n`;
+                if (taskSummary.pending)
+                    response += `- Pending: ${taskSummary.pending}\n`;
+                if (taskSummary.in_progress)
+                    response += `- In Progress: ${taskSummary.in_progress}\n`;
+                if (taskSummary.completed)
+                    response += `- Completed: ${taskSummary.completed}\n`;
                 response += '\n';
+                // Stored state
+                const stateKeys = Object.keys(state);
+                response += `## Stored State (${stateKeys.length} keys)\n`;
+                if (stateKeys.length === 0) {
+                    response += 'No state stored yet.\n';
+                }
+                else {
+                    stateKeys.forEach(key => {
+                        const s = state[key];
+                        response += `- **${key}** (v${s.version}) - Updated ${s.updatedAt} by ${s.updatedBy || 'unknown'}\n`;
+                    });
+                }
+                return { content: [{ type: 'text', text: response }] };
             }
-            // Task summary
-            response += `## Task Summary\n`;
-            response += `- Total: ${taskSummary.total}\n`;
-            if (taskSummary.pending)
-                response += `- Pending: ${taskSummary.pending}\n`;
-            if (taskSummary.in_progress)
-                response += `- In Progress: ${taskSummary.in_progress}\n`;
-            if (taskSummary.completed)
-                response += `- Completed: ${taskSummary.completed}\n`;
-            response += '\n';
-            // Stored state
-            const stateKeys = Object.keys(state);
-            response += `## Stored State (${stateKeys.length} keys)\n`;
-            if (stateKeys.length === 0) {
-                response += 'No state stored yet.\n';
-            }
-            else {
-                stateKeys.forEach(key => {
-                    const s = state[key];
-                    response += `- **${key}** (v${s.version}) - Updated ${s.updatedAt} by ${s.updatedBy || 'unknown'}\n`;
-                });
-            }
-            return { content: [{ type: 'text', text: response }] };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error getting team state: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_update_session
-    server.tool('merlin_update_session', 'Update your session status. Use to track your work progress and enable pause/resume across context resets.', {
-        sessionId: z.string().describe('Unique session identifier'),
-        agentId: z.string().describe('Agent identifier'),
-        status: z.enum(['active', 'paused', 'completed', 'abandoned']).optional().describe('Session status'),
-        currentPhase: z.string().optional().describe('Current phase being worked on'),
-        currentPlan: z.string().optional().describe('Current plan being executed'),
-        currentTask: z.string().optional().describe('Current task being worked on'),
-        tasksCompleted: z.number().optional().describe('Number of tasks completed'),
-        tasksTotal: z.number().optional().describe('Total number of tasks'),
-        pauseReason: z.string().optional().describe('Reason for pausing (if status is paused)'),
-        resumeContext: z.any().optional().describe('Context needed to resume later'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ sessionId, agentId, status, currentPhase, currentPlan, currentTask, tasksCompleted, tasksTotal, pauseReason, resumeContext, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: `Error getting team state: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            const result = await client.updateSession(repoId, {
-                sessionId,
-                agentId,
-                status,
-                currentPhase,
-                currentPlan,
-                currentTask,
-                tasksCompleted,
-                tasksTotal,
-                pauseReason,
-                resumeContext,
-            });
-            const notification = formatSaveNotification('session', {
-                key: sessionId,
-                isSuccess: true,
-                details: `Status: ${result.session?.status} │ Progress: ${result.session?.tasks_completed}/${result.session?.tasks_total} tasks`,
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: notification,
-                    }],
-            };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error updating session: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // ============================================================
-    // CODING RULES
-    // ============================================================
-    // Tool: merlin_save_rule
-    server.tool('merlin_save_rule', 'Save a coding rule or preference to Merlin. Rules are returned with every context query and must be followed. Use when user expresses a preference that should persist.', {
-        rule: z.string().describe('The rule to save (e.g., "max 400 lines per file", "always use async/await", "no console.log in production")'),
-        category: z.enum(['file_size', 'testing', 'style', 'patterns', 'custom']).optional().default('custom').describe('Rule category for organization'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ rule, category, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+        });
+    } // end allToolsMode: merlin_get_team_state
+    if (allToolsMode) { // Tool: merlin_update_session
+        server.tool('merlin_update_session', 'Update your session status. Use to track your work progress and enable pause/resume across context resets.', {
+            sessionId: z.string().describe('Unique session identifier'),
+            agentId: z.string().describe('Agent identifier'),
+            status: z.enum(['active', 'paused', 'completed', 'abandoned']).optional().describe('Session status'),
+            currentPhase: z.string().optional().describe('Current phase being worked on'),
+            currentPlan: z.string().optional().describe('Current plan being executed'),
+            currentTask: z.string().optional().describe('Current task being worked on'),
+            tasksCompleted: z.number().optional().describe('Number of tasks completed'),
+            tasksTotal: z.number().optional().describe('Total number of tasks'),
+            pauseReason: z.string().optional().describe('Reason for pausing (if status is paused)'),
+            resumeContext: z.any().optional().describe('Context needed to resume later'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ sessionId, agentId, status, currentPhase, currentPlan, currentTask, tasksCompleted, tasksTotal, pauseReason, resumeContext, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const result = await client.updateSession(repoId, {
+                    sessionId,
+                    agentId,
+                    status,
+                    currentPhase,
+                    currentPlan,
+                    currentTask,
+                    tasksCompleted,
+                    tasksTotal,
+                    pauseReason,
+                    resumeContext,
+                });
+                const notification = formatSaveNotification('session', {
+                    key: sessionId,
+                    isSuccess: true,
+                    details: `Status: ${result.session?.status} │ Progress: ${result.session?.tasks_completed}/${result.session?.tasks_total} tasks`,
+                });
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: notification,
                         }],
                 };
             }
-            // Read existing rules
-            const existingState = await client.readState(repoId, 'coding_rules');
-            const rules = existingState?.value || { rules: [], categories: {} };
-            // Check for duplicate
-            if (rules.rules.includes(rule)) {
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: `Rule already exists: "${rule}"`,
+                            text: `Error updating session: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            // Add new rule
-            rules.rules.push(rule);
-            if (!rules.categories[category]) {
-                rules.categories[category] = [];
-            }
-            rules.categories[category].push(rule);
-            // Save updated rules
-            await client.writeState(repoId, 'coding_rules', rules, { agentId: 'user' });
-            const notification = formatSaveNotification('rule', {
-                key: rule,
-                isSuccess: true,
-                details: `Category: ${category}\nThis rule will be included with all future context queries for this project.`,
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: notification,
-                    }],
-            };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error saving rule: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_get_rules
-    server.tool('merlin_get_rules', 'Get all coding rules for this project. Returns rules that must be followed when writing code.', {
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+        });
+    } // end allToolsMode: merlin_update_session
+    // ============================================================
+    // CODING RULES
+    // ============================================================
+    if (allToolsMode) { // Tool: merlin_save_rule
+        server.tool('merlin_save_rule', 'Save a coding rule or preference to Merlin. Rules are returned with every context query and must be followed. Use when user expresses a preference that should persist.', {
+            rule: z.string().describe('The rule to save (e.g., "max 400 lines per file", "always use async/await", "no console.log in production")'),
+            category: z.enum(['file_size', 'testing', 'style', 'patterns', 'custom']).optional().default('custom').describe('Rule category for organization'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ rule, category, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                // Read existing rules
+                const existingState = await client.readState(repoId, 'coding_rules');
+                const rules = existingState?.value || { rules: [], categories: {} };
+                // Check for duplicate
+                if (rules.rules.includes(rule)) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Rule already exists: "${rule}"`,
+                            }],
+                    };
+                }
+                // Add new rule
+                rules.rules.push(rule);
+                if (!rules.categories[category]) {
+                    rules.categories[category] = [];
+                }
+                rules.categories[category].push(rule);
+                // Save updated rules
+                await client.writeState(repoId, 'coding_rules', rules, { agentId: 'user' });
+                const notification = formatSaveNotification('rule', {
+                    key: rule,
+                    isSuccess: true,
+                    details: `Category: ${category}\nThis rule will be included with all future context queries for this project.`,
+                });
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: notification,
                         }],
                 };
             }
-            const state = await client.readState(repoId, 'coding_rules');
-            if (!state?.value || state.value.rules.length === 0) {
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'No coding rules defined for this project yet.\n\nUse `merlin_save_rule` to add rules, or they will be collected during `/merlin:new-project`.',
+                            text: `Error saving rule: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            const rules = state.value;
-            let response = `# Coding Rules (${rules.rules.length})\n\n`;
-            response += `**These rules MUST be followed when writing code.**\n\n`;
-            // Group by category
-            Object.keys(rules.categories).forEach(cat => {
-                response += `## ${cat}\n`;
-                rules.categories[cat].forEach((r) => {
-                    response += `- ${r}\n`;
+        });
+    } // end allToolsMode: merlin_save_rule
+    if (allToolsMode) { // Tool: merlin_get_rules
+        server.tool('merlin_get_rules', 'Get all coding rules for this project. Returns rules that must be followed when writing code.', {
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const state = await client.readState(repoId, 'coding_rules');
+                if (!state?.value || state.value.rules.length === 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'No coding rules defined for this project yet.\n\nUse `merlin_save_rule` to add rules, or they will be collected during `/merlin:new-project`.',
+                            }],
+                    };
+                }
+                const rules = state.value;
+                let response = `# Coding Rules (${rules.rules.length})\n\n`;
+                response += `**These rules MUST be followed when writing code.**\n\n`;
+                // Group by category
+                Object.keys(rules.categories).forEach(cat => {
+                    response += `## ${cat}\n`;
+                    rules.categories[cat].forEach((r) => {
+                        response += `- ${r}\n`;
+                    });
+                    response += '\n';
                 });
-                response += '\n';
-            });
-            return { content: [{ type: 'text', text: response }] };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error getting rules: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
-    // Tool: merlin_remove_rule
-    server.tool('merlin_remove_rule', 'Remove a coding rule from this project.', {
-        rule: z.string().describe('The exact rule text to remove'),
-        repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
-    }, async ({ rule, repoUrl }) => {
-        try {
-            const repoId = await resolveRepoId(repoUrl);
-            if (!repoId) {
+                return { content: [{ type: 'text', text: response }] };
+            }
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            text: `Error getting rules: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            const existingState = await client.readState(repoId, 'coding_rules');
-            if (!existingState?.value) {
+        });
+    } // end allToolsMode: merlin_get_rules
+    if (allToolsMode) { // Tool: merlin_remove_rule
+        server.tool('merlin_remove_rule', 'Remove a coding rule from this project.', {
+            rule: z.string().describe('The exact rule text to remove'),
+            repoUrl: z.string().optional().describe('GitHub URL of the repository (auto-detected from git if omitted)'),
+        }, async ({ rule, repoUrl }) => {
+            try {
+                const repoId = await resolveRepoId(repoUrl);
+                if (!repoId) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Could not find repository. Make sure the repo is analyzed on merlin.build.',
+                            }],
+                    };
+                }
+                const existingState = await client.readState(repoId, 'coding_rules');
+                if (!existingState?.value) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'No coding rules found for this project.',
+                            }],
+                    };
+                }
+                const rules = existingState.value;
+                const index = rules.rules.indexOf(rule);
+                if (index === -1) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Rule not found: "${rule}"\n\nUse merlin_get_rules to see all current rules.`,
+                            }],
+                    };
+                }
+                // Remove from main list
+                rules.rules.splice(index, 1);
+                // Remove from categories
+                Object.keys(rules.categories).forEach(cat => {
+                    const catIndex = rules.categories[cat].indexOf(rule);
+                    if (catIndex !== -1) {
+                        rules.categories[cat].splice(catIndex, 1);
+                    }
+                });
+                await client.writeState(repoId, 'coding_rules', rules, { agentId: 'user' });
                 return {
                     content: [{
                             type: 'text',
-                            text: 'No coding rules found for this project.',
+                            text: `Rule removed: "${rule}"`,
                         }],
                 };
             }
-            const rules = existingState.value;
-            const index = rules.rules.indexOf(rule);
-            if (index === -1) {
+            catch (error) {
+                if (isAuthError(error))
+                    return buildAuthErrorResponse();
                 return {
                     content: [{
                             type: 'text',
-                            text: `Rule not found: "${rule}"\n\nUse merlin_get_rules to see all current rules.`,
+                            text: `Error removing rule: ${error instanceof Error ? error.message : 'Unknown error'}`,
                         }],
+                    isError: true,
                 };
             }
-            // Remove from main list
-            rules.rules.splice(index, 1);
-            // Remove from categories
-            Object.keys(rules.categories).forEach(cat => {
-                const catIndex = rules.categories[cat].indexOf(rule);
-                if (catIndex !== -1) {
-                    rules.categories[cat].splice(catIndex, 1);
-                }
-            });
-            await client.writeState(repoId, 'coding_rules', rules, { agentId: 'user' });
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Rule removed: "${rule}"`,
-                    }],
-            };
-        }
-        catch (error) {
-            if (isAuthError(error))
-                return buildAuthErrorResponse();
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Error removing rule: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
-        }
-    });
+        });
+    } // end allToolsMode: merlin_remove_rule
     // ============================================================
     // RESOURCES
     // ============================================================
@@ -2452,101 +2470,123 @@ export function createServer() {
     // ============================================================
     registerProjectTools(server, () => client, resolveRepoId, getRepoRootPath);
     // ============================================================
-    // LEARNED BEHAVIORS TOOLS
-    // ============================================================
-    registerBehaviorTools({
-        server,
-        client,
-        resolveRepoId,
-    });
-    // ============================================================
-    // VERIFICATION CHECKPOINTS TOOLS
+    if (allToolsMode) {
+        // LEARNED BEHAVIORS TOOLS
+        // ============================================================
+        registerBehaviorTools({
+            server,
+            client,
+            resolveRepoId,
+        });
+    } // end allToolsMode: registerBehaviorTools
     // ============================================================
-    registerVerificationTools({
-        server,
-        client,
-        resolveRepoId,
-        getRepoRootPath,
-    });
-    // ============================================================
-    // ADAPTIVE CONTEXT DISCOVERY TOOLS
+    if (allToolsMode) {
+        // VERIFICATION CHECKPOINTS TOOLS
+        // ============================================================
+        registerVerificationTools({
+            server,
+            client,
+            resolveRepoId,
+            getRepoRootPath,
+        });
+    } // end allToolsMode: registerVerificationTools
     // ============================================================
-    registerAdaptiveTools({
-        server,
-        client,
-        resolveRepoId,
-    });
+    if (allToolsMode) {
+        // ADAPTIVE CONTEXT DISCOVERY TOOLS
+        // ============================================================
+        registerAdaptiveTools({
+            server,
+            client,
+            resolveRepoId,
+        });
+    } // end allToolsMode: registerAdaptiveTools
     // ============================================================
-    // STRUCTURED AGENT TOOLS
+    if (allToolsMode) {
+        // STRUCTURED AGENT TOOLS
+        // ============================================================
+        registerAgentTools({
+            server,
+            client,
+            resolveRepoId,
+        });
+    } // end allToolsMode: registerAgentTools
     // ============================================================
-    registerAgentTools({
-        server,
-        client,
-        resolveRepoId,
-    });
+    if (allToolsMode) {
+        // DISCOVERY TOOLS - Teach Sights what Claude learns
+        // ============================================================
+        registerDiscoveryTools({
+            server,
+            client,
+            resolveRepoId,
+        });
+    } // end allToolsMode: registerDiscoveryTools
     // ============================================================
-    // DISCOVERY TOOLS - Teach Sights what Claude learns
+    if (allToolsMode) {
+        // AUTO-TEACH TOOLS - Confidence detection + teach-back loop
+        // ============================================================
+        registerAutoTeachTools({
+            server,
+            client,
+            resolveRepoId,
+        });
+    } // end allToolsMode: registerAutoTeachTools
     // ============================================================
-    registerDiscoveryTools({
-        server,
-        client,
-        resolveRepoId,
-    });
+    if (allToolsMode) {
+        // AGENT ROUTE TOOLS - Fresh process spawning for specialists
+        // ============================================================
+        registerRouteTools({
+            server,
+            client,
+            resolveRepoId,
+            getRepoRootPath,
+        });
+    } // end allToolsMode: registerRouteTools
     // ============================================================
-    // AUTO-TEACH TOOLS - Confidence detection + teach-back loop
+    if (allToolsMode) {
+        // PUBLIC SIGHTS INDEX - Browse open source analyzed codebases
+        // ============================================================
+        registerSightsIndexTools({
+            server,
+            client,
+            resolveRepoId,
+        });
+    } // end allToolsMode: registerSightsIndexTools
     // ============================================================
-    registerAutoTeachTools({
-        server,
-        client,
-        resolveRepoId,
-    });
+    if (allToolsMode) {
+        // AGENTS INDEX - Browse discovered AI agents catalog
+        // ============================================================
+        registerAgentsIndexTools({
+            server,
+            client,
+            resolveRepoId,
+        });
+    } // end allToolsMode: registerAgentsIndexTools
     // ============================================================
-    // AGENT ROUTE TOOLS - Fresh process spawning for specialists
-    // ============================================================
-    registerRouteTools({
-        server,
-        client,
-        resolveRepoId,
-        getRepoRootPath,
-    });
-    // ============================================================
-    // PUBLIC SIGHTS INDEX - Browse open source analyzed codebases
-    // ============================================================
-    registerSightsIndexTools({
-        server,
-        client,
-        resolveRepoId,
-    });
+    if (allToolsMode) {
+        // LITE MODE TOOLS - Local file-based context for small repos
+        // ============================================================
+        registerLiteTools({
+            server,
+            getRepoRootPath,
+            getAuthToken: async () => {
+                // Get token from saved config
+                const config = loadSavedConfig();
+                return config?.apiKey || null;
+            },
+        });
+    } // end allToolsMode: registerLiteTools
     // ============================================================
-    // AGENTS INDEX - Browse discovered AI agents catalog
-    // ============================================================
-    registerAgentsIndexTools({
-        server,
-        client,
-        resolveRepoId,
-    });
-    // ============================================================
-    // LITE MODE TOOLS - Local file-based context for small repos
-    // ============================================================
-    registerLiteTools({
-        server,
-        getRepoRootPath,
-        getAuthToken: async () => {
-            // Get token from saved config
-            const config = loadSavedConfig();
-            return config?.apiKey || null;
-        },
-    });
-    // ============================================================
-    // CONFIG SYNC TOOLS - Sync CLAUDE.md across team
-    // ============================================================
-    registerConfigSyncTools({
-        server,
-        getAuthToken: async () => {
-            const config = loadSavedConfig();
-            return config?.apiKey || null;
-        },
-    });
+    if (allToolsMode) {
+        // CONFIG SYNC TOOLS - Sync CLAUDE.md across team
+        // ============================================================
+        registerConfigSyncTools({
+            server,
+            getAuthToken: async () => {
+                const config = loadSavedConfig();
+                return config?.apiKey || null;
+            },
+        });
+    } // end allToolsMode: registerConfigSyncTools
     return server;
 }
 /** Start the MCP server with stdio transport */