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

package/dist/server/tools/diagnostics.js

@@ -2,17 +2,13 @@
  * diagnostics domain — observability tools (browser status, errors,
  * server metrics).
  *
- * Owns one consolidated tool (`diagnostics(level)`) plus four deprecated
- * aliases (`status`, `show_errors`, `performance_report`, `memory_usage`)
- * per #120 / #144.
+ * Owns one consolidated tool (`diagnostics(level)`) with status/full/
+ * perf/memory/errors levels.
  *
  * The `<15ms` SLA on `level='status'` is preserved — that branch only
  * reads from the controller's cache, not the browser. Other levels can
  * touch the browser (`level='full'`) or just inspect server state
  * (`perf`, `memory`).
- *
- * `screenshot` stays separate; it folds into `browser_window` per
- * Phase 3 (#156).
  */
 const SESSION_ID_PROP = {
     session_id: {
@@ -31,7 +27,7 @@ export const tools = [
             'level=errors returns captured console errors and warnings from Strudel. ' +
             'Default level=full preserves the pre-consolidation behaviour. ' +
             'Example: diagnostics({ level: "status" }) — millisecond-cheap. ' +
-            'For screenshots use browser_window (Phase 3 / #156); for tool listings use the strudel://docs/tools resource.',
+            'For screenshots use browser_window; for tool listings use the strudel://docs/tools resource.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -44,37 +40,6 @@ export const tools = [
             },
         },
     },
-    {
-        name: 'status',
-        description: '[DEPRECATED — use diagnostics({ level: "status" }) instead] Get current browser and playback status (quick state check)',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
-    {
-        name: 'show_errors',
-        description: '[DEPRECATED — use diagnostics({ level: "errors" }) instead] Display captured console errors and warnings from Strudel',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
-    {
-        name: 'performance_report',
-        description: '[DEPRECATED — use diagnostics({ level: "perf" }) instead] Get performance metrics and bottlenecks',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'memory_usage',
-        description: '[DEPRECATED — use diagnostics({ level: "memory" }) instead] Get current memory usage statistics',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'screenshot',
-        description: '[DEPRECATED — use browser_window({ action: "screenshot" }) instead] Take a screenshot of the current Strudel editor state',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filename: { type: 'string', description: 'Optional filename for screenshot' },
-                ...SESSION_ID_PROP,
-            },
-        },
-    },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 function getPerformanceReport(ctx) {
@@ -129,18 +94,6 @@ export async function execute(name, args, ctx) {
                     throw new Error(`Invalid level: ${level}. Must be one of: status, full, perf, memory, errors`);
             }
         }
-        // Deprecated aliases — forward to consolidated handler. Kept for ≥1
-        // release per #120 migration policy.
-        case 'status': return getStatus(ctx, sid);
-        case 'show_errors': return getErrors(ctx, sid);
-        case 'performance_report': return getPerformanceReport(ctx);
-        case 'memory_usage': return getMemoryUsage(ctx);
-        case 'screenshot': {
-            if (!sid && !ctx.isInitialized()) {
-                return 'Browser not initialized. Run init first.';
-            }
-            return await ctx.getController(sid).takeScreenshot(args?.filename);
-        }
         default:
             throw new Error(`diagnostics module does not handle tool: ${name}`);
     }

package/dist/server/tools/editor.js

@@ -1,12 +1,9 @@
 /**
  * editor domain — pattern editing in the CodeMirror editor.
  *
- * Owns one consolidated mutation tool (`edit_pattern(mode)`) plus
- * `get_pattern` (kept separate, hot read path) and five deprecated
- * aliases (write/append/insert/replace/clear) per #120 / #148.
- *
- * Aliases forward to `edit_pattern` and will be removed in a future
- * release per the deprecation policy.
+ * Owns one consolidated mutation tool (`edit_pattern(mode)`) with
+ * write/append/insert/replace/clear modes, plus `get_pattern` (kept
+ * separate — hot read path).
  */
 import { InputValidator } from '../../utils/InputValidator.js';
 const SESSION_ID_PROP = {
@@ -50,60 +47,6 @@ export const tools = [
         description: 'Get current pattern code',
         inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
     },
-    {
-        name: 'write',
-        description: '[DEPRECATED — use edit_pattern({ mode: "write" }) instead] Write pattern to editor with optional auto-play and validation',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: { type: 'string', description: 'Pattern code' },
-                auto_play: { type: 'boolean', description: 'Start playback immediately after writing (default: false)' },
-                validate: { type: 'boolean', description: 'Validate pattern before writing (default: true)' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['pattern'],
-        },
-    },
-    {
-        name: 'append',
-        description: '[DEPRECATED — use edit_pattern({ mode: "append" }) instead] Append code to current pattern',
-        inputSchema: {
-            type: 'object',
-            properties: { code: { type: 'string', description: 'Code to append' }, ...SESSION_ID_PROP },
-            required: ['code'],
-        },
-    },
-    {
-        name: 'insert',
-        description: '[DEPRECATED — use edit_pattern({ mode: "insert" }) instead] Insert code at specific line',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                position: { type: 'number', description: 'Line number' },
-                code: { type: 'string', description: 'Code to insert' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['position', 'code'],
-        },
-    },
-    {
-        name: 'replace',
-        description: '[DEPRECATED — use edit_pattern({ mode: "replace" }) instead] Replace pattern section',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                search: { type: 'string', description: 'Text to replace' },
-                replace: { type: 'string', description: 'Replacement text' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['search', 'replace'],
-        },
-    },
-    {
-        name: 'clear',
-        description: '[DEPRECATED — use edit_pattern({ mode: "clear" }) instead] Clear the editor',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 async function doWrite(args, ctx, sid) {
@@ -177,12 +120,6 @@ export async function execute(name, args, ctx) {
                     throw new Error(`Invalid mode: ${mode}. Must be one of: write, append, insert, replace, clear`);
             }
         }
-        // Deprecated aliases — forward to consolidated handler.
-        case 'write': return await doWrite(args, ctx, sid);
-        case 'append': return await doAppend(args, ctx, sid);
-        case 'insert': return await doInsert(args, ctx, sid);
-        case 'replace': return await doReplace(args, ctx, sid);
-        case 'clear': return await doClear(ctx, sid);
         case 'get_pattern':
             return await ctx.getCurrentPatternSafe(sid);
         default:

package/dist/server/tools/generate.js

@@ -1,16 +1,13 @@
 /**
  * generate domain — pattern and music-theory generation (no browser needed).
  *
- * Owns (9 tools):
- *   generate_pattern, generate_drums, generate_bassline, generate_melody,
- *   generate_fill, generate_scale, generate_chord_progression,
- *   generate_euclidean, generate_polyrhythm
+ * Owns (3 tools):
+ *   generate_part(role)   — drums/bass/melody/fill layers
+ *   music_theory(query)   — scale notes, chord progressions
+ *   generate_rhythm(type) — euclidean / polyrhythm patterns
  *
- * `compose` stays in server.ts for now — it orchestrates init + generate
- * + play + optional AI feedback and pairs with ai.ts when that extraction
- * happens. Per the #110 audit, compose eventually absorbs generate_pattern
- * and the four generate_* drums/bass/melody/fill tools collapse into
- * `generate_part(role)`, while scale+chord_prog become `music_theory`.
+ * Full-composition generation lives in `compose` (compose.ts), which
+ * orchestrates init + generate + play + optional AI feedback.
  */
 import { InputValidator } from '../../utils/InputValidator.js';
 const SESSION_ID_PROP = {
@@ -20,21 +17,6 @@ const SESSION_ID_PROP = {
     },
 };
 export const tools = [
-    {
-        name: 'generate_pattern',
-        description: '[DEPRECATED — use compose instead, which auto-inits and returns richer metadata] Generate complete pattern from style with optional auto-play.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                style: { type: 'string', description: 'Music style (techno/house/dnb/ambient/etc)' },
-                key: { type: 'string', description: 'Musical key' },
-                bpm: { type: 'number', description: 'Tempo in BPM' },
-                auto_play: { type: 'boolean', description: 'Start playback immediately (default: false)' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['style'],
-        },
-    },
     {
         name: 'generate_part',
         description: 'Generate a single instrumental layer and append it to the current session pattern. ' +
@@ -60,51 +42,11 @@ export const tools = [
             required: ['role'],
         },
     },
-    {
-        name: 'generate_drums',
-        description: '[DEPRECATED — use generate_part({ role: "drums" }) instead] Generate drum pattern',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                style: { type: 'string', description: 'Drum style' },
-                complexity: { type: 'number', description: 'Complexity (0-1)' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['style'],
-        },
-    },
-    {
-        name: 'generate_bassline',
-        description: '[DEPRECATED — use generate_part({ role: "bass" }) instead] Generate bassline',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string', description: 'Musical key' },
-                style: { type: 'string', description: 'Bass style' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['key', 'style'],
-        },
-    },
-    {
-        name: 'generate_melody',
-        description: '[DEPRECATED — use generate_part({ role: "melody" }) instead] Generate melody from scale',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                scale: { type: 'string', description: 'Scale name' },
-                root: { type: 'string', description: 'Root note' },
-                length: { type: 'number', description: 'Number of notes' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['scale', 'root'],
-        },
-    },
     {
         name: 'music_theory',
         description: 'Music-theory queries. ' +
             'query=scale returns the notes of a scale (e.g. "C major scale: C, D, E, F, G, A, B"). ' +
-            'query=chord_progression returns a chord progression for the key/style AND writes the resulting chord pattern into the current session (matches the pre-consolidation behaviour of generate_chord_progression). ' +
+            'query=chord_progression returns a chord progression for the key/style AND writes the resulting chord pattern into the current session. ' +
             'Example: music_theory({ query: "scale", root: "C", scale: "major" }). ' +
             'For pattern generation (drums/bass/melody) use generate_part; for rhythmic patterns use generate_rhythm.',
         inputSchema: {
@@ -120,31 +62,6 @@ export const tools = [
             required: ['query'],
         },
     },
-    {
-        name: 'generate_scale',
-        description: '[DEPRECATED — use music_theory({ query: "scale" }) instead] Generate scale notes',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                root: { type: 'string', description: 'Root note' },
-                scale: { type: 'string', description: 'Scale type' },
-            },
-            required: ['root', 'scale'],
-        },
-    },
-    {
-        name: 'generate_chord_progression',
-        description: '[DEPRECATED — use music_theory({ query: "chord_progression" }) instead] Generate chord progression',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string', description: 'Key' },
-                style: { type: 'string', description: 'Style (pop/jazz/blues/etc)' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['key', 'style'],
-        },
-    },
     {
         name: 'generate_rhythm',
         description: 'Generate a rhythmic pattern and append it to the current session. ' +
@@ -166,46 +83,6 @@ export const tools = [
             required: ['type'],
         },
     },
-    {
-        name: 'generate_euclidean',
-        description: '[DEPRECATED — use generate_rhythm({ type: "euclidean" }) instead] Generate Euclidean rhythm',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                hits: { type: 'number', description: 'Number of hits' },
-                steps: { type: 'number', description: 'Total steps' },
-                sound: { type: 'string', description: 'Sound to use' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['hits', 'steps'],
-        },
-    },
-    {
-        name: 'generate_polyrhythm',
-        description: '[DEPRECATED — use generate_rhythm({ type: "polyrhythm" }) instead] Generate polyrhythm',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sounds: { type: 'array', items: { type: 'string' }, description: 'Sounds to use' },
-                patterns: { type: 'array', items: { type: 'number' }, description: 'Pattern numbers' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['sounds', 'patterns'],
-        },
-    },
-    {
-        name: 'generate_fill',
-        description: '[DEPRECATED — use generate_part({ role: "fill" }) instead] Generate drum fill',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                style: { type: 'string', description: 'Fill style' },
-                bars: { type: 'number', description: 'Number of bars' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['style'],
-        },
-    },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 async function appendOrSet(generated, ctx, sessionId) {
@@ -278,20 +155,6 @@ async function doFill(args, ctx, sid) {
 export async function execute(name, args, ctx) {
     const sid = args?.session_id;
     switch (name) {
-        case 'generate_pattern': {
-            InputValidator.validateStringLength(args.style, 'style', 100, false);
-            if (args.key)
-                InputValidator.validateRootNote(args.key);
-            if (args.bpm !== undefined)
-                InputValidator.validateBPM(args.bpm);
-            const generated = ctx.generator.generateCompletePattern(args.style, args.key || 'C', args.bpm || 120);
-            await ctx.writePatternSafe(generated, sid);
-            if (args.auto_play && (sid || ctx.isInitialized())) {
-                await ctx.getController(sid).play();
-                return `Generated ${args.style} pattern. Playing.`;
-            }
-            return `Generated ${args.style} pattern`;
-        }
         case 'generate_part': {
             const role = args?.role;
             switch (role) {
@@ -303,9 +166,6 @@ export async function execute(name, args, ctx) {
                     throw new Error(`Invalid role: ${role}. Must be one of: drums, bass, melody, fill`);
             }
         }
-        case 'generate_drums': return await doDrums(args, ctx, sid);
-        case 'generate_bassline': return await doBassline(args, ctx, sid);
-        case 'generate_melody': return await doMelody(args, ctx, sid);
         case 'music_theory': {
             const q = args?.query;
             if (q !== 'scale' && q !== 'chord_progression') {
@@ -313,8 +173,6 @@ export async function execute(name, args, ctx) {
             }
             return q === 'scale' ? doScale(args, ctx) : await doChordProgression(args, ctx, sid);
         }
-        case 'generate_scale': return doScale(args, ctx);
-        case 'generate_chord_progression': return await doChordProgression(args, ctx, sid);
         case 'generate_rhythm': {
             const t = args?.type;
             if (t !== 'euclidean' && t !== 'polyrhythm') {
@@ -324,9 +182,6 @@ export async function execute(name, args, ctx) {
                 ? await doEuclidean(args, ctx, sid)
                 : await doPolyrhythm(args, ctx, sid);
         }
-        case 'generate_euclidean': return await doEuclidean(args, ctx, sid);
-        case 'generate_polyrhythm': return await doPolyrhythm(args, ctx, sid);
-        case 'generate_fill': return await doFill(args, ctx, sid);
         default:
             throw new Error(`generate module does not handle tool: ${name}`);
     }

package/dist/server/tools/history.js

@@ -1,15 +1,13 @@
 /**
  * history domain — undo/redo stacks and the pattern history browser.
  *
- * Owns (5 tools): undo, redo, list_history, restore_history,
- * compare_patterns. Post-consolidation target per the #110 audit:
- * single `history` tool with an `action` enum. For now we keep the
- * individual verbs.
+ * Owns one consolidated tool (`history(action)`) with undo/redo/list/
+ * restore/compare actions.
  *
  * The history module mutates the three state arrays (undoStack,
- * redoStack, historyStack) passed through ctx.history. The outer
- * server pushes onto these arrays on write/append/insert/replace/clear,
- * so all mutations share the same underlying storage.
+ * redoStack, historyStack) reached through ctx.getHistory(). The outer
+ * server pushes onto these arrays on every edit_pattern call, so all
+ * mutations share the same underlying storage.
  */
 const SESSION_ID_PROP = {
     session_id: {
@@ -45,51 +43,6 @@ export const tools = [
             required: ['action'],
         },
     },
-    {
-        name: 'undo',
-        description: '[DEPRECATED — use history({ action: "undo" }) instead] Undo last action',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
-    {
-        name: 'redo',
-        description: '[DEPRECATED — use history({ action: "redo" }) instead] Redo action',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
-    {
-        name: 'list_history',
-        description: '[DEPRECATED — use history({ action: "list" }) instead] List recent pattern history with timestamps and previews',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: { type: 'number', description: 'Maximum entries to return (default: 10)' },
-            },
-        },
-    },
-    {
-        name: 'restore_history',
-        description: '[DEPRECATED — use history({ action: "restore" }) instead] Restore a previous pattern from history by ID',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'number', description: 'History entry ID to restore' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['id'],
-        },
-    },
-    {
-        name: 'compare_patterns',
-        description: '[DEPRECATED — use history({ action: "compare" }) instead] Compare two patterns from history showing differences',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id1: { type: 'number', description: 'First pattern ID' },
-                id2: { type: 'number', description: 'Second pattern ID (default: current pattern)' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['id1'],
-        },
-    },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 function formatTimeAgo(date) {
@@ -244,12 +197,6 @@ export async function execute(name, args, ctx) {
                     throw new Error(`Invalid action: ${action}. Must be one of: undo, redo, list, restore, compare`);
             }
         }
-        // Deprecated aliases — forward to consolidated handler.
-        case 'undo': return await doUndo(ctx, sid);
-        case 'redo': return await doRedo(ctx, sid);
-        case 'list_history': return doList(args, ctx, sid);
-        case 'restore_history': return await doRestore(args, ctx, sid);
-        case 'compare_patterns': return await doCompare(args, ctx, sid);
         default:
             throw new Error(`history module does not handle tool: ${name}`);
     }

package/dist/server/tools/playback.js

@@ -1,11 +1,7 @@
 /**
  * playback domain — transport controls.
  *
- * Owns one consolidated tool (`playback(action)`) plus three deprecated
- * aliases (play, pause, stop) per #120 / #152.
- *
- * Aliases forward to `playback` and will be removed in a future release
- * per the deprecation policy.
+ * Owns one consolidated tool (`playback(action)`) with play/pause/stop.
  */
 const SESSION_ID_PROP = {
     session_id: {
@@ -35,21 +31,6 @@ export const tools = [
             required: ['action'],
         },
     },
-    {
-        name: 'play',
-        description: '[DEPRECATED — use playback({ action: "play" }) instead] Start playing pattern',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
-    {
-        name: 'pause',
-        description: '[DEPRECATED — use playback({ action: "pause" }) instead] Pause playback',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
-    {
-        name: 'stop',
-        description: '[DEPRECATED — use playback({ action: "stop" }) instead] Stop playback',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 export async function execute(name, args, ctx) {
@@ -58,7 +39,10 @@ export async function execute(name, args, ctx) {
         return 'Browser not initialized. Run init first.';
     }
     const controller = ctx.getController(sid);
-    const action = name === 'playback' ? args?.action : name;
+    if (name !== 'playback') {
+        throw new Error(`playback module does not handle tool: ${name}`);
+    }
+    const action = args?.action;
     switch (action) {
         case 'play':
             return await controller.play();

package/dist/server/tools/session.js

@@ -1,10 +1,9 @@
 /**
  * session domain — multi-session lifecycle management.
  *
- * Owns one consolidated tool (`session(action)`) plus four deprecated
- * aliases (create_session, destroy_session, list_sessions, switch_session)
- * per #120 / #158. `init` stays separate — it's the global bootstrap,
- * not a session operation.
+ * Owns one consolidated tool (`session(action)`) with create/destroy/
+ * list/switch actions. `init` stays separate — it's the global
+ * bootstrap, not a session operation.
  */
 import { InputValidator } from '../../utils/InputValidator.js';
 export const tools = [
@@ -26,38 +25,6 @@ export const tools = [
             required: ['action'],
         },
     },
-    {
-        name: 'create_session',
-        description: '[DEPRECATED — use session({ action: "create" }) instead] Create a new isolated Strudel browser session.',
-        inputSchema: {
-            type: 'object',
-            properties: { session_id: { type: 'string', description: 'Unique identifier for the session' } },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'destroy_session',
-        description: '[DEPRECATED — use session({ action: "destroy" }) instead] Close and destroy a Strudel session.',
-        inputSchema: {
-            type: 'object',
-            properties: { session_id: { type: 'string', description: 'Session identifier to destroy' } },
-            required: ['session_id'],
-        },
-    },
-    {
-        name: 'list_sessions',
-        description: '[DEPRECATED — use session({ action: "list" }) instead] List all active Strudel sessions.',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'switch_session',
-        description: '[DEPRECATED — use session({ action: "switch" }) instead] Change the default session.',
-        inputSchema: {
-            type: 'object',
-            properties: { session_id: { type: 'string', description: 'Session identifier to set as default' } },
-            required: ['session_id'],
-        },
-    },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 async function doCreate(args, ctx) {
@@ -141,11 +108,6 @@ export async function execute(name, args, ctx) {
                     throw new Error(`Invalid action: ${a}. Must be one of: create, destroy, list, switch`);
             }
         }
-        // Deprecated aliases.
-        case 'create_session': return await doCreate(args, ctx);
-        case 'destroy_session': return await doDestroy(args, ctx);
-        case 'list_sessions': return doList(ctx);
-        case 'switch_session': return doSwitch(args, ctx);
         default:
             throw new Error(`session module does not handle tool: ${name}`);
     }

package/dist/server/tools/storage.js

@@ -1,15 +1,7 @@
 /**
  * storage domain — pattern persistence.
  *
- * Owns one consolidated tool (`pattern_store`) plus three deprecated
- * aliases (`save`, `load`, `list`) per the #120 / #143 consolidation.
- *
- * The consolidation also resolves the `list` / `list_sessions` naming
- * collision from #110 — `pattern_store(action='list')` is unambiguous
- * versus `session(action='list')` after the #158 session consolidation.
- *
- * Aliases forward to `pattern_store` and will be removed in a future
- * release per the deprecation policy in #120.
+ * Owns one consolidated tool (`pattern_store`) with save/load/list actions.
  */
 import { InputValidator } from '../../utils/InputValidator.js';
 const SESSION_ID_PROP = {
@@ -43,41 +35,6 @@ export const tools = [
             required: ['action'],
         },
     },
-    {
-        name: 'save',
-        description: '[DEPRECATED — use pattern_store({ action: "save" }) instead] Save pattern with metadata',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Pattern name' },
-                tags: { type: 'array', items: { type: 'string' } },
-                ...SESSION_ID_PROP,
-            },
-            required: ['name'],
-        },
-    },
-    {
-        name: 'load',
-        description: '[DEPRECATED — use pattern_store({ action: "load" }) instead] Load saved pattern',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Pattern name' },
-                ...SESSION_ID_PROP,
-            },
-            required: ['name'],
-        },
-    },
-    {
-        name: 'list',
-        description: '[DEPRECATED — use pattern_store({ action: "list" }) instead] List saved patterns',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                tag: { type: 'string', description: 'Filter by tag' },
-            },
-        },
-    },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
 async function doSave(args, ctx, sid) {
@@ -121,11 +78,6 @@ export async function execute(name, args, ctx) {
             // Unreachable due to enum check above, but TypeScript wants it.
             return undefined;
         }
-        // Aliases — forward to consolidated handler. Kept for ≥1 release per
-        // #120 migration rules; removed afterwards.
-        case 'save': return await doSave(args, ctx, sid);
-        case 'load': return await doLoad(args, ctx, sid);
-        case 'list': return await doList(args, ctx);
         default:
             throw new Error(`storage module does not handle tool: ${name}`);
     }