@hybridlabor-api/bdb-antigravity-skills 1.2.0 → 1.2.2

package/skills/global_config/bdb-grandma3-mcp.md

@@ -0,0 +1,109 @@
+---
+name: bdb-grandma3-mcp
+description: Utilizes the grandMA3 MCP server to patch fixtures, execute console commands, and trigger macros via OSC.
+---
+
+# grandMA3 MCP — Integration and AI Agent Guide
+
+This skill file instructs AI agents on how to control grandMA3 lighting consoles using the `grandma3_mcp.py` script. It details OSC routing, command execution, fixture patching, and troubleshooting steps.
+
+## 1. Overview and Pipeline Value
+
+The **grandMA3 MCP Server** enables AI models to programmatically configure and drive grandMA3 lighting control software. In the BDB OS workflow, this integration automates fixture patching, triggers lighting states, executes macros, and manages live cue sequencing during stage productions.
+
+### Architecture
+- **FastMCP server:** Implements standard Model Context Protocol.
+- **OSC UDP Transport:** Sends network packets via Open Sound Control (OSC) to `127.0.0.1` on port `8000`.
+- **Command Router:** Maps JSON-RPC requests to OSC `/cmd` string paths, executing them natively inside grandMA3's Command Line.
+
+---
+
+## 2. System Instructions
+
+### Workflow Priorities
+1. **Target Port Configuration:** Ensure grandMA3's OSC settings are configured to listen on port `8000` and route `/cmd` addresses.
+2. **Console State Syntax:** Commands must match grandMA3 command-line syntax (e.g., `Fixture 1 At 100`, `Go Macro 5`).
+3. **Double Patch Safeguard:** Before calling `patch_fixture`, check if the targeted DMX address or fixture ID is already occupied by existing objects to avoid patching conflicts.
+
+---
+
+## 3. Available Tools and API Parameters
+
+| Tool | Parameters | Description |
+| :--- | :--- | :--- |
+| **`grandma3_ping`** | None | Verifies that the FastMCP server is active and ready to transmit commands. |
+| **`execute_command`** | `command: string` | Sends an arbitrary grandMA3 command to the console CLI via OSC (e.g., `ClearAll`, `Go Page 2`). |
+| **`execute_macro`** | `macro_number: int` | Executes a specific macro number using the `Go Macro {num}` syntax. |
+| **`patch_fixture`** | `fixture_id: int`, `name: string`, `fixture_type: string`, `address: string` | Automatically runs the console CLI command to assign, name, set fixture type, and patch a fixture. |
+
+---
+
+## 4. Code Recipes and Prompt Cookbook
+
+### Recipe 1: Standard Fixture Patching
+Patch four Robe BMFL fixtures starting at DMX address 1.101:
+
+```json
+// Tool Call: patch_fixture
+{
+  "fixture_id": 101,
+  "name": "BMFL_StageLeft_01",
+  "fixture_type": "Robe BMFL",
+  "address": "1.101"
+}
+
+// Tool Call: patch_fixture
+{
+  "fixture_id": 102,
+  "name": "BMFL_StageLeft_02",
+  "fixture_type": "Robe BMFL",
+  "address": "1.121"
+}
+```
+
+### Recipe 2: Triggering Show Cues
+Run a sequence command to clear the programmer, select fixtures, set intensity, and store a cue:
+
+```json
+// Tool Call: execute_command
+{
+  "command": "ClearAll"
+}
+
+// Tool Call: execute_command
+{
+  "command": "Fixture 101 Thru 105 At 80"
+}
+
+// Tool Call: execute_command
+{
+  "command": "Store Cue 1 \"Intro Light\""
+}
+```
+
+---
+
+## 5. Troubleshooting and Connection Details
+
+### Network Configuration
+- **OSC Target IP:** `127.0.0.1` (localhost)
+- **OSC Target Port:** `8000` (UDP)
+- **OSC Input Address:** `/cmd`
+
+### Console Settings Checklist
+1. Open grandMA3 -> **Setup** -> **In & Out** -> **OSC**.
+2. Create a new OSC connection entry.
+3. Configure the following parameters:
+   - **Mode:** `In` (Listening)
+   - **Destination IP:** `127.0.0.1`
+   - **Port:** `8000`
+   - **Protocol:** `UDP`
+4. Verify that the OSC connection status icon is green.
+
+### Common Errors and Fixes
+1. **`OSC message sent, but console is not responding`**
+   - *Cause:* grandMA3's OSC listener is disabled or binding to a different port.
+   - *Fix:* Verify that the OSC entry in grandMA3 matches port `8000` and has the `/cmd` prefix active.
+2. **`Patch Command Syntax Failure`**
+   - *Cause:* The `fixture_type` string does not match any profile loaded in grandMA3's fixture library.
+   - *Fix:* Pre-load the required fixture profiles inside grandMA3's Patch window before attempting to script patch mappings.

package/skills/global_config/bdb-resolume-mcp.md

@@ -0,0 +1,103 @@
+---
+name: bdb-resolume-mcp
+description: Utilizes the Resolume Arena MCP server to trigger clips, clear layers, adjust speeds, and query composition status via the Resolume REST API.
+---
+
+# Resolume Arena MCP — Integration and AI Agent Guide
+
+This skill file instructs AI agents on how to interface with Resolume Arena media servers using the `resolume_mcp.py` script. It details REST endpoint interactions, layer clearing, composition queries, and troubleshooting steps.
+
+## 1. Overview and Pipeline Value
+
+The **Resolume Arena MCP Server** exposes Resolume Arena's local REST API (7.26+) to AI agents. In the BDB OS media playback pipeline, this enables dynamic clip triggering, layer mixing, composition speed overrides, and status feedback for real-time visual performances.
+
+### Architecture
+- **FastMCP server:** Bridges MCP client requests to standard HTTP REST calls.
+- **HTTP REST Transport:** Talks to Resolume's built-in web server at `http://localhost:8080/api/v1`.
+- **JSON Payload Handler:** Processes composition, layer, deck, and clip properties natively.
+
+---
+
+## 2. System Instructions
+
+### Workflow Priorities
+1. **Enable Web Server:** Ensure Resolume's Web Server is activated in the preferences menu.
+2. **Layer/Clip Indices:** Note that Resolume's API endpoints are **1-indexed** for layers and clips (e.g., `layer=1`, `clip=1`).
+3. **Query before Trigger:** Query `/composition` to retrieve current deck layouts and identify which columns/rows contain clips before firing play triggers.
+
+---
+
+## 3. Available Tools and API Parameters
+
+| Tool | Parameters | Description |
+| :--- | :--- | :--- |
+| **`resolume_ping`** | None | Verifies if Resolume Arena is running by querying the `/product` endpoint. |
+| **`trigger_clip`** | `layer: int`, `clip: int` | Fires a clip located on a target layer and clip index (1-indexed). |
+| **`clear_layer`** | `layer: int` | Stops playback and clears visual output on a specific layer (1-indexed). |
+| **`get_composition`** | None | Retrieves a full JSON representation of the active composition, decks, layer routing, and parameter states. |
+| **`set_composition_speed`** | `speed: float` | Adjusts composition playback speed multiplier. |
+
+---
+
+## 4. Code Recipes and Prompt Cookbook
+
+### Recipe 1: Sequence Multi-Layer Visual Playback
+Trigger clip 3 on layer 1 and clip 5 on layer 2 simultaneously:
+
+```json
+// Step 1: Trigger layer 1 clip
+// Tool Call: trigger_clip
+{
+  "layer": 1,
+  "clip": 3
+}
+
+// Step 2: Trigger layer 2 clip
+// Tool Call: trigger_clip
+{
+  "layer": 2,
+  "clip": 5
+}
+```
+
+### Recipe 2: Transition / Fade-Out Setup
+Clear the primary foreground visual layer and scale composition speed to normal:
+
+```json
+// Step 1: Clear foreground layer (Layer 3)
+// Tool Call: clear_layer
+{
+  "layer": 3
+}
+
+// Step 2: Normalize master composition speed
+// Tool Call: set_composition_speed
+{
+  "speed": 1.0
+}
+```
+
+---
+
+## 5. Troubleshooting and Connection Details
+
+### Network Configuration
+- **Resolume API Host:** `localhost`
+- **Resolume API Port:** `8080` (Default REST Port)
+- **API Base URL:** `http://localhost:8080/api/v1`
+
+### Resolume Preference Verification
+1. Open Resolume Arena -> **Preferences** -> **Web Server**.
+2. Check the box **"Enable Web Server"**.
+3. Verify the port is set to `8080`. (If you use a password, note that the current MCP server relies on unauthenticated local network access; disable password auth or modify `resolume_mcp.py` to add auth headers).
+
+### Common Errors and Fixes
+1. **`Resolume API not reachable: HTTP Error 404`**
+   - *Cause:* Resolume is running, but the Web Server is disabled.
+   - *Fix:* Enable the Web Server in Resolume's preferences.
+2. **`Trigger Clip fails / success status returned but no output`**
+   - *Cause:* The layer or clip indices do not contain active media assets, or the target deck is not selected.
+   - *Fix:* Call `get_composition` to inspect deck configurations and verify that the target layer/clip slot contains media.
+3. **`Port Conflict on 8080`**
+   - *Cause:* Another developer service (e.g. Apache, Tomcat, or Docker) is binding to port 8080.
+   - *Fix:* Change the web server port inside Resolume's Preferences -> Web Server settings, and update `RESOLUME_API_BASE` inside `resolume_mcp.py`.

package/skills/global_config/bdb-rhino-mcp.md

@@ -0,0 +1,153 @@
+---
+name: bdb-rhino-mcp
+description: Utilizes the Rhino MCP servers (RhinoMCP and golem-rhino-mcp) to create and manipulate 3D models and run Grasshopper graphs.
+---
+
+# Rhino 3D MCP — Integration and AI Agent Guide
+
+This skill file instructs AI agents on how to utilize the McNeel Rhino MCP and GOLEM-3DMCP integrations. It details tool prefixes, API structures, geometry operations, Grasshopper automation, and troubleshooting steps.
+
+## 1. Overview and Pipeline Value
+
+The **Rhino MCP Platform** and **GOLEM-3DMCP Server** connect AI agents to McNeel Rhino 7/8. This allows natural language-driven 3D CAD modeling, NURBS reconstruction, structural planning, and parametric scripting in Grasshopper.
+
+### Architecture
+- **In-Process socket server:** A custom startup script (`startup.py`) running inside Rhino's Python Script Editor creates a JSON-RPC 2.0 socket server on localhost.
+- **MCP Server bridge:** A Python MCP server proxy connects the AI assistant to the socket server, translating MCP tool calls to Rhino API calls.
+- **Grasshopper runtime:** Provides direct control over Grasshopper parameters, enabling real-time solver execution and parameter sweeps.
+
+---
+
+## 2. System Instructions
+
+### Workflow Priorities
+1. **Scene Audit first:** Always run `scene.get_document_info` or `scene.list_layers` to understand the scale, active units (e.g. millimeters vs. meters), and current hierarchy.
+2. **Object Lifecycle:** Many geometry operations (like booleans) consume their input objects and return new GUIDs. Update your working memory with the returned GUIDs and discard the consumed ones to prevent `OBJECT_NOT_FOUND` errors.
+3. **Run on UI Thread:** Complex viewport updates or UI-dependent Grasshopper runs require queuing on the Rhino UI thread. The MCP server handles this, but be prepared for a 30s timeout under heavy load.
+4. **Grasshopper Workflow:** Run `grasshopper.open_definition` before modifying sliders. Always call `grasshopper.recompute` to update the solver after changing parameter values.
+
+---
+
+## 3. Available Tools and API Parameters
+
+GOLEM-3DMCP provides 105 granular tools across multiple categories.
+
+### Scene Intelligence (`scene.*`)
+- **`scene.get_document_info()`**: Returns units, tolerance, layer count, and bounding box.
+- **`scene.list_layers()`**: Lists all layers, visibility, lock states, and colors.
+- **`scene.list_objects(object_type: string, layer?: string)`**: Lists objects with optional type filters (point, curve, surface, brep, mesh, subd, annotation).
+- **`scene.get_object_info(guid: string)`**: Returns precise control points, layer, and metadata.
+- **`scene.create_layer(name: string, color?: object)`**: Creates layers (nested with `::` syntax).
+
+### Geometry Creation (`create_*`)
+- **`create_box(width: float, depth: float, height: float, corner_x?: float, corner_y?: float, corner_z?: float)`**
+- **`create_sphere(radius: float, center_x?: float, center_y?: float, center_z?: float)`**
+- **`create_cylinder(radius: float, height: float)`**
+- **`create_nurbs_curve(points: list[list[float]], degree?: int)`**
+- **`create_polyline(points: list[list[float]], closed?: boolean)`**
+- **`create_text(text: string, location: list[float], height: float)`**
+
+### Geometry Operations (`operations.*` & `surfaces.*`)
+- **`operations.boolean_union(guids: list[string])`**: Unions closed solids.
+- **`operations.boolean_difference(guid_a: string, guids_b: list[string])`**: Cuts `guids_b` from `guid_a`.
+- **`operations.offset_curve(curve_id: string, distance: float)`**
+- **`operations.fillet_edge(brep_id: string, edge_indices: list[int], radius: float)`**
+- **`surfaces.loft(curve_ids: list[string], loft_type?: string)`**
+- **`surfaces.sweep1(rail_id: string, shape_ids: list[string])`**
+
+### Grasshopper Automation (`grasshopper.*`)
+- **`grasshopper.open_definition(path: string)`**: Loads a `.gh` or `.ghx` definition.
+- **`grasshopper.get_parameters()`**: Queries all sliders, panels, and outputs.
+- **`grasshopper.set_parameter(name_or_id: string, value: any)`**: Modifies sliders or inputs.
+- **`grasshopper.recompute()`**: Forces a solution recalculation.
+- **`grasshopper.get_output_value(name_or_id: string)`**: Reads output component values.
+
+### Scripting and Viewports (`scripting.*` & `viewport.*`)
+- **`scripting.execute_python(code: string)`**: Runs arbitrary Python script utilizing `Rhino` and `rhinoscriptsyntax`.
+- **`viewport.capture_to_file(path: string, width?: int, height?: int)`**: Captures the current view.
+- **`viewport.set_camera(location: list[float], target: list[float])`**: Points the camera.
+
+---
+
+## 4. Code Recipes and Prompt Cookbook
+
+### Recipe 1: Parametric Truss Setup in Grasshopper
+Open a Grasshopper file, adjust structural dimensions, and extract the generated geometry:
+
+```json
+// Step 1: Load file
+// Tool: grasshopper.open_definition(path="/Users/timrennings/project/truss.gh")
+
+// Step 2: Modify span and height
+// Tool: grasshopper.set_parameter(name_or_id="SpanSlider", value=150.0)
+// Tool: grasshopper.set_parameter(name_or_id="HeightSlider", value=22.5)
+
+// Step 3: Recompute solver
+// Tool: grasshopper.recompute()
+
+// Step 4: Bake outputs
+// Tool: grasshopper.bake_output(name_or_id="TrussGeometry", layer="StructuralTrusses")
+```
+
+### Recipe 2: Custom NURBS Loft Creation
+To generate custom ribs and loft a skin between them using Python scripting:
+
+```python
+# Call tool: scripting.execute_python(code="...")
+import rhinoscriptsyntax as rs
+import math
+
+curves = []
+for i in range(5):
+    points = []
+    for j in range(10):
+        x = i * 20.0
+        y = j * 10.0
+        z = math.sin(j * 0.5) * 15.0 + (i * 2.0)
+        points.append([x, y, z])
+    
+    # Create curve
+    crv = rs.AddNurbsCurve(points)
+    curves.append(crv)
+
+# Loft skin
+loft = rs.AddLoftSrf(curves)
+rs.ObjectName(loft, "ProceduralNurbsCanopy")
+print(f"Lofted canopy created with ID: {loft}")
+```
+
+---
+
+## 5. Troubleshooting and Connection Details
+
+### Connection Setup
+- **Default Port:** `9876` (TCP socket communication)
+- **Rhino Startup Script:** `rhino_plugin/startup.py`
+- **Verify Connection:**
+  ```bash
+  # Check if server is running on the port
+  lsof -i :9876
+  ```
+
+### Common Errors and Fixes
+
+1. **`RhinoConnectionError: Cannot connect to Rhino plugin at 127.0.0.1:9876`**
+   - *Cause:* The plugin server is not running inside Rhino.
+   - *Fix:* Open Rhino's Python script editor, open `rhino_plugin/startup.py`, and run it. To automate, add it to Options -> RhinoScript -> Startup scripts.
+   
+2. **`GH not available`**
+   - *Cause:* Grasshopper is installed but has not been loaded in the active session.
+   - *Fix:* Run the `Grasshopper` command in Rhino once, then restart the GOLEM plugin by running:
+     ```python
+     import rhino_plugin.startup as golem
+     golem.restart_golem()
+     ```
+
+3. **`RhinoTimeoutError`**
+   - *Cause:* An operation took longer than the default 30-second threshold.
+   - *Fix:* Increase the timeout in your `.mcp.json` config:
+     ```json
+     "env": {
+       "GOLEM_TIMEOUT": "120"
+     }
+     ```

package/skills/global_config/bdb-touchdesigner-mcp.md

@@ -0,0 +1,116 @@
+---
+name: bdb-touchdesigner-mcp
+description: Utilizes the TouchDesigner MCP servers (tdmcp and touchdesigner-mcp) to create TOP/CHOP chains, script operators, inspect parameters, and debug node networks.
+---
+
+# TouchDesigner MCP — Integration and AI Agent Guide
+
+This skill file instructs AI agents on how to construct real-time visual systems inside TouchDesigner using the `tdmcp` (MindDesigner) and `touchdesigner-mcp` (Backup) integrations. It details node building, operator classes, preview generation, and troubleshooting steps.
+
+## 1. Overview and Pipeline Value
+
+The **TouchDesigner MCP (MindDesigner)** server enables AI models to programmatically construct, connect, parameterize, and debug node networks in TouchDesigner. In the BDB OS architecture, this automates audio-reactive particle simulations, feedback systems, projection mapping, GLSL shader chains, and data visualizations.
+
+### Architecture
+- **In-Process WebServer / Socket Bridge:** A custom component (e.g. `tdmcp_bridge_package.tox` or `mcp_webserver_base.tox`) is placed inside TouchDesigner. It listens on a local port and translates incoming JSON commands to Python operations (like `parent().create(noiseTOP)`).
+- **Dual Server Layout:**
+  - *`tdmcp` (MindDesigner):* Runs on port `9980`. Focuses on creative visual engineering with 332 high-level generation tools.
+  - *`touchdesigner-mcp` (Backup/Direct):* Runs on port `9981`. Focuses on atomic node CRUD and low-level scripting fallback.
+
+---
+
+## 2. System Instructions
+
+### Workflow Priorities
+1. **Bridge Verification first:** Always call `get_td_info` to confirm the TouchDesigner bridge is reachable and running compatible versions.
+2. **Consult Operator Knowledge:** Consult the operator library before placing nodes. Never guess operator types or namespaces (e.g. use `noiseTOP` for a Noise TOP, `constantCHOP` for a Constant CHOP).
+3. **Structured Tools first:** Prefer structured inspection and modification tools (`find_td_nodes`, `get_td_node_parameters`, `update_td_node_parameters`, `get_td_node_errors`) over raw Python execution. Use `execute_python_script` only when no structured tool fits the request.
+4. **Visual Feedback:** After creating or modifying a network, call `get_preview` or `get_inline_preview` so the user can verify the rendering in real-time.
+
+---
+
+## 3. Available Tools and API Parameters
+
+### High-Level Creative Tools (`tdmcp`)
+- **`create_audio_reactive(layer_name: string)`**: Sets up a complete audio spectrum analyzer routing to video modifiers.
+- **`create_feedback_network(parent: string, input_op: string)`**: Creates a feedback loop using feedback, blur, level, and composite TOPs.
+- **`create_particle_system(parent: string)`**: Generates a GPU particle flow using SOPs, CHOPs, and TOPs.
+- **`animate_parameter(op_path: string, par_name: string, chop_expr: string)`**: Binds a node parameter to a CHOP expression.
+
+### Atomic Node Tools (`touchdesigner-mcp` & fallback)
+- **`create_td_node(type: string, path: string, name: string)`**: Places a single node in a network container.
+- **`delete_td_node(path: string)`**: Deletes an operator.
+- **`connect_nodes(from_op: string, to_op: string, from_connector?: int, to_connector?: int)`**: Connects outputs to inputs.
+- **`get_td_nodes(path: string)`**: Lists all operators in a specific network.
+- **`get_td_node_errors(path: string)`**: Checks for active operator errors (red flags) recursively.
+- **`update_td_node_parameters(path: string, parameters: object)`**: Modifies parameter settings.
+
+---
+
+## 4. Code Recipes and Prompt Cookbook
+
+### Recipe 1: Procedural Feedback Loop (MindDesigner)
+Generate a feedback warp tunnel TOP chain:
+
+```json
+// Step 1: Create noise source
+// Tool: create_td_node(type="noiseTOP", path="/project1", name="noise_src")
+
+// Step 2: Set noise parameters
+// Tool: update_td_node_parameters(path="/project1/noise_src", parameters={"resolutionw": 1080, "resolutionh": 1080, "period": 2.5})
+
+// Step 3: Set up feedback loop
+// Tool: create_feedback_network(parent="/project1", input_op="/project1/noise_src")
+```
+
+### Recipe 2: Run Custom Python Script for Network Connection
+Connect a series of CHOPs programmatically when structured connection tools are not flexible enough:
+
+```python
+# Call tool: execute_python_script(script="...")
+parent_comp = op('/project1')
+lfo = parent_comp.create(lfoCHOP, 'oscillator')
+math_op = parent_comp.create(mathCHOP, 'modifier')
+null_op = parent_comp.create(nullCHOP, 'out_signal')
+
+# Connect ports
+math_op.inputConnectors[0].connect(lfo)
+null_op.inputConnectors[0].connect(math_op)
+
+# Set Math CHOP range multiplier
+math_op.par.mult = 100.0
+```
+
+---
+
+## 5. Troubleshooting and Connection Details
+
+### Configuration and Ports
+- **MindDesigner Port:** `9980` (`TDMCP_PORT` environment variable)
+- **Backup Controller Port:** `9981` (WebServer port)
+- **Verify Endpoint Availability:**
+  ```bash
+  # Check if MindDesigner is reachable
+  curl http://localhost:9980/api/info
+  ```
+
+### Bridge Installation inside TouchDesigner
+1. Download `tdmcp_bridge_package.tox` or `mcp_webserver_base.tox`.
+2. Drag the `.tox` component directly into your active network pane (e.g. `/project1`).
+3. Press **Install** / verify the active port is running.
+
+Alternative Textport Bootstrap Installation:
+Open TouchDesigner Textport (`Dialogs -> Textport and DATs`), paste and run:
+```python
+import urllib.request; exec(urllib.request.urlopen("https://github.com/Pantani/tdmcp/raw/v0.12.0/td/bootstrap.py").read().decode())
+```
+
+### Common Errors and Fixes
+1. **`TouchDesignerClient ECONNREFUSED`**
+   - *Cause:* The bridge component is either not installed or disabled in TouchDesigner.
+   - *Fix:* Ensure you dragged the `.tox` component into the project and that its internal server is toggled active.
+2. **`Operator compilation error or red flag`**
+   - *Cause:* An invalid parameter type or code was set.
+   - *Fix:* Run `get_td_node_errors` on the path of the flagged node to read the compiled compiler/interpreter traceback.
+3. **`Version Mismatch Warning`**
+   - *Fix:* Download the latest bridge zip file from releases, delete the old `touchdesigner-mcp-td` folder in your project, restart TouchDesigner, and drop in the new `.tox`.

package/skills/global_config/bdb-unreal-mcp.md

@@ -0,0 +1,130 @@
+---
+name: bdb-unreal-mcp
+description: Utilizes the Unreal Engine MCP server to control UE5 via a native C++ Automation Bridge plugin.
+---
+
+# Unreal Engine MCP — Integration and AI Agent Guide
+
+This skill file instructs AI agents on how to interact with the Unreal Engine 5.8+ MCP Server. It details the tool capabilities, API schemas, design patterns, workflows, scripting rules, and troubleshooting steps for asset management, actor manipulation, and level automation.
+
+## 1. Overview and Pipeline Value
+
+The **Unreal Engine MCP Server** bridges AI assistants to Unreal Engine 5 (5.0–5.8+) using a native C++ `McpAutomationBridge` plugin. In the BDB OS ecosystem, this integration automates environment construction, material generation, cinematic sequences (Sequencer), Blueprint orchestration, and visual effects (Niagara). 
+
+### Architecture
+- **Dual Transport:** 
+  - *Native MCP Mode:* Direct Streamable HTTP/SSE transport (`http://localhost:3000/mcp`) running inside the UE process. No Node.js required.
+  - *TypeScript Bridge Mode:* Standard stdio-based bridge using a Node.js process proxying over WebSocket to the plugin's Automation Port (default `8091`).
+- **Discovery Mechanism:** Automatically discovers runtime properties, light classes, debug shapes, and track types using Unreal reflection.
+- **On-Demand Resilience:** Starts gracefully and will auto-reconnect if the Unreal Editor goes offline or is restarted.
+
+---
+
+## 2. System Instructions
+
+### Workflow Priorities
+1. **Introspection First:** Always call `inspect` with `action="inspect_class"` or `action="inspect_cdo"` before mutating parameters. Never guess property names or paths.
+2. **Path Conventions:** Use Unreal paths starting with `/Game/` (e.g., `/Game/Materials/M_Chrome`). Respect additional content mount prefixes registered in `MCP_ADDITIONAL_PATH_PREFIXES`.
+3. **Safety Rules:** Dangerous console commands are pattern-filtered by the bridge. Use high-level tools (`manage_asset`, `control_actor`) rather than running raw console commands.
+4. **Python Scripting:** For complex operations that require native API access not exposed via tools, use `system_control` with `action="execute_python"`. Keep code size under 1MB.
+
+---
+
+## 3. Available Tools and API Parameters
+
+The server exposes 23 canonical MCP tools.
+
+| Tool | Action | Parameters | Description |
+| :--- | :--- | :--- | :--- |
+| **`manage_asset`** | `list`, `search_assets`, `import`, `duplicate`, `rename`, `move`, `delete`, `create_folder`, `get_asset`, `get_dependencies`, `analyze_graph`, `set_tags`, `validate`, `create_material`, `create_material_instance`, `create_render_target`, `connect_material_pins` | `objectPath: string`, `destinationPath?: string`, `tags?: object` | Creates, deletes, queries, or modifies project assets and materials. |
+| **`manage_blueprint`** | `create`, `get_blueprint`, `compile`, `add_component`, `set_default`, `get_scs`, `create_node`, `delete_node`, `connect_pins` | `blueprintPath: string`, `componentName?: string`, `properties?: object` | Manages Blueprints, SCS components, graph connections, and compilation. |
+| **`control_actor`** | `spawn`, `spawn_blueprint`, `delete`, `delete_by_tag`, `duplicate`, `set_transform`, `get_transform`, `set_visibility`, `add_component`, `add_tag`, `attach`, `detach` | `actorClass?: string`, `blueprintPath?: string`, `location: float[]`, `rotation: float[]`, `scale: float[]` | Controls spawning, physics, tags, and transforms of actors in the active level. |
+| **`control_editor`** | `play`, `stop`, `set_camera`, `console_command`, `screenshot`, `create_bookmark` | `command?: string`, `location?: float[]`, `rotation?: float[]` | Triggers Play-In-Editor (PIE), positions viewports, and captures screenshots. |
+| **`manage_level`** | `load_level`, `save_level`, `save_level_as`, `stream`, `unload_level`, `create_level`, `build_lighting`, `add_sublevel` | `levelPath: string`, `shouldSave?: boolean` | Manages map loading, streaming, sublevel structure, and lighting builds. |
+| **`build_environment`** | `create_landscape`, `sculpt`, `paint_foliage`, `add_foliage_instances`, `create_procedural_terrain` | `dimensions?: int[]`, `materialPath?: string`, `foliageType?: string` | Automates landscapes, terrain, and foliage placement. |
+| **`system_control`** | `execute_python`, `console_command`, `run_tests`, `subscribe`, `unsubscribe`, `set_project_setting` | `code?: string`, `command?: string` | Low-level execution, settings access, log subscriptions, and Python integration. |
+| **`inspect`** | `inspect_object`, `inspect_class`, `inspect_cdo`, `set_property`, `get_property` | `objectPath: string`, `propertyName?: string`, `propertyValue?: any` | Reflective inspection of live CDO or instantiated object properties. |
+| **`manage_sequence`** | `create`, `add_actor`, `play`, `add_keyframe`, `add_camera`, `add_track` | `sequencePath: string`, `actorPath?: string`, `time?: float` | Creates and drives Sequencer cinematics, tracks, and camera paths. |
+| **`manage_audio`** | `create_sound_cue`, `play_sound_2d`, `play_sound_at_location`, `create_audio_component` | `soundPath: string`, `location?: float[]` | Manages MetaSounds, SoundCues, mixes, attenuation, and spatialized playback. |
+| **`manage_ai`** | `add_node`, `connect_nodes`, `set_node_properties`, `get_tree` | `treePath: string`, `nodeClass?: string` | Builds and queries Behavior Trees, blackboard keys, and EQS queries. |
+| **`manage_geometry`** | `create_box`, `boolean_union`, `boolean_subtract`, `extrude`, `auto_uv`, `convert_to_static_mesh` | `width?: float`, `height?: float`, `meshName?: string` | Procedural modeling in editor using Unreal Geometry Script. |
+
+---
+
+## 4. Code Recipes and Prompt Cookbook
+
+### Recipe 1: Inline Python Scripting via system_control
+To create custom asset chains or perform batch automation directly via Unreal's Python API:
+
+```python
+# Call tool: system_control(action="execute_python", params={"code": "..."})
+import unreal
+
+def setup_studio_lighting():
+    # Retrieve subsystems
+    editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+    
+    # Spawn directional light
+    dir_light_class = unreal.DirectionalLight.static_class()
+    light_actor = editor_actor_subsystem.spawn_actor_from_class(dir_light_class, unreal.Vector(0, 0, 500))
+    light_component = light_actor.get_component_by_class(unreal.DirectionalLightComponent.static_class())
+    light_component.set_intensity(10.0)
+    
+    # Spawn sky light
+    sky_light_class = unreal.SkyLight.static_class()
+    sky_actor = editor_actor_subsystem.spawn_actor_from_class(sky_light_class, unreal.Vector(0, 0, 1000))
+    
+    unreal.log("Studio lighting initialized successfully.")
+
+setup_studio_lighting()
+```
+
+### Recipe 2: Procedural Geometry Construction
+To create a procedural staircase using the Geometry Scripting API:
+
+```python
+# Call tool: manage_geometry(action="create_stairs", params={"width": 200, "height": 300, "steps": 12})
+# Followed by: manage_geometry(action="convert_to_static_mesh", params={"meshPath": "/Game/Geometry/SM_ProceduralStairs"})
+```
+
+### Recipe 3: Material Instance Setup
+Create a master material instance and override properties programmatically:
+
+```json
+// Tool Call: manage_asset(action="create_material_instance")
+{
+  "parentMaterialPath": "/Game/Materials/M_MasterShader",
+  "destinationPath": "/Game/Materials/Instances/MI_GlossyRed"
+}
+
+// Tool Call: inspect(action="set_property")
+{
+  "objectPath": "/Game/Materials/Instances/MI_GlossyRed",
+  "propertyName": "VectorParameterValues",
+  "propertyValue": {
+    "ParameterName": "BaseColor",
+    "ParameterValue": [1.0, 0.0, 0.0, 1.0]
+  }
+}
+```
+
+---
+
+## 5. Troubleshooting and Connection Details
+
+### Connection Setup
+- **Native Port:** `3000` (Direct HTTP endpoint: `http://localhost:3000/mcp`)
+- **Bridge Port:** `8091` (Used for TS bridge to communicate with the C++ plugin)
+- **Status Indicator:** Look for `● MCP :3000 (X)` in the Unreal Editor status bar (bottom-right). Green means active.
+
+### Command Verification
+Verify port binding and server availability from terminal:
+```bash
+# Verify native server
+curl http://localhost:3000/mcp/tools
+```
+
+### Common Errors
+1. **`McpAutomationBridge not loaded`**: Make sure the plugin is enabled in your `.uproject` file under `Plugins` and that your project is compiled.
+2. **`Missing Python Subsystem`**: Ensure that the **Python Editor Script Plugin** and **Editor Scripting Utilities** are enabled in the editor preferences.
+3. **`Connection Timeout`**: If running over LAN, check that `Listen Host` is set to `0.0.0.0` and that the `Allow Non Loopback` setting is active in the project's plugin settings.