@mthines/reaper-mcp 0.6.0 → 0.8.0

package/main.js

@@ -1,16 +1,143 @@
 #!/usr/bin/env node
 
 // apps/reaper-mcp-server/src/main.ts
+import { SpanKind as SpanKind3, SpanStatusCode as SpanStatusCode3 } from "@opentelemetry/api";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // apps/reaper-mcp-server/src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SpanKind as SpanKind2, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
+
+// apps/reaper-mcp-server/src/telemetry.ts
+import { trace, metrics } from "@opentelemetry/api";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_NAMESPACE,
+  ATTR_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+var SERVICE_NAME = process.env["OTEL_SERVICE_NAME"] ?? "reaper-mcp-server";
+var SERVICE_NAMESPACE = "reaper-mcp";
+var DEPLOYMENT_ENV = process.env["DEPLOYMENT_ENVIRONMENT"] ?? "development";
+var SCOPE_NAME = "reaper-mcp-server";
+function readServiceVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const __dirname2 = dirname(fileURLToPath(import.meta.url));
+    const pkgPaths = [
+      join(__dirname2, "..", "package.json"),
+      join(__dirname2, "package.json")
+    ];
+    for (const p of pkgPaths) {
+      try {
+        const pkg = require2(p);
+        if (pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "unknown";
+}
+var sdk = null;
+async function initTelemetry() {
+  if (sdk) return;
+  const serviceVersion = readServiceVersion();
+  const resource = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: SERVICE_NAME,
+    [ATTR_SERVICE_NAMESPACE]: SERVICE_NAMESPACE,
+    [ATTR_SERVICE_VERSION]: serviceVersion,
+    "deployment.environment.name": DEPLOYMENT_ENV
+  });
+  sdk = new NodeSDK({ resource });
+  sdk.start();
+  const tracesExporter = process.env["OTEL_TRACES_EXPORTER"] ?? "none";
+  const metricsExporter = process.env["OTEL_METRICS_EXPORTER"] ?? "none";
+  const logsExporter = process.env["OTEL_LOGS_EXPORTER"] ?? "none";
+  const endpoint = process.env["OTEL_EXPORTER_OTLP_ENDPOINT"];
+  const hasExporter = [tracesExporter, metricsExporter, logsExporter].some(
+    (e) => e !== "none" && e !== ""
+  );
+  if (hasExporter) {
+    const signals = [
+      tracesExporter !== "none" && `traces=${tracesExporter}`,
+      metricsExporter !== "none" && `metrics=${metricsExporter}`,
+      logsExporter !== "none" && `logs=${logsExporter}`
+    ].filter(Boolean).join(", ");
+    console.error(`[reaper-mcp] OpenTelemetry enabled (${signals})`);
+    if (endpoint) {
+      console.error(`[reaper-mcp] OTLP endpoint: ${endpoint}`);
+    }
+  } else {
+    console.error(
+      "[reaper-mcp] OpenTelemetry initialized (no exporters configured \u2014 telemetry stays local)"
+    );
+  }
+}
+async function shutdownTelemetry() {
+  if (!sdk) return;
+  try {
+    await sdk.shutdown();
+  } catch (err) {
+    console.error("[reaper-mcp] OTel shutdown error:", err);
+  } finally {
+    sdk = null;
+  }
+}
+function getTracer() {
+  return trace.getTracer(SCOPE_NAME);
+}
+function getMeter() {
+  return metrics.getMeter(SCOPE_NAME);
+}
+function getTraceContext() {
+  const span = trace.getActiveSpan();
+  if (!span) return { trace_id: "", span_id: "" };
+  const ctx = span.spanContext();
+  return { trace_id: ctx.traceId, span_id: ctx.spanId };
+}
+var _commandDurationHistogram = null;
+var _commandCounter = null;
+var _timeoutCounter = null;
+function getCommandDurationHistogram() {
+  if (!_commandDurationHistogram) {
+    _commandDurationHistogram = getMeter().createHistogram(
+      "mcp.bridge.command.duration",
+      {
+        description: "Duration of MCP bridge commands (file IPC round-trip)",
+        unit: "ms"
+      }
+    );
+  }
+  return _commandDurationHistogram;
+}
+function getCommandCounter() {
+  if (!_commandCounter) {
+    _commandCounter = getMeter().createCounter("mcp.bridge.command.count", {
+      description: "Number of MCP bridge commands sent, by type and success"
+    });
+  }
+  return _commandCounter;
+}
+function getTimeoutCounter() {
+  if (!_timeoutCounter) {
+    _timeoutCounter = getMeter().createCounter("mcp.bridge.timeout.count", {
+      description: "Number of MCP bridge commands that timed out waiting for REAPER"
+    });
+  }
+  return _timeoutCounter;
+}
 
 // apps/reaper-mcp-server/src/bridge.ts
 import { randomUUID } from "node:crypto";
 import { readFile, writeFile, readdir, unlink, mkdir, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import { homedir, platform } from "node:os";
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
 var POLL_INTERVAL_MS = 50;
 var DEFAULT_TIMEOUT_MS = 1e4;
 function getReaperResourcePath() {
@@ -19,15 +146,15 @@ function getReaperResourcePath() {
   const home = homedir();
   switch (platform()) {
     case "darwin":
-      return join(home, "Library", "Application Support", "REAPER");
+      return join2(home, "Library", "Application Support", "REAPER");
     case "win32":
-      return join(process.env["APPDATA"] ?? join(home, "AppData", "Roaming"), "REAPER");
+      return join2(process.env["APPDATA"] ?? join2(home, "AppData", "Roaming"), "REAPER");
     default:
-      return join(home, ".config", "REAPER");
+      return join2(home, ".config", "REAPER");
   }
 }
 function getBridgeDir() {
-  return join(getReaperResourcePath(), "Scripts", "mcp_bridge_data");
+  return join2(getReaperResourcePath(), "Scripts", "mcp_bridge_data");
 }
 async function ensureBridgeDir() {
   const dir = getBridgeDir();
@@ -35,40 +162,102 @@ async function ensureBridgeDir() {
   return dir;
 }
 async function sendCommand(type, params = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const dir = await ensureBridgeDir();
-  const id = randomUUID();
-  const command2 = {
-    id,
-    type,
-    params,
-    timestamp: Date.now()
-  };
-  const commandPath = join(dir, `command_${id}.json`);
-  await writeFile(commandPath, JSON.stringify(command2, null, 2), "utf-8");
-  const responsePath = join(dir, `response_${id}.json`);
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      const data = await readFile(responsePath, "utf-8");
-      const response = JSON.parse(data);
-      await Promise.allSettled([unlink(commandPath), unlink(responsePath)]);
-      return response;
-    } catch {
-      await sleep(POLL_INTERVAL_MS);
+  const tracer = getTracer();
+  const startMs = Date.now();
+  return tracer.startActiveSpan(
+    `mcp.bridge ${type}`,
+    {
+      kind: SpanKind.CLIENT,
+      attributes: {
+        "mcp.command.type": type,
+        "mcp.bridge.timeout_ms": timeoutMs
+      }
+    },
+    async (span) => {
+      const dir = await ensureBridgeDir();
+      const id = randomUUID();
+      span.setAttribute("mcp.command.id", id);
+      const command2 = {
+        id,
+        type,
+        params,
+        timestamp: Date.now()
+      };
+      const commandPath = join2(dir, `command_${id}.json`);
+      await writeFile(commandPath, JSON.stringify(command2, null, 2), "utf-8");
+      const traceCtx = getTraceContext();
+      console.error(
+        JSON.stringify({
+          msg: "bridge_command_sent",
+          commandType: type,
+          commandId: id,
+          ...traceCtx
+        })
+      );
+      const responsePath = join2(dir, `response_${id}.json`);
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        try {
+          const data = await readFile(responsePath, "utf-8");
+          const response = JSON.parse(data);
+          await Promise.allSettled([unlink(commandPath), unlink(responsePath)]);
+          const durationMs2 = Date.now() - startMs;
+          const succeeded = response.success;
+          span.setAttribute("mcp.response.success", succeeded);
+          if (!succeeded) {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: response.error ?? "Bridge error" });
+            span.setAttribute("mcp.response.error", response.error ?? "unknown");
+            console.error(
+              JSON.stringify({
+                msg: "bridge_command_error",
+                commandType: type,
+                commandId: id,
+                error: response.error,
+                durationMs: durationMs2,
+                ...traceCtx
+              })
+            );
+          }
+          span.end();
+          getCommandDurationHistogram().record(durationMs2, { command_type: type });
+          getCommandCounter().add(1, { command_type: type, success: String(succeeded) });
+          return response;
+        } catch {
+          await sleep(POLL_INTERVAL_MS);
+        }
+      }
+      await unlink(commandPath).catch(() => {
+      });
+      const durationMs = Date.now() - startMs;
+      const timeoutMsg = `Timeout: no response from REAPER Lua bridge after ${timeoutMs}ms. Is the bridge script running in REAPER?`;
+      span.setAttribute("mcp.response.success", false);
+      span.setAttribute("mcp.response.error", "timeout");
+      span.setStatus({ code: SpanStatusCode.ERROR, message: timeoutMsg });
+      span.end();
+      getCommandDurationHistogram().record(durationMs, { command_type: type });
+      getCommandCounter().add(1, { command_type: type, success: "false" });
+      getTimeoutCounter().add(1, { command_type: type });
+      console.error(
+        JSON.stringify({
+          msg: "bridge_command_timeout",
+          commandType: type,
+          commandId: id,
+          timeoutMs,
+          ...traceCtx
+        })
+      );
+      return {
+        id,
+        success: false,
+        error: timeoutMsg,
+        timestamp: Date.now()
+      };
     }
-  }
-  await unlink(commandPath).catch(() => {
-  });
-  return {
-    id,
-    success: false,
-    error: `Timeout: no response from REAPER Lua bridge after ${timeoutMs}ms. Is the bridge script running in REAPER?`,
-    timestamp: Date.now()
-  };
+  );
 }
 async function isBridgeRunning() {
   const dir = getBridgeDir();
-  const heartbeatPath = join(dir, "heartbeat.json");
+  const heartbeatPath = join2(dir, "heartbeat.json");
   try {
     const info = await stat(heartbeatPath);
     return Date.now() - info.mtimeMs < 5e3;
@@ -84,7 +273,7 @@ async function cleanupStaleFiles(maxAgeMs = 3e4) {
     const now = Date.now();
     for (const file of files) {
       if (!file.startsWith("command_") && !file.startsWith("response_")) continue;
-      const filePath = join(dir, file);
+      const filePath = join2(dir, file);
       const info = await stat(filePath);
       if (now - info.mtimeMs > maxAgeMs) {
         await unlink(filePath).catch(() => {
@@ -97,10 +286,10 @@ async function cleanupStaleFiles(maxAgeMs = 3e4) {
   return cleaned;
 }
 function getReaperScriptsPath() {
-  return join(getReaperResourcePath(), "Scripts");
+  return join2(getReaperResourcePath(), "Scripts");
 }
 function getReaperEffectsPath() {
-  return join(getReaperResourcePath(), "Effects");
+  return join2(getReaperResourcePath(), "Effects");
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -151,11 +340,11 @@ function registerTrackTools(server) {
   );
   server.tool(
     "set_track_property",
-    "Set a track property: volume (dB), pan (-1.0 to 1.0), mute (0/1), or solo (0/1)",
+    "Set a track property: volume (dB), pan (-1.0 to 1.0), mute/solo/recordArm/phase (0/1), input (REAPER input index)",
     {
       trackIndex: z.coerce.number().int().min(0).describe("Zero-based track index"),
-      property: z.enum(["volume", "pan", "mute", "solo"]).describe("Property to set"),
-      value: z.coerce.number().describe("Value: volume in dB, pan -1.0\u20131.0, mute/solo 0 or 1")
+      property: z.enum(["volume", "pan", "mute", "solo", "recordArm", "phase", "input"]).describe("Property to set: volume (dB), pan (-1.0\u20131.0), mute/solo/recordArm/phase (0 or 1), input (REAPER input index, -1=no input)"),
+      value: z.coerce.number().describe("Value: volume in dB, pan -1.0\u20131.0, mute/solo/recordArm/phase 0 or 1, input = REAPER input index")
     },
     async ({ trackIndex, property, value }) => {
       const res = await sendCommand("set_track_property", { trackIndex, property, value });
@@ -233,6 +422,38 @@ function registerFxTools(server) {
       return { content: [{ type: "text", text: `Set FX ${fxIndex} param ${paramIndex} = ${value}` }] };
     }
   );
+  server.tool(
+    "set_fx_enabled",
+    "Enable or disable (bypass) an FX plugin on a track",
+    {
+      trackIndex: z2.coerce.number().int().min(0).describe("Zero-based track index"),
+      fxIndex: z2.coerce.number().int().min(0).describe("Zero-based FX index in the chain"),
+      enabled: z2.coerce.number().int().min(0).max(1).describe("1 = enabled, 0 = disabled (bypassed)")
+    },
+    async ({ trackIndex, fxIndex, enabled }) => {
+      const res = await sendCommand("set_fx_enabled", { trackIndex, fxIndex, enabled });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `FX ${fxIndex} on track ${trackIndex} ${enabled ? "enabled" : "disabled"}` }] };
+    }
+  );
+  server.tool(
+    "set_fx_offline",
+    "Set an FX plugin online or offline. Offline FX uses no CPU but preserves settings.",
+    {
+      trackIndex: z2.coerce.number().int().min(0).describe("Zero-based track index"),
+      fxIndex: z2.coerce.number().int().min(0).describe("Zero-based FX index in the chain"),
+      offline: z2.coerce.number().int().min(0).max(1).describe("1 = offline, 0 = online")
+    },
+    async ({ trackIndex, fxIndex, offline }) => {
+      const res = await sendCommand("set_fx_offline", { trackIndex, fxIndex, offline });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `FX ${fxIndex} on track ${trackIndex} set ${offline ? "offline" : "online"}` }] };
+    }
+  );
 }
 
 // apps/reaper-mcp-server/src/tools/meters.ts
@@ -552,13 +773,30 @@ function registerMidiTools(server) {
   );
   server.tool(
     "get_midi_notes",
-    "Get all MIDI notes in a MIDI item. Returns pitch (0-127, 60=C4), velocity (0-127), position and duration in beats from item start.",
+    "Get MIDI notes in a MIDI item. Supports pagination with offset/limit for large items. For a high-level overview of a large MIDI item, use analyze_midi instead. Returns pitch (0-127, 60=C4), velocity (0-127), position and duration in beats from item start.",
+    {
+      trackIndex: z10.coerce.number().min(0).describe("0-based track index"),
+      itemIndex: z10.coerce.number().min(0).describe("0-based item index on the track"),
+      offset: z10.coerce.number().min(0).optional().describe("Skip first N notes (default 0)"),
+      limit: z10.coerce.number().min(1).optional().describe("Max notes to return (default all). Use with offset to paginate large items.")
+    },
+    async ({ trackIndex, itemIndex, offset, limit }) => {
+      const res = await sendCommand("get_midi_notes", { trackIndex, itemIndex, offset, limit });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "analyze_midi",
+    "Analyze a MIDI item and return summary statistics computed in REAPER. Much more efficient than get_midi_notes for large items. Returns per-pitch stats (count, velocity min/max/avg/stddev), velocity histogram, and machine gun detection (consecutive identical velocities). Use this first to understand the MIDI data before reading individual notes.",
     {
       trackIndex: z10.coerce.number().min(0).describe("0-based track index"),
       itemIndex: z10.coerce.number().min(0).describe("0-based item index on the track")
     },
     async ({ trackIndex, itemIndex }) => {
-      const res = await sendCommand("get_midi_notes", { trackIndex, itemIndex });
+      const res = await sendCommand("analyze_midi", { trackIndex, itemIndex });
       if (!res.success) {
         return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
       }
@@ -595,11 +833,17 @@ function registerMidiTools(server) {
   );
   server.tool(
     "insert_midi_notes",
-    'Batch insert multiple MIDI notes. Pass a JSON array of notes as a string. Each note: { "pitch": 60, "velocity": 100, "startPosition": 0.0, "duration": 1.0, "channel": 0 }. Positions/durations in beats from item start.',
+    "Batch insert multiple MIDI notes in a single call. Pass a native array of note objects. Each note: { pitch, velocity, startPosition, duration, channel? }. Positions/durations in beats from item start (1.0=quarter, 0.5=eighth).",
     {
       trackIndex: z10.coerce.number().min(0).describe("0-based track index"),
       itemIndex: z10.coerce.number().min(0).describe("0-based item index on the track"),
-      notes: z10.string().describe('JSON array string of notes: [{"pitch":60,"velocity":100,"startPosition":0,"duration":1,"channel":0}, ...]')
+      notes: z10.array(z10.object({
+        pitch: z10.coerce.number().min(0).max(127).describe("MIDI note number (60=C4/Middle C)"),
+        velocity: z10.coerce.number().min(1).max(127).describe("Note velocity (1-127)"),
+        startPosition: z10.coerce.number().min(0).describe("Start position in beats from item start"),
+        duration: z10.coerce.number().min(0).describe("Duration in beats (1.0=quarter note)"),
+        channel: z10.coerce.number().min(0).max(15).optional().describe("MIDI channel 0-15 (default 0)")
+      })).describe("Array of notes to insert")
     },
     async ({ trackIndex, itemIndex, notes }) => {
       const res = await sendCommand("insert_midi_notes", { trackIndex, itemIndex, notes });
@@ -639,6 +883,29 @@ function registerMidiTools(server) {
       return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
     }
   );
+  server.tool(
+    "edit_midi_notes",
+    "Batch edit multiple MIDI notes in a single call. Much more efficient than calling edit_midi_note repeatedly. Pass a native array of edit objects, each with noteIndex and any fields to change (pitch, velocity, startPosition, duration, channel). Only provided fields are changed.",
+    {
+      trackIndex: z10.coerce.number().min(0).describe("0-based track index"),
+      itemIndex: z10.coerce.number().min(0).describe("0-based item index on the track"),
+      edits: z10.array(z10.object({
+        noteIndex: z10.coerce.number().min(0).describe("0-based note index to edit"),
+        pitch: z10.coerce.number().min(0).max(127).optional().describe("New pitch (0-127)"),
+        velocity: z10.coerce.number().min(1).max(127).optional().describe("New velocity (1-127)"),
+        startPosition: z10.coerce.number().min(0).optional().describe("New start position in beats from item start"),
+        duration: z10.coerce.number().min(0).optional().describe("New duration in beats"),
+        channel: z10.coerce.number().min(0).max(15).optional().describe("New MIDI channel (0-15)")
+      })).describe("Array of note edits to apply")
+    },
+    async ({ trackIndex, itemIndex, edits }) => {
+      const res = await sendCommand("edit_midi_notes", { trackIndex, itemIndex, edits });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
   server.tool(
     "delete_midi_note",
     "Delete a MIDI note by index from a MIDI item",
@@ -820,6 +1087,30 @@ function registerMediaTools(server) {
       return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
     }
   );
+  server.tool(
+    "set_media_items_properties",
+    "Batch set properties on multiple media items in a single call. Much more efficient than calling set_media_item_properties repeatedly. Pass a native array of item objects, each with trackIndex, itemIndex, and any properties to change.",
+    {
+      items: z11.array(z11.object({
+        trackIndex: z11.coerce.number().min(0).describe("0-based track index"),
+        itemIndex: z11.coerce.number().min(0).describe("0-based item index on the track"),
+        position: z11.coerce.number().min(0).optional().describe("New position in seconds"),
+        length: z11.coerce.number().min(0).optional().describe("New length in seconds"),
+        volume: z11.coerce.number().optional().describe("New volume in dB (0 = unity gain)"),
+        mute: z11.coerce.number().min(0).max(1).optional().describe("Mute state (0=unmuted, 1=muted)"),
+        fadeInLength: z11.coerce.number().min(0).optional().describe("Fade-in length in seconds"),
+        fadeOutLength: z11.coerce.number().min(0).optional().describe("Fade-out length in seconds"),
+        playRate: z11.coerce.number().min(0.1).max(10).optional().describe("Playback rate (1.0=normal)")
+      })).describe("Array of item property updates to apply")
+    },
+    async ({ items }) => {
+      const res = await sendCommand("set_media_items_properties", { items });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
   server.tool(
     "split_media_item",
     "Split a media item at a given position (absolute project time in seconds). Returns info about both resulting items.",
@@ -935,12 +1226,382 @@ function registerMediaTools(server) {
   );
 }
 
+// apps/reaper-mcp-server/src/tools/selection.ts
+import { z as z12 } from "zod/v4";
+function registerSelectionTools(server) {
+  server.tool(
+    "get_selected_tracks",
+    "Get all currently selected tracks in REAPER with their indices and names",
+    {},
+    async () => {
+      const res = await sendCommand("get_selected_tracks");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_time_selection",
+    "Get the current time selection (loop selection) start and end in seconds",
+    {},
+    async () => {
+      const res = await sendCommand("get_time_selection");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "set_time_selection",
+    "Set the time selection (loop selection) to a start and end position in seconds",
+    {
+      start: z12.coerce.number().min(0).describe("Start position in seconds"),
+      end: z12.coerce.number().min(0).describe("End position in seconds")
+    },
+    async ({ start, end }) => {
+      const res = await sendCommand("set_time_selection", { start, end });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Time selection set: ${start}s - ${end}s` }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/markers.ts
+import { z as z13 } from "zod/v4";
+function registerMarkerTools(server) {
+  server.tool(
+    "list_markers",
+    "List all project markers with index, name, position, and color",
+    {},
+    async () => {
+      const res = await sendCommand("list_markers");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_regions",
+    "List all project regions with index, name, start/end positions, and color",
+    {},
+    async () => {
+      const res = await sendCommand("list_regions");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "add_marker",
+    "Add a project marker at a position in seconds, with optional name and color",
+    {
+      position: z13.coerce.number().min(0).describe("Position in seconds"),
+      name: z13.string().optional().describe("Marker name"),
+      color: z13.coerce.number().optional().describe("REAPER native color int (0 = default)")
+    },
+    async ({ position, name, color }) => {
+      const res = await sendCommand("add_marker", { position, name, color });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "add_region",
+    "Add a project region with start/end in seconds, optional name and color",
+    {
+      start: z13.coerce.number().min(0).describe("Region start in seconds"),
+      end: z13.coerce.number().min(0).describe("Region end in seconds"),
+      name: z13.string().optional().describe("Region name"),
+      color: z13.coerce.number().optional().describe("REAPER native color int (0 = default)")
+    },
+    async ({ start, end, name, color }) => {
+      const res = await sendCommand("add_region", { start, end, name, color });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "delete_marker",
+    "Delete a project marker by its marker index number",
+    {
+      markerIndex: z13.coerce.number().int().min(0).describe("Marker index number")
+    },
+    async ({ markerIndex }) => {
+      const res = await sendCommand("delete_marker", { markerIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Deleted marker ${markerIndex}` }] };
+    }
+  );
+  server.tool(
+    "delete_region",
+    "Delete a project region by its region index number",
+    {
+      regionIndex: z13.coerce.number().int().min(0).describe("Region index number")
+    },
+    async ({ regionIndex }) => {
+      const res = await sendCommand("delete_region", { regionIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Deleted region ${regionIndex}` }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/tempo.ts
+function registerTempoTools(server) {
+  server.tool(
+    "get_tempo_map",
+    "Get all tempo and time signature change points in the project (tempo map markers)",
+    {},
+    async () => {
+      const res = await sendCommand("get_tempo_map");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/envelopes.ts
+import { z as z14 } from "zod/v4";
+function registerEnvelopeTools(server) {
+  server.tool(
+    "get_track_envelopes",
+    "List all automation envelopes on a track (volume, pan, mute, FX params, etc.) with point counts",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index")
+    },
+    async ({ trackIndex }) => {
+      const res = await sendCommand("get_track_envelopes", { trackIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_envelope_points",
+    "Get automation points for a track envelope with pagination. Returns time, value, shape, tension per point.",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index"),
+      envelopeIndex: z14.coerce.number().int().min(0).describe("Zero-based envelope index on the track"),
+      offset: z14.coerce.number().int().min(0).optional().describe("Skip first N points (default 0)"),
+      limit: z14.coerce.number().int().min(1).optional().describe("Max points to return (default all)")
+    },
+    async ({ trackIndex, envelopeIndex, offset, limit }) => {
+      const res = await sendCommand("get_envelope_points", { trackIndex, envelopeIndex, offset, limit });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "insert_envelope_point",
+    "Insert an automation point on a track envelope at a given time with value and optional shape/tension",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index"),
+      envelopeIndex: z14.coerce.number().int().min(0).describe("Zero-based envelope index on the track"),
+      time: z14.coerce.number().describe("Time position in seconds"),
+      value: z14.coerce.number().describe("Envelope value (scale depends on envelope type)"),
+      shape: z14.coerce.number().int().min(0).max(5).optional().describe("Shape: 0=linear, 1=square, 2=slow start/end, 3=fast start, 4=fast end, 5=bezier"),
+      tension: z14.coerce.number().min(-1).max(1).optional().describe("Tension for bezier shape (-1.0 to 1.0)")
+    },
+    async ({ trackIndex, envelopeIndex, time, value, shape, tension }) => {
+      const res = await sendCommand("insert_envelope_point", {
+        trackIndex,
+        envelopeIndex,
+        time,
+        value,
+        shape,
+        tension
+      });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "delete_envelope_point",
+    "Delete an automation point from a track envelope by point index",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index"),
+      envelopeIndex: z14.coerce.number().int().min(0).describe("Zero-based envelope index on the track"),
+      pointIndex: z14.coerce.number().int().min(0).describe("Zero-based point index")
+    },
+    async ({ trackIndex, envelopeIndex, pointIndex }) => {
+      const res = await sendCommand("delete_envelope_point", {
+        trackIndex,
+        envelopeIndex,
+        pointIndex
+      });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Deleted envelope point ${pointIndex}` }] };
+    }
+  );
+  server.tool(
+    "create_track_envelope",
+    "Create/show an automation envelope on a track. Use envelopeName for built-in envelopes (Volume, Pan, Mute, Width, Trim Volume) or fxIndex+paramIndex for FX parameter envelopes. The envelope is made visible and active.",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index"),
+      envelopeName: z14.string().optional().describe('Built-in envelope name: "Volume", "Pan", "Mute", "Width", "Trim Volume"'),
+      fxIndex: z14.coerce.number().int().min(0).optional().describe("FX chain index (for FX parameter envelopes)"),
+      paramIndex: z14.coerce.number().int().min(0).optional().describe("FX parameter index (required if fxIndex provided)")
+    },
+    async ({ trackIndex, envelopeName, fxIndex, paramIndex }) => {
+      const res = await sendCommand("create_track_envelope", {
+        trackIndex,
+        envelopeName,
+        fxIndex,
+        paramIndex
+      });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "set_envelope_properties",
+    "Set properties (active, visible, armed) on a track envelope. Requires SWS extension for full support.",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index"),
+      envelopeIndex: z14.coerce.number().int().min(0).describe("Zero-based envelope index on the track"),
+      active: z14.boolean().optional().describe("Set envelope active/inactive"),
+      visible: z14.boolean().optional().describe("Set envelope visible/hidden in arrange view"),
+      armed: z14.boolean().optional().describe("Set envelope armed for writing automation")
+    },
+    async ({ trackIndex, envelopeIndex, active, visible, armed }) => {
+      const res = await sendCommand("set_envelope_properties", {
+        trackIndex,
+        envelopeIndex,
+        active,
+        visible,
+        armed
+      });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "clear_envelope",
+    "Delete ALL automation points from an envelope, resetting it to its default state",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index"),
+      envelopeIndex: z14.coerce.number().int().min(0).describe("Zero-based envelope index on the track")
+    },
+    async ({ trackIndex, envelopeIndex }) => {
+      const res = await sendCommand("clear_envelope", { trackIndex, envelopeIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "remove_envelope_points",
+    "Delete automation points in a time range from a track envelope. Use to surgically remove a section of automation.",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index"),
+      envelopeIndex: z14.coerce.number().int().min(0).describe("Zero-based envelope index on the track"),
+      timeStart: z14.coerce.number().describe("Start of time range in seconds (inclusive)"),
+      timeEnd: z14.coerce.number().describe("End of time range in seconds (exclusive)")
+    },
+    async ({ trackIndex, envelopeIndex, timeStart, timeEnd }) => {
+      const res = await sendCommand("remove_envelope_points", {
+        trackIndex,
+        envelopeIndex,
+        timeStart,
+        timeEnd
+      });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "insert_envelope_points",
+    "Batch insert multiple automation points on a track envelope. Much faster than repeated insert_envelope_point calls.",
+    {
+      trackIndex: z14.coerce.number().int().min(0).describe("Zero-based track index"),
+      envelopeIndex: z14.coerce.number().int().min(0).describe("Zero-based envelope index on the track"),
+      points: z14.string().describe("JSON array of point objects: [{time, value, shape?, tension?}, ...]")
+    },
+    async ({ trackIndex, envelopeIndex, points }) => {
+      const res = await sendCommand("insert_envelope_points", {
+        trackIndex,
+        envelopeIndex,
+        points
+      });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
 // apps/reaper-mcp-server/src/server.ts
+function instrumentToolHandlers(server) {
+  const originalTool = server.tool.bind(server);
+  server.tool = (...args) => {
+    const toolName = args[0];
+    const cbIndex = args.length - 1;
+    const originalCb = args[cbIndex];
+    args[cbIndex] = async (...cbArgs) => {
+      const tracer = getTracer();
+      return tracer.startActiveSpan(
+        `mcp.tool ${toolName}`,
+        { kind: SpanKind2.SERVER, attributes: { "mcp.tool.name": toolName } },
+        async (span) => {
+          try {
+            const result = await originalCb(...cbArgs);
+            const res = result;
+            if (res?.isError) {
+              const errorText = res.content?.[0]?.text ?? "Tool error";
+              span.setStatus({ code: SpanStatusCode2.ERROR, message: errorText });
+              span.setAttribute("mcp.tool.error", errorText);
+            }
+            return result;
+          } catch (err) {
+            const message = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+            span.setStatus({ code: SpanStatusCode2.ERROR, message });
+            throw err;
+          } finally {
+            span.end();
+          }
+        }
+      );
+    };
+    return originalTool(...args);
+  };
+}
 function createServer() {
   const server = new McpServer({
     name: "reaper-mcp",
     version: "0.1.0"
   });
+  instrumentToolHandlers(server);
   registerProjectTools(server);
   registerTrackTools(server);
   registerFxTools(server);
@@ -953,30 +1614,44 @@ function createServer() {
   registerAnalysisTools(server);
   registerMidiTools(server);
   registerMediaTools(server);
+  registerSelectionTools(server);
+  registerMarkerTools(server);
+  registerTempoTools(server);
+  registerEnvelopeTools(server);
   return server;
 }
 
 // apps/reaper-mcp-server/src/main.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join3, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join as join4, dirname as dirname2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { homedir as homedir2 } from "node:os";
 
 // apps/reaper-mcp-server/src/cli.ts
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 function resolveAssetDir(baseDir, name) {
-  const sibling = join2(baseDir, name);
+  const sibling = join3(baseDir, name);
   if (existsSync(sibling)) return sibling;
-  return join2(baseDir, "..", name);
+  const parent = join3(baseDir, "..", name);
+  if (existsSync(parent)) return parent;
+  let dir = baseDir;
+  for (let i = 0; i < 5; i++) {
+    const candidate = join3(dir, name);
+    if (existsSync(candidate)) return candidate;
+    const up = join3(dir, "..");
+    if (up === dir) break;
+    dir = up;
+  }
+  return sibling;
 }
 function copyDirSync(src, dest) {
   if (!existsSync(src)) return 0;
   mkdirSync(dest, { recursive: true });
   let count = 0;
   for (const entry of readdirSync(src)) {
-    const srcPath = join2(src, entry);
-    const destPath = join2(dest, entry);
+    const srcPath = join3(src, entry);
+    const destPath = join3(dest, entry);
     if (statSync(srcPath).isDirectory()) {
       count += copyDirSync(srcPath, destPath);
     } else {
@@ -1054,9 +1729,11 @@ var MCP_TOOL_NAMES = [
   "create_midi_item",
   "list_midi_items",
   "get_midi_notes",
+  "analyze_midi",
   "insert_midi_note",
   "insert_midi_notes",
   "edit_midi_note",
+  "edit_midi_notes",
   "delete_midi_note",
   "get_midi_cc",
   "insert_midi_cc",
@@ -1067,18 +1744,45 @@ var MCP_TOOL_NAMES = [
   "list_media_items",
   "get_media_item_properties",
   "set_media_item_properties",
+  "set_media_items_properties",
   "split_media_item",
   "delete_media_item",
   "move_media_item",
   "trim_media_item",
   "add_stretch_marker",
   "get_stretch_markers",
-  "delete_stretch_marker"
+  "delete_stretch_marker",
+  // selection & navigation
+  "get_selected_tracks",
+  "get_time_selection",
+  "set_time_selection",
+  // markers & regions
+  "list_markers",
+  "list_regions",
+  "add_marker",
+  "add_region",
+  "delete_marker",
+  "delete_region",
+  // tempo map
+  "get_tempo_map",
+  // fx enable/offline
+  "set_fx_enabled",
+  "set_fx_offline",
+  // envelopes
+  "get_track_envelopes",
+  "get_envelope_points",
+  "insert_envelope_point",
+  "insert_envelope_points",
+  "delete_envelope_point",
+  "create_track_envelope",
+  "set_envelope_properties",
+  "clear_envelope",
+  "remove_envelope_points"
 ];
 function ensureClaudeSettings(settingsPath) {
   const allowList = MCP_TOOL_NAMES.map((t) => `mcp__reaper__${t}`);
   if (!existsSync(settingsPath)) {
-    mkdirSync(join2(settingsPath, ".."), { recursive: true });
+    mkdirSync(join3(settingsPath, ".."), { recursive: true });
     const config = { permissions: { allow: allowList } };
     writeFileSync(settingsPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     return "created";
@@ -1095,7 +1799,7 @@ function ensureClaudeSettings(settingsPath) {
 }
 
 // apps/reaper-mcp-server/src/main.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath2(import.meta.url));
 async function setup() {
   console.log("REAPER MCP Server \u2014 Setup\n");
   const bridgeDir = await ensureBridgeDir();
@@ -1104,23 +1808,23 @@ async function setup() {
   const scriptsDir = getReaperScriptsPath();
   mkdirSync2(scriptsDir, { recursive: true });
   const reaperDir = resolveAssetDir(__dirname, "reaper");
-  const luaSrc = join3(reaperDir, "mcp_bridge.lua");
-  const luaDest = join3(scriptsDir, "mcp_bridge.lua");
+  const luaSrc = join4(reaperDir, "mcp_bridge.lua");
+  const luaDest = join4(scriptsDir, "mcp_bridge.lua");
   console.log("Installing Lua bridge...");
   if (installFile(luaSrc, luaDest)) {
     console.log(`  Installed: mcp_bridge.lua`);
   } else {
     console.log(`  Not found: ${luaSrc}`);
   }
-  const effectsDir = getReaperEffectsPath();
+  const effectsDir = join4(getReaperEffectsPath(), "reaper-mcp");
   mkdirSync2(effectsDir, { recursive: true });
   console.log("\nInstalling JSFX analyzers...");
   for (const jsfx of REAPER_ASSETS) {
     if (jsfx === "mcp_bridge.lua") continue;
-    const src = join3(reaperDir, jsfx);
-    const dest = join3(effectsDir, jsfx);
+    const src = join4(reaperDir, jsfx);
+    const dest = join4(effectsDir, jsfx);
     if (installFile(src, dest)) {
-      console.log(`  Installed: ${jsfx}`);
+      console.log(`  Installed: reaper-mcp/${jsfx}`);
     } else {
       console.log(`  Not found: ${src}`);
     }
@@ -1133,70 +1837,66 @@ async function setup() {
   console.log("  4. Run the script (it will keep running in background via defer loop)");
   console.log("  5. Add reaper-mcp to your Claude Code config (see: npx @mthines/reaper-mcp doctor)");
 }
-async function installSkills() {
-  console.log("REAPER MCP \u2014 Install AI Mix Engineer Skills\n");
-  const targetDir = process.cwd();
-  const globalClaudeDir = join3(homedir2(), ".claude");
+function parseInstallScope(args) {
+  if (args.includes("--project")) return "project";
+  return "global";
+}
+async function installSkills(scope) {
+  console.log(`REAPER MCP \u2014 Install AI Mix Engineer Skills (scope: ${scope})
+`);
+  const isGlobal = scope === "global";
+  const baseDir = isGlobal ? join4(homedir2(), ".claude") : process.cwd();
+  const claudeDir = isGlobal ? baseDir : join4(baseDir, ".claude");
   const knowledgeSrc = resolveAssetDir(__dirname, "knowledge");
-  const knowledgeDest = join3(targetDir, "knowledge");
   if (existsSync2(knowledgeSrc)) {
-    const count = copyDirSync(knowledgeSrc, knowledgeDest);
-    console.log(`Installed knowledge base: ${count} files \u2192 ${knowledgeDest}`);
+    const dest = join4(baseDir, "knowledge");
+    const count = copyDirSync(knowledgeSrc, dest);
+    console.log(`Installed knowledge base: ${count} files \u2192 ${dest}`);
   } else {
     console.log("Knowledge base not found in package. Skipping.");
   }
   const rulesSrc = resolveAssetDir(__dirname, "claude-rules");
-  const rulesDir = join3(targetDir, ".claude", "rules");
   if (existsSync2(rulesSrc)) {
-    const count = copyDirSync(rulesSrc, rulesDir);
-    console.log(`Installed Claude rules: ${count} files \u2192 ${rulesDir}`);
+    const dest = join4(claudeDir, "rules");
+    const count = copyDirSync(rulesSrc, dest);
+    console.log(`Installed Claude rules: ${count} files \u2192 ${dest}`);
   } else {
     console.log("Claude rules not found in package. Skipping.");
   }
   const skillsSrc = resolveAssetDir(__dirname, "claude-skills");
-  const skillsDir = join3(targetDir, ".claude", "skills");
   if (existsSync2(skillsSrc)) {
-    const count = copyDirSync(skillsSrc, skillsDir);
-    console.log(`Installed Claude skills: ${count} files \u2192 ${skillsDir}`);
+    const dest = join4(claudeDir, "skills");
+    const count = copyDirSync(skillsSrc, dest);
+    console.log(`Installed Claude skills: ${count} files \u2192 ${dest}`);
   } else {
     console.log("Claude skills not found in package. Skipping.");
   }
   const agentsSrc = resolveAssetDir(__dirname, "claude-agents");
-  const agentsDir = join3(targetDir, ".claude", "agents");
   if (existsSync2(agentsSrc)) {
-    const count = copyDirSync(agentsSrc, agentsDir);
-    console.log(`Installed Claude agents: ${count} files \u2192 ${agentsDir}`);
+    const dest = join4(claudeDir, "agents");
+    const count = copyDirSync(agentsSrc, dest);
+    console.log(`Installed Claude agents: ${count} files \u2192 ${dest}`);
   } else {
     console.log("Claude agents not found in package. Skipping.");
   }
-  const globalAgentsDir = join3(globalClaudeDir, "agents");
-  if (existsSync2(agentsSrc)) {
-    const count = copyDirSync(agentsSrc, globalAgentsDir);
-    console.log(`Installed Claude agents (global): ${count} files \u2192 ${globalAgentsDir}`);
-  }
-  const localSettingsPath = join3(targetDir, ".claude", "settings.json");
-  const localResult = ensureClaudeSettings(localSettingsPath);
-  if (localResult === "created") {
-    console.log(`Created Claude settings: ${localSettingsPath}`);
-  } else if (localResult === "updated") {
-    console.log(`Updated Claude settings with new REAPER tools: ${localSettingsPath}`);
+  const settingsPath = join4(claudeDir, "settings.json");
+  const result = ensureClaudeSettings(settingsPath);
+  if (result === "created") {
+    console.log(`Created Claude settings: ${settingsPath}`);
+  } else if (result === "updated") {
+    console.log(`Updated Claude settings with new REAPER tools: ${settingsPath}`);
   } else {
-    console.log(`Claude settings already has all REAPER tools: ${localSettingsPath}`);
-  }
-  const globalSettingsPath = join3(globalClaudeDir, "settings.json");
-  const globalResult = ensureClaudeSettings(globalSettingsPath);
-  if (globalResult === "created") {
-    console.log(`Created Claude settings (global): ${globalSettingsPath}`);
-  } else if (globalResult === "updated") {
-    console.log(`Updated Claude settings (global) with new REAPER tools: ${globalSettingsPath}`);
+    console.log(`Claude settings already has all REAPER tools: ${settingsPath}`);
   }
-  const mcpJsonPath = join3(targetDir, ".mcp.json");
-  if (createMcpJson(mcpJsonPath)) {
-    console.log(`
+  if (!isGlobal) {
+    const mcpJsonPath = join4(baseDir, ".mcp.json");
+    if (createMcpJson(mcpJsonPath)) {
+      console.log(`
 Created: ${mcpJsonPath}`);
-  } else {
-    console.log(`
+    } else {
+      console.log(`
 .mcp.json already exists \u2014 add the reaper server config manually if needed.`);
+    }
   }
   console.log("\nDone! Claude Code now has mix engineer agents, knowledge, and REAPER MCP tools.");
   console.log("All 48 REAPER tools are pre-approved \u2014 agents work autonomously.");
@@ -1210,20 +1910,27 @@ async function doctor() {
   if (!bridgeRunning) {
     console.log('  \u2192 Run "npx @mthines/reaper-mcp setup" then load mcp_bridge.lua in REAPER');
   }
-  const agentsExist = existsSync2(join3(process.cwd(), ".claude", "agents"));
-  console.log(`Mix agents:    ${agentsExist ? "\u2713 Found (.claude/agents/)" : "\u2717 Not installed"}`);
+  const globalClaudeDir = join4(homedir2(), ".claude");
+  const localAgents = existsSync2(join4(process.cwd(), ".claude", "agents"));
+  const globalAgents = existsSync2(join4(globalClaudeDir, "agents"));
+  const agentsExist = localAgents || globalAgents;
+  const agentsLocation = localAgents ? ".claude/agents/" : globalAgents ? "~/.claude/agents/" : "";
+  console.log(`Mix agents:    ${agentsExist ? `\u2713 Found (${agentsLocation})` : "\u2717 Not installed"}`);
   if (!agentsExist) {
-    console.log('  \u2192 Run "npx @mthines/reaper-mcp install-skills" in your project directory');
+    console.log('  \u2192 Run "npx @mthines/reaper-mcp install-skills"');
   }
-  const knowledgeExists = existsSync2(join3(process.cwd(), "knowledge"));
-  console.log(`Knowledge base: ${knowledgeExists ? "\u2713 Found in project" : "\u2717 Not installed"}`);
+  const localKnowledge = existsSync2(join4(process.cwd(), "knowledge"));
+  const globalKnowledge = existsSync2(join4(globalClaudeDir, "knowledge"));
+  const knowledgeExists = localKnowledge || globalKnowledge;
+  const knowledgeLocation = localKnowledge ? "project" : globalKnowledge ? "~/.claude/" : "";
+  console.log(`Knowledge base: ${knowledgeExists ? `\u2713 Found (${knowledgeLocation})` : "\u2717 Not installed"}`);
   if (!knowledgeExists) {
-    console.log('  \u2192 Run "npx @mthines/reaper-mcp install-skills" in your project directory');
+    console.log('  \u2192 Run "npx @mthines/reaper-mcp install-skills"');
   }
-  const mcpJsonExists = existsSync2(join3(process.cwd(), ".mcp.json"));
+  const mcpJsonExists = existsSync2(join4(process.cwd(), ".mcp.json"));
   console.log(`MCP config:    ${mcpJsonExists ? "\u2713 .mcp.json found" : "\u2717 .mcp.json missing"}`);
   if (!mcpJsonExists) {
-    console.log('  \u2192 Run "npx @mthines/reaper-mcp install-skills" to create .mcp.json');
+    console.log('  \u2192 Run "npx @mthines/reaper-mcp install-skills --project" to create .mcp.json');
   }
   console.log('\nTo check SWS Extensions, start REAPER and use the "list_available_fx" tool.');
   console.log("SWS provides enhanced plugin discovery and snapshot support.\n");
@@ -1231,25 +1938,53 @@ async function doctor() {
 }
 async function serve() {
   const log = (...args) => console.error("[reaper-mcp]", ...args);
+  await initTelemetry();
   log("Starting REAPER MCP Server...");
-  log(`Entry: ${fileURLToPath(import.meta.url)}`);
-  await ensureBridgeDir();
-  const cleaned = await cleanupStaleFiles();
-  if (cleaned > 0) {
-    log(`Cleaned up ${cleaned} stale bridge files`);
-  }
-  const bridgeRunning = await isBridgeRunning();
-  if (!bridgeRunning) {
-    log("WARNING: Lua bridge does not appear to be running in REAPER.");
-    log("Commands will timeout until the bridge script is started.");
-    log('Run "npx @mthines/reaper-mcp setup" for installation instructions.');
-  } else {
-    log("Lua bridge detected \u2014 connected to REAPER");
-  }
-  const server = createServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  log("MCP server connected via stdio");
+  log(`Entry: ${fileURLToPath2(import.meta.url)}`);
+  const tracer = getTracer();
+  await tracer.startActiveSpan("mcp.server.startup", { kind: SpanKind3.INTERNAL }, async (startupSpan) => {
+    try {
+      await ensureBridgeDir();
+      const cleaned = await cleanupStaleFiles();
+      if (cleaned > 0) {
+        startupSpan.setAttribute("mcp.bridge.stale_files_cleaned", cleaned);
+        log(`Cleaned up ${cleaned} stale bridge files`);
+      }
+      const bridgeRunning = await tracer.startActiveSpan("mcp.bridge.connect", { kind: SpanKind3.INTERNAL }, async (bridgeSpan) => {
+        const running = await isBridgeRunning();
+        bridgeSpan.setAttribute("mcp.bridge.connected", running);
+        if (!running) {
+          bridgeSpan.setStatus({
+            code: SpanStatusCode3.UNSET,
+            message: "Lua bridge not detected \u2014 commands will timeout until started"
+          });
+          log("WARNING: Lua bridge does not appear to be running in REAPER.");
+          log("Commands will timeout until the bridge script is started.");
+          log('Run "npx @mthines/reaper-mcp setup" for installation instructions.');
+        } else {
+          bridgeSpan.setStatus({ code: SpanStatusCode3.OK });
+          log("Lua bridge detected \u2014 connected to REAPER");
+        }
+        bridgeSpan.end();
+        return running;
+      });
+      startupSpan.setAttribute("mcp.bridge.connected", bridgeRunning);
+      const server = createServer();
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+      startupSpan.setStatus({ code: SpanStatusCode3.OK });
+      log("MCP server connected via stdio");
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      startupSpan.setStatus({
+        code: SpanStatusCode3.ERROR,
+        message: `${err.name}: ${err.message}`
+      });
+      throw error;
+    } finally {
+      startupSpan.end();
+    }
+  });
 }
 var command = process.argv[2];
 switch (command) {
@@ -1260,7 +1995,7 @@ switch (command) {
     });
     break;
   case "install-skills":
-    installSkills().catch((err) => {
+    installSkills(parseInstallScope(process.argv.slice(3))).catch((err) => {
       console.error("Install failed:", err);
       process.exit(1);
     });
@@ -1293,14 +2028,16 @@ Usage:
   npx @mthines/reaper-mcp                  Start MCP server (stdio mode)
   npx @mthines/reaper-mcp serve            Start MCP server (stdio mode)
   npx @mthines/reaper-mcp setup            Install Lua bridge + JSFX analyzers into REAPER
-  npx @mthines/reaper-mcp install-skills   Install AI mix engineer knowledge + agents into your project
+  npx @mthines/reaper-mcp install-skills   Install AI knowledge + agents globally (default)
+  npx @mthines/reaper-mcp install-skills --project  Install into current project directory
+  npx @mthines/reaper-mcp install-skills --global   Install into ~/.claude/ (default)
   npx @mthines/reaper-mcp doctor           Check that everything is configured correctly
   npx @mthines/reaper-mcp status           Check if Lua bridge is running in REAPER
 
 Quick Start:
   1. npx @mthines/reaper-mcp setup            # install REAPER components
   2. Load mcp_bridge.lua in REAPER (Actions > Load ReaScript > Run)
-  3. npx @mthines/reaper-mcp install-skills   # install AI knowledge + agents
+  3. npx @mthines/reaper-mcp install-skills   # install AI knowledge + agents (globally)
   4. Open Claude Code \u2014 REAPER tools + mix engineer agents are ready
 
 Tip: install globally for shorter commands:
@@ -1311,10 +2048,18 @@ Tip: install globally for shorter commands:
 }
 process.on("SIGINT", () => {
   console.error("[reaper-mcp] Interrupted");
-  process.exit(0);
+  shutdownTelemetry().finally(() => process.exit(0));
 });
 process.on("SIGTERM", () => {
   console.error("[reaper-mcp] Terminated");
-  process.exit(0);
+  shutdownTelemetry().finally(() => process.exit(0));
+});
+process.on("uncaughtException", (err) => {
+  console.error("[reaper-mcp] Uncaught exception:", err);
+  shutdownTelemetry().finally(() => process.exit(1));
+});
+process.on("unhandledRejection", (reason) => {
+  console.error("[reaper-mcp] Unhandled rejection:", reason);
+  shutdownTelemetry().finally(() => process.exit(1));
 });
 //# sourceMappingURL=main.js.map