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

package/dist/server/tools/storage.js

@@ -1,74 +1,82 @@
 /**
- * storage domain — pattern persistence (save, load, list).
+ * storage domain — pattern persistence.
  *
- * Owns (3 tools): save, load, list. Post-consolidation target per the
- * #110 audit: single `pattern_store` tool with `action` enum + params,
- * which also resolves the `list` / `list_sessions` naming collision.
- * For now we keep the individual verbs.
+ * Owns one consolidated tool (`pattern_store`) with save/load/list actions.
  */
 import { InputValidator } from '../../utils/InputValidator.js';
-export const tools = [
-    {
-        name: 'save',
-        description: 'Save pattern with metadata',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Pattern name' },
-                tags: { type: 'array', items: { type: 'string' } },
-            },
-            required: ['name'],
-        },
-    },
-    {
-        name: 'load',
-        description: 'Load saved pattern',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Pattern name' },
-            },
-            required: ['name'],
-        },
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Sources/targets the named session\'s current pattern; the on-disk catalog is shared across sessions.',
     },
+};
+export const tools = [
     {
-        name: 'list',
-        description: 'List saved patterns',
+        name: 'pattern_store',
+        description: 'Persist patterns to disk and read them back. ' +
+            'Use action=save to write the current session pattern under a name; ' +
+            'action=load to restore a named pattern into the current session; ' +
+            'action=list to enumerate the on-disk catalog (optionally filtered by tag). ' +
+            'Example: pattern_store({ action: "save", name: "my-jam", tags: ["techno"] }). ' +
+            'For session lifecycle (create/destroy/list active sessions) use the session tool — pattern_store deals with on-disk patterns, not runtime sessions.',
         inputSchema: {
             type: 'object',
             properties: {
-                tag: { type: 'string', description: 'Filter by tag' },
+                action: {
+                    type: 'string',
+                    enum: ['save', 'load', 'list'],
+                    description: 'Which on-disk operation to perform',
+                },
+                name: { type: 'string', description: 'Pattern name (required for save/load)' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Tags to attach (save only)' },
+                tag: { type: 'string', description: 'Filter by tag (list only)' },
+                ...SESSION_ID_PROP,
             },
+            required: ['action'],
         },
     },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
+async function doSave(args, ctx, sid) {
+    InputValidator.validateStringLength(args.name, 'name', 255, false);
+    const toSave = await ctx.getCurrentPatternSafe(sid);
+    if (!toSave) {
+        return 'No pattern to save';
+    }
+    await ctx.store.save(args.name, toSave, args.tags || []);
+    return `Pattern saved as "${args.name}"`;
+}
+async function doLoad(args, ctx, sid) {
+    InputValidator.validateStringLength(args.name, 'name', 255, false);
+    const saved = await ctx.store.load(args.name);
+    if (saved) {
+        await ctx.writePatternSafe(saved.content, sid);
+        return `Loaded pattern "${args.name}"`;
+    }
+    return `Pattern "${args.name}" not found`;
+}
+async function doList(args, ctx) {
+    if (args?.tag) {
+        InputValidator.validateStringLength(args.tag, 'tag', 100, false);
+    }
+    const patterns = await ctx.store.list(args?.tag);
+    return patterns.map(p => `• ${p.name} [${p.tags.join(', ')}] - ${p.timestamp}`).join('\n') || 'No patterns found';
+}
 export async function execute(name, args, ctx) {
+    const sid = args?.session_id;
     switch (name) {
-        case 'save': {
-            InputValidator.validateStringLength(args.name, 'name', 255, false);
-            const toSave = await ctx.getCurrentPatternSafe();
-            if (!toSave) {
-                return 'No pattern to save';
+        case 'pattern_store': {
+            const action = args?.action;
+            if (!action || !['save', 'load', 'list'].includes(action)) {
+                throw new Error(`Invalid action: ${action}. Must be one of: save, load, list`);
             }
-            await ctx.store.save(args.name, toSave, args.tags || []);
-            return `Pattern saved as "${args.name}"`;
-        }
-        case 'load': {
-            InputValidator.validateStringLength(args.name, 'name', 255, false);
-            const saved = await ctx.store.load(args.name);
-            if (saved) {
-                await ctx.writePatternSafe(saved.content);
-                return `Loaded pattern "${args.name}"`;
-            }
-            return `Pattern "${args.name}" not found`;
-        }
-        case 'list': {
-            if (args?.tag) {
-                InputValidator.validateStringLength(args.tag, 'tag', 100, false);
+            switch (action) {
+                case 'save': return await doSave(args, ctx, sid);
+                case 'load': return await doLoad(args, ctx, sid);
+                case 'list': return await doList(args, ctx);
             }
-            const patterns = await ctx.store.list(args?.tag);
-            return patterns.map(p => `• ${p.name} [${p.tags.join(', ')}] - ${p.timestamp}`).join('\n') || 'No patterns found';
+            // Unreachable due to enum check above, but TypeScript wants it.
+            return undefined;
         }
         default:
             throw new Error(`storage module does not handle tool: ${name}`);

package/dist/server/tools/transform.js

@@ -1,17 +1,12 @@
 /**
  * transform domain — mutate the current pattern.
  *
- * Owns (14 tools): transpose, reverse, stretch, quantize, humanize,
- * add_swing, apply_scale, generate_variation, add_effect, remove_effect,
- * set_tempo, shift_mood, set_energy, refine.
- *
- * Per the #110 audit this eventually collapses into:
- * - `transform` (op enum) — 8 tools
- * - `effect` (add/remove enum) — 2 tools
- * - `shape` (mood/energy/refine enum) — 3 tools
- * - `set_tempo` stays — high-traffic verb
- *
- * For now we keep the individual verbs and just move them out of server.ts.
+ * Owns (4 tools):
+ * - `transform` (op enum: transpose/reverse/stretch/quantize/humanize/
+ *    swing/scale/vary)
+ * - `effect` (action enum: add/remove)
+ * - `shape` (dimension enum: mood/energy/refine)
+ * - `set_tempo` — high-traffic standalone verb
  */
 import { InputValidator } from '../../utils/InputValidator.js';
 const ENERGY_LEVELS = {
@@ -50,74 +45,62 @@ function transposePattern(pattern, semitones) {
         return noteNames[newNoteValue] + newOctave;
     });
 }
-export const tools = [
-    {
-        name: 'transpose',
-        description: 'Transpose notes by semitones',
-        inputSchema: {
-            type: 'object',
-            properties: { semitones: { type: 'number', description: 'Semitones to transpose' } },
-            required: ['semitones'],
-        },
-    },
-    {
-        name: 'reverse',
-        description: 'Reverse pattern',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'stretch',
-        description: 'Time stretch pattern',
-        inputSchema: {
-            type: 'object',
-            properties: { factor: { type: 'number', description: 'Stretch factor' } },
-            required: ['factor'],
-        },
-    },
-    {
-        name: 'quantize',
-        description: 'Quantize to grid',
-        inputSchema: {
-            type: 'object',
-            properties: { grid: { type: 'string', description: 'Grid size (e.g., "1/16")' } },
-            required: ['grid'],
-        },
-    },
-    {
-        name: 'humanize',
-        description: 'Add human timing variation',
-        inputSchema: {
-            type: 'object',
-            properties: { amount: { type: 'number', description: 'Humanization amount (0-1)' } },
-        },
-    },
-    {
-        name: 'generate_variation',
-        description: 'Create pattern variations',
-        inputSchema: {
-            type: 'object',
-            properties: { type: { type: 'string', description: 'Variation type (subtle/moderate/extreme/glitch/evolving)' } },
-        },
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Omit to use default session.',
     },
+};
+export const tools = [
     {
-        name: 'add_effect',
-        description: 'Add effect to pattern',
+        name: 'transform',
+        description: 'Apply a single transform op to the current session pattern. ' +
+            'op=transpose shifts notes by `semitones`. ' +
+            'op=reverse appends `.rev` to the pattern. ' +
+            'op=stretch slows by `factor` (>1 slower, <1 faster). ' +
+            'op=quantize snaps to the `grid` (e.g. "1/16"). ' +
+            'op=humanize adds rand-nudge timing of `amount` (0-1). ' +
+            'op=swing applies `.swing(amount)`. ' +
+            'op=scale applies a `root`/`scale` filter to notes. ' +
+            'op=vary returns a variation of `type` (subtle/moderate/extreme/glitch/evolving). ' +
+            'Example: transform({ op: "transpose", semitones: 7 }). ' +
+            'For effects (add/remove) use effect; for mood/energy/refine use shape; for tempo use set_tempo.',
         inputSchema: {
             type: 'object',
             properties: {
-                effect: { type: 'string', description: 'Effect name' },
-                params: { type: 'string', description: 'Effect parameters' },
+                op: {
+                    type: 'string',
+                    enum: ['transpose', 'reverse', 'stretch', 'quantize', 'humanize', 'swing', 'scale', 'vary'],
+                    description: 'Which transform to apply',
+                },
+                semitones: { type: 'number', description: 'op=transpose: integer semitones to shift' },
+                factor: { type: 'number', description: 'op=stretch: stretch factor' },
+                grid: { type: 'string', description: 'op=quantize: grid size (e.g. "1/16")' },
+                amount: { type: 'number', description: 'op=humanize/swing: amount 0-1' },
+                root: { type: 'string', description: 'op=scale: root note (e.g. "C")' },
+                scale: { type: 'string', description: 'op=scale: scale name (e.g. "minor")' },
+                type: { type: 'string', description: 'op=vary: variation type (subtle/moderate/extreme/glitch/evolving)' },
+                ...SESSION_ID_PROP,
             },
-            required: ['effect'],
+            required: ['op'],
         },
     },
     {
-        name: 'remove_effect',
-        description: 'Remove effect',
+        name: 'effect',
+        description: 'Add or remove a Strudel effect on the current session pattern. ' +
+            'action=add appends `.<effect>(<params>)`. ' +
+            'action=remove strips the last `.<effect>(...)` call from the pattern. ' +
+            'Example: effect({ action: "add", effect: "lpf", params: "1000" }). ' +
+            'For higher-level effect bundles (mood/energy/refine) use shape; for raw transforms use transform.',
         inputSchema: {
             type: 'object',
-            properties: { effect: { type: 'string', description: 'Effect to remove' } },
-            required: ['effect'],
+            properties: {
+                action: { type: 'string', enum: ['add', 'remove'], description: 'add or remove the effect' },
+                effect: { type: 'string', description: 'Effect name (e.g. lpf, room, delay)' },
+                params: { type: 'string', description: 'Effect parameters (action=add only)' },
+                ...SESSION_ID_PROP,
+            },
+            required: ['action', 'effect'],
         },
     },
     {
@@ -125,160 +108,164 @@ export const tools = [
         description: 'Set BPM',
         inputSchema: {
             type: 'object',
-            properties: { bpm: { type: 'number', description: 'Tempo in BPM' } },
+            properties: { bpm: { type: 'number', description: 'Tempo in BPM' }, ...SESSION_ID_PROP },
             required: ['bpm'],
         },
     },
     {
-        name: 'add_swing',
-        description: 'Add swing to pattern',
-        inputSchema: {
-            type: 'object',
-            properties: { amount: { type: 'number', description: 'Swing amount (0-1)' } },
-            required: ['amount'],
-        },
-    },
-    {
-        name: 'apply_scale',
-        description: 'Apply scale to notes',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                scale: { type: 'string', description: 'Scale name' },
-                root: { type: 'string', description: 'Root note' },
-            },
-            required: ['scale', 'root'],
-        },
-    },
-    {
-        name: 'shift_mood',
-        description: 'Transform current pattern to match a different emotional mood by adjusting tempo, effects, and note choices. Moods: dark, euphoric, melancholic, aggressive, dreamy, peaceful, energetic.',
+        name: 'shape',
+        description: 'Shape the current pattern along one of three high-level dimensions. ' +
+            'dimension=mood applies a mood profile (dark/euphoric/melancholic/aggressive/dreamy/peaceful/energetic) with optional intensity 0-1. ' +
+            'dimension=energy applies an energy level (integer 0-10). ' +
+            'dimension=refine applies a directional refinement: faster/slower/louder/quieter/brighter/darker/"more reverb"/drier. ' +
+            'All three auto-play by default. ' +
+            'Example: shape({ dimension: "mood", target_mood: "dark", intensity: 0.8 }). ' +
+            'For raw transform ops use transform; for explicit effects use effect.',
         inputSchema: {
             type: 'object',
             properties: {
+                dimension: { type: 'string', enum: ['mood', 'energy', 'refine'], description: 'Which dimension to shape along' },
                 target_mood: {
                     type: 'string',
                     enum: ['dark', 'euphoric', 'melancholic', 'aggressive', 'dreamy', 'peaceful', 'energetic'],
-                    description: 'Target mood',
+                    description: 'dimension=mood: target mood',
                 },
-                intensity: { type: 'number', minimum: 0, maximum: 1, description: 'How strongly to apply the mood transformation (0-1, default: 0.5)' },
-                auto_play: { type: 'boolean', description: 'Start playback after transformation (default: true)' },
+                intensity: { type: 'number', minimum: 0, maximum: 1, description: 'dimension=mood: intensity 0-1 (default 0.5)' },
+                level: { type: 'number', description: 'dimension=energy: integer level 0-10' },
+                direction: { type: 'string', description: 'dimension=refine: faster, slower, louder, quieter, brighter, darker, "more reverb", drier' },
+                auto_play: { type: 'boolean', description: 'Start playback after shape (default true)' },
+                ...SESSION_ID_PROP,
             },
-            required: ['target_mood'],
-        },
-    },
-    {
-        name: 'set_energy',
-        description: 'Adjust the overall energy level of the current pattern on a 0-10 scale. 0: minimal/ambient, 1-2: sparse, 3-4: light/relaxed, 5-6: normal/moderate, 7-8: driving/intense, 9-10: maximum. Auto-plays after applying energy level.',
-        inputSchema: {
-            type: 'object',
-            properties: { level: { type: 'number', description: 'Energy level from 0 (minimal) to 10 (maximum)' } },
-            required: ['level'],
-        },
-    },
-    {
-        name: 'refine',
-        description: 'Incrementally refine the current pattern with simple directional commands. Supports: faster/slower (tempo), louder/quieter (gain), brighter/darker (filter cutoff), "more reverb"/drier (reverb). Auto-plays after applying refinement.',
-        inputSchema: {
-            type: 'object',
-            properties: { direction: { type: 'string', description: 'Refinement direction: faster, slower, louder, quieter, brighter, darker, "more reverb", or drier' } },
-            required: ['direction'],
+            required: ['dimension'],
         },
     },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
+// ---- per-op helpers (shared by transform({op}) and the deprecated aliases)
+async function opTranspose(args, ctx, sid) {
+    if (typeof args.semitones !== 'number' || !Number.isInteger(args.semitones)) {
+        throw new Error('Semitones must be an integer');
+    }
+    const p = await ctx.getCurrentPatternSafe(sid);
+    await ctx.writePatternSafe(transposePattern(p, args.semitones), sid);
+    return `Transposed ${args.semitones} semitones`;
+}
+async function opReverse(ctx, sid) {
+    const p = await ctx.getCurrentPatternSafe(sid);
+    await ctx.writePatternSafe(p + '.rev', sid);
+    return 'Pattern reversed';
+}
+async function opStretch(args, ctx, sid) {
+    InputValidator.validateGain(args.factor);
+    const p = await ctx.getCurrentPatternSafe(sid);
+    await ctx.writePatternSafe(p + `.slow(${args.factor})`, sid);
+    return `Stretched by factor of ${args.factor}`;
+}
+async function opQuantize(args, ctx, sid) {
+    InputValidator.validateStringLength(args.grid, 'grid', 50, false);
+    const p = await ctx.getCurrentPatternSafe(sid);
+    await ctx.writePatternSafe(p + `.struct("${args.grid}")`, sid);
+    return `Quantized to ${args.grid} grid`;
+}
+async function opHumanize(args, ctx, sid) {
+    if (args.amount !== undefined)
+        InputValidator.validateNormalizedValue(args.amount, 'amount');
+    const p = await ctx.getCurrentPatternSafe(sid);
+    const amt = args.amount || 0.01;
+    await ctx.writePatternSafe(p + `.nudge(rand.range(-${amt}, ${amt}))`, sid);
+    return 'Added human timing';
+}
+async function opVary(args, ctx, sid) {
+    const p = await ctx.getCurrentPatternSafe(sid);
+    const varied = ctx.generator.generateVariation(p, args.type || 'subtle');
+    await ctx.writePatternSafe(varied, sid);
+    return `Added ${args.type || 'subtle'} variation`;
+}
+async function opSwing(args, ctx, sid) {
+    InputValidator.validateNormalizedValue(args.amount, 'amount');
+    const p = await ctx.getCurrentPatternSafe(sid);
+    await ctx.writePatternSafe(p + `.swing(${args.amount})`, sid);
+    return `Added swing: ${args.amount}`;
+}
+async function opScale(args, ctx, sid) {
+    InputValidator.validateStringLength(args.scale, 'scale', 50, false);
+    InputValidator.validateRootNote(args.root);
+    const p = await ctx.getCurrentPatternSafe(sid);
+    await ctx.writePatternSafe(p + `.scale("${args.root}:${args.scale}")`, sid);
+    return `Applied ${args.root} ${args.scale} scale`;
+}
+async function opEffectAdd(args, ctx, sid) {
+    InputValidator.validateStringLength(args.effect, 'effect', 100, false);
+    if (args.params)
+        InputValidator.validateStringLength(args.params, 'params', 1000, true);
+    const p = await ctx.getCurrentPatternSafe(sid);
+    const withEffect = args.params
+        ? p + `.${args.effect}(${args.params})`
+        : p + `.${args.effect}()`;
+    await ctx.writePatternSafe(withEffect, sid);
+    return `Added ${args.effect} effect`;
+}
+async function opEffectRemove(args, ctx, sid) {
+    InputValidator.validateStringLength(args.effect, 'effect', 100, false);
+    const p = await ctx.getCurrentPatternSafe(sid);
+    const regex = new RegExp(`\\.${args.effect}\\([^)]*\\)`, 'g');
+    const stripped = p.replace(regex, '');
+    if (stripped === p)
+        return `No ${args.effect} effect found to remove`;
+    await ctx.writePatternSafe(stripped, sid);
+    return `Removed ${args.effect} effect`;
+}
 export async function execute(name, args, ctx) {
+    const sid = args?.session_id;
+    if (!sid && !ctx.isInitialized()) {
+        return 'Browser not initialized. Run init first.';
+    }
     switch (name) {
-        case 'transpose': {
-            if (typeof args.semitones !== 'number' || !Number.isInteger(args.semitones)) {
-                throw new Error('Semitones must be an integer');
+        case 'transform': {
+            const op = args?.op;
+            switch (op) {
+                case 'transpose': return await opTranspose(args, ctx, sid);
+                case 'reverse': return await opReverse(ctx, sid);
+                case 'stretch': return await opStretch(args, ctx, sid);
+                case 'quantize': return await opQuantize(args, ctx, sid);
+                case 'humanize': return await opHumanize(args, ctx, sid);
+                case 'swing': return await opSwing(args, ctx, sid);
+                case 'scale': return await opScale(args, ctx, sid);
+                case 'vary': return await opVary(args, ctx, sid);
+                default:
+                    throw new Error(`Invalid op: ${op}. Must be one of: transpose, reverse, stretch, quantize, humanize, swing, scale, vary`);
             }
-            const p = await ctx.getCurrentPatternSafe();
-            await ctx.writePatternSafe(transposePattern(p, args.semitones));
-            return `Transposed ${args.semitones} semitones`;
         }
-        case 'reverse': {
-            const p = await ctx.getCurrentPatternSafe();
-            await ctx.writePatternSafe(p + '.rev');
-            return 'Pattern reversed';
-        }
-        case 'stretch': {
-            InputValidator.validateGain(args.factor);
-            const p = await ctx.getCurrentPatternSafe();
-            await ctx.writePatternSafe(p + `.slow(${args.factor})`);
-            return `Stretched by factor of ${args.factor}`;
-        }
-        case 'quantize': {
-            InputValidator.validateStringLength(args.grid, 'grid', 50, false);
-            const p = await ctx.getCurrentPatternSafe();
-            await ctx.writePatternSafe(p + `.struct("${args.grid}")`);
-            return `Quantized to ${args.grid} grid`;
-        }
-        case 'humanize': {
-            if (args.amount !== undefined)
-                InputValidator.validateNormalizedValue(args.amount, 'amount');
-            const p = await ctx.getCurrentPatternSafe();
-            const amt = args.amount || 0.01;
-            await ctx.writePatternSafe(p + `.nudge(rand.range(-${amt}, ${amt}))`);
-            return 'Added human timing';
-        }
-        case 'generate_variation': {
-            const p = await ctx.getCurrentPatternSafe();
-            const varied = ctx.generator.generateVariation(p, args.type || 'subtle');
-            await ctx.writePatternSafe(varied);
-            return `Added ${args.type || 'subtle'} variation`;
-        }
-        case 'add_effect': {
-            InputValidator.validateStringLength(args.effect, 'effect', 100, false);
-            if (args.params)
-                InputValidator.validateStringLength(args.params, 'params', 1000, true);
-            const p = await ctx.getCurrentPatternSafe();
-            const withEffect = args.params
-                ? p + `.${args.effect}(${args.params})`
-                : p + `.${args.effect}()`;
-            await ctx.writePatternSafe(withEffect);
-            return `Added ${args.effect} effect`;
-        }
-        case 'remove_effect': {
-            InputValidator.validateStringLength(args.effect, 'effect', 100, false);
-            const p = await ctx.getCurrentPatternSafe();
-            const regex = new RegExp(`\\.${args.effect}\\([^)]*\\)`, 'g');
-            const stripped = p.replace(regex, '');
-            if (stripped === p)
-                return `No ${args.effect} effect found to remove`;
-            await ctx.writePatternSafe(stripped);
-            return `Removed ${args.effect} effect`;
+        case 'effect': {
+            const a = args?.action;
+            if (a !== 'add' && a !== 'remove') {
+                throw new Error(`Invalid action: ${a}. Must be one of: add, remove`);
+            }
+            return a === 'add'
+                ? await opEffectAdd(args, ctx, sid)
+                : await opEffectRemove(args, ctx, sid);
         }
         case 'set_tempo': {
             InputValidator.validateBPM(args.bpm);
-            const p = await ctx.getCurrentPatternSafe();
-            await ctx.writePatternSafe(`setcpm(${args.bpm})\n${p}`);
+            const p = await ctx.getCurrentPatternSafe(sid);
+            await ctx.writePatternSafe(`setcpm(${args.bpm})\n${p}`, sid);
             return `Set tempo to ${args.bpm} BPM`;
         }
-        case 'add_swing': {
-            InputValidator.validateNormalizedValue(args.amount, 'amount');
-            const p = await ctx.getCurrentPatternSafe();
-            await ctx.writePatternSafe(p + `.swing(${args.amount})`);
-            return `Added swing: ${args.amount}`;
-        }
-        case 'apply_scale': {
-            InputValidator.validateStringLength(args.scale, 'scale', 50, false);
-            InputValidator.validateRootNote(args.root);
-            const p = await ctx.getCurrentPatternSafe();
-            await ctx.writePatternSafe(p + `.scale("${args.root}:${args.scale}")`);
-            return `Applied ${args.root} ${args.scale} scale`;
+        case 'shape': {
+            const dim = args?.dimension;
+            switch (dim) {
+                case 'mood': return await shiftMood(args, ctx, sid);
+                case 'energy': return await setEnergyLevel(args.level, ctx, sid);
+                case 'refine': return await refinePattern(args.direction, ctx, sid);
+                default:
+                    throw new Error(`Invalid dimension: ${dim}. Must be one of: mood, energy, refine`);
+            }
         }
-        case 'shift_mood':
-            return await shiftMood(args, ctx);
-        case 'set_energy':
-            return await setEnergyLevel(args.level, ctx);
-        case 'refine':
-            return await refinePattern(args.direction, ctx);
         default:
             throw new Error(`transform module does not handle tool: ${name}`);
     }
 }
-async function shiftMood(args, ctx) {
+async function shiftMood(args, ctx, sid) {
     const mood = args.target_mood?.toLowerCase()?.trim();
     const profile = MOOD_PROFILES[mood];
     if (!profile) {
@@ -287,7 +274,7 @@ async function shiftMood(args, ctx) {
             error: `Unknown mood: ${args.target_mood}. Valid moods: ${Object.keys(MOOD_PROFILES).join(', ')}.`,
         };
     }
-    const pattern = await ctx.getCurrentPatternSafe();
+    const pattern = await ctx.getCurrentPatternSafe(sid);
     if (!pattern || pattern.trim().length === 0) {
         return { success: false, error: 'No pattern to transform. Write a pattern first.' };
     }
@@ -329,17 +316,17 @@ async function shiftMood(args, ctx) {
         result += `.gain(${g.toFixed(2)})`;
         applied.push(`gain ${profile.gainMod > 0 ? '+' : ''}${Math.round(profile.gainMod * 100 * intensity)}%`);
     }
-    await ctx.writePatternSafe(result);
-    if (args.auto_play !== false && ctx.isInitialized()) {
-        await ctx.controller.play();
+    await ctx.writePatternSafe(result, sid);
+    if (args.auto_play !== false && (sid || ctx.isInitialized())) {
+        await ctx.getController(sid).play();
     }
     return { success: true, target_mood: mood, intensity, applied_effects: applied };
 }
-async function setEnergyLevel(level, ctx) {
+async function setEnergyLevel(level, ctx, sid) {
     if (level < 0 || level > 10 || !Number.isInteger(level)) {
         return { success: false, error: 'Energy level must be an integer from 0 to 10.' };
     }
-    const pattern = await ctx.getCurrentPatternSafe();
+    const pattern = await ctx.getCurrentPatternSafe(sid);
     if (!pattern || pattern.trim().length === 0) {
         return { success: false, error: 'No pattern to adjust. Write a pattern first.' };
     }
@@ -348,13 +335,13 @@ async function setEnergyLevel(level, ctx) {
     if (config.densityAdjust)
         result += config.densityAdjust;
     result += `.room(${config.roomAmount})`;
-    await ctx.writePatternSafe(result);
-    if (ctx.isInitialized())
-        await ctx.controller.play();
+    await ctx.writePatternSafe(result, sid);
+    if (sid || ctx.isInitialized())
+        await ctx.getController(sid).play();
     return { success: true, level, description: config.description };
 }
-async function refinePattern(direction, ctx) {
-    const pattern = await ctx.getCurrentPatternSafe();
+async function refinePattern(direction, ctx, sid) {
+    const pattern = await ctx.getCurrentPatternSafe(sid);
     if (!pattern || pattern.trim().length === 0) {
         return { success: false, error: 'No pattern to refine. Write a pattern first.' };
     }
@@ -391,9 +378,9 @@ async function refinePattern(direction, ctx) {
                 error: `Unknown refinement direction: ${direction}. Supported: faster, slower, louder, quieter, brighter, darker, "more reverb", drier.`,
             };
     }
-    await ctx.writePatternSafe(pattern + modification);
-    if (ctx.isInitialized())
-        await ctx.controller.play();
+    await ctx.writePatternSafe(pattern + modification, sid);
+    if (sid || ctx.isInitialized())
+        await ctx.getController(sid).play();
     return { success: true, direction: dir, applied: modification };
 }
 export const transformModule = { tools, toolNames, execute };