@map-audio/pam-mcp-server 1.25.0 → 1.28.0

package/dist/server.js

@@ -4,26 +4,28 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { completable } from "@modelcontextprotocol/sdk/server/completable.js";
 import { z } from "zod";
 import { buildVariationSnapshotBase } from "./generated/variationSnapshot.js";
+import { CELL_CONFIG_KV_OPTIONS, EFFECT_CONFIG_KV_OPTIONS, MASTER_CONFIG_KV_OPTIONS, PATTERN_EDIT_KV_OPTIONS, STATE_UPDATE_KV_OPTIONS, } from "./generated/kvWriteOptions.js";
 import { CORPUS_META, CORPUS_RANGES } from "./corpusRanges.js";
 import { CORPUS_FINGERPRINTS, CORPUS_NOVELTY_BASELINE, CORPUS_VARIATION_BASELINE } from "./corpusFingerprints.js";
 import { buildFingerprint, scoreNovelty, similarity as fingerprintSimilarity } from "./fingerprint.js";
 import { analyzeMotion, decodeWav } from "./audioAnalysis.js";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { inflateSync } from "node:zlib";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createDrumSynthCatalog, } from "./drumSynth.js";
-import { loadManifest, cellEffectNames, cellEffectOrder, getParameterIndex, getParametersByCell, getGlobalParameters, findPresetDirs, resolvePresetPath, setActiveProductHint, walkPresets, } from "./manifest.js";
+import { loadManifest, cellEffectNames, cellEffectOrder, getParameterIndex, getParametersByCell, getGlobalParameters, findPresetDirs, resolvePresetPath, productExportDir, setActiveProductHint, walkPresets, } from "./manifest.js";
 import { PluginBridge } from "./bridge.js";
+import { LANE_TARGET_FIELD, PATTERN_LANE_IDS, PATTERN_LANE_SUFFIX, CC_LANES, PARAM_LANES, ccLaneMayLand, ccLaneIndex, ccLaneSlotField, ccLaneSlotOf, CC_OUT_CONFIG_KEYS, CC_OUT_SLOTS, isCcLane, isCcOutValueSuffix, isParamLane, normalizeCcLaneEvents, normalizeTargetLaneEvents, productHasLane, resolveLaneTarget, } from "./patternLanes.js";
 import { buildMixMeasurementFromState, currentFlatFromState, parseMixAnalysisPayload, suggestMix, } from "./mixAssist.js";
-import { normalizePresetLookupPath, parsePresetFile, selectSaveVariationSourcePath, } from "./presetSave.js";
-import { STOP_SEQUENCES, buildGenerationPrompt, parseFunctionCalls, renderContextLine, renderFunctionCall, renderFunctionResponse, truncateAtFabricatedResponse, withContext, } from "./fgemma-format.js";
+import { isFactoryPresetPath, nativePresetPath, normalizePresetLookupPath, parsePresetFile, selectSaveVariationSourcePath, } from "./presetSave.js";
+import { STOP_SEQUENCES, buildGenerationPrompt, parseFunctionCalls, renderContextLine, renderFunctionCall, renderFunctionResponse, truncateAtFabricatedResponse, withContext, } from "./functiongemma-format.js";
 import { mcpProductProfile } from "./productProfile.js";
-import { MFX_COMBO_COUNT, MFX_COMBO_MANUAL_STRENGTH, buildMfxComboTarget, isMfxComboTargetParameter, mfxComboTargetValueFromCurrent, parseMfxComboSlots, reanchorMfxComboTarget, resolveMfxCombos, setMfxComboTargetStop, } from "./mfxCombos.js";
-import { GENERATIVE_PLAYERS, LISTEN_MODES, MODULATABLE_PLAYER_FIELDS, NO_POLY_ARM, PATTERN_MODES, PLAYER_GENRES, PLAYER_NAMES, PLAYER_SLOT_FIELDS, cellPlayerType, describeCellPlayer, describePlayerSpec, getPlayerSpec, isMelodicPlayer, playerDefaultsFor, playerDensityDisplay, playerGenreConfig, playerMutateDisplay, playerPresetsFor, playerSlotDisplay, presetConfig, randomPlayerSeed, resolvePlayerPreset, resolvePlayerSpec, resolveSlotValue, rolePlayerConfigFor, roleSpreadSummary, snapPlayerValue, } from "./players.js";
-import { buildMidiFile, patternSpeedMultiplier, tilePatternEvents } from "./midiFile.js";
+import { MFX_COMBO_COUNT, MFX_COMBO_MANUAL_STRENGTH, buildMfxComboTarget, isMfxComboTargetParameter, mfxComboTargetValueFromCurrent, mfxComboTargetValueAfterRangeEdit, parseMfxComboSlots, reanchorMfxComboTarget, resolveMfxCombos, setMfxComboTargetStop, } from "./mfxCombos.js";
+import { GENERATIVE_PLAYERS, LISTEN_MODES, LISTEN_PAIRS, MODULATABLE_PLAYER_FIELDS, NO_POLY_ARM, NO_SCALE_ARM, PATTERN_MODES, PLAYER_GENRES, PLAYER_GRIDS, PLAYER_NAMES, PLAYER_SLOT_FIELDS, cellPlayerType, describeCellPlayer, describePlayerSpec, getPlayerSpec, isMelodicPlayer, crowdedComplementCell, listenPartnerFor, soleComplementPartner, playerDefaultsFor, playerDensityDisplay, playerGenreConfig, playerGridValue, playerMutateDisplay, playerPresetsFor, playerSlotDisplay, presetConfig, randomPlayerSeed, resolvePlayerPreset, resolvePlayerSpec, resolveSlotValue, rolePlayerConfigFor, roleSpreadSummary, snapPlayerValue, } from "./players.js";
+import { beatsPerBar, buildMidiFile, patternSpeedMultiplier, tilePatternEvents } from "./midiFile.js";
 import { MAX_SLICES, detectOnsetBoundaries, equalBoundaries, normalizeBoundaries } from "./sampleSlicing.js";
 // --- State ---
 // Variation slot count. Must stay in sync with PRESET_VARIATION_SLOTS in
@@ -32,7 +34,56 @@ import { MAX_SLICES, detectOnsetBoundaries, equalBoundaries, normalizeBoundaries
 const PRESET_VARIATION_SLOTS = 8;
 const SERVER_PRODUCT = mcpProductProfile();
 const IS_MFX_SERVER = SERVER_PRODUCT.id === "mfx";
+const IS_MSQ_SERVER = SERVER_PRODUCT.id === "msq";
+// A product launcher attaches to its own product only; pam-mcp follows whichever instance is connected.
+const PINNED_PRODUCT = IS_MFX_SERVER || IS_MSQ_SERVER ? SERVER_PRODUCT.id : undefined;
+if (PINNED_PRODUCT)
+    process.env.PAM_BRIDGE_PRODUCT = SERVER_PRODUCT.name;
+const DAEMON_SESSION = process.argv.includes("--pamd-session");
+function sessionOption(name) {
+    return process.argv.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3);
+}
+const SESSION_DATA_ROOT = sessionOption("data-root");
+const SESSION_OUTPUT_DIR = sessionOption("out-dir");
+const SESSION_DISCOVERY = sessionOption("discovery-file");
+for (const [name, path] of [["data-root", SESSION_DATA_ROOT], ["out-dir", SESSION_OUTPUT_DIR], ["discovery-file", SESSION_DISCOVERY]])
+    if (path && !isAbsolute(path))
+        throw new Error(`${name} must be absolute`);
+if (SESSION_DATA_ROOT)
+    process.env.PAM_AI_DATA_ROOT = SESSION_DATA_ROOT;
+if (DAEMON_SESSION && (!SESSION_DATA_ROOT || !SESSION_OUTPUT_DIR || !SESSION_DISCOVERY))
+    throw new Error("pamd session requires captured data-root, out-dir and discovery-file");
+// Loaded only for pam mcp sessions, so the plugin-only server starts without a built pamd client.
+const daemon = DAEMON_SESSION
+    ? new (await import("./daemon.js")).DaemonSession(SESSION_DISCOVERY, SESSION_DATA_ROOT, SESSION_OUTPUT_DIR) : undefined;
+const daemonDownloads = new Map();
+function daemonModel(engine, model) {
+    if (engine === "aigen")
+        return "stable-audio-3-small-sfx";
+    if (engine === "magenta")
+        return model === "base" ? "mrt2-base" : "mrt2-small";
+    throw new Error("unsupported_model: notochord remains managed by the plugin");
+}
 const bridge = new PluginBridge();
+async function pinnedGeneration(args, pinned, signal) {
+    const destination = pinned ?? new PluginBridge();
+    const instance = bridge.getConnectedInstance();
+    if (!pinned && (!instance || !await destination.connect({ instanceId: instance.instanceId, product: instance.product })))
+        throw new Error("plugin_unavailable: selected instance disconnected");
+    try {
+        const result = await daemon.generate(args, signal);
+        if (args.cellId !== undefined) {
+            if (typeof result.wavPath !== "string" || !isAbsolute(result.wavPath))
+                throw new Error("invalid_result: generated WAV path missing");
+            await destination.send("loadSampleToCell", result.wavPath, args.cellId);
+        }
+        return result;
+    }
+    finally {
+        if (!pinned)
+            destination.disconnect();
+    }
+}
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const cellModeChangeSeq = {};
 let lastSavedPresetName;
@@ -73,12 +124,96 @@ function structuredFromBridge(raw) {
 function error(msg) {
     return { content: [{ type: "text", text: msg }], isError: true };
 }
+function daemonFailureCode(cause) {
+    try {
+        const detail = JSON.parse(cause instanceof Error ? cause.message : String(cause));
+        return isRecord(detail) && typeof detail.code === "string" ? detail.code : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const LOST_DAEMON_JOB = new Set(["job_expired", "not_found", "daemon_restarted", "unavailable"]);
+function daemonFailure(cause, prefix = "") {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    const result = error(prefix + message);
+    try {
+        const detail = JSON.parse(message);
+        if (isRecord(detail) && detail.ok === false && typeof detail.code === "string" && typeof detail.error === "string")
+            return { ...result, structuredContent: detail };
+    }
+    catch { }
+    return result;
+}
 function isMfxManifest(manifest) {
     return (manifest.name?.toLowerCase() === "mfx" ||
         manifest.bundleId?.toLowerCase() === "map.audio.mfx" ||
         manifest.pluginCode?.toLowerCase() === "amfx");
 }
-const MFX_CELL_CONFIG_KEYS = new Set(["sidechainFrom"]);
+function isMsqManifest(manifest) {
+    return (manifest.name?.toLowerCase() === "msq" ||
+        manifest.bundleId?.toLowerCase() === "map.audio.msq" ||
+        manifest.pluginCode?.toLowerCase() === "amsq");
+}
+const PACK_TOOL_NAMES = new Set(["list_packs", "install_pack", "get_pack_install_status", "uninstall_pack"]);
+// MSQ sequences MIDI only. These tools drive a part of PAM it does not have, so on an
+// MSQ instance they answer with the reason instead of writing state nothing reads.
+const MSQ_MISSING_BY_TOOL = new Map([
+    ...[
+        "load_sample", "randomize_samples", "trim_sample", "reverse_sample", "normalize_sample", "gain_sample",
+        "analyze_sample_pitch", "repitch_sample", "analyze_sample_tempo", "get_sample_peaks", "preview_slice",
+        "resample_sample_to_bpm", "restore_original_sample", "build_sample_chain", "export_slice", "set_slices",
+        "preview_sample", "get_sample_usage", "repair_preset_samples", "set_drum_synth", "set_drum_synth_wave",
+        "set_lane_target",
+    ].map((tool) => [tool, "sampler"]),
+    ...["update_effect_config", "set_effects_enabled", "set_effect_order", "set_spectral_delay_curve"].map((tool) => [tool, "cell effects"]),
+    ...["set_master_effects", "get_master_analysis", "get_mix_analysis", "suggest_mix", "set_metronome"].map((tool) => [tool, "audio output"]),
+    ...["export_audio", "export_song", "song_mode", "live_resample"].map((tool) => [tool, "audio render or Song Mode"]),
+    ["dj_set", "DJ view"],
+    ...[
+        "arm_looper_track", "set_looper_track", "clear_looper_track", "set_looper_track_selection",
+        "start_looper_recording", "stop_looper_recording", "capture_looper_now", "load_audio_to_looper_track",
+        "request_looper_warp", "looper_settings", "looper_variation", "looper_variation_sync",
+    ].map((tool) => [tool, "looper"]),
+    ...[
+        "set_visual", "list_visuals", "delete_visual", "get_visual_data_url", "import_visual_folder", "get_video_state",
+        "video_command", "add_video_layer", "update_video_layer", "set_video_layer_source", "remove_video_layer",
+        "apply_video_layout", "add_video_fx", "set_video_fx", "remove_video_fx", "bind_video_param", "set_video_settings",
+        "vx_variation", "analyze_motion",
+    ].map((tool) => [tool, "VX video engine"]),
+    ...[
+        "list_plugins", "scan_plugins", "cancel_plugin_scan", "get_plugin_scan_status", "list_loaded_plugins",
+        "load_plugin", "unload_plugin", "set_plugin_param", "set_plugin_params", "set_plugin_bypass",
+        "skip_current_plugin_scan", "remove_plugin_from_blocklist",
+    ].map((tool) => [tool, "plugin host"]),
+    ...[
+        "download_model", "get_model_status", "load_model", "unload_model", "delete_model", "list_models",
+        "generate_sample", "generate_kit", "workbench_get_state", "workbench_set_state", "workbench_render",
+        "workbench_list_takes", "workbench_load_take", "workbench_undo", "workbench_reset_chain",
+        "workbench_sidecar_status", "ask_assistant",
+    ].map((tool) => [tool, "AI stack"]),
+    ...[...PACK_TOOL_NAMES].map((tool) => [tool, "preset pack store"]),
+]);
+// Tools whose failures carry a code answer MSQ's refusal with one too.
+const MSQ_MISSING_CODES = new Map([
+    ...[...PACK_TOOL_NAMES].map((tool) => [tool, "pack_unsupported_product"]),
+    ["dj_set", "dj_unsupported_product"],
+]);
+const MFX_CELL_CONFIG_KEYS = new Set(["sidechainFrom", "cellmixFrom", "cellmixPreFx"]);
+// MSQ cells are MIDI tracks: their note, channel, scale and output wiring, never sampler config.
+const MSQ_CELL_CONFIG_KEYS = new Set([
+    "isPoly", "midiNote", "midiChannel", "midiIsolate", "armed", "polyRootNote", "scaleName", "scaleRoot",
+    "midiOutChannel", "sendToHost", "midiOutPort", "polyNoteMin", "polyNoteMax", ...CC_OUT_CONFIG_KEYS,
+    ...CC_LANES.map(ccLaneSlotField),
+]);
+// A CC out slot's controller (cell config ccOutCc{K}); 120-127 are channel-mode messages.
+const ccOutControllerSchema = (slot) => z
+    .number()
+    .int()
+    .min(-1)
+    .max(119)
+    .optional()
+    .describe(`Controller number CC out slot ${slot} sends, -1=Off. Its value is the parameter cell{N}_ccOut${slot} (0-127).`);
 async function loadManifestForProductGuard() {
     try {
         return await loadManifest();
@@ -115,7 +250,11 @@ function validateCellIdForManifest(cellId, manifest) {
     return true;
 }
 function readPackageVersion() {
-    const override = IS_MFX_SERVER ? process.env.MFX_MCP_SERVER_VERSION?.trim() : undefined;
+    const override = IS_MFX_SERVER
+        ? process.env.MFX_MCP_SERVER_VERSION?.trim()
+        : IS_MSQ_SERVER
+            ? process.env.MSQ_MCP_SERVER_VERSION?.trim()
+            : undefined;
     if (override)
         return override;
     try {
@@ -162,12 +301,12 @@ async function requireBridge() {
     if (!ok) {
         const pin = process.env.PAM_BRIDGE_PRODUCT;
         return error(`Not connected to ${SERVER_PRODUCT.name}. Start ${SERVER_PRODUCT.name} (standalone or in a DAW) with MCP bridge enabled. ` +
-            (IS_MFX_SERVER
-                ? "The launcher finds MFX through the local bridge registry; the plugin records its actual port on startup."
-                : "The bridge writes its port to ~/.pam-mcp-bridge.json on startup.") +
+            (PINNED_PRODUCT
+                ? `The launcher finds ${SERVER_PRODUCT.name} through the local bridge registry; the plugin records its actual port on startup.`
+                : "The bridge writes an authenticated registration under its data folder on startup. If PAM is already running with the bridge enabled, update PAM to a version that supports authenticated MCP connections.") +
             (pin
-                ? IS_MFX_SERVER
-                    ? " The MFX launcher is product-pinned, but no matching instance was found."
+                ? PINNED_PRODUCT
+                    ? ` The ${SERVER_PRODUCT.name} launcher is product-pinned, but no matching instance was found.`
                     : ` Note: PAM_BRIDGE_PRODUCT pins this server to '${pin}' — no matching instance was found (connection_status lists what is running).`
                 : ""));
     }
@@ -178,7 +317,7 @@ async function requireBridge() {
  * requireBridge() plus product-aware cell bounds, for tools that ADDRESS a cell.
  *
  * The zod schemas cap cellId at 8 because they are built before we know which
- * product is on the other end. Cell1 has 1 cell and MFX has 4, so without this
+ * product is on the other end. MFX has 4 cells, so without this
  * an agent aims at cell 7 and gets a bridge-level failure or a silent no-op
  * instead of being told the cell does not exist. Read filters (get_state,
  * get_design_overview) deliberately stay unguarded — returning only the cells
@@ -358,12 +497,6 @@ const FULL_STATE_RESPONSE_LIMIT_CHARS = 24_000;
 // Preset listings grow with every installed pack; cap the unfiltered dump so it
 // can't crowd out the agent's context (`search` narrows it).
 const LIST_PRESETS_MAX = 400;
-const PATTERN_LANES = {
-    note: "midiSequence",
-    pitch: "pitchSequence",
-    slice: "sliceSequence",
-    stretch: "stretchSequence",
-};
 const LFO_DIVISIONS = [
     "16 bar", "8 bar", "4 bar", "2 bar", "1 bar",
     "1/2D", "1/2", "1/2T",
@@ -458,6 +591,44 @@ function formatNotModulatableError(paramId, index) {
     const suggestions = suggestParams(paramId, index, { modulatableOnly: true });
     return `Parameter '${paramId}' is not modulatable.${suggestions.length ? ` Try modulatable target ${suggestions.join(", ")}.` : ""}`;
 }
+// Hosted-plugin params exist only while a plugin is loaded, so they resolve against
+// the live instance; the id is the UI's `cell{N}_plugin_{slug(name)}_{index}`.
+const HOSTED_MOD_TARGET_RX = /^cell(\d+)_plugin(Fx)?_[a-z0-9][a-z0-9_]*_(\d+)$/;
+function hostedParamSlug(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 32) || "p";
+}
+function hostedModTargetId(cellId, param, effect = false) {
+    return `cell${cellId}_${effect ? "pluginFx" : "plugin"}_${hostedParamSlug(param.name || param.label || `p${param.index}`)}_${param.index}`;
+}
+/** A manifest param, or a hosted-plugin param checked against the loaded instance; a string is the error. */
+async function resolveModulationTarget(paramId, index) {
+    const param = index.get(paramId);
+    if (param)
+        return param.isModulatable ? param : formatNotModulatableError(paramId, index);
+    const hosted = paramId.match(HOSTED_MOD_TARGET_RX);
+    if (!hosted)
+        return formatUnknownParamError(paramId, index, { modulatableOnly: true });
+    const cellId = Number(hosted[1]);
+    const hostedTarget = { paramId, name: paramId, displayName: paramId, min: 0, max: 1, defaultValue: 0, step: 0.001, skew: 1, isModulatable: true };
+    // list_loaded_plugins covers the instrument slot only; an FX id is taken as named.
+    if (hosted[2])
+        return hostedTarget;
+    let listed;
+    try {
+        listed = (await bridge.send("listLoadedPlugins"));
+    }
+    catch {
+        return `Hosted plugin parameters need a running PAM with the MCP bridge connected (${paramId}).`;
+    }
+    const plugin = listed?.loadedPlugins?.find((p) => Number(p.cellId) === cellId);
+    if (!plugin)
+        return `No hosted instrument plugin is loaded in cell ${cellId}; load one before targeting ${paramId}.`;
+    const entry = plugin.params?.find((p) => Number(p.index) === Number(hosted[3]));
+    if (!entry)
+        return `${plugin.name} in cell ${cellId} has no parameter at index ${hosted[3]}.`;
+    const expected = hostedModTargetId(cellId, { ...entry, index: Number(entry.index) });
+    return expected === paramId ? hostedTarget : `Unknown hosted parameter ${paramId}. Did you mean ${expected}?`;
+}
 function formatRangeError(param, value) {
     const unit = param.suffix ? param.suffix : "unitless";
     const traits = [
@@ -557,6 +728,29 @@ function filterSectionResult(section, result, opts) {
 function countEvents(value) {
     return Array.isArray(value) ? value.length : 0;
 }
+// What an MSQ cell sends: its output wiring, what plays it, and the CC it carries.
+function msqCellSummary(id, cell, state) {
+    const prefix = `cell${id}_`;
+    const channel = Math.round(Number(cell.midiOutChannel ?? 0));
+    return {
+        cellId: id,
+        muted: state[`${prefix}mute`] === 1 || state[`${prefix}mute`] === true,
+        send: Number(cell.sendToHost ?? 1) > 0.5,
+        channel: channel >= 1 && channel <= 16 ? channel : `auto (${((id - 1) % 16) + 1})`,
+        port: Math.round(Number(cell.midiOutPort ?? 0)),
+        triggerNote: cell.midiNote,
+        poly: Number(cell.isPoly) > 0.5 ? { low: cell.polyNoteMin ?? 0, high: cell.polyNoteMax ?? 127 } : false,
+        player: describeCellPlayer(id, cell, state),
+        noteEvents: countEvents(state[`${prefix}${PATTERN_LANE_SUFFIX.note}`]),
+        ccLaneEvents: Object.fromEntries(CC_LANES.map((lane) => [lane, countEvents(state[`${prefix}${PATTERN_LANE_SUFFIX[lane]}`])])),
+        ccOut: CC_OUT_SLOTS.flatMap((slot) => {
+            const controller = Number(cell[`ccOutCc${slot}`]);
+            return Number.isInteger(controller) && controller >= 0 && controller <= 119
+                ? [{ slot, controller, value: state[`${prefix}ccOut${slot}`] }]
+                : [];
+        }),
+    };
+}
 function stemName(path) {
     if (typeof path !== "string" || path.length === 0)
         return undefined;
@@ -571,11 +765,19 @@ const server = new McpServer({
     instructions: IS_MFX_SERVER
         ? "MFX is a four-cell modular FX router: cells are patched with cables and each cell runs its own effect chain. " +
             "Use cells 1-4. Treat tool annotations as authoritative and use select_instance when several products are running."
-        : "PAM is an eight-cell sampler. " +
-            "Sequencer output requires a running transport. UI, video, and visual tools require the plugin " +
-            "window open; experimental plugin-host and AI tools require experimentalMode plus the matching " +
-            "feature flag. Treat tool annotations as authoritative and use select_instance when several " +
-            "products are running. A 'build does not support' error means update the plugin, not only this server.",
+        : IS_MSQ_SERVER
+            ? "MSQ is an eight-cell MIDI sequencer: each cell sends its pattern or Player's notes and its CC out on its own " +
+                "MIDI channel to the host's instruments or, standalone, to MIDI devices. It makes no sound itself. Notes need a " +
+                "running transport; a CC out slot sends whenever its value moves. Treat tool annotations as authoritative and " +
+                "use select_instance when several MSQ instances are running."
+            : "PAM is an eight-cell sampler. " +
+                "Sequencer notes require a running transport; a cell's CC out slots send whenever their value moves. " +
+                "UI, video, and visual tools require the plugin " +
+                "window open; experimental plugin-host and AI tools require experimentalMode plus the matching " +
+                "feature flag. Treat tool annotations as authoritative and use select_instance when several " +
+                "products are running. A 'build does not support' error means update the plugin, not only this server. " +
+                "An MSQ instance sequences MIDI only: its cells send notes and CC to the host MIDI out, so sample, effect, " +
+                "master, looper, video, plugin-host and AI tools refuse it.",
 });
 // --- tool annotation policy ---------------------------------------------------
 // Single audit surface for MCP tool annotations. Every tool MUST have an entry;
@@ -638,7 +840,10 @@ const TOOL_ANNOTATIONS = {
     clear_modulations: DI,
     reset_patterns: DI,
     update_effect_config: WI,
+    set_effects_enabled: WI,
+    set_spectral_delay_curve: WI,
     update_cell_config: WI,
+    set_lane_target: WI,
     set_cell_mute: WI,
     set_master_effects: WI,
     add_param_seq: W,
@@ -648,6 +853,7 @@ const TOOL_ANNOTATIONS = {
     set_drum_synth_wave: WI,
     list_players: RO,
     set_player: WI,
+    keep_player: W,
     set_slices: WI,
     set_free_sequencer: WI,
     export_midi: W,
@@ -668,12 +874,18 @@ const TOOL_ANNOTATIONS = {
     trigger_midi_cc: W,
     trigger_midi_program_change: W,
     midi_recording: W,
+    session_take: W,
     // Presets / variations
     load_preset: DI, // replaces the working state (unsaved edits are lost)
     get_preset_load_status: RO,
     save_preset: WI,
     new_preset: DI,
     import_preset: WI,
+    // Preset packs
+    list_packs: RO,
+    get_pack_install_status: RO,
+    install_pack: WI,
+    uninstall_pack: DI, // deletes the pack's presets, samples and media
     export_preset: W,
     update_preset_metadata: WI,
     delete_preset: DI,
@@ -691,6 +903,8 @@ const TOOL_ANNOTATIONS = {
     trim_sample: W, // restore_original_sample recovers the pre-edit file
     reverse_sample: W,
     gain_sample: W,
+    repitch_sample: W,
+    analyze_sample_pitch: RO,
     normalize_sample: WI,
     analyze_sample_tempo: WI, // dispatches results into state
     resample_sample_to_bpm: WI,
@@ -713,6 +927,7 @@ const TOOL_ANNOTATIONS = {
     live_resample: D, // finalize replaces the destination cell; finalize:false discards the take
     // Song mode / export
     song_mode: W,
+    dj_set: DI,
     export_song: W,
     export_audio: W,
     // Settings / devices
@@ -795,6 +1010,8 @@ const MFX_TOOL_NAMES = new Set([
     "update_modulation",
     "clear_modulations",
     "update_effect_config",
+    "set_effects_enabled",
+    "set_spectral_delay_curve",
     "update_cell_config",
     "set_cell_mute",
     "set_master_effects",
@@ -826,7 +1043,6 @@ const MFX_TOOL_NAMES = new Set([
     "cancel_queued_variation",
     "update_variations",
     "variation_hold",
-    "export_audio",
     "update_settings",
     "get_audio_device_setup",
     "set_audio_device",
@@ -847,13 +1063,13 @@ function mfxSurfaceText(value) {
         .replaceAll(" Check corr in get_master_analysis after widening.", "")
         .replaceAll(" (same constraint as the video tools)", "")
         .replaceAll("so the preset_novelty scale does", "so a whole-preset novelty scale does")
-        .replaceAll("PAM/Cell1-only", "sampler-product-only")
-        .replaceAll("PAM/Cell1", "sampler products")
         .replaceAll("PAM-only", "sampler-product-only")
         .replaceAll("PAM's", "MFX's")
         .replaceAll("PAM", "MFX");
 }
 const MFX_MAX_CELL = 4;
+// Copy of syncUtils::kValidBarSyncIntervals (SyncUtils.h); check-parity compares them.
+const LOOPER_BAR_SYNC_INTERVALS = [0.25, 0.5, 1, 2, 4, 8];
 // Zod wrappers are immutable, so narrowing a leaf means rebuilding the
 // optional/default/array/union chain around it and re-attaching the description.
 function rebuildSchema(schema, narrowLeaf) {
@@ -895,49 +1111,94 @@ const MFX_CELL_FIELDS = new Set([
     "cellIds",
     "selectedCellIds",
     "sidechainFrom",
+    "cellmixFrom",
 ]);
 // Enum members MFX has no surface for: Vary is removed from its modulation stack,
-// and neither song_mode nor a looper tool is registered on this launcher.
+// neither song_mode nor a looper tool is registered on this launcher, and the MIDI
+// settings page hides the looper, resample and VX mappings.
 const MFX_ENUM_DROPS = {
     add_modulation: { type: ["vary"] },
+    update_modulation: { type: ["vary"] },
     get_state: { section: ["vary", "loopers", "songMode"] },
-    export_audio: { mode: ["song-mode"] },
+    set_midi_mapping: { target: ["looper", "resample", "vxRecord", "looperVariation"] },
 };
 const MFX_KEPT_FIELDS = {
-    update_cell_config: ["cellId", "sidechainFrom"],
+    update_cell_config: ["cellId", "sidechainFrom", "cellmixFrom", "cellmixPreFx"],
 };
 const MFX_DROPPED_FIELDS = {
     select_instance: ["product"],
     // MFX cells are effect slots — there is no synth/sampler tab to switch.
     capture_ui: ["instrumentView"],
+    // MFX processes host input, which an offline render leaves silent.
+    analyze_motion: ["bars"],
 };
 const MFX_TOOL_DESCRIPTIONS = {
     select_instance: "Choose which running MFX instance the live tools drive. Match by instanceId or port from connection_status. The launcher refuses non-MFX instances.",
-    update_cell_config: "Set one MFX cell's sidechain source. A non-null source also enables that cell's compressor.",
+    update_cell_config: "Set one MFX cell's sidechain or Cell Mix source. A non-null sidechain source also enables that cell's " +
+        "compressor, and a Cell Mix source other than -1 enables its Cell Mix card.",
     capture_ui: "Render MFX's plugin UI (#app_root) to a PNG via html2canvas and return the saved file path (read it to " +
         "view the image). Optionally compose the view first: gridSize (1 or 4), mainView (CellGrid|MfxRouting|" +
         "CtrlAll|Envelope|LFO|ParamSeq|Mixer|PresetBrowser; omit/null = cell grid). REQUIRES MFX's window OPEN — " +
         "html2canvas needs the live DOM, there is no headless renderer. Beats screen-capture: deterministic, no " +
         "cursor/screen control, exact UI bitmap. View arguments switch the live editor and the previous view is " +
         "not restored.",
+    copy_cell: "Copy a cell's manifest parameters and remap its LFO and envelope links onto another cell, overwriting the " +
+        "target's. Not copied: parameter sequencers and the cell config block (sidechain source) — re-apply that with " +
+        "update_cell_config.",
+    set_midi_mapping: "Configure the global MIDI-controller mappings that trigger MFX actions: variation switch and preset change. " +
+        "Set the enable flag, MIDI channel, CC number, source (Program Change or CC), or bar-sync for each target. " +
+        "One field per call.",
 };
 const MFX_FIELD_DESCRIPTIONS = {
     capture_ui: { gridSize: "Cell grid size to set before capture: 1 or 4." },
-    export_audio: { bars: "Bars to render." },
+    analyze_motion: {
+        wavPath: "Absolute path to a WAV of material processed through MFX, such as a DAW bounce. Required on MFX.",
+    },
+    set_midi_mapping: {
+        target: "Which action's mapping to configure.",
+        field: "Field to set. 'source' (0 = Program Change, 1 = CC) applies to preset and variation; 'barSync' is variation-only.",
+    },
+    queue_variation: {
+        fadeMs: "Crossfade duration in ms. Omit all transition options to inherit the native Bar Sync settings.",
+    },
+    update_modulation: {
+        payload: "Update payload object, one property per call. lfo, envelope, macro and paramSeq all take " +
+            "{ index, property, value }, where index is the 0-based position in that state array (get_state " +
+            "section 'lfos' / 'envelopes' / 'macros' / 'paramSeqs') and property is the field name to overwrite. " +
+            "paramSeqSequence takes { index, sequence: number[] }. freeSeqSequence takes { sequence: number[] } — the " +
+            "master step contour every free-mode ParamSeq follows.",
+    },
     add_modulation: {
         cellId: "Required for envelope: source cell driving the follower (1-4). This is not the target cell; target is inferred from paramId.",
     },
 };
 // Text whose subject is a tool this launcher does not register.
 function mfxDescriptionEdits(name, value) {
-    if (name === "export_audio")
-        return value
-            .replace("Set `mode` to bounce stems or the whole Song Mode arrangement.", "Set `mode` to bounce per-cell or per-bus stems.")
-            .replace(" · 'song-mode' (the Song Mode timeline)", "")
-            .replace(/\n\nNOTE on 'song-mode':[\s\S]*$/, "");
     if (name === "analyze_motion")
-        return value.replace("Fills the gap left by get_master_analysis (loudness) and get_mix_analysis (aggregate spectrum + onset " +
-            "density), neither of which can tell a modulated preset from a static one.", "No other tool on this surface can tell a modulated preset from a static one.");
+        return value
+            .replace("Fills the gap left by get_master_analysis (loudness) and get_mix_analysis (aggregate spectrum + onset " +
+            "density), neither of which can tell a modulated preset from a static one.", "No other tool on this surface can tell a modulated preset from a static one.")
+            .replace(/Pass wavPath to analyze an existing render[\s\S]*$/, "Pass wavPath to a WAV of material processed through MFX, such as a DAW bounce. MFX processes its " +
+            "host's input, so there is no offline render to fall back on.");
+    if (name === "reset_cell")
+        return value.replace("Untouched: envelopes targeting this cell from another source (clear_modulations), pattern lanes (reset_patterns), " +
+            "the cell config block (update_cell_config) and the loaded sample.", "Untouched: envelopes targeting this cell from another source (clear_modulations) and the cell config block " +
+            "(update_cell_config).");
+    if (name === "clear_modulations")
+        return value.replace("LFO, envelope, and vary modulation links", "LFO and envelope modulation links")
+            .replace("for envelopes/vary", "for envelopes");
+    if (name === "update_modulation")
+        return value.replace("LFO, Envelope, Vary, Macro", "LFO, Envelope, Macro");
+    if (name === "get_default_locations")
+        return value.replace(" Use these paths with list_samples to browse the sample library.", "");
+    if (name === "save_variation")
+        return value.replace("(load samples, set parameters, enable effects, add modulation)", "(set parameters, enable effects, patch cables, add modulation)");
+    if (name === "queue_variation")
+        return value.replace(" (song mode / an already-engaged queued-flip window only;", " (an already-engaged queued-flip window only;");
+    if (name === "get_design_overview")
+        return value.replace("cells, loaded samples/synth engines, enabled effects, pattern counts, modulation link counts, mixer values, " +
+            "BPM, and master FX.", "cells, enabled effects and order, sidechain sources, modulation link counts, mixer values, cables, cable " +
+            "levels, Combo assignments, band split, BPM, and transport state.");
     if (name === "set_master_effects")
         return value.replace("Check results with get_master_analysis (keep tp <= -1 dBTP, PSR >= 8 in the loudest section). ", "Aim for tp <= -1 dBTP and PSR >= 8 in the loudest section; no loudness analysis tool is registered on this surface. ");
     if (name === "set_parameters")
@@ -978,6 +1239,202 @@ function mfxToolConfig(name, config) {
         ...(inputSchema ? { inputSchema } : {}),
     };
 }
+// MSQ's launcher advertises the pattern layer only. The sampler, effect, master, looper, video,
+// plugin-host, AI and MFX handlers live in this file too; discovery must not offer them.
+const MSQ_TOOL_NAMES = new Set([
+    "get_parameter_info", "list_presets", "read_preset", "get_manifest_summary", "variation_distinctness",
+    "get_state", "get_design_overview", "connection_status", "situation", "select_instance", "get_default_locations",
+    "capture_ui", "set_view", "set_parameters", "trigger_midi", "trigger_midi_cc", "trigger_midi_program_change",
+    "stop_cell", "reset_cell", "copy_cell", "update_cell_config", "set_cell_mute", "update_pattern", "reset_patterns",
+    "randomize", "randomize_patterns", "list_players", "set_player", "keep_player", "add_modulation",
+    "update_modulation", "clear_modulations", "add_param_seq", "update_param_seq", "remove_param_seq",
+    "set_free_sequencer", "start_transport", "stop_transport", "full_stop_transport", "get_transport", "set_bpm",
+    "configure_transport", "load_preset", "get_preset_load_status", "new_preset", "save_preset",
+    "update_preset_metadata", "export_preset", "import_preset", "delete_preset", "set_preset_factory_status",
+    "load_variation", "save_variation", "queue_variation", "cancel_queued_variation", "update_variations",
+    "variation_hold", "export_midi", "midi_recording", "update_settings", "get_audio_device_setup",
+    "set_audio_device", "set_midi_io", "set_midi_mapping",
+]);
+// No audio means no envelope follower; the looper, Song Mode, resample and VX mappings have no MSQ surface.
+const MSQ_ENUM_DROPS = {
+    update_pattern: { type: ["pitch", "slice", "stretch", "paramLane1", "paramLane2", "paramLane3", "paramLane4"] },
+    add_modulation: { type: ["envelope"] },
+    update_modulation: { type: ["envelope"] },
+    get_state: { section: ["envelopes", "loopers", "songMode"] },
+    set_midi_mapping: { target: ["looper", "resample", "vxRecord", "looperVariation"] },
+    set_view: { fullscreen: ["effects"] },
+};
+const MSQ_KEPT_FIELDS = {
+    update_cell_config: ["cellId", ...MSQ_CELL_CONFIG_KEYS],
+};
+const MSQ_DROPPED_FIELDS = {
+    select_instance: ["product"],
+    capture_ui: ["instrumentView"],
+    get_parameter_info: ["effect"],
+    add_modulation: ["pitch", "pitchDuck"],
+    // Without a lane runtime every queued flip lands hard at its boundary: nothing to morph or crossfade.
+    queue_variation: ["fadeMs", "morphBars", "morphMode", "morphCurve", "transition"],
+};
+const MSQ_FIELD_SCHEMAS = {
+    randomize: {
+        target: z
+            .enum(["sequences", "lfos", "mods"])
+            .default("sequences")
+            .describe("What to randomize: the cells' note patterns, or the global LFOs / modulation links."),
+    },
+    set_view: {
+        panel: z
+            .enum(["pattern", "player", "midi"])
+            .optional()
+            .describe("Cell card tab to show, on cellId or else every cell: pattern, player or midi."),
+    },
+};
+const MSQ_TOOL_DESCRIPTIONS = {
+    select_instance: "Choose which running MSQ instance the live tools drive. Match by instanceId or port from connection_status. The launcher refuses other products' instances.",
+    get_design_overview: "Return a compact snapshot of what each cell sends: Send, output channel (Auto = cell number), port, trigger " +
+        "note, poly range, Player, note and CC-lane event counts, CC out slots and modulation link counts, plus BPM and " +
+        "transport. Use this instead of full get_state.",
+    randomize: "Trigger MSQ's randomizer. target:'sequences' writes new note patterns natively; 'lfos'/'mods' reshape the " +
+        "global modulation and need MSQ's window open. Returns queued, not completed: poll get_state for the requested " +
+        "changes before another randomize, edit, or save. A preset or variation load can discard pending work.",
+    randomize_patterns: "Generate new note patterns with MSQ's native pattern engine from the genre, BPM and each cell's role. " +
+        "Identical to randomize target:'sequences'. Returns queued: poll get_state for changed cellN_midiSequence " +
+        "values before another randomize, edit, or save.",
+    export_preset: "Export a preset as a zip file written to MSQ's Exports folder as <outputFolderName>.zip. An existing folder " +
+        "or zip of that name is replaced, and presets belonging to a preset pack are refused.",
+    update_settings: "Merge a partial settings delta into MSQ's plugin settings (the Settings panel state) and apply it live. " +
+        "Returns the full merged settings object, so call it with {} to discover the keys; experimentalMode and " +
+        "mcpBridgeEnabled are among them (mcpBridgeEnabled:false closes this bridge after it replies).",
+    set_view: "Navigate MSQ's UI: switch the main view, focus a cell, or set the pad-grid size. Routed through the " +
+        "WebView, so MSQ's window must be OPEN.",
+    capture_ui: "Render MSQ's plugin UI (#app_root) to a PNG via html2canvas and return the saved file path (read it to view " +
+        "the image). Optionally compose the view first: gridSize (1|4|8), mainView (CellGrid|CtrlAll|LFO|Vary|" +
+        "ParamSeq|Mixer|PresetBrowser; omit/null = cell grid). REQUIRES MSQ's window OPEN: html2canvas needs the live " +
+        "DOM. View arguments switch the live editor and the previous view is not restored.",
+    copy_cell: "Copy a cell's manifest parameters and remap its LFO and vary links onto another cell, overwriting the " +
+        "target's. A CC lane lands only on a target slot that is Off or on the same controller; CC out values and " +
+        "controllers, output channel, Send and port stay the target's. Not copied: parameter sequencers and the cell " +
+        "config block (poly, trigger note, scale), which update_cell_config sets.",
+    reset_cell: "Reset a single cell's manifest parameters to their defaults. Untouched: pattern lanes (reset_patterns), the " +
+        "cell config block (update_cell_config) and modulation targeting the cell from elsewhere (clear_modulations). " +
+        "Does not touch other cells.",
+    update_cell_config: "Set one MSQ cell's MIDI config: trigger note, poly and scale, output channel (0 = Auto), Send, standalone " +
+        "port, the CC out slots' controllers and the CC lanes' slots.",
+    get_manifest_summary: "Get a high-level summary of MSQ's capabilities: number of cells, modulators, and parameter counts.",
+    add_modulation: "Add a modulation link (LFO or vary) to a parameter. The parameter must be modulatable (check with " +
+        "get_parameter_info).",
+    update_modulation: "Apply a delta to a modulation source: LFO, Vary, Macro, ParamSeq config, ParamSeq sequence data, or the Free " +
+        "Sequencer master pattern. Use add_modulation to first attach a source to a target, then this tool to edit it.",
+    clear_modulations: "Remove all LFO and vary modulation links targeting a cell's parameters (or driven by that cell, for vary). " +
+        "Parameter sequencers survive; use remove_param_seq for those.",
+    load_variation: "Request a switch to a saved variation slot (0-7), including parameters, patterns, players, cell wiring and " +
+        "modulation. Empty slots are rejected. Verify currentVariation and a slot-specific value with get_state before " +
+        "editing or saving.",
+    new_preset: "Reset MSQ to its initial/default state, equivalent to creating a new empty preset. All cells, modulation and " +
+        "sequences are cleared.",
+    set_cell_mute: "Mute, unmute, solo, or unsolo a cell. A muted cell, or every other cell while one is soloed, sends no notes " +
+        "or CC and releases the notes it holds. cell{N}_mute / cell{N}_solo are live-polled state variables.",
+    read_preset: "Read an MSQ preset file and return its state: parameters, patterns, cell config and variations.",
+    variation_distinctness: "Measure whether a preset's variation slots are actually different, and name what is identical about the " +
+        "pairs that are not. Structural comparison of the saved slot snapshots: no render, no transport, no audition " +
+        "loop, and no risk of the load_variation race. Each failing pair reports the dimensions it duplicates plus the " +
+        "move that would fix it.",
+    set_parameters: "Set one or more MSQ parameters. Values are validated against the manifest; get_parameter_info lists valid " +
+        "IDs and ranges. Writing a macro_* id also enables that macro, matching the UI.",
+    update_pattern: "Write one lane of a cell's pattern: the notes, or a CC lane (ccOut1-ccOut4, the timeline of that CC out " +
+        "slot: each event sends its value on the slot's controller for its duration, then the slot returns to its knob).",
+    save_variation: "Capture the current plugin state and save it to a variation slot (0-7). Use this to build presets with " +
+        "multiple variations, e.g. a build-up from sparse to full. Set patterns, players, parameters and modulation " +
+        "first, then snapshot them into a slot. The preset must have been saved once via save_preset, or pass a name " +
+        "to create it.",
+    situation: "One-call orientation snapshot: discovered instances, the connected instance's product/pid/executable (plus " +
+        "build mtime and a dev-build heuristic when resolvable), server and manifest identity, active preset, " +
+        "transport, and what each cell sends. Start a session here; get_design_overview reads deeper.",
+    get_default_locations: "Get the standard folders MSQ knows (home, desktop, documents, music, downloads, presets), for an export_midi " +
+        "outputDir or an import_preset path.",
+    import_preset: "Import a preset from a zip file or folder into MSQ's preset library. Returns the relative path of the first " +
+        "imported preset, or an empty string on failure. A name already in the library is never overwritten: the " +
+        "import lands as <name>_1, <name>_2 and so on.",
+    reset_patterns: "Clear every pattern lane of one cell: the note lane and the four CC lanes. CC out controllers stay.",
+    queue_variation: "Schedule a global variation switch on the next bar boundary; for an immediate switch use load_variation. " +
+        "MSQ switches at the boundary without a morph.",
+    trigger_midi_cc: "Send a MIDI Control Change message into MSQ's MIDI router. Maps to any MIDI-learned parameter or variation " +
+        "CC binding.",
+    set_midi_mapping: "Configure the global MIDI-controller mappings that trigger MSQ actions: variation switch and preset change. " +
+        "Set the enable flag, MIDI channel, CC number, source (Program Change or CC), or bar-sync for each target. " +
+        "One field per call.",
+    export_midi: "Write the cells' note patterns to a Standard MIDI File (type 1, 480 PPQ, tempo from the transport): one track " +
+        "per cell, across `bars`, on the cell's output channel (Auto = cell number). Each sending CC out slot's value " +
+        "opens the track at tick 0 and its CC lane's locks and releases follow on the lane's own clock; a cell with Send " +
+        "off is left out, as are notes outside a poly cell's Low-High. A Player cell exports the cycles it generates, " +
+        "rendered by MSQ itself; Listen responses are left out. Grid timing from base values: swing, probability, CTRL " +
+        "macros and modulators are not applied. Nothing changes in MSQ. Default location is MSQ's Export folder.",
+};
+const MSQ_FIELD_DESCRIPTIONS = {
+    get_parameter_info: { paramId: "Specific parameter ID (e.g. 'cell1_patternSwing'). Omit for all." },
+    get_state: { keys: "Exact top-level state keys to return, e.g. ['cell1_patternSwing','cell1_midiSequence']." },
+    add_modulation: {
+        paramId: "Target parameter ID (e.g. 'cell1_ccOut1').",
+        cellId: "Required for vary: the cell whose triggers drive it (1-8). The target cell is inferred from paramId.",
+    },
+    add_param_seq: { paramId: "Target parameter ID (e.g. 'cell1_ccOut1')." },
+    update_modulation: {
+        payload: "Update payload object, one property per call. lfo, vary, macro and paramSeq all take { index, property, " +
+            "value }, where index is the 0-based position in that state array (get_state section 'lfos' / 'vary' / " +
+            "'macros' / 'paramSeqs') and property is the field name to overwrite. paramSeqSequence takes { index, " +
+            "sequence: number[] }. freeSeqSequence takes { sequence: number[] }, the master step contour every " +
+            "free-mode ParamSeq follows.",
+    },
+    set_parameters: { parameters: "Map of paramId to value. Example: { 'cell1_ccOut1': 100, 'cell2_patternSwing': 0.2 }" },
+    update_pattern: {
+        sequence: "Array of sequence events. For 'note': [{time, note, duration, velocity, prob}]. For CC lanes: " +
+            "[{time, value, duration, prob?}] (values 0-127; times and durations in beats).",
+    },
+    randomize: { genreHint: "Genre hint for the generated patterns (e.g. 'techno', 'hip-hop')." },
+    save_preset: { image: "Relative path to a thumbnail image for the preset browser." },
+    update_preset_metadata: { image: "Relative path to a thumbnail image for the preset browser." },
+    update_cell_config: { polyRootNote: "Root note for poly pitch calculation." },
+    variation_distinctness: { threshold: "Similarity above which a pair fails. Default 0.9." },
+    set_midi_mapping: {
+        target: "Which action's mapping to configure.",
+        field: "Field to set. 'source' (0 = Program Change, 1 = CC) applies to preset and variation; 'barSync' is variation-only.",
+    },
+    set_view: {
+        view: "Main view: cells, mixer, ctrl, lfo, vary, paramseq, presets.",
+        fullscreen: "CTRL page rack to show alone (sequencer, players), or none.",
+    },
+};
+function msqSurfaceText(value) {
+    return value
+        .replace(/PAM ?(?:≥|>=) ?\d+(?:\.\d+)*/g, "a current MSQ build")
+        .replaceAll("a PAM build", "an MSQ build")
+        .replaceAll("PAM", "MSQ");
+}
+function msqToolConfig(name, config) {
+    const source = config;
+    const kept = MSQ_KEPT_FIELDS[name];
+    const droppedFields = MSQ_DROPPED_FIELDS[name] ?? [];
+    const enumDrops = MSQ_ENUM_DROPS[name] ?? {};
+    const fieldText = MSQ_FIELD_DESCRIPTIONS[name] ?? {};
+    const fieldSchemas = MSQ_FIELD_SCHEMAS[name] ?? {};
+    const inputSchema = source.inputSchema
+        ? Object.fromEntries(Object.entries(source.inputSchema)
+            .filter(([key]) => (!kept || kept.includes(key)) && !droppedFields.includes(key))
+            .map(([key, schema]) => {
+            if (fieldSchemas[key])
+                return [key, fieldSchemas[key]];
+            const narrowed = enumDrops[key] ? rebuildSchema(schema, dropEnumMembers(enumDrops[key])) : schema;
+            const described = fieldText[key] ?? (narrowed.description ? msqSurfaceText(narrowed.description) : undefined);
+            return [key, described ? narrowed.describe(described) : narrowed];
+        }))
+        : undefined;
+    const description = MSQ_TOOL_DESCRIPTIONS[name] ?? (source.description ? msqSurfaceText(source.description) : undefined);
+    return {
+        ...source,
+        ...(description ? { description } : {}),
+        ...(inputSchema ? { inputSchema } : {}),
+    };
+}
 {
     const origRegisterTool = server.registerTool.bind(server);
     server.registerTool = ((name, config, handler) => {
@@ -985,8 +1442,19 @@ function mfxToolConfig(name, config) {
         // tools therefore have no runtime handle to return.
         if (IS_MFX_SERVER && !MFX_TOOL_NAMES.has(name))
             return undefined;
-        const productConfig = (IS_MFX_SERVER ? mfxToolConfig(name, config) : config);
-        internalTools.set(name, { shape: productConfig.inputSchema, handler });
+        if (IS_MSQ_SERVER && !MSQ_TOOL_NAMES.has(name))
+            return undefined;
+        const productConfig = (IS_MFX_SERVER ? mfxToolConfig(name, config) : IS_MSQ_SERVER ? msqToolConfig(name, config) : config);
+        const missing = MSQ_MISSING_BY_TOOL.get(name);
+        // Judged by the instance actually connected, not a manifest hint a previous session left behind.
+        const productHandler = missing
+            ? async (args, extra) => (await requireBridge()) === true && bridge.getConnectedInstance()?.product?.toUpperCase() === "MSQ"
+                ? MSQ_MISSING_CODES.has(name)
+                    ? packFailure(MSQ_MISSING_CODES.get(name), `${name} is not available in MSQ: it has no ${missing}.`)
+                    : error(`${name} is not available in MSQ: it has no ${missing}.`)
+                : handler(args, extra)
+            : handler;
+        internalTools.set(name, { shape: productConfig.inputSchema, handler: productHandler });
         // Merge the central annotation policy. Inline annotations at the call site
         // win per key; openWorldHint is false server-wide (local plugin only).
         const cfg = productConfig;
@@ -994,7 +1462,7 @@ function mfxToolConfig(name, config) {
             console.error(`[${SERVER_PRODUCT.command}] tool '${name}' has no TOOL_ANNOTATIONS entry — classify it (check-tool-surface fails on this)`);
         }
         cfg.annotations = { openWorldHint: false, ...TOOL_ANNOTATIONS[name], ...cfg.annotations };
-        return origRegisterTool(name, productConfig, handler);
+        return origRegisterTool(name, productConfig, productHandler);
     });
 }
 async function callInternalTool(name, args) {
@@ -1407,7 +1875,7 @@ server.registerTool("design_context", {
             filterCutoff: "Use real Hz values; move at least 1.5 octaves for obviously audible modulation.",
             delayDelayTime: "With delaySyncEnabled=1, normalized 0..1 maps to musical divisions; do not use cellN_delayTime.",
             flanger: "cellN_flangerTime and cellN_flangerFreq are normalized 0..1, not ms/Hz. flangerFeedback is where the character lives — the corpus median is 70 and the top quartile is at 95+.",
-            eqGains: "cellN_eq{Low,Mid,High}Gain are -60..12 dB. The -60 floor makes the EQ a band KILL, not just a tilt.",
+            eqGains: "cellN_eq{Low,Mid,High}Gain are -60..12 dB. The -60 floor cuts the band fully, not just a tilt.",
             lfoRate: "LFO IDs are 1-based: lfo1_... through lfo6_.... Sync ON uses index/22.",
             lfoFeel: "lfoN_jitter and lfoN_offset (both 0..100, both default 0) are what stop an LFO sounding like a metronome — jitter randomizes the period, offset moves the starting phase so two LFOs at the same rate stop moving in lockstep. Only 8% and 6% of shipped LFOs set them.",
             granular: "The granular engine runs under cellN_stretch. cellN_stretchGrainMs (1..2000) is grain size — small values buzz, 200+ smears into a pad; cellN_grainDensity (1..32) is grains in flight; cellN_grainScan (-100..100) moves the read head independently of playback, so a negative scan plays a sample backwards through itself; cellN_grainFeedback (0..100) recirculates grains; cellN_grainTone (-100..100) tilts them; cellN_grainWindow (0..4) is the grain envelope shape.",
@@ -1464,7 +1932,7 @@ server.registerTool("design_context", {
         })),
         variationSlots: "API is 0-based (0..7); PAM UI labels slots 1..8. Save/load variation index 0 = UI slot 1.",
         generativePlayers: "set_player turns a cell into a live generator (list_players for the roster: EUCLID, KIT, TURING, WALK, MARKOV, " +
-            "RATCHET, PHASE, RIFF, MASK). cell{N}_playerDensity/Mutate/P1..P5 are modulatable params with macro_player* twins; " +
+            "RATCHET, PHASE, RIFF, MASK, PERC). cell{N}_playerDensity/Mutate/P1..P5 are modulatable params with macro_player* twins; " +
             "write them through set_player, never set_parameters alone, so the cell config stays in step.",
         modulationGuidance: "Primary movement should target per-cell params for distinct audible changes. Use macro_* for performance-level fan-out across cells. " +
             "Shipped presets that modulate at all carry a mean of 8.2 sources; the top third carry 8-46. Four sources is the corpus MEDIAN, i.e. the unremarkable middle — not a target.",
@@ -1560,7 +2028,7 @@ server.registerTool("analyze_motion", {
         "a bar — the last one is what catches a bar-synced gate, tremolo or sidechain pump, whose bars are all " +
         "identical to each other.\n\n" +
         "Pass wavPath to analyze an existing render or live_resample capture. Otherwise the tool runs an offline " +
-        "export first and leaves that render in PAM's Exports folder as pam_motion_<epoch>.wav. Digital silence is " +
+        "export first and leaves that render in PAM's Exports folder (its path is in the result). Digital silence is " +
         "reported as a RENDER FAILURE with the workaround, not as 'no motion' — offline export is known to produce " +
         "silence in the standalone build.",
     inputSchema: {
@@ -1572,35 +2040,34 @@ server.registerTool("analyze_motion", {
         bpm: z
             .number()
             .optional()
-            .describe("Tempo for the per-bar windows. Read from the transport when omitted."),
+            .describe("wavPath only: tempo for the 4/4 per-bar windows (default: the transport's). A render uses its own tempo and meter."),
     },
     annotations: { readOnlyHint: false, destructiveHint: false },
 }, async ({ wavPath, bars, bpm }) => {
     let path = wavPath;
     let effectiveBpm = bpm;
+    if (!path && IS_MFX_SERVER) {
+        return error("Pass wavPath: MFX processes its host's input, so an offline render has no source to analyze.");
+    }
+    // Bar windows in seconds; a render reports its own, from the transport's tempo and meter.
+    let barSeconds;
     if (!path) {
         const check = await requireBridge();
         if (check !== true)
             return check;
-        const transport = (await bridge.send("getTransport"));
-        effectiveBpm ??= typeof transport?.bpm === "number" ? transport.bpm : 120;
-        const filename = `pam_motion_${Date.now()}`;
-        await bridge.send("exportAudio", {
-            filename,
-            mode: "main",
-            durationInSeconds: (bars * 4 * 60) / (effectiveBpm || 120),
-            bitDepth: 24,
-        });
+        // The bars form of exportAudio is the one that reports its output path.
+        const started = await bridge.send("exportAudio", { bars, bitDepth: 24 });
+        const outputPath = isRecord(started) && typeof started.outputPath === "string" ? started.outputPath : undefined;
+        if (!outputPath)
+            return error("This build did not report the render's output path. Re-run with an explicit wavPath.");
         const outcome = await pollExportStatus();
         if (outcome !== "success")
-            return error(`Render failed before analysis could run (export ${outcome}).`);
-        const locations = (await bridge.send("getDefaultLocations"));
-        const exportDir = [locations?.exports, locations?.exportsLocation, locations?.Exports].find((v) => typeof v === "string" && v.length > 0);
-        if (!exportDir) {
-            return error(`Rendered ${filename}.wav but could not resolve PAM's Exports folder from get_default_locations. ` +
-                "Re-run with an explicit wavPath.");
-        }
-        path = resolve(exportDir, `${filename}.wav`);
+            return error(`Render failed before analysis could run (export ${outcome}).${exportFailureDetail()}`);
+        path = outputPath;
+        const renderedSeconds = isRecord(started) ? Number(started.durationInSeconds) : NaN;
+        barSeconds = renderedSeconds > 0 ? renderedSeconds / bars : undefined;
+        if (isRecord(started) && typeof started.bpm === "number")
+            effectiveBpm = started.bpm;
     }
     else if (effectiveBpm === undefined) {
         const check = await requireBridge();
@@ -1612,7 +2079,7 @@ server.registerTool("analyze_motion", {
     }
     let metrics;
     try {
-        metrics = analyzeMotion(decodeWav(await readFile(path)), effectiveBpm);
+        metrics = analyzeMotion(decodeWav(await readFile(path)), barSeconds ?? (effectiveBpm ? (60 / effectiveBpm) * 4 : undefined));
     }
     catch (e) {
         return error(`Could not analyze ${path}: ${e.message}`);
@@ -1745,69 +2212,6 @@ server.registerTool("variation_distinctness", {
         corpusHabit: "Shipped variations mostly change modulation and groove; they almost never change samples or FX chain order. Those two are therefore the least-used lever available to you.",
     });
 });
-// Standard full update — graph dispatch + KV sync + parameter updates.
-const KV_OPTS_STANDARD = {
-    shouldDispatch: true,
-    syncKVResources: true,
-    syncConfigResources: true,
-    resyncKVAfterDispatch: true,
-    updateParameters: true,
-    broadcastFollowers: true,
-};
-// Modulation update — same as standard but no follower broadcast.
-const KV_OPTS_MOD = {
-    shouldDispatch: true,
-    syncKVResources: true,
-    syncConfigResources: true,
-    resyncKVAfterDispatch: true,
-    updateParameters: true,
-    broadcastFollowers: false,
-};
-// Pattern/sequencer update — KV-only, no graph rebuild, no param updates.
-const KV_OPTS_PATTERN = {
-    shouldDispatch: true,
-    syncKVResources: true,
-    syncConfigResources: false,
-    skipFileLoadingIfUnchanged: true,
-    resyncKVAfterDispatch: false,
-    updateParameters: false,
-    broadcastFollowers: false,
-};
-// Master-chain config — KV + config-resource sync, NO graph dispatch. Every
-// master key (comp incl. the full promoted Punch surface, tape, iron, clipper,
-// limiter, EQ/width) is live-polled from master_config by its native node, so
-// a rebuild here is pure dropout risk (the plan's no-rebuild contract).
-// Mirrors interop.ts updateMasterConfig's options.
-const KV_OPTS_MASTER_CONFIG = {
-    shouldDispatch: false,
-    syncKVResources: true,
-    syncConfigResources: true,
-    skipFileLoadingIfUnchanged: true,
-    resyncKVAfterDispatch: false,
-    updateParameters: true,
-    broadcastFollowers: false,
-};
-// Effect config toggle — lighter KV path, no graph dispatch.
-const KV_OPTS_EFFECT_CONFIG = {
-    shouldDispatch: false,
-    syncKVResources: true,
-    syncConfigResources: true,
-    skipFileLoadingIfUnchanged: true,
-    resyncKVAfterDispatch: false,
-    updateParameters: true,
-    broadcastFollowers: true,
-};
-// Cell config update — KV-only, syncs cell config resources, no graph dispatch.
-// Matches interop.ts updateCellConfig() options.
-const KV_OPTS_CELL_CONFIG = {
-    shouldDispatch: false,
-    syncKVResources: true,
-    syncConfigResources: true,
-    skipFileLoadingIfUnchanged: true,
-    resyncKVAfterDispatch: false,
-    updateParameters: true,
-    broadcastFollowers: false,
-};
 async function applyKv(delta, options, directNodeOps) {
     const payload = { delta, options };
     if (directNodeOps)
@@ -1890,6 +2294,29 @@ server.registerTool("get_design_overview", {
         vary: Array.isArray(state.vary) ? state.vary : [],
         paramSeq: Array.isArray(state.paramSeqs) ? state.paramSeqs : [],
     };
+    if (isMsqManifest(manifest)) {
+        const cells = ids.map((id) => {
+            const rawCell = cellsObj[String(id)];
+            const targets = new Set([`cell${id}_`]);
+            return {
+                ...msqCellSummary(id, isRecord(rawCell) ? rawCell : {}, state),
+                modulation: Object.fromEntries(Object.entries(modArrays).map(([kind, arr]) => [kind, arr.filter((entry) => paramTargetsCell(entry, targets)).length])),
+            };
+        });
+        return json({
+            product: manifest.name,
+            bpm: state.bpm ?? transport.bpm,
+            playing: transport.isPlaying,
+            totals: {
+                cellsSending: cells.filter((cell) => cell.send && !cell.muted).length,
+                playersRunning: cells.filter((cell) => cell.player).length,
+                noteEvents: cells.reduce((sum, cell) => sum + cell.noteEvents, 0),
+                ccSlots: cells.reduce((sum, cell) => sum + cell.ccOut.length, 0),
+                modulationLinks: cells.reduce((sum, cell) => sum + Object.values(cell.modulation).reduce((subtotal, count) => subtotal + count, 0), 0),
+            },
+            cells,
+        });
+    }
     if (IS_MFX_SERVER) {
         const cells = ids.map((id) => {
             const prefix = `cell${id}_`;
@@ -1917,8 +2344,9 @@ server.registerTool("get_design_overview", {
         return json({
             product: manifest.name,
             bpm: state.bpm ?? transport.bpm,
-            playing: transport.playing,
+            playing: transport.isPlaying,
             mix: state.mfx_mix,
+            outputGain: state.mfx_outputGain,
             routing: state.mfx_routing,
             edgeGains: state.mfx_edge_gains,
             split: { lowHz: state.mfx_split_lo_hz, highHz: state.mfx_split_hi_hz },
@@ -1956,10 +2384,14 @@ server.registerTool("get_design_overview", {
             synthEngine: describeSynthEngine(state[`${prefix}synthEngine`]),
             player: describeCellPlayer(id, cellState, state),
             enabledEffects: effectNames.filter((effectName) => state[`${prefix}${effectName}Enabled`] === 1 || state[`${prefix}${effectName}Enabled`] === true),
-            patternEvents: Object.fromEntries(Object.entries(PATTERN_LANES).map(([lane, suffix]) => [
+            patternEvents: Object.fromEntries(Object.entries(PATTERN_LANE_SUFFIX).map(([lane, suffix]) => [
                 lane,
                 countEvents(state[`${prefix}${suffix}`]),
             ])),
+            laneTargets: Object.fromEntries(PARAM_LANES.flatMap((lane) => {
+                const target = cellState[LANE_TARGET_FIELD[lane]];
+                return typeof target === "string" && target ? [[lane, target]] : [];
+            })),
             modulation,
             mixer: {
                 volume: state[`${prefix}volume`],
@@ -1971,7 +2403,7 @@ server.registerTool("get_design_overview", {
     return json({
         product: manifest.name,
         bpm: state.bpm ?? transport.bpm,
-        playing: transport.playing,
+        playing: transport.isPlaying,
         masterFx: {
             compressorEnabled: state.masterCompressorEnabled,
             limiterEnabled: state.masterLimiterEnabled,
@@ -2067,14 +2499,7 @@ server.registerTool("set_parameters", {
     }
     await bridge.send("applyUnifiedStateKvUpdate", {
         delta,
-        options: {
-            shouldDispatch: true,
-            syncKVResources: true,
-            syncConfigResources: true,
-            resyncKVAfterDispatch: true,
-            updateParameters: true,
-            broadcastFollowers: true,
-        },
+        options: STATE_UPDATE_KV_OPTIONS,
     });
     return text(`Set ${Object.keys(parameters).length} parameter(s): ${Object.entries(parameters).map(([k, v]) => `${k}=${v}`).join(", ")}` +
         (comboTargetCount > 0 ? `; fanned out ${comboTargetCount} MFX combo target write(s)` : ""));
@@ -2106,9 +2531,25 @@ const MODEL_VARIANT = z
     .describe("Magenta only: which variant (base = 2.4B, needs ~M2 Max/M3 Pro+; small = 230M, default). Ignored for notochord/aigen (single model).");
 server.registerTool("download_model", {
     title: "Download AI Model",
-    description: "Start (or resume) downloading model weights for an AI engine. Async — returns immediately with download progress; poll get_model_status. aigen + notochord auto-load on completion; magenta needs a separate load_model. Requires the engine's experimental flags.",
+    description: "Start (or resume) downloading model weights for an AI engine. Returns at once with the download's progress (in a pam mcp session, the daemon job's jobId); poll get_model_status. Downloads through PAM need the engine's experimental flags, and aigen + notochord then auto-load on completion; magenta and pam mcp session downloads need a separate load_model.",
     inputSchema: { engine: MODEL_ENGINE, model: MODEL_VARIANT },
 }, async ({ engine, model }) => {
+    if (DAEMON_SESSION && engine !== "notochord") {
+        try {
+            const running = daemonDownloads.get(engine);
+            if (running?.model === daemonModel(engine, model)) {
+                const job = await daemon.downloadStatus(running).catch(() => undefined);
+                if (job?.inFlight)
+                    return json({ ok: true, ...job });
+            }
+            const download = await daemon.startDownload(daemonModel(engine, model));
+            daemonDownloads.set(engine, download);
+            return json(download);
+        }
+        catch (cause) {
+            return daemonFailure(cause);
+        }
+    }
     const check = await requireBridge();
     if (check !== true)
         return check;
@@ -2127,8 +2568,30 @@ server.registerTool("get_model_status", {
         version: z.string().optional(),
         state: z.string().optional(),
         progress: z.number().optional(),
+        jobId: z.string().optional(),
+        daemonEpoch: z.string().optional(),
     },
 }, async ({ engine }) => {
+    const download = DAEMON_SESSION ? daemonDownloads.get(engine) : undefined;
+    let job;
+    if (download) {
+        try {
+            job = await daemon.downloadStatus(download);
+        }
+        catch (cause) {
+            // A job pamd no longer knows stops shadowing the plugin's own status.
+            if (!LOST_DAEMON_JOB.has(daemonFailureCode(cause) ?? ""))
+                return daemonFailure(cause);
+            daemonDownloads.delete(engine);
+        }
+    }
+    if (job) {
+        const plugin = bridge.isConnected() || await bridge.connect()
+            ? await bridge.send("modelStatus", { engine }).then((raw) => typeof raw === "string" ? JSON.parse(raw) : raw).catch(() => undefined)
+            : undefined;
+        const live = isRecord(plugin) ? plugin : { engine };
+        return structured(job.inFlight ? { ...live, ...job } : { ...job, ...live });
+    }
     const check = await requireBridge();
     if (check !== true)
         return check;
@@ -2156,9 +2619,33 @@ server.registerTool("unload_model", {
 });
 server.registerTool("delete_model", {
     title: "Delete AI Model",
-    description: "Delete downloaded model weights from disk. Unloads first automatically. DESTRUCTIVE — re-download to restore. magenta delete is variant-agnostic (removes both variants + shared resources).",
+    description: "Delete downloaded model weights from disk. Unloads first automatically. DESTRUCTIVE — re-download to restore. For magenta, model (small|base) removes that variant and keeps the resources the other installed variant shares; omit model to remove both variants and the shared resources.",
     inputSchema: { engine: MODEL_ENGINE, model: MODEL_VARIANT },
-}, async ({ engine, model }) => {
+}, async ({ engine, model }, extra) => {
+    if (DAEMON_SESSION && engine !== "notochord") {
+        const models = engine === "magenta" && !model ? ["mrt2-small", "mrt2-base"] : [daemonModel(engine, model)];
+        try {
+            if (bridge.isConnected() || await bridge.connect()) {
+                try {
+                    await bridge.send("modelDelete", { engine, model });
+                }
+                catch (cause) {
+                    const name = engine === "aigen" ? "AIGen" : "Magenta";
+                    if (!(cause instanceof Error) || !cause.message.startsWith(`[modelDelete] ${name} disabled —`))
+                        throw cause;
+                }
+            }
+            const results = [];
+            for (const id of models)
+                results.push(await daemon.remove(id, extra?.signal));
+            if (models.includes(daemonDownloads.get(engine)?.model ?? ""))
+                daemonDownloads.delete(engine);
+            return json(results);
+        }
+        catch (cause) {
+            return daemonFailure(cause);
+        }
+    }
     const check = await requireBridge();
     if (check !== true)
         return check;
@@ -2176,22 +2663,18 @@ server.registerTool("list_models", {
 });
 server.registerTool("generate_sample", {
     title: "Generate Sample (AI)",
-    description: "Generate a new audio sample via the on-device AI engine (Stable Audio 3 Small SFX, 2.71 GB). The plugin must have the model downloaded first (Settings → Local models). Returns the on-disk path to the generated WAV and optionally loads it into a cell.",
+    description: "Generate a new audio sample from a text prompt via the on-device AI engine (Stable Audio 3 Small SFX, 2.71 GB; text-to-audio only — audio-to-audio lives in the Workbench tools). The plugin must have the model downloaded first (Settings → Local models). Returns the on-disk path to the generated WAV and optionally loads it into a cell.",
     inputSchema: {
         category: z
             .enum(["kick", "snare", "hat", "perc", "bass", "synth", "pad", "fx", "loop"])
             .describe("Sound category — drives prompt template defaults."),
         prompt: z.string().describe("Text prompt describing the desired sound."),
+        // The plugin renders Small SFX: OnnxAIGenEngine::kMinDurationSeconds and its Sa3Layout maximum.
         durationSeconds: z
             .number()
-            .min(0.1)
-            .max(47)
-            .describe("Output length in seconds (Stable Audio 3 Small SFX engine cap ≈ 47 s). For loops, pass bar-converted duration: bars * beatsPerBar * 60 / bpm."),
-        mode: z
-            .enum(["text", "inpaint", "continuation"])
-            .optional()
-            .default("text")
-            .describe("Generation mode. text = unconditional, inpaint = audio-to-audio with mask, continuation = extend existing audio."),
+            .min(0.05)
+            .max(120)
+            .describe("Output length in seconds (the model's window is ~120 s). For loops, pass bar-converted duration: bars * beatsPerBar * 60 / bpm."),
         cellId: z
             .number()
             .int()
@@ -2199,28 +2682,32 @@ server.registerTool("generate_sample", {
             .max(8)
             .optional()
             .describe("If provided, load result directly into this cell."),
-        seed: z.number().int().optional().describe("Deterministic seed. Random if omitted."),
-        refAudioPath: z.string().optional().describe("Required for inpaint/continuation. Absolute path to a WAV."),
-        maskSpec: z
-            .string()
+        seed: z
+            .number()
+            .int()
+            .min(0)
+            .max(4294967295)
             .optional()
-            .describe('Mask spec for inpaint mode: "tail:0.5" or "transient:0-0.05" or "full".'),
+            .describe("Deterministic seed. Random if omitted or 0; the result's seed reproduces the take."),
     },
-}, async (args) => {
+}, async (args, extra) => {
     const ok = await requireBridge();
     if (ok !== true)
         return ok;
     try {
-        const result = await bridge.send("aiGenerate", args);
+        const cells = await requireBridgeForCells(args.cellId);
+        if (cells !== true)
+            return cells;
+        const result = DAEMON_SESSION ? await pinnedGeneration(args, undefined, extra?.signal) : await bridge.send("aiGenerate", args);
         return json(result);
     }
     catch (e) {
-        return error(`AI generation failed: ${e.message}`);
+        return DAEMON_SESSION ? daemonFailure(e, "AI generation failed: ") : error(`AI generation failed: ${e.message}`);
     }
 });
 server.registerTool("generate_kit", {
     title: "Generate Kit (AI)",
-    description: "Generate multiple AI samples in parallel (Stable Audio 3 Small SFX) and load them into a list of cells. Useful for building a coherent drum / instrument kit from a single high-level prompt. Requires the on-device model to be downloaded (Settings → Local models).",
+    description: "Generate multiple AI samples one after another (Stable Audio 3 Small SFX) and load them into a list of cells. Useful for building a coherent drum / instrument kit from a single high-level prompt. Requires the on-device model to be downloaded (Settings → Local models).",
     inputSchema: {
         prompt: z.string().describe('High-level kit description (e.g. "dark trap drum kit", "lofi house").'),
         cells: z
@@ -2232,7 +2719,7 @@ server.registerTool("generate_kit", {
             .max(8)
             .describe("Cells to populate. Each gets one sample matching the role."),
     },
-}, async (args) => {
+}, async (args, extra) => {
     const ok = await requireBridge();
     if (ok !== true)
         return ok;
@@ -2248,11 +2735,29 @@ server.registerTool("generate_kit", {
         durationSeconds: durationForRole(c.role),
     }));
     try {
+        if (DAEMON_SESSION) {
+            const check = await requireBridgeForCells(...cells.map((cell) => cell.id));
+            if (check !== true)
+                return check;
+            const instance = bridge.getConnectedInstance();
+            const destination = new PluginBridge();
+            if (!instance || !await destination.connect({ instanceId: instance.instanceId, product: instance.product }))
+                return error("plugin_unavailable: selected instance disconnected");
+            try {
+                const results = [];
+                for (const request of requests)
+                    results.push(await pinnedGeneration(request, destination, extra?.signal));
+                return json(results);
+            }
+            finally {
+                destination.disconnect();
+            }
+        }
         const results = await bridge.send("aiGenerateKit", { requests });
         return json(results);
     }
     catch (e) {
-        return error(`Kit generation failed: ${e.message}`);
+        return DAEMON_SESSION ? daemonFailure(e, "Kit generation failed: ") : error(`Kit generation failed: ${e.message}`);
     }
 });
 // --- AI Audio Workbench (Phase A, dev-gated) ---------------------------------
@@ -2319,7 +2824,7 @@ server.registerTool("workbench_set_state", {
 server.registerTool("workbench_render", {
     title: "Workbench: Render",
     description: WORKBENCH_PREREQ +
-        "Render the Workbench transform via the SA3 sidecar and append the result to the take shelf. Renders the CURRENT canvas state merged with any overrides passed here (overrides do not persist). Blocks until done (up to ~3 min: pipeline rebuilds + multi-region inpaints render sequentially). Returns the take { id, wavPath, prompt, seed, sigma, maskRegions, createdAt, sourceCellId, durationSeconds, error? }. Source resolution: sourcePath override > activeSourcePath (chain head) > state.sourceCellId's sample file. A successful render ADVANCES the chain (activeSourcePath = new take's wavPath) — step back with workbench_undo or workbench_reset_chain.",
+        "Render the Workbench transform via the SA3 sidecar and append the result to the take shelf. Renders the CURRENT canvas state merged with any overrides passed here (overrides do not persist). Waits until done (up to ~10 min: pipeline rebuilds + multi-region inpaints render sequentially). Returns the take { id, wavPath, prompt, seed, sigma, maskRegions, createdAt, sourceCellId, sourcePath, durationSeconds, activeSourcePath, chainAdvanced, error? }. Source resolution: sourcePath override > activeSourcePath (chain head) > state.sourceCellId's sample file (a sourceCellId override renders that cell's sample). A successful render of the canvas's own source ADVANCES the chain (activeSourcePath = new take's wavPath) — step back with workbench_undo or workbench_reset_chain; renders with a sourcePath/sourceCellId override, or that finished after the chain moved, leave the head alone (chainAdvanced: false).",
     inputSchema: {
         ...WORKBENCH_STATE_FIELDS,
         sourcePath: z.string().optional()
@@ -2506,17 +3011,16 @@ server.registerTool("add_modulation", {
     },
 }, async ({ type, paramId, cellId, lfoIndex, strength, bipolar, pitch, pitchDuck }) => {
     const index = await getParameterIndex();
-    const param = index.get(paramId);
-    if (!param)
-        return error(formatUnknownParamError(paramId, index, { modulatableOnly: true }));
-    if (!param.isModulatable)
-        return error(formatNotModulatableError(paramId, index));
+    const param = await resolveModulationTarget(paramId, index);
+    if (typeof param === "string")
+        return error(param);
     const check = await requireBridgeForCells(cellId);
     if (check !== true)
         return check;
     // Compute effect-enabled params to auto-enable disabled effects (mirrors UI behavior)
     const effectEnableParams = {};
-    if (param.effect && param.cell) {
+    // Only cells have per-effect flags; native enables a macro target itself (MCPBridge::handleAddModulation).
+    if (param.effect && /^cell\d+$/.test(param.cell ?? "")) {
         effectEnableParams[`${param.cell}_${param.effect}Enabled`] = 1;
     }
     if (type === "lfo") {
@@ -2536,34 +3040,42 @@ server.registerTool("add_modulation", {
     }
     return text(`Added ${type} modulation to ${paramId} (strength: ${strength}%).`);
 });
+/** The full parameter rows (ranges, isModulatable) a lane target is checked against. */
+async function laneTargetParameters() {
+    return loadManifest()
+        .then((manifest) => manifest.parameters)
+        .catch(() => []);
+}
+/** A cell's param-lane target suffix ("" = none). */
+async function laneTargetOf(cellId, lane) {
+    const cells = await bridge.send("getState", "cells").catch(() => undefined);
+    const cell = isRecord(cells) ? cells[String(cellId)] : undefined;
+    const target = isRecord(cell) ? cell[LANE_TARGET_FIELD[lane]] : undefined;
+    return typeof target === "string" ? target : "";
+}
 server.registerTool("update_pattern", {
     title: "Update Pattern",
-    description: "Write a note, pitch, slice, or stretch sequence to a cell's pattern sequencer.",
+    description: "Write one lane of a cell's pattern: the notes, a value lane (pitch, slice, stretch), a CC lane (ccOut1-ccOut4, " +
+        "the timeline of that CC out slot: each event sends its value on the slot's controller for its duration, then the " +
+        "slot returns to its knob) or a PAM param lane (paramLane1-paramLane4: each event sets the parameter the lane " +
+        "targets for its duration, in that parameter's units). MSQ has note and CC lanes; MFX has none.",
     inputSchema: {
         cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
-        type: z
-            .enum(["note", "pitch", "slice", "stretch"])
-            .describe("Pattern lane type."),
+        type: z.enum(PATTERN_LANE_IDS).describe("Pattern lane."),
         sequence: z
             .array(z.any())
             .describe("Array of sequence events. For 'note': [{time, note, duration, velocity, prob}]. " +
-            "For 'pitch'/'slice'/'stretch': [{time, value, duration}]."),
+            "For value and CC lanes: [{time, value, duration, prob?}] (CC values 0-127; times and durations in beats)."),
     },
 }, async ({ cellId, type, sequence }) => {
     const check = await requireBridgeForCells(cellId);
     if (check !== true)
         return check;
-    // Map pattern type to state key suffix
-    const keyMap = {
-        note: "midiSequence",
-        midi: "midiSequence",
-        pitch: "pitchSequence",
-        slice: "sliceSequence",
-        stretch: "stretchSequence",
-    };
-    const suffix = keyMap[type];
-    if (!suffix)
-        return error(`Unknown pattern type: ${type}`);
+    const manifest = await loadManifestForProductGuard();
+    if (manifest && !productHasLane(cellId, type, manifest.stateVariables)) {
+        return error(`${manifest.name ?? "This product"} has no ${type} lane.`);
+    }
+    const suffix = PATTERN_LANE_SUFFIX[type];
     // For note sequences, fill in required defaults that PAM's sequencer expects
     let normalizedSequence = sequence;
     if (suffix === "midiSequence") {
@@ -2586,22 +3098,79 @@ server.registerTool("update_pattern", {
             value: evt.value ?? evt.velocity ?? 127,
         }));
     }
+    if (isCcLane(type))
+        normalizedSequence = normalizeCcLaneEvents(sequence);
+    if (isParamLane(type)) {
+        const target = await laneTargetOf(cellId, type);
+        if (!target)
+            return error(`Cell ${cellId}'s ${type} has no target parameter: pick one with set_lane_target first.`);
+        const resolved = resolveLaneTarget(cellId, target, await laneTargetParameters());
+        if ("reason" in resolved)
+            return error(`The ${type} lane targets ${target}: ${resolved.reason}.`);
+        normalizedSequence = normalizeTargetLaneEvents(sequence, resolved.param);
+    }
     const stateKey = `cell${cellId}_${suffix}`;
     await bridge.send("applyUnifiedStateKvUpdate", {
         delta: { [stateKey]: normalizedSequence, __forceRender__: true },
-        options: {
-            shouldDispatch: true,
-            syncKVResources: true,
-            syncConfigResources: false,
-            skipFileLoadingIfUnchanged: true,
-            resyncKVAfterDispatch: false,
-            updateParameters: false,
-            broadcastFollowers: false,
-        },
+        options: PATTERN_EDIT_KV_OPTIONS,
         directNodeOps: [{ key: stateKey, property: "sequence", value: normalizedSequence }],
     });
     return text(`Updated ${type} pattern for cell ${cellId} (${normalizedSequence.length} events).`);
 });
+server.registerTool("set_lane_target", {
+    title: "Set Lane Target",
+    description: "Point one of a PAM cell's four param lanes (paramLane1-paramLane4) at a modulatable parameter of the same cell " +
+        "(a suffix such as 'filterCutoff'), or clear it with null. Each lane event then sets that parameter for its " +
+        "duration; outside events the parameter follows its knob and modulation. Each param lane loops at its own " +
+        "clock, cell{N}_patternLengthParam{K} and cell{N}_patternSpeedParam{K} (set_parameters; 4 beats at 1x by default), " +
+        "while swing and direction follow the note lane; copy the note lane's length and speed to match it. The lane is cleared (its values meant the old target); another param lane already on that " +
+        "parameter is cleared too. Write the lane with update_pattern in the target's units. For a free-running step " +
+        "contour that adds to the knob, use a ParamSeq instead.",
+    inputSchema: {
+        cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
+        lane: z.enum(PARAM_LANES).describe("Param lane to point."),
+        param: z.string().min(1).nullable().describe("Target parameter suffix (no cellN_ prefix), or null for none."),
+    },
+}, async ({ cellId, lane, param }) => {
+    const check = await requireBridgeForCells(cellId);
+    if (check !== true)
+        return check;
+    const manifest = await loadManifestForProductGuard();
+    if (manifest && !productHasLane(cellId, lane, manifest.stateVariables)) {
+        return error(`${manifest.name ?? "This product"} has no ${lane} lane.`);
+    }
+    let targetParam = null;
+    if (param !== null) {
+        const resolved = resolveLaneTarget(cellId, param, await laneTargetParameters());
+        if ("reason" in resolved)
+            return error(`Cannot target ${param}: ${resolved.reason}.`);
+        targetParam = resolved.param;
+    }
+    const cells = await bridge.send("getState", "cells").catch(() => undefined);
+    const cell = isRecord(cells) ? cells[String(cellId)] : undefined;
+    const target = param ?? "";
+    const current = isRecord(cell) && typeof cell[LANE_TARGET_FIELD[lane]] === "string" ? cell[LANE_TARGET_FIELD[lane]] : "";
+    if (current === target)
+        return text(`Cell ${cellId} ${lane} already ${target ? `→ ${target}` : "has no target"}; nothing changed.`);
+    const cellDelta = { [LANE_TARGET_FIELD[lane]]: target };
+    const delta = { [`cell${cellId}_${PATTERN_LANE_SUFFIX[lane]}`]: [] };
+    const reverted = [];
+    for (const sibling of PARAM_LANES) {
+        if (sibling === lane || !target || !isRecord(cell) || cell[LANE_TARGET_FIELD[sibling]] !== target)
+            continue;
+        cellDelta[LANE_TARGET_FIELD[sibling]] = "";
+        delta[`cell${cellId}_${PATTERN_LANE_SUFFIX[sibling]}`] = [];
+        reverted.push(sibling);
+    }
+    delta.cells = { [cellId]: cellDelta };
+    // Same as add_modulation: a lane on a bypassed effect's param turns the effect on.
+    if (targetParam?.effect && targetParam.cell)
+        delta[`${targetParam.cell}_${targetParam.effect}Enabled`] = 1;
+    await applyKv(delta, STATE_UPDATE_KV_OPTIONS);
+    const where = target ? `→ ${target}` : "target cleared";
+    const note = reverted.length ? ` ${reverted.join(", ")} lost that target and was cleared.` : "";
+    return text(`Cell ${cellId} ${lane} ${where}; lane cleared.${note}`);
+});
 server.registerTool("randomize", {
     title: "Randomize",
     description: "Trigger PAM's randomization engine to generate random sounds and patterns. " +
@@ -2723,10 +3292,8 @@ server.registerTool("randomize_samples", {
     let pool = allowedSamplePaths;
     let diversifyNote = "";
     if (!pool && diversify && diversify > 0) {
-        const locations = (await bridge.send("getDefaultLocations"));
-        const roots = Object.entries(locations ?? {})
-            .filter(([k, v]) => typeof v === "string" && v.length > 0 && /sample/i.test(k))
-            .map(([, v]) => v);
+        const locations = await defaultLocationPaths();
+        const roots = ["User Samples", "Factory Samples"].flatMap((name) => locations.get(name) ?? []);
         if (roots.length) {
             const byFolder = await collectLibraryByFolder(roots);
             const spread = spreadAcrossFolders(byFolder, diversify, seed ?? 0);
@@ -2827,12 +3394,14 @@ server.registerTool("full_stop_transport", {
 });
 server.registerTool("get_transport", {
     title: "Get Transport",
-    description: "Get current transport state (BPM, playing, position).",
+    description: "Get current transport state (BPM, playing, position, meter).",
     inputSchema: {},
     outputSchema: {
         bpm: z.number().optional(),
         isPlaying: z.boolean().optional(),
         ppqPosition: z.number().optional(),
+        timeSigNumerator: z.number().optional(),
+        timeSigDenominator: z.number().optional(),
     },
     annotations: { readOnlyHint: true },
 }, async () => {
@@ -2864,8 +3433,10 @@ server.registerTool("get_mix_analysis", {
     title: "Get Per-Cell Mix Analysis",
     description: "Per-cell stem measurements from a faster-than-realtime offline bounce: LUFS (i/s/roll), LRA, " +
         "true/sample peak (tp/sp), PSR/PLR crest, stereo correlation, onset density, and a 25-band Bark " +
-        "spectrum per cell, plus the full-mix master block. Pass refresh:true to run a new analysis " +
-        "(renders each sounding cell soloed from bar 0 — takes a few seconds; audio does NOT need to be " +
+        "spectrum per cell, plus the full-mix master block. Each cell also carries coact: {otherCellId: " +
+        "fraction of this cell's sounding time the other cell sounds too}. Pass refresh:true to run a new " +
+        "analysis (one in-context render from bar 0; each cell is measured at its post-fader output before " +
+        "the master chain, so muted cells read silent — takes a few seconds; audio does NOT need to be " +
         "playing). Cached result otherwise. Requires a PAM build with Mix Assist support.",
     inputSchema: {
         refresh: z.boolean().optional().describe("Run a fresh analysis instead of returning the cached one."),
@@ -2986,7 +3557,7 @@ server.registerTool("suggest_mix", {
         ? { balanceParked: true, note: "Auto Mix AUTO owns the balance — balance scope was skipped." }
         : {};
     if (apply && suggestion.moves.length > 0) {
-        await applyKv(suggestion.flat, KV_OPTS_STANDARD);
+        await applyKv(suggestion.flat, STATE_UPDATE_KV_OPTIONS);
         if (!analysis.live)
             lastAppliedMixEpoch = analysis.epoch;
         return json({ ...suggestion, ...parkedNote, applied: true });
@@ -3070,7 +3641,7 @@ server.registerTool("save_preset", {
     }
     const metadata = { name, factory: false };
     if (path !== undefined)
-        metadata.path = path;
+        metadata.path = nativePresetPath(path);
     for (const [k, v] of Object.entries(extras)) {
         if (v !== undefined)
             metadata[k] = v;
@@ -3169,7 +3740,7 @@ server.registerTool("save_variation", {
     let resultSuffix = "";
     const destinationPath = normalizePresetLookupPath(diskPath);
     if (!name && !destinationPath.startsWith("Factory/")) {
-        metadata.path = destinationPath;
+        metadata.path = nativePresetPath(destinationPath);
     }
     else if (sourcePath.startsWith("Factory/")) {
         // Cannot write back to factory location; savePreset will create User/{name}.preset
@@ -3280,6 +3851,9 @@ server.registerTool("trim_sample", {
     const check = await requireBridgeForCells(cellId);
     if (check !== true)
         return check;
+    const loaded = await requireCellSample(cellId);
+    if (loaded !== true)
+        return loaded;
     await bridge.send("trimSampleForCell", cellId);
     return text(`Trimmed sample in cell ${cellId}.`);
 });
@@ -3293,6 +3867,9 @@ server.registerTool("reverse_sample", {
     const check = await requireBridgeForCells(cellId);
     if (check !== true)
         return check;
+    const loaded = await requireCellSample(cellId);
+    if (loaded !== true)
+        return loaded;
     await bridge.send("reverseSampleForCell", cellId);
     return text(`Reversed sample in cell ${cellId}.`);
 });
@@ -3316,15 +3893,15 @@ server.registerTool("connection_status", {
     annotations: { readOnlyHint: true },
 }, async () => {
     const discoveredInstances = await bridge.discover();
-    const instances = IS_MFX_SERVER
-        ? discoveredInstances.filter((instance) => instance.product?.trim().toLowerCase() === "mfx")
+    const instances = PINNED_PRODUCT
+        ? discoveredInstances.filter((instance) => instance.product?.trim().toLowerCase() === PINNED_PRODUCT)
         : discoveredInstances;
     if (instances.length === 0) {
         return structured({
             instances: [],
             connected: false,
             note: `No running ${SERVER_PRODUCT.name} instances found. To use live tools, ${SERVER_PRODUCT.name} needs the MCP bridge enabled: ` +
-                `start ${SERVER_PRODUCT.name} (standalone or in a DAW) and enable it in Settings → Experimental. ` +
+                `start ${SERVER_PRODUCT.name} (standalone or in a DAW) and enable it in Settings → Integrations → MCP Bridge. ` +
                 "Offline tools (get_parameter_info, list_presets, read_preset) work without a connection.",
         });
     }
@@ -3342,6 +3919,54 @@ server.registerTool("connection_status", {
             : "Found instances but could not connect. The plugin may have shut down.",
     });
 });
+// A plugin instance's pid is its DAW, so `ps` names the host; the plugin's own
+// binary is one of the host's mapped files (e.g. PAM.vst3/Contents/MacOS/PAM).
+function hostedPluginBinaries(pid, product) {
+    const pluginBinary = new RegExp(`/${product}\\.(?:vst3|component|clap)/Contents/MacOS/${product}$`, "i");
+    try {
+        const mapped = execFileSync("lsof", ["-a", "-p", String(pid), "-d", "txt", "-Fn"], {
+            encoding: "utf8",
+            timeout: 5000,
+        });
+        return [...new Set(mapped.split("\n").filter((line) => line.startsWith("n")).map((line) => line.slice(1)))]
+            .filter((path) => pluginBinary.test(path));
+    }
+    catch {
+        return [];
+    }
+}
+// build.js restages plugins with size and mtime intact, so an identical file in
+// the checkout's build tree identifies a development build.
+function matchesRepoBuild(binary, projectRoot) {
+    const entries = (path) => {
+        try {
+            return readdirSync(path);
+        }
+        catch {
+            return [];
+        }
+    };
+    try {
+        const target = statSync(binary);
+        const bundlePath = binary.split("/").slice(-4).join("/");
+        const darwin = join(resolve(projectRoot), "build", "Darwin");
+        for (const config of entries(darwin))
+            for (const artefacts of entries(join(darwin, config)).filter((name) => name.endsWith("_artefacts")))
+                for (const mode of entries(join(darwin, config, artefacts)))
+                    for (const format of entries(join(darwin, config, artefacts, mode))) {
+                        const candidate = join(darwin, config, artefacts, mode, format, bundlePath);
+                        if (!existsSync(candidate))
+                            continue;
+                        const stats = statSync(candidate);
+                        if (stats.size === target.size && Math.abs(stats.mtimeMs - target.mtimeMs) < 1000)
+                            return true;
+                    }
+    }
+    catch {
+        /* binary or build tree unreadable */
+    }
+    return false;
+}
 server.registerTool("situation", {
     title: "Situation",
     description: "One-call orientation snapshot: discovered instances, the connected instance's product/pid/executable " +
@@ -3359,21 +3984,34 @@ server.registerTool("situation", {
     let build;
     if (instance?.pid) {
         try {
-            const executable = execFileSync("ps", ["-o", "comm=", "-p", String(instance.pid)], {
+            const processExecutable = execFileSync("ps", ["-o", "comm=", "-p", String(instance.pid)], {
                 encoding: "utf8",
             }).trim();
-            if (executable) {
-                build = {
-                    executable,
-                    looksLikeDevBuild: executable.includes("/build/") && !executable.startsWith("/Applications/"),
-                };
+            if (processExecutable) {
+                const product = instance.product ?? SERVER_PRODUCT.name;
+                const projectRoot = process.env.PAM_PROJECT_ROOT;
+                const hosted = basename(processExecutable).toLowerCase() !== product.toLowerCase();
+                const pluginBinaries = hosted ? hostedPluginBinaries(instance.pid, product) : [];
+                const executable = hosted ? (pluginBinaries.length === 1 ? pluginBinaries[0] : undefined) : processExecutable;
+                build = hosted ? { host: processExecutable } : {};
+                if (pluginBinaries.length > 1)
+                    build.pluginBinaries = pluginBinaries;
+                if (executable) {
+                    build.executable = executable;
+                    if (!hosted) {
+                        build.looksLikeDevBuild = executable.includes("/build/") && !executable.startsWith("/Applications/");
+                    }
+                    else if (projectRoot) {
+                        build.looksLikeDevBuild = matchesRepoBuild(executable, projectRoot);
+                    }
+                }
                 try {
-                    build.executableMtime = statSync(executable).mtime.toISOString();
+                    if (executable)
+                        build.executableMtime = statSync(executable).mtime.toISOString();
                 }
                 catch {
                     /* executable path unreadable from this process */
                 }
-                const projectRoot = process.env.PAM_PROJECT_ROOT;
                 if (projectRoot && typeof build.executableMtime === "string") {
                     try {
                         const headIso = execFileSync("git", ["-C", resolve(projectRoot), "log", "-1", "--format=%cI"], { encoding: "utf8" }).trim();
@@ -3409,10 +4047,23 @@ server.registerTool("situation", {
                     .filter((cell) => typeof cell === "string" && /^cell\d+$/.test(cell))
                     .map((cell) => Number(cell.replace("cell", ""))))].sort((a, b) => a - b);
             const cellsObj = isRecord(state.cells) ? state.cells : {};
+            const msq = isMsqManifest(manifest);
             const cells = ids.map((id) => {
                 const prefix = `cell${id}_`;
                 const rawCellState = cellsObj[String(id)];
                 const cellState = isRecord(rawCellState) ? rawCellState : {};
+                if (msq) {
+                    const summary = msqCellSummary(id, cellState, state);
+                    return {
+                        cellId: id,
+                        muted: summary.muted,
+                        send: summary.send,
+                        channel: summary.channel,
+                        player: summary.player?.name,
+                        noteEvents: summary.noteEvents,
+                        ccSlots: summary.ccOut.length,
+                    };
+                }
                 const samplePath = cellState.filePath ??
                     cellState.samplePath ??
                     state[`${prefix}filePath`] ??
@@ -3429,9 +4080,9 @@ server.registerTool("situation", {
             live = {
                 activePreset: state.activePresetPath,
                 bpm: state.bpm ?? transport.bpm,
-                playing: transport.playing,
+                playing: transport.isPlaying,
                 cells,
-                ...(IS_MFX_SERVER ? { mix: state.mfx_mix, routing: state.mfx_routing } : {}),
+                ...(IS_MFX_SERVER ? { mix: state.mfx_mix, outputGain: state.mfx_outputGain, routing: state.mfx_routing } : {}),
             };
         }
     }
@@ -3450,13 +4101,13 @@ server.registerTool("situation", {
 });
 server.registerTool("select_instance", {
     title: "Select Plugin Instance",
-    description: "Choose which running plugin instance (PAM / CELL1 / MFX) the live tools drive when more than " +
+    description: "Choose which running plugin instance (PAM / MFX / MSQ) the live tools drive when more than " +
         "one is running. Match by product name, instanceId, or port — connection_status lists them. " +
         "Reconnects if currently connected to a different instance, and points offline parameter " +
         "validation at the selected product's manifest. The PAM_BRIDGE_PRODUCT env var pins the same " +
         "choice at server launch.",
     inputSchema: {
-        product: z.string().optional().describe("Product name: PAM, CELL1, or MFX (case-insensitive)."),
+        product: z.string().optional().describe("Product name: PAM, MFX, or MSQ (case-insensitive)."),
         instanceId: z.string().optional().describe("Exact instanceId from connection_status."),
         port: z.number().int().optional().describe("Exact TCP port from connection_status."),
     },
@@ -3469,22 +4120,23 @@ server.registerTool("select_instance", {
     if (!product && !instanceId && port === undefined) {
         return error("Pass at least one of product, instanceId, or port. Call connection_status to list running instances.");
     }
-    if (IS_MFX_SERVER && product && product.trim().toLowerCase() !== "mfx") {
-        return error("The mfx-mcp launcher can select MFX instances only.");
+    if (PINNED_PRODUCT && product && product.trim().toLowerCase() !== PINNED_PRODUCT) {
+        return error(`The ${SERVER_PRODUCT.command} launcher can select ${SERVER_PRODUCT.name} instances only.`);
     }
-    const targetProduct = IS_MFX_SERVER ? "MFX" : product;
+    const targetProduct = PINNED_PRODUCT ? SERVER_PRODUCT.name : product;
     const ok = await bridge.connect({ product: targetProduct, instanceId, port });
     if (!ok) {
         const discovered = await bridge.discover();
-        const instances = IS_MFX_SERVER
-            ? discovered.filter((instance) => instance.product?.trim().toLowerCase() === "mfx")
+        const instances = PINNED_PRODUCT
+            ? discovered.filter((instance) => instance.product?.trim().toLowerCase() === PINNED_PRODUCT)
             : discovered;
         const listing = instances.length
             ? ` Running instances: ${instances
                 .map((i) => `${i.product} (port ${i.port}, id ${i.instanceId})`)
                 .join("; ")}.`
             : " No running instances found.";
-        return error(`No running instance matches that selector.${listing}`);
+        // pamd keys selection recovery on this code (PluginSession selectorNotFound); keep it with any rewording.
+        return { ...error(`No running instance matches that selector.${listing}`), _meta: { code: "instance_not_found" } };
     }
     syncProductHint();
     return structured({
@@ -3537,6 +4189,31 @@ async function searchSampleLibrary(rootPath, term, audioOnly) {
 }
 // Walk the library and return audio files grouped by their parent folder.
 // Bounded like searchSampleLibrary — this runs inside a tool call, not a job.
+// The sample-edit actions answer "ok" before their async edit runs, even on an empty cell.
+async function requireCellSample(cellId, field = "filePath") {
+    const cells = await bridge.send("getState", "cells").catch(() => undefined);
+    if (!isRecord(cells))
+        return true;
+    const cell = cells[String(cellId)];
+    const path = isRecord(cell) ? cell[field] : undefined;
+    if (typeof path === "string" && path.length > 0)
+        return true;
+    return error(field === "filePath" ? `Cell ${cellId} has no sample loaded.` : `Cell ${cellId} has no original sample to restore.`);
+}
+// getDefaultLocations returns [{name, path, icon}]; the names are fixed in FileHandler.
+async function defaultLocationPaths() {
+    const locations = await bridge.send("getDefaultLocations").catch(() => undefined);
+    const entries = Array.isArray(locations) ? locations : [];
+    return new Map(entries
+        .filter((entry) => isRecord(entry) && typeof entry.name === "string" && typeof entry.path === "string")
+        .map((entry) => [entry.name, entry.path]));
+}
+// Native exports to <base>/Export beside <base>/Samples ("Plugin Samples"); check-parity pins both.
+// MSQ keeps no sample folder, so its Export resolves from the product's own base folder.
+async function exportsFolder() {
+    const pluginSamples = (await defaultLocationPaths()).get("Plugin Samples");
+    return pluginSamples ? join(dirname(pluginSamples), "Export") : productExportDir();
+}
 async function collectLibraryByFolder(roots, maxDirReads = 120) {
     const byFolder = new Map();
     const queue = roots.map((path) => ({ path, depth: 0 }));
@@ -3721,17 +4398,21 @@ server.registerTool("export_preset", {
     const check = await requireBridge();
     if (check !== true)
         return check;
-    await bridge.send("exportPresetWithSamples", presetPath, outputFolderName);
-    return text(`Exported preset to: ${outputFolderName}`);
+    const result = await bridge.send("exportPresetWithSamples", nativePresetPath(presetPath), outputFolderName);
+    if (result === false) {
+        return error(`Export refused for ${presetPath}: the preset is missing, belongs to a preset pack, or the folder name is invalid.`);
+    }
+    return text(`Exported preset to: ${outputFolderName}.zip in ${SERVER_PRODUCT.name}'s Exports folder`);
 });
 server.registerTool("import_preset", {
     title: "Import Preset",
     description: "Import a preset from a zip file or folder into PAM's preset library. Returns the relative path of the " +
         "first imported preset, or an empty string on failure. Referenced samples are copied into the user sample " +
         "folder and the preset's paths are rewritten. A name already in the library is never overwritten: the " +
-        "import lands as <name>_1, <name>_2 and so on.",
+        "import lands as <name>_1, <name>_2 and so on. A downloaded .pampack file installs as a whole pack and " +
+        "returns true on success.",
     inputSchema: {
-        path: z.string().describe("Absolute path to the preset zip file or folder to import."),
+        path: z.string().describe("Absolute path to the preset zip file, folder or .pampack to import."),
     },
 }, async ({ path: presetPath }) => {
     const check = await requireBridge();
@@ -3740,6 +4421,158 @@ server.registerTool("import_preset", {
     const result = await bridge.send("importPreset", presetPath);
     return json(result);
 });
+const PACK_JOB_TERMINAL = new Set(["succeeded", "failed", "cancelled"]);
+const PACK_INSTALL_WAIT_MS = 15 * 60_000;
+function isPackFailure(value) {
+    return isRecord(value) && value.ok === false && typeof value.code === "string" && typeof value.error === "string";
+}
+// The failure shape pamd's CLI-backed tools return: structuredContent {ok:false, code, error}.
+function packFailure(code, message) {
+    const detail = { ok: false, code, error: message };
+    return {
+        content: [{ type: "text", text: JSON.stringify(detail, null, 2) }],
+        structuredContent: detail,
+        isError: true,
+    };
+}
+function parseBridgeValue(raw) {
+    if (typeof raw !== "string")
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** The connected instance's product; only a build that reports none falls back to the manifest. */
+async function connectedProduct() {
+    const reported = bridge.getConnectedInstance()?.product?.toUpperCase();
+    if (reported)
+        return reported;
+    const manifest = await loadManifestForProductGuard();
+    if (!manifest)
+        return undefined;
+    return isMfxManifest(manifest) ? "MFX" : isMsqManifest(manifest) ? "MSQ" : "PAM";
+}
+async function requirePackStore() {
+    const check = await requireBridge();
+    if (check !== true)
+        return check;
+    return (await connectedProduct()) === "MFX"
+        ? packFailure("pack_unsupported_product", "MFX has no preset pack store; packs are a PAM feature.")
+        : true;
+}
+const PACK_ENTRY = z.object({}).passthrough();
+const PACK_JOB_OUTPUT = {
+    jobId: z.string().optional(),
+    daemonEpoch: z.string().optional(),
+    state: z.string().optional(),
+    progress: z.number().optional(),
+    result: z.object({ packs: z.array(PACK_ENTRY).optional() }).passthrough().optional(),
+    error: z.object({ code: z.string().optional(), message: z.string().optional() }).passthrough().optional(),
+};
+server.registerTool("list_packs", {
+    title: "List Preset Packs",
+    description: "List the map.audio preset pack catalog with this machine's state: installed and catalog version, whether an " +
+        "update is available, whether the licence owns the pack or it is free with PAM, price and download size. " +
+        "Installed packs the catalog no longer lists appear with listed:false.",
+    inputSchema: {},
+    outputSchema: { packs: z.array(PACK_ENTRY) },
+}, async () => {
+    const check = await requirePackStore();
+    if (check !== true)
+        return check;
+    const listing = parseBridgeValue(await bridge.send("listPacks"));
+    if (isPackFailure(listing))
+        return packFailure(listing.code, listing.error);
+    return structured(listing);
+});
+server.registerTool("install_pack", {
+    title: "Install Preset Packs",
+    description: "Download and install preset packs the licence owns (free packs need an active PAM licence), one at a time. " +
+        "Pass packIds, or allOwned:true for every owned pack that is missing or outdated. Waits for the installs and " +
+        "returns {packs:[{packId, version, state}]}; detach:true returns the job at once. A requestKey makes a retry " +
+        "return the original job instead of downloading again. An unowned pack fails with pack_license_required.",
+    inputSchema: {
+        packIds: z.array(z.string().min(1)).min(1).max(64).optional().describe("Pack ids from the catalog, e.g. 'eko'."),
+        allOwned: z.boolean().optional().describe("Install every owned pack that is missing or outdated."),
+        requestKey: z.string().max(128).optional().describe("Stable caller key; reuse it to recover the same job."),
+        detach: z.boolean().optional().describe("Return the job without waiting for the installs."),
+    },
+    outputSchema: { ...PACK_JOB_OUTPUT, packs: z.array(PACK_ENTRY).optional(), note: z.string().optional() },
+}, async ({ packIds, allOwned, requestKey, detach }) => {
+    if (Boolean(packIds?.length) === Boolean(allOwned))
+        return packFailure("usage", "Pass packIds or allOwned:true, not both.");
+    const check = await requirePackStore();
+    if (check !== true)
+        return check;
+    const started = parseBridgeValue(await bridge.send("installPack", {
+        ...(packIds?.length ? { packIds } : {}),
+        ...(allOwned ? { allOwned: true } : {}),
+        ...(requestKey ? { requestKey } : {}),
+    }));
+    if (isPackFailure(started))
+        return packFailure(started.code, started.error);
+    if (!isRecord(started) || typeof started.jobId !== "string")
+        return error(`Unexpected installPack reply: ${JSON.stringify(started)}`);
+    if (detach)
+        return structured(started);
+    // The job lives in the instance that accepted it; a select_instance meanwhile must not redirect the polls.
+    const accepting = bridge.getConnectedInstance()?.instanceId;
+    let job = started;
+    const deadline = Date.now() + PACK_INSTALL_WAIT_MS;
+    while (!PACK_JOB_TERMINAL.has(String(job.state)) && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 1000));
+        if (bridge.getConnectedInstance()?.instanceId !== accepting)
+            return structured({
+                ...job,
+                note: `Instance ${accepting} is still installing; select it again, then poll get_pack_install_status with this jobId.`,
+            });
+        const next = parseBridgeValue(await bridge.send("getPackInstallStatus", started.jobId));
+        if (isPackFailure(next))
+            return packFailure(next.code, next.error);
+        if (isRecord(next))
+            job = next;
+    }
+    if (job.state === "succeeded")
+        return structured(isRecord(job.result) ? job.result : { packs: [] });
+    if (job.state === "failed" || job.state === "cancelled") {
+        const failure = isRecord(job.error) ? job.error : {};
+        return packFailure(typeof failure.code === "string" ? failure.code : job.state === "cancelled" ? "cancelled" : "pack_install_failed", typeof failure.message === "string" ? failure.message : `Pack install job ${started.jobId} ${String(job.state)}.`);
+    }
+    return structured({ ...job, note: "Still installing; poll get_pack_install_status with this jobId." });
+});
+server.registerTool("get_pack_install_status", {
+    title: "Get Pack Install Status",
+    description: "Report a pack install job: state (queued, running, succeeded, failed, cancelled), progress 0..1, per-pack " +
+        "state in result.packs, and error {code, message} when it failed.",
+    inputSchema: { jobId: z.string().min(1).describe("The jobId install_pack returned.") },
+    outputSchema: PACK_JOB_OUTPUT,
+}, async ({ jobId }) => {
+    const check = await requirePackStore();
+    if (check !== true)
+        return check;
+    const job = parseBridgeValue(await bridge.send("getPackInstallStatus", jobId));
+    if (isPackFailure(job))
+        return packFailure(job.code, job.error);
+    return structured(job);
+});
+server.registerTool("uninstall_pack", {
+    title: "Uninstall Preset Pack",
+    description: "Remove an installed preset pack: every preset carrying its pack id, its samples and media, and its installed " +
+        "record. Fails with pack_not_installed when nothing of the pack is on disk or recorded.",
+    inputSchema: { packId: z.string().min(1).describe("Pack id from the catalog, e.g. 'eko'.") },
+    outputSchema: { packId: z.string(), removed: z.boolean() },
+}, async ({ packId }) => {
+    const check = await requirePackStore();
+    if (check !== true)
+        return check;
+    const removed = parseBridgeValue(await bridge.send("uninstallPack", packId));
+    if (isPackFailure(removed))
+        return packFailure(removed.code, removed.error);
+    return structured(removed);
+});
 server.registerTool("set_visual", {
     title: "Set Visual",
     description: "Save an image file as a preset visual/thumbnail in PAM's media library. " +
@@ -3862,9 +4695,6 @@ const VIDEO_LAYER_FX = "hueRotate, glow, audioReact, vibration, chromaticAberrat
     "polarSlitScan, cellVoronoi, spectralZones, paletteLut, asciiDither, pixelSort, " +
     "cameraShake, blur, cymatics, lineJitter, crt, vhs";
 // Output/global FX chain ids (videoStore, DEFAULT_VIDEO_FX_CONFIG).
-const VIDEO_OUTPUT_FX = "lines, barrelBlur, brightnessContrast, edge, glow, shake, rgbShift, halftone, mirror, " +
-    "patches, pixelate, rolls, feedback, warp, datamosh, slicer, positionXY, speed, " +
-    "cellVoronoi, polarSlitScan, spectralZones, audioReact";
 // Binding source vocabulary (sourceKey string form OR a ModSource object).
 const VIDEO_BIND_SOURCES = "Pass `source` as a sourceKey string: " +
     "`g:<id>` global (level, bandLow, bandMid, bandHigh, transient, transientLow, " +
@@ -3901,14 +4731,15 @@ async function resolveNewId(requestId, beforeIds, pick, ackIdKey, timeoutMs = 25
         if (ack && ack.requestId === requestId) {
             const minted = ack.result?.[ackIdKey];
             if (typeof minted === "string" && minted.length > 0)
-                return minted;
-            return null; // acked but failed / no id — don't misattribute via the diff
+                return { id: minted };
+            // An acked command never falls back to the diff, which could misattribute a concurrent edit.
+            return ack.ok === false ? { error: ack.error || "the command failed" } : {};
         }
         const found = pick(s).find((id) => !beforeIds.has(id));
         if (found)
-            return found;
+            return { id: found };
     }
-    return null;
+    return {};
 }
 server.registerTool("get_video_state", {
     title: "Get Video State",
@@ -3951,7 +4782,7 @@ server.registerTool("capture_ui", {
             .optional()
             .describe("Switch all cells to the synth or sampler tab before capture."),
         settleMs: z.number().optional().describe("Delay (ms) after view changes before rasterizing. Default 350."),
-        timeoutMs: z.number().optional().default(8000).describe("Max ms to wait for the WebView to return the image."),
+        timeoutMs: z.number().optional().default(30000).describe("Max ms to wait for the WebView to return the image. Default 30000."),
     },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
 }, async ({ gridSize, mainView, instrumentView, settleMs, timeoutMs }) => {
@@ -3970,15 +4801,15 @@ server.registerTool("capture_ui", {
         setup.settleMs = settleMs;
     // Forward is fire-and-forget; poll the C++ cache until the WebView posts the PNG back.
     await bridge.send("captureUi", setup);
-    const deadline = Date.now() + (timeoutMs ?? 8000);
+    const deadline = Date.now() + (timeoutMs ?? 30000);
     for (;;) {
         const res = (await bridge.send("getUiCapture", { requestId }));
         if (res.ready && res.requestId === requestId && res.path) {
             return text(`Saved UI screenshot: ${res.path}`);
         }
         if (Date.now() > deadline) {
-            return error("capture_ui timed out waiting for the WebView to return the image. Is PAM's window " +
-                "open and active? html2canvas needs the live DOM — a closed/suspended editor cannot render.");
+            return error(`capture_ui got no image within ${timeoutMs ?? 30000} ms. Either PAM's window is closed or suspended ` +
+                "(html2canvas needs the live DOM), or a dense view is still rendering on a loaded machine: retry with a larger timeoutMs.");
         }
         await new Promise((r) => setTimeout(r, 150));
     }
@@ -3999,14 +4830,14 @@ server.registerTool("video_command", {
         "addLayerFx{layerId,fxType,params?,beforeFxId?}, removeLayerFx{layerId,fxId}, " +
         "removeAllLayerFx{layerId}, setLayerFxParam{layerId,fxId,param,value|params}, " +
         "setLayerFxEnabled{layerId,fxId,enabled?}, reorderLayerFx{layerId,fxIds}, " +
-        "resetLayerFx{layerId,fxId}; bind{layerId,fxId?,paramKey,source,...}, " +
+        "resetLayerFx{layerId,fxId}, setFxParamMeta{layerId,fxId,param,lock?,limit?:{min,max}|null,snap?:step|null}, " +
+        "randomizeFx{layerId,fxId}, setRandomizeAuto{config} (sanitized AutoRandomizeConfig; see get_video_state); " +
+        "bind{layerId,fxId?,paramKey,source,...}, " +
         "unbind{layerId,fxId?,paramKey}, setBindingField{layerId,fxId?,paramKey,field,value}, " +
         "fireImpulse{layerId,fxId?,paramKey}, removeBindingsForLayer{layerId}, clearBindings; " +
         "addOutputFx{fxId}, removeOutputFx{instanceId}, setOutputFxParam{instanceId|fxId,param,value}, " +
-        "setOutputFxEnabled{instanceId,enabled}, setOutputFxStrength{instanceId,strength}; " +
-        "addModRoute{route}, removeModRoute{id}, updateModRoute{id,updates}, clearModRoutes, " +
-        "setModEnabled{enabled}; setModel{sourcePath?,visible?,blendMode?,audioReactive?,autoRotate?,transform?}, " +
-        "resetModel; setSettings{...incl vxVariationFollowAudio,vxBarSyncEnabled,vxBarSyncIntervalBars}, " +
+        "setOutputFxEnabled{instanceId,enabled} (the output chain is the master layer's FX); " +
+        "setSettings{...incl vxVariationFollowAudio,vxBarSyncEnabled,vxBarSyncIntervalBars}, " +
         "setActiveCell{cellId} (deprecated no-op), resetWorkspace; " +
         "VX variation slots: saveVxVariation{index 0-7}, loadVxVariation{index}, clearVxVariation{index}, " +
         "fillVxVariationsRandomized (occupancy/current in get_video_state; or use the vx_variation tool); " +
@@ -4064,7 +4895,9 @@ server.registerTool("add_video_layer", {
     const beforeIds = new Set((before.layers ?? []).map((l) => l.id));
     const requestId = mintVideoRequestId();
     await sendVideoCommand({ op: "addLayer", kind, name, insertAt, sourcePath, maxBytes, requestId });
-    const id = await resolveNewId(requestId, beforeIds, (s) => (s.layers ?? []).map((l) => l.id), "layerId");
+    const { id, error: failure } = await resolveNewId(requestId, beforeIds, (s) => (s.layers ?? []).map((l) => l.id), "layerId");
+    if (failure)
+        return error(`add_video_layer failed: ${failure}`);
     return text(id
         ? `Added ${kind} layer: ${id}`
         : `Added ${kind} layer (window may be closed; call get_video_state to confirm).`);
@@ -4075,7 +4908,8 @@ server.registerTool("update_video_layer", {
         "(partial) against the current transform; other fields replace. Common: opacity " +
         "(0..1), blendMode (normal|add|multiply|screen), enabled, name, transform " +
         "{x,y(0..1),scale,rotation(rad),anchor}. Kind-specific via `fields`: text layers " +
-        "{text,fontSize,fontWeight,color,align,lineHeight}; image/video/model3d {sourcePath,fit}; " +
+        "{text,fontSize,fontWeight,color,align,lineHeight}; image/video/model3d {sourcePath (loads the file, as " +
+        "set_video_layer_source does),fit}; " +
         "camera {deviceId,mirror,fit}; drawing {paintColor,paintWidth}; model3d " +
         "{lightingMode,lightIntensity,rotateRateX/Y/Z,...}. Use get_video_state to see a " +
         "layer's current fields.",
@@ -4098,7 +4932,11 @@ server.registerTool("update_video_layer", {
     const check = await requireBridge();
     if (check !== true)
         return check;
-    const patch = { ...(fields ?? {}) };
+    // A sourcePath in the patch is only stored; setLayerSource is what loads the media.
+    const { sourcePath, ...kindFields } = fields ?? {};
+    if (sourcePath !== undefined && typeof sourcePath !== "string")
+        return error("fields.sourcePath must be a file path.");
+    const patch = { ...kindFields };
     if (opacity !== undefined)
         patch.opacity = opacity;
     if (blendMode !== undefined)
@@ -4109,6 +4947,10 @@ server.registerTool("update_video_layer", {
         patch.name = name;
     if (transform !== undefined)
         patch.transform = transform;
+    if (sourcePath !== undefined)
+        await sendVideoCommand({ op: "setLayerSource", layerId, sourcePath });
+    if (Object.keys(patch).length === 0)
+        return text(`Loading ${sourcePath} into layer ${layerId}.`);
     const result = await sendVideoCommand({ op: "updateLayer", layerId, patch });
     return json(result);
 });
@@ -4158,11 +5000,9 @@ server.registerTool("apply_video_layout", {
 });
 server.registerTool("add_video_fx", {
     title: "Add Video FX",
-    description: "Append an FX to a layer's chain (target='layer', needs layerId) or to the output/" +
-        "global chain (target='output'), and return the new id. Per-layer FX: " +
+    description: "Append an FX to a layer's chain (target='layer', needs layerId) or to the output " +
+        "chain, which is the master layer's chain (target='output'), and return the new id. FX: " +
         VIDEO_LAYER_FX +
-        ". Output FX: " +
-        VIDEO_OUTPUT_FX +
         ". FX params seed from registry defaults; override via `params`. Use set_video_fx " +
         "to tweak afterwards.",
     inputSchema: {
@@ -4187,7 +5027,9 @@ server.registerTool("add_video_fx", {
         const beforeIds = new Set((before.outputFx ?? []).map((f) => f.instanceId));
         const requestId = mintVideoRequestId();
         await sendVideoCommand({ op: "addOutputFx", fxId: fxType, requestId });
-        const id = await resolveNewId(requestId, beforeIds, (s) => (s.outputFx ?? []).map((f) => f.instanceId), "instanceId");
+        const { id, error: failure } = await resolveNewId(requestId, beforeIds, (s) => (s.outputFx ?? []).map((f) => f.instanceId), "instanceId");
+        if (failure)
+            return error(`add_video_fx failed: ${failure}`);
         // Apply param overrides now that the instance exists.
         if (params && id)
             for (const [param, value] of Object.entries(params))
@@ -4201,10 +5043,12 @@ server.registerTool("add_video_fx", {
     const beforeIds = new Set((layer?.fx ?? []).map((f) => f.id));
     const requestId = mintVideoRequestId();
     await sendVideoCommand({ op: "addLayerFx", layerId, fxType, params, beforeFxId, requestId });
-    const id = await resolveNewId(requestId, beforeIds, (s) => {
+    const { id, error: failure } = await resolveNewId(requestId, beforeIds, (s) => {
         const l = (s.layers ?? []).find((x) => x.id === layerId);
         return (l?.fx ?? []).map((f) => f.id);
     }, "fxId");
+    if (failure)
+        return error(`add_video_fx failed: ${failure}`);
     return text(id ? `Added ${fxType} to layer ${layerId}: ${id}` : `Added ${fxType} (confirm via get_video_state).`);
 });
 server.registerTool("set_video_fx", {
@@ -4212,7 +5056,7 @@ server.registerTool("set_video_fx", {
     description: "Set FX params / enabled / strength on a per-layer FX (target='layer', needs " +
         "layerId + fxId) or an output FX (target='output', needs instanceId, or fxId to " +
         "auto-create). Pass a single {param,value}, multiple {params}, `enabled`, and/or " +
-        "`strength` (output only). Get current ids/params from get_video_state.",
+        "`strength` (unsupported: set the FX mix param). Get current ids/params from get_video_state.",
     inputSchema: {
         target: z.enum(["layer", "output"]).default("layer"),
         layerId: z.string().optional().describe("target='layer': owning layer id."),
@@ -4222,7 +5066,7 @@ server.registerTool("set_video_fx", {
         value: z.number().optional().describe("Value for `param`."),
         params: z.record(z.string(), z.number()).optional().describe("Multiple params {key: value}."),
         enabled: z.boolean().optional().describe("Enable/bypass this FX."),
-        strength: z.number().optional().describe("Output FX wet strength (output target only)."),
+        strength: z.number().optional().describe("Unsupported; output FX run on the master layer and have no strength."),
     },
 }, async ({ target, layerId, fxId, instanceId, param, value, params, enabled, strength }) => {
     const check = await requireBridge();
@@ -4245,10 +5089,18 @@ server.registerTool("set_video_fx", {
         if (params)
             for (const [p, v] of Object.entries(params))
                 results.push(await sendVideoCommand({ op: "setOutputFxParam", instanceId, fxId, param: p, value: v }));
-        if (enabled !== undefined && instanceId)
-            results.push(await sendVideoCommand({ op: "setOutputFxEnabled", instanceId, enabled }));
-        if (strength !== undefined && instanceId)
-            results.push(await sendVideoCommand({ op: "setOutputFxStrength", instanceId, strength }));
+        // A param write by fxId has just auto-created the FX, so resolve the instance after it.
+        let outputInstance = instanceId;
+        if (!outputInstance && fxId && (enabled !== undefined || strength !== undefined)) {
+            const current = await getVideoStateRaw();
+            outputInstance = (current.outputFx ?? []).find((fx) => fx.fxId === fxId)?.instanceId;
+            if (!outputInstance)
+                return error(`set_video_fx: no output ${fxId} to enable or scale; add_video_fx it first.`);
+        }
+        if (enabled !== undefined && outputInstance)
+            results.push(await sendVideoCommand({ op: "setOutputFxEnabled", instanceId: outputInstance, enabled }));
+        if (strength !== undefined && outputInstance)
+            results.push(await sendVideoCommand({ op: "setOutputFxStrength", instanceId: outputInstance, strength }));
     }
     if (results.length === 0)
         return error("set_video_fx: nothing to set (provide param/value, params, enabled, or strength).");
@@ -4296,7 +5148,7 @@ server.registerTool("bind_video_param", {
             .union([z.string(), z.record(z.string(), z.any())])
             .describe("sourceKey string (e.g. 'g:bandLow', 'c:1:onset', 't:beat') or ModSource object."),
         fxId: z.string().optional().describe("FX instance id; omit/'' for a layer-field target."),
-        amount: z.number().min(-1).max(1).optional().describe("Modulation depth (-1..1), default 1."),
+        amount: z.number().min(-1).max(1).optional().describe("Modulation depth (-1..1), default 0.5 (the VX UI default)."),
         curve: z.enum(["linear", "exp", "expInverse", "bipolar"]).optional(),
         mode: z.enum(["additive", "replace", "multiply", "centered"]).optional(),
         attackMs: z.number().min(0).optional(),
@@ -4350,7 +5202,6 @@ server.registerTool("set_video_settings", {
             .describe("Canvas design ratio as width/height (e.g. 1.7777 for 16:9). null clears it and follows the window."),
         letterboxColor: z.string().describe("#hex fill for the bars outside the design aspect.").optional(),
         canvasColor: z.string().describe("#hex background behind every VX layer.").optional(),
-        modEnabled: z.boolean().optional().describe("Mod-matrix master enable."),
         vxVariationFollowAudio: z
             .boolean()
             .optional()
@@ -4366,7 +5217,7 @@ server.registerTool("set_video_settings", {
         activeCell: z.number().int().optional().describe("Deprecated/no-op: VX is a single global scene (no per-cell video)."),
         resetWorkspace: z.boolean().optional().describe("If true, clear the whole scene first."),
     },
-}, async ({ syncMode, loopBars, aspectRatio, renderQuality, designAspect, letterboxColor, canvasColor, modEnabled, vxVariationFollowAudio, vxBarSyncEnabled, vxBarSyncIntervalBars, activeCell, resetWorkspace }) => {
+}, async ({ syncMode, loopBars, aspectRatio, renderQuality, designAspect, letterboxColor, canvasColor, vxVariationFollowAudio, vxBarSyncEnabled, vxBarSyncIntervalBars, activeCell, resetWorkspace }) => {
     const check = await requireBridge();
     if (check !== true)
         return check;
@@ -4374,8 +5225,6 @@ server.registerTool("set_video_settings", {
         await sendVideoCommand({ op: "resetWorkspace" });
     if (activeCell !== undefined)
         await sendVideoCommand({ op: "setActiveCell", cellId: activeCell });
-    if (modEnabled !== undefined)
-        await sendVideoCommand({ op: "setModEnabled", enabled: modEnabled });
     const settings = {};
     if (syncMode !== undefined)
         settings.syncMode = syncMode;
@@ -4463,12 +5312,6 @@ server.registerTool("vx_variation", {
 // ============================================================
 // Composite cell-operation tools
 // ============================================================
-const PATTERN_SUFFIXES = [
-    "midiSequence",
-    "pitchSequence",
-    "sliceSequence",
-    "stretchSequence",
-];
 server.registerTool("reset_cell", {
     title: "Reset Cell",
     description: "Reset a single cell's manifest parameters to their defaults and remove the envelopes whose SOURCE is this cell. " +
@@ -4492,6 +5335,8 @@ server.registerTool("reset_cell", {
     ]);
     const delta = {};
     for (const p of cellParams) {
+        if (isCcOutValueSuffix(p.paramId.replace(/^cell\d+_/, "")))
+            continue;
         if (p.defaultValue !== undefined)
             delta[p.paramId] = p.defaultValue;
     }
@@ -4501,12 +5346,14 @@ server.registerTool("reset_cell", {
     const removedEnvs = envArray.length - filteredEnvs.length;
     if (removedEnvs > 0)
         delta.envelopes = filteredEnvs;
-    await applyKv(delta, KV_OPTS_STANDARD);
+    await applyKv(delta, STATE_UPDATE_KV_OPTIONS);
     return text(`Reset cell ${cellId} to defaults (${paramCount} params, removed ${removedEnvs} envelopes).`);
 });
 server.registerTool("copy_cell", {
     title: "Copy Cell",
     description: "Copy a cell's manifest parameters and remap its LFO, envelope and vary links onto another cell, overwriting the target's. " +
+        "Param-lane targets travel with their lanes. A CC lane lands only on a target slot that is Off or on the same " +
+        "controller; CC out values and controllers stay the target's. " +
         "Not copied: the loaded sample, parameter sequencers, and the cell config block (polyphony, MIDI note/channel, scale, " +
         "sidechain source, pitch/stretch engine, slice keymap) — re-apply those with load_sample and update_cell_config.",
     inputSchema: {
@@ -4533,10 +5380,33 @@ server.registerTool("copy_cell", {
     const dstPrefix = `cell${targetCellId}_`;
     const delta = {};
     for (const [key, value] of Object.entries(state)) {
-        if (key.startsWith(srcPrefix)) {
+        if (key.startsWith(srcPrefix) && !isCcOutValueSuffix(key.slice(srcPrefix.length))) {
             delta[dstPrefix + key.slice(srcPrefix.length)] = value;
         }
     }
+    // Destination wiring: a CC lane lands only where the slot it locks is Off or on the same controller,
+    // and then brings that slot; one that stays out keeps the destination's.
+    const cellsState = isRecord(state.cells) ? state.cells : {};
+    const srcRaw = cellsState[String(sourceCellId)];
+    const dstRaw = cellsState[String(targetCellId)];
+    const srcCell = isRecord(srcRaw) ? srcRaw : {};
+    const dstCell = isRecord(dstRaw) ? dstRaw : {};
+    const targetDelta = {};
+    for (const lane of CC_LANES) {
+        const slot = ccLaneSlotOf(srcCell, lane);
+        if (slot === 0 || ccLaneMayLand(srcCell[`ccOutCc${slot}`], dstCell[`ccOutCc${slot}`])) {
+            targetDelta[ccLaneSlotField(lane)] = slot;
+        }
+        else {
+            delete delta[`${dstPrefix}${PATTERN_LANE_SUFFIX[lane]}`];
+            targetDelta[ccLaneSlotField(lane)] = ccLaneSlotOf(dstCell, lane);
+        }
+    }
+    for (const lane of PARAM_LANES) {
+        const target = srcCell[LANE_TARGET_FIELD[lane]];
+        targetDelta[LANE_TARGET_FIELD[lane]] = typeof target === "string" ? target : "";
+    }
+    delta.cells = { [targetCellId]: targetDelta };
     // Remap envelopes
     const envelopes = state.envelopes || [];
     if (envelopes.length > 0) {
@@ -4612,7 +5482,7 @@ server.registerTool("copy_cell", {
         if (remapped.length > 0)
             delta.paramSeqs = [...kept, ...remapped];
     }
-    await applyKv(delta, KV_OPTS_STANDARD);
+    await applyKv(delta, STATE_UPDATE_KV_OPTIONS);
     return text(`Copied cell ${sourceCellId} → cell ${targetCellId} (${Object.keys(delta).length} keys).`);
 });
 server.registerTool("clear_modulations", {
@@ -4655,7 +5525,7 @@ server.registerTool("clear_modulations", {
     if (Object.keys(delta).length === 0) {
         return text(`No modulations found for cell ${cellId}.`);
     }
-    await applyKv(delta, KV_OPTS_MOD);
+    await applyKv(delta, STATE_UPDATE_KV_OPTIONS);
     const removed = (lfos.length - filteredLfos.length) +
         (vary.length - filteredVary.length) +
         (envelopes.length - filteredEnvs.length);
@@ -4663,7 +5533,8 @@ server.registerTool("clear_modulations", {
 });
 server.registerTool("reset_patterns", {
     title: "Reset Patterns",
-    description: "Clear all sequencer lanes (note, pitch, slice, stretch) for a single PAM/Cell1 sampler cell.",
+    description: "Clear every pattern lane of one cell (note, pitch, slice, stretch, the CC lanes and the param lanes, as the " +
+        "product has them) and clear the param lanes' targets. CC out controllers stay.",
     inputSchema: {
         cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
     },
@@ -4682,16 +5553,58 @@ server.registerTool("reset_patterns", {
         return error(`${productName} has no sampler MIDI/pitch/slice/stretch pattern lanes.`);
     }
     const delta = { __forceRender__: true };
-    for (const suffix of PATTERN_SUFFIXES) {
-        delta[`cell${cellId}_${suffix}`] = [];
+    for (const lane of PATTERN_LANE_IDS) {
+        if (!manifest || productHasLane(cellId, lane, manifest.stateVariables))
+            delta[`cell${cellId}_${PATTERN_LANE_SUFFIX[lane]}`] = [];
+    }
+    if (!manifest || productHasLane(cellId, "paramLane1", manifest.stateVariables)) {
+        delta.cells = { [cellId]: Object.fromEntries(PARAM_LANES.map((lane) => [LANE_TARGET_FIELD[lane], ""])) };
     }
-    await applyKv(delta, KV_OPTS_PATTERN);
+    await applyKv(delta, PATTERN_EDIT_KV_OPTIONS);
     return text(`Cleared all patterns for cell ${cellId}.`);
 });
+server.registerTool("set_effects_enabled", {
+    title: "Enable or Bypass Cell Effects",
+    description: "Enable or bypass cell effects. Omit cellId for every cell (CTRL ALL); omit effect for the entire cell FX chain. " +
+        "This changes cell effect enable flags, preserving their settings and the master bus. Use set_master_effects for master-bus changes.",
+    inputSchema: {
+        enabled: z.boolean().describe("true enables, false bypasses."),
+        cellId: z.number().int().min(1).max(8).optional().describe("Cell number (1-8). Omit for all cells, including empty cells."),
+        effect: z.string().optional().describe("Cell effect name, e.g. delay, crusher, fdn, filter. Omit for all cell effects."),
+    },
+}, async ({ enabled, cellId, effect }) => {
+    const check = await requireBridge();
+    if (check !== true)
+        return check;
+    const manifest = await loadManifestForProductGuard();
+    if (!manifest)
+        return error("The selected product manifest is unavailable; effect availability cannot be validated safely.");
+    const available = cellEffectOrder(manifest);
+    if (!available.length)
+        return error("The selected product has no cell effect chain.");
+    if (effect !== undefined && !available.includes(effect))
+        return error(`Unknown cell effect: ${effect}. Available effects: ${available.join(", ")}.`);
+    if (cellId !== undefined) {
+        const cellCheck = validateCellIdForManifest(cellId, manifest);
+        if (cellCheck !== true)
+            return cellCheck;
+    }
+    const cellCount = manifestMaxCellId(manifest);
+    if (cellCount === null)
+        return error("The selected product manifest has no cells.");
+    const cellIds = cellId === undefined ? Array.from({ length: cellCount }, (_, i) => i + 1) : [cellId];
+    const effects = effect === undefined ? available : [effect];
+    const delta = Object.fromEntries(cellIds.flatMap((id) => effects.map((name) => [`cell${id}_${name}Enabled`, enabled ? 1 : 0])));
+    const stateRaw = await bridge.send("getState");
+    const state = isRecord(stateRaw) ? stateRaw : {};
+    const changed = Object.entries(delta).filter(([key, value]) => Number(state[key] ?? 0) !== value).length;
+    await applyKv(delta, EFFECT_CONFIG_KV_OPTIONS);
+    return text(JSON.stringify({ cellIds, effects, enabled, changed }));
+});
 server.registerTool("update_effect_config", {
     title: "Update Effect Config",
-    description: "Toggle cell effects on/off (filter, delay, crusher, flanger, chorus, phaser, eq, eq8, tablefilter, fdn, gate, compressor, panner, gain, vocoder, ringmod, vinylbrake, transient, repeat, pitchshift, limiter, qverb, shimmer, wavefold, resonator). " +
-        "Wavefold and Resonator ship in every product. Exact availability comes from the selected product manifest. " +
+    description: "Toggle cell effects on/off (filter, delay, crusher, flanger, chorus, phaser, freqshift, drive, lpc, fmod, specdelay, squeeze, tape, granular, noisegate, codec, cellmix, eq, eq8, tablefilter, fdn, gate, compressor, panner, gain, vocoder, ringmod, vinylbrake, transient, repeat, pitchshift, limiter, shimmer, wavefold, resonator). " +
+        "granular is the Grain card and noisegate the Noise Gate. Wavefold and Resonator ship in every product. Exact availability comes from the selected product manifest. " +
         "Uses the lighter KV path that does not rebuild the audio graph. Pass 1 to enable, 0 to disable.",
     inputSchema: {
         cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
@@ -4703,7 +5616,7 @@ server.registerTool("update_effect_config", {
         fdnEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         gateEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         compressorEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
-        // Shared extended effects. These ship on PAM/Cell1 too, so leaving them out of the
+        // Shared extended effects. These ship on PAM too, so leaving them out of the
         // schema made them unreachable over the bridge even though the handler is
         // generic (it just builds `cell{N}_{key}`) and the state vars exist in
         // build.js alongside the eight above.
@@ -4717,9 +5630,19 @@ server.registerTool("update_effect_config", {
         repeatEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         pitchshiftEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         limiterEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
-        qverbEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         chorusEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         phaserEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        freqshiftEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        driveEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        lpcEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        specdelayEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        squeezeEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        tapeEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        granularEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        noisegateEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        codecEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        cellmixEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
+        fmodEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         shimmerEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         tablefilterEnabled: z.union([z.literal(0), z.literal(1)]).optional(),
         // Product-specific extended effects. The handler rejects flags absent from
@@ -4753,17 +5676,50 @@ server.registerTool("update_effect_config", {
     if (Object.keys(delta).length === 0) {
         return error("At least one effect flag must be provided.");
     }
-    await applyKv(delta, KV_OPTS_EFFECT_CONFIG);
+    await applyKv(delta, EFFECT_CONFIG_KV_OPTIONS);
     const summary = Object.entries(delta)
         .map(([k, v]) => `${k}=${v}`)
         .join(", ");
     return text(`Updated effect config for cell ${cellId}: ${summary}`);
 });
+// Spectral Delay's curve is the array state var cell{N}_specdelayBands, which set_parameters
+// (numbers only) cannot write. KVStateSyncManager projects it to the node, so no WebView is needed.
+const SPECDELAY_BANDS = 32;
+server.registerTool("set_spectral_delay_curve", {
+    title: "Set Spectral Delay Curve",
+    description: "Set a cell's Spectral Delay curve: 32 log-spaced bands from 20 Hz to 20 kHz, each 0..1. In TIME mode a " +
+        "band's value is its share of Time (0 = the shortest repeat, 1 = the whole Time); in LEVEL mode it is how " +
+        "much of that band is repeated. Depth scales the curve. Pass shape 'rise' (highs arrive last) or 'fall', or " +
+        "32 explicit bands, low to high. Enable the effect with update_effect_config specdelayEnabled.",
+    inputSchema: {
+        cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
+        shape: z.enum(["rise", "fall"]).optional().describe("A factory curve. Omit when passing bands."),
+        bands: z
+            .array(z.number().min(0).max(1))
+            .length(SPECDELAY_BANDS)
+            .optional()
+            .describe("32 values 0..1, 20 Hz first. Omit when passing shape."),
+    },
+}, async ({ cellId, shape, bands }) => {
+    const check = await requireBridgeForCells(cellId);
+    if (check !== true)
+        return check;
+    if ((shape === undefined) === (bands === undefined))
+        return error("Pass exactly one of shape or bands.");
+    const manifest = await loadManifestForProductGuard();
+    if (manifest && !cellEffectNames(manifest).includes("specdelay")) {
+        return error(`Spectral Delay is not available in ${manifest.name ?? "the selected product"}.`);
+    }
+    const rise = Array.from({ length: SPECDELAY_BANDS }, (_, b) => b / (SPECDELAY_BANDS - 1));
+    const curve = bands ?? (shape === "fall" ? rise.map((v) => 1 - v) : rise);
+    await applyKv({ [`cell${cellId}_specdelayBands`]: curve }, STATE_UPDATE_KV_OPTIONS);
+    return text(`Set cell ${cellId} Spectral Delay curve (${shape ?? "32 bands"}).`);
+});
 // MFX cable patchbay. `mfx_routing` is a non-numeric state variable, so it was
 // unreachable through set_parameters (numbers only) — an agent could shape an MFX
 // cell but never patch one to another, which is the whole product.
 //
-// Validation mirrors parseRoutingEdges (interface/src/dsp/products/mfx/mfxRouting.ts): the
+// Validation mirrors parseRoutingEdges (interface/src/utils/mfxRouting.ts): the
 // plugin re-validates on receipt, so this pass exists to fail loudly here rather
 // than have a typo silently drop a cable.
 const MFX_ROUTING_SOURCE_HINT = "'input', 'sidechain', 'split_lo' / 'split_mid' / 'split_hi', or 'cellN'. " +
@@ -4812,8 +5768,8 @@ function validateMfxEdges(edges, maxCells) {
 }
 server.registerTool("set_mfx_routing", {
     title: "Set MFX Cable Routing",
-    description: "Read or replace the MFX cable patch — the graph that decides which cell feeds which. MFX-only; on PAM/Cell1 " +
-        "this returns a product error.\n\n" +
+    description: "Read or replace the MFX cable patch — the graph that decides which cell feeds which. MFX-only; other products " +
+        "return a product error.\n\n" +
         "Ports: 'input' (the host's audio in) and 'sidechain' are sources; 'output' is the destination; 'cellN' is both. " +
         "A self-edge cellN→cellN is a feedback loop, and input→output is a direct dry path. Duplicate cables are dropped.\n\n" +
         "SPLIT is a three-band crossover node: cable 'input' (or 'sidechain') to 'split', then patch 'split_lo', " +
@@ -4858,7 +5814,7 @@ server.registerTool("set_mfx_routing", {
         return error(`${validated.reason}. This product exposes cells 1..${maxCells}.`);
     }
     // mfx_routing is a GRAPH_RENDER state var — a re-patch must rebuild the graph.
-    await applyKv({ mfx_routing: validated.edges }, KV_OPTS_STANDARD);
+    await applyKv({ mfx_routing: validated.edges }, STATE_UPDATE_KV_OPTIONS);
     const summary = validated.edges.map((e) => `${e.from}→${e.to}`).join(", ");
     return text(`MFX routing set: ${validated.edges.length} cable(s)${summary ? ` — ${summary}` : " (patch cleared)"}.`);
 });
@@ -4895,7 +5851,8 @@ server.registerTool("set_mfx_edge_gain", {
         return error(`Cable ${from}→${to} is not in the current patch. Add it with set_mfx_routing first.`);
     const key = `${from}__${to}`;
     gains[key] = gain;
-    await applyKv({ mfx_edge_gains: gains }, KV_OPTS_EFFECT_CONFIG);
+    // Cable gains reach audio only through the graph's mounted refs, which a dispatch updates.
+    await applyKv({ mfx_edge_gains: gains }, STATE_UPDATE_KV_OPTIONS);
     return text(`MFX cable gain set: ${from}→${to} = ${gain}.`);
 });
 const MFX_COMBO_TARGET_INPUT = z.object({
@@ -4954,7 +5911,7 @@ server.registerTool("configure_mfx_combo", {
             const currentTargetValue = state[target.id];
             delta[target.id] = mfxComboTargetValueFromCurrent(target, typeof previousComboValue === "number" ? previousComboValue : 0, value, info, typeof currentTargetValue === "number" ? currentTargetValue : info.defaultValue);
         }
-        await applyKv(delta, KV_OPTS_STANDARD);
+        await applyKv(delta, STATE_UPDATE_KV_OPTIONS);
         return json({ combo: index, value, targetsWritten: combo.targets.map((target) => target.id) });
     }
     const materialized = () => ({ ...stored, targets: [...combo.targets] });
@@ -5051,7 +6008,20 @@ server.registerTool("configure_mfx_combo", {
         locked: next?.locked === 1 ? 1 : 0,
         targets: Array.isArray(next?.targets) ? next.targets : null,
     };
-    await applyKv({ mfx_combos: { ...slots, [String(index)]: update } }, KV_OPTS_EFFECT_CONFIG);
+    const delta = { mfx_combos: { ...slots, [String(index)]: update } };
+    if ((op === "setTargetStop" || op === "invertTarget") && paramId) {
+        const before = combo.targets.find((target) => target.id === paramId);
+        const after = next?.targets?.find((target) => target.id === paramId);
+        const info = parameterIndex.get(paramId);
+        if (before && after && info) {
+            const current = typeof state[paramId] === "number" ? state[paramId] : info.defaultValue;
+            const comboValue = state[`mfx_combo${index}`];
+            const changed = mfxComboTargetValueAfterRangeEdit(before, after, typeof comboValue === "number" ? comboValue : 0, info, current);
+            if (changed !== current)
+                delta[paramId] = changed;
+        }
+    }
+    await applyKv(delta, EFFECT_CONFIG_KV_OPTIONS);
     return json({ combo: index, slot: update });
 });
 server.registerTool("set_effect_order", {
@@ -5111,15 +6081,16 @@ server.registerTool("set_effect_order", {
             "To bypass a stage set its *Enabled flag via update_effect_config; leaving it out of the chain is not the same thing.");
     }
     // effectOrder rebuilds the cell's FX graph, like an MFX re-patch.
-    await applyKv({ [key]: order }, KV_OPTS_STANDARD);
+    await applyKv({ [key]: order }, STATE_UPDATE_KV_OPTIONS);
     return text(`Cell ${cellId} FX chain: ${order.join(" → ")}.`);
 });
 server.registerTool("update_cell_config", {
     title: "Update Cell Config",
-    description: "Update cell-level configuration properties like polyphony, MIDI settings, varispeed, and modulation latch. " +
+    description: "Update cell-level configuration properties like polyphony, MIDI settings, MIDI output (channel, Send, CC out controllers), varispeed, and modulation latch. " +
         "These are KV-only properties that don't appear in the parameter manifest. " +
-        "Uses a lightweight KV path without graph rebuild. " +
-        "When bound to MFX, this tool only accepts sidechainFrom; sampler/MIDI/instrument config is PAM/Cell1-only.",
+        "Most keys take a lightweight KV path; the source keys (sidechainFrom, cellmixFrom, cellmixPreFx) rebuild the graph once. " +
+        "cellmixFrom picks the source the cell's Cell Mix card blends in and switches the card on. " +
+        "When bound to MFX, this tool accepts only sidechainFrom, cellmixFrom and cellmixPreFx; on MSQ it accepts the MIDI and output keys only.",
     inputSchema: {
         cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
         isPoly: z.union([z.literal(0), z.literal(1)]).optional().describe("Polyphonic mode (0=mono, 1=poly)."),
@@ -5173,6 +6144,34 @@ server.registerTool("update_cell_config", {
             .optional()
             .describe("Sidechain compressor source. null=no sidechain, 0=external audio input, 1-8=cell output. " +
             "Auto-enables the cell's compressor when set to a non-null value."),
+        cellmixFrom: z
+            .number()
+            .int()
+            .min(-1)
+            .max(8)
+            .optional()
+            .describe("Cell Mix source: -1=none, 0=external sidechain input, 1-8=another cell (never this cell). " +
+            "Any value but -1 also switches the cell's Cell Mix card on."),
+        cellmixPreFx: z
+            .boolean()
+            .optional()
+            .describe("Where Cell Mix taps a source cell: true=before its effects, false=after its effects and before its fader."),
+        midiOutChannel: z.number().int().min(0).max(16).optional().describe("MIDI out channel for the cell's CC out (and MSQ's notes): 0=Auto (the cell number), 1-16 explicit."),
+        sendToHost: z.union([z.literal(0), z.literal(1)]).optional().describe("0 keeps the cell's CC out (and MSQ's notes) off the MIDI out."),
+        midiOutPort: z.number().int().min(0).max(3).optional().describe("Standalone only: 0=Main MIDI Output, 1-3=Ports B-D set in Settings."),
+        polyNoteMin: z.number().int().min(0).max(127).optional().describe("Lowest note a poly cell plays (MSQ: sends), at most polyNoteMax."),
+        polyNoteMax: z.number().int().min(0).max(127).optional().describe("Highest note a poly cell plays (MSQ: sends), at least polyNoteMin."),
+        ...Object.fromEntries(CC_OUT_SLOTS.map((slot) => [`ccOutCc${slot}`, ccOutControllerSchema(slot)])),
+        ...Object.fromEntries(CC_LANES.map((lane) => [
+            ccLaneSlotField(lane),
+            z
+                .number()
+                .int()
+                .min(0)
+                .max(CC_OUT_SLOTS.length)
+                .optional()
+                .describe(`CC out slot (1-${CC_OUT_SLOTS.length}) that CC lane ${ccLaneIndex(lane)} locks per event, 0=none. Lane L starts on slot L. The lane loops at its own cell{N}_patternLengthCc${ccLaneIndex(lane)} / patternSpeedCc${ccLaneIndex(lane)}.`),
+        ])),
     },
 }, async ({ cellId, ...config }) => {
     const check = await requireBridge();
@@ -5197,10 +6196,38 @@ server.registerTool("update_cell_config", {
     if (manifest && isMfxManifest(manifest)) {
         const unsupported = providedKeys.filter((key) => !MFX_CELL_CONFIG_KEYS.has(key));
         if (unsupported.length > 0) {
-            return error("update_cell_config in MFX only accepts sidechainFrom. " +
-                `Sampler/MIDI/instrument config keys are PAM/Cell1-only: ${unsupported.join(", ")}.`);
+            return error(`update_cell_config in MFX accepts only ${[...MFX_CELL_CONFIG_KEYS].join(", ")}. ` +
+                `Sampler/MIDI/instrument config keys are PAM-only: ${unsupported.join(", ")}.`);
         }
     }
+    if (bridge.getConnectedInstance()?.product?.toUpperCase() === "MSQ") {
+        const unsupported = providedKeys.filter((key) => !MSQ_CELL_CONFIG_KEYS.has(key));
+        if (unsupported.length > 0) {
+            return error(`update_cell_config in MSQ accepts MIDI keys only (${[...MSQ_CELL_CONFIG_KEYS].join(", ")}). ` +
+                `MSQ has no sampler: ${unsupported.join(", ")}.`);
+        }
+    }
+    if (config.cellmixFrom === cellId) {
+        return error(`cellmixFrom cannot be cell ${cellId} itself: use -1 for none, 0 for the sidechain input, or another cell.`);
+    }
+    if (config.cellmixFrom !== undefined && config.cellmixFrom >= 1) {
+        const sourceCheck = validateCellIdForManifest(config.cellmixFrom, manifest);
+        if (sourceCheck !== true)
+            return sourceCheck;
+    }
+    // MSQ's router drops every note outside Low-High as stored, so an inverted pair would silence the cell.
+    if (config.polyNoteMin !== undefined || config.polyNoteMax !== undefined) {
+        let current = {};
+        if (config.polyNoteMin === undefined || config.polyNoteMax === undefined) {
+            const state = await bridge.send("getState");
+            const cells = isRecord(state) && isRecord(state.cells) ? state.cells : {};
+            current = isRecord(cells[String(cellId)]) ? cells[String(cellId)] : {};
+        }
+        const low = config.polyNoteMin ?? Number(current.polyNoteMin ?? 0);
+        const high = config.polyNoteMax ?? Number(current.polyNoteMax ?? 127);
+        if (low > high)
+            return error(`polyNoteMin (${low}) must not exceed polyNoteMax (${high}).`);
+    }
     const cellConfig = {};
     const flatDelta = {};
     for (const [key, value] of Object.entries(config)) {
@@ -5211,10 +6238,18 @@ server.registerTool("update_cell_config", {
         else
             cellConfig[key] = value;
     }
+    // An agent's scale is the user's: a Player switched off later must not put its pre-arm scale back.
+    if (cellConfig.scaleName !== undefined || cellConfig.scaleRoot !== undefined) {
+        cellConfig.playerPreScale = NO_SCALE_ARM;
+        cellConfig.playerPreScaleRoot = NO_POLY_ARM;
+    }
     // Auto-enable compressor when setting sidechain source
     if (cellConfig.sidechainFrom !== undefined && cellConfig.sidechainFrom !== null) {
         flatDelta[`cell${cellId}_compressorEnabled`] = 1;
     }
+    if (cellConfig.cellmixFrom !== undefined && cellConfig.cellmixFrom !== -1) {
+        flatDelta[`cell${cellId}_cellmixEnabled`] = 1;
+    }
     // Mirror interop.ts updateCellConfig: a pitch/stretch engine change OR a
     // sliceKeymapMode flip (which changes pitch interpretation) bumps
     // modeChangeSeq so the audio thread flushes its Signalsmith analysis state.
@@ -5228,7 +6263,9 @@ server.registerTool("update_cell_config", {
     const delta = { ...flatDelta };
     if (Object.keys(cellConfig).length > 0)
         delta.cells = { [cellId]: cellConfig };
-    await applyKv(delta, KV_OPTS_CELL_CONFIG);
+    // Sidechain and Cell Mix sources are wired at graph build, so they need the dispatch the UI's setters make.
+    const wiresGraph = ["sidechainFrom", "cellmixFrom", "cellmixPreFx"].some((key) => cellConfig[key] !== undefined);
+    await applyKv(delta, wiresGraph ? STATE_UPDATE_KV_OPTIONS : CELL_CONFIG_KV_OPTIONS);
     const summary = [
         ...Object.entries(cellConfig).map(([k, v]) => `${k}=${v}`),
         ...Object.entries(flatDelta).map(([k, v]) => `${k}=${v}`),
@@ -5264,10 +6301,10 @@ server.registerTool("set_cell_mute", {
     }
     // cell{N}_mute / cell{N}_solo are flat state vars projected to
     // cell{N}_config.enabled by KVStateSyncManager — same options the UI's
-    // applyStateDelta uses (KV_OPTS_STANDARD); the projection needs
+    // applyStateDelta uses (STATE_UPDATE_KV_OPTIONS); the projection needs
     // syncConfigResources, no graph rebuild required but the standard path is
     // the exact UI parity.
-    await applyKv(delta, KV_OPTS_STANDARD);
+    await applyKv(delta, STATE_UPDATE_KV_OPTIONS);
     const summary = Object.entries(delta)
         .map(([k, v]) => `${k}=${v}`)
         .join(", ");
@@ -5303,11 +6340,13 @@ server.registerTool("set_master_effects", {
         masterTapeDrive: z.number().min(0).max(1).optional().describe("Tape drive / saturation amount (0-1, default 0.5). Higher = more harmonic grit + HF compression ('push it harder → it gets duller')."),
         masterTapeTone: z.number().min(-1).max(1).optional().describe("Tape tone tilt (-1 dark .. 0 flat .. +1 bright, default 0). Go negative for dusty/lo-fi."),
         masterTapeMix: z.number().min(0).max(1).optional().describe("Tape dry/wet (0-1, default 1 = fully wet)."),
-        masterTapeMode: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]).optional().describe("Tape character: 0=Clean (gentle tanh), 1=Lo-Fi (most degradation, dusty), 2=Amp (hard asymmetric drive), 3=Studio (Jiles-Atherton magnetic hysteresis — the deep hi-fi machine, no wow/hiss). Default 0."),
+        masterTapeMode: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]).optional().describe("Tape character: 0=Clean (gentle tanh), 1=Lo-Fi (most degradation, dusty), 2=Broken (drifting wow/flutter, crackle, hard asymmetric drive), 3=Studio (Jiles-Atherton magnetic hysteresis — the deep hi-fi machine, no wow/hiss). Default 0."),
         masterTapeWear: z.number().min(0).max(1).optional().describe("Tape wear: wow/flutter pitch drift + age (0-1, default 0.5). Raise for warble/sag."),
+        masterTapeOutTrim: z.number().min(-24).max(24).optional().describe("Tape output trim dB on the wet signal, after Mix (default 0). Unity while Tape is off."),
         masterEqEnabled: z.union([z.literal(0), z.literal(1)]).optional().describe("Enable the master EQ (trim/tilt/shelves/bells)."),
         masterWidthEnabled: z.union([z.literal(0), z.literal(1)]).optional().describe("Enable the stereo utility (width + elliptical bass-mono)."),
         masterInputTrim: z.number().min(-24).max(24).optional().describe("Master input trim in dB (gain staging into the chain; default 0)."),
+        masterEqOutTrim: z.number().min(-24).max(24).optional().describe("Master EQ output trim dB (default 0). Unity while the EQ is off."),
         masterEqTilt: z.number().min(-6).max(6).optional().describe("Tilt in dB at the extremes around a 650 Hz pivot (+ = brighter; the coarse tonal-balance lever)."),
         masterEqLsFreq: z.number().min(20).max(500).optional().describe("Low-shelf corner Hz (default 90)."),
         masterEqLsGain: z.number().min(-12).max(12).optional().describe("Low-shelf gain dB (default 0)."),
@@ -5319,11 +6358,21 @@ server.registerTool("set_master_effects", {
         masterClipDrive: z.number().min(0).max(12).optional().describe("Clipper drive dB (default 0). Staging guidance: the clipper shaves the sharpest 2-3 dB so the limiter works 1-2 dB."),
         masterClipMix: z.number().min(0).max(1).optional().describe("Clipper parallel blend (1 = fully clipped)."),
         masterClipMode: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]).optional().describe("Clipper transfer: 0=Smooth (knee-tanh), 1=Silicon diode (hard knee), 2=Germanium diode (earlier, softer knee), 3=LED (higher knee). Diode modes are exact antiparallel-pair solves, ADAA at the 2x rate. Default 0."),
+        masterDenoiseEnabled: z.union([z.literal(0), z.literal(1)]).optional().describe("Enable master noise reduction before EQ and compression; off by default. Adds one FFT frame of latency while enabled; a DAW that is playing keeps that latency after a switch-off until its transport stops, and Fixed latency mode keeps it always."),
+        masterDenoiseLow: z.number().min(0).max(100).optional().describe("Low-band noise reduction strength, percent (default 50)."),
+        masterDenoiseMid: z.number().min(0).max(100).optional().describe("Mid-band noise reduction strength, percent (default 50)."),
+        masterDenoiseHigh: z.number().min(0).max(100).optional().describe("High-band noise reduction strength, percent (default 50)."),
+        masterDenoiseSplitLow: z.number().min(40).max(2000).optional().describe("Low/mid split in Hz (default 250)."),
+        masterDenoiseSplitHigh: z.number().min(500).max(12000).optional().describe("Mid/high split in Hz (default 4000)."),
+        masterDenoiseMix: z.number().min(0).max(1).optional().describe("Master Denoise dry/wet, 0..1 (default 1)."),
+        masterDenoiseOutTrim: z.number().min(-24).max(24).optional().describe("Master Denoise output trim dB on the wet signal, after Mix (default 0). Unity while Denoise is off."),
+        masterDenoisePrint: z.string().optional().describe("Learned noise print ('pdn1:<sampleRate>:<fftSize>:<base64>'), written by the Denoise panel's Learn button. Pass '' to forget it and return to adaptive tracking; copy a value read from get_state to reuse a print."),
         masterIronEnabled: z.union([z.literal(0), z.literal(1)]).optional().describe("Enable the console/transformer iron colour stage (post-Tape, pre-Clipper; zero latency)."),
         masterIronDrive: z.number().min(0).max(12).optional().describe("Iron drive dB (default 0). Level-compensated — drive adds colour, not loudness."),
         masterIronAmount: z.number().min(0).max(1).optional().describe("Transformer (magnetizing-branch) depth 0..1 — LF-concentrated saturation, the 'iron' signature (default 0.5)."),
         masterIronMode: z.union([z.literal(0), z.literal(1)]).optional().describe("0=Console (amp-forward, subtle), 1=Transformer (heavier LF iron)."),
-        masterSqueezeEnabled: z.union([z.literal(0), z.literal(1)]).optional().describe("Enable Squeeze — a 3-band upward+downward compressor (post-Punch, pre-Tape; zero latency). The character (88/2500 Hz splits, thresholds, ratios) is baked; Depth is the main lever."),
+        masterIronOutTrim: z.number().min(-24).max(24).optional().describe("Iron output trim dB on the wet signal (default 0). Unity while Iron is off."),
+        masterSqueezeEnabled: z.union([z.literal(0), z.literal(1)]).optional().describe("Enable Squeeze — a 3-band upward+downward compressor (post-Punch, pre-Tape; zero latency). The character (thresholds, ratios) is baked; Depth is the main lever."),
         masterSqueezeDepth: z.number().min(0).max(1).optional().describe("Squeeze depth 0..1 (default 0.3): scales the applied per-band gain toward the full character — a density control, NOT a dry/wet. 0.15-0.3 densifies a master; 0.6+ is the aggressive pumped sound."),
         masterSqueezeTime: z.number().min(0.1).max(10).optional().describe("Squeeze time multiplier on all band attack+release (0.1 fast .. 10 slow, default 1)."),
         masterSqueezeTone: z.number().min(-1).max(1).optional().describe("Squeeze tone: bipolar low<->high band tilt, ±6 dB at the extremes (default 0)."),
@@ -5332,6 +6381,8 @@ server.registerTool("set_master_effects", {
         masterSqueezeUpAmount: z.number().min(0).max(1.5).optional().describe("Squeeze upward-branch trim 0..1.5 (default 1). 0 disables the upward lift (downward-only multiband)."),
         masterSqueezeDownAmount: z.number().min(0).max(1.5).optional().describe("Squeeze downward-branch trim 0..1.5 (default 1). 0 disables the downward limiting (pure upward lift)."),
         masterSqueezeUpCapDb: z.number().min(0).max(24).optional().describe("Squeeze upward max-boost clamp dB (default 12) — bounds how far quiet material (tails, noise floor) is lifted."),
+        masterSqueezeLoCross: z.number().min(10).max(500).optional().describe("Squeeze low/mid crossover Hz (default 88.3)."),
+        masterSqueezeHiCross: z.number().min(500).max(20000).optional().describe("Squeeze mid/high crossover Hz (default 2500)."),
         masterLoudnessAutoReset: z.union([z.literal(0), z.literal(1)]).optional().describe("Loudness meter auto-reset on host transport start (default 1). 0 keeps measurements running across transport stops."),
         masterEqBells: z
             .array(z.object({
@@ -5390,7 +6441,7 @@ server.registerTool("set_master_effects", {
     // No-dispatch path: every master key is live-polled from master_config
     // (the full Punch surface included), so a graph rebuild here would only
     // risk dropouts during automated mastering.
-    await applyKv(delta, KV_OPTS_MASTER_CONFIG);
+    await applyKv(delta, MASTER_CONFIG_KV_OPTIONS);
     const summary = Object.entries(delta)
         .map(([k, v]) => `${k}=${v}`)
         .join(", ");
@@ -5399,7 +6450,7 @@ server.registerTool("set_master_effects", {
 // Built-in per-cell drum synth ("machines"). Engine enum index = drumsynth::Engine
 // (Off = 0). The roster, the curated defaults and the engine-switch rule all come
 // from shared/drumSynthEngines.json — the registry build.js codegens the C++ cook
-// and the manifest from, and interface/src/dsp/modules/drumSynth.ts derives its
+// and the manifest from, and interface/src/utils/drumSynth.ts derives its
 // own tables from. The hand-copied table this replaced had drifted on Kick,
 // Cowbell and 808 (issue #999); the switch rule it shipped with carried knob
 // positions where the plugin carries engine units.
@@ -5422,6 +6473,14 @@ const DRUM_SYNTH_REGISTRY = (() => {
 })();
 const drumSynth = createDrumSynthCatalog(DRUM_SYNTH_REGISTRY);
 const DRUM_SYNTH_ENGINE_NAMES = drumSynth.engineNames;
+const DRUM_SYNTH_MODE_ROSTER = drumSynth.engines
+    .filter((e) => e.modes.length > 0)
+    .map((e) => `${e.name}=[${e.modes.map((m) => m.name).join(",")}]`)
+    .join("; ");
+const DRUM_SYNTH_HOLD_ENGINES = drumSynth.engines
+    .filter((e) => e.hold || e.modes.some((m) => m.hold))
+    .map((e) => (e.hold ? e.name : `${e.name} (${e.modes.filter((m) => m.hold).map((m) => m.name).join("/")} mode)`))
+    .join(", ");
 /** State carries the bare enum; agents reason about the name. Report both. */
 function describeSynthEngine(raw) {
     const id = Math.round(Number(raw ?? 0));
@@ -5439,12 +6498,28 @@ server.registerTool("set_drum_synth", {
         "(re-mapped through the destination's own range), so Kick Decay 0.41 becomes Stab Decay 0.336 — the same 198 ms. " +
         "Untouched slots, and slots whose label or unit has no counterpart, take the destination's default. Per-engine p-labels: " +
         drumSynth.engines.map((e) => `${e.name}=[${e.params.map((p) => p.label).join(",")}]`).join("; ") + ". " +
+        `Engine modes are alternative topologies over the same knobs: ${DRUM_SYNTH_MODE_ROSTER}. A mode belongs to ` +
+        "its engine: a change of engine without mode selects the first one, the original render; re-selecting the " +
+        "cell's current engine keeps its mode. hold:true makes each new " +
+        "hit sustain at its post-attack level for as long as its note is held (a sequencer step's gate length or a " +
+        `held MIDI key), then decay at the live Decay rate. Only ${DRUM_SYNTH_HOLD_ENGINES} sustain; on any other ` +
+        "engine or mode the flag is stored but has no effect. The synth-only output stage after the voice sum is four " +
+        "ordinary parameters, set with set_parameters: cell{N}_synthFilterMode (0 Off, 1 LP, 2 BP, 3 HP), " +
+        "cell{N}_synthCutoff (Hz), cell{N}_synthReso (%), cell{N}_synthDrive (%). " +
         "NOTE: requires a PAM build with drum synth (manifest.drumSynth.enabled). This headless tool is product-gated, " +
         "not gated by the UI-only drumSynthEnabled preference. " +
         "On products without it, this tool returns a product error instead of writing inert synth keys.",
     inputSchema: {
         cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
         engine: z.enum(DRUM_SYNTH_ENGINE_NAMES).describe("Engine name. 'Off' disables the synth voice (sample-only cell)."),
+        mode: z
+            .string()
+            .optional()
+            .describe(`Engine mode name, case-insensitive: ${DRUM_SYNTH_MODE_ROSTER}. Other engines have none. Omitted: kept on the same engine, the first mode on a change.`),
+        hold: z
+            .boolean()
+            .optional()
+            .describe(`Sustain each hit while its note is held, then decay (cell{N}_synthHold). Sustains only on ${DRUM_SYNTH_HOLD_ENGINES}; a trigger_midi note-on then rings until its noteOn:false.`),
         volume: z.number().min(-60).max(12).optional().describe("Synth output level in dB (default 0)."),
         p1: z.number().min(0).max(1).optional().describe("Param 1 (engine-specific; usually Tune). Overrides the engine default."),
         p2: z.number().min(0).max(1).optional().describe("Param 2 (engine-specific)."),
@@ -5455,7 +6530,7 @@ server.registerTool("set_drum_synth", {
         p7: z.number().min(0).max(1).optional().describe("Param 7 (engine-specific)."),
         p8: z.number().min(0).max(1).optional().describe("Param 8 (engine-specific)."),
     },
-}, async ({ cellId, engine, volume, ...overrides }) => {
+}, async ({ cellId, engine, mode, hold, volume, ...overrides }) => {
     const check = await requireBridge();
     if (check !== true)
         return check;
@@ -5469,10 +6544,17 @@ server.registerTool("set_drum_synth", {
     const engineId = DRUM_SYNTH_ENGINE_NAMES.indexOf(engine);
     if (engineId < 0)
         return error(`Unknown drum synth engine: ${engine}`);
+    const desc = drumSynth.getEngine(engineId);
+    const modes = desc?.modes ?? [];
+    const modeId = mode === undefined ? -1 : modes.findIndex((m) => m.name.toLowerCase() === mode.trim().toLowerCase());
+    if (mode !== undefined && modeId < 0) {
+        return error(modes.length > 0
+            ? `Unknown ${engine} mode: ${mode}. Valid modes: ${modes.map((m) => m.name).join(", ")}.`
+            : `${engine} has no engine modes. Modes exist on ${DRUM_SYNTH_MODE_ROSTER}.`);
+    }
     const stateRaw = await bridge.send("getState");
     const state = isRecord(stateRaw) ? stateRaw : {};
     const delta = drumSynth.buildEngineSwitchDelta(cellId, engineId, state);
-    const desc = drumSynth.getEngine(engineId);
     if (desc) {
         for (const [key, value] of Object.entries(overrides)) {
             if (value === undefined)
@@ -5484,10 +6566,26 @@ server.registerTool("set_drum_synth", {
     }
     if (volume !== undefined)
         delta[`cell${cellId}_synthVolume`] = volume;
-    // synthEngine is a graph-render key → needs a graph dispatch (KV_OPTS_STANDARD).
-    await applyKv(delta, KV_OPTS_STANDARD);
+    if (modeId >= 0)
+        delta[`cell${cellId}_synthMode`] = modeId;
+    if (hold !== undefined)
+        delta[`cell${cellId}_synthHold`] = hold ? 1 : 0;
+    // synthEngine is a graph-render key → needs a graph dispatch (STATE_UPDATE_KV_OPTIONS).
+    await applyKv(delta, STATE_UPDATE_KV_OPTIONS);
     const labels = desc ? desc.params.map((p) => p.label).join(",") : "—";
-    return text(`Cell ${cellId} drum synth → ${engine}${engineId > 0 ? ` (p1..pN = ${labels})` : ""}.`);
+    let summary = `Cell ${cellId} drum synth → ${engine}${engineId > 0 ? ` (p1..pN = ${labels})` : ""}.`;
+    if (modeId >= 0)
+        summary += ` Mode ${modes[modeId].name}.`;
+    if (hold === false)
+        summary += " Hold off.";
+    if (hold === true) {
+        const playedMode = Math.round(Number(delta[`cell${cellId}_synthMode`] ?? state[`cell${cellId}_synthMode`] ?? 0));
+        summary += drumSynth.holdsInMode(engineId, playedMode)
+            ? " Hold on: each hit sustains while its note is held."
+            : ` Hold on, but ${engine}${modes.length > 0 ? ` in mode ${modes[playedMode]?.name ?? modes[0].name}` : ""} ` +
+                `does not sustain; it takes effect on ${DRUM_SYNTH_HOLD_ENGINES}.`;
+    }
+    return text(summary);
 });
 server.registerTool("set_drum_synth_wave", {
     title: "Set Drum Synth Wave Curve (Wave engine)",
@@ -5545,7 +6643,7 @@ const playerSlotArg = (n) => z
 server.registerTool("list_players", {
     title: "List Generative Players",
     description: "Catalogue of PAM's generative Players — per-cell generators that replace a cell's drawn pattern with a " +
-        "seeded, transport-synced cycle (EUCLID, KIT, TURING, WALK, MARKOV, RATCHET, PHASE, RIFF, MASK). Returns each " +
+        "seeded, transport-synced cycle (EUCLID, KIT, TURING, WALK, MARKOV, RATCHET, PHASE, RIFF, MASK, PERC). Returns each " +
         "player's blurb, defaults, P-slot vocabulary (detented positions or 0..1 knobs) and curated preset names, plus " +
         "the role spread (which player each cell arms by default). Offline — no bridge needed. Arm one with set_player.",
     inputSchema: {
@@ -5580,13 +6678,29 @@ server.registerTool("list_players", {
         ],
     });
 });
+/** The plugin's default-source rule (PlayerListenSection): a cell worth hearing runs a Player or has drawn
+ *  notes, and for Harmonic its notes are pitches (`cellNotesArePitches`). */
+function cellSounds(state, cells, id, mode, midiProduct) {
+    const raw = cells[String(id)];
+    const cell = isRecord(raw) ? raw : {};
+    const drawn = state[`cell${id}_midiSequence`];
+    const sounds = cellPlayerType(cell) > 0 || (Array.isArray(drawn) && drawn.length > 0);
+    if (!sounds || mode !== 3)
+        return sounds;
+    const mono = !midiProduct && Math.round(Number(cell.isPoly ?? 0)) !== 1;
+    const drumPlayer = getPlayerSpec(cellPlayerType(cell))?.tag === "drum";
+    return !mono && (!drumPlayer || Math.round(Number(cell.playerPatternMode ?? 0)) === 1);
+}
 server.registerTool("set_player", {
     title: "Set Generative Player",
     description: "Arm, edit or switch off a cell's generative Player (PAM-only). Passing `player` arms that generator with the " +
         "roster's own voicing (or a curated `preset`), the track genre on genre-aware players, and a reversible poly " +
         "arm on melodic ones; omit `player` to edit the running player's values in place. Values land in both the cell " +
         "config and the cell{N}_player* automation params, like the plugin UI. 'off' restores the drawn pattern and the " +
-        "cell's pre-arm polyphony. The player sounds only while the transport runs. The UI shows a running player " +
+        "cell's pre-arm polyphony and scale. A melodic arm in the plugin UI also gives a chromatic cell the house or song " +
+        "scale; here the scale stays update_cell_config's (scaleName/scaleRoot). Pass p1 to choose PERC's drum; without it " +
+        "PERC arms on Conga. A plugin-UI arm also takes the cell's snap as the grid when the cell never chose one; " +
+        "here pass grid, or the cell keeps its own (1/4 when unset). The player sounds only while the transport runs. The UI shows a running player " +
         "unprompted; to arm from the UI as well, update_settings { experimentalMode: true, experimentalGenerativePatterns: true }.",
     inputSchema: {
         cellIds: z
@@ -5616,19 +6730,33 @@ server.registerTool("set_player", {
         patternMode: z
             .enum(PATTERN_MODES)
             .optional()
-            .describe("'mask' (default): the player replaces the drawn pattern. 'keep': the drawn pattern keeps sounding and the player layers over it."),
+            .describe("'mask' (default, shown as Replace in the UI): the player replaces the drawn pattern. 'keep' (shown as Layer): the drawn pattern keeps sounding and the player layers over it."),
+        grid: z
+            .enum(PLAYER_GRIDS)
+            .optional()
+            .describe("The step the player generates on, named as the snap menu names it: 1/N of a beat, so '1/4' is sixteenths (the default), " +
+            "'1/3' eighth-note triplets, '1/2' eighths. A cycle holds at most 128 steps; a longer pattern stretches the step. " +
+            "Swing is off on 1/3, 1/5 and 1/9. Kept per cell; it never follows the snap menu."),
         listenMode: z
             .enum(LISTEN_MODES)
             .optional()
-            .describe("Ensemble listening: react to another cell's last completed cycle — complement its gaps, answer it, or shade velocity harmonically."),
-        listenSource: z.number().int().min(0).max(8).optional().describe("Listening source: 0 = all other cells, 1-8 = one cell (never itself)."),
-        listenAmount: z.number().min(0).max(1).optional().describe("Listening strength 0..1."),
+            .describe("Ensemble listening on the source's last completed cycle: complement gives way where it played and fills its rests, " +
+            "answer replies half a phrase later, harmonic favours the notes it sounds. A soft source note pushes less than the loudest notes the cell hears. " +
+            "Switching listening on without listenSource hears the cell's role partner (the bass hears the kick), as the plugin UI does."),
+        listenSource: z.number().int().min(0).max(8).optional().describe("Listening source: 0 = all other cells, 1-8 = one cell (a cell's own number is skipped)."),
+        listenAmount: z.number().min(0).max(1).optional().describe("Listening strength 0..1: a nudge low down; at 1 the relationship decides which candidates play."),
+        listenPair: z
+            .enum(LISTEN_PAIRS)
+            .optional()
+            .describe("Two cells that complement each other: 'keep' gives this cell the steps they share (its partner gives way), " +
+            "'trade' never settles (they swap those steps every cycle), 'auto' (default) lets the lower cell keep them. " +
+            "Written to both cells of the pair; refused while a cell complements several cells."),
         poly: z
             .boolean()
             .optional()
             .describe("Override the automatic poly arm: true forces poly, false keeps the cell mono even for a melodic player."),
     },
-}, async ({ cellIds, player, preset, genre, density, mutate, p1, p2, p3, p4, p5, seed, patternMode, listenMode, listenSource, listenAmount, poly }) => {
+}, async ({ cellIds, player, preset, genre, density, mutate, p1, p2, p3, p4, p5, seed, patternMode, grid, listenMode, listenSource, listenAmount, listenPair, poly }) => {
     const check = await requireBridgeForCells(cellIds);
     if (check !== true)
         return check;
@@ -5636,6 +6764,7 @@ server.registerTool("set_player", {
     const gate = playerProductError(manifest);
     if (gate)
         return gate;
+    const midiProduct = !!manifest && isMsqManifest(manifest);
     const playerRef = typeof player === "string" ? player.trim().toLowerCase() : player;
     const wantsOff = playerRef === "off" || playerRef === 0;
     const wantsRole = playerRef === "role";
@@ -5670,11 +6799,20 @@ server.registerTool("set_player", {
                 config.isPoly = prePoly;
             if (preRoot !== undefined)
                 config.polyRootNote = preRoot;
+            // The scale a melodic arm seeded in the plugin UI goes back with the player.
+            const preScale = typeof cell.playerPreScale === "string" && cell.playerPreScale !== NO_SCALE_ARM ? cell.playerPreScale : undefined;
+            if (preScale !== undefined) {
+                config.scaleName = preScale;
+                config.scaleRoot = recorded("playerPreScaleRoot") ?? 0;
+            }
             config.playerPrePoly = NO_POLY_ARM;
             config.playerPreRoot = NO_POLY_ARM;
+            config.playerPreScale = NO_SCALE_ARM;
+            config.playerPreScaleRoot = NO_POLY_ARM;
             cellsDelta[String(cellId)] = config;
             lines.push(`Cell ${cellId}: ${getPlayerSpec(currentType)?.name ?? "player"} off — drawn pattern restored` +
-                `${prePoly !== undefined || preRoot !== undefined ? ", pre-arm polyphony restored" : ""}.`);
+                `${prePoly !== undefined || preRoot !== undefined ? ", pre-arm polyphony restored" : ""}` +
+                `${preScale !== undefined ? ", pre-arm scale restored" : ""}.`);
             continue;
         }
         const roleConfig = wantsRole ? rolePlayerConfigFor(cellId) : undefined;
@@ -5726,12 +6864,23 @@ server.registerTool("set_player", {
             config.playerSeed = seed === "random" ? randomPlayerSeed() : Math.round(seed);
         if (patternMode)
             config.playerPatternMode = PATTERN_MODES.indexOf(patternMode);
+        if (grid)
+            config.playerGrid = playerGridValue(grid);
         if (listenMode)
             config.playerListenMode = LISTEN_MODES.indexOf(listenMode);
-        if (listenSource !== undefined)
+        if (listenSource !== undefined && listenSource !== cellId)
             config.playerListenSource = listenSource;
+        // Switching listening on with no source named hears the role partner, never the whole rack by default.
+        const startsListening = (listenSource === undefined || listenSource === cellId) && (config.playerListenMode ?? 0) > 0 &&
+            Math.round(Number(cell.playerListenMode ?? 0)) <= 0 && Math.round(Number(cell.playerListenSource ?? 0)) === 0;
+        if (startsListening) {
+            const mode = config.playerListenMode;
+            config.playerListenSource = listenPartnerFor(cellId, mode, 8, (id) => cellSounds(state, cellsObj, id, mode, midiProduct));
+        }
         if (listenAmount !== undefined)
             config.playerListenAmount = listenAmount;
+        if (listenPair)
+            config.playerListenPair = LISTEN_PAIRS.indexOf(listenPair);
         // Reversible poly arm: record the pre-arm values once, never the armed state.
         const autoPoly = arming && poly !== false && (isMelodicPlayer(spec) || roleConfig?.isPoly === 1);
         let polyNote = "";
@@ -5771,16 +6920,74 @@ server.registerTool("set_player", {
             parts.push(`seed ${config.playerSeed}`);
         if (patternMode)
             parts.push(`pattern ${patternMode}`);
+        if (grid)
+            parts.push(`grid ${grid}`);
         if (listenMode)
-            parts.push(`listen ${listenMode}`);
+            parts.push(`listen ${listenMode}${config.playerListenSource !== undefined ? ` to ${config.playerListenSource > 0 ? `cell ${config.playerListenSource}` : "all"}` : ""}`);
+        if (listenSource === cellId)
+            parts.push(`source ${cellId} skipped (a cell cannot listen to itself)`);
+        if (listenPair)
+            parts.push(`pair ${listenPair}`);
         lines.push(`Cell ${cellId}: ${spec.name} ${arming ? "armed" : "updated"} — ${parts.join(", ")}${polyNote}.`);
     }
+    // A pair's choice lands on both cells, as the plugin's pair chips write it.
+    if (listenPair) {
+        const cellOf = (id) => {
+            const raw = cellsObj[String(id)];
+            return { ...(isRecord(raw) ? raw : {}), ...(cellsDelta[String(id)] ?? {}) };
+        };
+        const choice = LISTEN_PAIRS.indexOf(listenPair);
+        const partnerChoice = listenPair === "keep" ? LISTEN_PAIRS.indexOf("auto") : choice;
+        for (const cellId of cellIds) {
+            if (!cellsDelta[String(cellId)])
+                continue;
+            const partner = soleComplementPartner(cellOf, cellId, 8);
+            if (partner < 0) {
+                const crowded = crowdedComplementCell(cellOf, cellId, 8);
+                return error(`Cell ${crowded} complements several cells, so one pair choice would settle all of them; give cell ${crowded} one listenSource first.`);
+            }
+            if (partner === 0) {
+                lines.push(`Cell ${cellId}: no cell complements it back yet; its pair choice applies once one does.`);
+                continue;
+            }
+            if (listenPair === "keep" && cellIds.includes(partner))
+                return error(`Cells ${cellId} and ${partner} complement each other: name one of them for listenPair 'keep'.`);
+            cellsDelta[String(partner)] = { ...(cellsDelta[String(partner)] ?? {}), playerListenPair: partnerChoice };
+            if (!cellIds.includes(partner))
+                lines.push(`Cell ${partner}: ${listenPair === "keep" ? `gives cell ${cellId} the steps they share` : `pair ${listenPair}`}.`);
+        }
+    }
     if (Object.keys(cellsDelta).length === 0)
         return text(lines.join("\n"));
-    await applyKv({ ...flatDelta, cells: cellsDelta }, KV_OPTS_CELL_CONFIG);
+    await applyKv({ ...flatDelta, cells: cellsDelta }, CELL_CONFIG_KV_OPTIONS);
     return text(`${lines.join("\n")}\n` +
         "Players sound only while the transport runs; get_design_overview reports each cell's player.");
 });
+server.registerTool("keep_player", {
+    title: "Keep a Player's Cycles",
+    description: "Commit what a cell's generative Player played into its drawn pattern (PAM-only), through the plugin UI so it is " +
+        "one undo step: 'cycle' merges the cycle playing now, 'previous' the one before it, 'last-two' both, and 'freeze' " +
+        "merges the cycle and switches the Player off. Merges are unions with the drawn notes. Needs the PAM window open " +
+        "and the transport having run a cycle; the commit is asynchronous, so read cell{N}_midiSequence with get_state after.",
+    inputSchema: {
+        cellId: z.number().int().min(1).max(8).describe("The Player cell (1-8)."),
+        keep: z.enum(["cycle", "previous", "last-two", "freeze"]).describe("Which cycles to commit; 'freeze' also switches the Player off."),
+    },
+}, async ({ cellId, keep }) => {
+    const check = await requireBridgeForCells(cellId);
+    if (check !== true)
+        return check;
+    const gate = playerProductError(await loadManifestForProductGuard());
+    if (gate)
+        return gate;
+    const cells = await bridge.send("getState", "cells").catch(() => undefined);
+    const cell = isRecord(cells) ? cells[String(cellId)] : undefined;
+    if (!(isRecord(cell) && Number(cell.playerType) > 0))
+        return error(`Cell ${cellId} runs no Player — nothing to keep.`);
+    await bridge.send("playerKeep", { cellId, keep });
+    return text(`Cell ${cellId}: ${keep === "freeze" ? "freeze" : `keep ${keep}`} sent to the plugin window. ` +
+        "Nothing lands if that cycle has not played yet; check cell" + cellId + "_midiSequence.");
+});
 /** A cell's sample as a readable file: absolute as given, else relative to a library root. */
 async function resolveCellSampleFile(filePath) {
     const expanded = expandHome(filePath);
@@ -5870,7 +7077,7 @@ server.registerTool("set_slices", {
     };
     if (currentKnob < 1 || currentKnob > sliceCount)
         delta[`cell${cellId}_slice`] = 1;
-    await applyKv(delta, KV_OPTS_CELL_CONFIG);
+    await applyKv(delta, CELL_CONFIG_KV_OPTIONS);
     let sequenceNote = "";
     if (sequence) {
         const transportRaw = await bridge.send("getTransport").catch(() => undefined);
@@ -5908,7 +7115,10 @@ server.registerTool("set_slices", {
             [`cell${cellId}_slice`]: 1,
             cells: { [cellId]: { modLatch: 1 } },
             __forceRender__: true,
-        }, KV_OPTS_PATTERN);
+        }, 
+        // Pattern lengths are DAW params and modLatch is cell config: interop's
+        // applySliceSequenceFromBoundaries syncs both, so this must too.
+        { ...PATTERN_EDIT_KV_OPTIONS, syncConfigResources: true, updateParameters: true });
         sequenceNote = ` Chopped into the slice + note lanes over ${patternLength} beats at ${bpm} BPM; start_transport to hear it.`;
     }
     const positions = resolved.slice(1, -1).map((b) => `${Math.round(b * 1000) / 10}%`);
@@ -5925,11 +7135,12 @@ server.registerTool("add_param_seq", {
         cellId: z.number().min(1).max(8).describe("Cell ID (1-8) — used for routing."),
         sequence: z
             .array(z.number().min(0).max(1))
+            .max(128)
             .optional()
-            .describe("Step values (0-1). Defaults to 16 steps of 0.5."),
+            .describe("Step values (0-1), up to 128. Defaults to 16 steps of 0.5."),
         strength: z.number().min(0).max(1).default(0.5).describe("Modulation depth (0-1)."),
         bipolar: z.union([z.literal(0), z.literal(1)]).default(0).describe("0 = unipolar, 1 = bipolar."),
-        length: z.number().min(0.0625).max(16).default(1).describe("Pattern length in bars."),
+        length: z.number().min(1 / 64).max(16).default(1).describe("Pattern length in bars."),
         speed: z.number().min(0.0625).max(16).default(1).describe("Pattern speed multiplier."),
         freeMode: z
             .union([z.literal(0), z.literal(1)])
@@ -5945,13 +7156,25 @@ server.registerTool("add_param_seq", {
     if (check !== true)
         return check;
     const index = await getParameterIndex();
-    const param = index.get(paramId);
-    if (!param)
-        return error(formatUnknownParamError(paramId, index, { modulatableOnly: true }));
-    if (!param.isModulatable)
-        return error(formatNotModulatableError(paramId, index));
+    const param = await resolveModulationTarget(paramId, index);
+    if (typeof param === "string")
+        return error(param);
     const existing = await bridge.send("getState", "paramSeqs");
     const paramSeqs = (Array.isArray(existing) ? existing : []).filter((seq) => seq?.paramId !== paramId);
+    // The target's effect and macro switch on, as the UI's addParamSeq does.
+    const enables = {};
+    if (param.effect && /^cell\d+$/.test(param.cell ?? ""))
+        enables[`${param.cell}_${param.effect}Enabled`] = 1;
+    if (paramId.startsWith("macro_")) {
+        const macrosRaw = await bridge.send("getState", "macros");
+        const macros = Array.isArray(macrosRaw) ? macrosRaw : [];
+        const held = macros.find((m) => m.paramId === paramId);
+        if (held?.enabled !== 1) {
+            enables.macros = held
+                ? macros.map((m) => (m === held ? { ...m, enabled: 1 } : m))
+                : [...macros, { paramId, enabled: 1, strength: 0.5, bipolar: 0, mode: 0 }];
+        }
+    }
     const newSeq = {
         paramId,
         cellId,
@@ -5967,7 +7190,7 @@ server.registerTool("add_param_seq", {
         stepMode,
     };
     paramSeqs.push(newSeq);
-    await applyKv({ paramSeqs }, KV_OPTS_MOD);
+    await applyKv({ paramSeqs, ...enables }, STATE_UPDATE_KV_OPTIONS);
     return text(`Added paramSeq for ${paramId} (${newSeq.sequence.length} steps, strength ${strength}).`);
 });
 server.registerTool("update_param_seq", {
@@ -5976,9 +7199,9 @@ server.registerTool("update_param_seq", {
         "Use add_param_seq first if no paramSeq exists for this paramId.",
     inputSchema: {
         paramId: z.string().describe("Target parameter ID."),
-        sequence: z.array(z.number().min(0).max(1)).optional().describe("New step values (0-1)."),
+        sequence: z.array(z.number().min(0).max(1)).max(128).optional().describe("New step values (0-1), up to 128."),
         strength: z.number().min(0).max(1).optional().describe("Modulation depth (0-1)."),
-        length: z.number().min(0.0625).max(16).optional().describe("Pattern length in bars."),
+        length: z.number().min(1 / 64).max(16).optional().describe("Pattern length in bars."),
         speed: z.number().min(0.0625).max(16).optional().describe("Pattern speed multiplier."),
         bipolar: z.union([z.literal(0), z.literal(1)]).optional().describe("0 = unipolar, 1 = bipolar."),
         enabled: z.union([z.literal(0), z.literal(1)]).optional().describe("0 = bypass the sequencer, 1 = run it."),
@@ -6010,37 +7233,51 @@ server.registerTool("update_param_seq", {
         return error(`No paramSeq found for ${paramId}. Use add_param_seq first.`);
     }
     paramSeqs[idx] = { ...paramSeqs[idx], ...cleanUpdates };
-    await applyKv({ paramSeqs }, KV_OPTS_MOD);
+    await applyKv({ paramSeqs }, STATE_UPDATE_KV_OPTIONS);
     return text(`Updated paramSeq ${paramId}: ${Object.keys(cleanUpdates).join(", ")}`);
 });
 server.registerTool("set_free_sequencer", {
     title: "Set Free Sequencer",
-    description: "Write the Free Sequencer's master step contour (top-level `freeSeqSequence`, 2..64 steps of 0..1). Every " +
+    description: "Write the Free Sequencer's master step contour (top-level `freeSeqSequence`, 2..128 steps of 0..1). Every " +
         "parameter sequencer mapped to it (freeMode:1 via add_param_seq / update_param_seq) follows these steps AND its " +
         "clock live, each with its own strength, polarity and smoothing; cell-locked and Gate-mode sequencers keep " +
         "their own steps. An empty contour restores the legacy per-sequencer behaviour.",
     inputSchema: {
-        sequence: z.array(z.number().min(0).max(1)).min(2).max(64).describe("Master step values, 0..1 each."),
+        sequence: z
+            .array(z.number().min(0).max(1))
+            .max(128)
+            .describe("Master step values, 0..1 each: 2..128 steps, or [] to clear the contour."),
     },
 }, async ({ sequence }) => {
     const check = await requireBridge();
     if (check !== true)
         return check;
+    if (sequence.length === 1)
+        return error("A contour needs 2..128 steps; pass [] to clear it.");
     await bridge.send("applyFreeSeqSequenceUpdate", { sequence });
+    if (sequence.length === 0)
+        return text("Free Sequencer contour cleared; mapped sequencers use their own steps.");
     return text(`Free Sequencer: ${sequence.length} steps written. Map a paramSeq with freeMode:1 to follow it.`);
 });
+// getMidiExportEvents' cap (MCPBridge::handleGetMidiExportEvents); check-parity compares the two.
+const MAX_MIDI_EXPORT_BEATS = 1024;
 server.registerTool("export_midi", {
     title: "Export MIDI",
-    description: "Write the cells' drawn note patterns to a Standard MIDI File (type 1, 480 PPQ, tempo from the transport): " +
-        "one track per cell on MIDI channel = cell number, each pattern tiled across `bars`. Pure file write — no " +
-        "render, nothing changes in PAM. Generated Player cycles are not drawn patterns; FREEZE them first (in the UI) " +
-        "to export what a player is playing. Default location is PAM's Exports folder.",
-    inputSchema: {
-        filename: z.string().optional().describe("Base name without extension (default pam_midi_<epoch>)."),
-        cellIds: z.array(z.number().int().min(1).max(8)).optional().describe("Cells to include (default: every cell with notes)."),
-        bars: z.number().min(1).max(64).optional().describe("Length in 4/4 bars (default: the longest included pattern cycle, at least 1)."),
+    description: "Write the cells' note patterns to a Standard MIDI File (type 1, 480 PPQ, tempo and meter from the transport): " +
+        "one track per cell, across `bars`. MSQ writes each cell on its output channel (Auto = cell number), leaves " +
+        "out a cell with Send off and notes outside a poly cell's Low-High; PAM writes notes on the cell number and " +
+        "CC on the cell's MIDI out channel. Each sending CC out slot's value opens the track at tick 0, its CC lane's " +
+        "locks and releases follow on the lane's own clock, and a pedal still down at the end is lifted there. A Player cell exports the cycles it " +
+        "generates (density-gated, PATTERN Keep layered), rendered by PAM itself; Listen responses are left out. " +
+        "Grid timing from base values: swing, probability, CTRL macros and modulators are not applied. Nothing " +
+        "changes in PAM. Default location " +
+        "is PAM's Exports folder.",
+    inputSchema: {
+        filename: z.string().optional().describe("Base name without extension (default <product>_midi_<epoch>)."),
+        cellIds: z.array(z.number().int().min(1).max(8)).optional().describe("Cells to include (default: every cell with notes or CC out)."),
+        bars: z.number().min(1).max(64).optional().describe("Length in bars of the transport's meter (default: the longest included pattern cycle, at least 1)."),
         mode: z.enum(["combined", "stems"]).optional().describe("'combined' (default): one multi-track file. 'stems': one file per cell."),
-        outputDir: z.string().optional().describe("Directory to write into (default: the Exports location from get_default_locations)."),
+        outputDir: z.string().optional().describe("Directory to write into (default: PAM's Exports folder)."),
     },
 }, async ({ filename, cellIds, bars, mode, outputDir }) => {
     const check = await requireBridgeForCells(cellIds);
@@ -6049,28 +7286,38 @@ server.registerTool("export_midi", {
     const manifest = await loadManifestForProductGuard();
     if (manifest && isMfxManifest(manifest))
         return error("export_midi needs sampler cells with note patterns; MFX has none.");
-    const [stateRaw, transportRaw, locations] = await Promise.all([
+    const [stateRaw, transportRaw, exportsDir] = await Promise.all([
         bridge.send("getState"),
         bridge.send("getTransport").catch(() => undefined),
-        bridge.send("getDefaultLocations").catch(() => undefined),
+        exportsFolder(),
     ]);
     const state = isRecord(stateRaw) ? stateRaw : {};
-    const bpm = Number(isRecord(transportRaw) ? transportRaw.bpm : undefined) || Number(state.bpm) || 120;
-    let dir = outputDir ? expandHome(outputDir) : undefined;
-    if (!dir) {
-        if (Array.isArray(locations)) {
-            const exportsEntry = locations.find((entry) => isRecord(entry) && /export/i.test(String(entry.name)));
-            if (isRecord(exportsEntry) && typeof exportsEntry.path === "string")
-                dir = exportsEntry.path;
-        }
-        else if (isRecord(locations)) {
-            dir = [locations.exports, locations.exportsLocation, locations.Exports].find((v) => typeof v === "string" && v.length > 0);
-        }
-    }
+    const transport = isRecord(transportRaw) ? transportRaw : {};
+    const bpm = Number(transport.bpm) || Number(state.bpm) || 120;
+    // A build whose getTransport predates the meter writes 4/4, as it always did.
+    const numerator = Math.round(Number(transport.timeSigNumerator));
+    const denominatorPower = Math.round(Math.log2(Number(transport.timeSigDenominator)));
+    const meter = numerator >= 1 && numerator <= 32 && denominatorPower >= 0 && denominatorPower <= 5
+        ? { numerator, denominator: 2 ** denominatorPower }
+        : { numerator: 4, denominator: 4 };
+    const barBeats = beatsPerBar(meter);
+    const dir = outputDir ? expandHome(outputDir) : exportsDir;
     if (!dir)
         return error("Could not resolve PAM's Exports folder from get_default_locations — pass outputDir.");
     const maxCell = manifestMaxCellId(manifest) ?? 8;
     const ids = (cellIds?.length ? cellIds : Array.from({ length: maxCell }, (_, i) => i + 1)).filter((id) => id <= maxCell);
+    const cellConfig = (id) => {
+        const cells = isRecord(state.cells) ? state.cells : {};
+        const config = cells[String(id)];
+        return isRecord(config) ? config : {};
+    };
+    const playerIds = ids.filter((id) => Number(cellConfig(id).playerType) > 0);
+    // A GRAB follower plays its source's notes, so an empty own grid does not rule it out.
+    const followerIds = ids.filter((id) => Number(cellConfig(id).seqFrom) > 0);
+    const ccIds = ids.filter((id) => CC_OUT_CONFIG_KEYS.some((key) => {
+        const controller = cellConfig(id)[key];
+        return typeof controller === "number" && Number.isInteger(controller) && controller >= 0 && controller <= 119;
+    }));
     const cells = ids
         .map((id) => ({
         id,
@@ -6078,39 +7325,101 @@ server.registerTool("export_midi", {
         patternLength: state[`cell${id}_patternLength`],
         speed: state[`cell${id}_patternSpeed`],
     }))
-        .filter((cell) => Array.isArray(cell.sequence) && cell.sequence.length > 0);
+        .filter((cell) => (Array.isArray(cell.sequence) && cell.sequence.length > 0) ||
+        playerIds.includes(cell.id) ||
+        followerIds.includes(cell.id) ||
+        ccIds.includes(cell.id));
     if (cells.length === 0)
-        return error("No note patterns to export — the selected cells carry no notes.");
-    const cycleBars = cells.map((cell) => {
-        const length = Number(cell.patternLength);
-        const speedIndex = Math.round(Number(cell.speed));
+        return error("Nothing to export — the selected cells carry no notes, run no Player and send no CC out.");
+    const cycleOf = (length, speed) => {
+        const bars = Number(length);
+        const speedIndex = Math.round(Number(speed));
         const mul = Number.isFinite(speedIndex) ? patternSpeedMultiplier(speedIndex) : 1;
-        return (Number.isFinite(length) && length > 0 ? length : 4) / mul / 4;
-    });
-    const totalBars = bars ?? Math.max(1, Math.ceil(Math.max(...cycleBars)));
-    const totalBeats = totalBars * 4;
-    const tracks = cells.map((cell) => ({
-        name: `Cell ${cell.id}`,
-        events: tilePatternEvents(cell.sequence, cell.patternLength, cell.speed, totalBeats, Math.min(16, cell.id)),
-    }));
-    const base = (filename?.trim() || `pam_midi_${Date.now()}`).replace(/\.mid$/i, "").replace(/[\\/:]/g, "_");
+        return (Number.isFinite(bars) && bars > 0 ? bars : 4) / mul / barBeats;
+    };
+    // A CC lane loops on its own clock, so its cycle counts toward the default length too.
+    const cycleBars = cells.flatMap((cell) => [
+        cycleOf(cell.patternLength, cell.speed),
+        ...CC_LANES.map(ccLaneIndex)
+            .filter((lane) => {
+            const sequence = state[`cell${cell.id}_ccOut${lane}Sequence`];
+            return Array.isArray(sequence) && sequence.length > 0;
+        })
+            .map((lane) => cycleOf(state[`cell${cell.id}_patternLengthCc${lane}`], state[`cell${cell.id}_patternSpeedCc${lane}`])),
+    ]);
+    const maxBars = Math.max(1, Math.floor(MAX_MIDI_EXPORT_BEATS / barBeats));
+    const totalBars = Math.min(maxBars, bars ?? Math.max(1, Math.ceil(Math.max(...cycleBars))));
+    const totalBeats = totalBars * barBeats;
+    // PAM renders the notes itself (Player cycles included); a build without the route
+    // falls back to tiling the drawn grids here. Any other failure is reported, not tiled.
+    let native;
+    try {
+        native = await bridge.send("getMidiExportEvents", { beats: totalBeats, cellIds: cells.map((cell) => cell.id) });
+    }
+    catch (e) {
+        const msg = e.message;
+        if (!/unknown action|does not support/i.test(msg))
+            return error(`export_midi failed: ${msg}`);
+    }
+    const nativeCells = isRecord(native) && Array.isArray(native.cells) ? native.cells.filter(isRecord) : undefined;
+    const staleBuildNote = !nativeCells && playerIds.length > 0
+        ? `This PAM build predates Player-aware export: cell ${playerIds.join(", ")} exported its drawn grid, not the Player. Update PAM.`
+        : !nativeCells && ccIds.length > 0
+            ? `This PAM build predates CC export: cell ${ccIds.join(", ")} left its CC out behind. Update PAM.`
+            : undefined;
+    const tracks = cells
+        .map((cell) => {
+        const rendered = nativeCells?.find((entry) => Number(entry.cellId) === cell.id);
+        // Only a build without the route lands here without channels; it predates MSQ's output channel.
+        const fallbackChannel = Math.min(16, cell.id);
+        const events = rendered && Array.isArray(rendered.events)
+            ? rendered.events.filter(isRecord).map((e) => ({
+                channel: Number(e.channel) || fallbackChannel,
+                note: Number(e.note),
+                velocity: Number(e.velocity),
+                startBeats: Number(e.startBeats),
+                durationBeats: Number(e.durationBeats),
+            }))
+            : tilePatternEvents(cell.sequence, cell.patternLength, cell.speed, totalBeats, fallbackChannel);
+        const cc = rendered && Array.isArray(rendered.cc)
+            ? rendered.cc.filter(isRecord).map((e) => ({
+                channel: Number(e.channel) || fallbackChannel,
+                controller: Number(e.controller),
+                value: Number(e.value),
+                beats: Number(e.beats),
+            }))
+            : [];
+        return { name: `Cell ${cell.id}`, events, cc };
+    })
+        .filter((track) => track.events.length > 0 || track.cc.length > 0);
+    if (tracks.length === 0)
+        return error(staleBuildNote ?? "Nothing to export — the selected cells rendered no notes or CC over that length.");
+    const notes = [];
+    if (staleBuildNote)
+        notes.push(staleBuildNote);
+    const listening = playerIds.filter((id) => Number(cellConfig(id).playerListenMode) > 0 && cells.some((cell) => cell.id === id));
+    if (nativeCells && listening.length > 0)
+        notes.push(`Cell ${listening.join(", ")} listens to other cells; the file carries its cycles without that response.`);
+    const product = manifest && isMsqManifest(manifest) ? "msq" : "pam";
+    const base = (filename?.trim() || `${product}_midi_${Date.now()}`).replace(/\.mid$/i, "").replace(/[\\/:]/g, "_");
     await mkdir(dir, { recursive: true });
     const written = [];
     if (mode === "stems") {
         for (const track of tracks) {
             const path = join(dir, `${base}_cell${track.name.slice(5)}.mid`);
-            await writeFile(path, buildMidiFile(bpm, [track], track.name));
+            await writeFile(path, buildMidiFile(bpm, [track], track.name, meter, totalBeats));
             written.push(path);
         }
     }
     else {
         const path = join(dir, `${base}.mid`);
-        await writeFile(path, buildMidiFile(bpm, tracks, base));
+        await writeFile(path, buildMidiFile(bpm, tracks, base, meter, totalBeats));
         written.push(path);
     }
     const noteCount = tracks.reduce((sum, track) => sum + track.events.length, 0);
-    return text(`Exported ${noteCount} notes from ${tracks.length} cell${tracks.length === 1 ? "" : "s"} over ${totalBars} bar${totalBars === 1 ? "" : "s"} at ${bpm} BPM.\n` +
-        written.map((path) => `File: ${path}`).join("\n"));
+    const ccCount = tracks.reduce((sum, track) => sum + track.cc.length, 0);
+    return text(`Exported ${noteCount} notes${ccCount > 0 ? ` and ${ccCount} CC messages` : ""} from ${tracks.length} cell${tracks.length === 1 ? "" : "s"} over ${totalBars} bar${totalBars === 1 ? "" : "s"}${meter.numerator === 4 && meter.denominator === 4 ? "" : ` of ${meter.numerator}/${meter.denominator}`} at ${bpm} BPM.\n` +
+        [...written.map((path) => `File: ${path}`), ...notes].join("\n"));
 });
 server.registerTool("remove_param_seq", {
     title: "Remove Parameter Sequencer",
@@ -6125,7 +7434,7 @@ server.registerTool("remove_param_seq", {
         return check;
     const existing = await bridge.send("getState", "paramSeqs");
     const paramSeqs = (Array.isArray(existing) ? existing : []).filter((seq) => seq?.paramId !== paramId);
-    await applyKv({ paramSeqs }, KV_OPTS_MOD);
+    await applyKv({ paramSeqs }, STATE_UPDATE_KV_OPTIONS);
     return text(`Removed paramSeq for ${paramId}.`);
 });
 server.registerTool("normalize_sample", {
@@ -6138,6 +7447,9 @@ server.registerTool("normalize_sample", {
     const check = await requireBridgeForCells(cellId);
     if (check !== true)
         return check;
+    const loaded = await requireCellSample(cellId);
+    if (loaded !== true)
+        return loaded;
     await bridge.send("normalizeSampleForCell", cellId);
     return text(`Normalized sample in cell ${cellId}.`);
 });
@@ -6157,9 +7469,64 @@ server.registerTool("gain_sample", {
     const check = await requireBridgeForCells(cellId);
     if (check !== true)
         return check;
+    const loaded = await requireCellSample(cellId);
+    if (loaded !== true)
+        return loaded;
     await bridge.send("gainSampleForCell", { cellId, gainDb });
     return text(`Applied ${gainDb > 0 ? "+" : ""}${gainDb} dB to the sample in cell ${cellId}.`);
 });
+// Mirrors pam::repitch::kMaxCoarseSemitones / kMaxFineCents (modules/sampler/SampleRepitch.h).
+const REPITCH_COARSE_RANGE = 24;
+const REPITCH_FINE_RANGE = 100;
+const PITCH_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+const pitchName = (midi) => {
+    const note = Math.round(midi);
+    const cents = Math.round((midi - note) * 100);
+    const name = `${PITCH_NAMES[((note % 12) + 12) % 12]}${Math.floor(note / 12) - 1}`;
+    return cents === 0 ? name : `${name} ${cents > 0 ? "+" : ""}${cents} cents`;
+};
+server.registerTool("analyze_sample_pitch", {
+    title: "Analyze Sample Pitch",
+    description: "Detect the fundamental of a cell's single-note sample and suggest the repitch_sample shift that centres it on the nearest C. " +
+        "The sampler's root note is a C, so a sample centred on C is the one the global tuning layer retunes correctly.",
+    inputSchema: {
+        cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
+    },
+}, async ({ cellId }) => {
+    const check = await requireBridgeForCells(cellId);
+    if (check !== true)
+        return check;
+    const result = (await bridge.send("analyzeSamplePitch", cellId));
+    if (!result?.loaded)
+        return error(`Cell ${cellId} has no readable sample.`);
+    const hz = result.hz ?? 0;
+    if (hz <= 0)
+        return text(`No stable pitch in cell ${cellId}'s sample; tune it by ear with repitch_sample.`);
+    const midi = 69 + 12 * Math.log2(hz / 440);
+    const target = Math.round(midi / 12) * 12;
+    const semitones = Math.round(target - midi) || 0;
+    const cents = Math.round((target - midi - semitones) * 100) || 0;
+    return text(`Cell ${cellId} sounds ${pitchName(midi)} (${hz.toFixed(2)} Hz, confidence ${Math.round((result.confidence ?? 0) * 100)}%). ` +
+        `Nearest C is ${pitchName(target)}: repitch_sample with semitones ${semitones}, cents ${cents}.`);
+});
+server.registerTool("repitch_sample", {
+    title: "Repitch Sample",
+    description: "Varispeed a cell's sample by semitones plus cents and render it into a new file (offline, destructive): pitch and length change together, like tape. " +
+        "analyze_sample_pitch suggests the shift that centres a single-note sample on C. The original library file is left unchanged.",
+    inputSchema: {
+        cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
+        semitones: z.number().int().min(-REPITCH_COARSE_RANGE).max(REPITCH_COARSE_RANGE).describe("Coarse shift in semitones."),
+        cents: z.number().min(-REPITCH_FINE_RANGE).max(REPITCH_FINE_RANGE).default(0).describe("Fine shift in cents."),
+    },
+}, async ({ cellId, semitones, cents }) => {
+    if (semitones === 0 && cents === 0)
+        return error("A zero shift leaves the sample unchanged.");
+    const check = await requireBridgeForCells(cellId);
+    if (check !== true)
+        return check;
+    await bridge.send("repitchSampleForCell", { cellId, semitones, cents });
+    return text(`Repitched the sample in cell ${cellId} by ${semitones} semitones ${cents} cents.`);
+});
 // Poll the offline-render status flag until the export completes or times out.
 async function pollExportStatus(maxWaitMs = 180_000, pollMs = 500) {
     const t0 = Date.now();
@@ -6168,6 +7535,7 @@ async function pollExportStatus(maxWaitMs = 180_000, pollMs = 500) {
         const status = (await bridge.send("getExportStatus"));
         if (status.complete) {
             lastExportLoudness = status.loudness ?? null;
+            lastExportError = typeof status.error === "string" ? status.error : null;
             return status.success ? "success" : "failed";
         }
     }
@@ -6175,6 +7543,11 @@ async function pollExportStatus(maxWaitMs = 180_000, pollMs = 500) {
 }
 // Loudness report of the last completed bounce (set by pollExportStatus).
 let lastExportLoudness = null;
+// Native reason for the last failed bounce, when the plugin reports one.
+let lastExportError = null;
+function exportFailureDetail() {
+    return lastExportError ? ` ${lastExportError}` : "";
+}
 function loudnessReportLine() {
     const l = lastExportLoudness;
     if (!l || typeof l.i !== "number")
@@ -6192,7 +7565,8 @@ function loudnessReportLine() {
 }
 server.registerTool("export_audio", {
     title: "Export Audio",
-    description: "Render and export audio from the current preset to a WAV file in PAM's Exports folder. " +
+    description: "Render and export audio from the current preset in a running PAM instance to a WAV file in PAM's Exports folder. " +
+        "For a saved preset with no PAM open, use the paid `preset render` command through `pam mcp`'s `run` tool; it supports master, stems, variations and songs. " +
         "Waits for completion. Default mode renders the looping preset for `bars` bars at the current BPM. " +
         "Set `mode` to bounce stems or the whole Song Mode arrangement.\n\n" +
         "Modes: 'main' (full mix, default) · 'individual' (one cell solo, needs cellId) · " +
@@ -6250,7 +7624,7 @@ server.registerTool("export_audio", {
                 `Duration: ${durationSecs.toFixed(1)}s (${bars} bars at ${bpm} BPM, ${bitDepth}-bit)` +
                 loudnessReportLine());
         if (outcome === "failed")
-            return error("Audio export failed.");
+            return error(`Audio export failed.${exportFailureDetail()}`);
         return text(`Export timed out. The render may still be running.\nExpected output: ${outputPath}`);
     }
     // Stem / song-mode modes: build full pass-through options (filename + mode +
@@ -6281,7 +7655,7 @@ server.registerTool("export_audio", {
             `File(s) written to ${SERVER_PRODUCT.name}'s Exports folder, base name: ${filename}.wav` +
             loudnessReportLine());
     if (outcome === "failed")
-        return error(`Export failed (mode '${effectiveMode}').`);
+        return error(`Export failed (mode '${effectiveMode}').${exportFailureDetail()}`);
     return text(`Export timed out (mode '${effectiveMode}'). The render may still be running.`);
 });
 // ============================================================
@@ -6333,7 +7707,9 @@ server.registerResource("cell-parameters", new ResourceTemplate(`${SERVER_PRODUC
 });
 server.registerResource("global-parameters", `${SERVER_PRODUCT.resourceScheme}://parameters/global`, {
     title: "Global Parameters",
-    description: "Non-cell-specific parameters (volume, crossfade, looper, etc.).",
+    description: IS_MSQ_SERVER
+        ? "Non-cell-specific parameters (LFOs, macros, XY, pattern selectors)."
+        : "Non-cell-specific parameters (volume, crossfade, looper, etc.).",
     mimeType: "application/json",
 }, async (uri) => {
     const params = await getGlobalParameters();
@@ -6362,7 +7738,7 @@ MFX has four effects cells. Audio reaches a cell only when the cable patch route
             }],
     }));
 }
-else {
+else if (!IS_MSQ_SERVER) {
     server.registerResource("beat-making-guide", "pam://guide/beat-making", {
         title: "PAM Beat-Making Guide",
         description: "Comprehensive guide for creating beats with PAM. Covers cell roles, slicer for loops, " +
@@ -6758,12 +8134,37 @@ if (IS_MFX_SERVER) {
         description: "Diagnose why live tools cannot reach MFX.",
         argsSchema: {},
     }, () => promptText(`Diagnose the MFX MCP connection:\n\n` +
-        `1. Run connection_status. If no instance appears, start MFX and enable Settings → Experimental → MCP Bridge.\n` +
+        `1. Run connection_status. If no instance appears, start MFX and enable Settings → Integrations → MCP Bridge.\n` +
         `2. MFX starts at the configured port and automatically takes the next available port when needed; do not assign a second fixed product port.\n` +
         `3. If an instance appears but cannot connect, it may have closed or be busy with a render; retry once.\n` +
         `4. If a live tool is unavailable, update the MFX plugin as well as the mfx-mcp package.`));
 }
-if (!IS_MFX_SERVER)
+if (IS_MSQ_SERVER) {
+    server.registerPrompt("sequence-a-part", {
+        title: "Sequence a Part",
+        description: "Turn a musical brief into cells that drive the host's instruments, then save it.",
+        argsSchema: {
+            brief: z.string().describe("Musical brief, e.g. 'rolling acid bass on channel 2 with a filter sweep'."),
+        },
+    }, ({ brief }) => promptText(`Sequence this in MSQ: "${brief}"\n\n` +
+        `1. connection_status, then get_design_overview for what each cell sends now.\n` +
+        `2. set_bpm, and configure_transport for the time signature if the brief needs one.\n` +
+        `3. Wire each cell with update_cell_config: output channel (0 = Auto, the cell number) matching the instrument that should play it, trigger note, poly and scale, Send on.\n` +
+        `4. Notes: update_pattern (type 'note'), or set_player for a generated part (list_players first); randomize target:'sequences' gives a starting point.\n` +
+        `5. CC: update_cell_config ccOutCc1-16 picks controllers, set_parameters cell{N}_ccOut{K} sets their values, update_pattern with type 'ccOut1'-'ccOut4' draws CC lanes. add_modulation adds movement.\n` +
+        `6. start_transport: notes leave only while it rolls.\n` +
+        `7. save_preset and update_preset_metadata; export_midi writes the parts to a MIDI file.`));
+    server.registerPrompt("troubleshoot-bridge", {
+        title: "Troubleshoot the MSQ Bridge",
+        description: "Diagnose why live tools cannot reach MSQ, or why its instruments stay silent.",
+        argsSchema: {},
+    }, () => promptText(`Diagnose the MSQ MCP connection:\n\n` +
+        `1. Run connection_status. If no instance appears, start MSQ and enable Settings → Integrations → MCP Bridge.\n` +
+        `2. MSQ records its actual port on startup. If an instance appears but cannot connect, it may have closed; retry once.\n` +
+        `3. MSQ makes no sound itself. If nothing plays, check each cell's Send and channel with get_design_overview, that the host routes MSQ's MIDI out to an instrument listening on that channel, and that the transport is rolling.\n` +
+        `4. If a live tool is unavailable, update the MSQ plugin as well as the msq-mcp package.`));
+}
+if (SERVER_PRODUCT.id === "pam")
     server.registerPrompt("build-a-beat", {
         title: "Build a Beat",
         description: "Guided kit-building + pattern workflow: coherent samples, genre patterns, transport, refinement, save.",
@@ -6778,7 +8179,7 @@ if (!IS_MFX_SERVER)
         `4. start_transport — sequencer output needs the transport rolling.\n` +
         `5. Refine: update_pattern for individual lanes, set_parameters for levels/filters (ranges via design_context), update_effect_config to switch FX on, add_modulation for movement. For a groove that evolves, set_player (player 'role' across the kit, or KIT / EUCLID / RIFF per cell — list_players first${genre ? `, genre '${genre}'` : ""}).\n` +
         `6. save_preset once it works, and update_preset_metadata with genre tags and BPM.`));
-if (!IS_MFX_SERVER)
+if (SERVER_PRODUCT.id === "pam")
     server.registerPrompt("make-a-song", {
         title: "Make a Song",
         description: "Arrange the current preset into sections with variations + Song Mode, then bounce a full track.",
@@ -6791,7 +8192,7 @@ if (!IS_MFX_SERVER)
         `3. Audition: start_transport with Song Mode driving the timeline; queue_variation switches sections live.\n` +
         `4. Bounce with export_song — strategy 'live' captures the ground-truth master mix (required for Magenta/Notochord/automation), strategy 'offline' is the deterministic multi-section bounce with no bar cap. includeVideo:true films the VX scene (window must be open).\n` +
         `5. The rendered file lands in PAM's Exports/Resamples locations — get_default_locations resolves them.`));
-if (!IS_MFX_SERVER)
+if (SERVER_PRODUCT.id === "pam")
     server.registerPrompt("design-a-preset", {
         title: "Design a Preset",
         description: "Sound-design workflow from a creative brief to a saved preset.",
@@ -6805,7 +8206,7 @@ if (!IS_MFX_SERVER)
         `4. Add movement: add_modulation (LFO / envelope / vary), add_param_seq for stepped motion.\n` +
         `5. Write patterns with update_pattern, then start_transport to audition.\n` +
         `6. save_preset with a fitting name and update_preset_metadata (category, tags, BPM).`));
-if (!IS_MFX_SERVER)
+if (SERVER_PRODUCT.id === "pam")
     server.registerPrompt("mix-and-master", {
         title: "Mix and Master",
         description: "Balance the cells and shape the master bus using the analysis + suggestion tools.",
@@ -6816,13 +8217,13 @@ if (!IS_MFX_SERVER)
         `3. Shape the master bus with set_master_effects (compressor, tape, limiter — design_context lists the keys).\n` +
         `4. Re-check get_master_analysis and iterate toward the loudness target.\n` +
         `5. Render with export_audio (mode 'main'; 'all-cells' for stems).`));
-if (!IS_MFX_SERVER)
+if (SERVER_PRODUCT.id === "pam")
     server.registerPrompt("troubleshoot-bridge", {
         title: "Troubleshoot the PAM Bridge",
         description: "Diagnose why live tools can't reach the plugin.",
         argsSchema: {},
     }, () => promptText(`Diagnose the PAM MCP connection:\n\n` +
-        `1. connection_status. No instances → PAM isn't running or the bridge is off (PAM Settings → Experimental Mode → MCP Bridge, default port 9847). Multiple instances → select_instance picks which product the live tools drive.\n` +
+        `1. connection_status. No instances → PAM isn't running or the bridge is off (PAM Settings → Integrations → MCP Bridge, default port 9847). Multiple instances → select_instance picks which product the live tools drive.\n` +
         `2. Instances found but not connected → the plugin may have shut down, or its message thread is busy (heavy render); retry once.\n` +
         `3. Timeouts on WebView-routed tools (video tools, capture_ui, set_drum_synth_wave, randomize target 'synth') → the plugin window must be OPEN.\n` +
         `4. "PAM build does not support 'X'" errors → the plugin is older than this server; the user must update PAM (updating the npm package alone is not enough).\n` +
@@ -6830,20 +8231,11 @@ if (!IS_MFX_SERVER)
 // ============================================================
 // TOOLS — Looper (state deltas)
 // ============================================================
-// applyStateDelta-equivalent options: full update, dispatch graph, sync KV.
-const KV_OPTS_LOOPER_STATE = {
-    shouldDispatch: true,
-    syncKVResources: true,
-    syncConfigResources: true,
-    resyncKVAfterDispatch: true,
-    updateParameters: true,
-    broadcastFollowers: true,
-};
 async function applyLoopersDelta(loopers, extra) {
     const delta = { loopers, ...(extra ?? {}) };
     await bridge.send("applyUnifiedStateKvUpdate", {
         delta,
-        options: KV_OPTS_LOOPER_STATE,
+        options: STATE_UPDATE_KV_OPTIONS,
     });
 }
 server.registerTool("arm_looper_track", {
@@ -7146,7 +8538,7 @@ server.registerTool("looper_settings", {
 server.registerTool("looper_variation", {
     title: "Looper Variation",
     description: "Manage looper variation slots (clip-set snapshots). Operations: 'apply' (immediate), 'queue' (bar-synced), " +
-        "'cancel', 'clear', 'setCurrent', 'save' (snapshot current looper state into the slot).",
+        "'cancel', 'clear', 'setCurrent', 'save' (write a snapshot object from the `data` field into the slot).",
     inputSchema: {
         op: z
             .enum(["apply", "queue", "cancel", "clear", "setCurrent", "save"])
@@ -7159,7 +8551,7 @@ server.registerTool("looper_variation", {
             .describe("Variation slot 0-7 (required for apply/queue/clear/setCurrent/save)."),
         intervalBars: z
             .number()
-            .min(0.125)
+            .min(0.25)
             .max(64)
             .optional()
             .describe("Bar interval for 'queue' (required for queue)."),
@@ -7167,7 +8559,7 @@ server.registerTool("looper_variation", {
         data: z
             .record(z.string(), z.unknown())
             .optional()
-            .describe("For 'save': the looper variation snapshot (object). Omit this field to clear the slot instead."),
+            .describe("For 'save' (required): the looper variation snapshot object. Use op 'clear' to empty a slot."),
     },
 }, async (args) => {
     const check = await requireBridge();
@@ -7204,10 +8596,10 @@ server.registerTool("looper_variation", {
         case "save":
             if (args.index === undefined)
                 return error("'save' requires index");
-            await bridge.send("saveLooperVariation", { index: args.index, data: args.data ?? null });
-            return text(args.data
-                ? `Saved looper variation slot ${args.index}.`
-                : `Cleared looper variation slot ${args.index} (no data).`);
+            if (!args.data)
+                return error("'save' requires data (a looper variation snapshot); use op 'clear' to empty a slot.");
+            await bridge.send("saveLooperVariation", { index: args.index, data: args.data });
+            return text(`Saved looper variation slot ${args.index}.`);
     }
     return text("No-op");
 });
@@ -7216,12 +8608,18 @@ server.registerTool("looper_variation_sync", {
     description: "Configure how looper variation switches synchronize to bar boundaries.",
     inputSchema: {
         barSyncEnabled: z.boolean().optional().describe("Toggle bar-sync mode."),
-        intervalBars: z.number().min(0.125).max(64).optional().describe("Sync interval in bars."),
+        intervalBars: z
+            .number()
+            .optional()
+            .describe(`Sync interval in bars: one of ${LOOPER_BAR_SYNC_INTERVALS.join(", ")}.`),
     },
 }, async ({ barSyncEnabled, intervalBars }) => {
     const check = await requireBridge();
     if (check !== true)
         return check;
+    if (intervalBars !== undefined && !LOOPER_BAR_SYNC_INTERVALS.includes(intervalBars)) {
+        return error(`intervalBars must be one of ${LOOPER_BAR_SYNC_INTERVALS.join(", ")}; native resets anything else to 1.`);
+    }
     const updates = [];
     if (typeof barSyncEnabled === "boolean") {
         await bridge.send("setLooperVariationBarSyncEnabled", barSyncEnabled);
@@ -7236,6 +8634,18 @@ server.registerTool("looper_variation_sync", {
 // ============================================================
 // TOOLS — Bar-synced variation scheduling + variation hold
 // ============================================================
+// Shared by queue_variation and the song_mode transition schema below.
+const swapSpecSchema = z.object({
+    order: z
+        .array(z.number().int().min(1).max(16))
+        .refine((order) => new Set(order).size === order.length, { message: "swap.order must not repeat a cell" })
+        .optional()
+        .describe("Cell Swap hand-over order as 1-based cell numbers (leftmost swaps first); unlisted cells follow in ascending order. Omit or [] for left to right."),
+    timing: z
+        .enum(["immediate", "step", "bar"])
+        .optional()
+        .describe("When a cell whose threshold the curve crossed hands over: 'immediate' at once (default), 'step' at the next 16th-note step, 'bar' at the next bar line, both counted back from the transition's anchor bar."),
+});
 server.registerTool("queue_variation", {
     title: "Queue Variation Switch",
     description: "Schedule a global variation switch on the next bar boundary. " +
@@ -7244,7 +8654,7 @@ server.registerTool("queue_variation", {
         "already-engaged queued-flip window only; a from-idle flip hard-switches).",
     inputSchema: {
         index: z.number().min(0).max(7).describe("Variation slot 0-7."),
-        intervalBars: z.number().min(0.125).max(64).describe("Bars before switching."),
+        intervalBars: z.number().min(0.25).max(64).describe("Bars before switching."),
         fadeMs: z.number().min(0).max(2000).optional().describe("Crossfade duration in ms. Omit all transition options to inherit the native Bar Sync/Song Mode settings."),
         resetPhase: z
             .boolean()
@@ -7257,9 +8667,9 @@ server.registerTool("queue_variation", {
             .optional()
             .describe("Pre-anchor morph window in bars for this flip. Omit all transition options to inherit native settings."),
         morphMode: z
-            .enum(["auto", "param", "mix", "seq", "all"])
+            .enum(["auto", "param", "mix", "seq", "all", "swap"])
             .optional()
-            .describe("Morph style: 'param' glides continuous params (default); 'mix' equal-power blends the two sections; 'seq' adds a staged pattern dissolve to the glide (old notes lose trigger probability as new notes gain it); 'all' runs glide + dissolve + blend together; 'auto' lets the engine pick — mix when the sections differ in graph topology (samples, synth engines, routing) or when nothing can glide, param otherwise."),
+            .describe("Morph style: 'param' glides continuous params (default); 'mix' equal-power blends the two sections; 'seq' adds a staged pattern dissolve to the glide (old notes lose trigger probability as new notes gain it); 'all' runs glide + dissolve + blend together; 'swap' hands whole cells over one by one across the window (PAM only; order via transition.swap.order); 'auto' lets the engine pick — mix when the sections differ in graph topology (samples, synth engines, routing) or when nothing can glide, param otherwise."),
         morphCurve: z
             .enum(["linear", "ease", "exp", "log"])
             .optional()
@@ -7270,11 +8680,14 @@ server.registerTool("queue_variation", {
             mixLaw: z.enum(["equalPower", "equalGain", "correlation"]).optional(),
             tail: z.enum(["cut", "fade", "ring"]).optional(),
             tailMaxBars: z.number().min(0.25).max(8).optional(),
+            swap: swapSpecSchema
+                .optional()
+                .describe("Cell Swap settings for a swap morph: order (1-based cells, leftmost first; unlisted cells follow ascending) and timing."),
         })
             .optional()
             .describe("Advanced transition settings for this flip: pattern policy for a " +
-            "seq/all morph, blend gain law for a mix/all morph, and the outgoing section's " +
-            "tail. Omitted fields keep the defaults (dissolve, equalPower, fade)."),
+            "seq/all morph, blend gain law for a mix/all morph, the Cell Swap order for a swap morph, and the outgoing section's " +
+            "tail. Omitted fields keep the defaults (dissolve, equalPower, left to right, fade)."),
     },
 }, async ({ index, intervalBars, fadeMs, resetPhase, morphBars, morphMode, morphCurve, transition }) => {
     const check = await requireBridge();
@@ -7346,14 +8759,25 @@ server.registerTool("variation_hold", {
     if (check !== true)
         return check;
     const updates = [];
+    // The native router holds the live values; settings persist them the way the UI's
+    // setVariationHoldEnabled / syncVariationHoldBindings do.
+    const persisted = {};
     if (typeof enabled === "boolean") {
         await bridge.send("setVariationHoldEnabled", enabled);
+        persisted.variationHoldEnabled = enabled;
         updates.push(`enabled=${enabled}`);
     }
     if (bindings) {
-        await bridge.send("syncVariationHoldBindings", bindings);
+        const slots = Array.from({ length: PRESET_VARIATION_SLOTS }, (_, slot) => bindings[slot] ?? { triggerNote: -1, triggerChannel: 0 });
+        await bridge.send("syncVariationHoldBindings", slots);
+        persisted.variationHoldBindings = slots.map(({ triggerNote, triggerChannel }) => ({
+            triggerNote: triggerNote >= 0 ? triggerNote : null,
+            triggerChannel,
+        }));
         updates.push(`bindings=${bindings.length}`);
     }
+    if (Object.keys(persisted).length)
+        await bridge.send("applySettingsUpdate", persisted);
     if (allNotesOff) {
         await bridge.send("variationHoldAllNotesOff");
         updates.push("allNotesOff");
@@ -7440,6 +8864,21 @@ server.registerTool("midi_recording", {
     }
     return text("No-op");
 });
+server.registerTool("session_take", {
+    title: "Session Take",
+    description: "Record a session take: the master WAV plus a log of PAM's main window, rendered later to video by pam-render. " +
+        "PAM only; needs Settings > Experimental > Session Recorder. 'start' needs the window open. 'stop' saves in the " +
+        "background: poll 'status' until phase is 'idle' (saved to folder) or 'failed' (error). Returns the recorder status.",
+    inputSchema: {
+        op: z.enum(["start", "stop", "status"]).describe("Operation."),
+    },
+}, async ({ op }) => {
+    const check = await requireBridge();
+    if (check !== true)
+        return check;
+    const status = await bridge.send("sessionTake", op);
+    return text(typeof status === "string" ? status : JSON.stringify(status));
+});
 // ============================================================
 // TOOLS — Modulation updates (LFO/Env/Vary/Macro/ParamSeq)
 // ============================================================
@@ -7486,7 +8925,7 @@ server.registerTool("update_modulation", {
 // ============================================================
 const morphCurveEnum = z.enum(["linear", "ease", "exp", "log"]);
 const transitionSpecSchema = z.object({
-    mode: z.enum(["auto", "param", "mix", "seq", "all"]).optional(),
+    mode: z.enum(["auto", "param", "mix", "seq", "all", "swap"]).optional(),
     window: z
         .object({
         bars: z.number().min(0).max(8).optional(),
@@ -7508,6 +8947,7 @@ const transitionSpecSchema = z.object({
     })
         .optional(),
     phase: z.enum(["inherit", "reset", "continue"]).optional(),
+    swap: swapSpecSchema.optional().describe("Cell Swap settings (mode 'swap'; PAM only)."),
 });
 const TRANSITION_SPEC_HONESTY = "Advanced transition spec: pattern.policy " +
     "('dissolve' prob-morphs events, 'wipe' replaces them at a moving frontier, 'cells' hands " +
@@ -7515,7 +8955,7 @@ const TRANSITION_SPEC_HONESTY = "Advanced transition spec: pattern.policy " +
     "correlated sections, 'correlation' auto-adapts), audio.tail ('fade' default, 'cut', 'ring' " +
     "lets voices/FX decay up to tailMaxBars), phase ('reset'/'continue' overrides the song's " +
     "Reset Phase per cable), window.patternCurve/mixCurve (per-domain easing; patternCurve " +
-    "defaults linear). window.staggerBy (off/cell/category), staggerSpread (0..0.9), staggerOrder (forward/reverse), and relations (off/stepped) shape the parameter glide. Runs on variation sections + queued flips, and on preset destinations " +
+    "defaults linear). window.staggerBy (off/cell/category), staggerSpread (0..0.9), staggerOrder (forward/reverse), and relations (off/stepped) shape the parameter glide. swap.order (1-based cells) sets the Cell Swap hand-over order and swap.timing (immediate/step/bar) when a crossed cell hands over, for mode 'swap', which swaps whole cells one by one along the curve (PAM only). Runs on variation sections + queued flips, and on preset destinations " +
     "when the lanePresetSections setting is on (the dual-lane preset section " +
     "pipeline; with it off, preset destinations coerce to a param glide). Offline bounces " +
     "coerce ring→fade, blend→hard switch. 'get' reads back each cable's resolvedTransition " +
@@ -7565,7 +9005,7 @@ server.registerTool("song_mode", {
         sections: z
             .array(z.object({
             variationIndex: z.number().min(0).max(7).describe("Audio variation slot 0-7 this section plays. With presetPath set, this selects the variation INSIDE that preset's own bank — the two compose, they are not mutually exclusive."),
-            bars: z.number().positive().optional().describe("Section length in bars (default: auto from longest pattern)."),
+            bars: z.number().int().min(1).optional().describe("Section length in whole bars (default: auto from longest pattern)."),
             repeat: z.number().int().min(1).optional().describe("Times to play before advancing (default 1)."),
             muted: z.boolean().optional().describe("Pass through without an audio trigger."),
             probability: z.number().min(0).max(1).optional().describe("Trigger probability (0-1)."),
@@ -7582,9 +9022,9 @@ server.registerTool("song_mode", {
                 .optional()
                 .describe("Morph glide easing; default ease. Ignored without morphBars."),
             morphMode: z
-                .enum(["auto", "param", "mix", "seq", "all"])
+                .enum(["auto", "param", "mix", "seq", "all", "swap"])
                 .optional()
-                .describe("Morph realization; default auto — the engine picks mix when the sections differ in graph topology (samples, synth engines, routing) or when nothing can glide, param otherwise. 'param' glides continuous params; 'mix' DJ-blends stems; 'seq' adds a staged pattern dissolve to the glide; 'all' runs glide + dissolve + blend. Ignored without morphBars."),
+                .describe("Morph realization; default auto — the engine picks mix when the sections differ in graph topology (samples, synth engines, routing) or when nothing can glide, param otherwise. 'param' glides continuous params; 'mix' DJ-blends stems; 'seq' adds a staged pattern dissolve to the glide; 'all' runs glide + dissolve + blend; 'swap' hands whole cells over one by one (PAM only). Ignored without morphBars."),
             transition: transitionSpecSchema.optional().describe(TRANSITION_SPEC_HONESTY),
             transitionPreset: z
                 .string()
@@ -7628,7 +9068,7 @@ server.registerTool("song_mode", {
                 .optional()
                 .describe("Per-cable morph easing; overrides the destination section's morphCurve."),
             morphMode: z
-                .enum(["auto", "param", "mix", "seq", "all"])
+                .enum(["auto", "param", "mix", "seq", "all", "swap"])
                 .optional()
                 .describe("Per-cable morph realization; overrides the destination section's morphMode. Same modes as the section field, incl. 'seq' (pattern dissolve) and 'all' (glide + dissolve + blend)."),
             transition: transitionSpecSchema.optional().describe("Per-cable " + TRANSITION_SPEC_HONESTY),
@@ -7808,9 +9248,118 @@ server.registerTool("song_mode", {
     }
     return text("No-op");
 });
+// TOOLS — DJ set (docs/plans/DJ_SINGLE_TIMELINE.md D23)
+const djBarsSchema = z.union([z.literal(1), z.literal(2), z.literal(4), z.literal(8), z.literal(16)]);
+// shared/dj/set.schema.json's longest window and ring tail, past song_mode's 8 (check-parity compares them).
+const DJ_TRANSITION_BARS_MAX = 32;
+// shared/dj/set.schema.json closes every object, so song_mode's spec is closed here section by section.
+const djTransitionSpecSchema = transitionSpecSchema
+    .extend({
+    window: transitionSpecSchema.shape.window.unwrap()
+        .extend({ bars: z.number().min(0).max(DJ_TRANSITION_BARS_MAX).optional() })
+        .strict()
+        .optional(),
+    pattern: transitionSpecSchema.shape.pattern.unwrap().strict().optional(),
+    audio: transitionSpecSchema.shape.audio.unwrap()
+        .extend({ tailMaxBars: z.number().min(0.25).max(DJ_TRANSITION_BARS_MAX).optional() })
+        .strict()
+        .optional(),
+    swap: swapSpecSchema.strict().optional().describe("Cell Swap settings (mode 'swap')."),
+})
+    .strict();
+const djTransitionSchema = z
+    .object({
+    preset: z.string().min(1).max(64).optional().describe("Transition preset id (drop, rise, break, blend, sweep, fill, or a saved one), stamped first."),
+    spec: djTransitionSpecSchema.optional().describe("Advanced transition spec, merged over the preset one level deep in each section."),
+    bars: z.number().min(0).max(DJ_TRANSITION_BARS_MAX).optional().describe(`Window length in bars, 0 to ${DJ_TRANSITION_BARS_MAX}; 0 is a cut.`),
+    mode: z.enum(["auto", "param", "mix", "seq", "all", "swap"]).optional().describe("AUTO, GLIDE (param), BLEND (mix), STEPS (seq), FULL (all) or SWAP."),
+    curve: morphCurveEnum.optional(),
+})
+    .strict();
+const djSetDocumentSchema = z
+    .object({
+    queue: z
+        .array(z
+        .object({
+        presetPath: z.string().min(1).max(4096),
+        variationIndex: z.number().int().min(0).max(7).optional().describe("Variation slot; absent plays the preset's first populated one."),
+        bars: z.number().int().min(1).max(64).optional().describe("The item's own length; absent follows stepBars."),
+        transition: djTransitionSchema.optional().describe("The boundary into this item; on queue[0], used only when it queues behind another NOW."),
+    })
+        .strict())
+        .min(1)
+        .max(65)
+        .describe("queue[0] is NOW; the rest play in order."),
+    stepBars: djBarsSchema.optional().describe("Bars each item plays under Auto (default 4)."),
+    launchBars: djBarsSchema.optional().describe("The grid boundaries land on (default 1)."),
+    auto: z.boolean().optional().describe("Step to the next item every stepBars (default true); off holds NOW until a Go."),
+    autoMix: z.boolean().optional().describe("Auto mix: after its dwell, fill NEXT from the library and go (default false)."),
+    defaultTransition: djTransitionSchema.optional().describe("Every boundary without its own (default AUTO, 8 bars, ease); bars, mode or curve alone edit that default."),
+    tempo: z
+        .object({
+        source: z.enum(["master", "followNext"]).optional().describe("The master tempo, or glide to each NEXT's preset tempo."),
+        glideBars: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(4), z.literal(8)]).optional(),
+        bpm: z.number().min(20).max(400).optional().describe("Master tempo to glide to; refused while a DAW or MIDI clock owns it."),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const DJ_SET_BOUNDARY = z.object({}).passthrough();
+server.registerTool("dj_set", {
+    title: "DJ Set",
+    description: "Load a whole DJ set into PAM's DJ view in one call, or read it back (op 'get'). PAM only; the window must be open " +
+        "and the experimental DJ view on (update_settings {experimentalMode:true, experimentalDjView:true}). queue[0] is " +
+        "NOW. Stopped, the set starts on queue[0] (loading it); playing, nothing is cut: a queue[0] equal to NOW keeps " +
+        "playing and the rest replace the queue, else every item queues behind NOW (nowMatched:false), behind any boundary " +
+        "already under way (kept). With an open set, an omitted top-level field keeps its running value. play:true starts " +
+        "the transport, so with auto (the default) the set runs. Pass `set` or the `presets` shorthand. The reply's `set` " +
+        "is canonical: sending it back changes nothing. Failures are {ok:false, code, error}.",
+    inputSchema: {
+        op: z.enum(["set", "get"]).optional().describe("'set' (default) loads; 'get' reads the open set and takes no other field."),
+        set: djSetDocumentSchema.optional(),
+        presets: z.array(z.string().min(1).max(4096)).min(1).max(65).optional().describe("Shorthand: these presets in order, each at its first populated slot."),
+        play: z.boolean().optional().describe("Start the transport after loading."),
+    },
+    outputSchema: {
+        ok: z.boolean(),
+        open: z.boolean().optional(),
+        playing: z.boolean().optional(),
+        bar: z.number().optional(),
+        bpm: z.number().optional(),
+        timeSig: z.array(z.number()).optional(),
+        set: z.object({}).passthrough().nullable().optional(),
+        now: z.object({ startBar: z.number() }).nullable().optional(),
+        boundaries: z.array(DJ_SET_BOUNDARY).optional(),
+        status: z.string().nullable().optional(),
+        nowMatched: z.boolean().optional(),
+        kept: z.number().optional(),
+        code: z.string().optional(),
+        error: z.string().optional(),
+    },
+}, async ({ op, set, presets, play }) => {
+    if ((op ?? "set") === "get" ? Boolean(set || presets) || play !== undefined : Boolean(set) === Boolean(presets))
+        return packFailure("dj_invalid_set", op === "get" ? "op 'get' takes no other field" : "Pass exactly one of set and presets.");
+    const check = await requireBridge();
+    if (check !== true)
+        return check;
+    const product = await connectedProduct();
+    if (product === "MFX" || product === "GATE" || product === "MSQ")
+        return packFailure("dj_unsupported_product", `${product} has no DJ view; dj_set is a PAM feature.`);
+    const reply = parseBridgeValue(await bridge.send("djSet", {
+        ...(op ? { op } : {}),
+        ...(set ? { set } : {}),
+        ...(presets ? { presets } : {}),
+        ...(play !== undefined ? { play } : {}),
+    }));
+    if (isPackFailure(reply))
+        return packFailure(reply.code, reply.error);
+    return structured(reply);
+});
 server.registerTool("export_song", {
     title: "Export Song (Full Track)",
-    description: "Bounce the full Song Mode arrangement — the 'render my whole track' button. " +
+    description: "Bounce the full Song Mode arrangement in a running PAM instance — the 'render my whole track' button. " +
+        "For a saved preset song with no PAM open, use the paid `preset render` command with song:true through `pam mcp`'s `run` tool. " +
         "Set up the arrangement first with the `song_mode` tool (prefer op setArrangement), then call this.\n\n" +
         "Strategies:\n" +
         "• 'live' + includeVideo:true — full A/V render: plays the arrangement in real time, films the VX " +
@@ -8069,7 +9618,7 @@ server.registerTool("preview_slice", {
     description: "Audition a single slice of a cell's sample.",
     inputSchema: {
         cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
-        sliceNumber: z.number().min(0).describe("Slice index (0-based)."),
+        sliceNumber: z.number().int().min(1).describe("Slice number, 1-based as in the UI (1 = first slice)."),
     },
 }, async ({ cellId, sliceNumber }) => {
     const check = await requireBridgeForCells(cellId);
@@ -8097,12 +9646,15 @@ server.registerTool("resample_sample_to_bpm", {
             .optional()
             .describe("Target BPM (defaults to current project BPM)."),
     },
-}, async (args) => {
+}, async ({ cellId, sourceBpm, targetBpm }) => {
     const check = await requireBridge();
     if (check !== true)
         return check;
-    await bridge.send("resampleSampleToBPM", args);
-    return text(`Resampled cell ${args.cellId} to BPM.`);
+    const loaded = await requireCellSample(cellId);
+    if (loaded !== true)
+        return loaded;
+    await bridge.send("resampleSampleToBPM", { cellId, sourceBPM: sourceBpm, targetBPM: targetBpm });
+    return text(`Resampled cell ${cellId} to ${targetBpm ?? "the project"} BPM.`);
 });
 server.registerTool("restore_original_sample", {
     title: "Restore Original Sample",
@@ -8114,6 +9666,9 @@ server.registerTool("restore_original_sample", {
     const check = await requireBridgeForCells(cellId);
     if (check !== true)
         return check;
+    const loaded = await requireCellSample(cellId, "originalFilePath");
+    if (loaded !== true)
+        return loaded;
     await bridge.send("restoreOriginalSample", { cellId });
     return text(`Restored original sample for cell ${cellId}.`);
 });
@@ -8136,7 +9691,7 @@ server.registerTool("export_slice", {
     description: "Export a single slice of a cell's sample as a standalone WAV.",
     inputSchema: {
         cellId: z.number().min(1).max(8).describe("Cell number (1-8)."),
-        sliceIndex: z.number().min(0).describe("Slice index (0-based)."),
+        sliceIndex: z.number().int().min(1).describe("Slice number, 1-based as in the UI (1 = first slice)."),
     },
 }, async ({ cellId, sliceIndex }) => {
     const check = await requireBridgeForCells(cellId);
@@ -8167,10 +9722,11 @@ server.registerTool("live_resample", {
             .describe("For 'start': destination cell the captured clip lands in. Use an empty/scratch cell for a full-mix bounce."),
         bars: z
             .number()
-            .min(0.125)
+            .int()
+            .min(1)
             .max(64)
             .optional()
-            .describe("For 'start': capture length in bars (max 64; the capture also stops on the 'stop' op)."),
+            .describe("For 'start': whole bars to capture (max 64; the capture also stops on the 'stop' op)."),
         source: z
             .enum(["cell", "input", "fullmix"])
             .default("cell")
@@ -8433,15 +9989,20 @@ server.registerTool("list_loaded_plugins", {
     title: "List Loaded Plugins",
     description: "List plugins currently hosted in PAM cells (instrument slot only — FX-side hosting is not exposed). " +
         "Each entry: cellId, name, manufacturer, format, " +
-        "path, isInstrument, bypassed, and the plugin's full param list (index, name, label, value, defaultValue, discrete, numSteps, and valueStrings for a discrete param). " +
-        "Use the param `index` with `set_plugin_param`.",
+        "path, isInstrument, bypassed, and the plugin's param list (index, name, label, value, defaultValue, discrete, numSteps, and valueStrings for a discrete param; " +
+        "JUCE's MIDI CC proxy parameters are omitted). Use the param `index` with `set_plugin_param`, and its `modTarget` as the paramId for add_modulation / add_param_seq.",
     inputSchema: {},
 }, async () => {
     const check = await requireBridge();
     if (check !== true)
         return check;
     const raw = await bridge.send("listLoadedPlugins");
-    return text(bridgeResultText(raw));
+    const listed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    for (const plugin of listed?.loadedPlugins ?? []) {
+        for (const p of plugin.params ?? [])
+            p.modTarget = hostedModTargetId(Number(plugin.cellId), p);
+    }
+    return text(bridgeResultText(listed));
 });
 server.registerTool("load_plugin", {
     title: "Load Plugin Into Cell",
@@ -8545,7 +10106,7 @@ server.registerTool("update_settings", {
     description: "Merge a partial settings delta into PAM's plugin settings (the Settings panel state) and apply it live. " +
         "Returns the full merged settings object so you can discover available keys. This is the only way to flip " +
         "experimental-feature gates from an agent. Common boolean keys: experimentalMode, " +
-        "experimentalPluginHost, experimentalMcpBridge. To enable the plugin host, set BOTH " +
+        "experimentalPluginHost, mcpBridgeEnabled (false closes this bridge after it replies). To enable the plugin host, set BOTH " +
         "experimentalMode:true AND the specific sub-flag (e.g. experimentalPluginHost:true) in one call. " +
         "Set drumSynthEnabled:false to hide its UI without muting loaded synths. Other keys " +
         "include UI/library preferences — call get_state or inspect the returned object for the current set.",
@@ -8614,7 +10175,7 @@ server.registerTool("configure_transport", {
 server.registerTool("get_audio_device_setup", {
     title: "Get Audio Device Setup",
     description: "Get the standalone audio/MIDI device setup (sample rate, buffer size, available and active input/output devices). " +
-        "Returns null when running plugin-hosted (the DAW owns the device config). Use the device IDs/names from here with set_midi_io.",
+        "Returns {pluginHosted:true} inside a DAW, which owns the device config. Use the device IDs/names from here with set_midi_io.",
     inputSchema: {},
     annotations: { readOnlyHint: true },
 }, async () => {
@@ -8622,6 +10183,9 @@ server.registerTool("get_audio_device_setup", {
     if (check !== true)
         return check;
     const setup = await bridge.send("getAudioDeviceSetup");
+    if (setup === null || (isRecord(setup) && Object.keys(setup).length === 0)) {
+        return json({ pluginHosted: true, note: "The DAW owns the audio and MIDI device setup." });
+    }
     return json(setup);
 });
 server.registerTool("get_memory_report", {
@@ -8655,35 +10219,76 @@ server.registerTool("set_audio_device", {
     const check = await requireBridge();
     if (check !== true)
         return check;
-    await bridge.send("setAudioDevice", [deviceName]);
+    await bridge.send("setAudioDevice", deviceName);
     return text(`Audio output device set to '${deviceName}'.`);
 });
 server.registerTool("set_midi_io", {
     title: "Set MIDI I/O Devices",
-    description: "Select MIDI input/output devices (standalone). Use get_audio_device_setup to discover device IDs first. " +
-        "All fields optional.",
+    description: "Select MIDI input/output devices (standalone). get_audio_device_setup lists them under midiInputs / " +
+        "midiOutputs (and each port's device under midiOutputPorts); pass each device's identifier or exact name. " +
+        "Ports B-D are extra outputs a cell can pick with update_cell_config midiOutPort. All fields optional.",
     inputSchema: {
-        inputDeviceIds: z.array(z.string()).optional().describe("Enabled MIDI input device IDs (replaces the active set)."),
-        outputDeviceId: z.string().optional().describe("MIDI output device ID."),
+        inputDeviceIds: z
+            .array(z.string())
+            .optional()
+            .describe("MIDI inputs to enable, by identifier or name. Replaces the active set; [] disables all inputs."),
+        outputDeviceId: z.string().optional().describe("MIDI output device, by identifier or name; \"\" selects none."),
         outputEnabled: z.boolean().optional().describe("Enable/disable MIDI output."),
+        outputPortDeviceIds: z
+            .array(z.string())
+            .max(3)
+            .optional()
+            .describe("Devices for Ports B, C and D in order, by identifier or name; \"\" leaves a port with no device."),
     },
 }, async (args) => {
     const check = await requireBridge();
     if (check !== true)
         return check;
     const applied = [];
+    // Native enables only exact identifiers and disables every other input, so an
+    // unresolved name must fail here rather than silently switch MIDI off.
+    const devices = args.inputDeviceIds?.length || args.outputDeviceId || args.outputPortDeviceIds?.some(Boolean)
+        ? await bridge.send("getMidiDevices").catch(() => undefined)
+        : undefined;
+    const resolveDevices = (kind, requested) => {
+        // Builds without getMidiDevices take identifiers as given.
+        if (!isRecord(devices) || !Array.isArray(devices[kind]))
+            return { ids: requested };
+        const listed = devices[kind].filter((device) => isRecord(device) && typeof device.name === "string" && typeof device.identifier === "string");
+        const ids = [];
+        for (const wanted of requested) {
+            const match = listed.find((device) => device.identifier === wanted || device.name === wanted);
+            if (!match)
+                return { error: `Unknown MIDI device '${wanted}'. Available: ${listed.map((device) => device.name).join(", ") || "none"}.` };
+            ids.push(match.identifier);
+        }
+        return { ids };
+    };
+    const inputs = args.inputDeviceIds?.length ? resolveDevices("midiInputs", args.inputDeviceIds) : { ids: [] };
+    if ("error" in inputs)
+        return error(inputs.error);
+    const output = args.outputDeviceId ? resolveDevices("midiOutputs", [args.outputDeviceId]) : { ids: [""] };
+    if ("error" in output)
+        return error(output.error);
     if (args.inputDeviceIds !== undefined) {
-        await bridge.send("setMidiInputDevices", args.inputDeviceIds);
-        applied.push(`inputs=${args.inputDeviceIds.length}`);
+        await bridge.send("setMidiInputDevices", inputs.ids);
+        applied.push(`inputs=${inputs.ids.length}`);
     }
     if (args.outputDeviceId !== undefined) {
-        await bridge.send("setMidiOutputDevice", args.outputDeviceId);
-        applied.push(`output=${args.outputDeviceId}`);
+        await bridge.send("setMidiOutputDevice", output.ids[0]);
+        applied.push(`output=${args.outputDeviceId || "none"}`);
     }
     if (args.outputEnabled !== undefined) {
         await bridge.send("setMidiOutputEnabled", args.outputEnabled);
         applied.push(`outputEnabled=${args.outputEnabled}`);
     }
+    for (const [index, wanted] of (args.outputPortDeviceIds ?? []).entries()) {
+        const resolved = wanted ? resolveDevices("midiOutputs", [wanted]) : { ids: [""] };
+        if ("error" in resolved)
+            return error(resolved.error);
+        await bridge.send("setMidiOutputPortDevice", index + 1, resolved.ids[0]);
+        applied.push(`port${"BCD"[index]}=${wanted || "none"}`);
+    }
     if (applied.length === 0)
         return error("No MIDI I/O fields provided.");
     return text(`MIDI I/O set: ${applied.join(", ")}.`);
@@ -8692,18 +10297,19 @@ server.registerTool("set_midi_mapping", {
     title: "Set MIDI Action Mapping",
     description: "Configure the global MIDI-controller mappings that trigger PAM actions: variation switch, preset change, " +
         "looper record, live resample, VX video record toggle, and looper-variation switch. Set the enable flag, " +
-        "MIDI channel, CC number, preset source, or bar-sync for each target. One field per call.",
+        "MIDI channel, CC number, source (Program Change or CC), or bar-sync for each target. One field per call.",
     inputSchema: {
         target: z
             .enum(["variation", "preset", "looper", "resample", "vxRecord", "looperVariation"])
             .describe("Which action's mapping to configure. 'vxRecord' toggles VX video recording — requires the PAM window open (VX renders in the WebView)."),
         field: z
             .enum(["enabled", "channel", "ccNumber", "source", "barSync"])
-            .describe("Field to set. 'source' is preset-only; 'barSync' is variation/looperVariation-only; " +
-            "looper/resample/vxRecord have no source/barSync."),
+            .describe("Field to set. 'source' applies to preset and variation (a variation switch on Program Change takes " +
+            "every program on its channel, so presets no longer load from it there); 'barSync' is " +
+            "variation/looperVariation-only; looper/resample/vxRecord have no source/barSync."),
         value: z
             .union([z.number(), z.boolean()])
-            .describe("boolean for enabled/barSync; number for channel (1-16), ccNumber (0-127), or source."),
+            .describe("boolean for enabled/barSync; number for channel (1-16), ccNumber (0-127), or source (0 = Program Change, 1 = CC)."),
     },
 }, async ({ target, field, value }) => {
     const check = await requireBridge();
@@ -8724,7 +10330,11 @@ server.registerTool("delete_preset", {
     const check = await requireBridge();
     if (check !== true)
         return check;
-    const result = await bridge.send("removePreset", presetPath);
+    if (isFactoryPresetPath(presetPath))
+        return error("Factory presets are protected and cannot be deleted.");
+    const result = await bridge.send("removePreset", nativePresetPath(presetPath));
+    if (result !== true)
+        return error(`Preset not found or not deletable: ${presetPath}`);
     return json(result);
 });
 server.registerTool("set_preset_factory_status", {
@@ -8738,7 +10348,7 @@ server.registerTool("set_preset_factory_status", {
     const check = await requireBridge();
     if (check !== true)
         return check;
-    const result = await bridge.send("togglePresetFactoryStatus", presetPath, makeFactory);
+    const result = await bridge.send("togglePresetFactoryStatus", nativePresetPath(presetPath), makeFactory);
     return json(result);
 });
 server.registerTool("get_sample_usage", {
@@ -8763,14 +10373,14 @@ server.registerTool("get_sample_usage", {
     if (check !== true)
         return check;
     const result = mode === "presetUsesSamples"
-        ? await bridge.send("getPresetSampleUsage", relPath)
+        ? await bridge.send("getPresetSampleUsage", nativePresetPath(relPath))
         : await bridge.send("getPresetsUsingSample", relPath, isFolder ?? false);
     return json(result);
 });
 server.registerTool("repair_preset_samples", {
     title: "Repair Preset Sample Paths",
     description: "Fix broken sample references in presets. mode 'fix' auto-relinks moved/renamed samples by searching the " +
-        "library (optionally scoped to one preset). mode 'rescan' re-audits a preset for still-missing samples and " +
+        "library (optionally scoped to one preset). mode 'rescan' re-audits the ACTIVE preset for still-missing samples and " +
         "reports them. Useful after moving a sample library or importing presets from another machine.",
     inputSchema: {
         mode: z
@@ -8779,18 +10389,20 @@ server.registerTool("repair_preset_samples", {
         presetPath: z
             .string()
             .optional()
-            .describe("Relative preset path. Omit for 'fix' to scan all presets; omit for 'rescan' to audit the active preset."),
+            .describe("'fix' only: relative preset path. Omit to scan all presets. 'rescan' always audits the active preset."),
     },
 }, async ({ mode, presetPath }) => {
     const check = await requireBridge();
     if (check !== true)
         return check;
     if (mode === "fix") {
-        const result = await bridge.send("fixPresetSamplePaths", presetPath ?? "");
+        const result = await bridge.send("fixPresetSamplePaths", presetPath ? nativePresetPath(presetPath) : "");
         return json(result);
     }
-    await bridge.send("rescanMissingSamples", presetPath ?? "");
-    return text(`Re-audited ${presetPath || "active preset"} for missing samples (results dispatched to UI state).`);
+    const missing = await bridge.send("rescanMissingSamples", "");
+    if (!Array.isArray(missing))
+        return text("Re-audited the active preset; this build reports the result only in its UI.");
+    return json({ missing, note: missing.length ? undefined : "The active preset has no missing samples." });
 });
 server.registerTool("preview_sample", {
     title: "Preview Sample",
@@ -8874,16 +10486,16 @@ server.registerTool("remove_plugin_from_blocklist", {
 // TOOL — ask_assistant (drive the FunctionGemma assistant end-to-end)
 // ============================================================
 // The in-server twin of the ASK bar: renders the SAME FunctionGemma prompt
-// (shared fgemma-format module + live [ctx] line), generates against a local
+// (shared functiongemma-format module + live [ctx] line), generates against a local
 // OpenAI-compatible endpoint (llama-server serving the fine-tune), parses the
 // call blocks, and executes them through this server's own handlers. Lets an
 // MCP client (Claude Code) test the assistant model directly against a live
 // PAM. Stateless per call — thread follow-ups by passing back `modelTurn`
 // from the previous trace as `history`.
 //
-// Dev-tree only: registered only when the fgemma toolpack resolves (the
+// Dev-tree only: registered only when the FunctionGemma toolpack resolves (the
 // published npm package doesn't carry it — the tool would be dead weight).
-const ASSISTANT_TOOLPACK_PATH = resolve(PACKAGE_ROOT, "../fgemma-poc/out/toolpack.json");
+const ASSISTANT_TOOLPACK_PATH = resolve(PACKAGE_ROOT, "../ml-research/out/toolpack.json");
 // The assistant's view vocabulary → MainViewTypes (stores/Interface.ts).
 // Pinned to the in-plugin executor's VIEW_MAP (assistantExecutor.ts) — one
 // vocabulary across tool arg, [ctx] view= field, and this dev twin. null =
@@ -8908,6 +10520,9 @@ const SET_VIEW_MAIN_VIEW = {
     export: "Export",
     presets: "PresetBrowser",
     browser: "PresetBrowser",
+    // The preset browser's pack Store tab, PAM only.
+    store: "PresetBrowser",
+    packs: "PresetBrowser",
     // MFX-only surfaces. The handler rejects them for other products.
     patch: "MfxRouting",
     patchbay: "MfxRouting",
@@ -8931,11 +10546,19 @@ if (existsSync(ASSISTANT_TOOLPACK_PATH))
                 .union([z.string(), z.number()])
                 .optional()
                 .describe("Main view: cells, mixer, ctrl, looper, song, lfo, envelope, vary, paramseq, video, export, presets. " +
-                "MFX also takes patch (the cable patchbay)."),
+                "PAM also takes store (the preset browser's pack Store tab); MFX also takes patch (the cable patchbay)."),
             cellId: z.number().int().optional().describe("Cell to select/focus (1-8)."),
             gridSize: z.number().optional().describe("How many pads the grid shows: 1, 4, or 8."),
+            panel: z
+                .enum(["sampler", "synth", "pattern", "effects"])
+                .optional()
+                .describe("Cell grid tab to show, on cellId or else every cell: sampler, synth, pattern, effects."),
+            fullscreen: z
+                .enum(["sequencer", "effects", "players", "none"])
+                .optional()
+                .describe("CTRL page rack to show alone (sequencer, effects, players), or none."),
         },
-    }, async ({ view: viewArg, cellId, gridSize }) => {
+    }, async ({ view: viewArg, cellId, gridSize, panel, fullscreen }) => {
         const check = await requireBridgeForCells(cellId);
         if (check !== true)
             return check;
@@ -8953,11 +10576,13 @@ if (existsSync(ASSISTANT_TOOLPACK_PATH))
             token = view.trim().toLowerCase();
             if (!(token in SET_VIEW_MAIN_VIEW))
                 return error(`Unknown view: ${view}. Views: cells, mixer, ctrl, looper, song, lfo, envelope, vary, paramseq, video, export, presets, patch.`);
-            if (token === "patch" || token === "patchbay") {
-                const manifest = await loadManifestForProductGuard();
-                if (manifest && !isMfxManifest(manifest))
-                    return error(`${token} is available in MFX only.`);
-            }
+            const product = token === "patch" || token === "patchbay" || token === "store" || token === "packs"
+                ? await connectedProduct()
+                : undefined;
+            if ((token === "patch" || token === "patchbay") && product && product !== "MFX")
+                return error(`${token} is available in MFX only.`);
+            if ((token === "store" || token === "packs") && (product === "MFX" || product === "MSQ"))
+                return error(`${token} is available in PAM only.`);
             applied.view = token;
         }
         if (gridSize !== undefined) {
@@ -8970,13 +10595,19 @@ if (existsSync(ASSISTANT_TOOLPACK_PATH))
                 return error("cellId must be 1-8.");
             applied.cellId = cellId;
         }
+        if (panel !== undefined)
+            applied.panel = panel;
+        if (fullscreen !== undefined)
+            applied.fullscreen = fullscreen;
         if (!Object.keys(applied).length)
-            return error("Provide view, cellId, and/or gridSize.");
+            return error("Provide view, cellId, gridSize, panel and/or fullscreen.");
         try {
             await bridge.send("setView", {
                 ...(token !== undefined ? { view: token } : {}),
                 ...(cellId !== undefined ? { cellId } : {}),
                 ...(gridSize !== undefined ? { gridSize } : {}),
+                ...(panel !== undefined ? { panel } : {}),
+                ...(fullscreen !== undefined ? { fullscreen } : {}),
             });
             return json(applied);
         }
@@ -9001,6 +10632,8 @@ if (existsSync(ASSISTANT_TOOLPACK_PATH))
                 return error(`set_view failed: ${e2.message}`);
             }
             delete applied.cellId; // not applied on the fallback path — don't over-claim
+            delete applied.panel;
+            delete applied.fullscreen;
             return json(applied);
         }
     });
@@ -9011,7 +10644,8 @@ if (existsSync(ASSISTANT_TOOLPACK_PATH))
             "FunctionGemma prompt (with the live [ctx] state line), generate via a local llama-server, " +
             "parse the tool calls, execute them against PAM, and return the full trace. Requires " +
             "llama-server running with the fine-tuned GGUF (--special). For multi-turn tests, pass the " +
-            "previous trace's modelTurn back via history.",
+            "previous trace's modelTurn back via history. The prompt keeps the v34 [ctx] line and has no " +
+            "[params] line, so for toolpack 36+ models it differs from the plugin's prompt.",
         inputSchema: {
             text: z.string().describe("The user command, e.g. 'mute the kick' or '174 bpm dnb kit'."),
             endpoint: z
@@ -9147,16 +10781,23 @@ if (existsSync(ASSISTANT_TOOLPACK_PATH))
                     result: result.text.length > 400 ? `${result.text.slice(0, 400)}…` : result.text,
                     isError: result.isError,
                 });
+                // Same wrapping as the in-plugin executor's toResponsePayload, so a
+                // trace here shows the exact function responses the model sees there.
                 let payload;
                 if (result.isError)
                     payload = { error: result.text.slice(0, 400) };
                 else {
                     try {
                         const parsed = JSON.parse(result.text);
-                        payload =
-                            parsed && typeof parsed === "object" && !Array.isArray(parsed) && result.text.length <= 400
-                                ? parsed
-                                : { result: result.text.slice(0, 400) };
+                        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                            const obj = parsed;
+                            if (obj.ok === true)
+                                delete obj.ok;
+                            payload = result.text.length <= 400 ? obj : { result: result.text.slice(0, 400) };
+                        }
+                        else {
+                            payload = { result: parsed };
+                        }
                     }
                     catch {
                         payload = { result: result.text.slice(0, 400) };
@@ -9245,6 +10886,7 @@ const shutdown = async () => {
         return;
     shuttingDown = true;
     bridge.disconnect();
+    await daemon?.close();
     try {
         await server.close();
     }