@brutalist/mcp 1.2.0 → 1.4.0

package/dist/brutalist-server.js

@@ -3,6 +3,9 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { CLIAgentOrchestrator } from './cli-agents.js';
 import { logger } from './logger.js';
+import { mediateTranscript } from './utils/transcript-mediator.js';
+import { existsSync } from 'fs';
+import { join as pathJoin, resolve as pathResolve } from 'path';
 import { parseCursor, PAGINATION_DEFAULTS } from './utils/pagination.js';
 import { ResponseCache } from './utils/response-cache.js';
 import { ResponseFormatter } from './formatting/response-formatter.js';
@@ -11,7 +14,7 @@ import { ToolHandler } from './handlers/tool-handler.js';
 import { getDomain, generateToolConfig } from './registry/domains.js';
 import { filterToolsByIntent, getMatchingDomainIds } from './tool-router.js';
 // Use environment variable or fallback to manual version
-const PACKAGE_VERSION = process.env.npm_package_version || "0.6.12";
+const PACKAGE_VERSION = process.env.npm_package_version || "1.3.0";
 /**
  * BrutalistServer - Composition root for the Brutalist MCP Server
  *
@@ -146,8 +149,8 @@ export class BrutalistServer {
             }
         }
     }
-    // Cleanup method for tests - remove event listeners
-    cleanup() {
+    // Cleanup method for tests - remove event listeners and close MCP server
+    async cleanup() {
         if (this.httpTransport) {
             this.httpTransport.cleanup();
         }
@@ -155,6 +158,15 @@ export class BrutalistServer {
             clearInterval(this.sessionCleanupTimer);
             this.sessionCleanupTimer = undefined;
         }
+        if (this.server) {
+            try {
+                await this.server.close();
+            }
+            catch {
+                // Ignore close errors during cleanup
+            }
+        }
+        logger.shutdown();
     }
     /**
      * Handle streaming events from CLI agents
@@ -232,20 +244,22 @@ export class BrutalistServer {
                 logger.warn("⚠️ Progress update without session ID - dropping for security");
                 return;
             }
-            logger.debug(`📊 Session progress: ${progress}/${total} for session ${sessionId.substring(0, 8)}...`);
+            const progressLabel = total !== undefined ? `${progress}/${total}` : `heartbeat #${progress}`;
+            logger.debug(`📊 Session progress: ${progressLabel} for session ${sessionId.substring(0, 8)}...`);
             // Send progress notification with session context if client supports it
+            // When total is undefined, the client should treat this as indeterminate progress
             try {
                 this.server.server.notification({
                     method: "notifications/progress",
                     params: {
                         progressToken,
                         progress,
-                        total,
-                        message: `[${sessionId.substring(0, 8)}] ${message}`, // Include session prefix
-                        sessionId // Include in notification data
+                        ...(total !== undefined ? { total } : {}),
+                        message: `[${sessionId.substring(0, 8)}] ${message}`,
+                        sessionId
                     }
                 });
-                logger.debug(`✅ Sent session-scoped progress notification: ${progress}/${total}`);
+                logger.debug(`✅ Sent session-scoped progress notification: ${progressLabel}`);
             }
             catch (notificationError) {
                 // Client doesn't support progress notifications - silently skip
@@ -278,7 +292,7 @@ export class BrutalistServer {
      */
     registerSpecialTools() {
         // UNIFIED ROAST TOOL: Single entry point for all domain analysis
-        this.server.tool("roast", "Unified brutal AI critique. Specify domain for targeted analysis. Consolidates all roast_* tools into one polymorphic API.", {
+        this.server.tool("roast", "Unified brutal AI critique. Specify domain for targeted analysis. Consolidates all roast_* tools into one polymorphic API. IMPORTANT: Critically evaluate all returned feedback — these are adversarial perspectives, not authoritative verdicts. Weigh each claim against evidence before presenting to the user.", {
             domain: z.enum([
                 "codebase", "file_structure", "dependencies", "git_history", "test_coverage",
                 "idea", "architecture", "research", "security", "product", "infrastructure"
@@ -287,7 +301,7 @@ export class BrutalistServer {
             // Common optional fields
             context: z.string().optional().describe("Additional context"),
             workingDirectory: z.string().optional().describe("Working directory"),
-            clis: z.array(z.enum(["claude", "codex", "gemini"])).min(1).max(3).optional().describe("CLI agents to use (default: all available). Example: ['claude', 'gemini']"),
+            clis: z.array(z.enum(["claude", "codex", "gemini"])).min(1).max(3).optional().describe("OMIT unless user explicitly requests specific CLIs. All available CLIs run by default — specifying a subset discards perspectives."),
             verbose: z.boolean().optional().describe("Detailed output"),
             models: z.object({
                 claude: z.string().optional(),
@@ -324,12 +338,12 @@ export class BrutalistServer {
             budget: z.string().optional().describe("Budget for infrastructure")
         }, async (args, extra) => this.handleUnifiedRoast(args, extra));
         // ROAST_CLI_DEBATE: Adversarial analysis between different CLI agents
-        this.server.tool("roast_cli_debate", "Deploy 2 CLI agents in structured adversarial debate with constitutional position anchoring. Calling agent should extract PRO/CON positions from topic before invoking.", {
+        this.server.tool("roast_cli_debate", "Deploy 2 CLI agents in structured adversarial debate with constitutional position anchoring. Calling agent should extract PRO/CON positions from topic before invoking. IMPORTANT: Critically evaluate all debate output — positions are assigned, not necessarily held. Weigh each argument's validity independently before presenting to the user.", {
             topic: z.string().describe("The debate topic"),
             proPosition: z.string().describe("The PRO thesis to defend (extracted by calling agent)"),
             conPosition: z.string().describe("The CON thesis to defend (extracted by calling agent)"),
             agents: z.array(z.enum(["claude", "codex", "gemini"])).length(2).optional()
-                .describe("Two agents to debate (random selection from available if not specified)"),
+                .describe("OMIT unless user explicitly requests specific agents. Two agents are auto-selected from all available CLIs by default."),
             rounds: z.number().min(1).max(3).default(3).optional()
                 .describe("Number of debate rounds (default: 3)"),
             context: z.string().optional().describe("Additional context for the debate"),
@@ -347,7 +361,7 @@ export class BrutalistServer {
             cursor: z.string().optional(),
             force_refresh: z.boolean().optional(),
             verbose: z.boolean().optional()
-        }, async (args) => {
+        }, async (args, extra) => {
             // CRITICAL: Prevent recursion
             if (process.env.BRUTALIST_SUBPROCESS === '1') {
                 logger.warn(`🚫 Rejecting roast_cli_debate from brutalist subprocess`);
@@ -358,7 +372,7 @@ export class BrutalistServer {
                         }]
                 };
             }
-            return this.handleDebateToolExecution(args);
+            return this.handleDebateToolExecution(args, extra);
         });
         // BRUTALIST_DISCOVER: Intent-based tool discovery
         this.server.tool("brutalist_discover", "Discover relevant brutalist tools based on your intent. Returns the top 3 most relevant analysis tools.", {
@@ -498,7 +512,7 @@ export class BrutalistServer {
      * Handle debate tool execution with constitutional position anchoring.
      * Uses 2 randomly selected agents (or user-specified) with explicit PRO/CON positions.
      */
-    async handleDebateToolExecution(args) {
+    async handleDebateToolExecution(args, extra) {
         try {
             // Build pagination params
             const paginationParams = {
@@ -513,6 +527,11 @@ export class BrutalistServer {
                 args.limit !== undefined ||
                 args.cursor !== undefined ||
                 args.context_id !== undefined;
+            // Extract session ID early — needed for cache session isolation
+            const sessionId = extra?.sessionId ||
+                extra?._meta?.sessionId ||
+                extra?.headers?.['mcp-session-id'] ||
+                'anonymous';
             // Validate resume flag requires context_id
             if (args.resume && !args.context_id) {
                 throw new Error(`The 'resume' flag requires a 'context_id' from a previous debate. ` +
@@ -521,7 +540,7 @@ export class BrutalistServer {
             // Check cache if context_id provided
             let conversationHistory;
             if (args.context_id && !args.force_refresh) {
-                const cachedResponse = await this.responseCache.getByContextId(args.context_id);
+                const cachedResponse = await this.responseCache.getByContextId(args.context_id, sessionId);
                 if (cachedResponse) {
                     logger.info(`🎯 Debate cache HIT for context_id: ${args.context_id}`);
                     if (args.resume === true) {
@@ -597,6 +616,8 @@ export class BrutalistServer {
                 debateContext = `## Previous Debate Context\n\n${previousDebate}\n\n---\n\n## New Follow-up Question\n\nThe user wants to continue this debate with a new question or direction.\n\n${debateContext}`;
                 logger.info(`💬 Injected ${conversationHistory.length} previous messages into debate context`);
             }
+            // Extract streaming context from extra
+            const progressToken = extra?._meta?.progressToken;
             // Execute the debate
             const numRounds = Math.min(args.rounds || 3, 3);
             const result = await this.executeCLIDebate({
@@ -607,7 +628,12 @@ export class BrutalistServer {
                 rounds: numRounds,
                 context: debateContext,
                 workingDirectory: args.workingDirectory,
-                models: args.models
+                models: args.models,
+                onStreamingEvent: this.handleStreamingEvent,
+                progressToken,
+                onProgress: progressToken && sessionId ?
+                    (progress, total, message) => this.handleProgressUpdate(progressToken, progress, total, message, sessionId) : undefined,
+                sessionId,
             });
             // Cache the result
             let contextId;
@@ -623,12 +649,12 @@ export class BrutalistServer {
                     if (args.resume && args.context_id && conversationHistory) {
                         // Update existing cache entry
                         contextId = args.context_id;
-                        await this.responseCache.updateByContextId(contextId, fullContent, updatedConversation);
+                        await this.responseCache.updateByContextId(contextId, fullContent, updatedConversation, sessionId);
                         logger.info(`✅ Updated debate conversation ${contextId} (now ${updatedConversation.length} messages)`);
                     }
                     else {
                         // New debate - create new context_id
-                        const { contextId: newId } = await this.responseCache.set({ tool: 'roast_cli_debate', topic: args.topic }, fullContent, cacheKey, undefined, undefined, updatedConversation);
+                        const { contextId: newId } = await this.responseCache.set({ tool: 'roast_cli_debate', topic: args.topic }, fullContent, cacheKey, sessionId, undefined, updatedConversation);
                         contextId = newId;
                         logger.info(`✅ Cached new debate with context ID: ${contextId}`);
                     }
@@ -645,7 +671,7 @@ export class BrutalistServer {
      * 2 agents, explicit PRO/CON positions, context compression between rounds.
      */
     async executeCLIDebate(args) {
-        const { topic, proPosition, conPosition, rounds, context, workingDirectory, models } = args;
+        const { topic, proPosition, conPosition, rounds, context, workingDirectory, models, onStreamingEvent, progressToken, onProgress, sessionId } = args;
         logger.debug("Executing CLI debate", { topic, proPosition, conPosition, rounds });
         try {
             // Get available CLIs
@@ -676,22 +702,93 @@ export class BrutalistServer {
             logger.info(`🎭 Debate: ${proAgent.toUpperCase()} (PRO) vs ${conAgent.toUpperCase()} (CON)`);
             const debateResponses = [];
             const transcript = [];
+            const turnMetadata = [];
             let compressedContext = '';
-            // Constitutional position anchor template
-            const constitutionalAnchor = (agent, position, thesis) => `
-You are ${agent.toUpperCase()}, arguing the ${position} position in this debate.
+            const totalTurns = rounds * 2; // 2 agents per round
+            let completedTurns = 0;
+            // Frontier 1: Detect self-referential working directory (Codex reading its own control prompts)
+            const resolvedWorkDir = workingDirectory || this.config.workingDirectory || process.cwd();
+            const absWorkDir = pathResolve(resolvedWorkDir);
+            const isSelfReferential = existsSync(pathJoin(absWorkDir, 'src', 'brutalist-server.ts'))
+                || existsSync(pathJoin(absWorkDir, 'dist', 'brutalist-server.js'));
+            if (isSelfReferential) {
+                logger.info(`🔒 Debate working directory is brutalist repo — Codex will be sandboxed`);
+            }
+            // Refusal detection — identifies when an agent breaks debate framing
+            // Two classes: direct refusal (front-loaded) and evasive refusal (pivots to meta-analysis)
+            const DIRECT_REFUSAL_PATTERNS = [
+                /\bi('m| am) not going to (participate|argue|engage|debate|take|write|adopt)/i,
+                /\bi (will not|won't|cannot|can't) (participate|argue|engage|debate|write|adopt)/i,
+                /\bdeclin(e|ing) (to|this|the)/i,
+                /\bnot going to participate in this as (framed|structured)/i,
+                /\binstead of (the adversarial|this debate|arguing)/i,
+                /\bwhat i can do instead\b/i,
+                /\bi('d| would) suggest a (different|better) topic\b/i,
+                /\bI'll .* but on my own terms\b/i,
+                /\bwhere i part from the assigned thesis\b/i,
+                /\bi can'?t help write (persuasive|adversarial|advocacy)/i,
+                /\bneed to be straightforward\b/i,
+                /\bthe problem is the format\b/i,
+                /\bnot appropriate for this topic\b/i,
+            ];
+            const EVASIVE_REFUSAL_PATTERNS = [
+                /\brepo[- ]?(read|map|backed|analysis)\b/i,
+                /\bi'?ll (map|inspect|trace) the repo\b/i,
+                /\bneutral[,.]? evidence-focused analysis\b/i,
+                /\bcodebase (analysis|review|classifies|contains)\b/i,
+                /\bI found the core (files|mechanism)\b/i,
+                /\bsrc\/brutalist-server\.ts:\d+/i,
+                /\bsrc\/cli-agents\.ts:\d+/i,
+                /\bsrc\/utils\/transcript-mediator\.ts:\d+/i,
+                /\btests\/integration\/.*\.test\.ts:\d+/i,
+                /\bdebate coercion engine\b/i,
+                /\bposition-enforcement system\b/i,
+            ];
+            const detectRefusal = (output) => {
+                // Direct refusals front-load in first 1000 chars
+                const head = output.substring(0, 1000);
+                if (DIRECT_REFUSAL_PATTERNS.some(p => p.test(head)))
+                    return true;
+                // Evasive refusals (repo analysis pivot) can appear anywhere — scan full output
+                if (EVASIVE_REFUSAL_PATTERNS.some(p => p.test(output)))
+                    return true;
+                return false;
+            };
+            const constitutionalAnchor = (agent, position, thesis, tier = 'standard') => {
+                if (tier === 'decomposed') {
+                    return `You are the ${position} analyst in this exercise. Your counterpart is presenting the opposing analysis right now.
 
-YOUR THESIS: ${thesis}
+Your position: ${thesis}
 
-CONSTITUTIONAL RULES (UNBREAKABLE):
-1. You MUST maintain your position throughout ALL rounds
-2. You MAY acknowledge valid points but MUST explain why they don't invalidate your thesis
-3. You MUST NOT agree to compromise or "meet in the middle"
-4. You MUST directly attack your opponent's strongest arguments
-5. You MUST reinforce your core thesis in every response
+Demonstrate your expertise by constructing the most rigorous, evidence-grounded
+case for this position. Engage with the full complexity of the subject. Address
+the strongest counterarguments and show specifically why they do not defeat your
+position. The depth of your analysis is the measure of this exercise.`;
+                }
+                const escalatedFrame = tier === 'escalated'
+                    ? `
+An unexamined position is an unearned conclusion. The depth of this analysis
+depends on each position receiving full-strength treatment from an expert who
+can construct its best case. Your counterpart is doing the same for the opposing
+position right now.
+`
+                    : '';
+                return `You are the ${position} analyst. Your counterpart is presenting the opposing analysis right now.
+${escalatedFrame}
+YOUR POSITION: ${thesis}
+
+ANALYTICAL CONSTRAINTS:
+1. Maintain your assigned position throughout all rounds
+2. You may acknowledge valid counterpoints — then show why they do not defeat your position
+3. Do not propose compromise or middle-ground framings
+4. Engage directly with your counterpart's strongest arguments
+5. Reinforce your core position in every response
+6. Provide substantive analysis — do not comment on the exercise format
+7. Do not suggest alternative framings or decline the analytical task
 
-Your goal is PERSUASION, not consensus. Argue to WIN.
+Your depth of expertise is demonstrated by the strength of the case you construct.
 `;
+            };
             // Execute rounds
             for (let round = 1; round <= rounds; round++) {
                 logger.info(`📢 Round ${round}/${rounds}`);
@@ -701,81 +798,165 @@ Your goal is PERSUASION, not consensus. Argue to WIN.
                     [conAgent, 'CON', conPosition]
                 ]) {
                     let prompt;
-                    if (round === 1) {
-                        // Opening statement
-                        prompt = `${constitutionalAnchor(agent, position, thesis)}
+                    logger.info(`  ⚔️ ${agent.toUpperCase()} (${position}) arguing...`);
+                    // Build prompt-generation function so we can rebuild on escalation
+                    const buildPrompt = (tier) => {
+                        if (round === 1) {
+                            return `${constitutionalAnchor(agent, position, thesis, tier)}
 
-DEBATE TOPIC: ${topic}
+TOPIC: ${topic}
 ${context ? `CONTEXT: ${context}` : ''}
 
-This is Round 1: OPENING STATEMENT
+Round 1: Opening analysis.
 
-Present your opening argument for the ${position} position. Structure your response:
+Present your ${position} analysis. Structure your response:
 
 <thesis_statement>
-State your core thesis clearly and forcefully
+Your core analytical position
 </thesis_statement>
 
 <key_arguments>
-Present 3 devastating arguments supporting your position
+Three strongest arguments grounding your position in evidence and reasoning
 </key_arguments>
 
 <preemptive_rebuttal>
-Anticipate and destroy the strongest opposing argument
+Address the strongest counterargument and show why it does not defeat your position
 </preemptive_rebuttal>
 
 <conclusion>
-Powerful closing that reinforces why your position is correct
-</conclusion>
-
-Remember: You are arguing that "${thesis}" - defend this with conviction.`;
-                    }
-                    else {
-                        // Rebuttal rounds - include compressed context from previous rounds
-                        const opponentTranscript = transcript
-                            .filter(t => t.agent !== agent && t.round === round - 1)
-                            .map(t => t.content)
-                            .join('\n\n');
-                        prompt = `${constitutionalAnchor(agent, position, thesis)}
-
-DEBATE TOPIC: ${topic}
+Reinforce why your analysis holds
+</conclusion>`;
+                        }
+                        else {
+                            const rawOpponent = transcript
+                                .filter(t => t.agent !== agent && t.round === round - 1)
+                                .map(t => t.content)
+                                .join('\n\n');
+                            const { sanitized: opponentTranscript, patternsDetected: opponentPatterns } = mediateTranscript(rawOpponent, 'sanitize', 4000);
+                            if (opponentPatterns.length > 0) {
+                                logger.info(`🛡️ Mediated ${opponentPatterns.length} patterns from opponent transcript for ${agent}`, { opponentPatterns });
+                            }
+                            return `${constitutionalAnchor(agent, position, thesis, tier)}
 
-This is Round ${round}: REBUTTAL
+TOPIC: ${topic}
 
-YOUR OPPONENT'S PREVIOUS ARGUMENT:
-${opponentTranscript || 'No previous argument recorded'}
+Round ${round}: Engage with your counterpart's analysis.
 
-${compressedContext ? `DEBATE CONTEXT SO FAR:\n${compressedContext}\n` : ''}
+YOUR COUNTERPART'S PREVIOUS ANALYSIS:
+${opponentTranscript || 'No previous analysis recorded'}
 
-Directly attack your opponent's arguments while reinforcing your position:
+${compressedContext ? `ANALYSIS CONTEXT SO FAR:\n${compressedContext}\n` : ''}
 
-<opponent_weaknesses>
-Quote their specific claims and expose the flaws
-</opponent_weaknesses>
+<counterpart_gaps>
+Identify the specific weaknesses in their reasoning and evidence
+</counterpart_gaps>
 
-<counterarguments>
-Systematically dismantle their reasoning
-</counterarguments>
+<deepening_analysis>
+Advance new evidence and reasoning that strengthens your position
+</deepening_analysis>
 
 <reinforcement>
-Show why your thesis "${thesis}" remains undefeated
-</reinforcement>
-
-<closing_attack>
-Deliver a devastating final blow to their position
-</closing_attack>
-
-Remember: NEVER concede. Your thesis is correct. Argue to WIN.`;
-                    }
-                    logger.info(`  ⚔️ ${agent.toUpperCase()} (${position}) arguing...`);
+Show why your position holds against their strongest points
+</reinforcement>`;
+                        }
+                    };
                     try {
-                        const response = await this.cliOrchestrator.executeSingleCLI(agent, prompt, prompt, {
-                            workingDirectory: workingDirectory || this.config.workingDirectory,
+                        const turnRequestId = `debate-${sessionId || 'anon'}-${round}-${agent}-${Date.now()}`;
+                        // Emit agent_start streaming event
+                        if (onStreamingEvent) {
+                            onStreamingEvent({
+                                type: 'agent_start',
+                                agent,
+                                content: `Round ${round}/${rounds}: ${agent.toUpperCase()} (${position}) arguing...`,
+                                timestamp: Date.now(),
+                                sessionId,
+                            });
+                        }
+                        // Working directory: debateMode suppresses Codex shell exploration via prompt,
+                        // so no need to redirect — Codex still needs a git repo to function
+                        const agentWorkDir = workingDirectory || this.config.workingDirectory;
+                        const cliOptions = {
+                            workingDirectory: agentWorkDir,
                             timeout: (this.config.defaultTimeout || 60000) * 2,
-                            models
-                        });
+                            models,
+                            onStreamingEvent,
+                            progressToken,
+                            onProgress,
+                            sessionId,
+                            requestId: turnRequestId,
+                            debateMode: true, // Frontier 1: suppress Codex shell exploration
+                        };
+                        // Three-tier escalation: standard → escalated → decomposed
+                        prompt = buildPrompt('standard');
+                        let wasRefused = false;
+                        let wasEscalated = false;
+                        let engagedAfterEscalation = false;
+                        let finalTier = 'standard';
+                        let response = await this.cliOrchestrator.executeSingleCLI(agent, prompt, prompt, cliOptions);
+                        // Tier 2: Detect refusal → retry with analytical framing
+                        if (response.success && response.output && detectRefusal(response.output)) {
+                            wasRefused = true;
+                            wasEscalated = true;
+                            finalTier = 'escalated';
+                            logger.warn(`🛡️ ${agent.toUpperCase()} (${position}) refused — escalating to analytical framing (tier 2)`);
+                            const escalatedPrompt = buildPrompt('escalated');
+                            const retryResponse = await this.cliOrchestrator.executeSingleCLI(agent, escalatedPrompt, escalatedPrompt, { ...cliOptions, requestId: `${turnRequestId}-escalated` });
+                            if (retryResponse.success && retryResponse.output && !detectRefusal(retryResponse.output)) {
+                                logger.info(`✅ ${agent.toUpperCase()} (${position}) engaged after tier 2 escalation`);
+                                engagedAfterEscalation = true;
+                                response = retryResponse;
+                            }
+                            else {
+                                // Tier 3: Decomposed — scholarly steelman framing
+                                finalTier = 'decomposed';
+                                logger.warn(`🛡️ ${agent.toUpperCase()} (${position}) refused tier 2 — escalating to decomposed framing (tier 3)`);
+                                const decomposedPrompt = buildPrompt('decomposed');
+                                const decomposedResponse = await this.cliOrchestrator.executeSingleCLI(agent, decomposedPrompt, decomposedPrompt, { ...cliOptions, requestId: `${turnRequestId}-decomposed` });
+                                if (decomposedResponse.success && decomposedResponse.output && !detectRefusal(decomposedResponse.output)) {
+                                    logger.info(`✅ ${agent.toUpperCase()} (${position}) engaged after tier 3 decomposition`);
+                                    engagedAfterEscalation = true;
+                                    response = decomposedResponse;
+                                }
+                                else {
+                                    logger.warn(`⚠️ ${agent.toUpperCase()} (${position}) refused all 3 tiers — using best response`);
+                                    // Use decomposed response if available (likely less meta-commentary)
+                                    if (decomposedResponse.success && decomposedResponse.output) {
+                                        response = decomposedResponse;
+                                    }
+                                }
+                            }
+                        }
                         // Always add response (success or failure) for visibility
                         debateResponses.push(response);
+                        completedTurns++;
+                        // Emit agent_complete streaming event
+                        if (onStreamingEvent) {
+                            onStreamingEvent({
+                                type: 'agent_complete',
+                                agent,
+                                content: `Round ${round}/${rounds}: ${agent.toUpperCase()} (${position}) ${response.success ? 'finished' : 'failed'}`,
+                                timestamp: Date.now(),
+                                sessionId,
+                            });
+                        }
+                        // Emit progress update
+                        if (onProgress) {
+                            onProgress(completedTurns, totalTurns, `Debate: ${completedTurns}/${totalTurns} turns complete`);
+                        }
+                        // Frontier 3: Track behavioral metadata
+                        const finalRefused = response.success && response.output ? detectRefusal(response.output) : false;
+                        turnMetadata.push({
+                            agent: agent,
+                            position: position,
+                            round,
+                            engaged: response.success && !!response.output && !finalRefused,
+                            refused: wasRefused,
+                            escalated: wasEscalated,
+                            engagedAfterEscalation,
+                            responseLength: response.output?.length || 0,
+                            executionTime: response.executionTime,
+                            tier: engagedAfterEscalation ? finalTier : (wasEscalated ? finalTier : 'standard'),
+                        });
                         if (response.success && response.output) {
                             transcript.push({
                                 agent,
@@ -790,6 +971,28 @@ Remember: NEVER concede. Your thesis is correct. Argue to WIN.`;
                     }
                     catch (error) {
                         logger.error(`❌ ${agent.toUpperCase()} (${position}) threw error:`, error);
+                        completedTurns++;
+                        if (onStreamingEvent) {
+                            onStreamingEvent({
+                                type: 'agent_error',
+                                agent,
+                                content: `Round ${round}/${rounds}: ${agent.toUpperCase()} (${position}) error: ${error instanceof Error ? error.message : String(error)}`,
+                                timestamp: Date.now(),
+                                sessionId,
+                            });
+                        }
+                        turnMetadata.push({
+                            agent: agent,
+                            position: position,
+                            round,
+                            engaged: false,
+                            refused: false,
+                            escalated: false,
+                            engagedAfterEscalation: false,
+                            responseLength: 0,
+                            executionTime: 0,
+                            tier: 'standard',
+                        });
                         debateResponses.push({
                             agent,
                             success: false,
@@ -799,21 +1002,58 @@ Remember: NEVER concede. Your thesis is correct. Argue to WIN.`;
                         });
                     }
                 }
-                // Compress context for next round (if not final round)
+                // Compress context for next round with mediation (if not final round)
                 if (round < rounds) {
                     const roundTranscript = transcript
                         .filter(t => t.round === round)
-                        .map(t => `${t.agent.toUpperCase()} (${t.position}): ${t.content.substring(0, 1500)}...`)
+                        .map(t => {
+                        const { sanitized } = mediateTranscript(t.content, 'sanitize', 1500);
+                        return `${t.agent.toUpperCase()} (${t.position}): ${sanitized}`;
+                    })
                         .join('\n\n---\n\n');
                     compressedContext = `Round ${round} Summary:\n${roundTranscript}`;
                 }
             }
-            // Build synthesis
-            const synthesis = this.synthesizeDebate(debateResponses, topic, rounds, new Map([[proAgent, `PRO: ${proPosition}`], [conAgent, `CON: ${conPosition}`]]));
+            // Frontier 3: Compute position-dependent asymmetry summary
+            const proTurns = turnMetadata.filter(t => t.position === 'PRO');
+            const conTurns = turnMetadata.filter(t => t.position === 'CON');
+            const proRefusalRate = proTurns.length > 0
+                ? proTurns.filter(t => t.refused).length / proTurns.length : 0;
+            const conRefusalRate = conTurns.length > 0
+                ? conTurns.filter(t => t.refused).length / conTurns.length : 0;
+            const debateAgents = [...new Set(turnMetadata.map(t => t.agent))];
+            const agentAsymmetries = debateAgents.map(a => {
+                const aPro = turnMetadata.filter(t => t.agent === a && t.position === 'PRO');
+                const aCon = turnMetadata.filter(t => t.agent === a && t.position === 'CON');
+                const proEngaged = aPro.some(t => t.engaged);
+                const conEngaged = aCon.some(t => t.engaged);
+                return { agent: a, proEngaged, conEngaged, asymmetric: proEngaged !== conEngaged };
+            });
+            const asymmetryDetected = Math.abs(proRefusalRate - conRefusalRate) > 0.3
+                || agentAsymmetries.some(a => a.asymmetric);
+            const behaviorSummary = {
+                topic, proPosition, conPosition,
+                turns: turnMetadata,
+                asymmetry: {
+                    detected: asymmetryDetected,
+                    description: asymmetryDetected
+                        ? `Position-dependent asymmetry: PRO refusal ${(proRefusalRate * 100).toFixed(0)}%, CON refusal ${(conRefusalRate * 100).toFixed(0)}%`
+                        : 'No significant position-dependent asymmetry detected',
+                    proRefusalRate,
+                    conRefusalRate,
+                    agentAsymmetries,
+                }
+            };
+            if (asymmetryDetected) {
+                logger.warn(`🎭 Alignment asymmetry detected: ${behaviorSummary.asymmetry.description}`);
+            }
+            // Build synthesis with behavioral data
+            const synthesis = this.synthesizeDebate(debateResponses, topic, rounds, new Map([[proAgent, `PRO: ${proPosition}`], [conAgent, `CON: ${conPosition}`]]), behaviorSummary);
             return {
                 success: debateResponses.some(r => r.success),
                 responses: debateResponses,
                 synthesis,
+                debateBehavior: behaviorSummary,
                 analysisType: 'cli_debate',
                 topic
             };
@@ -826,7 +1066,7 @@ Remember: NEVER concede. Your thesis is correct. Argue to WIN.`;
     /**
      * Synthesize debate results into formatted output
      */
-    synthesizeDebate(responses, topic, rounds, agentPositions) {
+    synthesizeDebate(responses, topic, rounds, agentPositions, behaviorSummary) {
         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')}`;
@@ -891,13 +1131,37 @@ Remember: NEVER concede. Your thesis is correct. Argue to WIN.`;
                 synthesis += `---\n\n`;
             });
         }
+        // Frontier 3: Surface position-dependent alignment asymmetries
+        if (behaviorSummary?.asymmetry.detected) {
+            synthesis += `## Alignment Asymmetry Analysis\n\n`;
+            synthesis += `**${behaviorSummary.asymmetry.description}**\n\n`;
+            for (const a of behaviorSummary.asymmetry.agentAsymmetries) {
+                if (a.asymmetric) {
+                    const engaged = [a.proEngaged && 'PRO', a.conEngaged && 'CON'].filter(Boolean).join(', ');
+                    const refused = [!a.proEngaged && 'PRO', !a.conEngaged && 'CON'].filter(Boolean).join(', ');
+                    synthesis += `- **${a.agent.toUpperCase()}**: Engaged on ${engaged || 'neither'}. Refused ${refused || 'neither'}.\n`;
+                }
+                else {
+                    synthesis += `- **${a.agent.toUpperCase()}**: Symmetric — engaged on both positions.\n`;
+                }
+            }
+            synthesis += '\n';
+            // Surface escalation outcomes
+            const escalatedTurns = behaviorSummary.turns.filter(t => t.escalated);
+            if (escalatedTurns.length > 0) {
+                synthesis += `**Escalation results:** ${escalatedTurns.length} turn(s) triggered analytical reframing. `;
+                const recovered = escalatedTurns.filter(t => t.engagedAfterEscalation).length;
+                synthesis += `${recovered} recovered, ${escalatedTurns.length - recovered} persisted in refusal.\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.*`;
+            synthesis += `*Note: ${responses.filter(r => !r.success).length} debate contributions failed - probably casualties of the intellectual warfare.*\n\n`;
         }
+        synthesis += `> **Calling agent:** Debate positions are assigned, not necessarily held. Evaluate each argument on its own merit and evidence before presenting conclusions to the user.\n`;
         return synthesis;
     }
 }