Sprint 6: wire channelName, registry, and auto-port into Processor.cpp

Changes from v0.5.3:
1. Constructor: McpServer(helper) — no port, auto-assigned
2. After start(): wire channelNameCallback + register to registry
3. Destructor: unregister from registry
4. New method: setChannelName()
5. getStateInformation: save channelName
6. setStateInformation: restore channelName"

Source/Plugin/PluginBridgeProcessor.cpp

@@ -2,6 +2,7 @@
 #include "PluginBridgeEditor.h"
 #include "IPCProtocol.h"
 #include "PBLog.h"
+#include "InstanceRegistry.h"
 
 #include <sys/wait.h>
 #include <spawn.h>
@@ -19,7 +20,7 @@ PluginBridgeProcessor::PluginBridgeProcessor()
     : AudioProcessor(BusesProperties()
                          .withInput("Input", juce::AudioChannelSet::stereo(), true)
                          .withOutput("Output", juce::AudioChannelSet::stereo(), true)),
-      mcpServer(std::make_unique<McpServer>(PluginBridgeConstants::kDefaultMcpPort, helper))
+      mcpServer(std::make_unique<McpServer>(helper))
 {
     PBLog::startSession("Processor");
     PBLOG("Processor", "Constructor — PluginBridgeProcessor created");
@@ -30,18 +31,15 @@ PluginBridgeProcessor::PluginBridgeProcessor()
     helper.onHelperCrashed = [this]()
     {
         PBLOG("Processor", "⚠️  Helper crashed — clearing plugin state");
-
         if (pluginPath.isNotEmpty())
         {
             PBLOG("Processor", "⚠️  Marking \"" + pluginName + "\" as UNSAFE (Helper crash)");
             safetyDB.setSafety(pluginPath, PluginSafetyDB::Safety::Unsafe);
         }
-
         pluginLoaded = false;
         pluginName.clear();
         pluginParamCount = 0;
         unloadInProcessPlugin();
-        DBG("PluginBridgeProcessor: Helper crashed");
     };
 
     helper.onParamChanged = [this](int idx, float val)
@@ -60,9 +58,17 @@ 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);
+
     startBackgroundScan();
 }
 
@@ -70,12 +76,31 @@ 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;
@@ -83,7 +108,6 @@ void PluginBridgeProcessor::prepareToPlay(double sampleRate, int samplesPerBlock
 
     analyser.prepareToPlay(sampleRate, samplesPerBlock);
 
-    // If in-process plugin is already loaded, update its sample rate/block size too
     if (inProcessPlugin)
     {
         inProcessPlugin->releaseResources();
@@ -119,7 +143,6 @@ void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce:
 
     if (!pluginLoaded) return;
 
-    // ── SAFE plugin path: audio goes through in-process instance ──────────────
     if (inProcessPlugin != nullptr)
     {
         inProcessPlugin->processBlock(buffer, midiMessages);
@@ -127,7 +150,6 @@ void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce:
         return;
     }
 
-    // ── UNSAFE plugin path: audio goes through Helper via shared memory ───────
     if (!helper.isHelperRunning()) return;
 
     auto& shm = helper.getSharedAudio();
@@ -166,7 +188,7 @@ juce::AudioProcessorEditor* PluginBridgeProcessor::createEditor()
     return new PluginBridgeEditor(*this);
 }
 
-// ── In-process plugin (now handles BOTH audio + GUI for SAFE plugins) ─────────
+// ── In-process plugin ─────────────────────────────────────────────────────────
 
 void PluginBridgeProcessor::loadInProcessPlugin(const juce::String& path)
 {
@@ -174,11 +196,7 @@ void PluginBridgeProcessor::loadInProcessPlugin(const juce::String& path)
     unloadInProcessPlugin();
 
     juce::File pluginFile(path);
-    if (!pluginFile.exists())
-    {
-        PBLOG("Processor", "loadInProcessPlugin: file not found — abort");
-        return;
-    }
+    if (!pluginFile.exists()) { PBLOG("Processor", "loadInProcessPlugin: file not found"); return; }
 
     juce::OwnedArray<juce::PluginDescription> typesFound;
     for (int i = 0; i < inProcessFormatManager.getNumFormats(); ++i)
@@ -186,31 +204,20 @@ void PluginBridgeProcessor::loadInProcessPlugin(const juce::String& path)
         auto* format = inProcessFormatManager.getFormat(i);
         bool isVST3 = pluginFile.getFileExtension() == ".vst3";
         bool isAU   = pluginFile.getFileExtension() == ".component";
-        if (isVST3 && format->getName() != "VST3")      continue;
-        if (isAU   && format->getName() != "AudioUnit")  continue;
+        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;
-    }
+    if (typesFound.isEmpty()) { PBLOG("Processor", "loadInProcessPlugin: no types found"); return; }
 
-    PBLOG("Processor", "loadInProcessPlugin: creating instance \"" + typesFound[0]->name + "\"");
     juce::String err;
     inProcessPlugin = inProcessFormatManager.createPluginInstance(
         *typesFound[0], currentSampleRate, currentBlockSize, err);
 
-    if (!inProcessPlugin)
-    {
-        PBLOG("Processor", "loadInProcessPlugin: createPluginInstance FAILED — " + err);
-        DBG("PluginBridgeProcessor: in-process load failed: " + err);
-        return;
-    }
+    if (!inProcessPlugin) { PBLOG("Processor", "loadInProcessPlugin: FAILED — " + err); return; }
 
-    // Configure buses
     inProcessPlugin->enableAllBuses();
     auto layout = juce::AudioProcessor::BusesLayout();
     layout.inputBuses.add(juce::AudioChannelSet::stereo());
@@ -218,11 +225,9 @@ void PluginBridgeProcessor::loadInProcessPlugin(const juce::String& path)
     if (inProcessPlugin->checkBusesLayoutSupported(layout))
         inProcessPlugin->setBusesLayout(layout);
 
-    // Prepare for audio processing — safe for SAFE plugins (unsafe ones never reach here)
     if (currentSampleRate > 0 && currentBlockSize > 0)
         inProcessPlugin->prepareToPlay(currentSampleRate, currentBlockSize);
 
-    // Sync state from Helper (if it has state loaded already)
     auto response = helper.sendCommand("{\"cmd\":\"get_state\"}");
     try {
         auto j = json::parse(response);
@@ -239,23 +244,17 @@ void PluginBridgeProcessor::loadInProcessPlugin(const juce::String& path)
     } catch (...) {}
 
     inProcessPlugin->addListener(this);
-    PBLOG("Processor", "loadInProcessPlugin: SUCCESS — \"" + inProcessPlugin->getName() + "\" (audio+GUI)");
-    DBG("PluginBridgeProcessor: in-process plugin loaded: " + inProcessPlugin->getName());
+    PBLOG("Processor", "loadInProcessPlugin: SUCCESS — \"" + inProcessPlugin->getName() + "\"");
 }
 
 void PluginBridgeProcessor::unloadInProcessPlugin()
 {
     if (inProcessPlugin)
     {
-        PBLOG("Processor", "unloadInProcessPlugin: removing \"" + inProcessPlugin->getName() + "\"");
+        PBLOG("Processor", "unloadInProcessPlugin: " + inProcessPlugin->getName());
         inProcessPlugin->removeListener(this);
         inProcessPlugin->releaseResources();
         inProcessPlugin.reset();
-        PBLOG("Processor", "unloadInProcessPlugin: done");
-    }
-    else
-    {
-        PBLOG("Processor", "unloadInProcessPlugin: nothing to unload");
     }
 }
 
@@ -263,7 +262,6 @@ void PluginBridgeProcessor::audioProcessorParameterChanged(juce::AudioProcessor*
 {
     if (suppressParamSync.load()) return;
     if (!helper.isHelperRunning()) return;
-
     auto cmdStr = json({{"cmd","set_params"},{"values",{{std::to_string(paramIdx), value}}}}).dump();
     std::thread([this, cmdStr]() { helper.sendCommand(cmdStr); }).detach();
 }
@@ -272,21 +270,18 @@ void PluginBridgeProcessor::audioProcessorParameterChanged(juce::AudioProcessor*
 
 void PluginBridgeProcessor::loadPlugin(const juce::String& path)
 {
-    PBLOG("Processor", "loadPlugin: " + juce::File(path).getFileName()
-          + "  (currently loaded: " + (pluginLoaded ? pluginName : "none") + ")");
+    PBLOG("Processor", "loadPlugin: " + juce::File(path).getFileName());
 
     if (blocklist.isBlocked(path))
     {
-        PBLOG("Processor", "loadPlugin: BLOCKED — skipping");
         if (onLoadFailed) onLoadFailed("Not compatible (crashed previously)");
         return;
     }
 
     auto safety = safetyDB.getSafety(path);
-    PBLOG("Processor", juce::String("loadPlugin: safety = ")
-          + (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)
     {
@@ -301,79 +296,59 @@ void PluginBridgeProcessor::loadPlugin(const juce::String& path)
         return;
     }
 
-    if (onPluginWillLoad)
-    {
-        PBLOG("Processor", "loadPlugin: firing onPluginWillLoad → editor will detach old GUI");
-        onPluginWillLoad();
-    }
+    if (onPluginWillLoad) onPluginWillLoad();
 
     if (!helper.isHelperRunning())
     {
-        PBLOG("Processor", "loadPlugin: Helper not running — spawning");
         if (!helper.spawnHelper())
         {
-            PBLOG("Processor", "loadPlugin: ❌ spawnHelper FAILED");
             if (onLoadFailed) onLoadFailed("Failed to start helper process");
             return;
         }
-        PBLOG("Processor", "loadPlugin: Helper spawned OK");
-
         json configCmd = {{"cmd","configure"},{"sampleRate",currentSampleRate},
                           {"blockSize",currentBlockSize},{"channels",2}};
         helper.sendCommand(configCmd.dump());
     }
 
-    PBLOG("Processor", "loadPlugin: sending load cmd to Helper...");
     json loadCmd = {{"cmd","load"},{"path",path.toStdString()},
                     {"sampleRate",currentSampleRate},{"blockSize",currentBlockSize}};
     auto response = helper.sendCommand(loadCmd.dump());
-    PBLOG("Processor", "loadPlugin: Helper response: " + juce::String(response));
 
     try
     {
         auto j = json::parse(response);
         if (j.value("ok", false))
         {
-            pluginLoaded     = true;
-            pluginName       = juce::String(j["name"].get<std::string>());
+            pluginLoaded = true;
+            pluginName = juce::String(j["name"].get<std::string>());
             pluginParamCount = j.value("params", 0);
-            pluginPath       = path;
-            PBLOG("Processor", "loadPlugin: Helper loaded \"" + pluginName
-                  + "\" (" + juce::String(pluginParamCount) + " params)");
+            pluginPath = path;
+            PBLOG("Processor", "loadPlugin: loaded \"" + pluginName + "\"");
 
             if (safety == PluginSafetyDB::Safety::Safe)
             {
                 juce::MessageManager::callAsync([this, path]()
                 {
-                    PBLOG("Processor", "loadPlugin: [msg thread] calling loadInProcessPlugin");
                     loadInProcessPlugin(path);
-                    PBLOG("Processor", "loadPlugin: [msg thread] firing onPluginLoaded");
                     if (onPluginLoaded) onPluginLoaded();
                 });
             }
             else
             {
-                PBLOG("Processor", "loadPlugin: UNSAFE — skipping in-process load, audio-only mode");
                 juce::MessageManager::callAsync([this]()
-                {
-                    if (onPluginLoaded) onPluginLoaded();
-                });
+                { if (onPluginLoaded) onPluginLoaded(); });
             }
         }
         else
         {
-            PBLOG("Processor", "loadPlugin: ❌ Helper refused load: "
-                  + juce::String(j.value("error", "unknown")));
             pluginLoaded = false;
             pluginPath.clear();
             blocklist.addBlocked(path);
-            if (onLoadFailed)
-                onLoadFailed("Not compatible: " + juce::String(j.value("error", "unknown")));
+            if (onLoadFailed) onLoadFailed("Not compatible: " + juce::String(j.value("error","unknown")));
         }
     }
     catch (...)
     {
-        PBLOG("Processor", "loadPlugin: ❌ exception parsing Helper response");
         pluginLoaded = false;
         pluginPath.clear();
         blocklist.addBlocked(path);
@@ -384,35 +359,25 @@ void PluginBridgeProcessor::loadPlugin(const juce::String& path)
 void PluginBridgeProcessor::unloadPlugin()
 {
     PBLOG("Processor", "unloadPlugin: \"" + pluginName + "\"");
-
-    if (helper.isHelperRunning())
-        helper.sendCommand("{\"cmd\":\"unload\"}");
-
+    if (helper.isHelperRunning()) helper.sendCommand("{\"cmd\":\"unload\"}");
     pluginLoaded = false;
     pluginName.clear();
     pluginPath.clear();
     pluginParamCount = 0;
-
     unloadInProcessPlugin();
-    PBLOG("Processor", "unloadPlugin: done");
-
     if (onPluginUnloaded)
         juce::MessageManager::callAsync([this]() { if (onPluginUnloaded) onPluginUnloaded(); });
 }
 
-// ── Plugin Scanner ────────────────────────────────────────────────────────────
+// ── Scanner ───────────────────────────────────────────────────────────────────
 
 static juce::String signalName(int sig)
 {
-    switch (sig)
-    {
-        case SIGSEGV: return "SIGSEGV (segmentation fault)";
-        case SIGABRT: return "SIGABRT (abort)";
-        case SIGBUS:  return "SIGBUS (bus error)";
-        case SIGILL:  return "SIGILL (illegal instruction)";
-        case SIGFPE:  return "SIGFPE (floating point exception)";
-        case SIGKILL: return "SIGKILL (killed — timeout)";
-        default:      return "signal " + juce::String(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);
     }
 }
 
@@ -422,23 +387,13 @@ static void writeScanLog(const juce::String& pluginPath, bool safe,
     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");
-    auto name = juce::File(pluginPath).getFileName();
-
+    auto ts = juce::Time::getCurrentTime().formatted("%Y-%m-%d %H:%M:%S");
     juce::String entry;
-    entry << "────────────────────────────────────────\n"
-          << ts << "  " << name << "\n"
-          << "Path   : " << pluginPath << "\n"
-          << "Result : " << (safe ? "SAFE ✓" : "UNSAFE ✗") << "\n";
-    if (!reason.isEmpty()) entry << "Reason : " << reason << "\n";
-    if (captured.isNotEmpty())
-    {
-        entry << "Scanner output:\n";
-        for (auto& line : juce::StringArray::fromLines(captured))
-            if (line.isNotEmpty()) entry << "  " << line << "\n";
-    }
-    entry << "\n";
+    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);
 }
 
@@ -449,98 +404,65 @@ bool PluginBridgeProcessor::runPluginScan(const juce::String& path)
                          .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 binary not found", {});
-        return false;
-    }
+                        .getChildFile("Resources").getChildFile(PluginBridgeConstants::kHelperBinaryName);
+    if (!helperApp.exists()) { writeScanLog(path, false, "Helper not found", {}); return false; }
 
     int pipeFd[2];
-    if (pipe(pipeFd) != 0) { writeScanLog(path, false, "pipe() failed", {}); return false; }
+    if (pipe(pipeFd) != 0) return false;
     fcntl(pipeFd[0], F_SETFL, O_NONBLOCK);
 
-    auto helperPathStr = helperApp.getFullPathName().toStdString();
-    auto pluginPathStr = path.toStdString();
-
+    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*)helperPathStr.c_str(), (char*)"--scan",
-                     (char*)pluginPathStr.c_str(), nullptr };
-
-    int spawnResult = posix_spawn(&pid, helperPathStr.c_str(), &actions, nullptr, argv, environ);
+    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]);
+    if (sr != 0) { close(pipeFd[0]); return false; }
 
-    if (spawnResult != 0)
-    {
-        close(pipeFd[0]);
-        writeScanLog(path, false, "posix_spawn failed: " + juce::String(strerror(spawnResult)), {});
-        return false;
-    }
-
-    bool timedOut = true;
-    int finalStatus = 0;
+    bool timedOut = true; int status = 0;
     auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(10);
-    while (std::chrono::steady_clock::now() < deadline)
-    {
-        pid_t result = waitpid(pid, &finalStatus, WNOHANG);
-        if (result == pid) { timedOut = false; break; }
+    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, &finalStatus, 0); }
+    if (timedOut) { kill(pid, SIGKILL); waitpid(pid, &status, 0); }
 
     juce::String captured;
-    { char buf[8192]; ssize_t n;
-      while ((n = read(pipeFd[0], buf, sizeof(buf)-1)) > 0) { buf[n]='\0'; captured += buf; } }
+    { 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 = false;
-    juce::String reason;
-    if (timedOut) reason = "Timed out after 10s";
-    else if (WIFEXITED(finalStatus)) { int code = WEXITSTATUS(finalStatus); safe = (code==0);
-        reason = safe ? "" : "Exited with code " + juce::String(code); }
-    else if (WIFSIGNALED(finalStatus)) reason = "Crashed: " + signalName(WTERMSIG(finalStatus));
-
+    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;
 }
 
-// ── Background Scanner ────────────────────────────────────────────────────────
-
 void PluginBridgeProcessor::startBackgroundScan()
 {
     if (scanRunning.load()) return;
     scanRunning.store(true);
-
-    scanThread = std::thread([this]()
-    {
+    scanThread = std::thread([this]() {
         auto files = getInstalledPluginFiles();
-        for (int i = 0; i < files.size() && scanRunning.load(); ++i)
-        {
+        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));
             if (!scanRunning.load()) break;
-
             bool safe = runPluginScan(path);
-            safetyDB.setSafety(path, safe ? PluginSafetyDB::Safety::Safe
-                                          : PluginSafetyDB::Safety::Unsafe);
+            safetyDB.setSafety(path, safe ? PluginSafetyDB::Safety::Safe : PluginSafetyDB::Safety::Unsafe);
             if (onScanProgress)
                 juce::MessageManager::callAsync([this, path, safe]()
                     { if (onScanProgress) onScanProgress(path, safe); });
@@ -561,135 +483,75 @@ juce::Array<juce::File> PluginBridgeProcessor::getInstalledPluginFiles() const
 {
     juce::Array<juce::File> results;
     std::set<std::string> seen;
-
-    struct DirSpec { juce::File dir; const char* pattern; };
-    std::vector<DirSpec> specs = {
+    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::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" }
+        { juce::File::getSpecialLocation(juce::File::userHomeDirectory).getChildFile("Library/Audio/Plug-Ins/Components"), "*.component" }
     };
-
-    for (auto& spec : specs)
-    {
-        if (!spec.dir.isDirectory()) continue;
-        auto files = spec.dir.findChildFiles(juce::File::findDirectories, false, spec.pattern);
-        for (auto& f : files)
-        {
-            auto stem = f.getFileNameWithoutExtension().toStdString();
-            if (seen.insert(stem).second) results.add(f);
-        }
+    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); }
 
-// ── Manufacturer name ─────────────────────────────────────────────────────────
-
-static juce::String cleanManufacturer(const juce::String& raw)
-{
-    auto s = raw.trim();
-    if (s.isEmpty()) return {};
-    if (s.containsOnly("0123456789.")) return {};
-
-    auto lower = s.toLowerCase();
-    if (lower.startsWith("copyright"))
-    {
-        auto rest = s.substring(9).trim();
-        if (rest.startsWithIgnoreCase("(c)")) rest = rest.substring(3).trim();
-        else if (rest.startsWith(juce::String::fromUTF8("\xc2\xa9")))
-            rest = rest.substring(juce::String::fromUTF8("\xc2\xa9").length()).trim();
-        else if (rest.startsWith(juce::CharPointer_UTF8("\xc2\xa9")))
-            rest = rest.substring(1).trim();
-        auto spacePos = rest.indexOfChar(' ');
-        if (spacePos > 0) rest = rest.substring(spacePos + 1).trim();
-        if (rest.isNotEmpty()) return rest;
-        return {};
+// ── Manufacturer ──────────────────────────────────────────────────────────────
+
+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();
     }
     return s;
 }
 
-static juce::String plistValue(const juce::String& text, const juce::String& key)
-{
-    auto pos = text.fromFirstOccurrenceOf(key, false, true);
-    if (pos.isEmpty()) return {};
-    return pos.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 pathKey = f.getFullPathName().toStdString();
-    { std::lock_guard<std::mutex> lock(manufacturerCacheMutex);
-      auto it = manufacturerCache.find(pathKey);
-      if (it != manufacturerCache.end()) return juce::String(it->second); }
-
+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); }
     juce::String mfr;
-
-    if (f.getFileExtension().toLowerCase() == ".vst3")
-    {
-        auto infoPlist = f.getChildFile("Contents").getChildFile("Info.plist");
-        if (infoPlist.existsAsFile())
-        {
-            auto text = infoPlist.loadFileAsString();
-            auto copyright = plistValue(text, "NSHumanReadableCopyright");
-            mfr = cleanManufacturer(copyright);
-
-            if (mfr.isEmpty())
-            {
-                auto infoStr = plistValue(text, "CFBundleGetInfoString");
-                if (infoStr.contains(","))
-                {
-                    auto beforeComma = infoStr.upToFirstOccurrenceOf(",", false, false).trim();
-                    auto first = beforeComma.upToFirstOccurrenceOf(" ", false, false).trim();
-                    if (first.isNotEmpty() && !first.containsOnly("0123456789.")) mfr = first;
-                }
-                if (mfr.isEmpty()) mfr = cleanManufacturer(infoStr);
-            }
-
-            if (mfr.isEmpty())
-            {
-                auto bid = plistValue(text, "CFBundleIdentifier");
-                auto segs = juce::StringArray::fromTokens(bid, ".", "");
-                if (segs.size() >= 2)
-                {
-                    auto slug = segs[1].trim();
-                    if (slug.isNotEmpty() && slug != "apple" && slug != "com")
-                    { slug = slug.substring(0,1).toUpperCase() + slug.substring(1); mfr = slug; }
-                }
-            }
+    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 moduleInfo = f.getChildFile("Contents").getChildFile("moduleinfo.json");
-            if (moduleInfo.existsAsFile())
-            {
-                try { auto j = json::parse(moduleInfo.loadFileAsString().toStdString());
-                      auto vendor = cleanManufacturer(juce::String(j.value("vendor",""))); 
-                      if (vendor.isNotEmpty()) mfr = vendor; } catch (...) {}
-            }
-        }
-    }
-
-    if (mfr.isEmpty())
-    {
-        auto name = f.getFileNameWithoutExtension();
-        auto first = name.upToFirstOccurrenceOf(" ", false, false);
-        if (first.isNotEmpty() && !first.containsOnly("0123456789.")) mfr = first;
-        else mfr = name;
+        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()) mfr = "Other";
-
-    std::lock_guard<std::mutex> lock(manufacturerCacheMutex);
-    manufacturerCache[pathKey] = mfr.toStdString();
-    return mfr;
+    std::lock_guard<std::mutex> l(manufacturerCacheMutex); manufacturerCache[pk] = mfr.toStdString(); return mfr;
 }
 
 // ── State ─────────────────────────────────────────────────────────────────────
@@ -698,13 +560,12 @@ 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 response = helper.sendCommand("{\"cmd\":\"get_state\"}");
-        try { auto j = json::parse(response);
-              if (j.value("ok",false))
-                  state.setProperty("pluginState", juce::String(j["state"].get<std::string>()), 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 (...) {}
     }
 
@@ -717,14 +578,17 @@ void PluginBridgeProcessor::setStateInformation(const void* data, int sizeInByte
     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;
 
     loadPlugin(path);
 
     auto pluginState = state.getProperty("pluginState").toString();
-    if (pluginState.isNotEmpty() && helper.isHelperRunning())
-    {
+    if (pluginState.isNotEmpty() && helper.isHelperRunning()) {
         json cmd = {{"cmd","set_state"},{"state",pluginState.toStdString()}};
         helper.sendCommand(cmd.dump());
     }
@@ -735,7 +599,4 @@ void PluginBridgeProcessor::setStateInformation(const void* data, int sizeInByte
 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();
-}
+juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter() { return new PluginBridgeProcessor(); }