| session_get_capabilitiesA | Report which FL Studio integration paths work in this bridge session. Returns the connection (FL version, protocol, write mode, and the current
session_fingerprint) and, for each capability, whether it is direct,
partial, unavailable, or unvalidated. Read-only. Call it when a tool is
refused or before planning work that depends on a capability; use
project_get_summary for the open project's contents.
|
| session_set_write_modeA | Turn write mode on or off for this bridge session without restarting FL. Setters (mixer_set_track, channel_set, plugin_set_parameter and the other
tools that change the project directly) refuse until write mode is on.
run_execute, run_continue, processing_apply, sound_apply_palette, and
review_apply_revision enable it for their own work. Enabling requires
confirm_user_present=true; the user's request to edit is that confirmation,
so do not ask separately. The result is verified with a fresh handshake.
Changes no project value, applies only to this session, and is never
saved. Disable it when the task's edits are done.
|
| project_get_summaryA | Read the open project's metadata, counts, dirty state, and transport. Returns the title, tempo, PPQ, mixer/channel/pattern/Playlist counts, the
undo position, dirty state, the connection with its session_fingerprint,
and the transport (playing, recording, loop mode, position, metronome,
precount, time signature). Read-only. Use it for overall context and the
transport state before transport_set; use the area list tools
(mixer_list_tracks, channel_list, pattern_list, playlist_list_tracks) for
target details.
|
| project_get_historyA | Read FL's undo history: position, count, next undo hint, and dirty state. Read-only. Call it before project_step_history to see what an undo or redo
would move to, and pass its position, count, or dirty flag as that call's
expected_before guard.
|
| project_step_historyA | Undo or redo one step of FL Studio's project history and verify the move. Requires write mode (session_set_write_mode). Moves exactly one step and
reads FL's history position back on a later tick; the receipt reports the
position before and after. FL's history covers every project change, not
only PostFader's, so read project_get_history first and guard with
expected_before. Does not save the project.
|
| project_apply_editsA | Apply edits you have already decided, across several targets, in one call. Each item sets an absolute value on a mixer track, channel, pattern,
Playlist track, plug-in parameter, or the tempo, in order, after one
session check; mixer_plan_gain_staging returns items in this form. For
several fields of one target, its setter (mixer_set_track, channel_set) is
simpler. It does not apply plans: processing_apply, sound_apply_palette,
and review_apply_revision apply their own planner's result, and
run_execute runs multi-step work. Requires write mode. Every attempted item
gets its own later-tick receipt. The batch is non-atomic: earlier changes
remain if a later item fails, and an unknown outcome stops it. Inspect each
receipt and never replay an ambiguous batch. No rollback or project save is
performed.
|
| transport_setA | Change playback, recording, tempo, loop mode, and other transport settings. Set only the fields to change; each is an absolute state, never a toggle.
Requires write mode. Writes run in a fixed order so one call can stop,
adjust, and restart: stop/pause and recording-off first; then tempo, time
signature, loop mode, metronome, precount, and position; then recording-on;
then playback last. Each write gets its own later-tick receipt, and
verified is true only when all of them verified. Non-atomic: earlier writes
remain if a later one fails. Read the current state with
project_get_summary. Does not save the project.
|
| mixer_list_tracksA | List mixer tracks with names, levels, mute/solo state, and loaded effects. Read-only. Index 0 is Master. Use it to find track indices and effect slots
before mixer_set_track or plugin tools; use mixer_get_track for one track's
built-in EQ and outgoing sends, and mixer_start_peak_watch for levels over
time.
|
| mixer_get_trackA | Read one mixer track's full state: level, pan, effects, EQ, and sends. Read-only. Returns the fader in normalized and dB form, pan, stereo
separation, mute/solo/arm, name, color, effect slots, the built-in
three-band EQ, and outgoing sends with their levels. Read it before
mixer_set_track to supply current values as expected_before guards.
|
| mixer_set_trackA | Change any combination of one mixer track's settings in one call. Set only the fields to change: name, color, volume (normalized or dB), pan,
stereo separation, mute, solo, record arm, built-in EQ bands, sends, and
whether it is the active track. Requires write mode
(session_set_write_mode). Writes run in that order, each read back on a
later FL tick with its own receipt; verified is true only when every write
verified. Non-atomic: earlier writes remain if a later one fails, and an
unknown outcome stops the rest. Use plugin_set_parameter for effect
parameters and project_apply_edits for several tracks. Does not save.
|
| mixer_start_peak_watchA | Start sampling mixer peak meters while the user plays the song. Runs in the background in this MCP process and returns its first frame and
a watch_id. Ask the user to play the section to measure, then read it with
mixer_get_peak_watch or end it with mixer_stop_peak_watch. Changes no
project state. Meter peaks are post-fader samples, not audio analysis; use
the watch with mixer_plan_gain_staging to propose fader moves.
|
| mixer_get_peak_watchA | Read a peak watch's status and cumulative per-track peaks so far. Read-only; the watch keeps running. Returns each track's maximum peak,
clipping frame count, and last fader reading. Watches are process-local
and end when the MCP server restarts. |
| mixer_stop_peak_watchA | Stop a peak watch early and return its final per-track aggregate. Changes no project state. A stopped watch can still be read and used by
mixer_plan_gain_staging.
|
| mixer_plan_gain_stagingA | Propose dB fader moves that bring each watched track to a target peak. Read-only: nothing is applied. Returns mixer_volume_db operations with
expected_before guards from the watch, the watch's session_fingerprint, a
rationale per track, and the tracks it skipped (muted, silent, Master, or
already within 0.5 dB). Review them, then pass operations and
session_fingerprint to project_apply_edits. Re-watch and re-bounce after
applying.
|
| channel_listA | List every Channel Rack channel with its mix, routing, and generator. Read-only. Each channel has a global channel_index, name, color, volume,
pan, pitch, mute/solo/selection, mixer destination, generator identity, and
a channel_fingerprint. Use the index for channel_set, channel_get_steps,
piano_roll tools, and channel_generator plug-in targets; pass the
fingerprint as channel_set's expected_before guard.
|
| channel_setA | Change any combination of one Channel Rack channel's settings in one call. Set only the fields to change: volume, pan, mute, solo, pitch, name and
color, mixer routing, and exclusive selection. Requires write mode
(session_set_write_mode). Writes run in that order, each read back on a
later FL tick with its own receipt; verified is true only when every write
verified. Non-atomic: earlier writes remain if a later one fails. Use
plugin_set_parameter for the channel's instrument, channel_set_steps for
its step grid, and piano_roll_write_notes for its notes. Does not save.
|
| channel_get_stepsA | Read one channel's step-sequencer grid in the current pattern. Read-only. Returns each step's on/off state and a digest of the grid. Pass
that digest as channel_set_steps' expected_digest so the edit refuses if
the grid changed in between. The pattern must be the current one; select
it first with pattern_set(select=true).
|
| channel_set_stepsA | Turn step-sequencer cells on or off for one channel in the current pattern. Requires write mode and a fresh channel_get_steps read: the edit refuses if
the grid no longer matches expected_digest, so nothing is overwritten
blindly. Each changed cell is read back on a later tick and reported. Use
piano_roll_write_notes for pitched notes and lengths. Does not save.
|
| channel_play_noteA | Play one short note on a channel so the user can hear the sound. Sends a bounded note-on/note-off pair; nothing is recorded or saved and
the project is unchanged. Requires write mode. The receipt confirms the
dispatch only: FL has no getter for what was heard. To add notes to the
project, use piano_roll_write_notes.
|
| pattern_listA | List the project's patterns with name, color, length, and which is current. Read-only. Also reports whether each pattern is FL's default empty pattern.
Use pattern numbers with pattern_set, channel_get_steps, and the piano_roll
tools; use pattern_create to make a new named pattern.
|
| pattern_setA | Rename, recolor, resize, or select one existing pattern in one call. Set only the fields to change. Requires write mode. Writes run in the order
name/color, length, then selection, each read back on a later tick with its
own receipt; verified is true only when all verified. Non-atomic. Use
pattern_create for a new empty pattern. Does not save the project.
|
| pattern_createA | Create a pattern: find the first empty one, select it, name it, and size it. Requires write mode. Searches from start_pattern_number for a pattern FL
reports as empty, then selects it and sets its name, optional color, and
length, verifying each step. outcome names the first step that did not
verify. Use pattern_set to change an existing pattern. Does not save.
|
| playlist_list_tracksA | List every Playlist track with its name, color, and mute/solo/selection. Read-only. Playlist track indices are one-based. Use them with
playlist_set_track. Clips on the Playlist are not readable through FL's
scripting API.
|
| playlist_set_trackA | Rename, recolor, mute, solo, or select one Playlist track in one call. Set only the fields to change. Requires write mode. Name and color are
written first, then mute/solo/selection, each read back on a later tick
with its own receipt; verified is true only when both verified. Playlist
clips cannot be created or moved through FL's scripting API. Does not
save the project. |
| playlist_get_selectionA | Read the Playlist's current time selection and the project PPQ. Read-only. Returns the raw selection endpoints with validity and
consistency evidence. PPQ is ticks per quarter note; the endpoints are not
converted to bars and are not guaranteed render limits, so check the
evidence before relying on them. Use project_get_summary for the playback
position.
|
| playlist_add_markersA | Add named section markers (Intro, Verse, Drop) to the Playlist timeline. Requires write mode. FL lets PostFader read marker names back but not
their times, so the receipt verifies the new names and reports times as
unverified. Does not save the project. |
| automation_record_valueA | Record one automation value into FL while playback and recording run. For writing a control change into the arrangement as automation. Requires
write mode, and FL must already be playing with recording armed (set both
with transport_set). Sends one REC event for the control at the current
song position and reports the control value before and after. Whether an
automation point was created cannot be read back. To set a value without
recording it, use mixer_set_track or channel_set.
|
| plugin_list_loadedA | List every loaded mixer effect and Channel Rack instrument as a target. Read-only. Each entry carries the target object that the other plugin_*
tools take (mixer_effect with track and slot, or channel_generator with a
channel index), the plug-in's reported name, and its parameter count. Use
atlas_match_loaded to identify products, and plugin_list_parameters to see
a plug-in's controls.
|
| plugin_list_parametersA | List a loaded plug-in's real controls with their current values and text. Read-only. FL reports a padded parameter count for VST plug-ins, often
thousands of empty slots; this walks the range inside FL and returns only
real controls, each with its index, name, normalized value, and display
text (which identifies unnamed controls). Check truncated before treating
the list as complete. Use the indices, names, or display text with
plugin_set_parameter.
|
| plugin_set_parameterA | Set one plug-in parameter by display value, option text, or raw 0..1 value. Supply exactly one value form. display_value searches the control until its
own display reads the number asked for, so no unit curve is guessed; use it
for anything with units (Hz, dB, ms, %). option sets a word-valued control
(Key, Scale, Mode) by sweeping it, which moves the control while it looks;
the result lists every option found, and an unknown option restores the
original value before the error. normalized_value writes 0..1 directly.
Requires write mode. Read controls with plugin_list_parameters first.
Inspect verified and the readback; does not save the project.
|
| plugin_list_presetsA | Read a page of a loaded plug-in's preset names, its preset count, and current preset. Read-only. Returns FL's authoritative preset_count, one page of names with
their indices (follow next_start for more), and, unless include_current is
false, the current preset with an index only when it is unique. Use a name
or index from this list with plugin_select_preset; use sound_plan_palette
to choose sounds across several roles.
|
| plugin_select_presetA | Load a known preset on one mixer effect or Channel Rack instrument. Supply an exact name and/or index from plugin_list_presets. Requires write
mode. FL steps through presets to reach the target, which changes the sound
through intermediate presets, bounded by max_navigation_steps; the landed
preset's identity is read back. Inspect verified and warnings. Use
sound_apply_palette for planned multi-role choices. This selects a preset;
it does not set a parameter or load a new plug-in (plugin_load).
|
| plugin_get_pad_mapA | Read an instrument's drum pads: MIDI note, color, and empty/muted state. Read-only. Read it before writing drums to a non-General-MIDI kit so each
hit lands on the right pad; sound selection and the inspect_drum_map run
operation turn these pads into the drum_map that compose_drums takes.
complete is false when FL did not report every pad.
|
| plugin_list_availableA | List the instruments and effects in FL's native Add menu (macOS only). Opens and closes the menu, which briefly changes focus; changes no project
state. Reports exact loadable names and whether each is an instrument or
an effect, for plugin_load. Menu presence is not proof of licensing or an
exhaustive install scan.
|
| plugin_loadA | Add one instrument (new channel) or mixer effect from FL's Add menu (macOS). Use an exact name from plugin_list_available. Requires write mode; an
effect load first selects its mixer track. Returns the new channel or
effect slot as a target for plugin_select_preset or plugin_set_parameter.
If the outcome is unknown, inspect plugin_list_loaded before trying again.
Windows insertion is not implemented. Does not save the project.
|
| atlas_searchA | Search the bundled offline Plugin Atlas for products by text and filters. query searches product knowledge; vendor_id, origin, kind, technique_id,
and stock_only narrow it, and limit caps the hits. No FL connection is
needed, and a hit does not mean the product is installed or owned. Use
atlas_get_product for one product's details and control adapters,
atlas_recommend for a production goal, and atlas_match_loaded to identify
plug-ins in the open project.
|
| atlas_get_productA | Read one Plugin Atlas product: vendor, controls, adapters, and alternatives. Offline and read-only. Returns the product's knowledge, its control
adapters (which parameters mean what), evidence, and stock alternatives. An
adapter record does not prove that a loaded copy is writable; join catalog
knowledge to live targets with atlas_match_loaded.
|
| atlas_recommendA | Rank Plugin Atlas products for a production problem or technique. Describe the task with query, problems, techniques, sources, and kind;
prefer_stock favors FL's stock plug-ins and limit bounds results. With
product_id and stock_alternatives=true it lists stock alternatives to a
known product. Offline static knowledge: not proof of availability or
ownership. Use sound_plan_palette to assign sounds from what is loaded.
|
| atlas_match_loadedA | Identify the open project's loaded plug-ins against Plugin Atlas. Reads the live inventory and returns, for each loaded effect and
instrument, its target, candidate Atlas products, and whether a control
adapter makes its parameters known. Read-only. only_used limits mixer
tracks; match_limit caps candidates; include_weak adds uncertain matches.
A match is not proof of ownership or writable controls; confirm controls
with plugin_list_parameters.
|
| processing_planA | Turn processing goals into concrete settings for effects that are loaded. Read-only: inspects loaded effects once and returns a plan of semantic
actions, each naming the effect, control, and value, plus what could not be
resolved and why. Goals and strength produce first-pass settings; explicit
controls override them. Review the plan, then apply it unchanged with
processing_apply, or use the plan_processing operation inside run_execute.
Re-bounce and listen before refining.
|
| processing_applyA | Apply the plan returned by processing_plan to the loaded effects. Takes only that plan, passed back unchanged, and runs it as a
single-operation Production Run: it checks readiness, enables write mode
for the run, writes each control with its verified setter, and releases
write mode. Requires the session_fingerprint from a recent live read and
authorized_to_modify=true. Stops on an unknown or unverified outcome;
earlier settings remain. Returns the run with per-action receipts;
continue or inspect it with run_continue and run_get. To set one parameter
value directly, use plugin_set_parameter.
|
| sound_get_inventoryA | Read the pool of loaded instruments and their presets that palettes choose from. Read-only. Returns each loaded instrument (and effects when requested) with
its preset names, current preset, drum pad map, and Atlas knowledge.
sound_plan_palette reads this inventory itself, so call it only to show
the user what is available. Atlas-only products are recommendations, not
loaded sounds.
|
| sound_plan_paletteA | Choose an instrument and preset for each musical role from loaded sounds. Read-only: reads the live inventory and returns deterministic assignments
with score reasons and a palette_id, without changing FL or history. With
base_palette_id it plans a variation for a later section instead, keeping
the base palette's anchors except replace_roles. Explicit roles and
preferences override genre defaults. Review the plan, then apply it with
sound_apply_palette before writing notes, so parts fit the chosen sounds.
|
| sound_get_paletteA | Look up a previously planned sound palette by its palette_id. Read-only. Palettes live in this MCP process; an expired or unknown ID is
reported in the result rather than raised as an error, so plan again if it
is gone.
|
| sound_apply_paletteA | Apply the palette returned by sound_plan_palette, loading each role's preset. Pass the palette (or its palette_id) unchanged, the session_fingerprint
from a live read, and authorized_to_modify=true. Enables write mode for
this application, selects each assignment's preset in a fixed order with
later-tick identity readback, and stops on an unknown or unverified
outcome; earlier roles remain applied. Does not install or load plug-ins
(plugin_load). Inspect the receipts before any further attempt. Use
plugin_select_preset for one known preset without a palette.
|
| sound_record_feedbackA | Record the user's explicit verdict on a palette so future picks follow it. Scope the verdict with palette_id and optionally role_id or assignment_id;
descriptors name qualities the user wants more or less of. May write local
history according to the request's persistence settings; never changes the
FL project. Never infer acceptance from silence. Feedback does not generate
a replacement: use sound_plan_palette with base_palette_id for that.
|
| sound_get_historyA | Report the local sound-selection history: location, health, and record counts. Read-only. History stores accepted and rejected choices on this computer
to steer later palettes. Use sound_reset_history only when the user asks
to clear it.
|
| sound_reset_historyA | Delete the local sound-selection history after the user asks to. Removes the bounded history records that steer future palettes. Cannot be
undone. The FL project and its presets are unchanged. |
| audio_analyze_fileA | Measure one rendered file's loudness, peaks, spectrum, dynamics, and stereo image. Reads the file only; FL's live output is not available. Returns integrated
and short-term loudness (LUFS), loudness range, sample and true peak,
spectral band balance, dynamics, stereo correlation and mono compatibility,
and optional pitch. Use audio_diagnose_mix for a pass/fail mix diagnosis,
audio_compare_files against a reference, and audio_list_recent_bounces to
find the user's latest export.
|
| audio_compare_filesA | Compare a candidate render with a reference and suggest tonal adjustments. Reads both files; changes nothing. Aligns them, matches loudness, and
measures per-band differences over their common overlap. When alignment
and readiness checks pass, it adds bounded review ranges per band (reduce
or increase the candidate); otherwise actionable is false. Suggestions are
starting points to review, not targets to apply blindly. |
| audio_analyze_maskingA | Measure where an instrumental masks a vocal and suggest remedies. Reads two sample-synchronous stems; changes nothing. Returns per-band
spectral overlap and vocal-minus-instrument margins and, when the evidence
is actionable, suggested instrument reductions per band (dynamic EQ or
automation). Use audio_diagnose_mix to judge the full mix.
|
| audio_diagnose_mixA | Diagnose a rendered mix against technical thresholds for a delivery target. Reads the files; changes nothing. Measures the mix, optionally compares it
with a reference and checks vocal masking, then lists issues with severity,
the measurement, the threshold it broke, and a recommendation, plus whether
the mix is technically export-ready. Passing is technical, not artistic
approval. After changing the project, have the user export again and
re-run it. |
| audio_list_recent_bouncesA | List the newest audio files in FL Studio's Rendered, Audio, and Projects folders. Read-only. Use it to find the user's latest export before measuring it with
the other audio_* tools; confirm with the user which file is the right one.
|
| audio_estimate_tempo_and_keyA | Estimate a file's tempo and major/minor key, with ranked alternatives. Reads the file only. Returns the best tempo and key, each with a confidence,
plus ranked tempo candidates and an ambiguity note, so half/double-tempo
readings stay visible. Use it to match a sample or reference before
composing. |
| audio_transcribe_melodyA | Transcribe a monophonic recording (a sung or played line) into notes. Reads the file only. Returns a note sequence in beats, ready to review and
then write with piano_roll_write_notes or export with compose_export_midi.
Chords and full mixes transcribe poorly; give it one isolated line.
|
| compose_chord_progressionA | Generate voice-led chords from Roman numerals in a key, without touching FL. Deterministic: the same inputs give the same notes. Returns a note sequence
in beats with a digest. Write it with piano_roll_write_notes, export it with
compose_export_midi, or pass the progression to compose_bassline.
|
| compose_melodyA | Generate a scale-aware melody within a register, without touching FL. Deterministic for a given seed; change the seed for alternatives. Returns a
note sequence in beats. Fit the register to the chosen sound
(sound_plan_palette) before writing it with piano_roll_write_notes.
|
| compose_basslineA | Generate a bass part that follows a Roman-numeral progression, without touching FL. Deterministic for a given seed. Use the same progression and key as
compose_chord_progression so the parts agree. Returns a note sequence in
beats for piano_roll_write_notes or compose_export_midi.
|
| compose_drumsA | Generate kick, snare, and hat patterns in a style, without touching FL. Deterministic for a given seed. Without drum_map it uses General MIDI
drum notes, which many FL kits do not follow; read the kit's pads with
plugin_get_pad_map and plan sounds first so hits land on the right pads.
Returns a note sequence in beats for piano_roll_write_notes.
|
| compose_export_midiA | Write note sequences to a standard Type-1 MIDI file and verify it. Writes a local file only; the FL project is unchanged. Re-opens and parses
the file to verify its digest, tracks, and events. Refuses to replace an
existing file unless overwrite=true. The user can drag the file into FL;
use piano_roll_write_notes to put notes in the open project instead.
|
| piano_roll_setupA | Prepare the one-time Piano Roll scripting setup that note tools need. status reports readiness without writing files. prepare writes the
Postfader Apply script into FL's Piano Roll scripts folder; the user must
then run it once from FL's Piano Roll menu. confirm with
confirm_user_ran_script=true arms this MCP process. Writes no notes. Reuse
the setup for the rest of the session.
|
| piano_roll_read_notesA | Read the notes of one channel in one pattern: pitch, timing, and expression. Opens that score in FL's Piano Roll (which changes focus) but never changes
notes or enables writes. Needs the piano_roll_setup step done once. Read
before composing around existing material or transforming it. Follow
next_offset to page; a selected_only page can be empty and still have a
next_offset.
|
| piano_roll_write_notesA | Write notes into one channel's Piano Roll score in a pattern. Requires write mode and the one-time piano_roll_setup. Writes a local
script, selects the channel and pattern, and triggers FL's run-last-script
shortcut, then checks the selected target, the script's application, and
persistence. A dispatch alone is not proof the notes landed: inspect the
returned evidence, and treat a missing receipt as an unknown outcome, not a
reason to retry. Use piano_roll_transform_notes to edit existing notes.
Does not save the project.
|
| piano_roll_transform_notesA | Quantize, transpose, humanize, duplicate, delete, or clear existing notes. Applies to the selected notes or the whole score of one channel in one
pattern. Requires write mode and the one-time piano_roll_setup; read the
notes first with piano_roll_read_notes. delete and clear remove notes in
scope. Works like piano_roll_write_notes: a dispatch is not proof, so
inspect the evidence. Use piano_roll_write_notes to add new notes.
|
| run_describe_operationsA | List Production Run operations and return exact schemas for the ones named. Read-only and offline. Plan schemas in run_execute, run_validate, and
run_continue name operations without listing their fields, so call this
first with the operations you will use (up to eight per call). Operations
cover composing, writing notes, patterns, markers, automation, direct
edits, sound palettes, presets, drum kits, effect processing, and review
steps; save, render, plug-in insertion, and Playlist clips are refused.
|
| run_validateA | Dry-run a Production Run plan against the live project without changing it. Checks the plan's structure, operation order, capabilities, targets, and
scope rules against the current FL session and returns whether it is
executable, its blockers, and a plan digest. include_readiness adds the
setup scorecard (Piano Roll setup, missing plug-ins, manual steps). Use it
only when the user wants a plan reviewed or a diagnosis: run_execute
performs the same checks itself, so do not validate before every run.
|
| run_executeA | Run a multi-step production plan, such as writing a chorus, as one task. The main path for work that spans several kinds of operation, such as
composing, writing notes, arranging, choosing sounds, and processing: it
validates the whole plan, checks readiness, enables write mode once for
the run, executes operations in order with per-operation receipts, and
releases write mode when finished. For edits already decided, use the
setters or project_apply_edits; to apply one result of processing_plan,
sound_plan_palette, or review_plan_revision, use that area's apply tool.
It stops at a blocker or an unknown outcome and reports the blocked
operation and a next step; resume with run_continue. Mutating plans need
authorized_to_modify=true. The run is saved locally and survives MCP
restarts. Never saves the project.
|
| run_continueA | Resume a stopped or blocked Production Run, or change its unexecuted remainder. Use it after the user's follow-up or after fixing a blocker. Completed
operations and their receipts are kept and never re-run; an operation with
an unknown outcome is never replayed. Write mode is enabled for the run
and released afterwards, like run_execute. Find saved runs with run_list.
|
| run_stopA | Stop a run so no further operations execute. Completed changes stay in the project; nothing is undone (use
project_step_history to undo). Returns the run's final state and
receipts.
|
| run_getA | Read a run's status, generated outputs, and per-operation receipts. Read-only; works for current runs and runs saved before an MCP restart.
Use it to inspect what a run did, which operation blocked, and the outputs
(note sequences, palettes, plans) that later operations or reviews can
reference. |
| run_listA | List recent Production Runs saved on this computer, newest first. Read-only; executes nothing. Use it after an MCP restart to find a run_id
for run_get or run_continue.
|
| review_startA | Start a Review Session for the result of one completed Production Run. The session keeps the run's outputs, palette, processing receipts, and
section map as evidence for evaluating bounces of that work. Changes no
project state. Next, have the user export a full mix and attach it with
review_attach_assets. Sessions are process-local unless persist_session
is set.
|
| review_attach_assetsA | Validate exported audio files and attach them to a Review Session. Paths must be explicit caller-selected files (audio_list_recent_bounces can
find them). Checks format, size, stability, hashes, and alignment evidence;
rejects directories, changing files, and duplicates. Changes no project
state. Evaluate the attached full mix with review_evaluate.
|
| review_evaluateA | Measure an attached bounce as a whole and section by section, with findings. Reads the files only; makes no FL changes. Returns findings tied to
measurements and sections that review_plan_revision can address.
Measurements support decisions; they never establish the producer's
approval, which only review_record_feedback records.
|
| review_getA | Read a Review Session, its next export request, or its delivery manifest. Read-only. Use view=session to see where the review stands and what to do
next; view=export_request when the user must export a new bounce, to tell
them exactly what to render; view=delivery_manifest to summarize what is
done and what export or import work remains. Write the manifest to files
with review_export_delivery.
|
| review_compareA | Compare the bounces before and after a revision against its objective. Reads the files only. Reports what changed toward or away from the
revision objective, using matching export settings. A better measurement
is not producer approval; ask the user and record it with
review_record_feedback.
|
| review_plan_revisionA | Compile one bounded revision plan from evaluation findings and feedback. Read-only: validates that each operation traces to a finding or feedback,
respects the producer's locks on accepted sound, notes, rhythm, register,
processing, level, placement, and roles, and stays within the pass limit.
Records the plan in the session for review_apply_revision.
|
| review_apply_revisionA | Apply the revision plan returned by review_plan_revision to the project. Takes only a plan recorded in this Review Session and runs it through a
Production Run. Needs authorized_to_modify=true from a request to revise
in this task. Runs one readiness preflight, enables write mode for the
run, applies the plan's operations with receipts, and releases write mode.
Stops on a blocker or unknown outcome. Then ask the user for a new export
(review_get view=export_request) and compare it with review_compare.
|
| review_record_feedbackA | Record the producer's explicit feedback and locks in a Review Session. Feedback outranks measurements. Locks protect accepted elements (sound,
notes, rhythm, register, processing, level, placement, role) from later
revisions. Changes no project state. Silence and good measurements never
count as approval. Use sound_record_feedback for feedback on a sound
palette.
|
| review_stopA | Stop a Review Session so no further revision work happens. Completed project changes stay; nothing is undone. The session's record
remains readable with review_get; use review_delete to remove it.
|
| review_deleteA | Delete one Review Session's stored record after the user asks to. Removes the session's metadata from the local store. Audio files and the FL
project are untouched. Cannot be undone. |
| review_export_deliveryA | Write a Review Session's delivery manifest to new JSON or Markdown files. Creates new local files only and never overwrites an existing one; the FL
project is not saved or changed. Preview the content first with review_get
view=delivery_manifest.
|
| render_start_jobA | Render a saved .flp to a WAV with FL's command-line exporter, as a background job. Starts a separate FL process; the open project and its unsaved changes are
not included, because only saved state renders. Returns a job_id at once;
poll render_get_job for the output. Jobs live in this MCP process. Use the
finished WAV with the audio_* or review_* tools.
|
| render_get_jobA | Read a render job's status and, once ready, its decoded WAV details. Read-only. output_ready means the WAV decoded fully and is usable;
completed also means the FL process has exited.
|
| render_cancel_jobA | Cancel a render job: stop monitoring it and the process it started. On macOS the separate FL renderer may stay open after cancellation; check
render_get_job for the final status.
|
