Sprint 7: wire param callbacks in loadInProcessPlugin, clear in unloadInProcessPlugin

When SAFE plugin loaded: searchParamCallback, getParamsCallback, setParamsCallback
route directly to inProcessPlugin. When unloaded: cleared to nullptr (falls back to Helper).
Pro-Q 4 GUI now updates instantly when AI sets parameters via MCP.

Source/Plugin/PluginBridgeProcessor.cpp

@@ -10,6 +10,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <chrono>
+#include <algorithm>
 
 extern char** environ;
 
@@ -58,13 +59,11 @@ PluginBridgeProcessor::PluginBridgeProcessor()
         });
     };
 
-    // Wire callbacks for MCP tools
     mcpServer->getAnalysisCallback = [this]() { return analyser.getCompactAnalysis(); };
     mcpServer->channelNameCallback = [this]() { return channelName.toStdString(); };
 
     mcpServer->start();
 
-    // Register this instance in the shared registry
     InstanceRegistry::registerInstance(channelName.toStdString(), mcpServer->getPort());
     PBLOG("Processor", "MCP server on port " + juce::String(mcpServer->getPort())
           + " — channel: " + channelName);
@@ -76,36 +75,26 @@ PluginBridgeProcessor::~PluginBridgeProcessor()
 {
     PBLOG("Processor", "Destructor — tearing down");
     stopBackgroundScan();
-
-    // Unregister from shared registry
     InstanceRegistry::unregisterInstance(channelName.toStdString());
-
     mcpServer->stop();
     unloadInProcessPlugin();
     helper.killHelper();
     PBLOG("Processor", "Destructor — done");
 }
 
-// ── Channel Name ──────────────────────────────────────────────────────────────
-
 void PluginBridgeProcessor::setChannelName(const juce::String& name)
 {
     if (name == channelName) return;
-
-    // Unregister old name, update, register new
     InstanceRegistry::unregisterInstance(channelName.toStdString());
     channelName = name;
     InstanceRegistry::registerInstance(channelName.toStdString(), mcpServer->getPort());
     PBLOG("Processor", "Channel renamed to: " + channelName);
 }
 
-// ── Audio ─────────────────────────────────────────────────────────────────────
-
 void PluginBridgeProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
 {
     currentSampleRate = sampleRate;
     currentBlockSize = samplesPerBlock;
-
     analyser.prepareToPlay(sampleRate, samplesPerBlock);
 
     if (inProcessPlugin)
@@ -116,19 +105,10 @@ void PluginBridgeProcessor::prepareToPlay(double sampleRate, int samplesPerBlock
 
     if (helper.isHelperRunning())
     {
-        json cmd = {{"cmd", "configure"},
-                    {"sampleRate", sampleRate},
-                    {"blockSize", samplesPerBlock},
-                    {"channels", 2}};
+        json cmd = {{"cmd","configure"},{"sampleRate",sampleRate},{"blockSize",samplesPerBlock},{"channels",2}};
         helper.sendCommand(cmd.dump());
-
         auto* header = helper.getSharedAudio().getHeader();
-        if (header)
-        {
-            header->sampleRate.store((uint32_t)sampleRate);
-            header->blockSize.store((uint32_t)samplesPerBlock);
-            header->numChannels.store(2);
-        }
+        if (header) { header->sampleRate.store((uint32_t)sampleRate); header->blockSize.store((uint32_t)samplesPerBlock); header->numChannels.store(2); }
     }
 }
 
@@ -137,10 +117,8 @@ void PluginBridgeProcessor::releaseResources() {}
 void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages)
 {
     juce::ScopedNoDenormals noDenormals;
-
     for (auto i = getTotalNumInputChannels(); i < getTotalNumOutputChannels(); ++i)
         buffer.clear(i, 0, buffer.getNumSamples());
-
     if (!pluginLoaded) return;
 
     if (inProcessPlugin != nullptr)
@@ -151,42 +129,24 @@ void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce:
     }
 
     if (!helper.isHelperRunning()) return;
-
     auto& shm = helper.getSharedAudio();
     if (!shm.isValid()) return;
-
-    int numChannels = buffer.getNumChannels();
-    int numSamples  = buffer.getNumSamples();
-
-    const float* inputPtrs[2] = {
-        buffer.getReadPointer(0),
-        numChannels > 1 ? buffer.getReadPointer(1) : buffer.getReadPointer(0)
-    };
+    int numChannels = buffer.getNumChannels(), numSamples = buffer.getNumSamples();
+    const float* inputPtrs[2] = { buffer.getReadPointer(0), numChannels > 1 ? buffer.getReadPointer(1) : buffer.getReadPointer(0) };
     shm.writeInput(inputPtrs, numChannels, numSamples);
-
     auto* header = shm.getHeader();
-    header->blockSize.store((uint32_t)numSamples);
-    header->numChannels.store((uint32_t)numChannels);
-    header->state.store(kStateInputReady);
-
+    header->blockSize.store((uint32_t)numSamples); header->numChannels.store((uint32_t)numChannels); header->state.store(kStateInputReady);
     helper.getInputSem().signal();
-
     if (helper.getOutputSem().wait(IPC::kProcessBlockTimeoutMs))
     {
-        float* outputPtrs[2] = {
-            buffer.getWritePointer(0),
-            numChannels > 1 ? buffer.getWritePointer(1) : buffer.getWritePointer(0)
-        };
+        float* outputPtrs[2] = { buffer.getWritePointer(0), numChannels > 1 ? buffer.getWritePointer(1) : buffer.getWritePointer(0) };
         shm.readOutput(outputPtrs, numChannels, numSamples);
         header->state.store(kStateIdle);
         analyser.processBlock(buffer);
     }
 }
 
-juce::AudioProcessorEditor* PluginBridgeProcessor::createEditor()
-{
-    return new PluginBridgeEditor(*this);
-}
+juce::AudioProcessorEditor* PluginBridgeProcessor::createEditor() { return new PluginBridgeEditor(*this); }
 
 // ── In-process plugin ─────────────────────────────────────────────────────────
 
@@ -203,19 +163,16 @@ void PluginBridgeProcessor::loadInProcessPlugin(const juce::String& path)
     {
         auto* format = inProcessFormatManager.getFormat(i);
         bool isVST3 = pluginFile.getFileExtension() == ".vst3";
-        bool isAU   = pluginFile.getFileExtension() == ".component";
+        bool isAU = pluginFile.getFileExtension() == ".component";
         if (isVST3 && format->getName() != "VST3") continue;
         if (isAU && format->getName() != "AudioUnit") continue;
         format->findAllTypesForFile(typesFound, pluginFile.getFullPathName());
         if (typesFound.size() > 0) break;
     }
-
     if (typesFound.isEmpty()) { PBLOG("Processor", "loadInProcessPlugin: no types found"); return; }
 
     juce::String err;
-    inProcessPlugin = inProcessFormatManager.createPluginInstance(
-        *typesFound[0], currentSampleRate, currentBlockSize, err);
-
+    inProcessPlugin = inProcessFormatManager.createPluginInstance(*typesFound[0], currentSampleRate, currentBlockSize, err);
     if (!inProcessPlugin) { PBLOG("Processor", "loadInProcessPlugin: FAILED — " + err); return; }
 
     inProcessPlugin->enableAllBuses();
@@ -224,31 +181,74 @@ void PluginBridgeProcessor::loadInProcessPlugin(const juce::String& path)
     layout.outputBuses.add(juce::AudioChannelSet::stereo());
     if (inProcessPlugin->checkBusesLayoutSupported(layout))
         inProcessPlugin->setBusesLayout(layout);
-
     if (currentSampleRate > 0 && currentBlockSize > 0)
         inProcessPlugin->prepareToPlay(currentSampleRate, currentBlockSize);
 
+    // Sync state from Helper
     auto response = helper.sendCommand("{\"cmd\":\"get_state\"}");
-    try {
-        auto j = json::parse(response);
-        if (j.value("ok", false))
+    try { auto j = json::parse(response); if (j.value("ok",false)) {
+        auto stateB64 = juce::String(j["state"].get<std::string>());
+        if (stateB64.isNotEmpty()) { juce::MemoryBlock d; if (d.fromBase64Encoding(stateB64))
+            inProcessPlugin->setStateInformation(d.getData(), (int)d.getSize()); }
+    }} catch (...) {}
+
+    inProcessPlugin->addListener(this);
+
+    // ── Wire MCP param callbacks to in-process plugin ─────────────────────────
+    mcpServer->searchParamCallback = [this](const std::string& keyword) -> std::string {
+        if (!inProcessPlugin) return "[]";
+        auto& params = inProcessPlugin->getParameters();
+        json results = json::array();
+        std::string kw = keyword;
+        std::transform(kw.begin(), kw.end(), kw.begin(), ::tolower);
+        for (int i = 0; i < params.size(); ++i)
         {
-            auto stateB64 = juce::String(j["state"].get<std::string>());
-            if (stateB64.isNotEmpty())
+            std::string name = params[i]->getName(128).toStdString();
+            std::string nameLow = name;
+            std::transform(nameLow.begin(), nameLow.end(), nameLow.begin(), ::tolower);
+            if (kw.empty() || nameLow.find(kw) != std::string::npos)
             {
-                juce::MemoryBlock stateData;
-                if (stateData.fromBase64Encoding(stateB64))
-                    inProcessPlugin->setStateInformation(stateData.getData(), (int)stateData.getSize());
+                results.push_back({{"i", i}, {"name", name},
+                    {"value", std::round(params[i]->getValue() * 1000.0f) / 1000.0f},
+                    {"display", params[i]->getText(params[i]->getValue(), 64).toStdString()}});
+                if (results.size() >= 50) break;
             }
         }
-    } catch (...) {}
+        return results.dump();
+    };
 
-    inProcessPlugin->addListener(this);
-    PBLOG("Processor", "loadInProcessPlugin: SUCCESS — \"" + inProcessPlugin->getName() + "\"");
+    mcpServer->getParamsCallback = [this](const std::vector<int>& ids) -> std::string {
+        if (!inProcessPlugin) return "{}";
+        auto& params = inProcessPlugin->getParameters();
+        json values = json::object();
+        for (int idx : ids)
+            if (idx >= 0 && idx < params.size())
+                values[std::to_string(idx)] = std::round(params[idx]->getValue() * 1000.0f) / 1000.0f;
+        return values.dump();
+    };
+
+    mcpServer->setParamsCallback = [this](const std::map<int,float>& values) -> bool {
+        if (!inProcessPlugin) return false;
+        juce::MessageManager::callAsync([this, values]() {
+            if (!inProcessPlugin) return;
+            auto& p = inProcessPlugin->getParameters();
+            for (auto& [idx, val] : values)
+                if (idx >= 0 && idx < p.size())
+                    p[idx]->setValueNotifyingHost(juce::jlimit(0.0f, 1.0f, val));
+        });
+        return true;
+    };
+
+    PBLOG("Processor", "loadInProcessPlugin: SUCCESS — \"" + inProcessPlugin->getName() + "\" + MCP param callbacks wired");
 }
 
 void PluginBridgeProcessor::unloadInProcessPlugin()
 {
+    // Clear MCP param callbacks BEFORE destroying plugin
+    mcpServer->searchParamCallback = nullptr;
+    mcpServer->getParamsCallback = nullptr;
+    mcpServer->setParamsCallback = nullptr;
+
     if (inProcessPlugin)
     {
         PBLOG("Processor", "unloadInProcessPlugin: " + inProcessPlugin->getName());
@@ -271,26 +271,17 @@ void PluginBridgeProcessor::audioProcessorParameterChanged(juce::AudioProcessor*
 void PluginBridgeProcessor::loadPlugin(const juce::String& path)
 {
     PBLOG("Processor", "loadPlugin: " + juce::File(path).getFileName());
-
-    if (blocklist.isBlocked(path))
-    {
-        if (onLoadFailed) onLoadFailed("Not compatible (crashed previously)");
-        return;
-    }
+    if (blocklist.isBlocked(path)) { if (onLoadFailed) onLoadFailed("Not compatible (crashed previously)"); return; }
 
     auto safety = safetyDB.getSafety(path);
-    PBLOG("Processor", "loadPlugin: safety = " + juce::String(
-        safety == PluginSafetyDB::Safety::Safe ? "SAFE" :
-        safety == PluginSafetyDB::Safety::Unsafe ? "UNSAFE" : "UNKNOWN"));
+    PBLOG("Processor", "loadPlugin: safety = " + juce::String(safety == PluginSafetyDB::Safety::Safe ? "SAFE" : safety == PluginSafetyDB::Safety::Unsafe ? "UNSAFE" : "UNKNOWN"));
 
     if (safety == PluginSafetyDB::Safety::Unknown)
     {
         if (onLoadFailed) onLoadFailed("Scanning plugin...");
-        std::thread([this, path]()
-        {
+        std::thread([this, path]() {
             bool safe = runPluginScan(path);
-            safetyDB.setSafety(path, safe ? PluginSafetyDB::Safety::Safe
-                                          : PluginSafetyDB::Safety::Unsafe);
+            safetyDB.setSafety(path, safe ? PluginSafetyDB::Safety::Safe : PluginSafetyDB::Safety::Unsafe);
             juce::MessageManager::callAsync([this, path]() { loadPlugin(path); });
         }).detach();
         return;
@@ -298,60 +289,33 @@ void PluginBridgeProcessor::loadPlugin(const juce::String& path)
 
     if (onPluginWillLoad) onPluginWillLoad();
 
-    if (!helper.isHelperRunning())
-    {
-        if (!helper.spawnHelper())
-        {
-            if (onLoadFailed) onLoadFailed("Failed to start helper process");
-            return;
-        }
-        json configCmd = {{"cmd","configure"},{"sampleRate",currentSampleRate},
-                          {"blockSize",currentBlockSize},{"channels",2}};
-        helper.sendCommand(configCmd.dump());
+    if (!helper.isHelperRunning()) {
+        if (!helper.spawnHelper()) { if (onLoadFailed) onLoadFailed("Failed to start helper"); return; }
+        json cfg = {{"cmd","configure"},{"sampleRate",currentSampleRate},{"blockSize",currentBlockSize},{"channels",2}};
+        helper.sendCommand(cfg.dump());
     }
 
-    json loadCmd = {{"cmd","load"},{"path",path.toStdString()},
-                    {"sampleRate",currentSampleRate},{"blockSize",currentBlockSize}};
+    json loadCmd = {{"cmd","load"},{"path",path.toStdString()},{"sampleRate",currentSampleRate},{"blockSize",currentBlockSize}};
     auto response = helper.sendCommand(loadCmd.dump());
 
-    try
-    {
+    try {
         auto j = json::parse(response);
-        if (j.value("ok", false))
-        {
+        if (j.value("ok",false)) {
             pluginLoaded = true;
             pluginName = juce::String(j["name"].get<std::string>());
-            pluginParamCount = j.value("params", 0);
+            pluginParamCount = j.value("params",0);
             pluginPath = path;
             PBLOG("Processor", "loadPlugin: loaded \"" + pluginName + "\"");
-
             if (safety == PluginSafetyDB::Safety::Safe)
-            {
-                juce::MessageManager::callAsync([this, path]()
-                {
-                    loadInProcessPlugin(path);
-                    if (onPluginLoaded) onPluginLoaded();
-                });
-            }
+                juce::MessageManager::callAsync([this, path]() { loadInProcessPlugin(path); if (onPluginLoaded) onPluginLoaded(); });
             else
-            {
-                juce::MessageManager::callAsync([this]()
-                { if (onPluginLoaded) onPluginLoaded(); });
-            }
-        }
-        else
-        {
-            pluginLoaded = false;
-            pluginPath.clear();
-            blocklist.addBlocked(path);
+                juce::MessageManager::callAsync([this]() { if (onPluginLoaded) onPluginLoaded(); });
+        } else {
+            pluginLoaded = false; pluginPath.clear(); blocklist.addBlocked(path);
             if (onLoadFailed) onLoadFailed("Not compatible: " + juce::String(j.value("error","unknown")));
         }
-    }
-    catch (...)
-    {
-        pluginLoaded = false;
-        pluginPath.clear();
-        blocklist.addBlocked(path);
+    } catch (...) {
+        pluginLoaded = false; pluginPath.clear(); blocklist.addBlocked(path);
         if (onLoadFailed) onLoadFailed("Helper communication error");
     }
 }
@@ -360,143 +324,76 @@ void PluginBridgeProcessor::unloadPlugin()
 {
     PBLOG("Processor", "unloadPlugin: \"" + pluginName + "\"");
     if (helper.isHelperRunning()) helper.sendCommand("{\"cmd\":\"unload\"}");
-    pluginLoaded = false;
-    pluginName.clear();
-    pluginPath.clear();
-    pluginParamCount = 0;
+    pluginLoaded = false; pluginName.clear(); pluginPath.clear(); pluginParamCount = 0;
     unloadInProcessPlugin();
-    if (onPluginUnloaded)
-        juce::MessageManager::callAsync([this]() { if (onPluginUnloaded) onPluginUnloaded(); });
+    if (onPluginUnloaded) juce::MessageManager::callAsync([this]() { if (onPluginUnloaded) onPluginUnloaded(); });
 }
 
 // ── Scanner ───────────────────────────────────────────────────────────────────
 
-static juce::String signalName(int sig)
-{
-    switch (sig) {
-        case SIGSEGV: return "SIGSEGV"; case SIGABRT: return "SIGABRT";
-        case SIGBUS: return "SIGBUS"; case SIGILL: return "SIGILL";
-        case SIGFPE: return "SIGFPE"; case SIGKILL: return "SIGKILL";
-        default: return "signal " + juce::String(sig);
-    }
+static juce::String signalName(int sig) {
+    switch (sig) { case SIGSEGV: return "SIGSEGV"; case SIGABRT: return "SIGABRT"; case SIGBUS: return "SIGBUS"; case SIGILL: return "SIGILL"; case SIGFPE: return "SIGFPE"; case SIGKILL: return "SIGKILL"; default: return "signal " + juce::String(sig); }
 }
 
-static void writeScanLog(const juce::String& pluginPath, bool safe,
-                         const juce::String& reason, const juce::String& captured)
-{
-    auto logFile = juce::File::getSpecialLocation(juce::File::userApplicationDataDirectory)
-                       .getChildFile("PluginBridge").getChildFile("scan.log");
+static void writeScanLog(const juce::String& pluginPath, bool safe, const juce::String& reason, const juce::String& captured) {
+    auto logFile = juce::File::getSpecialLocation(juce::File::userApplicationDataDirectory).getChildFile("PluginBridge").getChildFile("scan.log");
     logFile.getParentDirectory().createDirectory();
     auto ts = juce::Time::getCurrentTime().formatted("%Y-%m-%d %H:%M:%S");
-    juce::String entry;
-    entry << "───\n" << ts << "  " << juce::File(pluginPath).getFileName()
-          << "\nResult: " << (safe ? "SAFE" : "UNSAFE");
+    juce::String entry; entry << "───\n" << ts << "  " << juce::File(pluginPath).getFileName() << "\nResult: " << (safe ? "SAFE" : "UNSAFE");
     if (!reason.isEmpty()) entry << " (" << reason << ")";
     if (captured.isNotEmpty()) entry << "\nOutput: " << captured.substring(0, 500);
-    entry << "\n\n";
-    logFile.appendText(entry);
+    entry << "\n\n"; logFile.appendText(entry);
 }
 
-bool PluginBridgeProcessor::runPluginScan(const juce::String& path)
-{
-    auto helperApp = juce::File::getSpecialLocation(juce::File::currentExecutableFile)
-                         .getParentDirectory().getParentDirectory()
-                         .getChildFile("Resources").getChildFile("PluginBridgeHelper.app")
-                         .getChildFile("Contents").getChildFile("MacOS")
-                         .getChildFile(PluginBridgeConstants::kHelperBinaryName);
-    if (!helperApp.exists())
-        helperApp = juce::File::getSpecialLocation(juce::File::currentExecutableFile)
-                        .getParentDirectory().getParentDirectory()
-                        .getChildFile("Resources").getChildFile(PluginBridgeConstants::kHelperBinaryName);
+bool PluginBridgeProcessor::runPluginScan(const juce::String& path) {
+    auto helperApp = juce::File::getSpecialLocation(juce::File::currentExecutableFile).getParentDirectory().getParentDirectory().getChildFile("Resources").getChildFile("PluginBridgeHelper.app").getChildFile("Contents").getChildFile("MacOS").getChildFile(PluginBridgeConstants::kHelperBinaryName);
+    if (!helperApp.exists()) helperApp = juce::File::getSpecialLocation(juce::File::currentExecutableFile).getParentDirectory().getParentDirectory().getChildFile("Resources").getChildFile(PluginBridgeConstants::kHelperBinaryName);
     if (!helperApp.exists()) { writeScanLog(path, false, "Helper not found", {}); return false; }
-
-    int pipeFd[2];
-    if (pipe(pipeFd) != 0) return false;
-    fcntl(pipeFd[0], F_SETFL, O_NONBLOCK);
-
-    auto hStr = helperApp.getFullPathName().toStdString();
-    auto pStr = path.toStdString();
-    posix_spawn_file_actions_t actions;
-    posix_spawn_file_actions_init(&actions);
-    posix_spawn_file_actions_adddup2(&actions, pipeFd[1], STDERR_FILENO);
-    posix_spawn_file_actions_addclose(&actions, pipeFd[0]);
-
-    pid_t pid;
-    char* argv[] = { (char*)hStr.c_str(), (char*)"--scan", (char*)pStr.c_str(), nullptr };
+    int pipeFd[2]; if (pipe(pipeFd) != 0) return false; fcntl(pipeFd[0], F_SETFL, O_NONBLOCK);
+    auto hStr = helperApp.getFullPathName().toStdString(); auto pStr = path.toStdString();
+    posix_spawn_file_actions_t actions; posix_spawn_file_actions_init(&actions);
+    posix_spawn_file_actions_adddup2(&actions, pipeFd[1], STDERR_FILENO); posix_spawn_file_actions_addclose(&actions, pipeFd[0]);
+    pid_t pid; char* argv[] = { (char*)hStr.c_str(), (char*)"--scan", (char*)pStr.c_str(), nullptr };
     int sr = posix_spawn(&pid, hStr.c_str(), &actions, nullptr, argv, environ);
-    posix_spawn_file_actions_destroy(&actions);
-    close(pipeFd[1]);
+    posix_spawn_file_actions_destroy(&actions); close(pipeFd[1]);
     if (sr != 0) { close(pipeFd[0]); return false; }
-
     bool timedOut = true; int status = 0;
     auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(10);
-    while (std::chrono::steady_clock::now() < deadline) {
-        if (waitpid(pid, &status, WNOHANG) == pid) { timedOut = false; break; }
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
+    while (std::chrono::steady_clock::now() < deadline) { if (waitpid(pid, &status, WNOHANG) == pid) { timedOut = false; break; } std::this_thread::sleep_for(std::chrono::milliseconds(100)); }
     if (timedOut) { kill(pid, SIGKILL); waitpid(pid, &status, 0); }
-
-    juce::String captured;
-    { char buf[4096]; ssize_t n;
-      while ((n = read(pipeFd[0], buf, sizeof(buf)-1)) > 0) { buf[n]=0; captured += buf; } }
-    close(pipeFd[0]);
-
+    juce::String captured; { char buf[4096]; ssize_t n; while ((n = read(pipeFd[0], buf, sizeof(buf)-1)) > 0) { buf[n]=0; captured += buf; } } close(pipeFd[0]);
     bool safe = !timedOut && WIFEXITED(status) && WEXITSTATUS(status) == 0;
-    juce::String reason = timedOut ? "Timeout" :
-        WIFSIGNALED(status) ? signalName(WTERMSIG(status)) :
-        (!safe ? "Exit " + juce::String(WEXITSTATUS(status)) : "");
-    writeScanLog(path, safe, reason, captured);
-    return safe;
+    juce::String reason = timedOut ? "Timeout" : WIFSIGNALED(status) ? signalName(WTERMSIG(status)) : (!safe ? "Exit " + juce::String(WEXITSTATUS(status)) : "");
+    writeScanLog(path, safe, reason, captured); return safe;
 }
 
-void PluginBridgeProcessor::startBackgroundScan()
-{
-    if (scanRunning.load()) return;
-    scanRunning.store(true);
+void PluginBridgeProcessor::startBackgroundScan() {
+    if (scanRunning.load()) return; scanRunning.store(true);
     scanThread = std::thread([this]() {
         auto files = getInstalledPluginFiles();
         for (int i = 0; i < files.size() && scanRunning.load(); ++i) {
             auto path = files[i].getFullPathName();
             if (safetyDB.getSafety(path) != PluginSafetyDB::Safety::Unknown) continue;
-            while (helper.isHelperRunning() && scanRunning.load())
-                std::this_thread::sleep_for(std::chrono::milliseconds(500));
+            while (helper.isHelperRunning() && scanRunning.load()) std::this_thread::sleep_for(std::chrono::milliseconds(500));
             if (!scanRunning.load()) break;
             bool safe = runPluginScan(path);
             safetyDB.setSafety(path, safe ? PluginSafetyDB::Safety::Safe : PluginSafetyDB::Safety::Unsafe);
-            if (onScanProgress)
-                juce::MessageManager::callAsync([this, path, safe]()
-                    { if (onScanProgress) onScanProgress(path, safe); });
+            if (onScanProgress) juce::MessageManager::callAsync([this, path, safe]() { if (onScanProgress) onScanProgress(path, safe); });
         }
         scanRunning.store(false);
     });
 }
 
-void PluginBridgeProcessor::stopBackgroundScan()
-{
-    scanRunning.store(false);
-    if (scanThread.joinable()) scanThread.join();
-}
+void PluginBridgeProcessor::stopBackgroundScan() { scanRunning.store(false); if (scanThread.joinable()) scanThread.join(); }
 
 // ── Plugin List ───────────────────────────────────────────────────────────────
 
-juce::Array<juce::File> PluginBridgeProcessor::getInstalledPluginFiles() const
-{
-    juce::Array<juce::File> results;
-    std::set<std::string> seen;
+juce::Array<juce::File> PluginBridgeProcessor::getInstalledPluginFiles() const {
+    juce::Array<juce::File> results; std::set<std::string> seen;
     struct D { juce::File dir; const char* pat; };
-    std::vector<D> specs = {
-        { juce::File("/Library/Audio/Plug-Ins/VST3"), "*.vst3" },
-        { juce::File::getSpecialLocation(juce::File::userHomeDirectory).getChildFile("Library/Audio/Plug-Ins/VST3"), "*.vst3" },
-        { juce::File("/Library/Audio/Plug-Ins/Components"), "*.component" },
-        { juce::File::getSpecialLocation(juce::File::userHomeDirectory).getChildFile("Library/Audio/Plug-Ins/Components"), "*.component" }
-    };
-    for (auto& s : specs) {
-        if (!s.dir.isDirectory()) continue;
-        for (auto& f : s.dir.findChildFiles(juce::File::findDirectories, false, s.pat))
-            if (seen.insert(f.getFileNameWithoutExtension().toStdString()).second) results.add(f);
-    }
-    results.sort();
-    return results;
+    std::vector<D> specs = { { juce::File("/Library/Audio/Plug-Ins/VST3"), "*.vst3" }, { juce::File::getSpecialLocation(juce::File::userHomeDirectory).getChildFile("Library/Audio/Plug-Ins/VST3"), "*.vst3" }, { juce::File("/Library/Audio/Plug-Ins/Components"), "*.component" }, { juce::File::getSpecialLocation(juce::File::userHomeDirectory).getChildFile("Library/Audio/Plug-Ins/Components"), "*.component" } };
+    for (auto& s : specs) { if (!s.dir.isDirectory()) continue; for (auto& f : s.dir.findChildFiles(juce::File::findDirectories, false, s.pat)) if (seen.insert(f.getFileNameWithoutExtension().toStdString()).second) results.add(f); }
+    results.sort(); return results;
 }
 
 bool PluginBridgeProcessor::isBlocked(const juce::String& path) const { return blocklist.isBlocked(path); }
@@ -505,98 +402,46 @@ bool PluginBridgeProcessor::isBlocked(const juce::String& path) const { return b
 
 static juce::String cleanManufacturer(const juce::String& raw) {
     auto s = raw.trim(); if (s.isEmpty() || s.containsOnly("0123456789.")) return {};
-    if (s.toLowerCase().startsWith("copyright")) {
-        auto r = s.substring(9).trim();
-        if (r.startsWithIgnoreCase("(c)")) r = r.substring(3).trim();
-        else if (r.startsWith(juce::String::fromUTF8("\xc2\xa9")))
-            r = r.substring(juce::String::fromUTF8("\xc2\xa9").length()).trim();
-        auto sp = r.indexOfChar(' '); if (sp > 0) r = r.substring(sp+1).trim();
-        return r.isNotEmpty() ? r : juce::String();
-    }
+    if (s.toLowerCase().startsWith("copyright")) { auto r = s.substring(9).trim(); if (r.startsWithIgnoreCase("(c)")) r = r.substring(3).trim(); else if (r.startsWith(juce::String::fromUTF8("\xc2\xa9"))) r = r.substring(juce::String::fromUTF8("\xc2\xa9").length()).trim(); auto sp = r.indexOfChar(' '); if (sp > 0) r = r.substring(sp+1).trim(); return r.isNotEmpty() ? r : juce::String(); }
     return s;
 }
-
-static juce::String plistValue(const juce::String& t, const juce::String& k) {
-    auto p = t.fromFirstOccurrenceOf(k, false, true); if (p.isEmpty()) return {};
-    return p.fromFirstOccurrenceOf("<string>", false, false)
-            .upToFirstOccurrenceOf("</string>", false, false).trim();
-}
+static juce::String plistValue(const juce::String& t, const juce::String& k) { auto p = t.fromFirstOccurrenceOf(k, false, true); if (p.isEmpty()) return {}; return p.fromFirstOccurrenceOf("<string>", false, false).upToFirstOccurrenceOf("</string>", false, false).trim(); }
 
 juce::String PluginBridgeProcessor::getPluginManufacturer(const juce::File& f) const {
     auto pk = f.getFullPathName().toStdString();
-    { std::lock_guard<std::mutex> l(manufacturerCacheMutex);
-      auto it = manufacturerCache.find(pk); if (it != manufacturerCache.end()) return juce::String(it->second); }
+    { std::lock_guard<std::mutex> l(manufacturerCacheMutex); auto it = manufacturerCache.find(pk); if (it != manufacturerCache.end()) return juce::String(it->second); }
     juce::String mfr;
     if (f.getFileExtension().toLowerCase() == ".vst3") {
         auto ip = f.getChildFile("Contents").getChildFile("Info.plist");
-        if (ip.existsAsFile()) {
-            auto t = ip.loadFileAsString();
-            mfr = cleanManufacturer(plistValue(t, "NSHumanReadableCopyright"));
-            if (mfr.isEmpty()) { auto is = plistValue(t, "CFBundleGetInfoString");
-                if (is.contains(",")) { auto bc = is.upToFirstOccurrenceOf(",",false,false).trim();
-                    auto fw = bc.upToFirstOccurrenceOf(" ",false,false).trim();
-                    if (fw.isNotEmpty() && !fw.containsOnly("0123456789.")) mfr = fw; }
-                if (mfr.isEmpty()) mfr = cleanManufacturer(is); }
-            if (mfr.isEmpty()) { auto bid = plistValue(t, "CFBundleIdentifier");
-                auto segs = juce::StringArray::fromTokens(bid,".",""  );
-                if (segs.size()>=2) { auto sl = segs[1].trim();
-                    if (sl.isNotEmpty()&&sl!="apple"&&sl!="com")
-                        mfr = sl.substring(0,1).toUpperCase()+sl.substring(1); } }
-        }
-        if (mfr.isEmpty()) { auto mi = f.getChildFile("Contents").getChildFile("moduleinfo.json");
-            if (mi.existsAsFile()) { try { auto j = json::parse(mi.loadFileAsString().toStdString());
-                mfr = cleanManufacturer(juce::String(j.value("vendor",""))); } catch(...){} } }
+        if (ip.existsAsFile()) { auto t = ip.loadFileAsString(); mfr = cleanManufacturer(plistValue(t, "NSHumanReadableCopyright"));
+            if (mfr.isEmpty()) { auto is = plistValue(t, "CFBundleGetInfoString"); if (is.contains(",")) { auto bc = is.upToFirstOccurrenceOf(",",false,false).trim(); auto fw = bc.upToFirstOccurrenceOf(" ",false,false).trim(); if (fw.isNotEmpty() && !fw.containsOnly("0123456789.")) mfr = fw; } if (mfr.isEmpty()) mfr = cleanManufacturer(is); }
+            if (mfr.isEmpty()) { auto bid = plistValue(t, "CFBundleIdentifier"); auto segs = juce::StringArray::fromTokens(bid,".",""); if (segs.size()>=2) { auto sl = segs[1].trim(); if (sl.isNotEmpty()&&sl!="apple"&&sl!="com") mfr = sl.substring(0,1).toUpperCase()+sl.substring(1); } } }
+        if (mfr.isEmpty()) { auto mi = f.getChildFile("Contents").getChildFile("moduleinfo.json"); if (mi.existsAsFile()) { try { auto j = json::parse(mi.loadFileAsString().toStdString()); mfr = cleanManufacturer(juce::String(j.value("vendor",""))); } catch(...){} } }
     }
-    if (mfr.isEmpty()) { auto n = f.getFileNameWithoutExtension();
-        auto fw = n.upToFirstOccurrenceOf(" ",false,false);
-        mfr = (fw.isNotEmpty()&&!fw.containsOnly("0123456789.")) ? fw : n; }
+    if (mfr.isEmpty()) { auto n = f.getFileNameWithoutExtension(); auto fw = n.upToFirstOccurrenceOf(" ",false,false); mfr = (fw.isNotEmpty()&&!fw.containsOnly("0123456789.")) ? fw : n; }
     if (mfr.isEmpty()) mfr = "Other";
     std::lock_guard<std::mutex> l(manufacturerCacheMutex); manufacturerCache[pk] = mfr.toStdString(); return mfr;
 }
 
 // ── State ─────────────────────────────────────────────────────────────────────
 
-void PluginBridgeProcessor::getStateInformation(juce::MemoryBlock& destData)
-{
-    juce::ValueTree state("PluginBridgeState");
-    state.setProperty("pluginPath", pluginPath, nullptr);
-    state.setProperty("channelName", channelName, nullptr);
-
-    if (pluginLoaded && helper.isHelperRunning()) {
-        auto r = helper.sendCommand("{\"cmd\":\"get_state\"}");
-        try { auto j = json::parse(r); if (j.value("ok",false))
-            state.setProperty("pluginState", juce::String(j["state"].get<std::string>()), nullptr);
-        } catch (...) {}
-    }
-
-    juce::MemoryOutputStream stream(destData, false);
-    state.writeToStream(stream);
+void PluginBridgeProcessor::getStateInformation(juce::MemoryBlock& destData) {
+    juce::ValueTree state("PluginBridgeState"); state.setProperty("pluginPath", pluginPath, nullptr); state.setProperty("channelName", channelName, nullptr);
+    if (pluginLoaded && helper.isHelperRunning()) { auto r = helper.sendCommand("{\"cmd\":\"get_state\"}"); try { auto j = json::parse(r); if (j.value("ok",false)) state.setProperty("pluginState", juce::String(j["state"].get<std::string>()), nullptr); } catch (...) {} }
+    juce::MemoryOutputStream stream(destData, false); state.writeToStream(stream);
 }
 
-void PluginBridgeProcessor::setStateInformation(const void* data, int sizeInBytes)
-{
-    auto state = juce::ValueTree::readFromData(data, (size_t)sizeInBytes);
-    if (!state.isValid()) return;
-
-    // Restore channel name
-    auto savedChannel = state.getProperty("channelName", "Unnamed").toString();
-    setChannelName(savedChannel);
-
-    auto path = state.getProperty("pluginPath").toString();
-    if (path.isEmpty()) return;
-
+void PluginBridgeProcessor::setStateInformation(const void* data, int sizeInBytes) {
+    auto state = juce::ValueTree::readFromData(data, (size_t)sizeInBytes); if (!state.isValid()) return;
+    auto savedChannel = state.getProperty("channelName", "Unnamed").toString(); setChannelName(savedChannel);
+    auto path = state.getProperty("pluginPath").toString(); if (path.isEmpty()) return;
     loadPlugin(path);
-
     auto pluginState = state.getProperty("pluginState").toString();
-    if (pluginState.isNotEmpty() && helper.isHelperRunning()) {
-        json cmd = {{"cmd","set_state"},{"state",pluginState.toStdString()}};
-        helper.sendCommand(cmd.dump());
-    }
+    if (pluginState.isNotEmpty() && helper.isHelperRunning()) { json cmd = {{"cmd","set_state"},{"state",pluginState.toStdString()}}; helper.sendCommand(cmd.dump()); }
 }
 
 // ── MCP ───────────────────────────────────────────────────────────────────────
 
 bool PluginBridgeProcessor::isMcpServerRunning() const { return mcpServer && mcpServer->isRunning(); }
 int  PluginBridgeProcessor::getMcpServerPort()   const { return mcpServer ? mcpServer->getPort() : 0; }
-
 juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter() { return new PluginBridgeProcessor(); }