@williamzujkowski/live-coding-music-mcp 2.0.0 → 4.0.0

package/dist/server/server.js

@@ -1,6 +1,6 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { StrudelController } from '../StrudelController.js';
 import { PatternStore } from '../PatternStore.js';
 import { MusicTheory } from '../services/MusicTheory.js';
@@ -12,7 +12,6 @@ import { SessionManager } from '../services/SessionManager.js';
 import { readFileSync, existsSync } from 'fs';
 import { Logger } from '../utils/Logger.js';
 import { PerformanceMonitor } from '../utils/PerformanceMonitor.js';
-import { InputValidator } from '../utils/InputValidator.js';
 import { StrudelEngine } from '../services/StrudelEngine.js';
 import { diagnosticsModule } from './tools/diagnostics.js';
 import { playbackModule } from './tools/playback.js';
@@ -25,13 +24,14 @@ import { generateModule } from './tools/generate.js';
 import { sessionModule } from './tools/session.js';
 import { captureModule } from './tools/capture.js';
 import { aiModule } from './tools/ai.js';
+import { composeModule } from './tools/compose.js';
+import { categorizeError, err, isEnvelope, ok } from './tools/types.js';
+import { readResource, resources as mcpResources } from './resources.js';
+import { join } from 'node:path';
 const configPath = './config.json';
 const config = existsSync(configPath)
     ? JSON.parse(readFileSync(configPath, 'utf-8'))
     : { headless: false };
-/** Energy level configuration for set_energy tool (#81) */
-// MOOD_PROFILES + ENERGY_LEVELS moved to src/server/tools/transform.ts
-// alongside the shift_mood / set_energy / refine handlers that use them.
 export class StrudelMCPServer {
     server;
     controller;
@@ -39,29 +39,39 @@ export class StrudelMCPServer {
     theory;
     generator;
     geminiService;
-    audioCaptureService = null;
+    /**
+     * Per-session AudioCaptureService instances (#180). Keyed by session id
+     * (or 'default' for the legacy/single-session path). Each session's
+     * recorder injects into its own page, so concurrent captures across
+     * sessions no longer conflict.
+     */
+    audioCaptureServices = new Map();
     midiExportService;
     sessionManager;
     logger;
     perfMonitor;
     strudelEngine;
     sessionHistory = [];
-    undoStack = [];
-    redoStack = [];
-    /** Pattern history with metadata for browsing (#41) */
-    historyStack = [];
+    /**
+     * Per-session undo/redo/history bundles (#179). Keyed by session id;
+     * 'default' for the legacy/single-session path. Bundles are lazily
+     * created on first access via getHistory().
+     */
+    historyBundles = new Map();
+    /** Server-wide history-entry counter; IDs unique across all sessions. */
     historyIdCounter = 0;
-    /** Maximum history entries to prevent memory leaks */
+    /** Maximum history entries per session to prevent memory leaks */
     MAX_HISTORY = 100;
     isInitialized = false;
     generatedPatterns = new Map();
     constructor() {
         this.server = new Server({
             name: 'live-coding-music-mcp',
-            version: '2.0.1',
+            version: '4.0.0',
         }, {
             capabilities: {
                 tools: {},
+                resources: {},
             },
         });
         this.controller = new StrudelController(config.headless);
@@ -77,70 +87,24 @@ export class StrudelMCPServer {
         this.setupHandlers();
     }
     getTools() {
-        // Same tools as before - keeping the same structure
         return [
-            // Core Control Tools (10)
             {
                 name: 'init',
                 description: 'Initialize Strudel in browser',
-                inputSchema: { type: 'object', properties: {} }
+                inputSchema: { type: 'object', properties: {} },
             },
-            // write, append, insert, replace, clear, get_pattern —
-            // extracted to src/server/tools/editor.ts (#104)
             ...editorModule.tools,
-            // play, pause, stop — extracted to src/server/tools/playback.ts (#104)
             ...playbackModule.tools,
-            // transform + effect + shape + set_tempo — extracted to src/server/tools/transform.ts (#104)
             ...transformModule.tools,
-            // generate_pattern, generate_drums, generate_bassline, generate_melody,
-            // generate_scale, generate_chord_progression, generate_euclidean,
-            // generate_polyrhythm, generate_fill — extracted to src/server/tools/generate.ts (#104)
             ...generateModule.tools,
-            // Audio Analysis + runtime validation — extracted to src/server/tools/analysis.ts (#104)
             ...analysisModule.tools,
-            // add_effect, remove_effect, set_tempo, add_swing, apply_scale,
-            // shift_mood — all handled by transformModule (see above).
-            // save, load, list — extracted to src/server/tools/storage.ts (#104)
             ...storageModule.tools,
-            // undo, redo, list_history, restore_history, compare_patterns
-            // — extracted to src/server/tools/history.ts (#104)
             ...historyModule.tools,
-            // generate_scale, generate_chord_progression, generate_euclidean,
-            // generate_polyrhythm, generate_fill — handled by generateModule (above).
-            // Performance, diagnostics, screenshots — extracted to src/server/tools/diagnostics.ts (#104)
             ...diagnosticsModule.tools,
-            // UX Tools - Browser Control (#37)
-            {
-                name: 'show_browser',
-                description: 'Bring browser window to foreground for visual feedback',
-                inputSchema: { type: 'object', properties: {} }
-            },
-            // UX Tools - High-level Compose (#42, #73)
-            {
-                name: 'compose',
-                description: 'Generate, write, and play a complete pattern in one step. Auto-initializes browser if needed.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        style: { type: 'string', description: 'Genre: techno, house, dnb, ambient, trap, jungle, jazz, experimental' },
-                        tempo: { type: 'number', description: 'BPM (default: genre-appropriate)' },
-                        key: { type: 'string', description: 'Musical key (default: C)' },
-                        auto_play: { type: 'boolean', description: 'Start playback immediately (default: true)' },
-                        get_feedback: { type: 'boolean', description: 'Get AI feedback on the generated pattern (default: false)' }
-                    },
-                    required: ['style']
-                }
-            },
-            // get_pattern_feedback, suggest_pattern_from_audio, jam_with —
-            // extracted to src/server/tools/ai.ts (#104)
+            ...composeModule.tools,
             ...aiModule.tools,
-            // start_audio_capture, stop_audio_capture, capture_audio_sample,
-            // export_midi — extracted to src/server/tools/capture.ts (#104)
             ...captureModule.tools,
-            // create_session, destroy_session, list_sessions, switch_session —
-            // extracted to src/server/tools/session.ts (#104)
             ...sessionModule.tools,
-            // refine, set_energy — handled by transformModule (see above).
         ];
     }
     setupHandlers() {
@@ -149,60 +113,115 @@ export class StrudelMCPServer {
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
+            const envelope = await this.dispatchToolCall(name, args);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(envelope, null, 2) }],
+            };
+        });
+        // MCP resources — read-only catalogs (#131). Resource handlers stay
+        // here in server.ts because they're protocol surface, not tool calls.
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+            resources: mcpResources,
+        }));
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+            const uri = request.params.uri;
             try {
-                this.logger.info(`Executing tool: ${name}`, args);
-                // Measure performance
-                const result = await this.perfMonitor.measureAsync(name, () => this.executeTool(name, args));
-                return {
-                    content: [{
-                            type: 'text',
-                            text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
-                        }],
-                };
+                const content = await readResource(uri, {
+                    store: this.store,
+                    examplesDir: join(process.cwd(), 'patterns', 'examples'),
+                });
+                return { contents: [content] };
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                this.logger.error(`Tool execution failed: ${name}`, { error: message });
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Error: ${message}`
-                        }],
-                };
+                this.logger.error(`Resource read failed: ${uri}`, { error: message });
+                throw error;
             }
         });
     }
-    requiresInitialization(toolName) {
-        const toolsRequiringInit = [
-            'write', 'append', 'insert', 'replace', 'play', 'pause', 'stop',
-            'clear', 'get_pattern', 'analyze', 'analyze_spectrum', 'analyze_rhythm',
-            'transpose', 'reverse', 'stretch', 'humanize', 'generate_variation',
-            'add_effect', 'add_swing', 'set_tempo', 'save', 'undo', 'redo',
-            'validate_pattern_runtime'
-        ];
-        const toolsRequiringWrite = [
-            'generate_pattern', 'generate_drums', 'generate_bassline', 'generate_melody',
-            'generate_chord_progression', 'generate_euclidean', 'generate_polyrhythm',
-            'generate_fill'
-        ];
-        return toolsRequiringInit.includes(toolName) || toolsRequiringWrite.includes(toolName);
+    /**
+     * Wraps every tool call into the shared envelope (#130).
+     *
+     * Tools may return:
+     *   - a raw value → auto-wrapped via `ok(value)`
+     *   - a pre-built Envelope (via the `ok()`/`err()`/`empty()` helpers in
+     *     `tools/types.ts`) → passed through unchanged
+     *   - an "error-shaped" string (starts with "Error: " or "Browser not
+     *     initialized") → converted to `err(...)` so legacy modules still
+     *     surface as failures while their internal migration to envelope
+     *     helpers proceeds incrementally
+     *
+     * Thrown errors are caught and converted to `err(...)` with a category
+     * inferred from the message (see `categorizeError`).
+     */
+    async dispatchToolCall(name, args) {
+        try {
+            this.logger.info(`Executing tool: ${name}`, args);
+            const result = await this.perfMonitor.measureAsync(name, () => this.executeTool(name, args));
+            if (isEnvelope(result)) {
+                return result;
+            }
+            // Convert legacy "Error: ..." / "Browser not initialized" string returns
+            // into the envelope. Module-level migration is incremental — this branch
+            // shrinks as modules adopt the helpers natively.
+            if (typeof result === 'string') {
+                if (result.startsWith('Error: ')) {
+                    return err('internal', result.slice('Error: '.length));
+                }
+                if (result.startsWith('Browser not initialized')) {
+                    return err('business', result);
+                }
+                return ok(result);
+            }
+            return ok(result);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Tool execution failed: ${name}`, { error: message });
+            return err(categorizeError(error), message);
+        }
     }
-    async getCurrentPatternSafe() {
+    // requiresInitialization() removed (#141 / #108): each module's
+    // execute() does its own session-aware init check. The hardcoded
+    // tool-name lists had drifted and were silently wrong for explicit
+    // session_id.
+    async getCurrentPatternSafe(sessionId) {
+        if (sessionId) {
+            // Explicit session — strict lookup, no pre-init stash. Named sessions
+            // must be created via `session({ action: "create" })` before they're useful.
+            const sessionController = this.sessionManager.getSession(sessionId);
+            if (!sessionController) {
+                throw new Error(`Session '${sessionId}' not found. Create it first with session({ action: "create" }).`);
+            }
+            try {
+                return await sessionController.getCurrentPattern();
+            }
+            catch {
+                return '';
+            }
+        }
         if (!this.isInitialized) {
-            // Return the last generated pattern if available
+            // Default session: return the last pre-init generated pattern if any
             const lastPattern = Array.from(this.generatedPatterns.values()).pop();
             return lastPattern || '';
         }
         try {
             return await this.controller.getCurrentPattern();
         }
-        catch (e) {
+        catch {
             return '';
         }
     }
-    async writePatternSafe(pattern) {
+    async writePatternSafe(pattern, sessionId) {
+        if (sessionId) {
+            const sessionController = this.sessionManager.getSession(sessionId);
+            if (!sessionController) {
+                throw new Error(`Session '${sessionId}' not found. Create it first with session({ action: "create" }).`);
+            }
+            return await sessionController.writePattern(pattern);
+        }
         if (!this.isInitialized) {
-            // Store the pattern for later use
+            // Default session: stash the pattern for the next init/auto-init
             const id = `pattern_${Date.now()}`;
             this.generatedPatterns.set(id, pattern);
             return `Pattern generated (initialize Strudel to use it): ${pattern.substring(0, 50)}...`;
@@ -221,7 +240,7 @@ export class StrudelMCPServer {
         if (sessionId) {
             const controller = this.sessionManager.getSession(sessionId);
             if (!controller) {
-                throw new Error(`Session '${sessionId}' not found. Create it first with create_session.`);
+                throw new Error(`Session '${sessionId}' not found. Create it first with session({ action: "create" }).`);
             }
             return controller;
         }
@@ -246,41 +265,40 @@ export class StrudelMCPServer {
         return this.sessionManager.getDefaultSession() !== undefined || this.isInitialized;
     }
     async executeTool(name, args) {
-        // Check if tool needs initialization
-        if (this.requiresInitialization(name) && !this.isInitialized && name !== 'init') {
-            // For generation tools that don't require browser, handle them specially
-            const generationTools = [
-                'generate_pattern', 'generate_drums', 'generate_bassline', 'generate_melody',
-                'generate_chord_progression', 'generate_euclidean', 'generate_polyrhythm', 'generate_fill'
-            ];
-            if (!generationTools.includes(name)) {
-                return `Browser not initialized. Run 'init' first to use ${name}.`;
-            }
-        }
-        // Save current state for undo and history (#41) (only if initialized)
-        if (['write', 'append', 'insert', 'replace', 'clear'].includes(name) && this.isInitialized) {
-            try {
-                const current = await this.controller.getCurrentPattern();
-                this.undoStack.push(current);
-                // Add to history stack with metadata (#41)
-                this.historyIdCounter++;
-                this.historyStack.push({
-                    id: this.historyIdCounter,
-                    pattern: current,
-                    timestamp: new Date(),
-                    action: name
-                });
-                // Enforce bounds to prevent memory leaks
-                if (this.undoStack.length > this.MAX_HISTORY) {
-                    this.undoStack.shift();
+        // Pre-flight init check removed (#141): every module's execute() does
+        // its own session-aware init check via ctx.isInitialized() /
+        // ctx.getController(sid). The old hardcoded tool-name list drifted as
+        // tools moved between modules and #108 made it silently wrong for
+        // explicit session_id (it returned "Browser not initialized" instead
+        // of "Session 'X' not found").
+        // Save current state for undo and history (#41) before any edit
+        // (#179): route to the session-specific bundle. Default session is
+        // 'default'; named sessions get their own isolated stacks.
+        if (name === 'edit_pattern') {
+            const sid = args?.session_id;
+            const canRead = sid !== undefined || this.isInitialized;
+            if (canRead) {
+                try {
+                    const controller = this.getControllerForSession(sid);
+                    const current = await controller.getCurrentPattern();
+                    const bundle = this.getHistoryBundle(sid ?? 'default');
+                    bundle.undoStack.push(current);
+                    this.historyIdCounter++;
+                    bundle.historyStack.push({
+                        id: this.historyIdCounter,
+                        pattern: current,
+                        timestamp: new Date(),
+                        action: args?.mode ?? 'write',
+                    });
+                    if (bundle.undoStack.length > this.MAX_HISTORY)
+                        bundle.undoStack.shift();
+                    if (bundle.historyStack.length > this.MAX_HISTORY)
+                        bundle.historyStack.shift();
+                    bundle.redoStack.length = 0;
                 }
-                if (this.historyStack.length > this.MAX_HISTORY) {
-                    this.historyStack.shift();
+                catch {
+                    // Controller might not be initialized yet, or session is gone
                 }
-                this.redoStack = [];
-            }
-            catch (e) {
-                // Controller might not be initialized yet
             }
         }
         // Delegate to extracted per-domain tool modules before the big switch.
@@ -296,17 +314,25 @@ export class StrudelMCPServer {
             geminiService: this.geminiService,
             strudelEngine: this.strudelEngine,
             midiExportService: this.midiExportService,
-            getAudioCaptureService: () => this.getAudioCaptureService(),
-            history: {
-                undoStack: this.undoStack,
-                redoStack: this.redoStack,
-                historyStack: this.historyStack,
-                maxHistory: this.MAX_HISTORY,
+            getAudioCaptureService: (sessionId) => this.getAudioCaptureService(sessionId),
+            dropAudioCaptureService: (sessionId) => { this.audioCaptureServices.delete(sessionId); },
+            getHistory: (sessionId) => {
+                const bundle = this.getHistoryBundle(sessionId ?? 'default');
+                return {
+                    undoStack: bundle.undoStack,
+                    redoStack: bundle.redoStack,
+                    historyStack: bundle.historyStack,
+                    maxHistory: this.MAX_HISTORY,
+                };
             },
+            historyEntryId: () => ++this.historyIdCounter,
+            dropHistory: (sessionId) => { this.historyBundles.delete(sessionId); },
             logger: this.logger,
             isInitialized: () => this.isInitialized,
-            getCurrentPatternSafe: () => this.getCurrentPatternSafe(),
-            writePatternSafe: (p) => this.writePatternSafe(p),
+            ensureInitialized: () => this.ensureInitialized(),
+            getController: (sessionId) => this.getControllerForSession(sessionId),
+            getCurrentPatternSafe: (sessionId) => this.getCurrentPatternSafe(sessionId),
+            writePatternSafe: (p, sessionId) => this.writePatternSafe(p, sessionId),
         };
         if (diagnosticsModule.toolNames.has(name)) {
             return await diagnosticsModule.execute(name, args, ctx);
@@ -341,230 +367,82 @@ export class StrudelMCPServer {
         if (aiModule.toolNames.has(name)) {
             return await aiModule.execute(name, args, ctx);
         }
-        switch (name) {
-            // Core Control
-            case 'init':
-                const initResult = await this.controller.initialize();
-                this.isInitialized = true;
-                // Write any pending patterns
-                if (this.generatedPatterns.size > 0) {
-                    const lastPattern = Array.from(this.generatedPatterns.values()).pop();
-                    if (lastPattern) {
-                        await this.controller.writePattern(lastPattern);
-                        return `${initResult}. Loaded generated pattern.`;
-                    }
-                }
-                return initResult;
-            // write, append, insert, replace, clear, get_pattern
-            //   — handled by editorModule above.
-            // play, pause, stop — handled by playbackModule above.
-            // Pattern + music-theory generation — all handled by
-            // generateModule above. See src/server/tools/generate.ts.
-            // Pattern manipulation + effects + tempo — all handled by
-            // transformModule above. See src/server/tools/transform.ts.
-            // analyze, analyze_spectrum, analyze_rhythm, detect_tempo, detect_key,
-            // validate_pattern_runtime — handled by analysisModule above.
-            // Local Pattern Tools (#83) - No browser required
-            case 'validate_pattern_local':
-                InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
-                const localValidation = this.strudelEngine.validate(args.pattern);
-                return {
-                    valid: localValidation.valid,
-                    errors: localValidation.errors,
-                    warnings: localValidation.warnings,
-                    suggestions: localValidation.suggestions,
-                    errorLocation: localValidation.errorLocation,
-                    message: localValidation.valid
-                        ? '✅ Pattern is valid'
-                        : `❌ Pattern has ${localValidation.errors.length} error(s)`
-                };
-            case 'analyze_pattern_local':
-                InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
-                const patternMetadata = this.strudelEngine.analyzePattern(args.pattern);
-                return {
-                    ...patternMetadata,
-                    message: `Pattern analysis: ${patternMetadata.eventsPerCycle} events/cycle, ` +
-                        `complexity ${(patternMetadata.complexity * 100).toFixed(0)}%` +
-                        (patternMetadata.bpm ? `, ${patternMetadata.bpm} BPM` : '')
-                };
-            case 'query_pattern_events':
-                InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
-                const startCycle = args.start ?? 0;
-                const endCycle = args.end ?? 1;
-                if (startCycle >= endCycle) {
-                    return { error: 'Start must be less than end' };
-                }
-                if (endCycle - startCycle > 16) {
-                    return { error: 'Maximum range is 16 cycles to prevent excessive output' };
-                }
-                try {
-                    const events = this.strudelEngine.queryEvents(args.pattern, startCycle, endCycle);
-                    return {
-                        count: events.length,
-                        range: { start: startCycle, end: endCycle },
-                        events: events.map((e) => ({
-                            value: e.value,
-                            start: e.start,
-                            end: e.end,
-                            duration: e.end - e.start
-                        }))
-                    };
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    return {
-                        error: message,
-                        suggestion: 'Check pattern syntax with validate_pattern_local first'
-                    };
-                }
-            case 'transpile_pattern':
-                InputValidator.validateStringLength(args.pattern, 'pattern', 10000, false);
-                const transpileResult = this.strudelEngine.transpile(args.pattern);
-                if (transpileResult.success) {
-                    return {
-                        success: true,
-                        transpiledCode: transpileResult.transpiledCode,
-                        message: 'Pattern transpiled successfully'
-                    };
-                }
-                else {
-                    return {
-                        success: false,
-                        error: transpileResult.error,
-                        errorLocation: transpileResult.errorLocation,
-                        message: 'Transpilation failed'
-                    };
-                }
-            // shift_mood — handled by transformModule above.
-            // Session Management
-            // save, load, list — handled by storageModule above.
-            // undo, redo, list_history, restore_history, compare_patterns
-            //   — handled by historyModule above.
-            // performance_report, memory_usage, screenshot, status, diagnostics,
-            // show_errors — all handled by diagnosticsModule before this switch.
-            // show_browser stays here until session.ts extraction lands.
-            // UX Tools - Browser Control (#37)
-            case 'show_browser':
-                if (!this.isInitialized) {
-                    return 'Browser not initialized. Run init first.';
-                }
-                return await this.controller.showBrowser();
-            // UX Tools - High-level Compose (#42, #73)
-            case 'compose':
-                InputValidator.validateStringLength(args.style, 'style', 100, false);
-                if (args.key) {
-                    InputValidator.validateRootNote(args.key);
-                }
-                if (args.tempo !== undefined) {
-                    InputValidator.validateBPM(args.tempo);
-                }
-                // Auto-initialize if needed
-                if (!this.isInitialized) {
-                    await this.controller.initialize();
-                    this.isInitialized = true;
-                }
-                // Generate pattern
-                const composedPattern = this.generator.generateCompletePattern(args.style, args.key || 'C', args.tempo || this.getDefaultTempo(args.style));
-                // Write pattern
-                await this.controller.writePattern(composedPattern);
-                // Auto-play by default (unless explicitly set to false)
-                const shouldPlay = args.auto_play !== false;
-                if (shouldPlay) {
-                    await this.controller.play();
-                }
-                // Build response
-                const composeResponse = {
-                    success: true,
-                    pattern: composedPattern.substring(0, 200) + (composedPattern.length > 200 ? '...' : ''),
-                    metadata: {
-                        style: args.style,
-                        bpm: args.tempo || this.getDefaultTempo(args.style),
-                        key: args.key || 'C'
-                    },
-                    status: shouldPlay ? 'playing' : 'ready',
-                    message: `Created ${args.style} pattern in ${args.key || 'C'}${shouldPlay ? ' - now playing' : ''}`
-                };
-                // Get AI feedback if requested (#73)
-                if (args.get_feedback) {
-                    if (this.geminiService.isAvailable()) {
-                        try {
-                            const feedback = await this.geminiService.getCreativeFeedback(composedPattern);
-                            composeResponse.feedback = feedback;
-                            composeResponse.message += ` (AI feedback: ${feedback.complexity} complexity, estimated ${feedback.estimatedStyle})`;
-                        }
-                        catch (error) {
-                            const message = error instanceof Error ? error.message : String(error);
-                            this.logger.warn('Failed to get AI feedback for compose', { error: message });
-                            // Don't fail the whole operation, just note the feedback failure
-                            composeResponse.message += ' (AI feedback unavailable)';
-                        }
-                    }
-                    else {
-                        composeResponse.message += ' (AI feedback requires GEMINI_API_KEY)';
-                    }
+        if (composeModule.toolNames.has(name)) {
+            return await composeModule.execute(name, args, ctx);
+        }
+        if (name === 'init') {
+            const initResult = await this.controller.initialize();
+            this.isInitialized = true;
+            // Replay any pattern generated before init landed.
+            if (this.generatedPatterns.size > 0) {
+                const lastPattern = Array.from(this.generatedPatterns.values()).pop();
+                if (lastPattern) {
+                    await this.controller.writePattern(lastPattern);
+                    return `${initResult}. Loaded generated pattern.`;
                 }
-                return composeResponse;
-            // get_pattern_feedback, suggest_pattern_from_audio —
-            // handled by aiModule above.
-            // start_audio_capture, stop_audio_capture, capture_audio_sample,
-            // export_midi — handled by captureModule above.
-            // create_session, destroy_session, list_sessions, switch_session —
-            // handled by sessionModule above.
-            // jam_with — handled by aiModule above.
-            // refine, set_energy — handled by transformModule above.
-            default:
-                throw new Error(`Unknown tool: ${name}`);
+            }
+            return initResult;
         }
+        throw new Error(`Unknown tool: ${name}`);
     }
-    // refinePattern, setEnergyLevel, transposePattern moved to
-    // src/server/tools/transform.ts alongside the tools that used them.
     /**
-     * Gets the default tempo for a given music style
-     * @param style - Music style/genre
-     * @returns Default BPM for the style
+     * Lazily get or create the per-session history bundle (#179). Bundle is
+     * a mutable triple — callers push/shift directly on the arrays.
      */
-    getDefaultTempo(style) {
-        const tempoMap = {
-            'techno': 130,
-            'house': 125,
-            'dnb': 174,
-            'drum and bass': 174,
-            'ambient': 80,
-            'trap': 140,
-            'jungle': 160,
-            'jazz': 110,
-            'experimental': 120,
-            'dubstep': 140,
-            'trance': 138,
-            'breakbeat': 130,
-            'garage': 130,
-            'electro': 128,
-            'downtempo': 90,
-            'idm': 115
-        };
-        return tempoMap[style.toLowerCase()] || 120;
+    getHistoryBundle(sessionId) {
+        let bundle = this.historyBundles.get(sessionId);
+        if (!bundle) {
+            bundle = { undoStack: [], redoStack: [], historyStack: [] };
+            this.historyBundles.set(sessionId, bundle);
+        }
+        return bundle;
+    }
+    /** Idempotent browser bring-up. Used by tools that promise auto-init (e.g. `compose`). */
+    async ensureInitialized() {
+        if (this.isInitialized)
+            return;
+        await this.controller.initialize();
+        this.isInitialized = true;
     }
-    // formatTimeAgo, generateDiff, summarizeDiff moved to
-    // src/server/tools/history.ts along with the tools that used them.
-    // getPatternFeedback, suggestPatternFromAudio, captureAudioSample,
-    // jamWith + six pattern-analysis helpers moved to src/server/tools/ai.ts.
     /** Getter for page access in audio capture. */
     get _page() {
         return this.controller.page;
     }
-    // Audio capture + MIDI export logic moved to src/server/tools/capture.ts.
-    // Server still owns the AudioCaptureService lifecycle so tests can mock
-    // the class and the module fetches the (possibly mocked) instance via
-    // ctx.getAudioCaptureService() instead of caching its own.
-    async getAudioCaptureService() {
-        if (!this.isInitialized || !this._page) {
-            throw new Error('Browser not initialized. Run init first.');
+    // Audio capture + MIDI export logic lives in src/server/tools/capture.ts.
+    // Server still owns AudioCaptureService lifecycles so tests can mock
+    // the class. Post-#180: per-session — each session's recorder injects
+    // into its own page; concurrent captures across sessions no longer
+    // share a singleton stream.
+    async getAudioCaptureService(sessionId) {
+        // Resolve the right page: explicit session via SessionManager, or
+        // legacy/default via this.controller.
+        let page;
+        let key;
+        if (sessionId) {
+            const sessionController = this.sessionManager.getSession(sessionId);
+            if (!sessionController) {
+                throw new Error(`Session '${sessionId}' not found. Create it first with session({ action: "create" }).`);
+            }
+            if (!sessionController.page) {
+                throw new Error(`Session '${sessionId}' has no active page yet.`);
+            }
+            page = sessionController.page;
+            key = sessionId;
+        }
+        else {
+            if (!this.isInitialized || !this._page) {
+                throw new Error('Browser not initialized. Run init first.');
+            }
+            page = this._page;
+            key = 'default';
         }
-        if (!this.audioCaptureService) {
-            this.audioCaptureService = new AudioCaptureService();
-            await this.audioCaptureService.injectRecorder(this._page);
+        let service = this.audioCaptureServices.get(key);
+        if (!service) {
+            service = new AudioCaptureService();
+            await service.injectRecorder(page);
+            this.audioCaptureServices.set(key, service);
         }
-        return this.audioCaptureService;
+        return service;
     }
     async run() {
         const transport = new StdioServerTransport();