ue-mcp 1.2.4 → 1.3.0

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/LevelHandlers.cpp

@@ -14,6 +14,9 @@
 #include "Components/AudioComponent.h"
 #include "Sound/SoundBase.h"
 #include "Components/InstancedStaticMeshComponent.h"
+// #986: get_component_tree distinguishes HISM from plain ISM, because per
+// instance culling and LOD change what an edit to one costs.
+#include "Components/HierarchicalInstancedStaticMeshComponent.h"
 #include "Engine/StaticMesh.h"
 #include "Engine/SkeletalMesh.h"
 #include "Animation/SkeletalMeshActor.h"
@@ -86,6 +89,12 @@
 #include "Engine/SkeletalMesh.h"
 #include "Materials/MaterialInterface.h"
 #include "HandlerJsonProperty.h"
+#include "Engine/Blueprint.h"
+#include "Engine/LevelScriptBlueprint.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphNode.h"
+#include "Kismet2/BlueprintEditorUtils.h"
+#include "Kismet2/KismetEditorUtilities.h"
 
 void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 {
@@ -98,6 +107,10 @@ void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("get_component_tree"), &GetComponentTree);
 	Registry.RegisterHandler(TEXT("get_relative_transform"), &GetRelativeTransform);
 	Registry.RegisterHandler(TEXT("get_current_level"), &GetCurrentLevel);
+	// #964: LevelHandlers_Save.cpp. Saves through the same package path
+	// editor(save_dirty) uses, so the two cannot disagree about one package,
+	// and reports the package, the file and the engine's own reason on failure.
+	Registry.RegisterHandler(TEXT("save_level"), &SaveLevel);
 	Registry.RegisterHandler(TEXT("list_levels"), &ListLevels);
 	Registry.RegisterHandler(TEXT("get_selected_actors"), &GetSelectedActors);
 	Registry.RegisterHandler(TEXT("list_volumes"), &ListVolumes);
@@ -111,7 +124,9 @@ void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("add_component_to_actor"), &AddComponentToActor);
 	Registry.RegisterHandler(TEXT("remove_component_from_actor"), &RemoveComponentFromActor);
 	Registry.RegisterHandler(TEXT("load_level"), &LoadLevel);
+	Registry.RegisterHandler(TEXT("clear_level_script"), &ClearLevelScript);
 	Registry.RegisterHandler(TEXT("set_component_property"), &SetComponentProperty);
+	Registry.RegisterHandler(TEXT("nudge_component"), &NudgeComponent);
 	Registry.RegisterHandler(TEXT("get_component_details"), &GetComponentDetails);
 	Registry.RegisterHandler(TEXT("set_actor_material"), &SetActorMaterial);
 	Registry.RegisterHandler(TEXT("set_volume_properties"), &SetVolumeProperties);
@@ -120,6 +135,12 @@ void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("set_fog_properties"), &SetFogProperties);
 	Registry.RegisterHandler(TEXT("get_actors_by_class"), &GetActorsByClass);
 	Registry.RegisterHandler(TEXT("get_actors_by_component_class"), &GetActorsByComponentClass);
+	// Same budget as query_components, and for the same reason: this is a full
+	// TActorIterator pass on the game thread. It additionally sorts every actor
+	// by path name and sorts each actor's components, so it is the heavier of
+	// the two whole-map scans and had no business inheriting the 30 second
+	// default. Mirrored in src/bridge-timeouts.ts, which a parity test checks.
+	Registry.RegisterHandlerWithTimeout(TEXT("summarize_static_mesh_usage"), &SummarizeStaticMeshUsage, 300.0f);
 	Registry.RegisterHandler(TEXT("count_actors_by_class"), &CountActorsByClass);
 	Registry.RegisterHandler(TEXT("get_runtime_virtual_texture_summary"), &GetRVTSummary);
 	Registry.RegisterHandler(TEXT("set_water_body_property"), &SetWaterBodyProperty);
@@ -127,6 +148,7 @@ void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("resolve_actor"), &ResolveActor);
 	Registry.RegisterHandler(TEXT("set_actor_property"), &SetActorProperty);
 	Registry.RegisterHandler(TEXT("line_trace"), &LineTrace);
+	Registry.RegisterHandler(TEXT("bulk_line_trace"), &BulkLineTrace);
 	// #453: per-actor motion snapshot for telemetry probes. Reads location,
 	// rotation, velocity, angular velocity, scale, and ground state in one
 	// call. Caller is expected to invoke at the desired sample interval.
@@ -139,6 +161,11 @@ void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("get_instance_transforms"), &GetInstanceTransforms);
 	Registry.RegisterHandler(TEXT("update_instance_transform"), &UpdateInstanceTransform);
 	Registry.RegisterHandler(TEXT("remove_instance"), &RemoveInstance);
+	// Native bridge method only in this plugin-scoped change. It appears in
+	// get_bridge_capabilities.actions and can be called directly over JSON-RPC
+	// (or a UeMcpTask bridge.call). A first-class category action also requires a
+	// server schema wrapper, which intentionally lives outside this plugin.
+	Registry.RegisterHandlerWithTimeout(TEXT("snap_instances_to_surface"), &SnapInstancesToSurface, 300.0f);
 	// #696: enable + force-build Nanite on a static mesh.
 	Registry.RegisterHandler(TEXT("set_nanite_settings"), &SetNaniteSettings);
 	Registry.RegisterHandler(TEXT("get_nanite_info"), &GetNaniteInfo);
@@ -147,6 +174,11 @@ void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("place_skeletal_actor"), &SpawnSkeletalMeshActor);
 	// #666: add a material blendable to a PostProcessVolume.
 	Registry.RegisterHandler(TEXT("add_post_process_blendable"), &AddPostProcessBlendable);
+	// #950: LevelHandlers_PostProcess.cpp. The value half and the bOverride_ half
+	// of FPostProcessSettings, written together.
+	Registry.RegisterHandler(TEXT("set_post_process_settings"), &SetPostProcessSettings);
+	Registry.RegisterHandler(TEXT("get_post_process_settings"), &GetPostProcessSettings);
+	Registry.RegisterHandler(TEXT("set_fixed_exposure"), &SetFixedExposure);
 	// #637: export a selected actor's mesh to FBX + metadata sidecar.
 	Registry.RegisterHandler(TEXT("export_actor_fbx"), &ExportActorFbx);
 	Registry.RegisterHandler(TEXT("snap_actor_to_floor"), &SnapActorToFloor);
@@ -155,6 +187,16 @@ void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("set_actor_folder_path"), &SetActorFolderPath);
 	Registry.RegisterHandler(TEXT("list_actor_descs"), &ListActorDescs);
 	Registry.RegisterHandlerWithTimeout(TEXT("load_actor_descs"), &LoadActorDescs, 300.0f);
+	// #985: LevelHandlers_WorldPartitionSettings.cpp. The streaming knobs and
+	// the runtime cell transformer stack live with the other World Partition
+	// actions rather than in a category of their own.
+	Registry.RegisterHandler(TEXT("get_world_partition_settings"), &GetWorldPartitionSettings);
+	Registry.RegisterHandler(TEXT("set_world_partition_settings"), &SetWorldPartitionSettings);
+	Registry.RegisterHandler(TEXT("add_runtime_cell_transformer"), &AddRuntimeCellTransformer);
+	// #985: bulk HLOD layer assignment. A whole-map selector, so it takes the
+	// same 300 second budget as the other batch writes. Mirrored in
+	// src/bridge-timeouts.ts, which a parity test checks.
+	Registry.RegisterHandlerWithTimeout(TEXT("set_actor_hlod_layer"), &SetActorHLODLayer, 300.0f);
 	Registry.RegisterHandler(TEXT("add_actor_tag"), &AddActorTag);
 	Registry.RegisterHandler(TEXT("remove_actor_tag"), &RemoveActorTag);
 	Registry.RegisterHandler(TEXT("set_actor_tags"), &SetActorTags);
@@ -173,6 +215,31 @@ void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("spawn_grid"), &SpawnGrid);
 	Registry.RegisterHandler(TEXT("batch_translate"), &BatchTranslate);
 	Registry.RegisterHandler(TEXT("place_actors_batch"), &PlaceActorsBatch);
+	// #910/#943/#912: the general editor-side component query. A whole-map
+	// scan with a projection can take a while on a 4,000 actor level, so it
+	// gets its own timeout rather than the 30 second default.
+	Registry.RegisterHandlerWithTimeout(TEXT("query_components"), &QueryComponents, 300.0f);
+	// #984/#941/#907/#987: level-wide writes driven by an editor-side selector.
+	// Each can touch thousands of actors, so each gets its own timeout.
+	Registry.RegisterHandlerWithTimeout(TEXT("batch_set_actor_properties"), &BatchSetActorProperties, 300.0f);
+	Registry.RegisterHandlerWithTimeout(TEXT("bulk_set_component_property"), &BulkSetComponentProperty, 300.0f);
+	Registry.RegisterHandlerWithTimeout(TEXT("remove_components_by_class"), &RemoveComponentsByClass, 300.0f);
+	Registry.RegisterHandlerWithTimeout(TEXT("spawn_actors_batch"), &SpawnActorsBatch, 300.0f);
+	// #944/#915/#914: refresh state the editor is caching, and read the bounds
+	// a caller needs to check the result.
+	Registry.RegisterHandlerWithTimeout(TEXT("rerun_construction_scripts"), &RerunConstruction, 300.0f);
+	Registry.RegisterHandlerWithTimeout(TEXT("recreate_physics_state"), &RecreatePhysicsState, 300.0f);
+	Registry.RegisterHandler(TEXT("test_component_overlap"), &TestComponentOverlap);
+	// #911: BSP to StaticMesh. Generating meshes for hundreds of brushes takes
+	// far longer than the default handler timeout.
+	Registry.RegisterHandlerWithTimeout(TEXT("convert_brushes_to_static_mesh"), &ConvertBrushesToStaticMesh, 600.0f);
+	// #946: component-level material overrides on placed actors.
+	Registry.RegisterHandlerWithTimeout(TEXT("set_component_materials"), &SetComponentMaterials, 300.0f);
+	// #956: a transient verification subject, and the two actions that keep it
+	// from being left behind.
+	Registry.RegisterHandler(TEXT("spawn_transient_actor"), &SpawnTransientActor);
+	Registry.RegisterHandler(TEXT("destroy_transient_actor"), &DestroyTransientActor);
+	Registry.RegisterHandler(TEXT("list_transient_actors"), &ListTransientActors);
 }
 
 TSharedPtr<FJsonValue> FLevelHandlers::GetOutliner(const TSharedPtr<FJsonObject>& Params)
@@ -183,6 +250,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetOutliner(const TSharedPtr<FJsonObject>
 
 	FString ClassFilter = OptionalString(Params, TEXT("classFilter"));
 	FString NameFilter = OptionalString(Params, TEXT("nameFilter"));
+	// #911: classFilter has always been a case-sensitive substring on the class
+	// name, which cannot express "only this exact class". Combined with the
+	// folder filters below, that is what forced a get_actor_details round trip
+	// per entry to narrow a folder to one class.
+	const bool bExactClass = OptionalBool(Params, TEXT("exactClass"), false);
+	const FString FolderPathFilter = OptionalString(Params, TEXT("folderPath"));
+	const FString FolderPathPrefixFilter = OptionalString(Params, TEXT("folderPathPrefix"));
 	// Default 50 keeps us snappy on World Partition projects whose levels
 	// contain hundreds of streaming-proxy / HLOD actors. Callers who need the
 	// full list can pass a larger limit explicitly.
@@ -221,14 +295,36 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetOutliner(const TSharedPtr<FJsonObject>
 
 		FString ActorLabel = Actor->GetActorLabel();
 
-		if (!ClassFilter.IsEmpty() && !ActorClass.Contains(ClassFilter))
+		if (!ClassFilter.IsEmpty())
 		{
-			continue;
+			const bool bClassMatches = bExactClass
+				? ActorClass.Equals(ClassFilter, ESearchCase::IgnoreCase)
+				: ActorClass.Contains(ClassFilter);
+			if (!bClassMatches)
+			{
+				continue;
+			}
 		}
 		if (!NameFilter.IsEmpty() && !ActorName.Contains(NameFilter) && !ActorLabel.Contains(NameFilter))
 		{
 			continue;
 		}
+		if (!FolderPathFilter.IsEmpty() || !FolderPathPrefixFilter.IsEmpty())
+		{
+			const FString Folder = Actor->GetFolderPath().ToString();
+			if (!FolderPathFilter.IsEmpty() && !Folder.Equals(FolderPathFilter, ESearchCase::IgnoreCase))
+			{
+				continue;
+			}
+			// A folder prefix matches the folder itself and everything nested
+			// under it, so "Gameplay" does not also match "GameplayOld".
+			if (!FolderPathPrefixFilter.IsEmpty() &&
+				!Folder.Equals(FolderPathPrefixFilter, ESearchCase::IgnoreCase) &&
+				!Folder.StartsWith(FolderPathPrefixFilter + TEXT("/"), ESearchCase::IgnoreCase))
+			{
+				continue;
+			}
+		}
 
 #if WITH_EDITOR
 		const bool bEditorHidden = Actor->IsTemporarilyHiddenInEditor();
@@ -446,22 +542,29 @@ TSharedPtr<FJsonValue> FLevelHandlers::PlaceActor(const TSharedPtr<FJsonObject>&
 
 TSharedPtr<FJsonValue> FLevelHandlers::DeleteActor(const TSharedPtr<FJsonObject>& Params)
 {
-	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	FString Selector;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), Selector)) return Err;
 
 	REQUIRE_EDITOR_WORLD(World);
 
-	AActor* ActorToDelete = FindActorByLabel(World, ActorLabel);
+	// #983: a duplicate label is refused rather than deleted at random. The
+	// miss stays idempotent, but "already deleted" would be a lie when three
+	// actors carry the label and all three are still there.
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* ActorToDelete = MCPResolveActor(World, Params, ActorErr);
+	if (!ActorToDelete && MCPIsAmbiguousActorError(ActorErr)) return ActorErr;
 
 	// Idempotent: deleting a non-existent actor is a no-op, not an error.
 	if (!ActorToDelete)
 	{
 		auto Result = MCPSuccess();
-		Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Result->SetStringField(TEXT("actorLabel"), Selector);
 		Result->SetBoolField(TEXT("alreadyDeleted"), true);
 		return MCPResult(Result);
 	}
 
+	const FString ActorLabel = ActorToDelete->GetActorLabel();
+
 	World->DestroyActor(ActorToDelete);
 
 	auto Result = MCPSuccess();
@@ -474,14 +577,8 @@ TSharedPtr<FJsonValue> FLevelHandlers::DeleteActor(const TSharedPtr<FJsonObject>
 
 TSharedPtr<FJsonValue> FLevelHandlers::GetActorDetails(const TSharedPtr<FJsonObject>& Params)
 {
-	FString ActorLabel;
-	FString ActorPath;
-	bool bHasLabel = Params->TryGetStringField(TEXT("actorLabel"), ActorLabel);
-	bool bHasPath = Params->TryGetStringField(TEXT("actorPath"), ActorPath);
-	if (!bHasLabel && !bHasPath)
-	{
-		return MCPError(TEXT("Missing 'actorLabel' or 'actorPath' parameter"));
-	}
+	FString Selector;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), Selector)) return Err;
 
 	// World selection: "editor" (default) or "pie" (#111)
 	// #778: this hand-rolled loop took the FIRST PIE context, i.e. the server,
@@ -499,17 +596,26 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetActorDetails(const TSharedPtr<FJsonObj
 		if (!World) return MCPError(TEXT("No editor world available"));
 	}
 
-	AActor* Actor = FindActorByLabelOrPath(World, bHasLabel ? ActorLabel : FString(), bHasPath ? ActorPath : FString());
-	if (!Actor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), bHasPath ? *ActorPath : *ActorLabel));
-	}
+	// LabelOrName, not label alone: a caller often has an internal name rather
+	// than a label, because a PIE-spawned actor has no label worth guessing.
+	// The label tier is still exhausted first and the name tier refuses on
+	// ambiguity, so accepting the name cannot reintroduce a silent pick (#983).
+	FMCPActorSelector ActorSel;
+	ActorSel.Match = EMCPActorMatch::LabelOrName;
+	ActorSel.WorldLabel = World->IsGameWorld() ? TEXT("PIE") : TEXT("editor");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+	if (!Actor) return ActorErr;
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("label"), Actor->GetActorLabel());
 	Result->SetStringField(TEXT("name"), Actor->GetName());
 	Result->SetStringField(TEXT("class"), Actor->GetClass()->GetName());
 	Result->SetStringField(TEXT("path"), Actor->GetPathName());
+	// #983: the same value under the name the selector uses, so the round trip
+	// back into any actor-targeting action is a copy of one field.
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
+	Result->SetStringField(TEXT("actorLabel"), Actor->GetActorLabel());
 	Result->SetStringField(TEXT("folderPath"), Actor->GetFolderPath().ToString());
 
 	FVector Location = Actor->GetActorLocation();
@@ -567,10 +673,26 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetActorDetails(const TSharedPtr<FJsonObj
 			P->SetStringField(TEXT("name"), Prop->GetName());
 			P->SetStringField(TEXT("type"), Prop->GetCPPType());
 
-			FString ValueStr;
-			const void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(Actor);
-			Prop->ExportText_Direct(ValueStr, ValuePtr, ValuePtr, Actor, PPF_None);
-			P->SetStringField(TEXT("value"), ValueStr);
+			// #927: a UPROPERTY declared as a C-style fixed array, `int32 Foo[3]`,
+			// is ONE FProperty with ArrayDim == 3, not three properties. Exporting
+			// it without an index writes element 0 and stops, and the value then
+			// reads as an ordinary scalar with the remaining elements invisible.
+			//
+			// This is a general serialization bug, not a navmesh one. It was
+			// noticed on RecastNavMesh's NavMeshResolutionParams, a three-element
+			// fixed array holding the Low, Default and High generation tiers, and
+			// reporting only the Low tier as if it were the whole property sent a
+			// user tuning cell sizes against numbers Recast was not using. Any
+			// fixed array on any class had the same problem.
+			//
+			// MCPExportPropertyValue returns a JSON array of one string per
+			// element when ArrayDim > 1 and a plain string otherwise, so the two
+			// cases stay distinguishable rather than being conflated.
+			P->SetField(TEXT("value"), MCPExportPropertyValue(Prop, Actor));
+			if (MCPPropertyIsFixedArray(Prop))
+			{
+				P->SetNumberField(TEXT("arrayDim"), Prop->ArrayDim);
+			}
 			PropsArr.Add(MakeShared<FJsonValueObject>(P));
 		}
 		Result->SetArrayField(TEXT("properties"), PropsArr);
@@ -596,14 +718,8 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetActorDetails(const TSharedPtr<FJsonObj
 //   - reflected UPROPERTY name/type/value when includeProperties=true
 TSharedPtr<FJsonValue> FLevelHandlers::GetComponentTree(const TSharedPtr<FJsonObject>& Params)
 {
-	FString ActorLabel;
-	FString ActorPath;
-	const bool bHasLabel = Params->TryGetStringField(TEXT("actorLabel"), ActorLabel);
-	const bool bHasPath = Params->TryGetStringField(TEXT("actorPath"), ActorPath);
-	if (!bHasLabel && !bHasPath)
-	{
-		return MCPError(TEXT("Missing 'actorLabel' or 'actorPath' parameter"));
-	}
+	FString Selector;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), Selector)) return Err;
 
 	const FString WorldScope = OptionalString(Params, TEXT("world"), TEXT("editor"));
 	UWorld* World = ResolveWorldFromParams(Params, *WorldScope);
@@ -612,11 +728,16 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetComponentTree(const TSharedPtr<FJsonOb
 		return MCPError(FString::Printf(TEXT("World '%s' not available"), *WorldScope));
 	}
 
-	AActor* Actor = FindActorByLabelOrPath(World, bHasLabel ? ActorLabel : FString(), bHasPath ? ActorPath : FString());
-	if (!Actor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), bHasPath ? *ActorPath : *ActorLabel));
-	}
+	// LabelOrName, not label alone: a caller often has an internal name rather
+	// than a label, because a PIE-spawned actor has no label worth guessing.
+	// The label tier is still exhausted first and the name tier refuses on
+	// ambiguity, so accepting the name cannot reintroduce a silent pick (#983).
+	FMCPActorSelector ActorSel;
+	ActorSel.Match = EMCPActorMatch::LabelOrName;
+	ActorSel.WorldLabel = World->IsGameWorld() ? TEXT("PIE") : TEXT("editor");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+	if (!Actor) return ActorErr;
 
 	const bool bIncludeProperties = OptionalBool(Params, TEXT("includeProperties"));
 	const FString PropertyFilter = OptionalString(Params, TEXT("componentClass"));
@@ -728,6 +849,24 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetComponentTree(const TSharedPtr<FJsonOb
 						Mats.Add(MakeShared<FJsonValueString>(Mat ? Mat->GetPathName() : TEXT("")));
 					}
 					C->SetArrayField(TEXT("materials"), Mats);
+
+					// #986: an ISM/HISM reported its class and its mesh and not
+					// how many instances it holds, which is the one number that
+					// decides whether to touch it at all. A component with three
+					// instances and one with three hundred thousand looked
+					// identical here, so the decision was made blind or cost a
+					// separate get_instance_transforms dump of every transform.
+					if (UInstancedStaticMeshComponent* ISMC = Cast<UInstancedStaticMeshComponent>(SMC))
+					{
+						C->SetNumberField(TEXT("instanceCount"), ISMC->GetInstanceCount());
+						TSharedPtr<FJsonObject> Instanced = MakeShared<FJsonObject>();
+						// HISM culls and LODs per instance and ISM does not, so
+						// the distinction changes what an edit costs.
+						Instanced->SetBoolField(TEXT("hierarchical"),
+							ISMC->IsA<UHierarchicalInstancedStaticMeshComponent>());
+						Instanced->SetNumberField(TEXT("numCustomDataFloats"), ISMC->NumCustomDataFloats);
+						C->SetObjectField(TEXT("instanced"), Instanced);
+					}
 				}
 				else if (USkeletalMeshComponent* SKMC = Cast<USkeletalMeshComponent>(PC))
 				{
@@ -783,10 +922,15 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetComponentTree(const TSharedPtr<FJsonOb
 				TSharedPtr<FJsonObject> P = MakeShared<FJsonObject>();
 				P->SetStringField(TEXT("name"), Prop->GetName());
 				P->SetStringField(TEXT("type"), Prop->GetCPPType());
-				FString ValueStr;
-				const void* VP = Prop->ContainerPtrToValuePtr<void>(Comp);
-				Prop->ExportText_Direct(ValueStr, VP, VP, Comp, PPF_None);
-				P->SetStringField(TEXT("value"), ValueStr);
+				// #927: a fixed array is one FProperty with ArrayDim > 1, and
+				// exporting it without an index reports element 0 as though it
+				// were the whole value. Same helper as the actor dump, so the
+				// two cannot drift.
+				P->SetField(TEXT("value"), MCPExportPropertyValue(Prop, Comp));
+				if (MCPPropertyIsFixedArray(Prop))
+				{
+					P->SetNumberField(TEXT("arrayDim"), Prop->ArrayDim);
+				}
 				Props.Add(MakeShared<FJsonValueObject>(P));
 			}
 			C->SetArrayField(TEXT("properties"), Props);
@@ -797,6 +941,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetComponentTree(const TSharedPtr<FJsonOb
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("actorLabel"), Actor->GetActorLabel());
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("actorClass"), Actor->GetClass()->GetName());
 	Result->SetNumberField(TEXT("componentCount"), CompArr.Num());
 	Result->SetArrayField(TEXT("components"), CompArr);
@@ -809,19 +954,30 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetComponentTree(const TSharedPtr<FJsonOb
 // required execute_python with MathLibrary.inverse_transform_location.
 TSharedPtr<FJsonValue> FLevelHandlers::GetRelativeTransform(const TSharedPtr<FJsonObject>& Params)
 {
-	FString TargetLabel;
-	if (auto Err = RequireStringAlt(Params, TEXT("targetLabel"), TEXT("target"), TargetLabel)) return Err;
-	FString ReferenceLabel;
-	if (auto Err = RequireStringAlt(Params, TEXT("referenceLabel"), TEXT("reference"), ReferenceLabel)) return Err;
-
 	const FString WorldScope = OptionalString(Params, TEXT("world"), TEXT("editor"));
 	UWorld* World = ResolveWorldFromParams(Params, *WorldScope);
 	if (!World) return MCPError(FString::Printf(TEXT("World '%s' not available"), *WorldScope));
 
-	AActor* TargetActor = FindActorByLabel(World, TargetLabel);
-	AActor* ReferenceActor = FindActorByLabel(World, ReferenceLabel);
-	if (!TargetActor) return MCPError(FString::Printf(TEXT("Target actor not found: %s"), *TargetLabel));
-	if (!ReferenceActor) return MCPError(FString::Printf(TEXT("Reference actor not found: %s"), *ReferenceLabel));
+	// #983: both ends take a path. Two duplicated labels would otherwise
+	// produce a relative transform between whichever pair the actor iterator
+	// reached first, which is exactly the number this action exists to trust.
+	FMCPActorSelector TargetSel;
+	TargetSel.LabelKey = TEXT("targetLabel");
+	TargetSel.PathKey = TEXT("targetPath");
+	TargetSel.AltLabelKey = TEXT("target");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* TargetActor = MCPResolveActor(World, Params, ActorErr, TargetSel);
+	if (!TargetActor) return ActorErr;
+
+	FMCPActorSelector ReferenceSel;
+	ReferenceSel.LabelKey = TEXT("referenceLabel");
+	ReferenceSel.PathKey = TEXT("referencePath");
+	ReferenceSel.AltLabelKey = TEXT("reference");
+	AActor* ReferenceActor = MCPResolveActor(World, Params, ActorErr, ReferenceSel);
+	if (!ReferenceActor) return ActorErr;
+
+	const FString TargetLabel = TargetActor->GetActorLabel();
+	const FString ReferenceLabel = ReferenceActor->GetActorLabel();
 
 	const FTransform Target = TargetActor->GetActorTransform();
 	const FTransform Reference = ReferenceActor->GetActorTransform();
@@ -844,7 +1000,9 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetRelativeTransform(const TSharedPtr<FJs
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("targetLabel"), TargetLabel);
+	Result->SetStringField(TEXT("targetPath"), TargetActor->GetPathName());
 	Result->SetStringField(TEXT("referenceLabel"), ReferenceLabel);
+	Result->SetStringField(TEXT("referencePath"), ReferenceActor->GetPathName());
 	Result->SetObjectField(TEXT("location"), MakeVec(Relative.GetLocation()));
 	Result->SetObjectField(TEXT("rotation"), MakeRot(Relative.GetRotation().Rotator()));
 	Result->SetObjectField(TEXT("scale"), MakeVec(Relative.GetScale3D()));
@@ -947,21 +1105,27 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetSelectedActors(const TSharedPtr<FJsonO
 }
 TSharedPtr<FJsonValue> FLevelHandlers::MoveActor(const TSharedPtr<FJsonObject>& Params)
 {
-	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	FString Selector;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), Selector)) return Err;
 
 	// #586: support the PIE world so a label from get_outliner {world:pie}
-	// resolves and the live actor moves. FindActorByLabelOrName also matches the
-	// runtime instance name PIE shows.
+	// resolves and the live actor moves. The resolver also matches the runtime
+	// instance name PIE shows.
 	const FString WorldScope = OptionalString(Params, TEXT("world"), TEXT("editor"));
 	UWorld* World = ResolveWorldFromParams(Params, *WorldScope);
 	if (!World) return MCPError(TEXT("World not available"));
 
-	AActor* Actor = FindActorByLabelOrName(World, ActorLabel);
-	if (!Actor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
-	}
+	// LabelOrName, not label alone: a caller often has an internal name rather
+	// than a label, because a PIE-spawned actor has no label worth guessing.
+	// The label tier is still exhausted first and the name tier refuses on
+	// ambiguity, so accepting the name cannot reintroduce a silent pick (#983).
+	FMCPActorSelector ActorSel;
+	ActorSel.Match = EMCPActorMatch::LabelOrName;
+	ActorSel.WorldLabel = World->IsGameWorld() ? TEXT("PIE") : TEXT("editor");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+	if (!Actor) return ActorErr;
+	const FString ActorLabel = Actor->GetActorLabel();
 
 	// Capture previous transform for rollback.
 	const FVector PreviousLocation = Actor->GetActorLocation();
@@ -987,9 +1151,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::MoveActor(const TSharedPtr<FJsonObject>&
 	Result->SetObjectField(TEXT("rotation"), MCPRotatorToJsonObject(Actor->GetActorRotation()));
 	Result->SetObjectField(TEXT("scale"), MCPVec3ToJsonObject(Actor->GetActorScale3D()));
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 
-	// Self-inverse: call move_actor with previous transform.
+	// Self-inverse: call move_actor with previous transform. #983: the undo
+	// travels by path, so replaying it cannot land on a different actor that
+	// happens to share the label.
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+	Payload->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Payload->SetStringField(TEXT("actorLabel"), ActorLabel);
 	Payload->SetObjectField(TEXT("location"), MCPVec3ToJsonObject(PreviousLocation));
 	Payload->SetObjectField(TEXT("rotation"), MCPRotatorToJsonObject(PreviousRotation));
@@ -1004,23 +1172,27 @@ TSharedPtr<FJsonValue> FLevelHandlers::MoveActor(const TSharedPtr<FJsonObject>&
 // reading two transforms and computing the look-at client-side.
 TSharedPtr<FJsonValue> FLevelHandlers::AimActorAt(const TSharedPtr<FJsonObject>& Params)
 {
-	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	FString Selector;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), Selector)) return Err;
 
 	FString WorldScope = OptionalString(Params, TEXT("world"), TEXT("editor"));
 	UWorld* World = ResolveWorldFromParams(Params, *WorldScope);
 	if (!World) return MCPError(TEXT("World not available"));
 
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	const FString ActorLabel = Actor->GetActorLabel();
 
 	// Resolve the target point: an explicit target Vec3, or another actor's location.
 	FVector TargetLocation;
-	const FString TargetActorLabel = OptionalString(Params, TEXT("targetActor"));
-	if (!TargetActorLabel.IsEmpty())
+	if (Params->HasField(TEXT("targetActor")) || Params->HasField(TEXT("targetActorPath")))
 	{
-		AActor* TargetActor = FindActorByLabel(World, TargetActorLabel);
-		if (!TargetActor) return MCPError(FString::Printf(TEXT("Target actor not found: %s"), *TargetActorLabel));
+		FMCPActorSelector TargetSel;
+		TargetSel.LabelKey = TEXT("targetActor");
+		TargetSel.PathKey = TEXT("targetActorPath");
+		AActor* TargetActor = MCPResolveActor(World, Params, ActorErr, TargetSel);
+		if (!TargetActor) return ActorErr;
 		TargetLocation = TargetActor->GetActorLocation();
 	}
 	else if (Params->HasField(TEXT("target")))
@@ -1029,7 +1201,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::AimActorAt(const TSharedPtr<FJsonObject>&
 	}
 	else
 	{
-		return MCPError(TEXT("Supply 'target' (Vec3) or 'targetActor' (label)"));
+		return MCPError(TEXT("Supply 'target' (Vec3), 'targetActor' (label) or 'targetActorPath' (object path)"));
 	}
 
 	const FVector ActorLocation = Actor->GetActorLocation();
@@ -1048,11 +1220,14 @@ TSharedPtr<FJsonValue> FLevelHandlers::AimActorAt(const TSharedPtr<FJsonObject>&
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetObjectField(TEXT("rotation"), MCPRotatorToJsonObject(Actor->GetActorRotation()));
 	Result->SetObjectField(TEXT("target"), MCPVec3ToJsonObject(TargetLocation));
 
-	// Rollback: restore the prior rotation via move_actor.
+	// Rollback: restore the prior rotation via move_actor, by path so the undo
+	// cannot land on a namesake (#983).
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+	Payload->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Payload->SetStringField(TEXT("actorLabel"), ActorLabel);
 	Payload->SetObjectField(TEXT("rotation"), MCPRotatorToJsonObject(PreviousRotation));
 	MCPSetRollback(Result, TEXT("move_actor"), Payload);
@@ -1091,10 +1266,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::NavProjectPoint(const TSharedPtr<FJsonObj
 
 TSharedPtr<FJsonValue> FLevelHandlers::SelectActors(const TSharedPtr<FJsonObject>& Params)
 {
-	const TArray<TSharedPtr<FJsonValue>>* ActorLabelsArray = nullptr;
-	if (!Params->TryGetArrayField(TEXT("actorLabels"), ActorLabelsArray))
+	static const TArray<TSharedPtr<FJsonValue>> EmptySelection;
+	const TArray<TSharedPtr<FJsonValue>>* ActorLabelsArray = &EmptySelection;
+	const bool bHasLabels = Params->TryGetArrayField(TEXT("actorLabels"), ActorLabelsArray);
+	if (!bHasLabels) ActorLabelsArray = &EmptySelection;
+	if (!bHasLabels && !Params->HasField(TEXT("actorPaths")))
 	{
-		return MCPError(TEXT("Missing 'actorLabels' parameter"));
+		return MCPError(TEXT("Missing 'actorLabels' parameter (or 'actorPaths')"));
 	}
 
 	REQUIRE_EDITOR_WORLD(World);
@@ -1105,31 +1283,61 @@ TSharedPtr<FJsonValue> FLevelHandlers::SelectActors(const TSharedPtr<FJsonObject
 	TArray<TSharedPtr<FJsonValue>> SelectedArray;
 	TArray<TSharedPtr<FJsonValue>> NotFoundArray;
 
+	// #983: selection is the plural case, so a label naming several actors
+	// selects all of them rather than one at random. selectedPaths reports
+	// exactly which, and is what a follow-up write should target.
+	TArray<TSharedPtr<FJsonValue>> SelectedPathsArray;
 	for (const TSharedPtr<FJsonValue>& LabelValue : *ActorLabelsArray)
 	{
 		FString Label = LabelValue->AsString();
-		if (AActor* Match = FindActorByLabel(World, Label))
+		TArray<AActor*> Matches;
+		MCPCollectActorsByToken(World, Label, EMCPActorMatch::Label, Matches);
+		if (Matches.Num() == 0)
+		{
+			NotFoundArray.Add(MakeShared<FJsonValueString>(Label));
+			continue;
+		}
+		for (AActor* Match : Matches)
 		{
 			GEditor->SelectActor(Match, true, true, true);
-			SelectedArray.Add(MakeShared<FJsonValueString>(Label));
+			SelectedPathsArray.Add(MakeShared<FJsonValueString>(Match->GetPathName()));
 		}
-		else
+		SelectedArray.Add(MakeShared<FJsonValueString>(Label));
+	}
+
+	// An explicit path list selects exactly what it names, with no label
+	// resolution in the way at all.
+	const TArray<TSharedPtr<FJsonValue>>* ActorPathsArray = nullptr;
+	if (Params->TryGetArrayField(TEXT("actorPaths"), ActorPathsArray))
+	{
+		for (const TSharedPtr<FJsonValue>& PathValue : *ActorPathsArray)
 		{
-			NotFoundArray.Add(MakeShared<FJsonValueString>(Label));
+			const FString Path = PathValue->AsString();
+			if (AActor* Match = MCPFindActorByPath(World, Path))
+			{
+				GEditor->SelectActor(Match, true, true, true);
+				SelectedPathsArray.Add(MakeShared<FJsonValueString>(Match->GetPathName()));
+				SelectedArray.Add(MakeShared<FJsonValueString>(Match->GetActorLabel()));
+			}
+			else
+			{
+				NotFoundArray.Add(MakeShared<FJsonValueString>(Path));
+			}
 		}
 	}
 
 	auto Result = MCPSuccess();
 	Result->SetArrayField(TEXT("selected"), SelectedArray);
+	Result->SetArrayField(TEXT("selectedPaths"), SelectedPathsArray);
 	Result->SetArrayField(TEXT("notFound"), NotFoundArray);
-	Result->SetNumberField(TEXT("selectedCount"), SelectedArray.Num());
+	Result->SetNumberField(TEXT("selectedCount"), SelectedPathsArray.Num());
 
 	return MCPResult(Result);
 }
 TSharedPtr<FJsonValue> FLevelHandlers::AddComponentToActor(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
 	FString ComponentClass;
 	if (auto Err = RequireString(Params, TEXT("componentClass"), ComponentClass)) return Err;
@@ -1141,11 +1349,10 @@ TSharedPtr<FJsonValue> FLevelHandlers::AddComponentToActor(const TSharedPtr<FJso
 
 	REQUIRE_EDITOR_WORLD(World);
 
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
-	}
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	// Idempotency: check for an existing component with the same name on the actor.
 	FName CompName = FName(*ComponentName);
@@ -1161,6 +1368,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::AddComponentToActor(const TSharedPtr<FJso
 			auto ExistingResult = MCPSuccess();
 			MCPSetExisted(ExistingResult);
 			ExistingResult->SetStringField(TEXT("actorLabel"), ActorLabel);
+			ExistingResult->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 			ExistingResult->SetStringField(TEXT("componentName"), ComponentName);
 			ExistingResult->SetStringField(TEXT("componentClass"), Existing->GetClass()->GetName());
 			return MCPResult(ExistingResult);
@@ -1210,10 +1418,12 @@ TSharedPtr<FJsonValue> FLevelHandlers::AddComponentToActor(const TSharedPtr<FJso
 	auto Result = MCPSuccess();
 	MCPSetCreated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("componentName"), ComponentName);
 	Result->SetStringField(TEXT("componentClass"), NewComponent->GetClass()->GetName());
 
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+	Payload->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Payload->SetStringField(TEXT("actorLabel"), ActorLabel);
 	Payload->SetStringField(TEXT("componentName"), ComponentName);
 	MCPSetRollback(Result, TEXT("remove_component_from_actor"), Payload);
@@ -1225,14 +1435,16 @@ TSharedPtr<FJsonValue> FLevelHandlers::AddComponentToActor(const TSharedPtr<FJso
 TSharedPtr<FJsonValue> FLevelHandlers::RemoveComponentFromActor(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 	FString ComponentName;
 	if (auto Err = RequireString(Params, TEXT("componentName"), ComponentName)) return Err;
 
 	REQUIRE_EDITOR_WORLD(World);
 
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	const FName CompName(*ComponentName);
 	UActorComponent* Target = nullptr;
@@ -1245,6 +1457,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::RemoveComponentFromActor(const TSharedPtr
 	{
 		auto Noop = MCPSuccess();
 		Noop->SetStringField(TEXT("actorLabel"), ActorLabel);
+		Noop->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 		Noop->SetStringField(TEXT("componentName"), ComponentName);
 		Noop->SetBoolField(TEXT("alreadyDeleted"), true);
 		return MCPResult(Noop);
@@ -1258,6 +1471,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::RemoveComponentFromActor(const TSharedPtr
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("componentName"), ComponentName);
 	Result->SetStringField(TEXT("componentClass"), ComponentClass);
 	Result->SetBoolField(TEXT("deleted"), true);
@@ -1318,6 +1532,168 @@ TSharedPtr<FJsonValue> FLevelHandlers::LoadLevel(const TSharedPtr<FJsonObject>&
 	return MCPResult(Result);
 }
 
+int32 FLevelHandlers::ClearBlueprintGraphNodes(
+	UBlueprint* Blueprint,
+	bool bDryRun,
+	TArray<TSharedPtr<FJsonValue>>& OutGraphs)
+{
+	if (!Blueprint)
+	{
+		return 0;
+	}
+
+	TArray<UEdGraph*> Graphs;
+	Blueprint->GetAllGraphs(Graphs);
+	int32 NodeCount = 0;
+
+	for (UEdGraph* Graph : Graphs)
+	{
+		if (!Graph || Graph->Nodes.IsEmpty())
+		{
+			continue;
+		}
+
+		TArray<TSharedPtr<FJsonValue>> Nodes;
+		TArray<UEdGraphNode*> GraphNodes;
+		GraphNodes.Reserve(Graph->Nodes.Num());
+		for (UEdGraphNode* Node : Graph->Nodes)
+		{
+			GraphNodes.Add(Node);
+		}
+		if (!bDryRun)
+		{
+			Graph->Modify();
+		}
+		for (UEdGraphNode* Node : GraphNodes)
+		{
+			if (!Node)
+			{
+				continue;
+			}
+
+			auto NodeJson = MakeShared<FJsonObject>();
+			NodeJson->SetStringField(TEXT("name"), Node->GetName());
+			NodeJson->SetStringField(TEXT("classPath"), Node->GetClass()->GetPathName());
+			Nodes.Add(MakeShared<FJsonValueObject>(NodeJson));
+			++NodeCount;
+
+			if (!bDryRun)
+			{
+				Node->Modify();
+				FBlueprintEditorUtils::RemoveNode(Blueprint, Node, /*bDontRecompile*/ true);
+			}
+		}
+
+		auto GraphJson = MakeShared<FJsonObject>();
+		GraphJson->SetStringField(TEXT("name"), Graph->GetName());
+		GraphJson->SetNumberField(TEXT("nodeCount"), Nodes.Num());
+		GraphJson->SetArrayField(TEXT("nodes"), Nodes);
+		OutGraphs.Add(MakeShared<FJsonValueObject>(GraphJson));
+	}
+
+	return NodeCount;
+}
+
+TSharedPtr<FJsonValue> FLevelHandlers::ClearLevelScript(const TSharedPtr<FJsonObject>& Params)
+{
+	if (!GEditor)
+	{
+		return MCPError(TEXT("GEditor not available"));
+	}
+
+	UWorld* World = GEditor->GetEditorWorldContext().World();
+	if (!World || !World->PersistentLevel)
+	{
+		return MCPError(TEXT("No persistent editor level is loaded"));
+	}
+
+	const bool bDryRun = OptionalBool(Params, TEXT("dryRun"), true);
+	const bool bSave = OptionalBool(Params, TEXT("save"), false);
+	if (!bDryRun && bSave && World->GetOutermost()->IsDirty())
+	{
+		return MCPError(TEXT("Current level already has unsaved changes; save or discard them before clear_level_script with save=true"));
+	}
+	ULevelScriptBlueprint* LevelScript =
+		World->PersistentLevel->GetLevelScriptBlueprint(/*bDontCreate*/ true);
+
+	TArray<TSharedPtr<FJsonValue>> Graphs;
+	TArray<TSharedPtr<FJsonValue>> Variables;
+	int32 NodeCount = 0;
+	int32 VariableCount = 0;
+	bool bCompileSucceeded = true;
+	bool bSaved = false;
+
+	if (LevelScript)
+	{
+		TArray<FName> VariableNames;
+		VariableNames.Reserve(LevelScript->NewVariables.Num());
+		for (const FBPVariableDescription& Variable : LevelScript->NewVariables)
+		{
+			VariableNames.Add(Variable.VarName);
+			Variables.Add(MakeShared<FJsonValueString>(Variable.VarName.ToString()));
+		}
+		VariableCount = VariableNames.Num();
+
+		if (bDryRun)
+		{
+			NodeCount = ClearBlueprintGraphNodes(LevelScript, true, Graphs);
+		}
+		else
+		{
+			const FScopedTransaction Transaction(
+				NSLOCTEXT("UEMCPBridge", "ClearLevelScript", "MCP clear level script"));
+			World->Modify();
+			World->PersistentLevel->Modify();
+			LevelScript->Modify();
+			NodeCount = ClearBlueprintGraphNodes(LevelScript, false, Graphs);
+			for (const FName VariableName : VariableNames)
+			{
+				FBlueprintEditorUtils::RemoveMemberVariable(LevelScript, VariableName);
+			}
+
+			if (NodeCount > 0 || VariableCount > 0)
+			{
+				FBlueprintEditorUtils::MarkBlueprintAsStructurallyModified(LevelScript);
+				FKismetEditorUtilities::CompileBlueprint(LevelScript);
+				bCompileSucceeded = LevelScript->Status != BS_Error;
+				World->MarkPackageDirty();
+				if (!bCompileSucceeded)
+				{
+					return MCPError(TEXT("Level script nodes were cleared but compilation failed; the level was not saved and the change can be undone"));
+				}
+			}
+
+			if (bSave && (NodeCount > 0 || VariableCount > 0))
+			{
+				ULevelEditorSubsystem* LevelEditorSubsystem =
+					GEditor->GetEditorSubsystem<ULevelEditorSubsystem>();
+				if (!LevelEditorSubsystem)
+				{
+					return MCPError(TEXT("LevelEditorSubsystem not available; level was changed but not saved"));
+				}
+				bSaved = LevelEditorSubsystem->SaveCurrentLevel();
+				if (!bSaved)
+				{
+					return MCPError(TEXT("Level script was cleared and compiled, but the current level could not be saved"));
+				}
+			}
+		}
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("levelPath"), World->GetOutermost()->GetName());
+	Result->SetBoolField(TEXT("dryRun"), bDryRun);
+	Result->SetBoolField(TEXT("hasLevelScript"), LevelScript != nullptr);
+	Result->SetNumberField(TEXT("graphCount"), Graphs.Num());
+	Result->SetNumberField(TEXT("nodeCount"), NodeCount);
+	Result->SetArrayField(TEXT("graphs"), Graphs);
+	Result->SetNumberField(TEXT("variableCount"), VariableCount);
+	Result->SetArrayField(TEXT("variables"), Variables);
+	Result->SetBoolField(TEXT("compileSucceeded"), bCompileSucceeded);
+	Result->SetBoolField(TEXT("saved"), bSaved);
+	return MCPResult(Result);
+}
+
 // Resolve a component on a placed actor by name, case-insensitively, across
 // all components GetComponents returns (which includes inherited/SCS
 // components on placed Blueprint instances). Empty name -> root component.
@@ -1380,7 +1756,7 @@ static UActorComponent* FindNamedComponentOnActor(AActor* Actor, const FString&
 TSharedPtr<FJsonValue> FLevelHandlers::SetComponentProperty(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
 	FString ComponentName = OptionalString(Params, TEXT("componentName"));
 
@@ -1401,12 +1777,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetComponentProperty(const TSharedPtr<FJs
 	}
 	const bool bRuntimeWorld = World->IsGameWorld();
 
-	AActor* TargetActor = FindActorByLabelNameOrPath(World, ActorLabel);
-	if (!TargetActor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found in the %s world: %s"),
-			bRuntimeWorld ? TEXT("PIE") : TEXT("editor"), *ActorLabel));
-	}
+	FMCPActorSelector ActorSel;
+	ActorSel.Match = EMCPActorMatch::LabelNameOrPath;
+	ActorSel.WorldLabel = bRuntimeWorld ? TEXT("PIE") : TEXT("editor");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* TargetActor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+	if (!TargetActor) return ActorErr;
+	ActorLabel = TargetActor->GetActorLabel();
 
 	UActorComponent* TargetComp = FindComponentOnActor(TargetActor, ComponentName);
 	if (!TargetComp)
@@ -1426,24 +1803,65 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetComponentProperty(const TSharedPtr<FJs
 	UStruct* CurrentStruct = TargetComp->GetClass();
 	void* CurrentContainer = TargetComp;
 	FProperty* Prop = nullptr;
+	// #927: same fixed-array indexing as set_actor_property. A component
+	// property declared `float Foo[4]` is one FProperty with ArrayDim 4, and
+	// without an index every write lands on element 0.
+	int32 LeafArrayIndex = 0;
 	for (int32 i = 0; i < PathParts.Num(); ++i)
 	{
-		FProperty* SegmentProp = CurrentStruct->FindPropertyByName(FName(*PathParts[i]));
+		FString Token = PathParts[i];
+		int32 SegmentIndex = 0;
+		bool bHasSegmentIndex = false;
+		{
+			int32 OpenBracket = INDEX_NONE;
+			int32 CloseBracket = INDEX_NONE;
+			if (Token.FindChar(TEXT('['), OpenBracket) &&
+				Token.FindChar(TEXT(']'), CloseBracket) &&
+				CloseBracket > OpenBracket)
+			{
+				SegmentIndex = FCString::Atoi(*Token.Mid(OpenBracket + 1, CloseBracket - OpenBracket - 1));
+				Token = Token.Left(OpenBracket);
+				bHasSegmentIndex = true;
+			}
+		}
+
+		FProperty* SegmentProp = CurrentStruct->FindPropertyByName(FName(*Token));
 		if (!SegmentProp)
 		{
-			return MCPError(FString::Printf(TEXT("Property '%s' not found at '%s'"), *PathParts[i], *PropertyName));
+			return MCPError(FString::Printf(TEXT("Property '%s' not found at '%s'"), *Token, *PropertyName));
+		}
+		if (bHasSegmentIndex)
+		{
+			if (CastField<FArrayProperty>(SegmentProp))
+			{
+				return MCPError(FString::Printf(
+					TEXT("'%s' is a TArray. Indexing a dynamic array is not supported here; use asset(set_property) for dotted TArray paths. An index on this action addresses a C-style fixed array such as `float Foo[4]`."),
+					*Token));
+			}
+			if (SegmentProp->ArrayDim <= 1)
+			{
+				return MCPError(FString::Printf(
+					TEXT("'%s' is not a fixed array, so it cannot be indexed [%d]"), *Token, SegmentIndex));
+			}
+			if (SegmentIndex < 0 || SegmentIndex >= SegmentProp->ArrayDim)
+			{
+				return MCPError(FString::Printf(
+					TEXT("Index %d is out of range on '%s', which has ArrayDim %d"),
+					SegmentIndex, *Token, SegmentProp->ArrayDim));
+			}
 		}
 		if (i < PathParts.Num() - 1)
 		{
 			if (FStructProperty* SP = CastField<FStructProperty>(SegmentProp))
 			{
-				CurrentContainer = SP->ContainerPtrToValuePtr<void>(CurrentContainer);
+				CurrentContainer = SP->ContainerPtrToValuePtr<void>(CurrentContainer, SegmentIndex);
 				CurrentStruct = SP->Struct;
 			}
 			else if (FObjectProperty* OP = CastField<FObjectProperty>(SegmentProp))
 			{
 				// #305: descend through Instanced UObject sub-objects.
-				UObject* SubObject = OP->GetObjectPropertyValue(OP->ContainerPtrToValuePtr<void>(CurrentContainer));
+				UObject* SubObject = OP->GetObjectPropertyValue(
+					OP->ContainerPtrToValuePtr<void>(CurrentContainer, SegmentIndex));
 				if (!SubObject)
 				{
 					return MCPError(FString::Printf(
@@ -1463,6 +1881,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetComponentProperty(const TSharedPtr<FJs
 		else
 		{
 			Prop = SegmentProp;
+			LeafArrayIndex = SegmentIndex;
 		}
 	}
 
@@ -1472,7 +1891,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetComponentProperty(const TSharedPtr<FJs
 		return MCPError(TEXT("Missing 'value' parameter"));
 	}
 
-	void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(CurrentContainer);
+	void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(CurrentContainer, LeafArrayIndex);
 
 	// Capture previous value as a string for self-inverse rollback.
 	FString PreviousValueStr;
@@ -1509,9 +1928,21 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetComponentProperty(const TSharedPtr<FJs
 						// Skip obvious non-identifiers
 						if (Token != TEXT("True") && Token != TEXT("False") && Token != TEXT("None") && !Token.IsNumeric())
 						{
-							if (AActor* Resolved = FindActorByLabel(World, Token))
+							// #983: a duplicated label here would wire the
+							// struct's object reference to whichever namesake
+							// the iterator reached first, so it is refused.
+							// An unmatched token is left alone, as before: it
+							// is probably an enum literal, not an actor.
+							TArray<AActor*> TokenMatches;
+							MCPCollectActorsByToken(World, Token, EMCPActorMatch::Label, TokenMatches);
+							if (TokenMatches.Num() > 1)
 							{
-								Result.Append(Resolved->GetPathName());
+								return MCPAmbiguousActorError(
+									Token, TEXT("value"), TEXT("actorPath"), TEXT("editor label"), TokenMatches);
+							}
+							if (TokenMatches.Num() == 1)
+							{
+								Result.Append(TokenMatches[0]->GetPathName());
 								i = End;
 								goto AppendDone;
 							}
@@ -1571,12 +2002,15 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetComponentProperty(const TSharedPtr<FJs
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), TargetActor->GetPathName());
 	Result->SetStringField(TEXT("componentClass"), TargetComp->GetClass()->GetName());
 	Result->SetStringField(TEXT("propertyName"), PropertyName);
 	Result->SetStringField(TEXT("previousValue"), PreviousValueStr);
 
-	// Self-inverse: same handler with previous value as string.
+	// Self-inverse: same handler with previous value as string, addressed by
+	// path so the undo cannot land on a namesake (#983).
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+	Payload->SetStringField(TEXT("actorPath"), TargetActor->GetPathName());
 	Payload->SetStringField(TEXT("actorLabel"), ActorLabel);
 	if (!ComponentName.IsEmpty()) Payload->SetStringField(TEXT("componentName"), ComponentName);
 	Payload->SetStringField(TEXT("propertyName"), PropertyName);
@@ -1593,7 +2027,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetComponentProperty(const TSharedPtr<FJs
 TSharedPtr<FJsonValue> FLevelHandlers::GetComponentDetails(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
 	const FString ComponentName = OptionalString(Params, TEXT("componentName"));
 	// #584: optionally dump arbitrary UPROPERTY values (custom fields,
@@ -1608,11 +2042,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetComponentDetails(const TSharedPtr<FJso
 	UWorld* World = ResolveWorldFromParams(Params, *WorldScope);
 	if (!World) return MCPError(FString::Printf(TEXT("World not available for scope '%s'"), *WorldScope));
 
-	AActor* TargetActor = FindActorByLabelNameOrPath(World, ActorLabel);
-	if (!TargetActor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
-	}
+	FMCPActorSelector ActorSel;
+	ActorSel.Match = EMCPActorMatch::LabelNameOrPath;
+	ActorSel.WorldLabel = World->IsGameWorld() ? TEXT("PIE") : TEXT("editor");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* TargetActor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+	if (!TargetActor) return ActorErr;
+	ActorLabel = TargetActor->GetActorLabel();
 
 	auto DescribeComponent = [bIncludeValues, &PropFilter](UActorComponent* Comp) -> TSharedPtr<FJsonObject>
 	{
@@ -1656,9 +2092,9 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetComponentDetails(const TSharedPtr<FJso
 				FProperty* Prop = *It;
 				const FString PName = Prop->GetName();
 				if (PropFilter.Num() > 0 && !PropFilter.Contains(PName)) continue;
-				FString Exported;
-				Prop->ExportText_Direct(Exported, Prop->ContainerPtrToValuePtr<void>(Comp), Prop->ContainerPtrToValuePtr<void>(Comp), Comp, PPF_None);
-				Values->SetStringField(PName, Exported);
+				// #927: fixed arrays come back as a JSON array of elements
+				// rather than as element 0 wearing the whole property's name.
+				Values->SetField(PName, MCPExportPropertyValue(Prop, Comp));
 			}
 			Obj->SetObjectField(TEXT("values"), Values);
 		}
@@ -1667,6 +2103,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetComponentDetails(const TSharedPtr<FJso
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), TargetActor->GetPathName());
 
 	if (!ComponentName.IsEmpty())
 	{
@@ -1820,7 +2257,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetWorldSettings(const TSharedPtr<FJsonOb
 TSharedPtr<FJsonValue> FLevelHandlers::SetActorMaterial(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
 	FString MaterialPath;
 	if (auto Err = RequireString(Params, TEXT("materialPath"), MaterialPath)) return Err;
@@ -1829,11 +2266,10 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorMaterial(const TSharedPtr<FJsonOb
 
 	REQUIRE_EDITOR_WORLD(World);
 
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
-	}
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	UMaterialInterface* Material = LoadObject<UMaterialInterface>(nullptr, *MaterialPath);
 	if (!Material)
@@ -1860,6 +2296,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorMaterial(const TSharedPtr<FJsonOb
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("materialPath"), MaterialPath);
 	Result->SetNumberField(TEXT("slotIndex"), SlotIndex);
 	Result->SetStringField(TEXT("previousMaterialPath"), PreviousMaterialPath);
@@ -1870,6 +2307,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorMaterial(const TSharedPtr<FJsonOb
 	if (!PreviousMaterialPath.IsEmpty())
 	{
 		TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+		Payload->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 		Payload->SetStringField(TEXT("actorLabel"), ActorLabel);
 		Payload->SetStringField(TEXT("materialPath"), PreviousMaterialPath);
 		Payload->SetNumberField(TEXT("slotIndex"), SlotIndex);
@@ -2119,7 +2557,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetRVTSummary(const TSharedPtr<FJsonObjec
 TSharedPtr<FJsonValue> FLevelHandlers::SetWaterBodyProperty(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 	FString PropertyName;
 	if (auto Err = RequireString(Params, TEXT("propertyName"), PropertyName)) return Err;
 
@@ -2136,8 +2574,10 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetWaterBodyProperty(const TSharedPtr<FJs
 
 	REQUIRE_EDITOR_WORLD(World);
 
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	UClass* WBClass = LoadClass<UActorComponent>(nullptr, TEXT("/Script/Water.WaterBodyComponent"));
 	if (!WBClass)
@@ -2170,6 +2610,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetWaterBodyProperty(const TSharedPtr<FJs
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("componentName"), WBComp->GetName());
 	Result->SetStringField(TEXT("componentClass"), WBComp->GetClass()->GetName());
 	Result->SetStringField(TEXT("propertyName"), PropertyName);
@@ -2179,21 +2620,23 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetWaterBodyProperty(const TSharedPtr<FJs
 
 // ─── #188 get_actor_bounds ──────────────────────────────────────────
 // Returns the axis-aligned bounding box (origin + extent) for an actor
-// found by its editor label.
+// named by its editor label or its object path.
 TSharedPtr<FJsonValue> FLevelHandlers::GetActorBounds(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
 	const FString WorldScope = OptionalString(Params, TEXT("world"), TEXT("editor"));
 	UWorld* World = ResolveWorldFromParams(Params, *WorldScope);
 	if (!World) return MCPError(FString::Printf(TEXT("World not available for scope '%s'"), *WorldScope));
 
-	AActor* Actor = FindActorByLabelNameOrPath(World, ActorLabel);
-	if (!Actor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
-	}
+	FMCPActorSelector ActorSel;
+	ActorSel.Match = EMCPActorMatch::LabelNameOrPath;
+	ActorSel.WorldLabel = World->IsGameWorld() ? TEXT("PIE") : TEXT("editor");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	FVector Origin;
 	FVector Extent;
@@ -2225,6 +2668,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetActorBounds(const TSharedPtr<FJsonObje
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetObjectField(TEXT("origin"), OriginObj);
 	Result->SetObjectField(TEXT("extent"), ExtentObj);
 	return MCPResult(Result);
@@ -2270,15 +2714,16 @@ TSharedPtr<FJsonValue> FLevelHandlers::ResolveActor(const TSharedPtr<FJsonObject
 }
 
 // #202/#230: generic per-instance UPROPERTY writer for level actors. Resolves
-// the actor by label, walks dotted property paths, and routes the value
-// through the recursive JSON setter so object refs / vectors / nested
-// structs all apply. The optional `force` flag flips off the EditDefaultsOnly
-// gate so per-instance overrides on EditDefaultsOnly properties go through
-// (the per-instance value always existed - the editor UI just hides it).
+// the actor by label or object path, walks dotted property paths, and routes
+// the value through the recursive JSON setter so object refs / vectors /
+// nested structs all apply. The optional `force` flag flips off the
+// EditDefaultsOnly gate so per-instance overrides on EditDefaultsOnly
+// properties go through (the per-instance value always existed - the editor
+// UI just hides it).
 TSharedPtr<FJsonValue> FLevelHandlers::SetActorProperty(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
 	FString PropertyName;
 	if (auto Err = RequireString(Params, TEXT("propertyName"), PropertyName)) return Err;
@@ -2299,19 +2744,22 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorProperty(const TSharedPtr<FJsonOb
 	}
 
 	AActor* TargetActor = nullptr;
-	const bool bWorldSettings = ActorLabel.Equals(TEXT("WorldSettings"), ESearchCase::IgnoreCase);
+	const bool bWorldSettings =
+		ActorLabel.Equals(TEXT("WorldSettings"), ESearchCase::IgnoreCase)
+		&& !Params->HasField(TEXT("actorPath"));
 	if (bWorldSettings)
 	{
 		TargetActor = World->GetWorldSettings();
+		if (!TargetActor) return MCPError(TEXT("World settings not available"));
 	}
 	else
 	{
-		TargetActor = FindActorByLabel(World, ActorLabel);
-	}
-
-	if (!TargetActor)
-	{
-		return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+		TSharedPtr<FJsonValue> ActorErr;
+		FMCPActorSelector ActorSel;
+		ActorSel.WorldLabel = World->IsGameWorld() ? TEXT("PIE") : TEXT("editor");
+		TargetActor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+		if (!TargetActor) return ActorErr;
+		ActorLabel = TargetActor->GetActorLabel();
 	}
 
 	TArray<FString> PathParts;
@@ -2321,15 +2769,62 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorProperty(const TSharedPtr<FJsonOb
 	UStruct* CurrentStruct = TargetActor->GetClass();
 	void* CurrentContainer = TargetActor;
 	FProperty* Prop = nullptr;
+	// #927: the leaf element of a C-style fixed array, `int32 Foo[3]`. That is
+	// ONE FProperty with ArrayDim == 3, so without an index the write lands on
+	// element 0 and the other elements are unreachable. The read side has the
+	// mirror of this bug; a read that shows three tiers and a write that can
+	// only reach the first is not a usable pair.
+	int32 LeafArrayIndex = 0;
 	for (int32 i = 0; i < PathParts.Num(); ++i)
 	{
-		FProperty* Seg = CurrentStruct->FindPropertyByName(FName(*PathParts[i]));
-		if (!Seg) return MCPError(FString::Printf(TEXT("Property '%s' not found at '%s'"), *PathParts[i], *PropertyName));
+		FString Token = PathParts[i];
+		int32 SegmentIndex = 0;
+		bool bHasSegmentIndex = false;
+		{
+			int32 OpenBracket = INDEX_NONE;
+			int32 CloseBracket = INDEX_NONE;
+			if (Token.FindChar(TEXT('['), OpenBracket) &&
+				Token.FindChar(TEXT(']'), CloseBracket) &&
+				CloseBracket > OpenBracket)
+			{
+				SegmentIndex = FCString::Atoi(*Token.Mid(OpenBracket + 1, CloseBracket - OpenBracket - 1));
+				Token = Token.Left(OpenBracket);
+				bHasSegmentIndex = true;
+			}
+		}
+
+		FProperty* Seg = CurrentStruct->FindPropertyByName(FName(*Token));
+		if (!Seg) return MCPError(FString::Printf(TEXT("Property '%s' not found at '%s'"), *Token, *PropertyName));
+
+		if (bHasSegmentIndex)
+		{
+			if (CastField<FArrayProperty>(Seg))
+			{
+				// A TArray element needs the shared resolver's array helper,
+				// which this walker does not have. Say which action does
+				// rather than writing element 0 and calling it a success.
+				return MCPError(FString::Printf(
+					TEXT("'%s' is a TArray. Indexing a dynamic array is not supported here; use asset(set_property) for dotted TArray paths. An index on this action addresses a C-style fixed array such as `int32 Foo[3]`."),
+					*Token));
+			}
+			if (Seg->ArrayDim <= 1)
+			{
+				return MCPError(FString::Printf(
+					TEXT("'%s' is not a fixed array, so it cannot be indexed [%d]"), *Token, SegmentIndex));
+			}
+			if (SegmentIndex < 0 || SegmentIndex >= Seg->ArrayDim)
+			{
+				return MCPError(FString::Printf(
+					TEXT("Index %d is out of range on '%s', which has ArrayDim %d"),
+					SegmentIndex, *Token, Seg->ArrayDim));
+			}
+		}
+
 		if (i < PathParts.Num() - 1)
 		{
 			if (FStructProperty* SP = CastField<FStructProperty>(Seg))
 			{
-				CurrentContainer = SP->ContainerPtrToValuePtr<void>(CurrentContainer);
+				CurrentContainer = SP->ContainerPtrToValuePtr<void>(CurrentContainer, SegmentIndex);
 				CurrentStruct = SP->Struct;
 			}
 			// #305: descend through Instanced UObject sub-objects too. The path
@@ -2338,7 +2833,8 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorProperty(const TSharedPtr<FJsonOb
 			// rejection forced execute_python on every instanced-subobject write.
 			else if (FObjectProperty* OP = CastField<FObjectProperty>(Seg))
 			{
-				UObject* SubObject = OP->GetObjectPropertyValue(OP->ContainerPtrToValuePtr<void>(CurrentContainer));
+				UObject* SubObject = OP->GetObjectPropertyValue(
+					OP->ContainerPtrToValuePtr<void>(CurrentContainer, SegmentIndex));
 				if (!SubObject)
 				{
 					return MCPError(FString::Printf(
@@ -2358,6 +2854,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorProperty(const TSharedPtr<FJsonOb
 		else
 		{
 			Prop = Seg;
+			LeafArrayIndex = SegmentIndex;
 		}
 	}
 
@@ -2369,7 +2866,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorProperty(const TSharedPtr<FJsonOb
 		Prop->PropertyFlags &= ~CPF_DisableEditOnInstance;
 	}
 
-	void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(CurrentContainer);
+	void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(CurrentContainer, LeafArrayIndex);
 
 	FString PrevValue;
 	Prop->ExportText_Direct(PrevValue, ValuePtr, ValuePtr, TargetActor, PPF_None);
@@ -2377,15 +2874,30 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorProperty(const TSharedPtr<FJsonOb
 	TargetActor->Modify();
 
 	// If the JSON value is a string and the property is an object reference,
-	// try resolving the string as an actor label first so callers can write
-	// {value: "Hopper_01"} for AHopper* references.
+	// try resolving the string as an actor label or object path first, so
+	// callers can write {value: "Hopper_01"} for AHopper* references and hand
+	// back an actorPath when the label is not unique.
 	TSharedPtr<FJsonValue> Value = *ValueField;
 	if (Value->Type == EJson::String)
 	{
 		FString S = Value->AsString();
 		if (FObjectProperty* OP = CastField<FObjectProperty>(Prop))
 		{
-			AActor* RefActor = FindActorByLabel(World, S);
+			// LabelNameOrPath, where this used to be label alone: the value
+			// slot has to take an actorPath back, which is the whole point of
+			// returning one. An actor object path contains ":PersistentLevel."
+			// and so cannot collide with an asset path, and a value matching
+			// nothing still falls through to the generic setter as before.
+			TArray<AActor*> RefMatches;
+			MCPCollectActorsByToken(World, S, EMCPActorMatch::LabelNameOrPath, RefMatches);
+			// #983: wiring a reference to whichever namesake came first is the
+			// silent wrong write this issue is about, so it is refused here too.
+			if (RefMatches.Num() > 1)
+			{
+				Prop->PropertyFlags = OriginalFlags;
+				return MCPAmbiguousActorError(S, TEXT("value"), TEXT("actorPath"), TEXT("editor label"), RefMatches);
+			}
+			AActor* RefActor = RefMatches.Num() == 1 ? RefMatches[0] : nullptr;
 			if (RefActor && RefActor->IsA(OP->PropertyClass))
 			{
 				OP->SetObjectPropertyValue(ValuePtr, RefActor);
@@ -2423,7 +2935,16 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorProperty(const TSharedPtr<FJsonOb
 				{
 					FString Label;
 					(*Items)[i]->TryGetString(Label);
-					AActor* Ref = FindActorByLabel(World, Label);
+					TArray<AActor*> ElementMatches;
+					MCPCollectActorsByToken(World, Label, EMCPActorMatch::LabelNameOrPath, ElementMatches);
+					if (ElementMatches.Num() > 1)
+					{
+						// #983: one ambiguous entry poisons the whole array,
+						// so the write is refused before any element lands.
+						Prop->PropertyFlags = OriginalFlags;
+						return MCPAmbiguousActorError(Label, TEXT("value"), TEXT("actorPath"), TEXT("editor label"), ElementMatches);
+					}
+					AActor* Ref = ElementMatches.Num() == 1 ? ElementMatches[0] : nullptr;
 					if (!Ref)
 					{
 						Prop->PropertyFlags = OriginalFlags;
@@ -2460,10 +2981,13 @@ WriteDone:
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), TargetActor->GetPathName());
 	Result->SetStringField(TEXT("propertyName"), PropertyName);
 	Result->SetStringField(TEXT("previousValue"), PrevValue);
 
+	// The undo travels by path so replaying it cannot land on a namesake (#983).
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+	if (!bWorldSettings) Payload->SetStringField(TEXT("actorPath"), TargetActor->GetPathName());
 	Payload->SetStringField(TEXT("actorLabel"), ActorLabel);
 	Payload->SetStringField(TEXT("propertyName"), PropertyName);
 	Payload->SetStringField(TEXT("value"), PrevValue);
@@ -2512,9 +3036,28 @@ TSharedPtr<FJsonValue> FLevelHandlers::ReadActorMotion(const TSharedPtr<FJsonObj
 			FString L; if (V->TryGetString(L) && !L.IsEmpty()) Labels.Add(L);
 		}
 	}
-	if (Labels.Num() == 0)
+	// #983: the same list spelled as object paths, which is what a caller
+	// reaches for when several actors share a label. These are kept apart from
+	// the label list and resolved by MCPFindActorByPath rather than folded into
+	// the label token tier, so the export-text form and a case difference both
+	// resolve here exactly as they do everywhere else.
+	TArray<FString> Paths;
+	FString SinglePath;
+	if (Params->TryGetStringField(TEXT("actorPath"), SinglePath) && !SinglePath.IsEmpty())
 	{
-		return MCPError(TEXT("Pass at least one of 'actorLabel' or 'actorLabels'"));
+		Paths.Add(SinglePath);
+	}
+	const TArray<TSharedPtr<FJsonValue>>* PathsArr = nullptr;
+	if (Params->TryGetArrayField(TEXT("actorPaths"), PathsArr) && PathsArr)
+	{
+		for (const TSharedPtr<FJsonValue>& V : *PathsArr)
+		{
+			FString P; if (V->TryGetString(P) && !P.IsEmpty()) Paths.Add(P);
+		}
+	}
+	if (Labels.Num() == 0 && Paths.Num() == 0)
+	{
+		return MCPError(TEXT("Pass at least one of 'actorLabel', 'actorLabels', 'actorPath' or 'actorPaths'"));
 	}
 
 	auto VecToJson = [](const FVector& V) -> TSharedPtr<FJsonObject>
@@ -2532,16 +3075,37 @@ TSharedPtr<FJsonValue> FLevelHandlers::ReadActorMotion(const TSharedPtr<FJsonObj
 
 	TArray<TSharedPtr<FJsonValue>> Samples;
 	TArray<TSharedPtr<FJsonValue>> Missing;
+	TArray<AActor*> Targets;
 	for (const FString& Label : Labels)
 	{
-		AActor* Actor = FindActorByLabel(TargetWorld, Label);
-		if (!Actor)
+		// #983: this is a read, and a plural one, so a label naming several
+		// actors samples all of them rather than one at random. Each row
+		// carries actorPath, which is what a follow-up write should target.
+		TArray<AActor*> Matches;
+		MCPCollectActorsByToken(TargetWorld, Label, EMCPActorMatch::LabelNameOrPath, Matches);
+		if (Matches.Num() == 0)
 		{
 			Missing.Add(MakeShared<FJsonValueString>(Label));
 			continue;
 		}
+		for (AActor* Match : Matches) Targets.AddUnique(Match);
+	}
+	for (const FString& Path : Paths)
+	{
+		if (AActor* ByPath = MCPFindActorByPath(TargetWorld, Path))
+		{
+			Targets.AddUnique(ByPath);
+		}
+		else
+		{
+			Missing.Add(MakeShared<FJsonValueString>(Path));
+		}
+	}
+	for (AActor* Actor : Targets)
+	{
 		TSharedPtr<FJsonObject> S = MakeShared<FJsonObject>();
-		S->SetStringField(TEXT("actorLabel"), Label);
+		S->SetStringField(TEXT("actorLabel"), Actor->GetActorLabel());
+		S->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 		S->SetStringField(TEXT("class"), Actor->GetClass()->GetName());
 		S->SetObjectField(TEXT("location"), VecToJson(Actor->GetActorLocation()));
 		S->SetObjectField(TEXT("rotation"), RotToJson(Actor->GetActorRotation()));
@@ -2599,10 +3163,12 @@ TSharedPtr<FJsonValue> FLevelHandlers::AddHismcInstances(const TSharedPtr<FJsonO
 {
 	REQUIRE_EDITOR_WORLD(World);
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	FString ComponentName = OptionalString(Params, TEXT("componentName"));
 	UInstancedStaticMeshComponent* ISMC = nullptr;
@@ -2683,6 +3249,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::AddHismcInstances(const TSharedPtr<FJsonO
 	auto Result = MCPSuccess();
 	MCPSetCreated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("componentName"), ISMC->GetName());
 	Result->SetStringField(TEXT("componentClass"), ISMC->GetClass()->GetName());
 	Result->SetNumberField(TEXT("addedCount"), AddedIndices.Num());
@@ -2714,9 +3281,11 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetInstanceTransforms(const TSharedPtr<FJ
 {
 	REQUIRE_EDITOR_WORLD(World);
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	const FString ComponentName = OptionalString(Params, TEXT("componentName"));
 	UInstancedStaticMeshComponent* ISMC = ResolveISMC(Actor, ComponentName);
@@ -2739,6 +3308,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetInstanceTransforms(const TSharedPtr<FJ
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("componentName"), ISMC->GetName());
 	Result->SetNumberField(TEXT("count"), Count);
 	Result->SetBoolField(TEXT("worldSpace"), bWorldSpace);
@@ -2751,9 +3321,11 @@ TSharedPtr<FJsonValue> FLevelHandlers::UpdateInstanceTransform(const TSharedPtr<
 {
 	REQUIRE_EDITOR_WORLD(World);
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	const FString ComponentName = OptionalString(Params, TEXT("componentName"));
 	UInstancedStaticMeshComponent* ISMC = ResolveISMC(Actor, ComponentName);
@@ -2786,6 +3358,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::UpdateInstanceTransform(const TSharedPtr<
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("componentName"), ISMC->GetName());
 	Result->SetNumberField(TEXT("index"), Index);
 	return MCPResult(Result);
@@ -2796,9 +3369,11 @@ TSharedPtr<FJsonValue> FLevelHandlers::RemoveInstance(const TSharedPtr<FJsonObje
 {
 	REQUIRE_EDITOR_WORLD(World);
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
-	AActor* Actor = FindActorByLabel(World, ActorLabel);
-	if (!Actor) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	const FString ComponentName = OptionalString(Params, TEXT("componentName"));
 	UInstancedStaticMeshComponent* ISMC = ResolveISMC(Actor, ComponentName);
@@ -2818,6 +3393,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::RemoveInstance(const TSharedPtr<FJsonObje
 	auto Result = MCPSuccess();
 	Result->SetBoolField(TEXT("removed"), bOk);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("componentName"), ISMC->GetName());
 	Result->SetNumberField(TEXT("remainingInstances"), ISMC->GetInstanceCount());
 	return MCPResult(Result);
@@ -2884,12 +3460,16 @@ TSharedPtr<FJsonValue> FLevelHandlers::ExportActorFbx(const TSharedPtr<FJsonObje
 {
 	REQUIRE_EDITOR_WORLD(World);
 	FString ActorLabel;
-	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
+	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 	FString OutputPath;
 	if (auto Err = RequireStringAlt(Params, TEXT("outputPath"), TEXT("filePath"), OutputPath)) return Err;
 
-	AActor* Actor = FindActorByLabelNameOrPath(World, ActorLabel);
-	if (!Actor) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	FMCPActorSelector ActorSel;
+	ActorSel.Match = EMCPActorMatch::LabelNameOrPath;
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Actor = MCPResolveActor(World, Params, ActorErr, ActorSel);
+	if (!Actor) return ActorErr;
+	ActorLabel = Actor->GetActorLabel();
 
 	// Resolve the mesh asset from the actor (skeletal first, then static).
 	UObject* MeshAsset = nullptr;
@@ -2999,25 +3579,56 @@ TSharedPtr<FJsonValue> FLevelHandlers::SpawnSkeletalMeshActor(const TSharedPtr<F
 	if (!Actor) return MCPError(TEXT("Failed to spawn SkeletalMeshActor"));
 	if (!Label.IsEmpty()) Actor->SetActorLabel(Label);
 
+	// #946: per-slot COMPONENT material overrides, reported rather than
+	// applied silently. These write the component's OverrideMaterials, which
+	// is a different thing from the mesh ASSET's own slots: the asset is
+	// untouched here. For an actor that is already placed, or to apply one
+	// material to every slot, use level(set_component_materials).
+	TArray<TSharedPtr<FJsonValue>> MaterialResults;
+	int32 FailedMaterials = 0;
 	USkeletalMeshComponent* Comp = Actor->GetSkeletalMeshComponent();
 	if (Comp)
 	{
 		Comp->SetSkeletalMeshAsset(Mesh);
 
-		// Optional per-slot material overrides.
 		const TArray<TSharedPtr<FJsonValue>>* Mats = nullptr;
 		if (Params->TryGetArrayField(TEXT("materials"), Mats) && Mats)
 		{
+			const int32 SlotCount = Comp->GetNumMaterials();
 			for (int32 i = 0; i < Mats->Num(); ++i)
 			{
 				FString MatPath;
-				if ((*Mats)[i].IsValid() && (*Mats)[i]->TryGetString(MatPath) && !MatPath.IsEmpty())
+				const bool bHasPath =
+					(*Mats)[i].IsValid() && (*Mats)[i]->TryGetString(MatPath) && !MatPath.IsEmpty();
+				if (!bHasPath) continue;
+
+				TSharedPtr<FJsonObject> MatRow = MakeShared<FJsonObject>();
+				MatRow->SetNumberField(TEXT("slotIndex"), i);
+				MatRow->SetStringField(TEXT("materialPath"), MatPath);
+
+				// A slot index past the end, or a path that does not load,
+				// used to be dropped on the floor. That reads as a successful
+				// assignment that never happened.
+				if (i >= SlotCount)
 				{
-					if (UMaterialInterface* Mat = LoadAssetByPath<UMaterialInterface>(MatPath))
-					{
-						Comp->SetMaterial(i, Mat);
-					}
+					MatRow->SetBoolField(TEXT("ok"), false);
+					MatRow->SetStringField(TEXT("error"), FString::Printf(
+						TEXT("slot %d is past the mesh's %d material slots"), i, SlotCount));
+					++FailedMaterials;
+				}
+				else if (UMaterialInterface* Mat = LoadAssetByPath<UMaterialInterface>(MatPath))
+				{
+					Comp->SetMaterial(i, Mat);
+					MatRow->SetBoolField(TEXT("ok"), true);
+					MatRow->SetStringField(TEXT("source"), TEXT("componentOverride"));
+				}
+				else
+				{
+					MatRow->SetBoolField(TEXT("ok"), false);
+					MatRow->SetStringField(TEXT("error"), TEXT("material not found"));
+					++FailedMaterials;
 				}
+				MaterialResults.Add(MakeShared<FJsonValueObject>(MatRow));
 			}
 		}
 
@@ -3051,9 +3662,18 @@ TSharedPtr<FJsonValue> FLevelHandlers::SpawnSkeletalMeshActor(const TSharedPtr<F
 
 	auto Result = MCPSuccess();
 	MCPSetCreated(Result);
+	Result->SetBoolField(TEXT("success"), FailedMaterials == 0);
+	if (FailedMaterials > 0)
+	{
+		Result->SetStringField(TEXT("error"), FString::Printf(
+			TEXT("The actor was spawned but %d material override(s) did not apply; see materials[]."),
+			FailedMaterials));
+	}
 	Result->SetStringField(TEXT("actorLabel"), Actor->GetActorLabel());
 	Result->SetStringField(TEXT("actorPath"), Actor->GetPathName());
 	Result->SetStringField(TEXT("skeletalMesh"), Mesh->GetPathName());
+	Result->SetNumberField(TEXT("materialSlotCount"), Comp ? Comp->GetNumMaterials() : 0);
+	Result->SetArrayField(TEXT("materials"), MaterialResults);
 	Result->SetObjectField(TEXT("location"), MCPVec3ToJsonObject(Loc));
 	Result->SetObjectField(TEXT("boxExtent"), MCPVec3ToJsonObject(BoxExtent));
 	TSharedPtr<FJsonObject> Rb = MakeShared<FJsonObject>();
@@ -3191,14 +3811,46 @@ TSharedPtr<FJsonValue> FLevelHandlers::DeleteActors(const TSharedPtr<FJsonObject
 {
 	REQUIRE_EDITOR_WORLD(World);
 
+	// #963: the filter names say what they match, and the two that were
+	// previously reachable only through get_outliner's looser nameFilter are
+	// now first class here. labelPrefix stays a CASE-SENSITIVE PREFIX over the
+	// EDITOR LABEL, which is what it always was; labelContains and nameContains
+	// are the substring forms, over the label and the internal name
+	// respectively. Overloading one parameter to mean both is how a filter that
+	// selects fifteen actors in one action selects none in another.
 	const FString LabelPrefix = OptionalString(Params, TEXT("labelPrefix"));
+	const FString LabelContains = OptionalString(Params, TEXT("labelContains"));
+	const FString NameContains = OptionalString(Params, TEXT("nameContains"));
 	const FString ClassName = OptionalString(Params, TEXT("className"));
 	const FString Tag = OptionalString(Params, TEXT("tag"));
 	const bool bDryRun = OptionalBool(Params, TEXT("dryRun"), false);
 
-	if (LabelPrefix.IsEmpty() && ClassName.IsEmpty() && Tag.IsEmpty())
+	TArray<FString> ClassPathNeedles;
+	const FString ClassPathContains = OptionalString(Params, TEXT("classPathContains"));
+	if (!ClassPathContains.IsEmpty())
 	{
-		return MCPError(TEXT("Provide at least one filter: labelPrefix, className, or tag"));
+		ClassPathNeedles.Add(ClassPathContains);
+	}
+	const TArray<TSharedPtr<FJsonValue>>* ClassPathAny = nullptr;
+	if (Params.IsValid() && Params->TryGetArrayField(TEXT("classPathContainsAny"), ClassPathAny) && ClassPathAny)
+	{
+		for (const TSharedPtr<FJsonValue>& Value : *ClassPathAny)
+		{
+			FString Needle;
+			if (Value.IsValid() && Value->TryGetString(Needle) && !Needle.IsEmpty())
+			{
+				ClassPathNeedles.Add(Needle);
+			}
+		}
+	}
+
+	// #924 added the class-path filters and #963 added the label/name ones. Both
+	// are live, so the guard has to accept either family; requiring only one
+	// family's filters would make the other silently unusable.
+	if (LabelPrefix.IsEmpty() && LabelContains.IsEmpty() && NameContains.IsEmpty() &&
+		ClassName.IsEmpty() && Tag.IsEmpty() && ClassPathNeedles.Num() == 0)
+	{
+		return MCPError(TEXT("Provide at least one filter: labelPrefix (case-sensitive prefix over the editor label), labelContains (case-insensitive substring over the label), nameContains (case-insensitive substring over the internal name), className, tag, classPathContains, or classPathContainsAny"));
 	}
 
 	TArray<AActor*> Matches;
@@ -3207,19 +3859,37 @@ TSharedPtr<FJsonValue> FLevelHandlers::DeleteActors(const TSharedPtr<FJsonObject
 		AActor* A = *It;
 		if (!A) continue;
 		if (!LabelPrefix.IsEmpty() && !A->GetActorLabel().StartsWith(LabelPrefix)) continue;
+		if (!LabelContains.IsEmpty() && !A->GetActorLabel().Contains(LabelContains, ESearchCase::IgnoreCase)) continue;
+		if (!NameContains.IsEmpty() && !A->GetName().Contains(NameContains, ESearchCase::IgnoreCase)) continue;
 		if (!ClassName.IsEmpty())
 		{
 			const FString CName = A->GetClass()->GetName();
 			if (!CName.Contains(ClassName)) continue;
 		}
 		if (!Tag.IsEmpty() && !A->ActorHasTag(FName(*Tag))) continue;
+		if (ClassPathNeedles.Num() > 0)
+		{
+			const FString ClassPath = A->GetClass()->GetPathName();
+			bool bPathMatch = false;
+			for (const FString& Needle : ClassPathNeedles)
+			{
+				if (ClassPath.Contains(Needle, ESearchCase::IgnoreCase))
+				{
+					bPathMatch = true;
+					break;
+				}
+			}
+			if (!bPathMatch) continue;
+		}
 		Matches.Add(A);
 	}
 
 	TArray<TSharedPtr<FJsonValue>> Labels;
+	TArray<TSharedPtr<FJsonValue>> ClassPaths;
 	for (AActor* A : Matches)
 	{
 		Labels.Add(MakeShared<FJsonValueString>(A->GetActorLabel()));
+		ClassPaths.Add(MakeShared<FJsonValueString>(A->GetClass()->GetPathName()));
 	}
 
 	int32 Deleted = 0;
@@ -3246,17 +3916,38 @@ TSharedPtr<FJsonValue> FLevelHandlers::DeleteActors(const TSharedPtr<FJsonObject
 	Result->SetNumberField(TEXT("matched"), Matches.Num());
 	Result->SetNumberField(TEXT("deleted"), Deleted);
 	Result->SetArrayField(TEXT("labels"), Labels);
+	Result->SetArrayField(TEXT("classPaths"), ClassPaths);
+
+	// #963: a destructive action that matched nothing must not answer with a
+	// bare success and a zero. A caller who trusts that concludes there is
+	// nothing to delete and moves on, which is exactly what happened. Two
+	// things can produce a wrong zero here, and the response now names both.
+	if (Matches.IsEmpty())
+	{
+		Result->SetStringField(TEXT("zeroMatchNote"),
+			TEXT("No actor matched. This is a filter result, not a statement that the actors do not exist."));
+		const FString Needle = !LabelPrefix.IsEmpty()
+			? LabelPrefix
+			: (!LabelContains.IsEmpty() ? LabelContains : NameContains);
+		if (const TSharedPtr<FJsonObject> Hint = MCPDescribeZeroActorMatch(World, Needle))
+		{
+			Result->SetObjectField(TEXT("zeroMatchHint"), Hint);
+		}
+		MCPNoteLoadedOnlyEnumeration(World, Result);
+	}
 	return MCPResult(Result);
 }
 
 TSharedPtr<FJsonValue> FLevelHandlers::AddActorTag(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ActorLabel; if (auto E = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return E;
+	FString ActorLabel; if (auto E = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return E;
 	FString Tag; if (auto E = RequireString(Params, TEXT("tag"), Tag)) return E;
 
-	AActor* A = FindActorByLabel(World, ActorLabel);
-	if (!A) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* A = MCPResolveActor(World, Params, ActorErr);
+	if (!A) return ActorErr;
+	ActorLabel = A->GetActorLabel();
 
 	const FName TagName(*Tag);
 	const bool bAlreadyHad = A->Tags.Contains(TagName);
@@ -3269,6 +3960,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::AddActorTag(const TSharedPtr<FJsonObject>
 	auto Result = MCPSuccess();
 	if (bAlreadyHad) MCPSetExisted(Result); else MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), A->GetPathName());
 	Result->SetStringField(TEXT("tag"), Tag);
 	TArray<TSharedPtr<FJsonValue>> TagsOut;
 	for (const FName& T : A->Tags) TagsOut.Add(MakeShared<FJsonValueString>(T.ToString()));
@@ -3279,11 +3971,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::AddActorTag(const TSharedPtr<FJsonObject>
 TSharedPtr<FJsonValue> FLevelHandlers::RemoveActorTag(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ActorLabel; if (auto E = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return E;
+	FString ActorLabel; if (auto E = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return E;
 	FString Tag; if (auto E = RequireString(Params, TEXT("tag"), Tag)) return E;
 
-	AActor* A = FindActorByLabel(World, ActorLabel);
-	if (!A) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* A = MCPResolveActor(World, Params, ActorErr);
+	if (!A) return ActorErr;
+	ActorLabel = A->GetActorLabel();
 
 	const FName TagName(*Tag);
 	const int32 Removed = A->Tags.Remove(TagName);
@@ -3296,6 +3990,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::RemoveActorTag(const TSharedPtr<FJsonObje
 	auto Result = MCPSuccess();
 	if (Removed == 0) MCPSetExisted(Result); else MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), A->GetPathName());
 	Result->SetStringField(TEXT("tag"), Tag);
 	Result->SetNumberField(TEXT("removed"), Removed);
 	return MCPResult(Result);
@@ -3304,10 +3999,12 @@ TSharedPtr<FJsonValue> FLevelHandlers::RemoveActorTag(const TSharedPtr<FJsonObje
 TSharedPtr<FJsonValue> FLevelHandlers::SetActorTags(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ActorLabel; if (auto E = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return E;
+	FString ActorLabel; if (auto E = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return E;
 
-	AActor* A = FindActorByLabel(World, ActorLabel);
-	if (!A) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* A = MCPResolveActor(World, Params, ActorErr);
+	if (!A) return ActorErr;
+	ActorLabel = A->GetActorLabel();
 
 	const TArray<TSharedPtr<FJsonValue>>* TagsArr = nullptr;
 	if (!Params->TryGetArrayField(TEXT("tags"), TagsArr) || !TagsArr)
@@ -3330,6 +4027,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorTags(const TSharedPtr<FJsonObject
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), A->GetPathName());
 	TArray<TSharedPtr<FJsonValue>> Out;
 	for (const FName& T : A->Tags) Out.Add(MakeShared<FJsonValueString>(T.ToString()));
 	Result->SetArrayField(TEXT("tags"), Out);
@@ -3339,13 +4037,16 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorTags(const TSharedPtr<FJsonObject
 TSharedPtr<FJsonValue> FLevelHandlers::ListActorTags(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ActorLabel; if (auto E = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return E;
+	FString ActorLabel; if (auto E = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return E;
 
-	AActor* A = FindActorByLabel(World, ActorLabel);
-	if (!A) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* A = MCPResolveActor(World, Params, ActorErr);
+	if (!A) return ActorErr;
+	ActorLabel = A->GetActorLabel();
 
 	auto Result = MCPSuccess();
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), A->GetPathName());
 	TArray<TSharedPtr<FJsonValue>> Out;
 	for (const FName& T : A->Tags) Out.Add(MakeShared<FJsonValueString>(T.ToString()));
 	Result->SetArrayField(TEXT("tags"), Out);
@@ -3357,13 +4058,21 @@ TSharedPtr<FJsonValue> FLevelHandlers::ListActorTags(const TSharedPtr<FJsonObjec
 TSharedPtr<FJsonValue> FLevelHandlers::AttachActor(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ChildLabel; if (auto E = RequireString(Params, TEXT("childLabel"), ChildLabel)) return E;
-	FString ParentLabel; if (auto E = RequireString(Params, TEXT("parentLabel"), ParentLabel)) return E;
-
-	AActor* Child = FindActorByLabel(World, ChildLabel);
-	AActor* Parent = FindActorByLabel(World, ParentLabel);
-	if (!Child) return MCPError(FString::Printf(TEXT("Child actor not found: %s"), *ChildLabel));
-	if (!Parent) return MCPError(FString::Printf(TEXT("Parent actor not found: %s"), *ParentLabel));
+	FString ChildLabel; if (auto E = RequireStringAlt(Params, TEXT("childLabel"), TEXT("childPath"), ChildLabel)) return E;
+	FString ParentLabel; if (auto E = RequireStringAlt(Params, TEXT("parentLabel"), TEXT("parentPath"), ParentLabel)) return E;
+
+	// #983: both ends of an attachment take a path. Attaching to whichever
+	// namesake the iterator reached first is how a prop ends up parented to a
+	// building at the other end of the map.
+	FMCPActorSelector ChildSel; ChildSel.LabelKey = TEXT("childLabel"); ChildSel.PathKey = TEXT("childPath");
+	FMCPActorSelector ParentSel; ParentSel.LabelKey = TEXT("parentLabel"); ParentSel.PathKey = TEXT("parentPath");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Child = MCPResolveActor(World, Params, ActorErr, ChildSel);
+	if (!Child) return ActorErr;
+	AActor* Parent = MCPResolveActor(World, Params, ActorErr, ParentSel);
+	if (!Parent) return ActorErr;
+	ChildLabel = Child->GetActorLabel();
+	ParentLabel = Parent->GetActorLabel();
 
 	const FString RuleStr = OptionalString(Params, TEXT("attachRule"), TEXT("KeepWorld")).ToLower();
 	EAttachmentRule Loc = EAttachmentRule::KeepWorld;
@@ -3380,10 +4089,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::AttachActor(const TSharedPtr<FJsonObject>
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("childLabel"), ChildLabel);
 	Result->SetStringField(TEXT("parentLabel"), ParentLabel);
+	Result->SetStringField(TEXT("childPath"), Child->GetPathName());
+	Result->SetStringField(TEXT("parentPath"), Parent->GetPathName());
 	Result->SetBoolField(TEXT("attached"), bOk);
 
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
 	Payload->SetStringField(TEXT("childLabel"), ChildLabel);
+	Payload->SetStringField(TEXT("childPath"), Child->GetPathName());
 	MCPSetRollback(Result, TEXT("detach_actor"), Payload);
 	return MCPResult(Result);
 }
@@ -3391,10 +4103,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::AttachActor(const TSharedPtr<FJsonObject>
 TSharedPtr<FJsonValue> FLevelHandlers::DetachActor(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ChildLabel; if (auto E = RequireString(Params, TEXT("childLabel"), ChildLabel)) return E;
+	FString ChildLabel; if (auto E = RequireStringAlt(Params, TEXT("childLabel"), TEXT("childPath"), ChildLabel)) return E;
 
-	AActor* Child = FindActorByLabel(World, ChildLabel);
-	if (!Child) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ChildLabel));
+	FMCPActorSelector ChildSel; ChildSel.LabelKey = TEXT("childLabel"); ChildSel.PathKey = TEXT("childPath");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Child = MCPResolveActor(World, Params, ActorErr, ChildSel);
+	if (!Child) return ActorErr;
+	ChildLabel = Child->GetActorLabel();
 
 	Child->Modify();
 	Child->DetachFromActor(FDetachmentTransformRules(EDetachmentRule::KeepWorld, true));
@@ -3403,6 +4118,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::DetachActor(const TSharedPtr<FJsonObject>
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("childLabel"), ChildLabel);
+	Result->SetStringField(TEXT("childPath"), Child->GetPathName());
 	Result->SetBoolField(TEXT("detached"), true);
 	return MCPResult(Result);
 }
@@ -3413,13 +4129,21 @@ TSharedPtr<FJsonValue> FLevelHandlers::DetachActor(const TSharedPtr<FJsonObject>
 TSharedPtr<FJsonValue> FLevelHandlers::AttachComponent(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ChildLabel; if (auto E = RequireString(Params, TEXT("childLabel"), ChildLabel)) return E;
-	FString ParentLabel; if (auto E = RequireString(Params, TEXT("parentLabel"), ParentLabel)) return E;
-
-	AActor* Child = FindActorByLabel(World, ChildLabel);
-	AActor* Parent = FindActorByLabel(World, ParentLabel);
-	if (!Child) return MCPError(FString::Printf(TEXT("Child actor not found: %s"), *ChildLabel));
-	if (!Parent) return MCPError(FString::Printf(TEXT("Parent actor not found: %s"), *ParentLabel));
+	FString ChildLabel; if (auto E = RequireStringAlt(Params, TEXT("childLabel"), TEXT("childPath"), ChildLabel)) return E;
+	FString ParentLabel; if (auto E = RequireStringAlt(Params, TEXT("parentLabel"), TEXT("parentPath"), ParentLabel)) return E;
+
+	// #983: both ends of an attachment take a path. Attaching to whichever
+	// namesake the iterator reached first is how a prop ends up parented to a
+	// building at the other end of the map.
+	FMCPActorSelector ChildSel; ChildSel.LabelKey = TEXT("childLabel"); ChildSel.PathKey = TEXT("childPath");
+	FMCPActorSelector ParentSel; ParentSel.LabelKey = TEXT("parentLabel"); ParentSel.PathKey = TEXT("parentPath");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Child = MCPResolveActor(World, Params, ActorErr, ChildSel);
+	if (!Child) return ActorErr;
+	AActor* Parent = MCPResolveActor(World, Params, ActorErr, ParentSel);
+	if (!Parent) return ActorErr;
+	ChildLabel = Child->GetActorLabel();
+	ParentLabel = Parent->GetActorLabel();
 
 	const FString ChildComponentSelector = OptionalString(Params, TEXT("childComponentName"));
 	const FString ParentComponentSelector = OptionalString(Params, TEXT("parentComponentName"));
@@ -3645,10 +4369,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::AttachComponent(const TSharedPtr<FJsonObj
 TSharedPtr<FJsonValue> FLevelHandlers::DetachComponent(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ChildLabel; if (auto E = RequireString(Params, TEXT("childLabel"), ChildLabel)) return E;
+	FString ChildLabel; if (auto E = RequireStringAlt(Params, TEXT("childLabel"), TEXT("childPath"), ChildLabel)) return E;
 
-	AActor* Child = FindActorByLabel(World, ChildLabel);
-	if (!Child) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ChildLabel));
+	FMCPActorSelector ChildSel; ChildSel.LabelKey = TEXT("childLabel"); ChildSel.PathKey = TEXT("childPath");
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* Child = MCPResolveActor(World, Params, ActorErr, ChildSel);
+	if (!Child) return ActorErr;
+	ChildLabel = Child->GetActorLabel();
 
 	const FString ChildComponentSelector = OptionalString(Params, TEXT("childComponentName"));
 	UActorComponent* ResolvedChildComponent = ChildComponentSelector.IsEmpty()
@@ -3708,11 +4435,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::DetachComponent(const TSharedPtr<FJsonObj
 TSharedPtr<FJsonValue> FLevelHandlers::SetActorMobility(const TSharedPtr<FJsonObject>& Params)
 {
 	REQUIRE_EDITOR_WORLD(World);
-	FString ActorLabel; if (auto E = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return E;
+	FString ActorLabel; if (auto E = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return E;
 	FString MobilityStr; if (auto E = RequireString(Params, TEXT("mobility"), MobilityStr)) return E;
 
-	AActor* A = FindActorByLabel(World, ActorLabel);
-	if (!A) return MCPError(FString::Printf(TEXT("Actor not found: %s"), *ActorLabel));
+	TSharedPtr<FJsonValue> ActorErr;
+	AActor* A = MCPResolveActor(World, Params, ActorErr);
+	if (!A) return ActorErr;
+	ActorLabel = A->GetActorLabel();
 	USceneComponent* Root = A->GetRootComponent();
 	if (!Root) return MCPError(FString::Printf(TEXT("Actor '%s' has no root component"), *ActorLabel));
 
@@ -3731,12 +4460,14 @@ TSharedPtr<FJsonValue> FLevelHandlers::SetActorMobility(const TSharedPtr<FJsonOb
 	auto Result = MCPSuccess();
 	MCPSetUpdated(Result);
 	Result->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Result->SetStringField(TEXT("actorPath"), A->GetPathName());
 	Result->SetStringField(TEXT("mobility"), MobilityStr);
 
 	const TCHAR* PrevStr = Prev == EComponentMobility::Movable ? TEXT("movable")
 		: Prev == EComponentMobility::Stationary ? TEXT("stationary") : TEXT("static");
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
 	Payload->SetStringField(TEXT("actorLabel"), ActorLabel);
+	Payload->SetStringField(TEXT("actorPath"), A->GetPathName());
 	Payload->SetStringField(TEXT("mobility"), PrevStr);
 	MCPSetRollback(Result, TEXT("set_actor_mobility"), Payload);
 	return MCPResult(Result);
@@ -4021,7 +4752,22 @@ TSharedPtr<FJsonValue> FLevelHandlers::BatchTranslate(const TSharedPtr<FJsonObje
 		{
 			FString S; if (V.IsValid() && V->TryGetString(S))
 			{
-				if (AActor* A = FindActorByLabel(World, S)) Targets.Add(A);
+				// #983: a batch is the plural case, so a label naming several
+				// actors moves all of them rather than one at random.
+				TArray<AActor*> Matches;
+				MCPCollectActorsByToken(World, S, EMCPActorMatch::Label, Matches);
+				for (AActor* Match : Matches) Targets.Add(Match);
+			}
+		}
+	}
+	const TArray<TSharedPtr<FJsonValue>>* PathArr = nullptr;
+	if (Params->TryGetArrayField(TEXT("actorPaths"), PathArr) && PathArr)
+	{
+		for (const auto& V : *PathArr)
+		{
+			FString S; if (V.IsValid() && V->TryGetString(S))
+			{
+				if (AActor* A = MCPFindActorByPath(World, S)) Targets.Add(A);
 			}
 		}
 	}
@@ -4033,7 +4779,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::BatchTranslate(const TSharedPtr<FJsonObje
 			if (It->ActorHasTag(TagName)) Targets.Add(*It);
 		}
 	}
-	if (Targets.Num() == 0) return MCPError(TEXT("Provide actorLabels[] or tag matching at least one actor"));
+	if (Targets.Num() == 0) return MCPError(TEXT("Provide actorLabels[], actorPaths[] or tag matching at least one actor"));
 
 	for (AActor* A : Targets)
 	{