ue-mcp 1.2.3 → 1.3.0

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/SkeletonDiffTests.cpp

@@ -0,0 +1,685 @@
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Animation/Skeleton.h"
+#include "Engine/SkeletalMesh.h"
+#include "HandlerUtils.h"
+#include "HandlerRegistry.h"
+#include "Handlers/DiffHandlers.h"
+#include "Misc/AutomationTest.h"
+#include "ReferenceSkeleton.h"
+#include "UObject/ObjectSaveContext.h"
+#include "UObject/Package.h"
+
+#include <initializer_list>
+
+namespace
+{
+struct FTestBone
+{
+	const TCHAR* Name;
+	int32 ParentIndex;
+};
+
+class FTransientSkeletonPackage
+{
+public:
+	explicit FTransientSkeletonPackage(const TCHAR* TestName)
+	{
+		const FString PackageName = FString::Printf(
+			TEXT("/Temp/UEMCP_%s_%s"),
+			TestName,
+			*FGuid::NewGuid().ToString(EGuidFormats::Digits));
+		Package = CreatePackage(*PackageName);
+		// PKG_Transient was removed from EPackageFlags in UE 5.8. RF_Transient on
+		// the package object is the supported way to say "never save this".
+		Package->SetFlags(RF_Transient);
+		Package->SetDirtyFlag(false);
+	}
+
+	~FTransientSkeletonPackage()
+	{
+		if (Package)
+		{
+			Package->SetDirtyFlag(false);
+			Package->MarkAsGarbage();
+		}
+	}
+
+	USkeleton* AddSkeleton(const TCHAR* Name, std::initializer_list<FTestBone> Bones)
+	{
+		USkeleton* Skeleton = NewObject<USkeleton>(Package, FName(Name), RF_Transient);
+		{
+			FReferenceSkeletonModifier Modifier(Skeleton);
+			for (const FTestBone& Bone : Bones)
+			{
+				Modifier.Add(
+					FMeshBoneInfo(FName(Bone.Name), Bone.Name, Bone.ParentIndex),
+					FTransform::Identity);
+			}
+		}
+		return Skeleton;
+	}
+
+	USkeletalMesh* AddSkeletalMesh(
+		const TCHAR* Name,
+		std::initializer_list<FTestBone> Bones,
+		USkeleton* AssociatedSkeleton)
+	{
+		USkeletalMesh* Mesh = NewObject<USkeletalMesh>(Package, FName(Name), RF_Transient);
+		FReferenceSkeleton ReferenceSkeleton;
+		{
+			FReferenceSkeletonModifier Modifier(ReferenceSkeleton, AssociatedSkeleton);
+			for (const FTestBone& Bone : Bones)
+			{
+				Modifier.Add(
+					FMeshBoneInfo(FName(Bone.Name), Bone.Name, Bone.ParentIndex),
+					FTransform::Identity);
+			}
+		}
+		Mesh->SetRefSkeleton(ReferenceSkeleton);
+		Mesh->SetSkeleton(AssociatedSkeleton);
+		return Mesh;
+	}
+
+	UObject* AddWrongTypeObject(const TCHAR* Name)
+	{
+		return NewObject<UObject>(Package, FName(Name), RF_Transient);
+	}
+
+	void ResetDirty() const
+	{
+		Package->SetDirtyFlag(false);
+	}
+
+	UPackage* GetPackage() const
+	{
+		return Package;
+	}
+
+private:
+	UPackage* Package = nullptr;
+};
+
+class FPackageSaveObserver
+{
+public:
+	explicit FPackageSaveObserver(UPackage* InPackage)
+		: ObservedPackage(InPackage)
+	{
+		Handle = UPackage::PreSavePackageWithContextEvent.AddLambda(
+			[this](UPackage* Package, FObjectPreSaveContext)
+			{
+				if (Package == ObservedPackage)
+				{
+					++SaveAttempts;
+				}
+			});
+	}
+
+	~FPackageSaveObserver()
+	{
+		UPackage::PreSavePackageWithContextEvent.Remove(Handle);
+	}
+
+	int32 GetSaveAttempts() const
+	{
+		return SaveAttempts;
+	}
+
+private:
+	UPackage* ObservedPackage = nullptr;
+	FDelegateHandle Handle;
+	int32 SaveAttempts = 0;
+};
+
+TSharedPtr<FJsonObject> MakeDiffRequest(const FString& FromPath, const FString& ToPath)
+{
+	TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+	Request->SetStringField(TEXT("assetPath"), FromPath);
+	if (!ToPath.IsEmpty())
+	{
+		Request->SetStringField(TEXT("otherPath"), ToPath);
+	}
+	return Request;
+}
+
+TSharedPtr<FJsonObject> ExecuteDiff(
+	FMCPHandlerRegistry& Registry,
+	const FString& FromPath,
+	const FString& ToPath)
+{
+	const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(
+		TEXT("diff_asset"),
+		MakeDiffRequest(FromPath, ToPath));
+	return Response.IsValid() && Response->Type == EJson::Object
+		? Response->AsObject()
+		: nullptr;
+}
+
+TSharedPtr<FJsonObject> ExecuteDiff(
+	FMCPHandlerRegistry& Registry,
+	const UObject* From,
+	const UObject* To)
+{
+	return ExecuteDiff(
+		Registry,
+		From->GetPathName(),
+		To ? To->GetPathName() : FString());
+}
+
+TArray<FString> GetStringArray(const TSharedPtr<FJsonObject>& Object, const TCHAR* Field)
+{
+	TArray<FString> Result;
+	const TArray<TSharedPtr<FJsonValue>>* Values = nullptr;
+	if (Object.IsValid() && Object->TryGetArrayField(Field, Values) && Values)
+	{
+		for (const TSharedPtr<FJsonValue>& Value : *Values)
+		{
+			FString StringValue;
+			if (Value.IsValid() && Value->TryGetString(StringValue))
+			{
+				Result.Add(MoveTemp(StringValue));
+			}
+		}
+	}
+	return Result;
+}
+
+const TArray<TSharedPtr<FJsonValue>>* GetArray(
+	const TSharedPtr<FJsonObject>& Object,
+	const TCHAR* Field)
+{
+	const TArray<TSharedPtr<FJsonValue>>* Values = nullptr;
+	return Object.IsValid() && Object->TryGetArrayField(Field, Values) ? Values : nullptr;
+}
+
+bool AddNamedVirtualBoneForTest(
+	USkeleton* Skeleton,
+	const FName SourceBone,
+	const FName TargetBone,
+	const FName DesiredName,
+	FName& OutActualName)
+{
+#if UE_MCP_HAS_5_5_API
+	OutActualName = DesiredName;
+	return Skeleton->AddNewNamedVirtualBone(SourceBone, TargetBone, DesiredName);
+#else
+	OutActualName = NAME_None;
+	return Skeleton->AddNewVirtualBone(SourceBone, TargetBone, OutActualName);
+#endif
+}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletonDiffRegistrationAndValidationTest,
+	"UE.MCP.Diff.Skeleton.RegistrationAndValidation",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletonDiffRegistrationAndValidationTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	TestTrue(TEXT("diff_asset is registered"), Registry.HasHandler(TEXT("diff_asset")));
+
+	FTransientSkeletonPackage Fixture(TEXT("SkeletonDiffValidation"));
+	USkeleton* Skeleton = Fixture.AddSkeleton(TEXT("Skeleton"), {
+		{ TEXT("root"), INDEX_NONE },
+	});
+	UObject* WrongType = Fixture.AddWrongTypeObject(TEXT("WrongType"));
+	Fixture.ResetDirty();
+	FPackageSaveObserver SaveObserver(Fixture.GetPackage());
+
+	const TSharedPtr<FJsonObject> MissingOther = ExecuteDiff(Registry, Skeleton, nullptr);
+	TestTrue(TEXT("missing otherPath returns an object"), MissingOther.IsValid());
+	if (MissingOther.IsValid())
+	{
+		TestFalse(TEXT("missing otherPath fails"), MissingOther->GetBoolField(TEXT("success")));
+		TestTrue(
+			TEXT("missing otherPath names the missing parameter"),
+			MissingOther->GetStringField(TEXT("error")).Contains(TEXT("otherPath")));
+	}
+
+	const TSharedPtr<FJsonObject> WrongTypeResult = ExecuteDiff(Registry, Skeleton, WrongType);
+	TestTrue(TEXT("wrong-type otherPath returns an object"), WrongTypeResult.IsValid());
+	if (WrongTypeResult.IsValid())
+	{
+		TestFalse(TEXT("wrong-type otherPath fails"), WrongTypeResult->GetBoolField(TEXT("success")));
+		const FString Error = WrongTypeResult->GetStringField(TEXT("error"));
+		TestTrue(TEXT("wrong type requires an exact Skeleton"), Error.Contains(TEXT("must be exactly a Skeleton")));
+		TestTrue(TEXT("wrong type identifies the resolved class"), Error.Contains(TEXT("Object")));
+	}
+
+	const FString MissingFromPath = Fixture.GetPackage()->GetName() + TEXT(".MissingFrom");
+	const TSharedPtr<FJsonObject> MissingFrom = ExecuteDiff(
+		Registry,
+		MissingFromPath,
+		Skeleton->GetPathName());
+	TestTrue(TEXT("unloadable assetPath returns an object"), MissingFrom.IsValid());
+	if (MissingFrom.IsValid())
+	{
+		TestFalse(TEXT("unloadable assetPath fails"), MissingFrom->GetBoolField(TEXT("success")));
+		const FString Error = MissingFrom->GetStringField(TEXT("error"));
+		TestTrue(TEXT("unloadable assetPath has a clear not-found error"), Error.Contains(TEXT("Asset not found")));
+		TestTrue(TEXT("unloadable assetPath error identifies the path"), Error.Contains(MissingFromPath));
+	}
+
+	const FString MissingToPath = Fixture.GetPackage()->GetName() + TEXT(".MissingTo");
+	const TSharedPtr<FJsonObject> MissingTo = ExecuteDiff(
+		Registry,
+		Skeleton->GetPathName(),
+		MissingToPath);
+	TestTrue(TEXT("unloadable otherPath returns an object"), MissingTo.IsValid());
+	if (MissingTo.IsValid())
+	{
+		TestFalse(TEXT("unloadable otherPath fails"), MissingTo->GetBoolField(TEXT("success")));
+		const FString Error = MissingTo->GetStringField(TEXT("error"));
+		TestTrue(TEXT("unloadable otherPath has a clear not-found error"), Error.Contains(TEXT("Asset not found")));
+		TestTrue(TEXT("unloadable otherPath error identifies the path"), Error.Contains(MissingToPath));
+	}
+	TestFalse(TEXT("validation does not dirty the fixture package"), Fixture.GetPackage()->IsDirty());
+	TestEqual(TEXT("validation never attempts to save the fixture package"), SaveObserver.GetSaveAttempts(), 0);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletonDiffIdenticalAndSideEffectsTest,
+	"UE.MCP.Diff.Skeleton.IdenticalAndSideEffects",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletonDiffIdenticalAndSideEffectsTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	FTransientSkeletonPackage Fixture(TEXT("SkeletonDiffIdentical"));
+	USkeleton* Skeleton = Fixture.AddSkeleton(TEXT("Skeleton"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("pelvis"), 0 },
+	});
+	Fixture.ResetDirty();
+	FPackageSaveObserver SaveObserver(Fixture.GetPackage());
+
+	const TSharedPtr<FJsonObject> Result = ExecuteDiff(Registry, Skeleton, Skeleton);
+	TestTrue(TEXT("same-object diff returns an object"), Result.IsValid());
+	if (Result.IsValid())
+	{
+		TestTrue(TEXT("same-object diff succeeds"), Result->GetBoolField(TEXT("success")));
+		TestEqual(TEXT("asset type is Skeleton"), Result->GetStringField(TEXT("assetType")), FString(TEXT("Skeleton")));
+		TestTrue(TEXT("same-object diff is identical"), Result->GetBoolField(TEXT("identical")));
+		TestTrue(TEXT("same-object diff is structurally identical"), Result->GetBoolField(TEXT("structurallyIdentical")));
+		TestEqual(TEXT("identical diff has zero changes"), static_cast<int32>(Result->GetNumberField(TEXT("changeCount"))), 0);
+		TestEqual(TEXT("raw count is reported"), static_cast<int32>(Result->GetNumberField(TEXT("rawBoneCountFrom"))), 2);
+		TestEqual(TEXT("final count is reported"), static_cast<int32>(Result->GetNumberField(TEXT("boneCountFrom"))), 2);
+		TestTrue(TEXT("same object is editor-compatible"), Result->GetBoolField(TEXT("editorCompatible")));
+		TestTrue(TEXT("identical hierarchy is compatible"), Result->GetBoolField(TEXT("hierarchyCompatible")));
+		TestEqual(TEXT("identical diff has no added raw bones"), GetStringArray(Result, TEXT("rawBonesAdded")).Num(), 0);
+	}
+	TestFalse(TEXT("read-only diff does not dirty its package"), Fixture.GetPackage()->IsDirty());
+	TestEqual(TEXT("read-only diff never attempts to save its package"), SaveObserver.GetSaveAttempts(), 0);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletonDiffFNameIdentityTest,
+	"UE.MCP.Diff.Skeleton.FNameIdentity",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletonDiffFNameIdentityTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	FTransientSkeletonPackage Fixture(TEXT("SkeletonDiffFNameIdentity"));
+	USkeleton* From = Fixture.AddSkeleton(TEXT("From"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("pelvis"), 0 },
+		{ TEXT("hand"), 1 },
+	});
+	USkeleton* To = Fixture.AddSkeleton(TEXT("To"), {
+		{ TEXT("ROOT"), INDEX_NONE },
+		{ TEXT("PELVIS"), 0 },
+		{ TEXT("HAND"), 1 },
+	});
+	FName FromVirtualName;
+	FName ToVirtualName;
+	TestTrue(
+		TEXT("from virtual bone is created"),
+		AddNamedVirtualBoneForTest(From, TEXT("pelvis"), TEXT("hand"), TEXT("VB Aim"), FromVirtualName));
+	TestTrue(
+		TEXT("to virtual bone is created"),
+		AddNamedVirtualBoneForTest(To, TEXT("PELVIS"), TEXT("HAND"), TEXT("vb aim"), ToVirtualName));
+	TestEqual(TEXT("case-only virtual bone names retain FName identity"), FromVirtualName, ToVirtualName);
+	Fixture.ResetDirty();
+
+	const TSharedPtr<FJsonObject> Result = ExecuteDiff(Registry, From, To);
+	TestTrue(TEXT("case-only diff succeeds"), Result.IsValid() && Result->GetBoolField(TEXT("success")));
+	if (Result.IsValid())
+	{
+		TestTrue(TEXT("FName-equivalent skeletons are structurally identical"), Result->GetBoolField(TEXT("structurallyIdentical")));
+		TestTrue(TEXT("FName-equivalent hierarchy is compatible"), Result->GetBoolField(TEXT("hierarchyCompatible")));
+		TestEqual(TEXT("case-only names add no changes"), static_cast<int32>(Result->GetNumberField(TEXT("changeCount"))), 0);
+		TestEqual(TEXT("case-only raw names are not added"), GetStringArray(Result, TEXT("rawBonesAdded")).Num(), 0);
+		TestEqual(TEXT("case-only raw names are not removed"), GetStringArray(Result, TEXT("rawBonesRemoved")).Num(), 0);
+		const TArray<TSharedPtr<FJsonValue>>* AddedVirtual = GetArray(Result, TEXT("virtualBonesAdded"));
+		const TArray<TSharedPtr<FJsonValue>>* RemovedVirtual = GetArray(Result, TEXT("virtualBonesRemoved"));
+		TestTrue(TEXT("case-only virtual names are not added"), AddedVirtual && AddedVirtual->Num() == 0);
+		TestTrue(TEXT("case-only virtual names are not removed"), RemovedVirtual && RemovedVirtual->Num() == 0);
+	}
+	TestFalse(TEXT("case-only diff does not dirty its package"), Fixture.GetPackage()->IsDirty());
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletonDiffDirectionalRawBoneTest,
+	"UE.MCP.Diff.Skeleton.DirectionalRawBonesAndOrdering",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletonDiffDirectionalRawBoneTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	FTransientSkeletonPackage Fixture(TEXT("SkeletonDiffRaw"));
+	USkeleton* From = Fixture.AddSkeleton(TEXT("From"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("RemovedZulu"), 0 },
+		{ TEXT("RemovedAlpha"), 0 },
+	});
+	USkeleton* To = Fixture.AddSkeleton(TEXT("To"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("AddedZulu"), 0 },
+		{ TEXT("AddedAlpha"), 0 },
+	});
+	Fixture.ResetDirty();
+
+	const TSharedPtr<FJsonObject> Forward = ExecuteDiff(Registry, From, To);
+	TestTrue(TEXT("forward raw-bone diff succeeds"), Forward.IsValid() && Forward->GetBoolField(TEXT("success")));
+	if (Forward.IsValid())
+	{
+		const TArray<FString> Added = GetStringArray(Forward, TEXT("rawBonesAdded"));
+		const TArray<FString> Removed = GetStringArray(Forward, TEXT("rawBonesRemoved"));
+		TestEqual(TEXT("two raw bones are added"), Added.Num(), 2);
+		TestEqual(TEXT("two raw bones are removed"), Removed.Num(), 2);
+		if (Added.Num() == 2)
+		{
+			TestEqual(TEXT("added bones are sorted first"), Added[0], FString(TEXT("AddedAlpha")));
+			TestEqual(TEXT("added bones are sorted second"), Added[1], FString(TEXT("AddedZulu")));
+		}
+		if (Removed.Num() == 2)
+		{
+			TestEqual(TEXT("removed bones are sorted first"), Removed[0], FString(TEXT("RemovedAlpha")));
+			TestEqual(TEXT("removed bones are sorted second"), Removed[1], FString(TEXT("RemovedZulu")));
+		}
+		TestTrue(TEXT("additive/removal-only hierarchy stays compatible"), Forward->GetBoolField(TEXT("hierarchyCompatible")));
+	}
+
+	const TSharedPtr<FJsonObject> Reverse = ExecuteDiff(Registry, To, From);
+	TestTrue(TEXT("reverse raw-bone diff succeeds"), Reverse.IsValid() && Reverse->GetBoolField(TEXT("success")));
+	if (Reverse.IsValid())
+	{
+		TestTrue(
+			TEXT("reverse added set is the forward removed set"),
+			GetStringArray(Reverse, TEXT("rawBonesAdded")) == GetStringArray(Forward, TEXT("rawBonesRemoved")));
+		TestTrue(
+			TEXT("reverse removed set is the forward added set"),
+			GetStringArray(Reverse, TEXT("rawBonesRemoved")) == GetStringArray(Forward, TEXT("rawBonesAdded")));
+	}
+	TestFalse(TEXT("directional diff does not dirty its package"), Fixture.GetPackage()->IsDirty());
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletonDiffRawBoneIndexTest,
+	"UE.MCP.Diff.Skeleton.RawBoneIndexChanges",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletonDiffRawBoneIndexTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	FTransientSkeletonPackage Fixture(TEXT("SkeletonDiffRawIndex"));
+	USkeleton* From = Fixture.AddSkeleton(TEXT("From"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("SiblingZulu"), 0 },
+		{ TEXT("SiblingAlpha"), 0 },
+	});
+	USkeleton* To = Fixture.AddSkeleton(TEXT("To"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("SiblingAlpha"), 0 },
+		{ TEXT("SiblingZulu"), 0 },
+	});
+	Fixture.ResetDirty();
+
+	const TSharedPtr<FJsonObject> Result = ExecuteDiff(Registry, From, To);
+	TestTrue(TEXT("raw-index diff succeeds"), Result.IsValid() && Result->GetBoolField(TEXT("success")));
+	if (Result.IsValid())
+	{
+		TestFalse(TEXT("sibling reordering is not structurally identical"), Result->GetBoolField(TEXT("structurallyIdentical")));
+		TestTrue(TEXT("sibling reordering preserves hierarchy compatibility"), Result->GetBoolField(TEXT("hierarchyCompatible")));
+		TestEqual(TEXT("sibling reordering counts two index changes"), static_cast<int32>(Result->GetNumberField(TEXT("changeCount"))), 2);
+		TestEqual(TEXT("sibling reordering adds no raw bones"), GetStringArray(Result, TEXT("rawBonesAdded")).Num(), 0);
+		TestEqual(TEXT("sibling reordering removes no raw bones"), GetStringArray(Result, TEXT("rawBonesRemoved")).Num(), 0);
+		const TArray<TSharedPtr<FJsonValue>>* IndexChanges = GetArray(Result, TEXT("rawBoneIndexChanges"));
+		TestTrue(TEXT("raw index changes are present"), IndexChanges && IndexChanges->Num() == 2);
+		if (IndexChanges && IndexChanges->Num() == 2)
+		{
+			const TSharedPtr<FJsonObject> First = (*IndexChanges)[0]->AsObject();
+			const TSharedPtr<FJsonObject> Second = (*IndexChanges)[1]->AsObject();
+			TestEqual(TEXT("index changes are sorted by bone name"), First->GetStringField(TEXT("bone")), FString(TEXT("SiblingAlpha")));
+			TestEqual(TEXT("first old index is exact"), static_cast<int32>(First->GetNumberField(TEXT("fromIndex"))), 2);
+			TestEqual(TEXT("first new index is exact"), static_cast<int32>(First->GetNumberField(TEXT("toIndex"))), 1);
+			TestEqual(TEXT("second changed bone is exact"), Second->GetStringField(TEXT("bone")), FString(TEXT("SiblingZulu")));
+			TestEqual(TEXT("second old index is exact"), static_cast<int32>(Second->GetNumberField(TEXT("fromIndex"))), 1);
+			TestEqual(TEXT("second new index is exact"), static_cast<int32>(Second->GetNumberField(TEXT("toIndex"))), 2);
+		}
+	}
+	TestFalse(TEXT("raw-index diff does not dirty its package"), Fixture.GetPackage()->IsDirty());
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletalMeshDiffPublicRouteTest,
+	"UE.MCP.Diff.Skeleton.SkeletalMeshPublicRoute",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletalMeshDiffPublicRouteTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	FTransientSkeletonPackage Fixture(TEXT("SkeletalMeshDiffRoute"));
+	USkeleton* FromPolicy = Fixture.AddSkeleton(TEXT("FromPolicy"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("pelvis"), 0 },
+	});
+	USkeleton* ToPolicy = Fixture.AddSkeleton(TEXT("ToPolicy"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("pelvis"), 0 },
+		{ TEXT("hand_attach"), 1 },
+	});
+	FName FromVirtualName;
+	FName ToVirtualName;
+	TestTrue(
+		TEXT("from policy virtual bone is created"),
+		AddNamedVirtualBoneForTest(FromPolicy, TEXT("root"), TEXT("pelvis"), TEXT("VB shared"), FromVirtualName));
+	TestTrue(
+		TEXT("to policy virtual bone is created"),
+		AddNamedVirtualBoneForTest(ToPolicy, TEXT("root"), TEXT("pelvis"), TEXT("VB shared"), ToVirtualName));
+	USkeletalMesh* From = Fixture.AddSkeletalMesh(TEXT("SK_From"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("pelvis"), 0 },
+	}, FromPolicy);
+	USkeletalMesh* To = Fixture.AddSkeletalMesh(TEXT("SK_To"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("pelvis"), 0 },
+		{ TEXT("hand_attach"), 1 },
+	}, ToPolicy);
+	Fixture.ResetDirty();
+	FPackageSaveObserver SaveObserver(Fixture.GetPackage());
+
+	const TSharedPtr<FJsonObject> Result = ExecuteDiff(Registry, From, To);
+	TestTrue(TEXT("public diff_asset routes SkeletalMesh assets"), Result.IsValid() && Result->GetBoolField(TEXT("success")));
+	if (Result.IsValid())
+	{
+		TestEqual(TEXT("asset type is SkeletalMesh"), Result->GetStringField(TEXT("assetType")), FString(TEXT("SkeletalMesh")));
+		TestEqual(TEXT("mesh raw count from is compact"), static_cast<int32>(Result->GetNumberField(TEXT("rawBoneCountFrom"))), 2);
+		TestEqual(TEXT("mesh raw count to is compact"), static_cast<int32>(Result->GetNumberField(TEXT("rawBoneCountTo"))), 3);
+		const TArray<FString> Added = GetStringArray(Result, TEXT("rawBonesAdded"));
+		TestEqual(TEXT("mesh diff reports one added bone"), Added.Num(), 1);
+		if (Added.Num() == 1)
+		{
+			TestEqual(TEXT("mesh added bone is exact"), Added[0], FString(TEXT("hand_attach")));
+		}
+		TestTrue(TEXT("additive mesh hierarchy remains compatible"), Result->GetBoolField(TEXT("hierarchyCompatible")));
+		TestEqual(TEXT("mesh policy virtual bones are compared"), static_cast<int32>(Result->GetNumberField(TEXT("virtualBoneCountFrom"))), 1);
+		TestEqual(TEXT("from virtual source is the associated Skeleton"), Result->GetStringField(TEXT("virtualBoneSourceFrom")), FromPolicy->GetPathName());
+		TestFalse(TEXT("reference-pose omission is explicit"), Result->GetBoolField(TEXT("referencePoseCompared")));
+		TestFalse(TEXT("export-name omission is explicit"), Result->GetBoolField(TEXT("exportNamesCompared")));
+	}
+	TestFalse(TEXT("SkeletalMesh diff stays read-only"), Fixture.GetPackage()->IsDirty());
+	TestEqual(TEXT("SkeletalMesh diff never saves"), SaveObserver.GetSaveAttempts(), 0);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletonDiffReparentTest,
+	"UE.MCP.Diff.Skeleton.ReparentedHierarchy",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletonDiffReparentTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	FTransientSkeletonPackage Fixture(TEXT("SkeletonDiffReparent"));
+	USkeleton* From = Fixture.AddSkeleton(TEXT("From"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("ParentA"), 0 },
+		{ TEXT("ParentB"), 0 },
+		{ TEXT("CommonBone"), 1 },
+	});
+	USkeleton* To = Fixture.AddSkeleton(TEXT("To"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("ParentB"), 0 },
+		{ TEXT("ParentA"), 0 },
+		{ TEXT("CommonBone"), 1 },
+	});
+	Fixture.ResetDirty();
+
+	const TSharedPtr<FJsonObject> Result = ExecuteDiff(Registry, From, To);
+	TestTrue(TEXT("reparent diff succeeds"), Result.IsValid() && Result->GetBoolField(TEXT("success")));
+	if (Result.IsValid())
+	{
+		TestFalse(TEXT("reparented hierarchy is incompatible"), Result->GetBoolField(TEXT("hierarchyCompatible")));
+		TestEqual(TEXT("numeric sibling reordering does not look like add/remove"), GetStringArray(Result, TEXT("rawBonesAdded")).Num(), 0);
+		const TArray<TSharedPtr<FJsonValue>>* Reparented = GetArray(Result, TEXT("reparented"));
+		TestTrue(TEXT("reparented array is present"), Reparented != nullptr);
+		if (Reparented && Reparented->Num() == 1)
+		{
+			const TSharedPtr<FJsonObject> Delta = (*Reparented)[0]->AsObject();
+			TestEqual(TEXT("reparented bone is named"), Delta->GetStringField(TEXT("bone")), FString(TEXT("CommonBone")));
+			TestEqual(TEXT("old parent is name-derived"), Delta->GetStringField(TEXT("fromParent")), FString(TEXT("ParentA")));
+			TestEqual(TEXT("new parent is name-derived"), Delta->GetStringField(TEXT("toParent")), FString(TEXT("ParentB")));
+		}
+		else
+		{
+			AddError(TEXT("Expected exactly one reparented bone"));
+		}
+	}
+	TestFalse(TEXT("reparent diff does not dirty its package"), Fixture.GetPackage()->IsDirty());
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletonDiffVirtualBoneTest,
+	"UE.MCP.Diff.Skeleton.VirtualBones",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletonDiffVirtualBoneTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	FTransientSkeletonPackage Fixture(TEXT("SkeletonDiffVirtual"));
+	USkeleton* From = Fixture.AddSkeleton(TEXT("From"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("Source"), 0 },
+		{ TEXT("TargetA"), 0 },
+		{ TEXT("TargetB"), 0 },
+	});
+	USkeleton* To = Fixture.AddSkeleton(TEXT("To"), {
+		{ TEXT("root"), INDEX_NONE },
+		{ TEXT("Source"), 0 },
+		{ TEXT("TargetA"), 0 },
+		{ TEXT("TargetB"), 0 },
+	});
+	FName FromVirtualName;
+	FName ToVirtualName;
+	TestTrue(
+		TEXT("from virtual bone is created"),
+		AddNamedVirtualBoneForTest(From, TEXT("Source"), TEXT("TargetA"), TEXT("VB shared"), FromVirtualName));
+	TestTrue(
+		TEXT("to virtual bone is created"),
+		AddNamedVirtualBoneForTest(To, TEXT("Source"), TEXT("TargetB"), TEXT("VB shared"), ToVirtualName));
+	Fixture.ResetDirty();
+
+	const TSharedPtr<FJsonObject> Result = ExecuteDiff(Registry, From, To);
+	TestTrue(TEXT("virtual-bone diff succeeds"), Result.IsValid() && Result->GetBoolField(TEXT("success")));
+	if (Result.IsValid())
+	{
+		TestTrue(TEXT("virtual endpoint change is non-identical"), !Result->GetBoolField(TEXT("identical")));
+		TestTrue(TEXT("virtual-only delta preserves raw hierarchy compatibility"), Result->GetBoolField(TEXT("hierarchyCompatible")));
+		TestEqual(TEXT("declared virtual count from is reported"), static_cast<int32>(Result->GetNumberField(TEXT("virtualBoneCountFrom"))), 1);
+		TestEqual(TEXT("final reference count includes valid virtual from"), static_cast<int32>(Result->GetNumberField(TEXT("boneCountFrom"))), 5);
+
+		const TArray<TSharedPtr<FJsonValue>>* Added = GetArray(Result, TEXT("virtualBonesAdded"));
+		const TArray<TSharedPtr<FJsonValue>>* Removed = GetArray(Result, TEXT("virtualBonesRemoved"));
+		TestTrue(TEXT("changed virtual definition adds one record"), Added && Added->Num() == 1);
+		TestTrue(TEXT("changed virtual definition removes one record"), Removed && Removed->Num() == 1);
+		if (Added && Added->Num() == 1)
+		{
+			const TSharedPtr<FJsonObject> Bone = (*Added)[0]->AsObject();
+			TestEqual(TEXT("added virtual name"), Bone->GetStringField(TEXT("name")), ToVirtualName.ToString());
+			TestEqual(TEXT("added virtual source"), Bone->GetStringField(TEXT("sourceBone")), FString(TEXT("Source")));
+			TestEqual(TEXT("added virtual target"), Bone->GetStringField(TEXT("targetBone")), FString(TEXT("TargetB")));
+		}
+		if (Removed && Removed->Num() == 1)
+		{
+			const TSharedPtr<FJsonObject> Bone = (*Removed)[0]->AsObject();
+			TestEqual(TEXT("removed virtual name"), Bone->GetStringField(TEXT("name")), FromVirtualName.ToString());
+			TestEqual(TEXT("removed virtual target"), Bone->GetStringField(TEXT("targetBone")), FString(TEXT("TargetA")));
+		}
+	}
+	TestFalse(TEXT("virtual diff does not dirty its package"), Fixture.GetPackage()->IsDirty());
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FSkeletonDiffEditorCompatibilityTest,
+	"UE.MCP.Diff.Skeleton.EditorCompatibility",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FSkeletonDiffEditorCompatibilityTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FDiffHandlers::RegisterHandlers(Registry);
+	FTransientSkeletonPackage Fixture(TEXT("SkeletonDiffCompatibility"));
+	USkeleton* From = Fixture.AddSkeleton(TEXT("From"), {
+		{ TEXT("root"), INDEX_NONE },
+	});
+	USkeleton* To = Fixture.AddSkeleton(TEXT("To"), {
+		{ TEXT("root"), INDEX_NONE },
+	});
+	To->AddCompatibleSkeleton(From);
+	TestFalse(
+		TEXT("forward policy query is false before the reverse-compatible diff"),
+		From->IsCompatibleForEditor(To));
+	Fixture.ResetDirty();
+
+	const TSharedPtr<FJsonObject> Result = ExecuteDiff(Registry, From, To);
+	TestTrue(TEXT("editor-compatibility diff succeeds"), Result.IsValid() && Result->GetBoolField(TEXT("success")));
+	if (Result.IsValid())
+	{
+		TestTrue(TEXT("editorCompatible field is present"), Result->HasTypedField<EJson::Boolean>(TEXT("editorCompatible")));
+		TestTrue(TEXT("explicitly registered skeleton is editor-compatible"), Result->GetBoolField(TEXT("editorCompatible")));
+		TestTrue(TEXT("hierarchy compatibility remains separately present"), Result->HasTypedField<EJson::Boolean>(TEXT("hierarchyCompatible")));
+	}
+	TestFalse(TEXT("compatibility query does not dirty its package"), Fixture.GetPackage()->IsDirty());
+	return true;
+}
+
+#endif