Call first: report RenForge version and the active project.

active_project falls back from the dashboard selection to the serve default, then to a Ren'Py project detected from the current directory (project_source says which one matched). A null active_project only means auto-discovery found nothing — every tool accepts project_path directly, so ask the user for the game's path and keep going.

Discover the active Ren'Py project (dashboard, serve default, or cwd).

Open a local image and return an optional cropped/zoomed PNG for inspection.

Scan scripts; defaults to summary-only, with opt-in sections and pagination.

Find exact Ren'Py definitions/usages, including text interpolations.

Launch or reuse a game with the Live Editor enabled by default.

Pass editor=False to launch intentionally without the visual editor.

After launch, poll renforge_launch_status until ready, then observe with a fresh renforge_screenshot or renforge_scene_tree before any click. Use renforge_click_at or renforge_click_element with a current frame_id guard; verify the result, then renforge_stop. See docs/LIVE_EDITOR.md. Optional warp is a Ren'Py file:line target.

The call waits at most 20 seconds for readiness, then returns status="starting" while startup continues in the background. Poll renforge_launch_status until it reports ready or failed. display/audio default to auto; savedir='temporary' isolates saves. timeout controls the background startup deadline, not the MCP call.

Return starting, ready, failed, or idle for a background launch.

Restart at a label or file:line; poll launch status when still starting.

Start at the start label; poll launch status when still starting.

Stop a running game or cancel its in-progress launch, then clean up.

Return complete live state; optionally include compact metrics or audio.

Return bounded live state, optionally with selected variables.

Defaults to state_profile='interaction' so the full store is never returned in the payload unless state_profile='full' is requested.

Inspect an active screen's layer, JSON-safe scope, and arguments.

Advance the current dialogue.

Run a runtime action: advance, rollback, toggle_skip, toggle_auto, toggle_afm, game_menu, hide_windows, quick_save, quick_load, reload_script, restart_interaction, or quit.

Emits correlated business events (quick_save.completed, skip.stopped, …). Set wait_for_effect=true to block until the matching event appears.

Send exactly one input mode: text, named key, or scroll object.

text posts character-by-character TEXTINPUT events to a focused Ren'Py Input; submit optionally presses Enter after the text. key accepts readable names such as enter, esc, arrows, pageup, pagedown, backspace, delete, home, end, space, tab, and function keys. scroll is {"x": ..., "y": ..., "direction": "up"|"down"} in logical game coordinates, with optional integer amount. Exactly one of text, key, and scroll must be supplied.

Save, load, or list named save slots without screenshot payloads.

List the on-screen menu choices (text + index).

Select a menu choice by visible text (preferred) or by index.

List visible focusable Ren'Py controls with bounds and frame guard.

Click a visible control by text/id, guarded against a stale frame.

Returns received_by when another control owns the hit point. With wait_for_effect=true, wait for a correlated business event such as quick_save.completed when the clicked action is recognizable.

Move the pointer over a visible control without clicking it.

Report focus bounds and rendered painted bounds for a UI element.

Click screen coordinates with optional frame/state safety guards.

Report where a shown image tag was rendered, in logical coordinates.

Reposition a shown image tag live and return its new logical bounds.

Provide at least one placement field. The tag keeps its current attributes. Positions follow Ren'Py's rule: an integer is absolute pixels (xpos=600 is 600px), a float is a fraction of the screen (xpos=0.5 is the centre). Use this to converge on coordinates interactively, then write the final values into the .rpy script.

Diff two frames and return the bounding box of what changed.

before_path is a saved PNG. after_path is another saved PNG, or empty to diff against the current live frame. Use it to measure how far an element moved or to confirm a tweak left everything else untouched.

Evaluate a Python expression in the running game's store namespace.

Set a variable in the running game's store namespace.

Read a variable from the running game's store.

Return pushed events (dialogue, labels, exceptions) newer than since.

Return recent bridge exceptions or bounded crash-file diagnostics.

Wait for exactly one label, screen, or expression condition.

Returns a compact state by default (state_profile='interaction'). Pass include for extra fields/variables; use state_profile='full' only when the complete store is required.

Inspect the interactive focus stack at a coordinate.

Returns topmost and underneath focusable controls so agents can detect transparent overlays that intercept clicks.

Perceive the whole scene as structured data (logical coordinates).

Unlike renforge_list_ui_elements (focusables only), this reports every layer displayable, focusable control, and text block with id, type, bounds, center, zorder and screen. Every reply carries an omitted completeness hint. detail is semantic (default), layout or raw; layers/types/screen/ids scope the result. include=["color","style","overflow"] opts into composited colour, declared style, and best-effort text overflow. format="wireframe" adds an ASCII map. save_as persists a snapshot under .renforge/scenes/; diff_against diffs the live scene against a saved snapshot.

Measure pixel relationships between scene nodes, without eyes.

action is one of align, gap, distribute, center, overlap, fit, contrast. Each target (and within) is a renforge_scene_tree node id (string, resolved live) or a literal bounds object {x,y,width,height}. Returns actionable deltas in logical pixels; when tolerance is given, adds a pass verdict. contrast samples the live frame and reports a WCAG ratio (one target = its internal fg/bg, two targets = between the two elements).

Run a multi-step live scenario (click/wait/assert/...) in one call.

On failure, captures a screenshot and compact diagnostics automatically. Supported step actions: set, eval, click, click_at, advance, scroll, wait, assert, select_choice, capture, save, load, control, send_input.

Auto-play the game across all branches; report label coverage and crashes.

Find orphaned and missing image/audio assets in the project.

List translation languages present under game/tl/.

Report missing dialogue/string translation counts for a language.

Generate/update translation files for a language (writes game/tl//).

Export the game's dialogue as plain text.

Package the project as a browser-playable build (needs the web DLC).

Build desktop distributions (e.g. package='pc', 'mac', 'linux').

Search Ren'Py's offline documentation for a keyword.

Read a Ren'Py documentation page as plain text (e.g. topic='cli').

List available Ren'Py documentation topics.

Capture a game frame, optionally resizing, cropping, and zooming it.

Measurement guides help pixel-perfect placement: grid draws lines every N pixels, rulers labels those steps along the edges, and crosshair_x/crosshair_y mark a point. Capture at the game's logical resolution (width/height) so the labels read as logical coordinates. Passing only one of width/height keeps the game's aspect ratio.

Persist a screenshot under the project's controlled capture directory.

Estimate stable visual translation between two saved frames.

Find a template image in the current frame and return its bounds.