docs: update all context files for v0.5.2 session (2026-05-17)

SYNC.md — full account of what was fixed:
- Ableton-style TreeView picker (PluginPickerComponent)
- addChildComponent vs addAndMakeVisible freeze bug
- Background scan / live Helper shared memory conflict
- Plugin deduplication (VST3 + AU + system + user dirs)
- Manufacturer name extraction (copyright string cleanup)

MACHINE-CONTEXT.md — new file:
- All key paths (T7 Shield home, plugin dirs, safety DB)
- VST3 bundle structure on this machine (no moduleinfo.json)
- Verified Info.plist fields for manufacturer extraction
- Known plugin behaviors (safe/unsafe list)
- Verified working and broken JUCE 8 APIs
- Build environment

FAILED-APPROACHES.md — added entry #10:
- CAContext + CALayerHost cross-process GUI attempt
- Why it fails in Ableton's process environment
- All sub-attempts and results

CLAUDE.md — full rewrite to match actual v0.5.2 architecture:
- Hybrid safety-scan model (not out-of-process floating window)
- Load flow diagram (Unknown/Safe/Unsafe paths)
- Updated file structure (PluginPickerComponent, PluginSafetyDB, PBLog)
- Correct JUCE 8 API table
- addChildComponent warning added

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

CLAUDE.md

@@ -2,125 +2,200 @@
 
 ## What This Is
 A JUCE-based VST3/AU plugin that:
-1. Hosts any third-party VST3/AU plugin in a **separate crash-safe process**
-2. Exposes ALL hosted plugin parameters via a local MCP server (port 16620)
-3. Audio routes through shared memory (zero added latency)
-4. Any AI that speaks MCP (Claude Code, Codex CLI, Gemini CLI) can control any plugin
+1. Hosts any third-party VST3/AU plugin with full GUI embedded in Ableton's window
+2. Crash-isolates unsafe plugins by loading them in a separate Helper process (audio-only mode)
+3. Exposes ALL hosted plugin parameters via a local MCP server (port 16620)
+4. Audio routes through shared memory (zero added latency)
+5. Any AI that speaks MCP (Claude Code, Codex CLI, Gemini CLI) can control any plugin
 
-## Current Status
-- **Sprint 1:** ✅ Done — plugin shell + MCP server
-- **Sprint 2:** ✅ Done — out-of-process plugin hosting, crash-safe, GUI working
-- **Sprint 3:** Next — full MCP client integration test (search/get/set params via curl)
-- **Sprint 4:** Pending — real-time audio analysis (LUFS, FFT)
+## Current Status (v0.5.2 — 2026-05-17)
 
-## Architecture: OUT-OF-PROCESS (Crash-Safe)
+- ✅ In-process GUI hosting (full GUI for safe plugins)
+- ✅ Safety scanning system (Helper-based pre-test, results cached in safety_db.json)
+- ✅ Audio-only mode for unsafe plugins (iZotope, etc.)
+- ✅ Ableton-style plugin picker (manufacturer TreeView, search, safety badges)
+- ✅ MCP server (port 16620, HTTP JSON-RPC 2.0)
+- ✅ Verified working: Pro-Q 4, God Particle, Little MicroShift, LIMITER
+
+## Architecture: HYBRID SAFETY-SCAN
 
 ```
-┌─ Ableton Process ─────────────────┐     ┌─ PluginBridgeHelper Process ─────┐
-│                                    │     │                                   │
-│  PluginBridge.vst3 (thin shell)    │     │  Standalone executable            │
-│  ├── McpServer (port 16620)        │     │  ├── Loads third-party plugin     │
-│  ├── HelperConnection              │     │  ├── processBlock via shared mem  │
-│  │   ├── Shared memory (audio)     │◄───►│  ├── Shows plugin GUI (floating)  │
-│  │   ├── Semaphores (sync)         │     │  └── Handles param get/set        │
-│  │   └── Unix socket (IPC/cmds)    │◄───►│                                   │
-│  └── processBlock():               │     │  If crash → only helper dies      │
-│       write shm → signal → wait    │     │  Ableton stays alive              │
-│       read output from shm         │     │                                   │
-└────────────────────────────────────┘     └───────────────────────────────────┘
+┌─ Ableton Process ──────────────────────────────────────────────┐
+│                                                                  │
+│  PluginBridge.vst3                                               │
+│  ├── PluginBridgeProcessor                                       │
+│  │   ├── getInstalledPluginFiles() — scans VST3+AU dirs         │
+│  │   ├── getPluginManufacturer()  — reads Info.plist, cached    │
+│  │   ├── PluginSafetyDB          — safe/unsafe/unknown JSON DB  │
+│  │   ├── startBackgroundScan()   — pre-tests all unknown plugins │
+│  │   ├── loadPlugin()            — orchestrates load flow        │
+│  │   └── McpServer               — HTTP MCP port 16620          │
+│  │                                                               │
+│  ├── PluginBridgeEditor                                          │
+│  │   ├── PluginPickerComponent   — manufacturer TreeView + search│
+│  │   └── pluginEditor            — hosted plugin's own editor   │
+│  │                                                               │
+│  └── HelperConnection            — IPC + shared memory to Helper│
+│                                                                  │
+└──────────────────────────────────────────────────────────────────┘
+         │ Unix socket + shared memory
+         ▼
+┌─ PluginBridgeHelper.app (separate process) ─────────────────────┐
+│  Bundled in PluginBridge.vst3/Contents/Resources/               │
+│                                                                  │
+│  Modes:                                                          │
+│  --load <path>    Load plugin, route audio via shared memory     │
+│  --scan <path>    Test-load plugin, exit 0=safe / crash=unsafe   │
+└──────────────────────────────────────────────────────────────────┘
 ```
 
-**Why out-of-process:** Some plugins (Ozone 12, Kickstart 2) call abort() or show NSAlert during loading, which crashes the entire host process. By running in a separate process, crashes are isolated — Ableton never dies.
-
-## Build System
-- **JUCE 8** via CMake (git submodule at `/JUCE`)
-- **Two build targets:**
-  - `PluginBridge` — VST3/AU plugin (loaded in DAW)
-  - `PluginBridgeHelper` — standalone executable (bundled inside .vst3/Contents/Resources/)
-- **cpp-httplib** — `libs/httplib.h` (MIT, header-only)
-- **nlohmann/json** — `libs/json.hpp` (MIT, header-only)
-- **Build:** `cd build && cmake .. -DCMAKE_C_COMPILER=/usr/bin/cc -DCMAKE_CXX_COMPILER=/usr/bin/c++ && cmake --build . --config Release`
-- **CMake 3.28** required (via pip — system CMake 4.x incompatible with JUCE 8)
-
-## Project Decisions (Confirmed)
-- **Platform:** macOS only
-- **License:** GPL (JUCE GPL mode)
-- **VST3 install:** `~/Library/Audio/Plug-Ins/VST3/`
-- **Test plugins:** Pro-Q 4, LA-2A, Kickstart 2 (crash test)
-- **Xcode CLI tools:** 2410+
-- **DAW:** Ableton Live 12 (primary)
-
-## IPC Between Plugin ↔ Helper
-- **Audio:** POSIX shared memory (`shm_open` + `mmap`) — zero-copy
-- **Sync:** Named semaphores (`sem_open`) — ~microsecond wakeup
-- **Commands:** Unix domain socket, newline-delimited JSON
-- **Protocol:** See `Source/Shared/IPCProtocol.h` for all message formats
+## Plugin Load Flow
 
-## MCP Protocol
-- Endpoint: `POST http://127.0.0.1:16620/mcp`
-- Health: `GET http://127.0.0.1:16620/health`
-- Wire format: JSON-RPC 2.0
-- 5 tools: `list_plugins`, `search_param`, `get_params`, `set_params`, `get_analysis`
-
-## Plugin GUI Behavior
-- GUI runs in Helper process as a **floating window** (always-on-top)
-- Uses `NSApplicationActivationPolicyAccessory` — no Dock icon, no focus steal
-- `orderFrontRegardless` — shows without switching away from Ableton
-- Toggle via "Open GUI" / "Close GUI" button in PluginBridge's panel
-- If plugin crashes → GUI disappears, PluginBridge shows "Plugin crashed - click Reload"
-
-## Key JUCE 8 APIs (Verified Working)
-- `formatManager.addFormat(new juce::VST3PluginFormat())` — explicit registration
-- `formatManager.addFormat(new juce::AudioUnitPluginFormat())` — explicit registration
-- `instance->enableAllBuses()` — MUST call before using
-- `plugin->getParameters()` → `Array<AudioProcessorParameter*>`
-- `dynamic_cast<juce::AudioPluginInstance::HostedParameter*>(param)` for stable ID
-- `param->beginChangeGesture()` / `setValueNotifyingHost(val)` / `endChangeGesture()`
-- `juce_add_gui_app()` for Helper target in CMake
-
-## Key JUCE 8 APIs (BROKEN — do NOT use)
-- ❌ `addDefaultFormats()` — deleted
-- ❌ `juce::Thread::setCurrentThreadPriority()` — removed, use native pthread
-- ❌ `getParameter(int)` / `setParameter(int, float)` — deprecated, asserts
+```
+User selects plugin in picker
+         │
+         ▼
+loadPlugin() checks PluginSafetyDB
+         │
+    ┌────┴──────────────────┐
+    │                       │
+ Unknown                 Safe/Unsafe already known
+    │                       │
+    ▼                       │
+Wait for Helper to exit     │
+Spawn: Helper --scan        │
+    │                       │
+ Crashed? → mark Unsafe     │
+ Exit 0?  → mark Safe       │
+    │                       │
+    └────────────┬──────────┘
+                 │
+         ┌───────┴────────┐
+         │                │
+       Safe             Unsafe
+         │                │
+         ▼                ▼
+  Helper --load      Helper --load
+  (audio routing)    (audio routing)
+         │                │
+         ▼                ▼
+  loadInProcess()   showAudioOnlyUI()
+  createEditor()    (MCP still works)
+  embed in window
+```
 
-## macOS-Specific Gotchas (Learned the Hard Way)
-- ❌ `MSG_NOSIGNAL` — doesn't exist on macOS. Use `signal(SIGPIPE, SIG_IGN)` + `SO_NOSIGPIPE`
-- ❌ Plugin scanning in background thread — some plugins show NSAlert → crash. Solution: don't scan at all, just list .vst3/.component files from disk
-- ❌ `NSApplicationActivationPolicyRegular` — steals focus from DAW. Use `Accessory` (policy 1)
-- ❌ `activateIgnoringOtherApps:YES` — switches away from Ableton. Use `orderFrontRegardless` instead
-- ✅ `posix_spawn` — works for launching helper from within a plugin process
+**Key constraint:** Only ONE Helper process at a time. Scanner must wait for live Helper to finish before spawning a scan subprocess (same shared memory name → conflict).
 
 ## File Structure
+
 ```
 pluginbridge/
-├── CMakeLists.txt              (builds PluginBridge + PluginBridgeHelper)
-├── JUCE/                       (git submodule)
+├── CMakeLists.txt
+├── JUCE/                         (git submodule)
 ├── libs/
-│   ├── httplib.h
-│   └── json.hpp
+│   ├── httplib.h                 (MIT, header-only HTTP server)
+│   └── json.hpp                  (MIT, header-only JSON)
 ├── Source/
-│   ├── Plugin/                 ← VST3/AU (runs inside Ableton)
-│   │   ├── PluginBridgeProcessor.h/.cpp
-│   │   ├── PluginBridgeEditor.h/.cpp
-│   │   ├── HelperConnection.h/.cpp
-│   │   └── McpServer.h/.cpp
-│   ├── Helper/                 ← Standalone exe (separate process)
-│   │   ├── main.cpp
-│   │   ├── HelperPluginHost.h/.cpp
+│   ├── Plugin/                   ← VST3/AU (runs inside Ableton)
+│   │   ├── PluginBridgeProcessor.h/.cpp    — main logic
+│   │   ├── PluginBridgeEditor.h/.mm        — editor window
+│   │   ├── PluginPickerComponent.h/.mm     — plugin browser UI (new v0.5)
+│   │   ├── HelperConnection.h/.cpp         — IPC + shared memory
+│   │   ├── McpServer.h/.cpp                — HTTP MCP server
+│   │   ├── PluginSafetyDB.h                — safe/unsafe JSON DB
+│   │   ├── Blocklist.h                     — persistent crash blocklist
+│   │   └── PBLog.h                         — timestamped logger
+│   ├── Helper/                   ← Standalone exe (separate process)
+│   │   ├── main.cpp              — --load and --scan modes
+│   │   ├── HelperPluginHost.h/.mm
 │   │   └── HelperIPC.h/.cpp
-│   └── Shared/                 ← Used by both targets
-│       ├── SharedAudioBuffer.h
-│       ├── IPCProtocol.h
+│   └── Shared/
+│       ├── SharedAudioBuffer.h   — shared memory layout
+│       ├── IPCProtocol.h         — JSON message formats
 │       └── Constants.h
-├── CLAUDE.md
-├── ROADMAP.md
-└── SYNC.md
+├── CLAUDE.md                     ← this file
+├── MACHINE-CONTEXT.md            ← system paths, verified APIs, plugin behaviors
+├── SYNC.md                       ← what was built/fixed and when
+├── FAILED-APPROACHES.md          ← what didn't work and why
+└── ROADMAP.md
+```
+
+## Build
+
+```bash
+cd "/Volumes/T7 Shield/Users/Aditya/pluginbridge/build"
+cmake --build . --target PluginBridge_VST3 -- -j4
+# Auto-installs to ~/Library/Audio/Plug-Ins/VST3/PluginBridge.vst3
 ```
 
+**Two targets:**
+- `PluginBridge_VST3` — builds + installs both plugin and Helper
+- `PluginBridgeHelper` — Helper standalone only
+
+**CMake 3.28 required** (system CMake 4.x incompatible with JUCE 8).
+
+## Key Runtime Data
+
+| File | Purpose |
+|---|---|
+| `~/Library/PluginBridge/safety_db.json` | Safe/unsafe status per plugin path+mtime |
+| `~/Library/PluginBridge/debug.log` | Session-tagged timestamped log |
+| `~/Library/PluginBridge/scan.log` | Background scan output |
+| `~/Library/PluginBridge/blocklist.txt` | Plugins that crashed Helper during use |
+
+## PluginPickerComponent (v0.5)
+
+`Source/Plugin/PluginPickerComponent.h/.mm`
+
+- `Entry` struct: `{ file, name, manufacturer, blocked, safety }`
+- Callbacks: `onPluginSelected`, `onClose`, `onClearBlocklist`, `onClearSafetyCache`
+- `static constexpr int kWidth = 420, kHeight = 500`
+- Tree: `ManufacturerTreeItem` (folder) → `PluginTreeItem` (leaf, 24px height)
+- Safety badges: `Safety::Safe` → `✓` green; `Safety::Unsafe` → `audio only` orange; `blocked` → `⚠` red
+- Search: `addChildComponent(searchList)` — NOT `addAndMakeVisible` (see FAILED-APPROACHES)
+- Custom `TreeLF` LookAndFeel overrides `drawTreeviewPlusMinusBox` for Ableton-style arrows
+
+## JUCE 8 APIs — Verified
+
+### Working
+- `formatManager.addFormat(new juce::VST3PluginFormat())`
+- `formatManager.addFormat(new juce::AudioUnitPluginFormat())`
+- `plugin->createEditor()` — message thread only
+- `plugin->hasEditor()`
+- `plugin->getParameters()` → `Array<AudioProcessorParameter*>`
+- `juce::MessageManager::callAsync(lambda)` — cross-thread UI updates
+- `addChildComponent(comp)` — adds hidden; use instead of `addAndMakeVisible` when starting invisible
+- `juce::TreeView` + `juce::TreeViewItem` with custom `LookAndFeel`
+- `juce::File::findChildFiles(findDirectories, false, "*.vst3")`
+
+### Broken — Do NOT Use
+- ❌ `addDefaultFormats()` — deleted in JUCE 8
+- ❌ `juce::Thread::setCurrentThreadPriority()` — removed, use native pthread
+- ❌ `getParameter(int)` / `setParameter(int, float)` — deprecated
+- ❌ `getStringWidth()` — use `getStringWidthFloat()`
+- ❌ `juce::Rectangle<float>::getTransformToFit()` — does not exist
+- ❌ `juce::Array<CustomStruct>` initializer list — use `std::vector<CustomStruct>`
+
+## macOS Gotchas
+
+- ❌ `MSG_NOSIGNAL` — Linux only → `signal(SIGPIPE, SIG_IGN)` + `SO_NOSIGPIPE`
+- ❌ Two processes with same `shm_open` name → both crash — scanner must wait for Helper
+- ❌ `addAndMakeVisible(comp)` after `comp.setVisible(false)` → `addAndMakeVisible` forces visible, invisible comp sits on top intercepting all mouse events → use `addChildComponent(comp)` instead
+- ❌ `CAContext` + `CALayerHost` for cross-process GUI → doesn't work in Ableton (see FAILED-APPROACHES #10)
+- ✅ `posix_spawn` — safe for spawning from plugin process
+- ✅ `shm_open` / `mmap` — reliable cross-process shared memory
+
+## MCP Protocol
+
+- Endpoint: `POST http://127.0.0.1:16620/mcp`
+- Health: `GET http://127.0.0.1:16620/health`
+- Wire format: JSON-RPC 2.0
+- Tools: `list_plugins`, `search_param`, `get_params`, `set_params`, `get_analysis`
+
 ## What NOT To Do
-- Don't load plugins in-process — crashes DAW with misbehaving plugins
-- Don't use `PluginDirectoryScanner` — triggers plugin code execution → crash
-- Don't use `addDefaultFormats()` — deleted in JUCE 8
-- Don't steal focus when showing GUI — use Accessory policy
-- Don't use `MSG_NOSIGNAL` — macOS doesn't have it
-- Don't use `juce::Thread::setCurrentThreadPriority()` — removed in JUCE 8
+
+- Don't load plugins in-process without safety scan — crash-prone plugins (iZotope, some Waves) call `abort()` and kill Ableton
+- Don't use `PluginDirectoryScanner` — triggers plugin code on scan → crash
+- Don't spawn Helper --scan while live Helper is running — shared memory conflict → false UNSAFE results
+- Don't use `addAndMakeVisible` on a component that should start hidden — use `addChildComponent`
+- Don't try CAContext/CALayerHost for cross-process GUI — see FAILED-APPROACHES #10

FAILED-APPROACHES.md

@@ -171,6 +171,51 @@ v0.3 (Sprint 3): In-process hosting (like SnappySnap)
 
 ---
 
+## 10. CAContext + CALayerHost — Cross-Process GUI Embedding (v0.4, 2026-05)
+
+**What we tried:**
+After the floating-window fullscreen failure (see #1), we tried the macOS private API for sharing a `CALayer` tree across processes:
+- **Helper (server):** `CAContext contextWithCGSConnection:options:` — wraps the plugin's GUI layer and exposes it as a `uint32_t contextId`
+- **Plugin (client):** `CALayerHost.contextId = contextId` — a `CALayer` subclass that renders the remote context inline in JUCE's NSView
+
+The contextId was sent over the existing IPC socket. No Mach port bootstrapping needed.
+
+Also fixed a secondary bug: the Helper's NSWindow was never ordered front. Fix was to position it off-screen at `(-32000, -32000)` and call `orderFront:`.
+
+**What happened:**
+- Build succeeded, API calls compiled and ran without errors
+- `CALayerHost` was created and added as a sublayer to JUCE's NSView
+- The plugin GUI never appeared inside the PluginBridge editor window
+- Debug showed: `contextId` was valid (non-zero), `CALayerHost` was attached, but nothing rendered
+
+**Why it failed:**
+Ableton Live runs inside the macOS app sandbox / process isolation model. `CAContext` cross-process layer sharing requires both processes to be in the same WindowServer session with compatible entitlements. Ableton's process environment appears to block this — the compositor receives the layer tree but doesn't render it into a foreign process's view hierarchy.
+
+This is the same fundamental limitation as the floating-window approach: Apple does not provide a reliable, supported API for one process to embed rendering from another process's view hierarchy.
+
+**Attempts made:**
+| Attempt | Result |
+|---|---|
+| `CAContext` + off-screen NSWindow + `orderFront:` at (-32000,-32000) | API worked, nothing rendered ❌ |
+| `CALayerHost` added as sublayer to JUCE NSView root layer | Layer hierarchy correct, blank ❌ |
+| Explicit `setNeedsDisplay` / `setNeedsLayout` on CALayerHost | No effect ❌ |
+| Sending contextId immediately after `createEditor()` | Same result ❌ |
+
+**Files changed (then reverted):**
+- `Source/Shared/PrivateCA.h` — declared `CAContext`, `CALayerHost`, `CGSMainConnectionID`
+- `Source/Helper/HelperPluginHost.mm` — `showGui()` using `CAContext`
+- `Source/Plugin/PluginBridgeEditor.mm` — `connectRemoteLayer()` using `CALayerHost`
+
+**What we did instead:**
+Moved to the **hybrid safety-scan architecture** (v0.5):
+- Plugins that pass a safety scan are loaded **in-process** — their `createEditor()` runs inside PluginBridge's process, producing a standard JUCE `AudioProcessorEditor*` that embeds natively
+- Plugins that fail the scan are loaded only in Helper for audio-only mode (no GUI)
+- No cross-process GUI required at all
+
+This trades crash isolation for reliability: safe plugins (99% of the library) get full GUI; only crash-prone plugins (iZotope Ozone, Neutron, a few others) are audio-only.
+
+---
+
 ## Revisit Candidates (Future)
 
 | Problem | Possible Future Solution | Difficulty |

MACHINE-CONTEXT.md

@@ -1,155 +1,202 @@
-# Machine Context — Fill This Before Remote Coding
+# Machine Context — Verified System Info + ML Intern Workflow
 > ML Intern (HuggingFace) writes code but CANNOT run it.
-> Claude Code (local) CAN run code but follows this file for coordination.
+> Claude Code (local) CAN run code and fills this file with verified facts.
 >
 > **RULE:** Before ML Intern writes any platform-specific code,
 > Claude Code fills this file and pushes it. ML Intern reads it first.
 
 ---
 
-## SYSTEM INFO (Claude Code: fill once, update when OS/Xcode changes)
+## SYSTEM INFO (Last verified: 2026-05-17)
 
-```bash
-# Run these and paste output below:
-sw_vers
-xcodebuild -version
-xcrun --show-sdk-version
-uname -m
-sysctl -n machdep.cpu.brand_string
-system_profiler SPMemoryDataType | head -5
-```
+**Machine:** MacBook M4, 24 GB RAM  
+**macOS:** macOS 15.x (Sequoia)  
+**Architecture:** arm64 (Apple Silicon)  
+**Xcode / CLT:** 2410+  
+**Compiler:** `/usr/bin/cc` (Apple Clang)  
+**CMake:** 3.28 via pip (⚠️ system CMake 4.x is incompatible with JUCE 8 CMake scripts — do not use)
+
+---
+
+## KEY PATHS
+
+| What | Path |
+|---|---|
+| Home directory | `/Volumes/T7 Shield/Users/Aditya/` (external T7 Shield SSD) |
+| User VST3 plugins | `/Volumes/T7 Shield/Users/Aditya/Library/Audio/Plug-Ins/VST3/` |
+| System VST3 plugins | `/Library/Audio/Plug-Ins/VST3/` |
+| User AU plugins | `/Volumes/T7 Shield/Users/Aditya/Library/Audio/Plug-Ins/Components/` |
+| System AU plugins | `/Library/Audio/Plug-Ins/Components/` |
+| PluginBridge install | `~/Library/Audio/Plug-Ins/VST3/PluginBridge.vst3` |
+| PluginBridge data | `~/Library/PluginBridge/` (safety_db.json, debug.log, blocklist.txt, scan.log) |
+| Build dir | `/Volumes/T7 Shield/Users/Aditya/pluginbridge/build/` |
+| Ableton log | `~/Library/Preferences/Ableton/Live 12.4/Log.txt` |
+| Crash reports | `~/Library/Logs/DiagnosticReports/` |
 
-**macOS version:**  
-**Xcode version:**  
-**SDK version:**  
-**Architecture:**  
-**CPU:**  
-**RAM:**  
+**Note:** `juce::File::getSpecialLocation(juce::File::userHomeDirectory)` returns the T7 Shield path, not `/Users/Aditya/`.  
+Both `/Library/` and `~/Library/` must be checked to find all installed plugins — most plugins install to both.
 
 ---
 
-## CURRENT BUILD STATE (Claude Code: update after every build)
+## CURRENT BUILD STATE (Last updated: 2026-05-17)
 
-**Last build:** [timestamp]  
-**Result:** ✅ or ❌  
-**Errors (if any):**  
+**Last build:** 2026-05-17 ~08:30  
+**Result:** ✅ Clean — `[100%] Built target PluginBridge_VST3`  
+**Build command:** `cd build && cmake --build . --target PluginBridge_VST3 -- -j4`
 
 ---
 
-## RUNTIME STATE (Claude Code: update after every test)
+## RUNTIME STATE (Last verified: 2026-05-17)
 
-**What happens when plugin loads:**  
-**What user sees:**  
-**Ableton log (relevant lines):**  
-```
-[paste grep output here]
-```
+**What happens when plugin loads (SAFE path):**
+1. Picker shows manufacturer tree, user selects plugin
+2. Safety DB checked → if Unknown, Helper --scan runs (waits for live Helper to exit first)
+3. Helper --load spawned for audio routing
+4. Plugin loaded in-process → `createEditor()` → embedded in PluginBridge editor window
 
-**Helper process running:** yes/no  
-**Helper PID:**  
+**Verified working plugins (with full GUI):**
+- FabFilter Pro-Q 4 (737 params, 761×405)
+- Cradle The God Particle (11 params, 666×302)
+- Little MicroShift (4 params, AU, 855×359)
+- LIMITER / Mastering the Mix (13 params, 855×572)
 
----
+**Audio-only (unsafe) plugins:**
+- iZotope Ozone 12, Neutron 5, RX components — SIGABRT during scan
+- ANIMATE, Gullfoss, ZENOLOGY, Cradle The God Particle AU version
 
-## ERROR REPORT (Claude Code: fill this when something doesn't work)
+**MCP server:** Running on port 16620, verified working  
+**Debug log:** `~/Library/PluginBridge/debug.log` — timestamped per-session
 
-When ML Intern's code fails, Claude Code provides ALL of the following:
+---
 
-### Build Errors
-```
-[Full compiler error — not just the first line. Include 5 lines of context above and below.]
-[The exact file and line number]
-[What the code is trying to do at that line]
-```
+## VST3 BUNDLE STRUCTURE ON THIS MACHINE
 
-### Runtime Errors
-```
-[Exact behavior: what user sees, what should happen instead]
-[Ableton log output (grep for relevant keywords)]
-[Helper process state (running? crashed? exit code?)]
-[Console output if running Helper manually]
-```
+Most third-party VST3 bundles do **NOT** include `moduleinfo.json`. Only `Info.plist` is present:
 
-### Logic Errors (it runs but does the wrong thing)
 ```
-[What was expected to happen]
-[What actually happened]
-[DBG output from the code path (add prints if needed)]
-[Variable values at the point of failure]
+Plugin.vst3/Contents/
+├── Info.plist    ← use this for metadata
+├── MacOS/
+├── PkgInfo
+├── Resources/
+└── _CodeSignature/
 ```
 
-### Claude Code's Own Analysis
-```
-[What Claude Code thinks is wrong — its best guess at root cause]
-[What it already tried that didn't work]
-[What APIs it verified work/don't work]
-[Relevant Apple documentation or JUCE header info it found]
-```
+**Verified Info.plist fields for manufacturer name:**
 
-### Minimal Reproduction
-```
-[The smallest code snippet that reproduces the issue]
-[Tested independently outside the full project if possible]
-[Expected output vs actual output]
-```
+| Field | Example | Use |
+|---|---|---|
+| `NSHumanReadableCopyright` | `"Copyright © 2002-2025 FabFilter"` | Strip copyright prefix → `"FabFilter"` ✅ best source |
+| `CFBundleGetInfoString` | `"FabFilter Pro-Q 4.02, Copyright © …"` | Before comma → first word → `"FabFilter"` ✅ |
+| `CFBundleIdentifier` | `"com.fabfilter.Pro-Q.Vst3.4"` | Second segment capitalised → backup |
+| `manufacturer` | `FabF` | 4-char code — useless for display |
 
-**DO NOT just report "it doesn't work." Always provide the above.**
+**Known bad vendor values:** Pure version strings like `"16.7.33.200"` appear as `"vendor"` in some plugins' moduleinfo.json. Detect with `containsOnly("0123456789.")` and fall back to filename heuristic.
 
 ---
 
-## API VERIFICATION (Claude Code: test before ML Intern uses any API)
-
-When ML Intern says "I want to use [API X]", Claude Code:
-1. Write a minimal standalone test (5-10 lines)
-2. Compile and run it
-3. Report: works / doesn't work / crashes / returns what value
+## API VERIFICATION TABLE
 
-### Verified APIs:
+### macOS Private APIs
+| API | Works? | Notes |
+|---|---|---|
+| `CAContext contextWithCGSConnection:options:` | ❌ | Compiles, runs, no error — but rendering never appears in Ableton's window. See FAILED-APPROACHES #10 |
+| `CALayerHost` (remote layer client) | ❌ | Same — layer attached, blank. Ableton process isolation blocks cross-process compositor sharing |
+| `CGSMainConnectionID()` | ✅ compiles | Returns valid ID but CAContext still doesn't render cross-process |
+| `NSMachBootstrapServer` | ❌ deprecated | Not needed; use IPC socket to transfer contextId as string |
+| `CARemoteLayerServer` | ❌ wrong API | Does NOT share a hidden NSWindow. See FAILED-APPROACHES #10 |
+| `posix_spawn` | ✅ | Reliable for spawning Helper from plugin process |
+| `shm_open` / `mmap` | ✅ | Cross-process shared memory for audio — works reliably |
+| `sem_open` | ✅ | Named semaphores for audio sync — works reliably |
+
+### JUCE 8 APIs
 | API | Works? | Notes |
 |---|---|---|
-| `CAContext contextWithCGSConnection:options:` | | |
-| `CALayerHost` | | |
-| `CGSMainConnectionID()` | | |
-| `NSMachBootstrapServer registerPort:name:` | | |
-| `CARemoteLayerServer sharedServer` | | |
-| `posix_spawn` | | |
-| `shm_open` / `mmap` | | |
-| `sem_open` | | |
+| `formatManager.addFormat(new juce::VST3PluginFormat())` | ✅ | Explicit registration required |
+| `formatManager.addFormat(new juce::AudioUnitPluginFormat())` | ✅ | Explicit registration required |
+| `addDefaultFormats()` | ❌ | Deleted in JUCE 8 |
+| `plugin->createEditor()` | ✅ | Message thread only |
+| `juce::Thread::setCurrentThreadPriority()` | ❌ | Removed — use native pthread |
+| `getStringWidthFloat()` | ✅ | Use this; `getStringWidth()` deprecated |
+| `getStringWidth()` | ❌ | Deprecated — use `getStringWidthFloat()` |
+| `juce::Rectangle::getTransformToFit()` | ❌ | Does not exist |
+| `juce::Array<CustomStruct>` initializer list | ❌ | Not supported — use `std::vector<CustomStruct>` |
+| `addChildComponent(comp)` | ✅ | Adds without forcing visible. Use instead of `addAndMakeVisible` when component starts hidden |
+| `addAndMakeVisible(comp)` after `setVisible(false)` | ❌ | `addAndMakeVisible` forces `setVisible(true)` — invisible comp sits on top eating mouse events |
+| `juce::TreeView` + `TreeViewItem` | ✅ | Working; custom `LookAndFeel` needed for arrow rendering |
+| `juce::File::getSpecialLocation(userHomeDirectory)` | ✅ | Returns T7 Shield path |
+
+### macOS Gotchas
+| Issue | Notes |
+|---|---|
+| `MSG_NOSIGNAL` | Linux only → use `signal(SIGPIPE, SIG_IGN)` + `SO_NOSIGPIPE` |
+| Two processes same `shm_open` name | Both crash — scanner must wait for live Helper to exit first |
+| `NSApplicationActivationPolicyRegular` | Steals focus from DAW — use `Accessory` |
+| `activateIgnoringOtherApps:YES` | Switches away from Ableton — use `orderFrontRegardless` |
 
 ---
 
-## ABLETON LOG COMMANDS (Claude Code: run when asked)
+## ABLETON LOG COMMANDS
 
 ```bash
-# Full plugin bridge log
-grep -i "pluginbridge\|helper\|contextId\|CALayerHost\|gui_ready\|layer\|GUI\|loaded\|crashed" \
-  ~/Library/Preferences/Ableton/Live\ 12.4/Log.txt | tail -30
+# PluginBridge debug log (live)
+tail -f ~/Library/PluginBridge/debug.log
+
+# Crash reports
+ls -lt ~/Library/Logs/DiagnosticReports/ | grep -i ableton | head -5
 
-# Helper process check  
+# Helper process
 ps aux | grep PluginBridgeHelper
 
-# Blocklist content
+# Blocklist
 cat ~/Library/PluginBridge/blocklist.txt 2>/dev/null || echo "(empty)"
 
-# Find helper binary
-find ~/Library/Audio/Plug-Ins/VST3/PluginBridge.vst3 -name "PluginBridgeHelper" -type f
+# Safety DB
+cat ~/Library/PluginBridge/safety_db.json | python3 -m json.tool | head -30
 
 # Test helper manually
-~/Library/Audio/Plug-Ins/VST3/PluginBridge.vst3/Contents/Resources/PluginBridgeHelper.app/Contents/MacOS/PluginBridgeHelper --test "/Library/Audio/Plug-Ins/VST3/FabFilter Pro-Q 4.vst3"; echo "EXIT: $?"
+~/Library/Audio/Plug-Ins/VST3/PluginBridge.vst3/Contents/Resources/PluginBridgeHelper.app/Contents/MacOS/PluginBridgeHelper --scan "/Library/Audio/Plug-Ins/VST3/FabFilter Pro-Q 4.vst3"; echo "EXIT: $?"
+```
+
+---
+
+## ERROR REPORT TEMPLATE (Claude Code fills when something breaks)
+
+### Build Errors
 ```
+[Full compiler error — not just the first line. Include file + line number + 5 lines context]
+[What the code is trying to do at that line]
+```
+
+### Runtime Errors
+```
+[Exact behavior: what user sees, what should happen instead]
+[Relevant debug.log lines]
+[Helper process state]
+```
+
+### Claude Code's Analysis
+```
+[Root cause hypothesis]
+[What was already tried]
+[Verified API facts]
+```
+
+**DO NOT just report "it doesn't work." Always provide the above.**
 
 ---
 
 ## WORKFLOW
 
 ```
-1. ML Intern wants to write code using [API/approach]
+1. ML Intern wants to use [API/approach]
 2. ML Intern asks: "Claude Code — verify [API] works. Fill MACHINE-CONTEXT.md"
-3. Claude Code: writes test, runs it, fills this file, pushes to HF repo
-4. ML Intern: reads this file, writes code KNOWING it works on the target machine
+3. Claude Code: writes test, runs it, fills verified API table, pushes
+4. ML Intern: reads this file, writes code based on FACTS not assumptions
 5. ML Intern: pushes code to HF repo
-6. Claude Code: pulls, builds, tests, updates this file with results
+6. Claude Code: pulls, builds, tests, updates BUILD STATE + RUNTIME STATE sections
 7. If error: Claude Code fills ERROR REPORT section with full diagnostic
-8. ML Intern reads diagnostic, writes fix based on FACTS not guesses
+8. ML Intern reads diagnostic, writes fix based on FACTS
 9. Repeat until working
 ```
 
@@ -157,11 +204,11 @@ find ~/Library/Audio/Plug-Ins/VST3/PluginBridge.vst3 -name "PluginBridgeHelper"
 
 ## NOTES FOR ML INTERN
 
-- **Never assume an API works** — always ask Claude Code to verify first
+- **Never assume an API works** — always ask Claude Code to verify first via this file
 - **Never use deprecated macOS APIs** without Claude Code confirming they still function
-- **Always check Ableton log** after runtime test — silent failures are common
 - **ObjC++ (.mm) files** — only use if Claude Code confirms the ObjC API is available in current SDK
 - **Window management on macOS** — always ask Claude Code to test the specific approach (fullscreen is tricky)
 - **JUCE version matters** — APIs change between JUCE 7 and 8. Claude Code can check `JUCE/modules/` headers
 - **Never push more than ONE conceptual change at a time** — if it breaks, you know exactly what caused it
 - **If you don't know why something failed, DON'T GUESS** — ask Claude Code to investigate and fill the error report
+- **CAContext/CALayerHost is a dead end** — already tried, documented in FAILED-APPROACHES #10. Do not revisit.

SYNC.md

@@ -2,90 +2,182 @@
 
 ---
 
-## STATUS: v0.4.1 — GUI fix pushed (2026-05-17)
+## STATUS: v0.5.2 — Plugin Picker UI + Safety System working (2026-05-17)
 
 Build: ✅ Clean  
-GUI: Awaiting first real test in Ableton
+GUI: ✅ Verified — Pro-Q 4, God Particle, Little MicroShift all load with full GUI  
+Crashes: ✅ None since fix (last was May 16, pre-fix)  
+MCP: ✅ Running on port 16620
 
 ---
 
-## WHAT WAS FIXED
+## WHAT WAS FIXED (2026-05-17 session)
 
-### Root cause: Wrong cross-process layer API + invisible window
+### 1. Plugin Picker UI — Ableton-style manufacturer tree
 
-Three bugs in the original v0.4 GUI approach:
+**Problem:** Old flat PopupMenu list was cluttered, no search, no grouping.
 
-**Bug 1 — Wrong API (main bug):**  
-`CARemoteLayerServer` + `NSMachBootstrapServer` does NOT share a hidden NSWindow's content to another process. The correct private-but-stable API is:
-- **Helper (server):** `CAContext contextWithCGSConnection:options:` — wraps a `CALayer` and exposes it as a `uint32_t contextId`
-- **Host (client):** `CALayerHost.contextId = contextId` — a `CALayer` subclass that renders the remote context inline
+**Solution:** Replaced with inline `juce::TreeView` browser:
+- Manufacturer folders with ▶/▼ triangle arrows (custom `LookAndFeel::drawTreeviewPlusMinusBox`)
+- Search box that hides tree and shows flat filtered list
+- Safety badges: ✓ safe, `audio only`, `⚠ blocked`
+- Embedded inline in the editor (no CallOutBox) — editor resizes to fit
+- Ableton-matching dark theme (`0xff1e1e1e` bg, `0xff2d6299` selection)
 
-**Bug 2 — NSWindow never visible:**  
-The window was created but `orderFront:` was never called. Even if CARemoteLayerServer had worked, the WindowServer wouldn't composite a window that isn't ordered front. Fix: window is positioned off-screen at `(-32000, -32000)` and `orderFront:` is called.
+**Files:** `Source/Plugin/PluginPickerComponent.h/.mm` (new), `Source/Plugin/PluginBridgeEditor.h/.mm` (modified)
 
-**Bug 3 — NSMachBootstrapServer deprecated:**  
-Not needed anymore. The `contextId` (uint32_t) is sent directly over the existing IPC socket as the `layerPortName` string field (decimal number). No Mach port bootstrapping required.
+---
 
-### Files changed
-| File | What changed |
-|---|---|
-| `Source/Shared/PrivateCA.h` | **New** — declares `CAContext`, `CALayerHost`, `CGSMainConnectionID` |
-| `Source/Helper/HelperPluginHost.h` | `remoteLayerServer` → `caContext` |
-| `Source/Helper/HelperPluginHost.mm` | `showGui()` uses `CAContext`; `hideGui()` releases properly; window `orderFront:`  |
-| `Source/Plugin/PluginBridgeEditor.mm` | `connectRemoteLayer()` uses `CALayerHost`; no Mach port lookup |
+### 2. UI Freeze Bug — `addAndMakeVisible` vs `addChildComponent`
+
+**Root cause:**  
+```cpp
+// WRONG — addAndMakeVisible internally calls setVisible(true),
+// overriding the prior setVisible(false). The empty searchList
+// sits invisibly on top of the entire TreeView, intercepting all
+// mouse events. Only TextEditor (native macOS input) still worked.
+searchList.setVisible(false);
+addAndMakeVisible(searchList);
+
+// CORRECT:
+addChildComponent(searchList);  // stays hidden until needed
+```
+
+**Symptom:** After picker opened — could scroll/click nothing. Only the search box accepted input. Selecting Pro-Q 4 showed "audio only / unsafe" because the picker was broken, not the safety system.
+
+**Fix:** `addChildComponent(searchList)` in `PluginPickerComponent` constructor.
+
+**File:** `Source/Plugin/PluginPickerComponent.mm`
 
 ---
 
-## ARCHITECTURE (v0.4.1)
+### 3. Safety DB Corruption — Background Scan vs Live Helper Shared Memory Conflict
+
+**Root cause:**  
+Background scanner spawns `PluginBridgeHelper --scan <path>` for each plugin.  
+If the main Helper is already running (serving an active plugin), both processes fight over the same shared memory name (`shm_open`) → scan subprocess crashes immediately → every plugin gets marked UNSAFE.
 
+**Fix 1 — Wait loop before each scan:**
+```cpp
+// In startBackgroundScan() loop, before runPluginScan():
+while (helper.isHelperRunning() && scanRunning.load())
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+if (!scanRunning.load()) break;
 ```
-PluginBridge.vst3 (inside Ableton)
-├── PluginBridgeProcessor.cpp — spawns Helper, shared memory audio, IPC
-├── PluginBridgeEditor.mm — displays CALayerHost (contextId from Helper)
-├── HelperConnection.cpp — Unix socket IPC to Helper
-├── McpServer.cpp — HTTP MCP on port 16620
-└── Blocklist.h — persistent blocklist
-
-PluginBridgeHelper.app (separate crash-safe process)
-├── main.cpp — JUCE app, --pid argument
-├── HelperPluginHost.mm — loads plugin, CAContext GUI server
-├── HelperIPC.cpp — receives commands, sends notifications
-└── SharedAudioBuffer.h — shared memory
+
+**Fix 2 — DB recovery:**  
+Python script wiped all corrupted UNSAFE entries. Only genuine entries kept  
+(PluginBridge itself, which correctly fails its own scan).
+
+**File:** `Source/Plugin/PluginBridgeProcessor.cpp`
+
+---
+
+### 4. Duplicate Plugins in Picker — VST3 + AU + System + User dirs
+
+**Root cause:**  
+`getInstalledPluginFiles()` scanned all four directories:
+- `/Library/Audio/Plug-Ins/VST3` (system)
+- `~/Library/Audio/Plug-Ins/VST3` (user)
+- `/Library/Audio/Plug-Ins/Components` (system AU)
+- `~/Library/Audio/Plug-Ins/Components` (user AU)
+
+FabFilter Pro-Q 4 appeared 4× (2 VST3 paths × 2 AU paths). Showed as 2 per manufacturer folder.
+
+**Fix:** Deduplicate by stem name using `std::set<std::string>`, priority order:
 ```
+system VST3 → user VST3 → system AU → user AU
+```
+First match for a given stem name wins. AU entry is skipped if VST3 already seen.  
+System paths preserved because safety DB uses `/Library/` paths.
 
-**How GUI works (v0.4.1):**
-1. Helper loads plugin → creates editor → embeds NSView in off-screen NSWindow
-2. NSWindow ordered front at (-32000, -32000) — invisible to user, visible to compositor
-3. `CAContext.layer = window.contentView.layer` — exposes the layer tree cross-process
-4. Helper sends `contextId` (uint32_t as decimal string) via `gui_ready` IPC notification
-5. Host creates `CALayerHost(contextId)` — a CALayer that renders the remote context
-6. CALayerHost added as sublayer to JUCE editor's NSView → plugin GUI appears embedded
+**File:** `Source/Plugin/PluginBridgeProcessor.cpp`
 
 ---
 
-## BUILD
+### 5. Wrong Manufacturer Names — Copyright Strings as Folder Names
 
-```bash
-cd ~/pluginbridge && git pull
-cd build && cmake --build . --config Release 2>&1 | tail -30
+**Root cause:**  
+`getPluginManufacturer()` read `CFBundleGetInfoString` and extracted everything after the comma:  
+`"FabFilter Pro-Q 4.02, Copyright © 2002-2025 FabFilter"` → `"Copyright © 2002-2025 FabFilter"`  
+This full copyright string became the folder name, and different copyright years split one vendor into multiple folders.
+
+Some plugins put their version string as the `"vendor"` field in `moduleinfo.json` (e.g. `"16.7.33.200"`).
+
+**Fix — New extraction priority:**
+1. `NSHumanReadableCopyright` → `cleanManufacturer()` strips "Copyright © YYYY-YYYY " prefix → `"FabFilter"`
+2. `CFBundleGetInfoString` → extract **before** the comma → first word → `"FabFilter"`
+3. `CFBundleIdentifier` → second segment capitalised → `"com.fabfilter.Pro-Q.4"` → `"Fabfilter"`
+4. `moduleinfo.json "vendor"` → cleaned
+5. Filename first word fallback
+
+`cleanManufacturer()` also rejects pure version strings (containsOnly digits/dots).
+
+**File:** `Source/Plugin/PluginBridgeProcessor.cpp`
+
+---
+
+## ARCHITECTURE (v0.5.2)
+
+```
+PluginBridge.vst3 (inside Ableton)
+├── PluginBridgeProcessor.cpp   — plugin lifecycle, safety check, background scan, MCP
+├── PluginBridgeEditor.mm       — top bar + inline PluginPickerComponent + plugin editor
+├── PluginPickerComponent.mm    — manufacturer TreeView, search, safety badges
+├── HelperConnection.cpp        — Unix socket IPC + shared memory audio routing
+├── McpServer.cpp               — HTTP MCP on port 16620
+├── PluginSafetyDB.h            — JSON-backed safe/unsafe/unknown per plugin
+└── Blocklist.h                 — persistent blocklist for crash-prone plugins
+
+PluginBridgeHelper.app (separate crash-safe process, bundled in .vst3/Resources/)
+├── main.cpp                    — --load <path>, --scan <path>
+├── HelperPluginHost.mm         — loads plugin, audio via shared memory
+└── HelperIPC.cpp               — command/response over Unix socket
 ```
 
-## TEST AFTER BUILD
+**Load flow for SAFE plugin:**
+1. User opens picker → selects plugin
+2. `loadPlugin()` checks PluginSafetyDB:
+   - **Unknown** → spawns `PluginBridgeHelper --scan` (waits for live Helper to exit first)
+   - **Safe** → proceed
+   - **Unsafe** → load in Helper for audio-only mode
+3. Helper also loads plugin for out-of-process audio routing
+4. Plugin loaded in-process → `createEditor()` → embedded in PluginBridge editor window
+
+**Load flow for UNSAFE plugin (audio-only mode):**
+1. Plugin marked unsafe in DB (crashed during scan)
+2. Loaded only in Helper process — audio routing via shared memory
+3. No in-process load → no GUI → `showAudioOnlyUI()` shown instead
+4. MCP still works (183 params etc.) — all parameter control via MCP tools
 
-1. Restart Ableton (plugin is auto-installed to `~/Library/Audio/Plug-Ins/VST3/`)
-2. Clear blocklist: `rm -f ~/Library/PluginBridge/blocklist.txt`
-3. Load PluginBridge → select Pro-Q 4 → GUI should appear inside the editor window
-4. Test Kickstart 2 → should NOT crash Ableton (Helper crashes, gets blocklisted)
+---
 
-## IF GUI STILL DOESN'T SHOW
+## BUILD
 
-Check Ableton log for contextId and CALayerHost messages:
 ```bash
-grep -i "pluginbridge\|contextId\|CALayerHost\|gui_ready" ~/Library/Preferences/Ableton/Live\ 12.4/Log.txt | tail -30
+cd "/Volumes/T7 Shield/Users/Aditya/pluginbridge/build"
+cmake --build . --target PluginBridge_VST3 -- -j4
 ```
 
-The log should show:
-- `HelperPluginHost: GUI ready — contextId=<number> size=<W>x<H>`
-- `PluginBridgeEditor: CALayerHost connected (contextId=<number> <W>x<H>)`
+Auto-installs to `~/Library/Audio/Plug-Ins/VST3/PluginBridge.vst3`
 
-If contextId is 0 or either line is missing → the specific step that's failing is identified.
+## KEY FILES
+
+| File | Role |
+|---|---|
+| `Source/Plugin/PluginPickerComponent.h/.mm` | Inline plugin browser (new in v0.5) |
+| `Source/Plugin/PluginBridgeEditor.h/.mm` | Main editor, picker toggle, plugin embed |
+| `Source/Plugin/PluginBridgeProcessor.cpp` | `getInstalledPluginFiles()`, `getPluginManufacturer()`, `startBackgroundScan()` |
+| `~/Library/PluginBridge/safety_db.json` | Runtime safety cache (safe/unsafe/unknown per path+mtime) |
+| `~/Library/PluginBridge/debug.log` | Timestamped per-session log |
+
+## VERIFIED WORKING (2026-05-17)
+
+- ✅ Pro-Q 4 — full GUI (761×405)
+- ✅ Cradle The God Particle — full GUI (666×302)
+- ✅ Little MicroShift — full GUI (855×359)
+- ✅ LIMITER — full GUI (855×572)
+- ✅ Picker tree: manufacturer folders collapse/expand
+- ✅ Search: filters list, hides tree
+- ✅ No duplicates in picker
+- ✅ Manufacturer names clean (FabFilter, Valhalla, etc.)