kevinpbuckley/VibeUE

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "animation-system"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Animation Blueprint Skill

> **Loading skills:** skills load through the engine's `AgentSkillToolset` (`ListSkills`/`GetSkills`) —
> there is no `vibeue-skills-manager` tool. Run VibeUE services with `execute_python_code`
> (`unreal.AnimGraphService.<method>()`); reach engine toolsets with `call_tool`.

> An AnimBP **is a Blueprint**. The state-machine/AnimGraph authoring here is VibeUE
> `AnimGraphService` (intact). For its **variables and compile**, note VibeUE's `BlueprintService`
> was trimmed: **variable creation and blueprint compile moved to the engine** toolset
> `editor_toolset.toolsets.blueprint.BlueprintTools` (`add_variable`, `compile_blueprint`), called via
> `call_tool`. `BlueprintService` still has `list_variables`, `get_variable_info`,
> `set_variable_default_value`, `variable_exists`, components, and overridable functions. Bool fields

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "animation-system"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Animation Editing Skill

Covers the **profile → preview → validate → bake** workflow for safe bone edits with correct
bone-space handling and constraint validation.

> **Load companion skills:** `animsequence` (basic keyframe creation), `skeleton` (structure,
> retargeting), `animation-blueprint` (state machines / AnimGraph). Skills load via the engine's
> `AgentSkillToolset` (`ListSkills` / `GetSkills`) — there is no `vibeue-skills-manager` tool. Run the
> VibeUE services below with `execute_python_code` (`unreal.<Service>.<method>()`).

> **🛡<U+FE0F> Safe discovery — never `unreal.load_asset()` in loops (memory crash 0xC0000005).**
> Use `SkeletonService.list_skeletons(path)`, `AnimSequenceService.find_animations_for_skeleton(skeleton)`,

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "animation-system"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Animation Montage Skill

Use `AnimMontageService` for animation montage operations.

## Quick Reference - Python API

### Discovery Methods
> ⚠<U+FE0F> **`list_montages` filters are strings, not `None`** (issue #461) — pass `""` for "no
> filter", never `None` (an FString arg can't be null and raises a TypeError).
> **Playback rate:** there is no `set_playback_rate_scale` method; set the montage's `RateScale`
> directly — `unreal.load_asset(montage_path).set_editor_property("RateScale", 1.5)` then
> `unreal.EditorAssetLibrary.save_asset(montage_path)`.

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "animation-system"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Animation Sequence & Editing Skill

This skill covers the **inspect → profile → preview → validate → bake** workflow for safe animation bone edits with correct bone-space handling and constraint validation.

> **Loading skills:** skills load via the engine's `AgentSkillToolset` (`ListSkills` / `GetSkills`) —
> there is no `vibeue-skills-manager` tool. Run the VibeUE services below with `execute_python_code`
> (`unreal.AnimSequenceService.<method>()` / `unreal.SkeletonService.<method>()`).
>
> **Related Skills:**
> - **skeleton** - For modifying skeleton bone transforms/hierarchy and retargeting modes
> - **animation-blueprint** - For state machines and AnimGraph navigation
>

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "asset-management"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Asset Discovery & Management Skill

For static-mesh LOD reimport, lost textures or gray/default surfaces despite a
correct component material, read [mesh reimport material mappings](references/mesh-reimport-materials.md).
The bundled `scripts/mesh_material_slots.py` exposes explicit section inspection
and remapping through the existing engine Python API; no native service rebuild.

> 🔀 **Engine owns general asset ops now.** In the Unreal 5.8 consolidation, searching, loading,
> saving, moving, renaming, duplicating, and deleting assets moved to Unreal's native **`AssetTools`**
> toolset (reach it via `call_tool`; run `describe_toolset` for its actions) — or you can drive
> `unreal.EditorAssetLibrary` / `unreal.AssetRegistryHelpers` directly from `execute_python_code`.
> The old **`manage_asset` MCP tool is GONE.** VibeUE's `AssetDiscoveryService` was trimmed to only

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this
> session, call it with `{action: "load", skill: "ai-and-navigation"}` for UE domain knowledge on
> Behavior Trees — architecture, node semantics, best practices. If no such tool is available, skip
> this line entirely and proceed with this skill alone — do NOT attempt the call.

# Behavior Trees Skill

Two services, reachable from Python (`unreal.BehaviorTreeService.*`, `unreal.BlackboardService.*`)
and as AICallable tools:

```
BlackboardService     → UBlackboardData assets: create, key CRUD, metadata, re-parenting
BehaviorTreeService   → UBehaviorTree assets: structure, sub-nodes, properties, build, validate
```

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "blueprint-fundamentals"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Blueprint Graph Editing Skill

> **Also load `blueprints` skill** when creating new blueprints, adding variables/components, or overriding functions.
> This skill covers **node-level graph editing** — adding nodes, wiring pins, setting values, and layout.

## Critical Rules

### ⚠<U+FE0F> Nothing works during Play-In-Editor — and it fails SILENTLY

Every `BlueprintService` method resolves its target through `LoadBlueprint()`, which fails while PIE
is running. You get no error. You get an **empty array**, **`False`**, or an **empty-string node id**
— which reads exactly like "that node type doesn't exist" or "that spawner key is wrong". It is very

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "blueprint-fundamentals"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Blueprint System Skill

> **For node-level graph editing** (adding nodes, connecting pins, wiring logic, timers, layout), load the `blueprint-graphs` skill.

## Critical Rules

### ⚠<U+FE0F> Components added with `add_component` are NOT on the CDO

`add_component` creates a **SCS node template**, not an instance on the class default object. So the
obvious way to configure it silently does nothing — `get_components_by_class` on the CDO returns an
empty list and the loop body never runs:

# Safe Bulk Maintenance

Use `unreal.WorkflowService.run_bulk_maintenance(plan_json, apply, batch_size, stop_on_error)` for an
explicit target list. It is dry-run-first, path-scoped, bounded to 100 targets per GC batch, returns
one result per target, rolls back a failed apply operation, and writes a resumable report under
`Saved/VibeUE/Bulk`.

Rules:

1. Discover candidates, but pass the final explicit `targets` array yourself. Never turn a search
   result directly into deletion.
2. Call once with `apply=False`, inspect every `would-change`/refusal, then repeat the exact plan with
   `apply=True` and the same `resume_id`.
3. Set `path_scope` so a malformed target cannot escape the intended content folder.

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this
> session, call it with `{action: "search", query: "mutable customizable object"}` for UE domain
> knowledge on Mutable. If no such tool is available, skip this line entirely and proceed with this
> skill alone — do NOT attempt the call.

# Mutable Customizable Objects Skill

One service, reachable from Python (`unreal.CustomizableObjectService.*`) and as AICallable tools.
It edits the Customizable Object's **editor graph** (the node graph you see in the CO editor) and
compiles it. Discover exact signatures with
`discover_python_class('unreal.CustomizableObjectService')`.

- **Is Mutable on?** `is_mutable_available()`. In UE 5.8 it normally is (the default-enabled
  MutableAssetUserData plugin loads it). If it returns False, every method explains that the

# Engine Settings Skill

> 🔀 **Registered settings moved to the engine.** Category-based registered-setting access
> (`list_categories` / `list_settings` / `get_setting` / `set_setting`) is now Unreal 5.8's native
> **`ConfigSettingsToolset`** — reach it with `call_tool` (run `describe_toolset` on
> `ConfigSettingsToolset` for its actions/params). VibeUE's `EngineSettingsService` was trimmed to
> the delta the engine doesn't cover: **console variables (cvars), scalability levels, raw engine
> INI read/write, and config save**. Use those from `execute_python_code` as shown below.

## Critical Rules

### ⚠<U+FE0F> CVars (VibeUE) vs Registered Settings (engine toolset)

- **CVars** (console variables) → `unreal.EngineSettingsService.get_console_variable` /

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "enhanced-input"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Enhanced Input Skill

## Critical Rules

### 🚨 Real Python method names — do NOT search for the docstring's "action" names

The `InputService` class docstring lists MCP-style action ids (`action_create`,
`mapping_list_contexts`, `action_configure`, ...). Those are **not** the Python method
names — `discover_python_class(method_filter=...)` matches nothing for them. The complete
real API is below; you rarely need a discovery call at all:

| Area | Methods |

# Enum and Struct Skill

## Critical Rules

### Read-Only Native Types

Native C++ enums and structs are **read-only**. Only UserDefinedEnums and UserDefinedStructs can be modified:

```python
import unreal

# Search for user-defined enums only (editable)
enums = unreal.EnumStructService.search_enums("Weapon", True)  # bUserDefinedOnly=True

# Fab asset import

`FabService` supports two deliberately separate paths:

- **Public free catalog:** search exact zero-price listings and directly import eligible glTF/GLB
  downloads. This does not sign in, purchase, claim an entitlement, or add the listing to My Library.
- **Owned library:** use the editor/launcher Epic session to list and import assets already owned by the
  account, including migrated Unreal Marketplace items.

## Public free flow (Quixel/Megascans and other sellers)

1. Call `search_free_catalog(query="", seller_filter="Quixel Megascans", format_filter="gltf")`.
   Results are compact and include `id`, `title`, `seller`, `price`, formats, thumbnail, and an opaque
   `next_cursor`. Results require an exact-zero **Personal** tier; UEFN-reference-only offers are

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "landscape-and-foliage"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Foliage & Vegetation Skill

## Critical Rules

### Mesh Path Required

All placement methods require a valid `UStaticMesh` or `UFoliageType` asset path. Use `discover_python_class('unreal.FoliageService')` to see available methods.

### Surface Trace

All scatter/add methods trace downward to find the ground surface. If no surface is hit (e.g., position is outside the landscape bounds), that instance is rejected. Check `instances_rejected` in the result.

# Frame Rate / FPS Caps Skill

A "locked at 60 FPS" editor or game is almost never caused by a single setting — there
are **five independent caps** and any one of them holds the frame rate down. Check and
clear them all, in this order, before declaring it fixed.

## ⚠<U+FE0F> Diagnose first — don't guess

`t.MaxFPS = 0` already means *uncapped*, so if the editor is still stuck at 60 the cap is
coming from somewhere else (usually VSync to a 60 Hz monitor, or the smoothed frame-rate
range). Read every source below before changing anything.

> 🩺 **"Capped" vs "slow" are different problems.** If the frame rate is *low* rather than *pinned*
> at a round number, it's not a cap — it's a workload. Run `unreal.PerformanceService.frame_timing()`

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "gameplay-tags"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Gameplay Tags Skill

Manage Unreal Engine Gameplay Tags. Core CRUD (add / remove / rename / list) is now owned by
Unreal 5.8's native **`GameplayTagsToolset`** (call it via `call_tool`). VibeUE keeps only the
delta the engine toolset does NOT provide — runtime hierarchy queries, bulk registration, and
tag-value lookup: `unreal.GameplayTagService.has_tag` / `get_tag_info` / `get_children` /
`add_tags` / `request_tag` / `request_tag_container`.

Tags are written to INI config **and** registered at runtime — they appear immediately in the editor tag picker without restart.

## Critical Rules

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "gameplay-ability-system"}` for UE domain knowledge (ASC setup, attribute/effect/ability APIs, networking) — treat it as the rubric for any review / "best practices" question. If no such tool is available, skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Gameplay Ability System Skill

**Compose, do not duplicate.** Everything GAS needs already exists across Epic's engine toolsets,
the generic Blueprint/Object tools, and Python. VibeUE adds no GAS wrapper service; this skill is
the routing map plus the live-verified gotchas.

## Ownership matrix — who does what

| Operation | Owner |
|---|---|
| Inspect a live ASC (PIE): attributes, active tags, active effects, granted abilities | Epic **`GASToolsets.AbilitySystemInspectorToolset`** → `GetAttributeValues` / `GetActiveTags` / `GetActiveEffects` / `GetGrantedAbilities`. Input is `{"actor": {"refPath": "<actor path>"}}` — works on PIE actors, no selection needed |
| Discover attribute set classes / attributes | Epic **`GASToolsets.AttributeSetToolset`** → `FindAttributeSetClasses` / `ListAttributes` |

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "landscape-and-foliage"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Landscape Terrain Skill

## Sub-docs available

This skill is split into the lean index (you are reading it) plus sibling sub-docs. Skills
load via the engine's `AgentSkillToolset` (`ListSkills` / `GetSkills`) — request
`landscape/<section>` through `GetSkills`, or read the sibling `*.md` file (it sits next to
this `SKILL.md` on disk) directly:

| Sub-doc | When to load |
|---------|--------------|
| `return-types.md` | Exact property names of `LandscapeCreateResult`, `LandscapeInfo_Custom`, `LandscapeLayerInfo_Custom`, `LandscapeSplinePointInfo`, `LandscapeSplineSegmentInfo`, `LandscapeSplineMeshEntryInfo`, plus the `create_landscape` signature. |

# Landscape Auto-Material System Skill

## When to Use This Skill

Use this skill when you need **production-quality** landscape materials with:
- A master material → material instance workflow (artists change parameters, not graphs)
- Automatic layer blending by slope, altitude, or distance
- Material functions for reusable logic (layer sampling, color correction, etc.)
- Runtime Virtual Textures for scalable landscape rendering
- Biome configuration through material instances (swap textures/thresholds, same master)

For **simple prototyping** with 2-5 painted layers, load the **landscape-materials** skill instead (the engine's AgentSkillToolset `GetSkills` exposes it).

## Architecture Overview

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "materials-and-shaders"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Landscape Material System Skill

## When to Use This Skill vs. landscape-auto-material

- **This skill** (`landscape-materials`): Simple materials with 2-5 layers using `LandscapeLayerBlend`. Good for prototyping.
- **`landscape-auto-material`**: Production materials using material functions, RVT, and material instances. Good for shipping quality. Use when you need the Real_Landscape paradigm with auto-layering, altitude/slope blending via material functions, and biome configuration through material instances.

If you need material functions, Runtime Virtual Textures, or the master-material + instance pattern, load the **landscape-auto-material** skill (the engine's AgentSkillToolset `GetSkills` exposes it).

## Critical Rules

### 🚨 Inspect Before Modifying Existing Landscape Materials

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "actors-and-components"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Level Actors Skill

> 🔀 **Engine owns the basics now.** In the Unreal 5.8 consolidation, listing / finding / spawning /
> moving / transforming / selecting actors moved to Unreal's native toolsets — `ActorTools`,
> `SceneTools`, and `EditorAppToolset` (selection, camera, PIE, screenshots), reachable via
> `call_tool`. Equivalently you can drive `unreal.EditorActorSubsystem` /
> `unreal.LevelEditorSubsystem` directly from `execute_python_code` (shown throughout below).
> **VibeUE's `ActorService` was trimmed to only the delta the engine doesn't provide:** transform
> lock (`set_actor_lock_location`), absolute-transform flags, preserve-scale-ratio, viewport camera
> framing (`get_actor_view_camera` / `calculate_actor_view` / `set_viewport_camera`), and full
> property dumps (`get_all_properties`). `ActorService.add_actor` / `set_property` / `get_property`
> no longer exist — use the engine toolsets or `EditorActorSubsystem` for spawning and property edits.

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "levels-and-world-partition"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Procedural FPS Map Blockout Skill

Take a VibeUE-generated landscape (heightmap + paint layers) and turn it into a
fully validated, AAA-style open-world FPS map blockout — roads, POIs, fields,
forests/treelines, railway, bridges — then materialize the plan as real engine
geometry. Quality benchmark is **Arma / Squad**.

The design pipeline is **gated**: every stage runs ordered pass/fail checks
against the authoritative spec at [docs/design/map-designer-spec.md](../../../docs/design/map-designer-spec.md).
You may not advance until all checks PASS. On failure, fix the offending element
and re-run the stage.

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "materials-and-shaders"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Material System Skill

For generated textures on large organic surfaces, seams after triplanar projection,
or overly strong tissue relief, read [generated organic surfaces](references/generated-organic-surfaces.md).
For gray/default surfaces after mesh reimport, use the asset-management skill's
LOD-section mapping helper before changing the shader or buying new textures.

## Critical Rules

### Material information over MCP: use `GetMaterialInfoResult`

Call `VibeUE.MaterialService.GetMaterialInfoResult` with only `materialPath`.

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "audio-and-metasounds"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# MetaSound Service Skill

Use this skill to create and edit MetaSound Source assets via Python.

```python
import unreal
ms = unreal.MetaSoundService()
```

## Key Concepts

- **MetaSound Source** — a procedural audio asset (`UMetaSoundSource`) defined by a node graph. It replaces SoundCue for runtime-parameterisable sounds.

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "niagara-vfx"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

## Niagara Emitters Skill

> **Architecture (read first):** VibeUE extends Unreal's native MCP endpoint. Emitter **module and
> renderer CRUD** (add/remove/enable/reorder modules, add/remove renderers, set module/renderer
> inputs, search module scripts) are owned by the **engine** `NiagaraToolsets.*` toolsets, called
> through `call_tool`. VibeUE's `NiagaraEmitterService` was trimmed to the **color/curve authoring**
> the engine doesn't provide, plus a rapid-iteration-parameter reader.

**VibeUE `NiagaraEmitterService` (this skill) keeps ONLY color/curve authoring + a param reader:**
- `set_color_tint` — add/set a ScaleColor tint (handles ColorFromCurve automatically)
- `get_color_curve_keys` / `set_color_curve_keys` — read/replace ColorFromCurve keyframes
- `shift_color_hue` — hue-rotate a ColorFromCurve while preserving detail (best for recolors)

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "niagara-vfx"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

## Niagara Systems Skill

> **Architecture (read first):** VibeUE extends Unreal's native MCP endpoint. System / emitter /
> parameter **create / add / copy / remove / list / compile** are owned by the **engine** toolset
> `NiagaraToolsets.NiagaraToolset_System` (plus `…_Assets`, `…_Component`, `…_Blueprint`, `…_Info`),
> called through `call_tool`. VibeUE's `NiagaraService` was trimmed to the rapid-iteration-parameter
> tuning + diagnostics that the engine toolset does not cover, and `NiagaraScratchPadService`
> (Custom-HLSL graph authoring) which is unique to VibeUE.

**VibeUE `NiagaraService` (this skill) keeps ONLY:**
- Rapid-iteration parameter read/write — `list_rapid_iteration_params`, `set_rapid_iteration_param`, `set_rapid_iteration_param_by_stage`
- Diagnostics — `compare_systems`, `get_emitter_lifecycle`, `debug_activation`

# PCG Skill

PCG (Procedural Content Generation) in UE 5.7 is production-ready and fully scriptable via
the `PCGPythonInterop` plugin. No VibeUE service wrapper is needed — the Python API is complete.

## ⚠<U+FE0F> Read this before writing any code

These are the mistakes that cause infinite retry loops. Check each one before executing:

**Do not call `discover_python_class` or `discover_python_function` on any PCG class — this skill contains everything you need. Calling discover bloats context and causes content filter failures.**


1. **Volume Sampler input pin is `"Volume"`, not `"In"`** — `add_edge(input_node, 'In', sampler_node, 'Volume')`. Using `'In'` silently no-ops and produces 0 points.
2. **`voxel_size` is a `Vector`, not a float** — `set_editor_property('voxel_size', unreal.Vector(200, 200, 200))`. Passing a float raises a TypeError.

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "automation-and-testing"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Play-In-Editor (PIE) Testing Skill

PIE is the only way to validate runtime behavior — Blueprint logic, AI ticking, animation, input, widget interaction, gameplay events. Without starting PIE, your "fix" is unverified.

## PIE control — engine `EditorAppToolset`

Generic PIE start/stop/status is owned by Unreal 5.8's native **`EditorToolset.EditorAppToolset`**,
invoked through `call_tool` (run `describe_toolset` on it for exact action names/params):

| Action | Description |
|--------|-------------|
| `StartPIE` | Start PIE if not already running. Succeeds (no-op) if already running. |

# Profiling Skill

Unreal 5.8's native toolsets have **no** performance or tracing tools, so this is VibeUE's net-new
capability: `unreal.PerformanceService` answers "are we CPU- or GPU-bound?" and drives Unreal
Insights captures from Python with no C++ required. Run everything here through `execute_python_code`.

The whole API is small — read the live signatures once with
`discover_python_class(class_name="unreal.PerformanceService")`:

| Method | Purpose |
|--------|---------|
| `frame_timing(target_fps=60.0)` | Game/Render/GPU/RHI thread ms + a CPU-vs-GPU `bound` verdict + a `hint`, plus a per-thread `budget` breakdown gated against `target_fps` (`budget.meets_target` PASS/FAIL). **Run FIRST.** |
| `force_hitch(thread="game", ms=250.0, frames=1)` | Validation helper — deliberately stall a KNOWN thread (`"game"`/`"render"`/`"both"`/`"gpu"`) to confirm the verdict fires. CPU paths are self-measuring: validate from the SAME response (`observed_peak_*_ms`, `verdict_matched_expect`) — do NOT follow up with `frame_timing`. Only the async `gpu` path is read back on a following frame. Clamped (≤5000 ms, ~10 s total) for safety. |
| `report(title=..., source="both", file="")` | Write a self-contained, shareable HTML report (live verdict + budget + analyse stats + a data-driven "fix in this order" list) to `Saved/VibeUE/Performance/report_<timestamp>.html`. |

# Project Settings Skill

> 🔀 **Registered settings moved to the engine.** Category-based registered-setting access
> (`list_categories` / `list_settings` / `get_setting` / `set_setting` /
> `set_category_settings_from_json`) is now Unreal 5.8's native **`ConfigSettingsToolset`** — reach
> it with `call_tool` (run `describe_toolset` on `ConfigSettingsToolset` for its actions/params).
> VibeUE's `ProjectSettingsService` was trimmed to the delta the engine doesn't cover:
> **`discover_settings_classes` + direct INI read/write (`get_ini_value` / `set_ini_value` /
> `*_ini_array` / `list_ini_sections` / `list_ini_keys`) + config save**, plus
> **`set_settings_property` / `get_settings_property`** for one property of a settings class by
> name. Use those from `execute_python_code` as shown below.

## Critical Rules

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "animation-system"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Skeleton & Skeletal Mesh Skill

> **Architecture (read first):** VibeUE extends Unreal's native MCP endpoint. **Socket CRUD, bone
> enumeration, physics-asset assignment, and material/LOD/morph inspection** are owned by the **engine**
> toolset `editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools` (called via `call_tool`). VibeUE's
> `SkeletonService` was trimmed to what the engine doesn't cover: **bone transform/hierarchy editing,
> retargeting config, curve metadata, blend profiles, bone constraints, and learn-from-animations**.
>
> **Loading skills:** skills load through the engine's `AgentSkillToolset` (`ListSkills`/`GetSkills`) —
> there is no `vibeue-skills-manager` tool. Run VibeUE services with `execute_python_code`
> (`unreal.SkeletonService.<method>()`); reach engine tools with `call_tool` (discover with
> `list_toolsets` / `describe_toolset`).

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "audio-and-metasounds"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

> **Wrong skill for MetaSound assets?** If the user asked about `MetaSound`, `MS_` assets, or `UMetaSoundSource`, load the `metasounds` skill instead (via `GetSkills` / AgentSkillToolset).
> SoundCue and MetaSound are completely separate systems — do not use `SoundCueService` for MetaSound tasks.

# Sound Cue Editor Skill

## Service Access

```python
import unreal
svc = unreal.SoundCueService()
```

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "ai-and-navigation"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# StateTree Skill

StateTree is Unreal Engine's hierarchical state machine system for AI behavior and game logic.
This skill covers creating and editing StateTree assets via `unreal.StateTreeService`.

## ⚠<U+FE0F> StateTree Blueprint Tasks Require the Blueprints Skill

**StateTree Tasks prefixed `STT_` (e.g. `STT_Rotate`, `STT_Move`) are Blueprint assets.**
They are edited with `BlueprintService`, not `StateTreeService`.

**Always load the `blueprints` skill** when the user asks to:
- Add or edit variables on an STT task

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "landscape-and-foliage"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# Real-World Terrain Skill

Generates heightmaps and water feature splines from real geographic coordinates via the `terrain_data`
MCP tool. The tool downloads Mapbox tiles server-side and writes UE5-compatible heightmaps + landscape
splines into the project's `Saved/Terrain/` folder — no API key or chat configuration is required.

## Workflow

### Heightmap (always run first)

1. `preview_elevation` — fetch elevation stats + suggested settings. Returns `suggestedZScale`, `suggestedXYScales` (resolution → XY scale), height range.
2. `generate_heightmap` — generate the 16-bit PNG using suggested settings

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "umg-and-slate"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# UMG Widget Blueprints Skill

This skill covers authoring **Widget Blueprints (WBP)** with `WidgetService`. Read the Critical Rules
below first — they prevent the most common failures. Then pick a task from the Task Index and load the
matching workflow doc and/or run the matching sample script.

> Load the **`blueprints`** skill when you also need to add Blueprint variables, functions, or
> components, and **`blueprint-graphs`** when wiring event-graph nodes for bound events.

## Critical Rules

### 🚨 Creating Widget Blueprints — only one pattern works

> 🧠 **Brains complement:** IF an `unreal-engine-skills-manager` tool (external MCP) exists in this session, call it with `{action: "load", skill: "meshes-static-and-skeletal"}` for UE domain knowledge on this topic — correct APIs, architecture, best practices — and treat it as the rubric for any review / "best practices" question. If no such tool is available (e.g. running under Claude Code or Codex without that MCP), skip this line entirely and proceed with this skill alone — do NOT attempt the call.

# UV Mapping Skill

For seams on imported organic assets, first distinguish UV boundaries from split
corner normals, image-border wrapping and invalid material-section indices. See
the materials skill's `references/generated-organic-surfaces.md` and the
asset-management skill's `references/mesh-reimport-materials.md`. Do not unwrap
an approved mesh merely because its shading has a sharp band.

`UVMappingService` provides automation-grade UV channel manipulation for StaticMesh assets in UE 5.7+. The service is built around mesh-description editing and post-build commits — every mutation marks the package dirty and rebuilds render data, but **does not save**. Follow with `unreal.EditorAssetLibrary.save_asset(mesh_path)` once you finish a batch.

## When NOT to Use This Service

VibeUE is an **extension on Unreal Engine's native MCP endpoint** (`http://localhost:8000/mcp`).
There is no separate VibeUE server, no API key, and no in-editor chat — VibeUE simply registers
extra Python services (`unreal.<Service>`) and skill packs on top of the engine's own toolsets.

## Wait for VibeUE readiness after launch

`BuildAndLaunchGame.ps1` / `.sh` print `Editor-PID=<pid>` — treat that as the process identity. Check
once, then watch the filesystem for `<ProjectDir>/Saved/VibeUE/Signals/editor-<pid>-true.json` before
using MCP. Wait at most 180 seconds, do not poll MCP while waiting, and fail if that Editor process
exits or the timeout expires. Ignore signal files for other or dead PIDs. The signal only means
`RegisterToolsets()` reached its end; Python, World, and level readiness remain separate checks.

The file is JSON, written atomically, so it is complete the moment it appears:

# Viewport Control Skill

## Methods

| Method | Description |
|--------|-------------|
| `get_viewport_info()` | Get full viewport state (type, camera, FOV, exposure, layout) |
| `set_viewport_type(type)` | Switch perspective/orthographic views |
| `get_viewport_type()` | Get current view type as string |
| `set_view_mode(mode)` | Switch rendering mode (lit, wireframe, unlit, etc.) |
| `get_view_mode()` | Get current rendering mode |
| `set_fov(degrees)` | Set field of view (5-170, default 90) |
| `get_fov()` | Get current FOV |
| `set_near_clip_plane(distance)` | Set near clipping plane (-1 = engine default) |