Logic Pro MCP server for stateful DAW control, live readback, MIDI, plugins, and safety gates.
io.github.MongLong0214/logic-pro-mcp β MCP Server for Logic Pro
A local Model Context Protocol (MCP) server for stateful, fail-closed Logic Pro control and live project readback. It is intended for AI music production workflows where Claude Code, Claude Desktop, Cursor, VS Code, and custom AI agents interact with Logic Pro.
π οΈ Key Features
Stateful control of Logic Pro
Fail-closed behavior
Live project data inspection and readback
Create tracks and write MIDI
Operate transport and mixer state
π Use Cases
AI-assisted music production in Logic Pro
Programmatic track creation and MIDI generation
Automated manipulation of transport and mixer settings
Verifying results using live project data
β‘ Developer Benefits
Exposes Logic Pro operations via MCP
Suitable for Claude Code, Claude Desktop, Cursor, VS Code, and custom AI agents
Supports iterative workflows with live project state verification
β οΈ Limitations
Described as local (local MCP server) for Logic Pro control and readback
Logic Pro MCP Server for Claude, Cursor, and AI Agents
A local Model Context Protocol (MCP) server that lets Claude Code, Claude Desktop, Cursor, Codex, VS Code, and other MCP clients control Logic Pro for AI music production: create tracks, write MIDI, operate transport and mixer state, inspect live project data, and verify results.
Logic Pro MCP has been officially selected for Anthropic's Claude for Open Source program β recognition from the makers of Claude that this project is open-source work worth supporting. This server is built with Claude, for Claude-powered agents β and is now officially supported by the program.
imageimage
An 82 BPM D-minor lofi loop composed live in Logic Pro 12.3 by the MCP β tempo, three MIDI parts, a Drummer, and playback, all from prompts. βΆ Watch the 36-sec demo (with sound)
Logic Pro MCP Server gives Claude, Cursor, Codex, and other MCP clients a structured way to control Logic Pro without brittle keyboard macros. Logic Pro does not ship a first-party API for agentic composition, session setup, mixer operations, or live project readback, so Logic Pro MCP fills that gap by combining 7 native macOS control channels (CoreMIDI, Accessibility, AppleScript, CGEvent, MCU, Scripter, MIDI Key Commands β Sources/LogicProMCP/Channels/Channel.swift) behind one MCP interface, then wrapping every high-risk operation in explicit state, confirmation, and verification contracts.
The result is not "screen automation with prompts." It is a structured server for DAW agents: tools mutate, resources read, evidence is labeled, and uncertain outcomes stay uncertain instead of being reported as success.
code
You: "Make a 4-bar techno loop in A minor at 140 BPM"
MCP client β logic_tracks.record_sequence {
bar: 1, tempo: 140,
notes: "45,0,95;57,107,95;45,214,95;..."
}
MCP client β logic_tracks.set_instrument {
index: 0, path: "Electronic Drums/Roland TR-909"
}
Logic Pro MCP: region imported, instrument routed, readback exposed through resources.
At a Glance
Counts below are read from the current source tree with the command shown; re-run it after pulling to reproduce.
Latest Logic Pro first β desktop Logic Pro (com.apple.logic10, /Applications/Logic Pro.app). Apple Creator Studio Logic Pro Creator Studio (com.apple.mobilelogic, /Applications/Logic Pro Creator Studio.app) is recognised, not supported. Desktop Logic Pro is the only variant the release qualification matrix covers (shipVariants = [.desktop]), and the only one this release supports. Without LOGIC_PRO_BUNDLE_ID the server can still select Creator Studio: it targets the frontmost Logic; failing that a running one, then an installed one, desktop first in both. So a Creator Studio that is frontmost, or is the only Logic running, becomes the target, with no qualification evidence behind it. Set LOGIC_PRO_BUNDLE_ID=com.apple.logic10 to keep the server on desktop Logic Pro. Logic Pro 13.0 is the current first-class target; v3.19.0 carries bounded ko-KR read-only evidence on build 7801, not whole-release or cross-locale qualification. The broader live evidence remains on Logic 12.3 build 6674; older versions down to the 12.0.1 floor are best-effort
Release state
Source candidate: v3.19.0, targeting 2026-11-14 UTC. Current published stable: v3.18.0
If this project helps you make music with Claude, Cursor, Codex, or any MCP client, star the repo. It helps the project reach more Logic Pro users and maintainers.
Want to contribute? Start with the Contributing Guide and the open issues. Many docs, examples, validation tests, and CLI-message improvements do not require Logic Pro.
Why It Exists
Most Logic Pro automation attempts fall into one of three traps:
Prompt-only recipes that drift away from the real tool surface.
Keyboard macro automation that can click the wrong target and still look successful.
Single-channel control that can write to Logic but cannot reliably read what Logic actually did.
Logic Pro MCP uses a different model. It routes each operation to the strongest available channel, exposes live state through MCP resources, and forces callers to handle three outcomes: confirmed, uncertain, or failed.
What It Controls
Area
What agents can do
Safety/readback model
Transport
Play, stop, record, locate, cycle, metronome, tempo
CoreMIDI/AX routing with live logic://transport/state readback
Tracks
Create, delete, duplicate, select, rename, mute, solo, arm, set instruments
.mid imports are constrained to server-managed temp files and must create a live track
Mixer
Volume, pan, plugin snapshots, guarded stock plugin insertion, MCU-driven fader bank walk
AX writes with same-surface readback for volume/pan; MCU writes verify by LCD upper-row redraw; occupied plugin slots refuse replacement
Library
Scan Logic's instrument library and load patches by path
Disk/AX inventory is cached; disk scan dedupes user/app-bundle .patch candidates and resolve_path classifies kind/source/loadable before set_instrument
Navigation
Bars, markers, zoom, view toggles
Marker navigation is target-faithful; cold-cache misses return failure instead of "next marker"
Standalone bounce terminates unsupported without UI; guarded export_run is the automated artifact path
Agent-Grade Surfaces
Tools are for actions and local artifact checks. The public write surface is intentionally small: logic_transport, logic_tracks, logic_mixer, logic_plugins, logic_midi, logic_edit, logic_navigate, logic_project, and logic_system. logic_audio is read-only and verifies exported files after Logic writes them.
Resources are for state. Clients should read logic://transport/state, logic://tracks, logic://mixer, logic://project/info, logic://project/audit, logic://project/cleanup-plan, logic://midi/ports, and related resources instead of burning tool calls on polling.
Evidence is separated from claims. The README points to release evidence, current-main verification, and live media artifacts instead of implying that a successful command equals a verified Logic state.
Trust Model
Honest Contract envelopes: mutating operations return State A confirmed, State B uncertain with a reason, or State C failure with an error.
Verified plugin apply-back: logic_plugins.* uses HC v2 (hc_schema: 2) and returns State A only after project identity, target track, physical insert slot, plugin identity, and readback all agree.
Fail-closed targets: dangerous mixer, marker, track, MIDI import, and plugin operations require explicit targets and validation.
Confirmation levels: destructive/project and plugin insertion flows require explicit confirmation metadata before execution.
Provenance labels: read surfaces expose source, freshness, and evidence labels instead of forcing clients to guess.
Installer hardening: Homebrew pins SHA256; the shell installer refuses to run without explicit hash/team pins unless same-origin provenance is explicitly allowed.
Release honesty: v3.19.0 is the source candidate targeting 2026-11-14 UTC; v3.18.0 remains the current published stable until the candidate's tag, assets and public-byte readback exist. README claims stay tied to shipped artifacts, candidate-tree tests, or explicitly linked live evidence.
Locales
Logic Pro ships ten UI locales, and this server tracks all ten as the default scope (not just en/ko): de-DE, en-US, es-ES, fr-FR, it-IT, ja-JP, ko-KR, pt-BR, zh-CN, zh-TW. UI-string matching (menu items, header labels, dialog buttons) lives in docs/locale/ui-labels.json, the canon index every locale-sensitive locator derives from.
Each of the 203 canon labels carries a per-locale coverage: measured (read from a live, running Logic window and recorded with the host, date, and AX role/attribute), derived (computed from Apple's own .strings tables by Scripts/derive_label_variants.py, not read from a live window), unmeasured, or retired (one label, headerPanHint, superseded by sliderPanHint and kept in the canon with its reason). Measured counts per locale, out of 203 canon labels (python3 -c "import json,collections; d=json.load(open('docs/locale/ui-labels.json')); c=collections.Counter(); [c.update([(l,v) for l,v in e['coverage'].items() if v=='measured']) for e in d['labels'].values()]; print(c)"):
Locale
Measured
Derived
Unmeasured
Retired
en-US
45
156
1
1
ko-KR
50
147
5
1
ja-JP
37
154
11
1
de-DE
44
144
14
1
es-ES
7
177
18
1
fr-FR
6
175
21
1
it-IT
6
175
21
1
pt-BR
5
178
19
1
zh-CN
7
169
26
1
zh-TW
6
166
30
1
A derived label has not been read from a running Logic in that locale; it is Apple's own string for that key, which is a strong signal but not a live observation. The roadmap (docs/roadmap/README.md) tracks per-feature live locale campaigns (mixer routing graph, MCU bank walk, record-arm key-command setup, and others) as they are driven against real Logic sessions in each language.
Quick Start
Prerequisites: macOS 14+ for the MCP server, desktop Logic Pro (the current first-class target is 13.0; v3.19.0 has bounded build-7801 ko-KR read-only evidence rather than whole-release or cross-locale qualification, while the broader live corpus remains on 12.3 build 6674), and an MCP client that can launch a stdio server. Older Logic versions down to the 12.0.1 floor are best-effort. Published GitHub Actions/Homebrew assets are universal (arm64 + x86_64) and do not require Xcode. Bounce/export uses the bundled native CGEvent helper with no third-party click binary.
Logic Pro version policy. Logic Pro MCP tracks the latest Logic Pro release as its first-class target and prioritizes validation against it; the current release's exact evidence boundary is stated above. When Apple ships a new Logic Pro version, supporting it is the top priority β the Accessibility/UI tree shifts between releases, so the newest version is where fixes land first. Older versions above the 12.0.1 floor remain best-effort and may lose parity as those UI surfaces change.
The package manifest uses Swift tools 6.0 for compatibility. Current source verification uses
Command Line Tools with Swift 6.2 in CI.
The source candidate is v3.19.0, with a targeted release date of 2026-11-14 UTC; the current published stable remains v3.18.0. The candidate's per-release detail β everything added, changed, and fixed since v3.18.0, along with every stated limit β is in CHANGELOG.md; this README does not claim publication before the tag, assets and public-byte readback exist.
The Homebrew formula pins both the release tarball URL and its SHA256; Homebrew itself is a trusted delivery channel with its own signature chain. This is the hardened path for production installs. (On Homebrew older than 6.0 the brew trust step does not exist β skip it.)
For source-tree development, build locally:
bash
git clone https://github.com/MongLong0214/logic-pro-mcp.git
cd logic-pro-mcp
swift build -c release
To upgrade an existing install: Homebrew installs use brew update && brew upgrade logic-pro-mcp; source builds use git pull && swift build -c release; pinned shell-installer installs re-run the installer with the new release's pins (below). Published binaries are unsigned (no Apple Developer ID; see SECURITY.md), so treat a freshly built or reinstalled binary as a new executable identity β Accessibility and Automation grants may need to be granted again after an upgrade (docs/TROUBLESHOOTING.md covers removing stale TCC entries and re-granting them).
2. Register with an MCP client
Claude Code:
bash
claude mcp add --scope user logic-pro -- LogicProMCP
Generic MCP client config (Claude Desktop, Cursor, VS Code, Codex CLI, Codex Desktop, and any other client that accepts a stdio MCP server entry β each client's own config file location and key names are documented by that client, not here):
If you built from source, point the command at .build/release/LogicProMCP.
3. Inspect readiness
Run the local checks:
bash
LogicProMCP --check-permissions
The installer also performs its bounded permission check. Missing capabilities terminate explicitly;
it does not ask for a manual grant or attestation. The bundled Key Commands mapping and Scripter
assets remain references, but mapped send-only operations report unattended_unavailable because
their Logic-side setup and outcomes cannot be established programmatically. Raw MIDI bypass calls
remain available when their virtual transport is ready.
4. Test from your agent
Ask the client:
Check Logic Pro MCP health and show all ready channels.
Expected: only programmatically qualified channels report ready; Key Commands and Scripter mapped
operations remain unattended_unavailable rather than becoming ready from an operator assertion.
Pinned shell installer
The installer is fail-closed: it refuses to run without an explicit
LOGIC_PRO_MCP_SHA256 archive pin. Copy it from the
LogicProMCP-macOS-universal.tar.gz entry in the release's SHA256SUMS.txt.
It verifies the downloaded LogicProMCP-macOS-universal.tar.gz archive before extraction:
Accessibility: enable the app that launches LogicProMCP (Claude Code, Terminal, Cursor, Codex, or Claude Desktop).
Automation: allow that app to control Logic Pro and, separately, System Events β macOS treats these as two distinct grants, and granting Logic Pro does not imply System Events.
If you use Apple Creator Studio Logic Pro (com.apple.mobilelogic), grant Automation separately from desktop Logic Pro (com.apple.logic10); macOS treats them as distinct apps even though both appear as "Logic Pro" in some pickers.
--check-permissions and LogicProMCP doctor report each grant as a three-state value (granted / not_granted / not_verifiable, never a bare Bool) and cover: Accessibility, Automation β Logic Pro, Automation β System Events, and PostEvent (Input Monitoring, needed by the CGEvent bounce/click fallback).
bash
LogicProMCP --check-permissions
LogicProMCP doctor
Because published release binaries are unsigned, every new build or reinstall is a new executable identity to macOS: expect to re-grant Accessibility/Automation after upgrading, not only on first install. If permissions look wrong after reinstalling, remove the stale TCC entries in System Settings and grant them again to the actual launcher app (docs/TROUBLESHOOTING.md).
Forcing a Logic Pro variant
bash
LOGIC_PRO_BUNDLE_ID=com.apple.logic10 LogicProMCP
Valid values: com.apple.logic10 (desktop) and com.apple.mobilelogic (Creator Studio). Only desktop Logic Pro is qualified for this release. Forcing com.apple.mobilelogic points the server at Creator Studio anyway, with no qualification evidence behind it, and on a machine where Creator Studio is the only Logic installed, LogicProMCP doctor fails logic.installation with reason unshipped_variant_only.
Using LogicProMCP as a library
The package also exposes the LogicProMCP target as a library product named LogicProMCPKit (since v3.17.0), so a Swift application can link the same code the server runs instead of driving the server as a separate stdio process.
The public surface is small and deliberate. Almost all of the module, including the Accessibility readers (AXLogicProElements, AXHelpers, AccessibilityChannel), the channels, the state cache, and the dispatchers, is internal and is not reachable through the library. What is public:
PluginInspector (in Accessibility/PluginInspector.swift): the plug-in window Setting-menu inspector. Static entry points enumerateMenuTree, parsePath, encodePath, resolveMenuPath, selectMenuPath, decodeAUVersion, findPluginWindow, identifyPlugin, openPluginWindow, and closePluginWindow. Every entry point that touches a window or a menu takes a caller-supplied PluginPresetProbe or PluginWindowRuntime of closures; the module ships no public production runtime, so nothing here reaches Logic on its own.
The data types those entry points use: PluginPresetNodeKind, PluginPresetNode, PluginPresetCache, PluginPresetInventory, MenuHop, PluginMenuItemInfo, ScannerWindowRecord, PluginPresetProbe, PluginWindowRuntime, PluginError, AXUIElementSendable, and the constant maxPluginMenuDepth.
AXPluginInstanceIdentity (in Accessibility/AXPluginInstanceIdentity.swift, #972): a read-only census for plug-in hosts. census(pluginName:identifierPrefix:) returns an AXSnapshot of the Mixer strips whose insert slot names the plug-in (ordinal, name, slot positions) and of the open plug-in editor windows (title, and the first kAXIdentifier under the given prefix), plus Diagnostics saying what was found. It issues no actions. Three outcomes are distinguishable: an empty snapshot with a note, a partial strip read (stripsReadWhole is false, so ordinals are not trustworthy), and a failed editor-window read, which throws CensusError.windowsReadFailed instead of returning zero windows. The #972 measurement was on Logic Pro 12.3.1 with the Mixer docked in the main window (X).
The Library inventory data model (in Accessibility/LibraryAccessor.swift): LibraryNodeKind, LibraryNode, LibraryRoot, and TreeProbe. The LibraryAccessor enum that scans and selects patches is internal, so only its data model is reachable.
The product name is LogicProMCPKit; the module you import is LogicProMCP. from: "3.17.0" is the floor that guarantees the product β every tag before it predates it.
Setup Doctor
Getting an agent to reliably drive Logic Pro is mostly a permissions-and-environment problem: TCC grants, the right Logic version, a live document, a registered control surface, no blocking modal. LogicProMCP doctor is a first-class, intent-aware readiness platform built for exactly this β not a boolean "is it installed" check, but a diagnostic that tells you which capabilities are ready, which are blocked, why, and what to do next β and never reports green for something it could not actually verify.
bash
LogicProMCP doctor # human-readable report, color when a TTY
LogicProMCP doctor --json # stable machine contract (schema logic_pro_mcp_doctor.v5)
LogicProMCP doctor --strict # exit code encodes overall status (CI gate)
LogicProMCP doctor --profile core --client claude-desktop
LogicProMCP doctor --check-updates # opt-in: also checks for a newer release
Intent-aware profiles. You are not forced through checks you'll never use. --profile scopes the required set to how you actually drive Logic β core (transport/tracks/AX), mixer, keycmd, legacy-scripter, or full. --client (claude-code, claude-desktop, cursor, vscode, terminal, custom) adds the registration checks that matter for that host. Aggregate status is scoped to the selected profile's required checks, so an MCU-only workflow isn't marked unhealthy for a Scripter gap it will never hit.
Capability readiness, not just check pass/fail. Every check is mapped to the capabilities it gates (track_management, midi_import, mixer_ax, mixer_mcu, keycmd_only_ops, verified_plugin_applyback, project_lifecycle, β¦). The report tells you "MIDI import is ready; verified-plugin apply-back is blocked by PostEvent" β the language an agent (or an operator) can act on directly.
Causal chain β fix_plan and blocked_by. Only non-pass checks with a concrete remediation are ordered into fix_plan (the next actions, most-unblocking first), and each downstream check names the upstream check that blocked_by it β so you fix the root, not the symptom. When the highest-priority outcome has a concrete remediation, the headline restates that next action. A non-remediable failure remains visible as a Terminal outcome; a non-remediable warning or manual result remains visible as an Unresolved outcome, but neither invents an action or appears in fix_plan.
Honesty is the whole point. A check that could not run (missing capability, unreadable TCC db) is reported as an explicit skipped with a reason β it is never silently folded into a pass. Legacy manual-channel assertion/skip records remain readable for compatibility, but never qualify unattended readiness or change the selected doctor profile. TCC findings are redacted to service/principal/state summaries β no raw local paths in the report.
Strict exit codes (--strict, for CI/agent gating): 0 ok Β· 1 failed Β· 2 manual_action_required Β· 3 degraded. Codes 2/3 are status codes, not usage errors, and sit below the sysexits.h range.
A real (redacted) run on a box mid-setup:
jsonc
{"schema":"logic_pro_mcp_doctor.v5","doctor_profile":"core","status":"failed","headline":"Terminal outcome [permissions.accessibility]: Accessibility permission is not granted.","fix_plan":["install.binary_inventory"],"summary":{"total":26,"passed":15,"warnings":1,"failed":2,"skipped":8,"manual":0,"duration_ms":333},"checks":[{"id":"binary.path","status":"pass","category":"installation","severity":"info"}/* β¦ */]}
The same run in a terminal prints a grouped, color-coded report with per-check explanations and any concrete remediation anchors in docs/SETUP.md. The full flag reference, every check explanation, and actionable remediations live in docs/SETUP.md; the --json bytes are a stable contract you can assert against in your own onboarding automation.
Architecture at a Glance
MCP clients launch the Swift stdio server. Dispatchers validate tool parameters, ChannelRouter chooses the strongest available macOS channel, resources expose cached/live state, and high-risk writes return explicit confirmed/uncertain/failed envelopes. The core channels are MCU, Accessibility, AppleScript, CoreMIDI, CGEvent, Scripter, and MIDI Key Commands.
The public docs tree is intentionally scoped: setup, API, troubleshooting, README media, plus public issue PRDs/tickets that explain active or shipped user-visible remediation. Historical release notes, internal PRDs, private ticket boards, spike notes, and local live-evidence work files are kept out of docs/; public release history belongs in CHANGELOG.md, GitHub Releases, merged PRs, and issue history.
Verification
Gate
What it checks
Evidence
CI (every PR merge candidate)
Full deterministic test suite, release build, repo guards
Actions lists the exact merge-candidate validations
Release build
swift build -c release
Runs in CI and in the release workflow
Live E2E
Registered operations against a real, running Logic Pro session with independent readback
Per-release evidence and dated observation records under docs/observations/, linked from the relevant CHANGELOG entries; not run for every commit
README media
Actual Logic Pro screen-capture derivatives
Published under docs/media/
This README does not carry a fixed test-passing count: the suite's size changes every release, and a number here would go stale before the next one. Run swift test --no-parallel locally, or read the CI badge, for the current pass/fail state. Per-feature live-evidence claims (which locale, which Logic build, what was measured and what was not) live in CHANGELOG.md next to the change they support, not here.
Live E2E defaults to the release binary. Protocol/security assertions run on any host; Logic/CoreMIDI-dependent checks skip unless a real Logic Pro session is visible.
API Contracts That Matter
Honest Contract envelope β every mutating op returns State A confirmed, State B uncertain with reason, or State C hard failure with error. See docs/API.md.
HC v2 plugin apply-back β logic_plugins.get_inventory, set_param_verified, and insert_verified add state + hc_schema: 2; State C always carries verified:false, write_attempted, retry safety, and target identity where relevant.
Exact-slot plugin insertion β logic_plugins.insert_verified targets the physical insert index returned by get_inventory, verifies the popup is anchored to that slot, and confirms success only by post-write inventory diff.
Target-faithful navigation β goto_marker returns element_not_found on a cold cache instead of advancing to the next marker.
1-based MIDI channel β send_note, send_cc, and record_sequencech values accept 1..16 to match Logic's UI.
Bounded raw SysEx β send_sysex rejects payloads over 1024 bytes before CoreMIDI routing.
Audible-bounce guardrails β record_sequence refuses unverified GM Device / External MIDI imports, logic://project/audit reports External MIDI tracks with MIDI regions as export blockers, standalone logic_project bounce terminates unsupported, and confirmed export_run is the automated artifact path.
Verified project saves β project.save_as verifies the target .logicx package exists and that existing packages advance modification time.
Live project metadata β logic://project/info promotes live transport tempo, reads sample rate from validated saved project metadata, and falls back to live transport for sample rate only when that saved field is unavailable.
Side-effect-free reads β resources expose state, metadata, and cached inventory without mutating Logic.
Release & Distribution
Stable production releases use one immutable candidate artifact. The dispatch workflow builds it
once with Command Line Tools and validates its installer path on Intel and Apple Silicon runners;
local native qualification then stages and checks those exact bytes. The annotated-tag workflow
downloads that previously qualified artifact, never rebuilds or repackages it, publishes the five
unsigned assets with SHA256 metadata, and verifies the public bytes before registry work begins.
Per-release detail lives in CHANGELOG.md. Security and installer trust tiers are documented in SECURITY.md.
Registry Metadata
The repository ships server.json for the official MCP Registry metadata path. During this source cut, the source candidate is v3.19.0, while server.json and the Homebrew Formula remain pinned to the published registry release (v3.18.0) until hosted v3.19.0 assets and their checksum exist. The record carries discovery tags for Logic Pro, DAW automation, MIDI, Claude/Cursor MCP clients, and music-production agents. It is metadata-only because the registry package schema does not yet model Homebrew formulas or GitHub release tarballs as first-class package types. The install authority remains the pinned GitHub Release/Homebrew path above.
Known Limitations
Tempo typing: transport.set_tempo uses bounded coarse and exact AX slider fallbacks when Logic's inline tempo input does not commit, and fails closed if exact readback still cannot be verified.
MIDI region padding: record_sequence regions start at bar 1 and extend to the target bar using inaudible padding; note timing inside the region is exact, but the region can look longer than the phrase.
External MIDI bounce readiness: MIDI regions on GM Device / External MIDI tracks are not accepted as audible-bounce evidence by project audit. Standalone logic_project bounce is unsupported; use the guarded export_run workflow for automated artifact production.
MIDI Key Commands: Logic 12.2+ does not accept the legacy .plist Key Commands import. The reference cannot establish or read back Logic-side bindings, so keycmd-only mapped operations remain unattended_unavailable. The automated record-arm key-command setup (system.setup_arm_key) refuses for it-IT, pt-BR, and zh-TW until their Key Commands spelling is proven from Apple's data or measured live (see CHANGELOG v3.18.0).
Markers: marker creation uses Logic's native Navigate menu and verifies the Marker List when it is readable. A closed/unreadable Marker List is reported as unreadable or served from the last readable cache instead of being promoted to a verified empty list. rename_marker remains not_implemented.
Plugin parameter readback: logic_plugins.set_param_verified opens the target insert's plugin window when needed and live-verifies Compressor threshold through that window; arbitrary plugin parameters remain future work and fail closed with unsupported_param_readback.
Locale coverage is mostly derived, not measured: outside en-US, ko-KR, ja-JP, and de-DE, most canon UI labels are derived from Apple's .strings tables rather than read from a live Logic window in that language (see the Locales table above).
Development
Source builds use Command Line Tools with Swift 6.2.