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

package/dist/server/tools/capture.js

@@ -1,18 +1,19 @@
 /**
  * capture domain — audio recording and MIDI export.
  *
- * Owns (4 tools): start_audio_capture, stop_audio_capture,
- * capture_audio_sample, export_midi.
+ * Owns three tools: `audio_capture(action=start|stop|sample)`,
+ * `export_audio` (records a window and writes a file), and `export_midi`
+ * (kept separate — MIDI is symbolic, audio is waveform).
  *
- * Per the #110 audit, the three audio_capture tools collapse into a
- * single `audio_capture(action=start|stop|sample)` post-split.
- * `export_midi` stays separate — MIDI is symbolic, audio is waveform.
- *
- * The AudioCaptureService is lazy-instantiated module-side: we need
- * the current Playwright page for `injectRecorder()`, and that only
- * exists after `init`. The singleton survives across tool calls.
+ * AudioCaptureService instances are lazy-created per session: we need the
+ * session's Playwright page for `injectRecorder()`, and that only exists
+ * after `init`. The server holds them in a Map keyed by session id (#180),
+ * so each instance survives across tool calls and sessions do not share
+ * a recorder.
  */
+import { categorizeError, err } from './types.js';
 import { InputValidator } from '../../utils/InputValidator.js';
+import { declaredBpm } from '../../utils/Tempo.js';
 // AudioCaptureService lifecycle lives on the server; we fetch a shared
 // instance via ctx.getAudioCaptureService() so tests can mock the class
 // at module boundary without the extractor caching a stale instance.
@@ -27,7 +28,7 @@ function blobToBase64(arrayBuffer) {
 const SESSION_ID_PROP = {
     session_id: {
         type: 'string',
-        description: 'Optional session ID (#108). Routes page reference to the named session. Note: AudioCaptureService is currently server-wide — concurrent captures across sessions will conflict.',
+        description: 'Optional session ID (#108). Routes the capture to the named session, which has its own recorder — concurrent captures across sessions are safe (#180).',
     },
 };
 export const tools = [
@@ -40,13 +41,18 @@ export const tools = [
             'Example: audio_capture({ action: "sample", duration: 3000 }). ' +
             'Audio must be playing for capture to record meaningful data. ' +
             'For MIDI export use export_midi; for runtime diagnostics use diagnostics. ' +
-            'Note: the AudioCaptureService is currently a server-wide singleton — concurrent captures across sessions will conflict.',
+            'Each session has its own recorder, so captures in different sessions do not interfere (#180).',
         inputSchema: {
             type: 'object',
             properties: {
                 action: { type: 'string', enum: ['start', 'stop', 'sample'], description: 'Capture action' },
                 format: { type: 'string', enum: ['webm', 'opus'], description: 'action=start: audio format (default webm)' },
-                maxDuration: { type: 'number', description: 'action=start: maximum capture duration ms' },
+                maxDuration: {
+                    type: 'number',
+                    description: 'action=start: stop the recorder automatically after this many ms. '
+                        + 'Defaults to 600000 (ten minutes); the recording so far is kept and '
+                        + 'returned by a later stop.',
+                },
                 duration: { type: 'number', description: 'action=sample: duration ms (100-60000, default 5000)' },
                 ...SESSION_ID_PROP,
             },
@@ -54,29 +60,21 @@ export const tools = [
         },
     },
     {
-        name: 'start_audio_capture',
-        description: '[DEPRECATED — use audio_capture({ action: "start" }) instead] Start capturing audio. Audio must be playing.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                format: { type: 'string', enum: ['webm', 'opus'], description: 'Audio format (default: webm)' },
-                maxDuration: { type: 'number', description: 'Maximum capture duration in milliseconds' },
-                ...SESSION_ID_PROP,
-            },
-        },
-    },
-    {
-        name: 'stop_audio_capture',
-        description: '[DEPRECATED — use audio_capture({ action: "stop" }) instead] Stop audio capture and return base64-encoded audio.',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
-    {
-        name: 'capture_audio_sample',
-        description: '[DEPRECATED — use audio_capture({ action: "sample" }) instead] Capture a fixed-duration audio sample.',
+        name: 'export_audio',
+        description: 'Record a window of live Strudel audio and write it to a file. ' +
+            'Returns a path plus what was actually recorded, not a wall of base64 — ' +
+            'prefer this over audio_capture when you want the audio to exist somewhere. ' +
+            'format=wav (default) decodes to 16-bit PCM a DAW will open; format=webm writes the raw Opus recording. ' +
+            'Reports silent captures instead of writing a silent file and claiming success. ' +
+            'Audio must already be playing: call playback({ action: "play" }) first. ' +
+            'Example: export_audio({ duration: 4000, filename: "take-01" }).',
         inputSchema: {
             type: 'object',
             properties: {
-                duration: { type: 'number', description: 'Duration in milliseconds (default: 5000)' },
+                duration: { type: 'number', description: 'Window to record in ms (100-30000, default 5000)' },
+                format: { type: 'string', enum: ['wav', 'webm'], description: 'Output format (default wav)' },
+                filename: { type: 'string', description: 'Output filename; reduced to a basename and confined to the export directory' },
+                output: { type: 'string', enum: ['file', 'base64'], description: 'file (default) writes to disk and returns a path; base64 returns bytes inline' },
                 ...SESSION_ID_PROP,
             },
         },
@@ -89,7 +87,7 @@ export const tools = [
             properties: {
                 filename: { type: 'string', description: 'Output filename (optional, default: pattern.mid)' },
                 duration: { type: 'number', description: 'Export duration in bars (default: 4)' },
-                bpm: { type: 'number', description: 'Tempo in BPM (default: 120)' },
+                bpm: { type: 'number', description: "Tempo in BPM (default: the pattern's own tempo, or 120 if it declares none)" },
                 format: { type: 'string', enum: ['file', 'base64'], description: 'Output format: file or base64 (default: base64)' },
                 ...SESSION_ID_PROP,
             },
@@ -113,66 +111,98 @@ export async function execute(name, args, ctx) {
                     throw new Error(`Invalid action: ${a}. Must be one of: start, stop, sample`);
             }
         }
-        case 'start_audio_capture':
-            return await startAudioCapture(args?.format, args?.maxDuration, ctx, sid);
-        case 'stop_audio_capture':
-            return await stopAudioCapture(ctx, sid);
-        case 'capture_audio_sample':
-            return await captureAudioSample(args?.duration, ctx, sid);
+        case 'export_audio':
+            return await exportAudio(args, ctx, sid);
         case 'export_midi':
             return await exportMidi(args?.filename, args?.duration, args?.bpm, args?.format, ctx, sid);
         default:
             throw new Error(`capture module does not handle tool: ${name}`);
     }
 }
-async function startAudioCapture(format, _maxDuration, ctx, sid) {
+async function startAudioCapture(format, maxDuration, ctx, sid) {
     try {
         const service = await ctx.getAudioCaptureService(sid);
         if (service.isCapturing()) {
-            return { success: false, message: 'Audio capture already in progress. Stop it first.' };
+            return err('business', 'Audio capture already in progress. Stop it first.');
         }
-        await service.startCapture(ctx.getController(sid).page, { format });
+        if (maxDuration !== undefined) {
+            InputValidator.validatePositiveInteger(maxDuration, 'maxDuration');
+        }
+        await service.startCapture(ctx.getController(sid).page, { format, maxDuration });
         return {
             success: true,
-            message: 'Audio capture started. Use stop_audio_capture to get the recorded audio.',
-            format: format || 'webm',
+            message: 'Audio capture started. Use audio_capture({ action: "stop" }) to get the recorded audio.',
+            // The mime the recorder actually produces, which is what `stop`
+            // reports. Echoing the requested `format` here meant start said
+            // "opus" and the matching stop said "audio/webm;codecs=opus" for
+            // one recording (#437). MediaRecorder gives a webm container with
+            // an Opus stream either way.
+            format: service.getMimeType(),
         };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        return { success: false, message: `Failed to start audio capture: ${message}` };
+        return err(categorizeError(error), `Failed to start audio capture: ${message}`);
     }
 }
 async function stopAudioCapture(ctx, sid) {
     try {
         const service = await ctx.getAudioCaptureService(sid);
         if (!service.isCapturing()) {
-            return { success: false, message: 'No audio capture in progress. Start capture first.' };
+            // Distinguish "nothing is recording" from "something else is".
+            //
+            // `export_audio` drives the page-side recorder directly and never
+            // touches this service's mirror, so for the whole of an export
+            // this branch answered "No audio capture in progress" — the
+            // opposite of what was happening (#437 item 9). The export is
+            // left to finish on its own; stopping its recorder from here
+            // would leave its own stopCapture with nothing to collect.
+            const page = ctx.getController(sid).page;
+            // Optional-chained, as `server.ts` does for `isInjectedInto`.
+            if (page && (await service.isPageCapturing?.(page)) === true) {
+                return err('business', 'An audio export is recording on this page. It stops on its own when '
+                    + 'its duration elapses; audio_capture cannot end it early.');
+            }
+            return err('business', 'No audio capture in progress. Start capture first.');
         }
         const result = await service.stopCapture(ctx.getController(sid).page);
         const buf = await result.blob.arrayBuffer();
         return {
             success: true,
-            message: `Captured ${result.duration}ms of audio`,
+            // A capture that hit `maxDuration` is shorter than the caller
+            // asked for. Saying so is the whole point of the page computing
+            // it — this handler used to drop it (#464).
+            message: `Captured ${result.duration}ms of audio`
+                + (result.warning ? ` — ${result.warning}` : ''),
             audio: blobToBase64(buf),
             duration: result.duration,
             format: result.format,
+            ...(result.warning ? { warning: result.warning } : {}),
         };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        return { success: false, message: `Failed to stop audio capture: ${message}` };
+        return err(categorizeError(error), `Failed to stop audio capture: ${message}`);
     }
 }
 async function captureAudioSample(duration, ctx, sid) {
-    const durationMs = duration || 5000;
+    // `?? 5000`, not `|| 5000`. Zero is a number the caller passed, and
+    // `||` swallowed it into the default, so `duration: 0` recorded five
+    // seconds instead of being refused by the bound two lines down. The
+    // same shape as every other falsy-vs-absent bug in this repo (#437
+    // item 7).
+    const durationMs = duration ?? 5000;
     if (durationMs < 100 || durationMs > 60000) {
-        return { success: false, message: 'Duration must be between 100ms and 60000ms (1 minute)' };
+        // Validation, not business: the caller passed a number outside the
+        // allowed range, and no amount of setup changes that. My codemod
+        // guessed `business` from the absence of a nearby catch, which is
+        // the same guessing-by-shape this work exists to remove.
+        return err('validation', 'Duration must be between 100ms and 60000ms (1 minute)');
     }
     try {
         const service = await ctx.getAudioCaptureService(sid);
         if (service.isCapturing()) {
-            return { success: false, message: 'Audio capture already in progress. Stop it first.' };
+            return err('business', 'Audio capture already in progress. Stop it first.');
         }
         const result = await service.captureForDuration(ctx.getController(sid).page, durationMs);
         const buf = await result.blob.arrayBuffer();
@@ -186,32 +216,71 @@ async function captureAudioSample(duration, ctx, sid) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        return { success: false, message: `Failed to capture audio sample: ${message}` };
+        return err(categorizeError(error), `Failed to capture audio sample: ${message}`);
+    }
+}
+async function exportAudio(args, ctx, sid) {
+    try {
+        const service = ctx.audioExportService;
+        // Ensures the recorder is injected for this session; export needs the
+        // same GainNode interception audio_capture uses.
+        await ctx.getAudioCaptureService(sid);
+        const result = await service.exportAudio(ctx.getController(sid).page, {
+            duration: args?.duration,
+            format: args?.format,
+            filename: args?.filename,
+            output: args?.output,
+        });
+        if (!result.success) {
+            return { success: false, message: result.error ?? 'Audio export failed.' };
+        }
+        return {
+            ...result,
+            message: result.path
+                ? `Exported ${String(result.bytes)} bytes of ${result.format} to ${result.path}`
+                : `Captured ${String(result.bytes)} bytes of ${result.format}`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return err(categorizeError(error), `Audio export failed: ${message}`);
     }
 }
 async function exportMidi(filename, bars, bpm, format, ctx, sid) {
     if (bpm !== undefined)
         InputValidator.validateBPM(bpm);
     if (bars !== undefined && (bars < 1 || bars > 128)) {
-        return { success: false, message: 'Bars must be between 1 and 128' };
+        return err('validation', 'Bars must be between 1 and 128');
     }
     const pattern = await ctx.getCurrentPatternSafe(sid);
     if (!pattern || pattern.trim().length === 0) {
-        return { success: false, message: 'No pattern to export. Write a pattern first.' };
+        return err('business', 'No pattern to export. Write a pattern first.');
     }
-    const exportOptions = { bpm: bpm || 120, bars: bars || 4 };
+    // The pattern's own tempo, unless the caller asked for a different
+    // one. This used to be a flat `bpm || 120`, so exporting a 174 BPM
+    // pattern wrote a 120 BPM file and a round trip silently rewrote the
+    // tempo — the same guarantee #336 protects for the bar (#399).
+    const exportOptions = { bpm: bpm ?? declaredBpm(pattern) ?? 120, bars: bars ?? 4 };
     const outputFormat = format || 'base64';
     if (outputFormat === 'file') {
         const result = ctx.midiExportService.exportToFile(pattern, filename, exportOptions);
         return {
             success: result.success,
+            // The warning has to reach the caller or computing it in the
+            // service is pointless: this handler builds its own response and
+            // used to drop it, so an export that skipped most of a pattern
+            // still reported "Exported 2 notes" and nothing else (#335).
             message: result.success
                 ? `Exported ${result.noteCount} notes to ${result.output}`
+                    + (result.warning ? ` — ${result.warning}` : '')
                 : result.error || 'Export failed',
             output: result.output,
             noteCount: result.noteCount,
             bars: result.bars,
             bpm: result.bpm,
+            ...(result.warning ? { warning: result.warning } : {}),
+            ...(result.unrepresented ? { unrepresented: result.unrepresented } : {}),
+            ...(result.partiallyExported ? { partiallyExported: result.partiallyExported } : {}),
             error: result.error,
         };
     }
@@ -220,11 +289,15 @@ async function exportMidi(filename, bars, bpm, format, ctx, sid) {
         success: result.success,
         message: result.success
             ? `Exported ${result.noteCount} notes as base64 MIDI data`
+                + (result.warning ? ` — ${result.warning}` : '')
             : result.error || 'Export failed',
         output: result.output,
         noteCount: result.noteCount,
         bars: result.bars,
         bpm: result.bpm,
+        ...(result.warning ? { warning: result.warning } : {}),
+        ...(result.unrepresented ? { unrepresented: result.unrepresented } : {}),
+        ...(result.partiallyExported ? { partiallyExported: result.partiallyExported } : {}),
         error: result.error,
     };
 }

package/dist/server/tools/compose.js

@@ -1,16 +1,10 @@
 /**
  * compose domain — high-level UX tools that aren't a thin verb on a
- * subsystem: `compose` (one-shot generate+write+play) and `show_browser`
- * (bring the Strudel window forward).
- *
- * Post-consolidation (per #110 audit):
- *   - `compose` absorbs `generate_pattern` after the alias period
- *   - `show_browser` merges with `screenshot` into `browser_window`
- * These targets live in different epics (#120). Keeping the two tools
- * together here matches today's "UX Tools" grouping; the file is small
- * enough to split later without disruption.
+ * subsystem: `compose` (one-shot generate+write+play) and
+ * `browser_window` (show or screenshot the Strudel window).
  */
 import { InputValidator } from '../../utils/InputValidator.js';
+import { defaultTempoFor, resolveLayers } from '../../services/StyleRegistry.js';
 const SESSION_ID_PROP = {
     session_id: {
         type: 'string',
@@ -35,18 +29,13 @@ export const tools = [
             required: ['action'],
         },
     },
-    {
-        name: 'show_browser',
-        description: '[DEPRECATED — use browser_window({ action: "show" }) instead] Bring browser window to foreground',
-        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
-    },
     {
         name: 'compose',
         description: 'Generate, write, and play a complete pattern in one step. Auto-initializes default browser if needed.',
         inputSchema: {
             type: 'object',
             properties: {
-                style: { type: 'string', description: 'Genre: techno, house, dnb, ambient, trap, jungle, jazz, experimental' },
+                style: { type: 'string', description: 'Genre: techno, house, dnb, breakbeat, trap, jungle, ambient, experimental, intelligent_dnb, trip_hop, boom_bap. Anything else (jazz included) gets techno drums, and the response says so.' },
                 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)' },
@@ -58,27 +47,6 @@ export const tools = [
     },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
-const TEMPO_BY_STYLE = {
-    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,
-};
-function defaultTempo(style) {
-    return TEMPO_BY_STYLE[style.toLowerCase()] ?? 120;
-}
 async function doShow(ctx, sid) {
     if (!sid && !ctx.isInitialized()) {
         return 'Browser not initialized. Run init first.';
@@ -101,8 +69,6 @@ export async function execute(name, args, ctx) {
             }
             return a === 'show' ? await doShow(ctx, sid) : await doScreenshot(args, ctx, sid);
         }
-        case 'show_browser':
-            return await doShow(ctx, sid);
         case 'compose': {
             InputValidator.validateStringLength(args.style, 'style', 100, false);
             if (args.key) {
@@ -112,13 +78,21 @@ export async function execute(name, args, ctx) {
                 InputValidator.validateBPM(args.tempo);
             }
             // Auto-init only the default session. Named sessions must be
-            // created via `create_session` first — ctx.getController(sid)
+            // created via `session({ action: "create" })` first — ctx.getController(sid)
             // throws if missing, which the dispatcher renders as err('business').
             if (!sid) {
                 await ctx.ensureInitialized();
             }
             const controller = ctx.getController(sid);
-            const tempo = args.tempo || defaultTempo(args.style);
+            // compose assembles four independently-resolved layers, each
+            // falling back on its own. One `style` field cannot describe that
+            // — reporting only the drum resolution called
+            // compose({style:'jazz'}) "techno" while its bassline, Dorian
+            // scale and jazz chords were all genuinely jazz, and let
+            // `breakbeat` claim itself supported over a techno bassline
+            // (#294, correcting #279).
+            const resolution = resolveLayers(args.style);
+            const tempo = args.tempo || defaultTempoFor(args.style);
             const key = args.key || 'C';
             const pattern = ctx.generator.generateCompletePattern(args.style, key, tempo);
             await controller.writePattern(pattern);
@@ -129,9 +103,21 @@ export async function execute(name, args, ctx) {
             const response = {
                 success: true,
                 pattern: pattern.substring(0, 200) + (pattern.length > 200 ? '...' : ''),
-                metadata: { style: args.style, bpm: tempo, key },
+                metadata: {
+                    style: args.style,
+                    bpm: tempo,
+                    key,
+                    layers: resolution.layers,
+                    substituted: resolution.substituted,
+                },
                 status: shouldPlay ? 'playing' : 'ready',
-                message: `Created ${args.style} pattern in ${key}${shouldPlay ? ' - now playing' : ''}`,
+                message: resolution.substituted.length === 0
+                    ? `Created ${args.style} pattern in ${key}${shouldPlay ? ' - now playing' : ''}`
+                    : `Created pattern in ${key}${shouldPlay ? ' - now playing' : ''}. ` +
+                        `No ${resolution.substituted.join(' or ')} defined for style "${args.style}" — ` +
+                        resolution.substituted
+                            .map(l => `${l}: ${resolution.layers[l]}`)
+                            .join(', ') + '.',
             };
             if (args.get_feedback) {
                 if (ctx.geminiService.isAvailable()) {

package/dist/server/tools/diagnostics.js

@@ -2,18 +2,15 @@
  * 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).
  */
+import { empty } from './types.js';
 const SESSION_ID_PROP = {
     session_id: {
         type: 'string',
@@ -24,14 +21,14 @@ export const tools = [
     {
         name: 'diagnostics',
         description: 'Inspect server and browser state. ' +
-            'level=status returns a quick state snapshot (cache read, <15ms SLA). ' +
+            'level=status returns a quick state snapshot (cache read, <15ms SLA), plus which config.json was read and any warnings from it. ' +
             'level=full returns detailed browser diagnostics including caches, errors, and performance. ' +
             'level=perf returns server-side timing metrics + top bottlenecks. ' +
             'level=memory returns process memory usage. ' +
             '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 +41,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) {
@@ -87,7 +53,23 @@ function getMemoryUsage(ctx) {
     return memory ? JSON.stringify(memory, null, 2) : 'Memory usage not available';
 }
 function getStatus(ctx, sid) {
-    return ctx.getController(sid).getStatus();
+    const status = ctx.getController(sid).getStatus();
+    const report = ctx.configReport;
+    if (!report)
+        return status;
+    // Config problems reached `logger.warn` and nothing else — a client
+    // log file the user may never open. A `strudel_url` typo, or an
+    // `audio_analysis` block that parsed to nothing, was invisible from
+    // inside the session. The path is reported whether or not a file was
+    // found, so a cwd surprise is visible rather than guessed at (#442).
+    return {
+        ...(typeof status === 'object' && status !== null ? status : { status }),
+        config: {
+            path: report.path,
+            found: report.found,
+            ...(report.warnings.length > 0 ? { warnings: report.warnings } : {}),
+        },
+    };
 }
 async function getFullDiagnostics(ctx, sid) {
     if (!sid && !ctx.isInitialized()) {
@@ -103,7 +85,7 @@ function getErrors(ctx, sid) {
     const errors = controller.getConsoleErrors();
     const warnings = controller.getConsoleWarnings();
     if (errors.length === 0 && warnings.length === 0) {
-        return 'No errors or warnings captured.';
+        return empty('No errors or warnings captured.');
     }
     let result = '';
     if (errors.length > 0) {
@@ -129,18 +111,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}`);
     }