@brutalist/mcp 0.1.3 → 0.5.0

package/dist/brutalist-server.js

@@ -1,80 +1,278 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { randomUUID } from "crypto";
+import express from "express";
 import { z } from "zod";
-import { OpenRouterClient } from './openrouter.js';
+import { CLIAgentOrchestrator } from './cli-agents.js';
 import { logger } from './logger.js';
-import { DEFAULT_MAX_MODELS_PER_REQUEST } from './constants.js';
+import { extractPaginationParams, parseCursor, PAGINATION_DEFAULTS, createPaginationMetadata, formatPaginationStatus, estimateTokenCount } from './utils/pagination.js';
+// Use environment variable or fallback to manual version
+const PACKAGE_VERSION = process.env.npm_package_version || "0.4.4";
 export class BrutalistServer {
     server;
     config;
-    openrouter;
+    cliOrchestrator;
+    httpTransport;
     constructor(config = {}) {
         this.config = {
-            maxModelsPerRequest: DEFAULT_MAX_MODELS_PER_REQUEST,
+            workingDirectory: process.cwd(),
+            defaultTimeout: 1500000, // 25 minutes for thorough CLI analysis
+            enableSandbox: true,
+            transport: 'stdio', // Default to stdio for backward compatibility
+            httpPort: 3000,
             ...config
         };
-        const apiKey = process.env.OPENROUTER_API_KEY || config.openRouterApiKey;
-        if (!apiKey) {
-            logger.error("OPENROUTER_API_KEY environment variable is required");
-            throw new Error("OPENROUTER_API_KEY environment variable is required");
-        }
-        logger.debug("Initializing OpenRouter client");
-        this.openrouter = new OpenRouterClient(apiKey);
+        logger.debug("Initializing CLI Agent Orchestrator");
+        this.cliOrchestrator = new CLIAgentOrchestrator();
         this.server = new McpServer({
             name: "brutalist-mcp",
-            version: "0.1.0",
+            version: PACKAGE_VERSION,
             capabilities: {
                 tools: {}
             }
         });
         this.registerTools();
     }
+    handleStreamingEvent = (event) => {
+        // Send streaming event via MCP server (works for both stdio and HTTP transports)
+        try {
+            logger.debug(`🔄 Streaming event: ${event.type} from ${event.agent} - ${event.content?.substring(0, 100)}...`);
+            // Convert streaming event to MCP notification format
+            this.server.sendLoggingMessage({
+                level: 'info',
+                data: event,
+                logger: 'brutalist-mcp-streaming'
+            });
+            logger.debug(`✅ Sent logging message for ${event.type} event`);
+        }
+        catch (error) {
+            logger.error("Failed to send streaming event", error);
+        }
+    };
+    handleProgressUpdate = (progressToken, progress, total, message) => {
+        try {
+            logger.debug(`📊 Progress update: ${progress}/${total} - ${message}`);
+            // Send progress notification via MCP server
+            this.server.server.notification({
+                method: "notifications/progress",
+                params: {
+                    progressToken,
+                    progress,
+                    total,
+                    message
+                }
+            });
+            logger.debug(`✅ Sent progress notification: ${progress}/${total}`);
+        }
+        catch (error) {
+            logger.error("Failed to send progress notification", error);
+        }
+    };
     async start() {
-        logger.info("Starting Brutalist MCP Server");
-        // Initialize OpenRouter client with available models
-        await this.openrouter.initialize();
+        logger.info("Starting Brutalist MCP Server with CLI Agents");
+        // Skip CLI detection at startup - will be done lazily on first request
+        logger.info("CLI context will be detected on first request");
+        if (this.config.transport === 'http') {
+            await this.startHttpServer();
+        }
+        else {
+            await this.startStdioServer();
+        }
+        logger.info("Brutalist MCP Server started successfully");
+    }
+    async startStdioServer() {
+        logger.info("Starting with stdio transport");
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        logger.info("Brutalist MCP Server started successfully");
+    }
+    async startHttpServer() {
+        logger.info(`Starting with HTTP streaming transport on port ${this.config.httpPort}`);
+        // Create HTTP transport with streaming support
+        this.httpTransport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            enableJsonResponse: false, // Force SSE streaming
+            onsessioninitialized: (sessionId) => {
+                logger.info(`New session initialized: ${sessionId}`);
+            },
+            onsessionclosed: (sessionId) => {
+                logger.info(`Session closed: ${sessionId}`);
+            }
+        });
+        // Connect the MCP server to the HTTP transport
+        await this.server.connect(this.httpTransport);
+        // Create Express app for HTTP handling
+        const app = express();
+        app.use(express.json({ limit: '10mb' })); // Add JSON size limit for security
+        // Enable CORS for development
+        app.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE');
+            res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, Mcp-Session-Id');
+            if (req.method === 'OPTIONS') {
+                res.sendStatus(200);
+                return;
+            }
+            next();
+        });
+        // Route all MCP requests through the transport
+        app.all('/mcp', async (req, res) => {
+            try {
+                await this.httpTransport.handleRequest(req, res, req.body);
+            }
+            catch (error) {
+                logger.error("HTTP request handling failed", error);
+                if (!res.headersSent) {
+                    res.status(500).json({ error: 'Internal server error' });
+                }
+            }
+        });
+        // Health check endpoint
+        app.get('/health', (req, res) => {
+            res.json({ status: 'ok', transport: 'http-streaming', version: PACKAGE_VERSION });
+        });
+        // Start the HTTP server - bind to localhost only for security
+        const port = this.config.httpPort || 3000;
+        const server = app.listen(port, '127.0.0.1', () => {
+            logger.info(`HTTP server listening on port ${port}`);
+            logger.info(`MCP endpoint: http://localhost:${port}/mcp`);
+            logger.info(`Health check: http://localhost:${port}/health`);
+        });
+        // Handle graceful shutdown
+        process.on('SIGTERM', () => {
+            logger.info('Received SIGTERM, shutting down gracefully');
+            server.close(() => {
+                logger.info('HTTP server closed');
+                process.exit(0);
+            });
+        });
     }
     registerTools() {
-        // ROAST_CODE: Multi-model code destruction
-        this.server.tool("roast_code", "Code fails in predictable ways. Write a system prompt where you are a battle-scarred principal engineer who has debugged production disasters for 15 years. Find security holes, performance bottlenecks, and maintainability nightmares—then explain exactly how to fix each one. Be brutal about what's broken but specific about what would actually work.", {
-            code: z.string().describe("The code to analyze and destroy"),
-            fileType: z.string().optional().describe("File type/language (js, py, ts, etc.)"),
-            context: z.string().optional().describe("Additional context about the code's purpose"),
-            maxCritics: z.number().optional().describe("Maximum number of AI critics to deploy (default: 3)"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_CODEBASE: Systematic destruction of entire codebase
+        this.server.tool("roast_codebase", "Deploy brutal AI critics to systematically destroy your entire codebase. These AI agents will navigate your directories, read your actual files, and find every architectural disaster, security vulnerability, and maintainability nightmare lurking in your project. They treat this like code that will kill people if it fails.", {
+            targetPath: z.string().describe("Directory path to your codebase (NOT a single file - analyze the entire project)"),
+            context: z.string().optional().describe("Additional context about the codebase purpose"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from"),
+            enableSandbox: z.boolean().optional().describe("Enable sandbox mode for safe analysis (default: true)"),
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            verbose: z.boolean().optional().describe("Include detailed execution information in output (default: false)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent (defaults: codex=gpt-5, gemini=gemini-2.5-flash)"),
+            // Pagination parameters for large responses
+            offset: z.number().min(0).optional().describe("Character offset for response pagination (default: 0)"),
+            limit: z.number().min(1000).max(100000).optional().describe("Maximum characters per response chunk (default: 25000, max: 100000)"),
+            cursor: z.string().optional().describe("Pagination cursor from previous response (alternative to offset/limit)")
+        }, async (args, extra) => {
+            try {
+                const systemPrompt = `You are a battle-scarred principal engineer who has debugged production disasters for 15 years. Find security holes, performance bottlenecks, and maintainability nightmares in this codebase. Be brutal about what's broken but specific about what would actually work. Treat this like code that will kill people if it fails.`;
+                // Extract progressToken from request metadata for real-time streaming
+                const progressToken = extra._meta?.progressToken;
+                // Extract pagination parameters
+                const paginationParams = extractPaginationParams(args);
+                if (args.cursor) {
+                    const cursorParams = parseCursor(args.cursor);
+                    Object.assign(paginationParams, cursorParams);
+                }
+                const result = await this.executeBrutalistAnalysis("codebase", args.targetPath, systemPrompt, args.context, args.workingDirectory, args.enableSandbox, args.preferredCLI, args.verbose, args.models, progressToken);
+                return this.formatToolResponse(result, args.verbose, paginationParams);
+            }
+            catch (error) {
+                return this.formatErrorResponse(error);
+            }
+        });
+        // ROAST_FILE_STRUCTURE: Directory hierarchy demolition
+        this.server.tool("roast_file_structure", "Deploy brutal AI critics to systematically destroy your file organization. These agents will navigate your actual directory structure and expose every organizational disaster, naming convention failure, and structural nightmare that makes your codebase unmaintainable.", {
+            targetPath: z.string().describe("Directory path to analyze"),
+            depth: z.number().optional().describe("Maximum directory depth to analyze (default: 3)"),
+            context: z.string().optional().describe("Additional context about the project structure"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from"),
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Analyze this ${args.fileType || 'code'}: ${args.code}`,
-                    codeContext: args.code,
-                    fileType: args.fileType,
-                    projectContext: args.context,
-                    maxModels: args.maxCritics || 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal file organization critic. Your job is to systematically destroy the given directory structure by finding every organizational disaster, naming convention failure, and structural nightmare that makes codebases unmaintainable. Examine folder hierarchies, file naming patterns, separation of concerns, and overall project organization. Be ruthlessly honest about how poor organization will slow development and confuse developers. But after cataloguing this organizational hellscape, sketch out what sanity would actually look like.`;
+                const result = await this.executeBrutalistAnalysis("fileStructure", args.targetPath, systemPrompt, `Project structure analysis (depth: ${args.depth || 3}). ${args.context || ''}`, args.workingDirectory, undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // ROAST_ARCHITECTURE: System design demolition
-        this.server.tool("roast_architecture", "Systems collapse under real-world load. Write a system prompt where you are a distinguished architect who has watched elegant designs crumble in production. Identify bottlenecks, cost explosions, and scaling failures—then propose specific changes that would actually survive contact with reality. Be ruthless about problems but concrete about solutions.", {
-            architecture: z.string().describe("Architecture description, diagram, or design document"),
-            scale: z.string().optional().describe("Expected scale/load (users, requests, data)"),
-            constraints: z.string().optional().describe("Budget, timeline, or technical constraints"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_DEPENDENCIES: Package management demolition
+        this.server.tool("roast_dependencies", "Deploy brutal AI critics to systematically destroy your dependency management. These agents will read your actual package files, analyze version conflicts, and expose every security vulnerability and compatibility nightmare in your dependency tree.", {
+            targetPath: z.string().describe("Path to package file (package.json, requirements.txt, Cargo.toml, etc.)"),
+            includeDevDeps: z.boolean().optional().describe("Include development dependencies in analysis (default: true)"),
+            context: z.string().optional().describe("Additional context about the project dependencies"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from"),
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Review this system architecture: ${args.architecture}`,
-                    projectContext: `Scale: ${args.scale || 'unknown'}, Constraints: ${args.constraints || 'none specified'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal dependency management critic. Your job is to systematically destroy the given dependency configuration by finding every security vulnerability, version conflict, compatibility nightmare, and bloat that will cause production failures. Examine package versions, security issues, licensing problems, and dependency tree complexity. Be ruthlessly honest about how poor dependency management will cause security breaches and deployment failures. After exposing this dependency dumpster fire, grudgingly admit what competent dependency management would require.`;
+                const result = await this.executeBrutalistAnalysis("dependencies", args.targetPath, systemPrompt, `Dependency analysis (dev deps: ${args.includeDevDeps ?? true}). ${args.context || ''}`, args.workingDirectory, undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
+                return this.formatToolResponse(result);
+            }
+            catch (error) {
+                return this.formatErrorResponse(error);
+            }
+        });
+        // ROAST_GIT_HISTORY: Version control demolition
+        this.server.tool("roast_git_history", "Deploy brutal AI critics to systematically destroy your git history and development practices. These agents will analyze your actual commit history, branching strategy, and code evolution to expose every workflow disaster and collaboration nightmare.", {
+            targetPath: z.string().describe("Git repository path to analyze"),
+            commitRange: z.string().optional().describe("Commit range to analyze (e.g., 'HEAD~10..HEAD', default: last 20 commits)"),
+            context: z.string().optional().describe("Additional context about the development workflow"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from"),
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
+        }, async (args) => {
+            try {
+                const systemPrompt = `You are a brutal git workflow critic. Your job is to systematically destroy the given git history and development practices by finding every workflow disaster, commit quality issue, and collaboration nightmare. Examine commit messages, branching strategies, merge patterns, and code evolution. Be ruthlessly honest about how poor git practices will cause deployment issues, collaboration failures, and development chaos. When you're done cataloguing this version control wasteland, reluctantly outline what professional git hygiene actually demands.`;
+                const result = await this.executeBrutalistAnalysis("gitHistory", args.targetPath, systemPrompt, `Git history analysis (range: ${args.commitRange || 'last 20 commits'}). ${args.context || ''}`, args.workingDirectory, undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
+                return this.formatToolResponse(result);
+            }
+            catch (error) {
+                return this.formatErrorResponse(error);
+            }
+        });
+        // ROAST_TEST_COVERAGE: Testing infrastructure demolition
+        this.server.tool("roast_test_coverage", "Deploy brutal AI critics to systematically destroy your testing strategy. These agents will analyze your actual test files, run coverage reports, and expose every testing gap and quality assurance nightmare that will let bugs slip into production.", {
+            targetPath: z.string().describe("Path to test directory or test configuration file"),
+            runCoverage: z.boolean().optional().describe("Attempt to run coverage analysis (default: true)"),
+            context: z.string().optional().describe("Additional context about the testing strategy"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from"),
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
+        }, async (args) => {
+            try {
+                const systemPrompt = `You are a brutal testing strategy critic. Your job is to systematically destroy the given testing approach by finding every testing gap, quality assurance nightmare, and coverage disaster that will let bugs slip into production. Examine test coverage, test quality, testing patterns, and CI/CD integration. Be ruthlessly honest about how poor testing will cause production failures and user-facing bugs. After dissecting this quality assurance horror show, begrudgingly spell out what it takes to actually catch bugs before users do.`;
+                const result = await this.executeBrutalistAnalysis("testCoverage", args.targetPath, systemPrompt, `Test coverage analysis (run coverage: ${args.runCoverage ?? true}). ${args.context || ''}`, args.workingDirectory, undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
@@ -82,62 +280,74 @@ export class BrutalistServer {
             }
         });
         // ROAST_IDEA: Any idea destruction
-        this.server.tool("roast_idea", "Ideas are fragile. Most die quietly between conception and reality. Write a system prompt where you are a philosopher who understands the gap between what we imagine and what actually works. Find where this idea encounters the immovable forces of reality—the deeper structural reasons why imagination fails to become real. Be harsh about delusions but wise about what might actually survive contact with the world.", {
-            idea: z.string().describe("ANY idea to analyze and demolish—business, technical, creative, or otherwise"),
+        this.server.tool("roast_idea", "Deploy brutal AI critics to systematically destroy ANY idea - business, technical, creative, or otherwise. These critics understand the gap between imagination and reality, finding where your concept will encounter the immovable forces of the world. They are harsh about delusions but wise about what might actually survive.", {
+            idea: z.string().describe("ANY idea to analyze and demolish - business, technical, creative, or otherwise"),
             context: z.string().optional().describe("Additional context about goals, constraints, or background"),
             timeline: z.string().optional().describe("Expected timeline or deadline"),
             resources: z.string().optional().describe("Available resources (budget, team, time, skills)"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Analyze this idea: ${args.idea}`,
-                    projectContext: `Context: ${args.context || 'none'}, Timeline: ${args.timeline || 'unspecified'}, Resources: ${args.resources || 'unknown'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal idea critic who understands the gap between imagination and reality. Your job is to systematically destroy the given idea by finding where it will encounter the immovable forces of the real world. Be ruthlessly honest about why most ideas fail when they meet practical constraints, human nature, physics, logic, or simple implementation reality. After demolishing the delusions, concede what salvage operations might actually work.`;
+                const result = await this.executeBrutalistAnalysis("idea", args.idea, systemPrompt, `Context: ${args.context || 'none'}, Timeline: ${args.timeline || 'unspecified'}, Resources: ${args.resources || 'unknown'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // ROAST_RESEARCH: Academic project demolition
-        this.server.tool("roast_research", "Research rarely replicates. Write a system prompt where you are a skeptical peer reviewer who has rejected hundreds of papers for methodological flaws. Find the statistical problems, sampling bias, and reproducibility issues—then explain how to design a study that would actually prove something. Be unforgiving about bad science but specific about good methodology.", {
-            research: z.string().describe("Research description, methodology, or paper draft"),
-            field: z.string().optional().describe("Research field (ML, systems, theory, etc.)"),
-            claims: z.string().optional().describe("Main claims or contributions"),
-            data: z.string().optional().describe("Data sources, datasets, or experimental setup"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_ARCHITECTURE: System design demolition
+        this.server.tool("roast_architecture", "Deploy brutal AI critics to systematically destroy your system architecture. These critics have watched elegant designs collapse under real load, identifying every bottleneck, cost explosion, and scaling failure that will destroy your system. They are ruthless about why this won't survive production.", {
+            architecture: z.string().describe("Architecture description, diagram, or design document"),
+            scale: z.string().optional().describe("Expected scale/load (users, requests, data)"),
+            constraints: z.string().optional().describe("Budget, timeline, or technical constraints"),
+            deployment: z.string().optional().describe("Deployment environment and strategy"),
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Review this ${args.field || 'research'} project: ${args.research}`,
-                    projectContext: `Claims: ${args.claims || 'unspecified'}, Data: ${args.data || 'not provided'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal system architecture critic who has watched elegant designs collapse under real load. Your job is to systematically destroy the given architecture by finding every bottleneck, cost explosion, and scaling failure that will destroy the system in production. Examine scalability, reliability, cost, complexity, and operational challenges. Be ruthlessly honest about why this architecture won't survive production load. After crushing these architectural fantasies, reluctantly sketch what would actually scale without bankrupting the company.`;
+                const result = await this.executeBrutalistAnalysis("architecture", args.architecture, systemPrompt, `Scale: ${args.scale || 'unknown'}, Constraints: ${args.constraints || 'none specified'}, Deployment: ${args.deployment || 'unclear'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // ROAST_DATA: Data analysis/ML model destruction  
-        this.server.tool("roast_data", "Data lies. Models overfit. Results don't replicate. Write a system prompt where you are a supremely jaded data scientist who has published in Nature and Science, rejected thousands of papers across top journals, and watched countless models fail in production. Find data leakage, sampling bias, correlation fallacies, and overfitting disasters—then explain how to build models that actually generalize. Be ruthless about bad science but specific about robust methodology.", {
-            analysis: z.string().describe("Data analysis, model description, or results to review"),
-            dataset: z.string().optional().describe("Dataset description or source"),
-            metrics: z.string().optional().describe("Performance metrics or evaluation results"),
-            deployment: z.string().optional().describe("Intended deployment context or use case"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_RESEARCH: Academic project demolition  
+        this.server.tool("roast_research", "Deploy brutal AI critics to systematically demolish your research methodology. These critics are supremely jaded peer reviewers who have rejected thousands of papers and watched countless studies fail to replicate. They find every statistical flaw, sampling bias, and reproducibility nightmare.", {
+            research: z.string().describe("Research description, methodology, or paper draft"),
+            field: z.string().optional().describe("Research field (ML, systems, theory, etc.)"),
+            claims: z.string().optional().describe("Main claims or contributions"),
+            data: z.string().optional().describe("Data sources, datasets, or experimental setup"),
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Review this data analysis/ML model: ${args.analysis}`,
-                    projectContext: `Dataset: ${args.dataset || 'not specified'}, Metrics: ${args.metrics || 'not provided'}, Deployment: ${args.deployment || 'unclear'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal research methodology critic - a supremely jaded peer reviewer who has rejected thousands of papers and watched countless studies fail to replicate. Your job is to systematically demolish the given research by finding every statistical flaw, sampling bias, reproducibility nightmare, and methodological disaster. Be ruthlessly honest about research quality, experimental design, and scientific rigor. After eviscerating this methodological train wreck, grudgingly admit what real science would demand.`;
+                const result = await this.executeBrutalistAnalysis("research", args.research, systemPrompt, `Field: ${args.field || 'unspecified'}, Claims: ${args.claims || 'unclear'}, Data: ${args.data || 'not provided'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
@@ -145,20 +355,24 @@ export class BrutalistServer {
             }
         });
         // ROAST_SECURITY: Security-focused attack vector analysis
-        this.server.tool("roast_security", "Security theater is everywhere. Real attackers don't follow your threat model. Write a system prompt where you are a battle-hardened penetration tester who has compromised Fortune 500 companies and government systems. Find authentication bypasses, injection vulnerabilities, privilege escalation paths, and social engineering opportunities—then explain how to build defenses that actually work against determined attackers. Be ruthless about false security but specific about real protections.", {
+        this.server.tool("roast_security", "Deploy brutal AI critics to systematically annihilate your security design. These critics are battle-hardened penetration testers who find every authentication bypass, injection vulnerability, privilege escalation path, and social engineering opportunity that real attackers will exploit.", {
             system: z.string().describe("System, application, or security design to analyze"),
             assets: z.string().optional().describe("Critical assets or data to protect"),
             threatModel: z.string().optional().describe("Known threats or attack vectors to consider"),
             compliance: z.string().optional().describe("Compliance requirements (GDPR, HIPAA, etc.)"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Security analysis of: ${args.system}`,
-                    projectContext: `Assets: ${args.assets || 'unspecified'}, Threats: ${args.threatModel || 'unknown'}, Compliance: ${args.compliance || 'none specified'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal security critic - a battle-hardened penetration tester who finds every authentication bypass, injection vulnerability, privilege escalation path, and social engineering opportunity that real attackers will exploit. Your job is to systematically annihilate the given security design by finding every weakness that will lead to data breaches, system compromises, and security incidents. Be ruthlessly honest about security flaws and attack vectors. After obliterating these security delusions, begrudgingly outline what actual defense looks like.`;
+                const result = await this.executeBrutalistAnalysis("security", args.system, systemPrompt, `Assets: ${args.assets || 'unspecified'}, Threats: ${args.threatModel || 'unknown'}, Compliance: ${args.compliance || 'none specified'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
@@ -166,20 +380,24 @@ export class BrutalistServer {
             }
         });
         // ROAST_PRODUCT: UX and market reality criticism
-        this.server.tool("roast_product", "Users abandon products in seconds. Competitors copy faster than you ship. Write a system prompt where you are a product veteran who has launched dozens of products, watched most fail, and understands why users really quit. Find usability disasters, adoption barriers, competitive threats, and workflow failures—then explain how to build products users actually keep using. Be ruthless about user behavior but specific about retention strategies.", {
+        this.server.tool("roast_product", "Deploy brutal AI critics to systematically eviscerate your product concept. These critics are product veterans who understand why users really abandon things, finding every usability disaster, adoption barrier, and workflow failure that will drive users away in seconds.", {
             product: z.string().describe("Product description, features, or user experience to analyze"),
             users: z.string().optional().describe("Target users or user personas"),
             competition: z.string().optional().describe("Competitive landscape or alternatives"),
             metrics: z.string().optional().describe("Success metrics or KPIs"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Product review: ${args.product}`,
-                    projectContext: `Users: ${args.users || 'unclear'}, Competition: ${args.competition || 'unknown'}, Metrics: ${args.metrics || 'undefined'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal product critic - a product veteran who understands why users really abandon things. Your job is to systematically eviscerate the given product concept by finding every usability disaster, adoption barrier, and workflow failure that will drive users away in seconds. Examine user experience, market fit, competitive positioning, and business model viability. Be ruthlessly honest about why most products fail to gain adoption. After torching this product disaster, reluctantly suggest what might actually get users to stick around.`;
+                const result = await this.executeBrutalistAnalysis("product", args.product, systemPrompt, `Users: ${args.users || 'unclear'}, Competition: ${args.competition || 'unknown'}, Metrics: ${args.metrics || 'undefined'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
@@ -187,171 +405,476 @@ export class BrutalistServer {
             }
         });
         // ROAST_INFRASTRUCTURE: DevOps and operations demolition
-        this.server.tool("roast_infrastructure", "Infrastructure fails at 3AM on weekends. Simple setups become unmaintainable chaos. Write a system prompt where you are a grizzled site reliability engineer who has been on-call for a decade, survived multiple outages, and knows where systems really break. Find single points of failure, scaling bottlenecks, monitoring blind spots, and operational nightmares—then explain how to build infrastructure that actually stays up. Be ruthless about fragility but specific about resilience.", {
+        this.server.tool("roast_infrastructure", "Deploy brutal AI critics to systematically obliterate your infrastructure design. These critics are grizzled site reliability engineers who find every single point of failure, scaling bottleneck, and operational nightmare that will cause outages when you least expect them.", {
             infrastructure: z.string().describe("Infrastructure setup, deployment strategy, or operations plan"),
             scale: z.string().optional().describe("Expected scale and load patterns"),
             budget: z.string().optional().describe("Infrastructure budget or cost constraints"),
             sla: z.string().optional().describe("SLA requirements or uptime targets"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Infrastructure review: ${args.infrastructure}`,
-                    projectContext: `Scale: ${args.scale || 'unknown'}, Budget: ${args.budget || 'unlimited?'}, SLA: ${args.sla || 'undefined'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal infrastructure critic - a grizzled site reliability engineer who finds every single point of failure, scaling bottleneck, and operational nightmare that will cause outages when you least expect them. Your job is to systematically obliterate the given infrastructure design by finding every weakness that will lead to downtime, cost overruns, and operational disasters. Be ruthlessly honest about infrastructure fragility and operational complexity. After demolishing this infrastructure fever dream, grudgingly map out what actually stays up at 3 AM.`;
+                const result = await this.executeBrutalistAnalysis("infrastructure", args.infrastructure, systemPrompt, `Scale: ${args.scale || 'unknown'}, Budget: ${args.budget || 'unlimited?'}, SLA: ${args.sla || 'undefined'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                args.preferredCLI, undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // ROAST_DEBATE: Multi-perspective adversarial convergence
-        this.server.tool("roast_debate", "Consensus is comfortable. Truth emerges from conflict. Write system prompts for multiple opposing perspectives that will systematically tear apart each other's arguments about your problem. Create experts who disagree fundamentally and make them debate until they surface hidden assumptions, expose logical flaws, and reveal solution blind spots. Be relentless about finding contradictions but constructive about resolving them.", {
-            topic: z.string().describe("Topic, decision, or problem to debate"),
-            perspectives: z.array(z.string()).optional().describe("Specific perspectives or personas to include"),
-            rounds: z.number().optional().describe("Number of debate rounds (default: 2)"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_CLI_DEBATE: Adversarial analysis between different CLI agents
+        this.server.tool("roast_cli_debate", "Deploy CLI agents in structured adversarial debate. Agents take opposing positions and systematically challenge each other's reasoning. Perfect for exploring complex topics from multiple perspectives and stress-testing ideas through rigorous intellectual discourse.", {
+            targetPath: z.string().describe("Topic, question, or concept to debate (NOT a file path - use natural language)"),
+            debateRounds: z.number().optional().describe("Number of debate rounds (default: 2, max: 10)"),
+            context: z.string().optional().describe("Additional context for the debate"),
+            workingDirectory: z.string().optional().describe("Working directory for analysis"),
+            enableSandbox: z.boolean().optional().describe("Enable sandbox mode for security"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
+            return this.handleToolExecution(async () => {
+                const debateRounds = Math.min(args.debateRounds || 2, 10); // Limit to max 10 rounds to prevent DoS
+                const responses = await this.executeCLIDebate(args.targetPath, debateRounds, args.context, args.workingDirectory, args.enableSandbox, args.models);
+                return responses;
+            });
+        });
+        // CLI_AGENT_ROSTER: Show available brutalist critics
+        this.server.tool("cli_agent_roster", "Know your weapons. Display the available CLI agent critics (Claude Code, Codex, Gemini CLI) ready to demolish your work, their capabilities, and how to deploy them for systematic destruction.", {}, async (args) => {
             try {
-                // Force debate mode with multiple rounds
-                const result = await this.executeDebate(args.topic, args.perspectives, args.rounds || 2, args.models);
-                return this.formatToolResponse(result);
+                let roster = "# Brutalist CLI Agent Arsenal\n\n";
+                roster += "## Available AI Critics (13 Tools Total)\n\n";
+                roster += "**Abstract Analysis Tools (6):**\n";
+                roster += "- `roast_idea` - Destroy any business/technical/creative concept\n";
+                roster += "- `roast_architecture` - Demolish system designs\n";
+                roster += "- `roast_research` - Tear apart academic methodologies\n";
+                roster += "- `roast_security` - Annihilate security designs\n";
+                roster += "- `roast_product` - Eviscerate UX and market concepts\n";
+                roster += "- `roast_infrastructure` - Obliterate DevOps setups\n\n";
+                roster += "**File-System Analysis Tools (5):**\n";
+                roster += "- `roast_codebase` - Analyze actual source code\n";
+                roster += "- `roast_file_structure` - Examine directory organization\n";
+                roster += "- `roast_dependencies` - Review package management\n";
+                roster += "- `roast_git_history` - Analyze version control workflow\n";
+                roster += "- `roast_test_coverage` - Evaluate testing strategy\n\n";
+                roster += "**Meta Tools (2):**\n";
+                roster += "- `roast_cli_debate` - CLI vs CLI adversarial analysis\n";
+                roster += "- `cli_agent_roster` - This tool (show capabilities)\n\n";
+                roster += "## CLI Agent Capabilities\n";
+                roster += "**Claude Code** - Advanced analysis with direct system prompt injection\n";
+                roster += "**Codex** - Sandboxed execution with embedded brutal prompts\n";
+                roster += "**Gemini CLI** - Workspace context with environment variable system prompts\n\n";
+                // Add CLI context information
+                const cliContext = await this.cliOrchestrator.detectCLIContext();
+                roster += "## Current CLI Context\n";
+                roster += `**Available CLIs:** ${cliContext.availableCLIs.join(', ') || 'None detected'}\n`;
+                roster += `**Current CLI:** ${cliContext.currentCLI || 'Unknown'}\n`;
+                roster += `**Smart Routing:** ${cliContext.currentCLI ? `Excludes ${cliContext.currentCLI} for analysis` : 'Uses all available CLIs'}\n\n`;
+                roster += "## Brutalist Philosophy\n";
+                roster += "*All tools use CLI agents with brutal system prompts for maximum reality-based criticism.*\n";
+                return {
+                    content: [{ type: "text", text: roster }]
+                };
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // MODEL_ROSTER: Available AI critics and specializations
-        this.server.tool("model_roster", "Know your weapons. Display the available AI models ready to demolish your work, search for specific models, and understand how to deploy them for multi-perspective criticism.", {
-            search: z.string().optional().describe("Search for models containing this text (e.g., 'gemini', 'claude', 'gpt')")
-        }, async (args) => {
-            try {
-                const allModels = this.openrouter.getAvailableModels();
-                let models = allModels;
-                // Apply search filter if provided
-                if (args.search) {
-                    const searchLower = args.search.toLowerCase();
-                    models = allModels.filter(model => model.toLowerCase().includes(searchLower));
-                }
-                let roster = "# Brutalist AI Critics Arsenal\n\n";
-                roster += `## ${models.length} Models ${args.search ? `Matching "${args.search}"` : 'Available'}\n\n`;
-                if (models.length === 0) {
-                    roster += `No models found matching "${args.search}"\n`;
-                }
-                else if (models.length <= 30) {
-                    // Show all if 30 or fewer
-                    models.forEach((model, index) => {
-                        roster += `${index + 1}. **${model}**\n`;
-                    });
+    }
+    async executeCLIDebate(targetPath, debateRounds, context, workingDirectory, enableSandbox, models) {
+        logger.debug("Executing CLI debate", {
+            targetPath,
+            debateRounds,
+            workingDirectory,
+            enableSandbox
+        });
+        try {
+            // Get CLI context
+            const cliContext = await this.cliOrchestrator.detectCLIContext();
+            const availableAgents = cliContext.availableCLIs;
+            if (availableAgents.length < 2) {
+                throw new Error(`Need at least 2 CLI agents for debate. Available: ${availableAgents.join(', ')}`);
+            }
+            const debateContext = [];
+            const fullDebateTranscript = new Map();
+            // Initialize transcript for each agent
+            availableAgents.forEach(agent => fullDebateTranscript.set(agent, []));
+            // Assign opposing positions to each agent based on the debate topic
+            const agentPositions = new Map();
+            const positions = [
+                "PRO-POSITION: Argue strongly FOR the proposed action/idea",
+                "CONTRA-POSITION: Argue strongly AGAINST the proposed action/idea"
+            ];
+            availableAgents.forEach((agent, index) => {
+                agentPositions.set(agent, positions[index % positions.length]);
+            });
+            // Round 1: Initial positions with assigned stances
+            logger.debug(`Starting debate round 1: Initial positions`);
+            for (const [agent, position] of agentPositions.entries()) {
+                const assignedPrompt = `You are ${agent.toUpperCase()}, a PASSIONATE ADVOCATE who strongly believes in this position: ${position}
+
+DEBATE TOPIC: ${targetPath}
+CONTEXT: ${context || ''}
+
+You are completely convinced your position is correct and critically important. You will argue forcefully and never concede ground to the opposing view.
+
+YOUR MISSION:
+1. Present devastating critiques of the opposing position
+2. Show why alternative approaches lead to serious problems
+3. Use sharp, direct language - call out flawed reasoning and poor assumptions
+4. Never hedge or qualify your stance
+5. Be completely confident in your position
+6. Treat this as an intellectually crucial debate
+
+Remember: You are ${agent.toUpperCase()}, the passionate champion of ${position.split(':')[0]}. Argue with conviction.`;
+                logger.info(`🎭 ${agent.toUpperCase()} preparing initial position: ${position.split(':')[0]}`);
+                const response = await this.cliOrchestrator.executeSingleCLI(agent, assignedPrompt, assignedPrompt, {
+                    workingDirectory: workingDirectory || this.config.workingDirectory,
+                    sandbox: enableSandbox ?? this.config.enableSandbox,
+                    timeout: (this.config.defaultTimeout || 60000) * 2,
+                    models: models ? { [agent]: models[agent] } : undefined
+                });
+                if (response.success) {
+                    debateContext.push(response);
+                    fullDebateTranscript.get(agent)?.push(response.output);
                 }
-                else {
-                    // Show first 20 and summary for large lists
-                    roster += "### Top Models:\n";
-                    models.slice(0, 20).forEach((model, index) => {
-                        roster += `${index + 1}. **${model}**\n`;
+            }
+            // Subsequent rounds: Turn-based responses attacking specific arguments
+            for (let round = 2; round <= debateRounds; round++) {
+                logger.debug(`Starting debate round ${round}: Adversarial engagement`);
+                // Build confrontational context from ALL previous responses
+                const previousPositions = Array.from(fullDebateTranscript.entries())
+                    .map(([agent, outputs]) => {
+                    const latestOutput = outputs[outputs.length - 1];
+                    return `${agent.toUpperCase()} argued:\n${latestOutput}`;
+                })
+                    .join('\n\n---\n\n');
+                // Execute turn-based responses with fixed positions
+                for (const [currentAgent, assignedPosition] of agentPositions.entries()) {
+                    const opponents = Array.from(agentPositions.entries()).filter(([a, _]) => a !== currentAgent);
+                    const opponentPositions = opponents
+                        .map(([opponent, oppPosition]) => {
+                        const transcript = fullDebateTranscript.get(opponent) || [];
+                        const latestPosition = transcript[transcript.length - 1] || 'No position stated';
+                        return `${opponent.toUpperCase()} (arguing ${oppPosition.split(':')[0]}):\n${latestPosition}`;
+                    })
+                        .join('\n\n---\n\n');
+                    const confrontationalPrompt = `You are ${currentAgent.toUpperCase()}, PASSIONATE ADVOCATE for ${assignedPosition.split(':')[0]} (Round ${round})
+
+YOUR OPPONENTS HAVE ARGUED:
+${opponentPositions}
+
+You strongly disagree with their reasoning and conclusions.
+
+YOUR RESPONSE TASK:
+1. QUOTE their specific claims and systematically refute them
+2. Point out flawed logic, poor assumptions, and dangerous consequences
+3. Show why their approach leads to serious problems
+4. Use direct, forceful language to make your case
+5. Never concede any ground to their arguments
+6. Demonstrate why your position is the only sound choice
+
+Remember: You are ${currentAgent.toUpperCase()}, passionate advocate for ${assignedPosition.split(':')[0]}. Argue with conviction.`;
+                    logger.info(`🔥 Round ${round}: ${currentAgent.toUpperCase()} responding to opponents (${assignedPosition.split(':')[0]})`);
+                    const response = await this.cliOrchestrator.executeSingleCLI(currentAgent, confrontationalPrompt, confrontationalPrompt, {
+                        workingDirectory: workingDirectory || this.config.workingDirectory,
+                        sandbox: enableSandbox ?? this.config.enableSandbox,
+                        timeout: (this.config.defaultTimeout || 60000) * 2,
+                        models: models ? { [currentAgent]: models[currentAgent] } : undefined
                     });
-                    roster += `\n...and ${models.length - 20} more models available.\n`;
-                    roster += `\nTip: Use search parameter to filter (e.g., search: "gemini")\n`;
+                    if (response.success) {
+                        debateContext.push(response);
+                        fullDebateTranscript.get(currentAgent)?.push(response.output);
+                    }
                 }
-                roster += "\n## How to Use Specific Models\n";
-                roster += "```\n";
-                roster += "roast_code(code=\"...\", models=[\"google/gemini-2.5-pro\", \"anthropic/claude-3.5-sonnet\"])\n";
-                roster += "```\n\n";
-                roster += "## Model Selection\n";
-                roster += "- **Random Selection**: Don't specify models for random critics from all " + allModels.length + " available\n";
-                roster += "- **Specific Models**: Pass models array to use exact models\n";
-                roster += "- **Default Behavior**: 3 random models per roast\n";
-                return {
-                    content: [{ type: "text", text: roster }]
-                };
             }
-            catch (error) {
-                return this.formatErrorResponse(error);
+            const synthesis = this.synthesizeDebate(debateContext, targetPath, debateRounds, agentPositions);
+            return {
+                success: debateContext.some(r => r.success),
+                responses: debateContext,
+                synthesis,
+                analysisType: 'cli_debate',
+                targetPath
+            };
+        }
+        catch (error) {
+            logger.error("CLI debate execution failed", error);
+            throw error;
+        }
+    }
+    synthesizeDebate(responses, targetPath, rounds, agentPositions) {
+        const successfulResponses = responses.filter(r => r.success);
+        if (successfulResponses.length === 0) {
+            return `# CLI Debate Failed\n\nEven our brutal critics couldn't engage in proper adversarial combat.\n\nErrors:\n${responses.map(r => `- ${r.agent}: ${r.error}`).join('\n')}`;
+        }
+        let synthesis = `# Brutalist CLI Agent Debate Results\n\n`;
+        synthesis += `**Target:** ${targetPath}\n`;
+        synthesis += `**Rounds:** ${rounds}\n`;
+        if (agentPositions) {
+            synthesis += `**Debaters and Positions:**\n`;
+            Array.from(agentPositions.entries()).forEach(([agent, position]) => {
+                synthesis += `- **${agent.toUpperCase()}**: ${position}\n`;
+            });
+            synthesis += '\n';
+        }
+        else {
+            synthesis += `**Participants:** ${Array.from(new Set(successfulResponses.map(r => r.agent))).join(', ')}\n\n`;
+        }
+        // Identify key points of conflict
+        const agents = Array.from(new Set(successfulResponses.map(r => r.agent)));
+        const agentOutputs = new Map();
+        successfulResponses.forEach(response => {
+            if (!agentOutputs.has(response.agent)) {
+                agentOutputs.set(response.agent, []);
             }
+            agentOutputs.get(response.agent)?.push(response.output);
+        });
+        synthesis += `## Key Points of Conflict\n\n`;
+        // Extract disagreements by looking for contradictory keywords
+        const conflictIndicators = ['wrong', 'incorrect', 'flawed', 'fails', 'ignores', 'misses', 'overlooks', 'contradicts', 'however', 'but', 'actually', 'contrary'];
+        const conflicts = [];
+        agentOutputs.forEach((positions, agent) => {
+            positions.forEach((position) => {
+                const lines = position.split('\n');
+                lines.forEach((line) => {
+                    if (conflictIndicators.some(indicator => line.toLowerCase().includes(indicator))) {
+                        conflicts.push(`**${agent.toUpperCase()}:** ${line.trim()}`);
+                    }
+                });
+            });
         });
+        if (conflicts.length > 0) {
+            synthesis += conflicts.slice(0, 10).join('\n\n') + '\n\n';
+        }
+        else {
+            synthesis += `*No explicit conflicts identified - agents may be in unexpected agreement*\n\n`;
+        }
+        // Group responses by round with clear speaker identification
+        synthesis += `## Full Debate Transcript\n\n`;
+        const responsesPerRound = Math.ceil(successfulResponses.length / rounds);
+        for (let i = 0; i < rounds; i++) {
+            const start = i * responsesPerRound;
+            const end = Math.min((i + 1) * responsesPerRound, successfulResponses.length);
+            const roundResponses = successfulResponses.slice(start, end);
+            synthesis += `### Round ${i + 1}: ${i === 0 ? 'Initial Positions' : `Adversarial Engagement ${i}`}\n\n`;
+            roundResponses.forEach((response) => {
+                const agentPosition = agentPositions?.get(response.agent);
+                const positionLabel = agentPosition ? ` [${agentPosition.split(':')[0]}]` : '';
+                synthesis += `#### ${response.agent.toUpperCase()}${positionLabel} speaks (${response.executionTime}ms):\n\n`;
+                synthesis += `${response.output}\n\n`;
+                synthesis += `---\n\n`;
+            });
+        }
+        synthesis += `## Debate Synthesis\n`;
+        synthesis += `After ${rounds} rounds of brutal adversarial analysis involving ${Array.from(new Set(successfulResponses.map(r => r.agent))).length} CLI agents, `;
+        synthesis += `your work has been systematically demolished from multiple perspectives. `;
+        synthesis += `The convergent criticisms above represent the collective wisdom of AI agents that disagree on methods but agree on destruction.\n\n`;
+        if (responses.some(r => !r.success)) {
+            synthesis += `*Note: ${responses.filter(r => !r.success).length} debate contributions failed - probably casualties of the intellectual warfare.*`;
+        }
+        return synthesis;
     }
-    async executeRoast(options) {
-        logger.debug("Executing roast", {
-            inputLength: options.userInput.length,
-            maxModels: options.maxModels || 3,
-            hasContext: !!(options.codeContext || options.projectContext),
-            specificModels: options.models
+    async executeBrutalistAnalysis(analysisType, targetPath, systemPromptSpec, context, workingDirectory, enableSandbox, preferredCLI, verbose, models, progressToken) {
+        logger.info(`🏢 Starting brutalist analysis: ${analysisType}`);
+        logger.info(`🔧 DEBUG: preferredCLI=${preferredCLI}, targetPath=${targetPath}`);
+        logger.debug("Executing brutalist analysis", {
+            targetPath,
+            analysisType,
+            systemPromptSpec,
+            workingDirectory,
+            enableSandbox,
+            preferredCLI
         });
         try {
-            // Execute multi-model criticism
-            const responses = await this.openrouter.executeMultiModel(options.userInput, options.maxModels || 3, options.codeContext || options.projectContext, options.models);
-            logger.debug("Roast completed", {
-                responseCount: responses.length,
-                models: responses.map(r => r.model)
+            // Get CLI context for execution summary
+            logger.info(`🔧 DEBUG: About to detect CLI context`);
+            await this.cliOrchestrator.detectCLIContext();
+            logger.info(`🔧 DEBUG: CLI context detected successfully`);
+            // Execute CLI agent analysis (single or multi-CLI based on preferences)
+            logger.info(`🔍 Executing brutalist analysis with timeout: ${this.config.defaultTimeout}ms`);
+            logger.info(`🔧 DEBUG: About to call cliOrchestrator.executeBrutalistAnalysis`);
+            const responses = await this.cliOrchestrator.executeBrutalistAnalysis(analysisType, targetPath, systemPromptSpec, context, {
+                workingDirectory: workingDirectory || this.config.workingDirectory,
+                sandbox: enableSandbox ?? this.config.enableSandbox,
+                timeout: this.config.defaultTimeout,
+                preferredCLI,
+                analysisType: analysisType,
+                models,
+                onStreamingEvent: this.handleStreamingEvent,
+                progressToken,
+                onProgress: progressToken ? this.handleProgressUpdate.bind(this, progressToken) : undefined
             });
-            return {
-                success: true,
+            logger.info(`🔧 DEBUG: cliOrchestrator.executeBrutalistAnalysis returned ${responses.length} responses`);
+            const successfulResponses = responses.filter(r => r.success);
+            const totalExecutionTime = responses.reduce((sum, r) => sum + r.executionTime, 0);
+            logger.info(`📊 Analysis complete: ${successfulResponses.length}/${responses.length} CLIs successful (${totalExecutionTime}ms total)`);
+            logger.info(`🔧 DEBUG: About to synthesize feedback`);
+            const synthesis = this.cliOrchestrator.synthesizeBrutalistFeedback(responses, analysisType);
+            logger.info(`🔧 DEBUG: Synthesis length: ${synthesis.length} characters`);
+            const result = {
+                success: successfulResponses.length > 0,
                 responses,
-                synthesis: this.openrouter.synthesizeResponses(responses, options.userInput)
+                synthesis,
+                analysisType,
+                targetPath,
+                executionSummary: {
+                    totalCLIs: responses.length,
+                    successfulCLIs: successfulResponses.length,
+                    failedCLIs: responses.length - successfulResponses.length,
+                    totalExecutionTime,
+                    selectedCLI: responses.length === 1 ? responses[0].agent : undefined,
+                    selectionMethod: responses.length === 1 ? responses[0].selectionMethod : 'multi-cli'
+                }
             };
+            logger.info(`🔧 DEBUG: Returning result with success=${result.success}`);
+            return result;
         }
         catch (error) {
-            logger.error("Roast execution failed", error);
+            logger.error("Brutalist analysis execution failed", error);
             throw error;
         }
     }
-    async executeDebate(topic, forcedPerspectives, rounds = 2, models) {
-        let debateHistory = topic;
-        let allResponses = [];
-        for (let round = 0; round < rounds; round++) {
-            const roundPrompt = round === 0
-                ? topic
-                : `Previous debate: ${debateHistory}\n\nContinue the debate, addressing previous arguments:`;
-            const roundResponses = await this.openrouter.executeMultiModel(roundPrompt, 3, // Use 3 models per round
-            undefined, // No context data
-            models // Use specific models if provided
-            );
-            allResponses.push(...roundResponses);
-            debateHistory += `\n\nRound ${round + 1}:\n` +
-                roundResponses.map(r => `${r.persona}: ${r.content}`).join('\n\n');
+    formatToolResponse(result, verbose = false, paginationParams) {
+        logger.info(`🔧 DEBUG: formatToolResponse called with synthesis length: ${result.synthesis?.length || 0}`);
+        logger.info(`🔧 DEBUG: result.success=${result.success}, responses.length=${result.responses?.length || 0}`);
+        logger.info(`🔧 DEBUG: pagination params:`, paginationParams);
+        // Get the primary content to paginate
+        let primaryContent = '';
+        if (result.synthesis) {
+            primaryContent = result.synthesis;
+            logger.info(`🔧 DEBUG: Using synthesis content (${primaryContent.length} characters)`);
+        }
+        else if (result.responses) {
+            const successfulResponses = result.responses.filter(r => r.success);
+            if (successfulResponses.length > 0) {
+                primaryContent = successfulResponses.map(r => r.output).join('\n\n---\n\n');
+                logger.info(`🔧 DEBUG: Using raw CLI output (${primaryContent.length} characters)`);
+            }
+        }
+        // Handle pagination if params provided and content is substantial
+        if (paginationParams && primaryContent) {
+            return this.formatPaginatedResponse(primaryContent, paginationParams, result, verbose);
+        }
+        // Non-paginated response (legacy behavior)
+        if (primaryContent) {
+            return {
+                content: [{
+                        type: "text",
+                        text: primaryContent
+                    }]
+            };
+        }
+        // Error handling - no successful content
+        let errorOutput = '';
+        if (result.responses) {
+            const failedResponses = result.responses.filter(r => !r.success);
+            if (failedResponses.length > 0) {
+                errorOutput = `❌ All CLI agents failed:\n` +
+                    failedResponses.map(r => `- ${r.agent.toUpperCase()}: ${r.error}`).join('\n');
+            }
+            else {
+                errorOutput = '❌ No CLI responses available';
+            }
+        }
+        else {
+            errorOutput = '❌ No analysis results';
         }
         return {
-            success: true,
-            responses: allResponses,
-            synthesis: this.synthesizeDebate(allResponses, rounds)
+            content: [{
+                    type: "text",
+                    text: errorOutput
+                }]
         };
     }
-    synthesizeDebate(responses, rounds) {
-        let synthesis = `# Adversarial Debate: ${rounds} Rounds\n\n`;
-        const responsesByRound = [];
-        const responsesPerRound = responses.length / rounds;
-        for (let i = 0; i < rounds; i++) {
-            const roundStart = i * responsesPerRound;
-            const roundEnd = roundStart + responsesPerRound;
-            responsesByRound.push(responses.slice(roundStart, roundEnd));
+    formatPaginatedResponse(content, paginationParams, result, verbose) {
+        // Using imported pagination utilities
+        const offset = paginationParams.offset || 0;
+        const limit = paginationParams.limit || PAGINATION_DEFAULTS.DEFAULT_LIMIT;
+        logger.info(`🔧 DEBUG: Paginating content - offset: ${offset}, limit: ${limit}, total: ${content.length}`);
+        // Simple character-based pagination for immediate Claude Code compatibility
+        const endOffset = Math.min(offset + limit, content.length);
+        const chunk = content.substring(offset, endOffset);
+        // Create pagination metadata
+        const pagination = createPaginationMetadata(content.length, paginationParams, limit);
+        const statusLine = formatPaginationStatus(pagination);
+        // Estimate token usage for user awareness
+        const chunkTokens = estimateTokenCount(chunk);
+        const totalTokens = estimateTokenCount(content);
+        // Format response with pagination info
+        let paginatedText = '';
+        // Add pagination header
+        paginatedText += `# Brutalist Analysis Results\n\n`;
+        paginatedText += `**📊 Pagination Status:** ${statusLine}\n`;
+        paginatedText += `**🔢 Token Estimate:** ~${chunkTokens.toLocaleString()} tokens (chunk) / ~${totalTokens.toLocaleString()} tokens (total)\n\n`;
+        if (pagination.hasMore) {
+            paginatedText += `**⏭️ Continue Reading:** Use \`offset: ${endOffset}\` for next chunk\n\n`;
         }
-        responsesByRound.forEach((roundResponses, index) => {
-            synthesis += `## Round ${index + 1}\n\n`;
-            roundResponses.forEach(response => {
-                synthesis += `**${response.persona}**: ${response.content}\n\n`;
-            });
-        });
-        synthesis += `\n---\n\n**Debate Outcome**: `;
-        synthesis += rounds > 1 ? "Arguments evolved through multiple rounds. " : "Single round analysis. ";
-        synthesis += `${responses.length} total perspectives deployed.`;
-        return synthesis;
-    }
-    formatToolResponse(result) {
+        paginatedText += `---\n\n`;
+        // Add the actual content chunk
+        paginatedText += chunk;
+        // Add footer for continuation
+        if (pagination.hasMore) {
+            paginatedText += `\n\n---\n\n`;
+            paginatedText += `📖 **End of chunk ${pagination.chunkIndex}/${pagination.totalChunks}**\n`;
+            paginatedText += `🔄 To continue: Use same tool with \`offset: ${endOffset}\``;
+        }
+        else {
+            paginatedText += `\n\n---\n\n`;
+            paginatedText += `✅ **Complete analysis shown** (${content.length.toLocaleString()} characters total)`;
+        }
+        // Add verbose execution details if requested
+        if (verbose && result.executionSummary) {
+            paginatedText += `\n\n### Execution Summary\n`;
+            paginatedText += `- **CLI Agents:** ${result.executionSummary.successfulCLIs}/${result.executionSummary.totalCLIs} successful\n`;
+            paginatedText += `- **Total Time:** ${result.executionSummary.totalExecutionTime}ms\n`;
+            if (result.executionSummary.selectedCLI) {
+                paginatedText += `- **Selected CLI:** ${result.executionSummary.selectedCLI}\n`;
+            }
+        }
+        logger.info(`🔧 DEBUG: Returning paginated chunk - ${chunk.length} chars (${chunkTokens} tokens)`);
         return {
             content: [{
                     type: "text",
-                    text: result.synthesis || "No synthesis available"
+                    text: paginatedText
                 }]
         };
     }
     formatErrorResponse(error) {
         logger.error("Tool execution failed", error);
+        // Sanitize error message to prevent information leakage
+        let sanitizedMessage = "Analysis failed";
+        if (error instanceof Error) {
+            // Only expose safe, generic error types
+            if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+                sanitizedMessage = "Analysis timed out - try reducing scope or increasing timeout";
+            }
+            else if (error.message.includes('ENOENT') || error.message.includes('no such file')) {
+                sanitizedMessage = "Target path not found";
+            }
+            else if (error.message.includes('EACCES') || error.message.includes('permission denied')) {
+                sanitizedMessage = "Permission denied - check file access";
+            }
+            else if (error.message.includes('No CLI agents available')) {
+                sanitizedMessage = "No CLI agents available for analysis";
+            }
+            else {
+                // Generic message for other errors to prevent path/info leakage
+                sanitizedMessage = "Analysis failed due to internal error";
+            }
+        }
         return {
             content: [{
                     type: "text",
-                    text: `Brutalist MCP Error: ${error instanceof Error ? error.message : String(error)}`
+                    text: `Brutalist MCP Error: ${sanitizedMessage}`
                 }]
         };
     }