Monolith exposes a small set of namespace-dispatch MCP tools instead of ~1,500+ individual tools. Call monolith_discover() to list available actions, then use {namespace}_query(action, params) to invoke them. monolith_discover is terse by default — it returns each action's name plus a one-line description, not the full per-action param schema. Fetch a single action's full param schema on demand with describe_query("action_schema"), or pass detail=true (alias verbose=true) to monolith_discover to get the full schemas inline. New AI clients can also call monolith_guide() to self-onboard.

In-tree action count is approximate: ~1,500+ actions across 25+ in-tree namespaces (public, in-tree only; all active by default, plus +45 experimental town-gen actions when bEnableProceduralTownGen=true). The per-namespace numbers in the table below are kept for structure, not precision — query monolith_discover() (its total_actions field) for the exact live figure at any moment.

monolith_discover is terse by default: for a namespace it returns each action's name and a one-line description (first sentence, else hard-capped at 150 chars on a word boundary with a ... suffix), not the full param schema. The response always carries a total field and, in terse mode, a schema_hint pointing at the lazy-fetch path. To get a single action's full param schema, call describe_query("action_schema").

By default (no limit) discover returns the COMPLETE action list. discover() with no namespace is unchanged.

Two framework namespaces also live in MonolithCore. They route through a reflection walker to 12 per-namespace adapters (blueprint, gas, ui, ai, niagara, material, audio, mesh, animation, logicdriver, combograph, plus one extension-plugin adapter), so your AI can populate or inspect deeply-nested property trees with one mental model.

Complete Blueprint lifecycle management. Create Blueprints from any parent class, then build them out entirely through MCP — add variables (including replicated with RepNotify), components with hierarchy, functions with full signatures, macros, event dispatchers. Wire up node graphs with typed pins, set defaults, connect execution flow. Bulk operations let you add dozens of nodes and wire them in a single call. Sugiyama auto-layout cleans up messy graphs. Interface scaffolding auto-generates stub event nodes for unimplemented interfaces. CDO property reading gives reflection-level access to any UPROPERTY default. Validation catches unused variables, disconnected nodes, duplicate events, and unimplemented interfaces without triggering a full compile.

Full material authoring pipeline. Create materials, material instances, and material functions from scratch. Build complete material graphs from a declarative JSON spec — one call to define expressions, wire connections, and set properties. Or work incrementally: add expressions, connect them, set properties, recompile. Custom HLSL expression nodes with typed inputs/outputs. Material instances with full parameter override lifecycle — scalar, vector, texture, static switch. Import textures from disk directly into UE assets. Render material previews to PNG or base64. Validate graphs for islands, broken references, and duplicate parameters. Export/import graphs as JSON for templating, migration, or version control. Batch operations across multiple materials. Compilation stats give you shader instruction counts and sampler usage.

The most comprehensive animation tooling available through any MCP server. Covers the entire UE animation pipeline — from raw sequences and bone-level key editing through montages, blend spaces, and composites, all the way up to Animation Blueprint state machines with structural writes. PoseSearch integration for motion matching workflows. IK Rig and Retargeter configuration. Control Rig hierarchy manipulation with structural writes. Skeleton management with socket CRUD, virtual bones, and curve editing. Notify systems with track management and duration control. This isn't read-only inspection — you can add states to ABP state machines, wire transitions, set transition rule expressions, add and connect anim graph nodes, and set state animations programmatically. 5 ABP write actions + 3 ControlRig write actions + 1 layout action ride alongside the 96 baseline + 13 PoseSearch entries.

Blend space auto-bake fix (Unreleased). The four blend space mutators — add_blendspace_sample, edit_blendspace_sample, delete_blendspace_sample, set_blend_space_axis — now call ResampleData() after each edit and mark the package dirty, so MCP-authored blend spaces no longer ship with empty triangulation and play the bind/reference pose at runtime. Repair existing broken blend spaces in place with bake_blend_space.

AnimGraph-authoring extensions (Unreleased). set_transition_rule gained an expression kind for compound multi-term transition conditions — terms: [{ lhs, op, rhs, abs?, negate? }] folded through Boolean AND/OR via combine: "and" | "or" — extending the existing bool / auto / compare kinds; get_transition_rule decodes it back. set_anim_node_pin_binding now bootstraps the binding object when a node has none, so it works on previously-unbound nodes instead of refusing them. auto_layout gained a formatter:"builtin" (also the auto fallback) that lays out anim graphs by dependency-aware layering WITHOUT Blueprint Assist, so layout works in release builds where Blueprint Assist is compiled out.

Reading a native layer back. It appears in blueprint list_graphs as type: "function" — as does the stock AnimGraph, since that classification is by array membership, not schema — and never in blueprint get_interfaces. animation get_linked_layers shows the consumer node title "<Layer>\nAnim Layer (self)", and add_linked_anim_layer reports interface_class: "<self>" with guid_resolved: false for a self bind.

Ordering constraint. Self-layer pose pins resolve against the ABP's generated skeleton class, so add_anim_layer_graph(compile=false) followed immediately by add_linked_anim_layer places a node with no pose pins. Keep the default compile=true, or recompile before placing. Placing the node against a compiled layer regenerates its pins: an output Pose plus one input pin per declared input pose.

Motion matching support via Epic's PoseSearch plugin. Read schema configurations (channels, sample rates, cardinality), inspect databases (sequences, sampling data), and manage database contents — add or remove animation sequences and query stats like pose count and search mode. Useful for setting up and iterating on motion matching configurations without touching the editor UI.

Inspect and configure IK Rigs and IK Retargeters. Read chain definitions, goals, solvers, and retarget roots from IK Rigs. Add or remove solvers (Full Body IK, PBIK, TwoBone, etc.). Inspect Retargeter chain mappings between source and target rigs, including auto-map status per chain. Set or update chain mappings programmatically — essential for retargeting workflows where you need to map skeletons with different bone structures.

Read and modify Control Rig Blueprints. Inspect the full hierarchy — bones, controls, nulls, and curves. Read variables defined on the Control Rig. Add new elements (bones, controls, nulls) to the hierarchy with parent specification. Useful for procedural rig setup and bulk configuration.

Deep Niagara control — from system creation to individual module input configuration. Build complete particle systems from declarative JSON specs, or work incrementally through the module stack. Dynamic inputs get full lifecycle support: search available scripts, attach them to module inputs, configure their sub-inputs, read the tree, remove them. Event handler and simulation stage CRUD for advanced GPU particle workflows. Create custom Niagara modules and functions directly from HLSL source — define typed inputs/outputs, write the shader body, and it produces a proper .niagaraFunction asset that appears in the module stack with overridable pins. New in v0.18.0 (PR #65 by @middle233): read and overwrite the HLSL source on an existing CustomHlsl node in place (get_custom_hlsl_text / set_custom_hlsl_text), target shared-graph simulation-stage and event scripts directly via usage selectors on the module-stack actions, and a search & discovery pack for finding systems by parameter, data interface, material, or structural similarity. Renderer management with mesh, ribbon, and SubUV presets. Data interface configuration supports JSON arrays and structs. Export any system as a complete JSON spec for diffing, templating, or version control. System validation catches common issues like GPU+Light renderer conflicts. NPC particle system support with 5 dedicated actions. Override-preserving module reorder.

Sim-stage / event selectors (v0.18.0). get_ordered_modules / add_module / move_module / duplicate_module now accept usage: "particle_simulation_stage" (selectors usage_id / stage_name / stage_index) and usage: "particle_event" (selectors usage_id / handler_index), so you can target shared-graph simulation-stage and event scripts directly.

All Niagara actions accept asset_path as the primary param (system_path still works for backward compatibility).

Two actions let you create reusable Niagara scripts directly from HLSL source without touching the editor. Both work on CPU and GPU sim targets.

Creates a Niagara module script (usage: Module) and saves it as a .niagaraFunction asset. Module scripts run in the emitter stack — they read and write particle attributes.

Params:

Supported types: float, int, bool, vec2, vec3, vec4, color, position, quat, matrix

Example — scale particle color by speed:

{
  "action": "create_module_from_hlsl",
  "params": {
    "name": "M_ScaleColorBySpeed",
    "save_path": "/Game/VFX/Niagara/Modules/M_ScaleColorBySpeed",
    "description": "Tints particle color based on velocity magnitude",
    "inputs": [
      {"name": "InSpeedScale", "type": "float"},
      {"name": "InTintColor", "type": "color"}
    ],
    "hlsl": "float Speed = length(float3(Particles.Velocity.x, Particles.Velocity.y, Particles.Velocity.z));\nfloat4 C = Particles.Color;\nfloat4 Tint = InTintColor;\nParticles.Color = float4(C.rgb * Tint.rgb * (1.0 + Speed * InSpeedScale), C.a);"
  }
}

After creating the module, add it to a system and set its inputs:

{"action": "add_module", "params": {"asset_path": "/Game/VFX/NS_Fire", "emitter_name": "Emitter", "module_path": "/Game/VFX/Niagara/Modules/M_ScaleColorBySpeed", "stage": "update"}}

{"action": "set_module_input_value", "params": {"asset_path": "/Game/VFX/NS_Fire", "emitter_name": "Emitter", "module_name": "M_ScaleColorBySpeed", "input_name": "InSpeedScale", "value": "0.05", "type": "float"}}

Creates a Niagara function script (usage: Function) — a pure utility that takes typed inputs and returns typed outputs. Functions have no implicit access to particle attributes; all data flows through their explicit signature.

Params: Same as create_module_from_hlsl.

Example — remap a float from one range to another:

{
  "action": "create_function_from_hlsl",
  "params": {
    "name": "F_Remap",
    "save_path": "/Game/VFX/Niagara/Functions/F_Remap",
    "description": "Remaps InValue from [InMin, InMax] to [OutMin, OutMax]",
    "inputs": [
      {"name": "InValue", "type": "float"},
      {"name": "InMin",   "type": "float"},
      {"name": "InMax",   "type": "float"},
      {"name": "OutMin",  "type": "float"},
      {"name": "OutMax",  "type": "float"}
    ],
    "hlsl": "float T = saturate((InValue - InMin) / (InMax - InMin));\nfloat Result = lerp(OutMin, OutMax, T);"
  }
}

A few things will burn you if you're not expecting them:

• Use bare input names — write InValue, not Module.InValue. The compiler auto-qualifies with the module namespace. A dot in the name makes it a struct member access and you'll get an undeclared identifier.
• Same rule for outputs — bare names only, or skip the output signature entirely and write directly to particle attributes.
• Write to particle attributes directly in the body via ParameterMap tokens (Particles.Color, Particles.Velocity, etc.) — this is the right way for module scripts.
• Can't swizzle ParameterMap variables directly — Particles.Color.xyz is parsed as one token (the dot is not a separator in Niagara's HLSL tokenizer). Assign to a local first: float4 C = Particles.Color; float3 RGB = float3(C.x, C.y, C.z);
• Inputs are overridable after the fact — set_module_input_value and set_module_input_binding work on CustomHlsl modules the same as any other module. The inputs appear in the stack's details panel and as overridable pins.

All Niagara actions that take emitter_name also accept a numeric string index (e.g. "0", "1") as a fallback when no emitter matches the name exactly. Useful for inspecting emitters with auto-generated or non-obvious names.

Build and diagnostic tools. Trigger UBT builds or Live Coding compiles directly from your AI assistant. Read structured build errors, compile output, and crash context — no need to scroll through Output Log manually. The log system maintains a 10,000-entry ring buffer with full-text search, category filtering, and verbosity-level control. Scene capture saves viewport screenshots to disk. Texture import brings image files into UE as UTexture2D assets. Flipbook stitching combines sprite sheets into flipbook textures. Phase J F8 added a blank-map factory and module-status query for diagnosing missing-plugin/module-load issues from the AI side. v0.14.8 added list_automation_tests + run_automation_tests for in-editor automation regression runs (PR #48 by @MaxenceEpitech). v0.14.9 added run_python + load_level (Issue #50, ported from @JCSopko's fork). v0.14.10 added PIE control (PR #54 by @MaxenceEpitech). v0.16.0 added 4 new preview/inspection actions plus 3 new capture_scene_preview asset types. v0.19.0 adds live-PIE object introspection/driving, deterministic input injection, and a programmatic stat-group readout (see below).

INI config resolution and debugging. UE's config system stacks multiple INI files (Base, Default, Saved, platform overrides) and it's not always obvious which layer wins. These actions resolve any setting to its effective value, show a multi-layer breakdown of where the value comes from, diff your project against engine defaults, and search across all config files. Essential for debugging "why isn't this setting taking effect" situations.

Deep project search powered by SQLite FTS5. The plugin automatically indexes every asset in your project on editor startup — including marketplace plugins — into a searchable database. Full-text search with ranking and match highlighting. Bidirectional dependency tracing (what does this asset depend on, what references it). Filter by asset type with pagination. Deep asset details pull nodes, variables, and connections. Covers 9,500+ assets out of the box with zero configuration.

1M+ C++ symbols indexed natively in C++ — no Python, no external tools, no network access required. The engine source indexer runs automatically on startup and builds a local SQLite database of every class, function, enum, struct, and macro in UE. Read full class source or just the member list. Traverse call graphs in both directions (callers and callees). Walk class hierarchies with configurable depth. Search symbols by name across the entire engine codebase. Read raw source files by relative path. Optional project C++ indexing (via Scripts/index_project.py) adds your own source code alongside engine symbols, enabling find_callers/find_callees/get_class_hierarchy results that span both engine and project code.

v0.19.0 — symbol index tripled. A parser fix that indexes allman-brace (next-line {) plain classes/structs — the Epic coding-standard layout — took the engine symbols table from ~301K to ~967K rows. Types like FCollisionShape, FSceneView, FScopeLock, FPaths, and ~40K other exported non-reflected engine types now have rows and extracted members, so get_include_path, read_source, get_class_hierarchy, verify_symbols, get_signature, and find_example_usage resolve them. Existing EngineSource.db files enrich on the next full trigger_reindex.

Read-only / offline-served lookups so an AI agent can resolve an include, signature, deprecation, or Build.cs dep in one round-trip instead of reading raw source.

The always-on actions cover the full widget Blueprint lifecycle plus the Phase A–L architecture expansion (2026-04-26): widget tree CRUD, templates, styling, Animation v1 (deprecated) + v2 (hoisted Bezier/spring/event tracks), settings/save scaffolding, accessibility, EffectSurface widget + 10 sub-bag setters, Spec Builder + Schema + Serializer (build_ui_from_spec/dump_ui_spec_schema/dump_ui_spec), Type Registry diagnostic, and hoisted Design Import verbs (5). Templates are the headline feature: call one action and get a fully wired-up HUD, main menu, settings screen, dialog box, loading screen, inventory grid, save/load menu, or toast notification system. EffectSurface action handlers return -32010 ErrOptionalDepUnavailable when the optional EffectSurface provider is absent (decoupled 2026-04-27). Built-in accessibility audit checks your UI against common accessibility standards.

51 CommonUI actions (conditional on WITH_COMMONUI, shipped v0.14.0 across 9 categories + 1 Style Service diagnostic dump_style_cache_stats) cover activatable widgets, button styles, input routing, hardware visibility, and the class-as-data pattern for style creators. The default button class is auto-created at /Game/Monolith/CommonUI/MonolithDefaultCommonButton.

0.15.0 closed a big chunk of the MCP gap here. Close-the-loop primitives: rename_widget, add_widget_variable, audit_focus_chain, apply_token_binding, list_widget_property_enums, convert_textblock_to_common, set_action_bar_button_class, dump_blueprint_compile_log. Headline scaffolders: scaffold_main_menu, scaffold_settings_panel_with_tabs, scaffold_pause_menu, build_menu_from_spec. Navigation + conversion gap-closure: set_widget_navigation_bulk, dump_widget_navigation, convert_border_to_common, reparent_widget_root, set_widget_is_variable. The CommonUI-surface conversions are #if WITH_COMMONUI-gated. compile_widget now surfaces errors[] / warnings[] arrays instead of a bare boolean, and set_widget_property accepts value as an alias for property_value.

4 GAS attribute-binding actions (bind_widget_to_attribute, unbind_widget_attribute, list_attribute_bindings, clear_widget_attribute_bindings) are aliased into the ui namespace so widget work doesn't need to namespace-hop into gas. They dispatch to the same handlers as their canonical gas:: versions.

For the full action list, call monolith_discover("ui") (add detail=true for inline param schemas, or describe_query("action_schema") for one action) or check Docs/API_REFERENCE.md.

The largest module in Monolith. 22 capability tiers covering mesh inspection, scene manipulation, spatial queries, level blockout, GeometryScript mesh editing, horror spatial analysis, accessibility validation, lighting analysis, audio/acoustics, performance budgeting, decal/detail placement, level design, tech art pipeline (mesh import now supports optional skeletal-mesh + animation import via import_mesh — PR #58 by @4698to), advanced level design, context-aware prop placement, procedural geometry, genre presets, encounter design, and quality/polish. Plus 45 procedural town generation actions (work-in-progress, disabled by default via bEnableProceduralTownGen, not in the public count — unless you're willing to dig in and help improve it, best left alone for now). For a narrative walkthrough, see Mesh Module.

Requires WITH_GEOMETRYSCRIPT. Handle-based workflow — load a mesh into a handle, operate on it, save when done.

See Procedural Geometry for a full tutorial.

See Genre Presets for how to create preset packs for any genre.

See Horror Level Design for workflows and accessibility considerations.

Disabled by default. Enable via bEnableProceduralTownGen in Editor Preferences > Plugins > Monolith. Known geometry issues — wall misalignment, room separation. This is very much a work-in-progress — unless you're willing to dig in and help improve it, it's best left alone for now.

Floor plan generation, building facades, roofs, city blocks, spatial registry, auto-volumes, terrain/foundations, architectural features, room furnishing, and debug views. The pipeline: generate_floor_plan -> create_building_from_grid -> generate_facade -> generate_roof -> register_building. Or use create_city_block for the full pipeline in one call.

Complete Gameplay Ability System integration. 131 GAS-namespace actions plus 4 widget attribute-binding actions also aliased into the ui namespace for ergonomic UI work. Works with the engine's built-in GameplayAbilities plugin — no marketplace dependencies required for core functionality. Blueprint-based AttributeSets require the optional GBA (Blueprint Attributes) plugin from Fab. Phase J shipped a baseline vitals AttributeSet template (F4) so projects without GBA still get a working starter set.

All 4 implementation phases complete, 53/53 tests PASS. 12 bugs fixed across 8 commits.

The most comprehensive AI tooling available through any MCP server. 221 actions across 15 categories covering every major UE AI subsystem. Crown jewel actions: build_behavior_tree_from_spec and build_state_tree_from_spec — hand the AI a JSON description and it builds the entire asset. Conditional on State Tree and Smart Objects plugins (gated via WITH_STATETREE + WITH_SMARTOBJECTS after Phase J F22 — both ship with UE). Optional Mass Entity (WITH_MASSENTITY) and Zone Graph (WITH_ZONEGRAPH) integration for large-scale AI. Phase J F1 hardened BT crash-handling; F8 added add_perception_to_actor and get_bt_graph helpers.

For the full action list, call monolith_discover("ai") (add detail=true for inline param schemas, or describe_query("action_schema") for one action) or check Docs/API_REFERENCE.md.

Create, inspect, edit, and compile Behavior Trees. Add tasks, decorators, services, and composite nodes. Wire them into tree structures. Configure node properties. build_behavior_tree_from_spec creates complete BTs from a JSON specification.

Full Blackboard CRUD. Create Blackboard assets, add/remove/edit keys with type configuration (bool, int, float, string, name, vector, rotator, enum, object, class). Set key descriptions and sync modes.

Create and edit State Trees (UE's newer alternative to BTs). Add states, transitions, conditions, tasks, and evaluators. Configure state parameters and transition rules. build_state_tree_from_spec creates complete State Trees from JSON. Requires #if WITH_STATETREE.

Create EQS queries with generators and tests. Configure generator parameters (grid, ring, points around actor, pathfinding grid). Add and configure tests (distance, dot product, trace, overlap, gameplay tags, pathfinding). Full query template management.

Create and manage Smart Object Definitions. Add slots with behavior configurations, activity tags, and claim policies. Configure slot transforms and user conditions. Requires #if WITH_SMARTOBJECTS.

Create and configure AI Controller Blueprints. Set BT and BB assets. Configure perception components, team assignments, and pathfinding settings.

Configure Perception components with multiple senses: sight, hearing, damage, touch. Set sense parameters (range, angle, detection by affiliation). Configure stimulus sources on actors.

Navigation mesh queries, path filtering, navigation invokers, query filters, and avoidance configuration. Works with NavMesh at editor time (no PIE required for path queries).

Start and stop BTs, query active nodes, inspect Blackboard values, debug perception state — all during a Play-in-Editor session. Essential for runtime AI debugging.

Generate complete AI setups from templates: patrol AI, combat AI, companion AI, guard AI. Each scaffold creates the BT, BB, Controller, and optionally EQS queries and Smart Object definitions.

List available node classes (tasks, decorators, services), BT assets, BB assets, ST assets, EQS templates, SO definitions, and AI Controllers in the project.

Full integration with Logic Driver Pro, a marketplace state machine plugin. Reflection-only integration (no direct C++ API linkage) — works with any Logic Driver Pro version. Conditional on #if WITH_LOGICDRIVER with 3-location Build.cs detection.

For the full action list, call monolith_discover("logicdriver") (add detail=true for inline param schemas, or describe_query("action_schema") for one action) or check Docs/API_REFERENCE.md.

Add states, transitions, configure properties, set transition rules, manage state graph structure.

Configure state nodes (entry actions, update logic, exit actions), conduit nodes, and transition events. Set node properties via reflection.

Start, stop, query active states, trigger transitions, inspect variable values — all during Play-in-Editor.

build_sm_from_spec creates complete state machines from a JSON specification in one call. export_sm_spec and import_sm_spec for templating and version control.

Generate common patterns from templates: door controller, health system, AI patrol, dialogue system, elevator, puzzle, inventory.

Add and configure Logic Driver components on actors. Set up component properties and initial state machine assignments.

Text-based visualization of state machine structure for debugging and documentation.

List available node classes, state types, and templates.

Integration with the ComboGraph marketplace plugin for visual combo tree editing. Reflection-only integration, conditional on #if WITH_COMBOGRAPH. EdGraph sync keeps runtime and editor graphs in sync.

For the full action list, call monolith_discover("combograph") (add detail=true for inline param schemas, or describe_query("action_schema") for one action) or check Docs/API_REFERENCE.md.

Editor-time audio asset authoring. 82 baseline audio-namespace actions plus 4 perception-binding actions (bind_sound_to_perception, unbind_sound_from_perception, get_sound_perception_binding, list_perception_bound_sounds) that bridge audio assets into AI perception sound stimuli plus 12 v0.14.10 MetaSound document introspection actions (PR #18 by @alakangas — read-side complement to the existing 25 Builder API write-side actions). Covers the 5 configurable audio asset types (SoundAttenuation, SoundClass, SoundMix, SoundConcurrency, SoundSubmix), read-only SoundWave inspection, Sound Cue node graph construction, and MetaSound Builder API integration plus document-walk inspection. Phase J F11 hardened the audio asset validator. Phase J F18 added create_test_wave for generating sine-wave SoundWaves on demand. MetaSound features conditional on #if WITH_METASOUND — when MetaSound is absent, MetaSound actions are inert but Sound Cue, CRUD, batch, perception-binding, and query actions all function normally. Companion FMetaSoundIndexer deep indexer in MonolithIndex (also v0.14.10 from PR #18) walks all project MetaSounds at reindex time.

For the full action list, call monolith_discover("audio") (add detail=true for inline param schemas, or describe_query("action_schema") for one action) or check Docs/API_REFERENCE.md.

• Sound Cue connection semantics. from is the child (data source), to is the parent (consumer). This matches the ChildNodes[] model where the parent holds references to its inputs.
• MetaSound Builder lifecycle. For multi-step operations, the builder is cached via FindOrBeginBuilding(). If the editor restarts, the builder is lost and individual mutation actions return METASOUND_BUILDER_LOST. Use build_metasound_from_spec for full graph creation in one call.
• SoundWave is read-only. MonolithAudio does not create SoundWaves (they are imported assets). get_sound_wave_info reads properties; batch_set_sound_wave_properties modifies UPROPERTY fields via reflection.
• No overlap with runtime audio playback plugins. A runtime audio plugin owns footstep/surface/movement audio playback; MonolithAudio owns editor-time asset creation, management, and inspection.

New in v0.17.0. Deterministic markdown decision-record harvest from Docs/, plans, CHANGELOG.md, .claude/rules/. Three heuristic tiers with distinct confidence floors: YAML frontmatter decision: true / status: (0.90), ## ADR-N / ## Architectural Decision headers (0.85), markdown header followed within 8 lines by a paragraph containing because / rationale / evidence / decision: (0.65). Writes into two new SQLite tables (decision_records, decision_supersedes) on top of EngineSource.db. Lazy bootstrap on first call; FCoreUObjectDelegates::ReloadCompleteDelegate refresh on Live Coding / UBT hot-reload. All five actions are read-only + idempotent; path_filter carries EMonolithParamKind::DiskPath for automatic \ → / rewrite.

New in v0.17.0. Repo-level risk signals mined from git via FPlatformProcess::CreateProc against each nested repo's .git/. Hotspot score formula is deterministic and traceable: 0.6 * normalised_churn + 0.4 * normalised_loc. Co-change pair detection caps per-commit file count at MaxCommitFileCount (default 50) to suppress tree-wide refactor + initial-import noise. Writes into four new SQLite tables: git_file_churn, git_cochange_pairs, risk_hotspot_scores, reflect_conditional_gates. All five actions are read-only + idempotent.

Plus source_query("audit_module_dep_reality") (registered cross-module onto the source namespace) — catches the LNK2019 bug class where UPROPERTY (or any reflection-touching declaration) references a foreign-module type whose owning module is missing from the declaring module's Build.cs Private/PublicDependencyModuleNames. Regex-parses every *.Build.cs for declared deps and every *.h / *.cpp reflection declaration for type references, resolves against EngineSource.db's symbol → owning module map, flags violations. Cursor-paginated with module_filter substring scope.

New in v0.17.0 (Phase 3a); list_class_specifiers added in v0.19.0. UE 5.7 reflection-edge queries driven by direct reads of UHT artefacts (Intermediate/Build/Win64/.../Inc/<Module>/UHT/*.gen.cpp) cross-joined with IAssetRegistry::GetDependencies. No tree-sitter dependency, no ThirdParty vendoring — substrate is deterministic file IO plus 8 regex patterns derived from real .gen.cpp inspection. Writes into six new SQLite tables: reflect_uclasses, reflect_uproperties, reflect_ufunctions, reflect_uinterfaces, reflect_uinterface_impls, cpp_asset_edges. All six actions are read-only + idempotent; the list-style actions are cursor-paginated.

Scan scope (v0.19.0): the indexers no longer scan the project game module alone — scope is driven by IPluginManager::GetEnabledPlugins() along a game-module → project-plugin → marketplace ladder. bIndexProjectPluginReflection (default true) walks every enabled LoadedFrom == Project plugin (your project plugins); bIndexMarketplacePluginReflection (default false) also walks enabled engine-installed marketplace plugins (installed marketplace plugins). Epic engine built-ins stay excluded (separate bIndexEnginePluginReflection, default off). Both settings live under Category "CppReflect" on UMonolithReflectionIntelSettings.

Phase 3a known limitations (documented in Docs/specs/SPEC_MonolithReflectionIntel.md §5.7):

• source_path on the new tables is UHT's ModuleRelativePath, not the canonical project-relative path the Phase 1+2 tables use.
• source_line is 0 everywhere — UHT discards the original-header line during code generation.
• cpp_asset_edges.edge_kind is coarse 'package_dep'.
• reflect_uproperties.blueprint_visibility / .specifiers are empty strings — Phase 3b populates fully.

New in v0.17.0 (Phase 4a). UE 5.7 replication inspection driven by a second UHT-artefact regex sweep (independent of Phase 3a's reader) over per-property MetaData blocks plus the CPF_Net property-flag emission, cross-joined with Phase 3a's reflect_ufunctions. Writes into one new SQLite table: reflect_replicated_properties. All four actions are read-only + idempotent; all four cursor-paginated. As of the v0.19.0 scan-scope ladder, the sweep covers project plugins by default (marketplace plugins when enabled), so replicated classes and RPCs declared in project plugins are in scope — not just the game module.

Known status notes (documented in Docs/specs/SPEC_MonolithReflectionIntel.md §6.5):

• Bare UPROPERTY(Replicated) capture WORKS as of the v0.19.0 network-completeness workstream — list_replicated_classes picks it up via CPF_Net, verified E2E. (Was a Phase 4b WISHLIST item; now landed.)
• list_rpc_functions covers project plugins by default as of the v0.19.0 scan-scope ladder — detection is specifier-based (EFunctionFlags) and the indexer now walks enabled LoadedFrom == Project plugins, so the project's actual RPCs (verified E2E against the project's project-plugin RPCs) are in scope. The prior "empty because game-module-only" limitation is resolved. Enabled marketplace plugins are covered when bIndexMarketplacePluginReflection is on; Epic engine built-ins remain excluded by default.
• Multi-condition replication (COND_OwnerOnly, COND_SkipOwner, etc.) not surfaced — rep_kind carries 'rep_notify' (and post-workstream 'bare_replicated' for CPF_Net-only properties).

New in v0.17.0 (Phase 4a). Read-only composer actions that fan out other registered Monolith actions serially on the game thread and aggregate results into a single payload. Both composers are read-only end-to-end — every action they invoke is itself readOnlyHint: true. Fan out is serial; no ParallelFor, no async dispatch.

New in v0.19.0 (network-completeness workstream). One WRITE/maintenance action for repopulating the RI reflection tables. Exists because after an RI indexer code change there's no other clean repopulation trigger — the lazy bootstrap only fires on table-absence, OnReloadComplete only on Live Coding, and source_query("trigger_reindex") is the heavyweight full-engine reindex.

New in v0.17.0. Owned by MonolithReflectionIntel but registered onto the host namespace's adapter for caller ergonomics — agents already discover the host namespace first. All four are read-only + cursor-paginated; path_prefix carries EMonolithParamKind::AssetPath for automatic \ → / rewrite.