ue-mcp 1.0.39 → 1.0.41

package/dist/tool-counts.json

@@ -26,6 +26,6 @@
     "statetree": 35,
     "plugins": 2
   },
-  "generatedAt": "2026-05-25T18:04:42.047Z",
-  "version": "1.0.39"
+  "generatedAt": "2026-05-25T18:39:43.608Z",
+  "version": "1.0.41"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ue-mcp",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "Unreal Engine MCP server - 21 tools, 556+ actions for AI-driven editor control",
   "type": "module",
   "main": "dist/index.js",

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/PIE/PIEFrameSampler.cpp

@@ -146,6 +146,7 @@ namespace UEMCPPIE
 		TrackedValues.Reset();
 		Tracked.Reset();
 		PendingMarkerLabels.Reset();
+		PrevPawnLocation = FVector::ZeroVector;
 		// Re-seed TrackedValues from config in case the caller calls AttachToPIE again.
 		for (const FString& P : Config.TrackedValuePaths)
 		{
@@ -218,6 +219,41 @@ namespace UEMCPPIE
 		APawn* Pawn = PC->GetPawn();
 		if (!Pawn) return Row;
 
+		// Rescan for late-bound actions (IMCs added after initial attach).
+		if (UEnhancedInputComponent* EIC = Cast<UEnhancedInputComponent>(Pawn->InputComponent))
+		{
+			TSet<FString> Known;
+			for (const FTrackedAction& T : Tracked) Known.Add(T.Path);
+
+			TSet<FString> Whitelist;
+			for (const FString& P : Config.ActionPaths) Whitelist.Add(P);
+
+			for (const TUniquePtr<FEnhancedInputActionEventBinding>& Bind : EIC->GetActionEventBindings())
+			{
+				const UInputAction* Action = Bind->GetAction();
+				if (!Action) continue;
+				const FString Path = Action->GetPathName();
+				if (Known.Contains(Path)) continue;
+				if (!Whitelist.IsEmpty() && !Whitelist.Contains(Path)) continue;
+				Known.Add(Path);
+
+				FTrackedAction T;
+				T.Action = Action;
+				T.Name = Action->GetName();
+				T.Path = Path;
+				T.ValueType = ConvertValueType(Action->ValueType);
+				Tracked.Add(T);
+
+				FActionSpec Spec;
+				Spec.Name = T.Name;
+				Spec.Path = Path;
+				Spec.ValueType = T.ValueType;
+				Actions.Add(Spec);
+				UE_LOG(LogMCPBridge, Log, TEXT("[PIE-SAMPLER] Late-discovered action: %s (%s)"),
+					*T.Name, *Path);
+			}
+		}
+
 		if (Config.bCapturePawnState)
 		{
 			Row.PawnLocation = Pawn->GetActorLocation();
@@ -232,8 +268,21 @@ namespace UEMCPPIE
 			}
 			else
 			{
-				Row.PawnVelocity = Pawn->GetVelocity();
-				Row.Speed2D = Pawn->GetVelocity().Size2D();
+				FVector Vel = Pawn->GetVelocity();
+				if (Vel.IsNearlyZero())
+				{
+					if (UPrimitiveComponent* Root = Cast<UPrimitiveComponent>(Pawn->GetRootComponent()))
+					{
+						Vel = Root->GetPhysicsLinearVelocity();
+					}
+					if (Vel.IsNearlyZero() && FrameNumber > 0)
+					{
+						Vel = (Pawn->GetActorLocation() - PrevPawnLocation) / FMath::Max(DeltaTime, 0.001);
+					}
+				}
+				PrevPawnLocation = Pawn->GetActorLocation();
+				Row.PawnVelocity = Vel;
+				Row.Speed2D = Vel.Size2D();
 			}
 		}
 

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/PIE/PIEFrameSampler.h

@@ -94,5 +94,6 @@ namespace UEMCPPIE
 		TArray<FTrackedValueSpec> TrackedValues;
 		TArray<FTrackedAction> Tracked;
 		TArray<FString> PendingMarkerLabels;
+		FVector PrevPawnLocation = FVector::ZeroVector;
 	};
 }

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/PIE/PIEInputRecorder.cpp

@@ -242,6 +242,20 @@ namespace UEMCPPIE
 				ActorRows.Add(MoveTemp(AR));
 			}
 
+			// Detect late-discovered actions and rebuild CSV header.
+			const TArray<FActionSpec>& CurrentActions = Sampler.GetActions();
+			if (CurrentActions.Num() != CSVHdr.Actions.Num())
+			{
+				CSVHdr.Actions = CurrentActions;
+				CSVHdr.TrackedValues = Sampler.GetTrackedValues();
+				CSVHeader = BuildCSVHeader(CSVHdr);
+				CSVBody.Reset();
+				for (const FCSVRow& Prev : Rows)
+				{
+					AppendCSVRow(CSVBody, Prev, CSVHdr);
+				}
+			}
+
 			AppendCSVRow(CSVBody, Row, CSVHdr);
 			Rows.Add(MoveTemp(Row));
 		}

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

@@ -6,6 +6,7 @@
 #include "PIE/PIEInputRecorder.h"
 #include "PIE/PIEInputReplayer.h"
 #include "PIE/PIEObserver.h"
+#include "UI/SMCPPIEPanel.h"
 #include "Editor.h"
 #include "Editor/EditorEngine.h"
 #include "Misc/ConfigCacheIni.h"
@@ -26,6 +27,7 @@ void FUE_MCP_BridgeModule::StartupModule()
 	UEMCPPIE::FPIEInputRecorder::Get().Init();
 	UEMCPPIE::FPIEInputReplayer::Get().Init();
 	UEMCPPIE::FPIEObserver::Get().Init();
+	SMCPPIEPanel::RegisterTab();
 	// Clear any leftover injections from a previous PIE session so a fresh
 	// EndPIE-BeginPIE pair starts with no ghost holds in the queue.
 	FEditorDelegates::EndPIE.AddLambda([](bool /*bIsSimulating*/)
@@ -114,6 +116,7 @@ void FUE_MCP_BridgeModule::StartupModule()
 
 void FUE_MCP_BridgeModule::ShutdownModule()
 {
+	SMCPPIEPanel::UnregisterTab();
 	// Stop bridge server
 	FDialogHandlers::RemoveDialogHook();
 	UEMCPPIE::FPIEObserver::Get().Shutdown();

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/UI/SMCPPIEPanel.cpp

@@ -0,0 +1,489 @@
+#include "SMCPPIEPanel.h"
+#include "UE_MCP_BridgeModule.h"
+#include "PIE/PIEInputRecorder.h"
+#include "PIE/PIEInputReplayer.h"
+#include "PIE/PIEObserver.h"
+#include "PIE/MCPObservationProfile.h"
+#include "PIE/PIESequenceFormat.h"
+#include "Widgets/Layout/SScrollBox.h"
+#include "Widgets/Layout/SSeparator.h"
+#include "Widgets/Layout/SExpandableArea.h"
+#include "Widgets/Input/SButton.h"
+#include "Widgets/Text/STextBlock.h"
+#include "Framework/Docking/TabManager.h"
+#include "WorkspaceMenuStructure.h"
+#include "WorkspaceMenuStructureModule.h"
+#include "Styling/AppStyle.h"
+#include "AssetRegistry/AssetRegistryModule.h"
+#include "HAL/FileManager.h"
+#include "Misc/Paths.h"
+
+const FName SMCPPIEPanel::TabId(TEXT("MCPPIEPanel"));
+
+namespace
+{
+	FString RecorderStateStr(UEMCPPIE::ERecorderState S)
+	{
+		switch (S)
+		{
+		case UEMCPPIE::ERecorderState::Idle:           return TEXT("Idle");
+		case UEMCPPIE::ERecorderState::Armed:          return TEXT("Armed");
+		case UEMCPPIE::ERecorderState::WaitingForPawn: return TEXT("Waiting for Pawn");
+		case UEMCPPIE::ERecorderState::Recording:      return TEXT("Recording");
+		}
+		return TEXT("?");
+	}
+
+	FString ReplayerStateStr(UEMCPPIE::EReplayerState S)
+	{
+		switch (S)
+		{
+		case UEMCPPIE::EReplayerState::Idle:           return TEXT("Idle");
+		case UEMCPPIE::EReplayerState::Armed:          return TEXT("Armed");
+		case UEMCPPIE::EReplayerState::WaitingForPawn: return TEXT("Waiting for Pawn");
+		case UEMCPPIE::EReplayerState::Replaying:      return TEXT("Replaying");
+		case UEMCPPIE::EReplayerState::Completed:      return TEXT("Completed");
+		}
+		return TEXT("?");
+	}
+
+	FString ObserverStateStr(UEMCPPIE::EObserverState S)
+	{
+		switch (S)
+		{
+		case UEMCPPIE::EObserverState::Idle:           return TEXT("Idle");
+		case UEMCPPIE::EObserverState::Armed:          return TEXT("Armed");
+		case UEMCPPIE::EObserverState::WaitingForPawn: return TEXT("Waiting for Pawn");
+		case UEMCPPIE::EObserverState::Observing:      return TEXT("Observing");
+		case UEMCPPIE::EObserverState::Completed:      return TEXT("Completed");
+		}
+		return TEXT("?");
+	}
+
+	FSlateColor StateColor(bool bActive)
+	{
+		return bActive ? FSlateColor(FLinearColor::Green) : FSlateColor(FSlateColor::UseForeground());
+	}
+}
+
+void SMCPPIEPanel::RegisterTab()
+{
+	FGlobalTabmanager::Get()->RegisterNomadTabSpawner(TabId,
+		FOnSpawnTab::CreateLambda([](const FSpawnTabArgs&) -> TSharedRef<SDockTab>
+		{
+			return SNew(SDockTab)
+				.TabRole(NomadTab)
+				.Label(FText::FromString(TEXT("MCP PIE")))
+				[
+					SNew(SMCPPIEPanel)
+				];
+		}))
+		.SetDisplayName(FText::FromString(TEXT("MCP PIE")))
+		.SetTooltipText(FText::FromString(TEXT("PIE Record / Replay / Observe")))
+		.SetGroup(WorkspaceMenu::GetMenuStructure().GetToolsCategory());
+}
+
+void SMCPPIEPanel::UnregisterTab()
+{
+	FGlobalTabmanager::Get()->UnregisterNomadTabSpawner(TabId);
+}
+
+void SMCPPIEPanel::OpenTab()
+{
+	FGlobalTabmanager::Get()->TryInvokeTab(TabId);
+}
+
+void SMCPPIEPanel::Construct(const FArguments& InArgs)
+{
+	ChildSlot
+	[
+		SNew(SScrollBox)
+		+ SScrollBox::Slot().Padding(8)
+		[
+			SNew(SVerticalBox)
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 0, 0, 4)
+			[ BuildRecorderSection() ]
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+			[ SNew(SSeparator) ]
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 4, 0, 4)
+			[ BuildReplayerSection() ]
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+			[ SNew(SSeparator) ]
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 4, 0, 4)
+			[ BuildObserverSection() ]
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+			[ SNew(SSeparator) ]
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 4, 0, 4)
+			[ BuildRecordingsSection() ]
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+			[ SNew(SSeparator) ]
+
+			+ SVerticalBox::Slot().AutoHeight().Padding(0, 4, 0, 4)
+			[ BuildProfilesSection() ]
+		]
+	];
+}
+
+TSharedRef<SWidget> SMCPPIEPanel::BuildRecorderSection()
+{
+	return SNew(SVerticalBox)
+		+ SVerticalBox::Slot().AutoHeight()
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().AutoWidth().VAlign(VAlign_Center)
+			[
+				SNew(STextBlock)
+				.Font(FAppStyle::GetFontStyle("BoldFont"))
+				.Text(FText::FromString(TEXT("Recorder")))
+			]
+			+ SHorizontalBox::Slot().FillWidth(1.f)
+			+ SHorizontalBox::Slot().AutoWidth().Padding(4, 0)
+			[
+				SAssignNew(RecorderStateText, STextBlock)
+				.Text(FText::FromString(TEXT("Idle")))
+			]
+		]
+		+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().AutoWidth().Padding(0, 0, 4, 0)
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Arm")))
+				.OnClicked_Lambda([]()
+				{
+					UEMCPPIE::FRecorderArmConfig Cfg;
+					FString Err, Msg;
+					UEMCPPIE::FPIEInputRecorder::Get().Arm(Cfg, Err, Msg);
+					return FReply::Handled();
+				})
+			]
+			+ SHorizontalBox::Slot().AutoWidth().Padding(0, 0, 4, 0)
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Disarm")))
+				.OnClicked_Lambda([]()
+				{
+					FString Err;
+					UEMCPPIE::FPIEInputRecorder::Get().Disarm(Err);
+					return FReply::Handled();
+				})
+			]
+			+ SHorizontalBox::Slot().AutoWidth()
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Stop")))
+				.OnClicked_Lambda([]()
+				{
+					UEMCPPIE::FPIEInputRecorder::Get().ForceStop();
+					return FReply::Handled();
+				})
+			]
+		];
+}
+
+TSharedRef<SWidget> SMCPPIEPanel::BuildReplayerSection()
+{
+	return SNew(SVerticalBox)
+		+ SVerticalBox::Slot().AutoHeight()
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().AutoWidth().VAlign(VAlign_Center)
+			[
+				SNew(STextBlock)
+				.Font(FAppStyle::GetFontStyle("BoldFont"))
+				.Text(FText::FromString(TEXT("Replayer")))
+			]
+			+ SHorizontalBox::Slot().FillWidth(1.f)
+			+ SHorizontalBox::Slot().AutoWidth().Padding(4, 0)
+			[
+				SAssignNew(ReplayerStateText, STextBlock)
+				.Text(FText::FromString(TEXT("Idle")))
+			]
+		]
+		+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().AutoWidth().Padding(0, 0, 4, 0)
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Disarm")))
+				.OnClicked_Lambda([]()
+				{
+					FString Err;
+					UEMCPPIE::FPIEInputReplayer::Get().Disarm(Err);
+					return FReply::Handled();
+				})
+			]
+			+ SHorizontalBox::Slot().AutoWidth()
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Stop")))
+				.OnClicked_Lambda([]()
+				{
+					UEMCPPIE::FPIEInputReplayer::Get().ForceStop();
+					return FReply::Handled();
+				})
+			]
+		];
+}
+
+TSharedRef<SWidget> SMCPPIEPanel::BuildObserverSection()
+{
+	return SNew(SVerticalBox)
+		+ SVerticalBox::Slot().AutoHeight()
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().AutoWidth().VAlign(VAlign_Center)
+			[
+				SNew(STextBlock)
+				.Font(FAppStyle::GetFontStyle("BoldFont"))
+				.Text(FText::FromString(TEXT("Observer")))
+			]
+			+ SHorizontalBox::Slot().FillWidth(1.f)
+			+ SHorizontalBox::Slot().AutoWidth().Padding(4, 0)
+			[
+				SAssignNew(ObserverStateText, STextBlock)
+				.Text(FText::FromString(TEXT("Idle")))
+			]
+		]
+		+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().AutoWidth().Padding(0, 0, 4, 0)
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Disarm")))
+				.OnClicked_Lambda([]()
+				{
+					FString Err;
+					UEMCPPIE::FPIEObserver::Get().Disarm(Err);
+					return FReply::Handled();
+				})
+			]
+			+ SHorizontalBox::Slot().AutoWidth()
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Stop")))
+				.OnClicked_Lambda([]()
+				{
+					UEMCPPIE::FPIEObserver::Get().ForceStop();
+					return FReply::Handled();
+				})
+			]
+		];
+}
+
+TSharedRef<SWidget> SMCPPIEPanel::BuildRecordingsSection()
+{
+	return SNew(SVerticalBox)
+		+ SVerticalBox::Slot().AutoHeight()
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().AutoWidth().VAlign(VAlign_Center)
+			[
+				SNew(STextBlock)
+				.Font(FAppStyle::GetFontStyle("BoldFont"))
+				.Text(FText::FromString(TEXT("Recordings")))
+			]
+			+ SHorizontalBox::Slot().FillWidth(1.f)
+			+ SHorizontalBox::Slot().AutoWidth().Padding(4, 0)
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Refresh")))
+				.OnClicked_Lambda([this]()
+				{
+					RefreshRecordings();
+					return FReply::Handled();
+				})
+			]
+		]
+		+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+		[
+			SAssignNew(RecordingsListBox, SVerticalBox)
+		];
+}
+
+TSharedRef<SWidget> SMCPPIEPanel::BuildProfilesSection()
+{
+	return SNew(SVerticalBox)
+		+ SVerticalBox::Slot().AutoHeight()
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().AutoWidth().VAlign(VAlign_Center)
+			[
+				SNew(STextBlock)
+				.Font(FAppStyle::GetFontStyle("BoldFont"))
+				.Text(FText::FromString(TEXT("Observation Profiles")))
+			]
+			+ SHorizontalBox::Slot().FillWidth(1.f)
+			+ SHorizontalBox::Slot().AutoWidth().Padding(4, 0)
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Refresh")))
+				.OnClicked_Lambda([this]()
+				{
+					RefreshProfiles();
+					return FReply::Handled();
+				})
+			]
+		]
+		+ SVerticalBox::Slot().AutoHeight().Padding(0, 4)
+		[
+			SAssignNew(ProfilesListBox, SVerticalBox)
+		];
+}
+
+void SMCPPIEPanel::Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
+{
+	SCompoundWidget::Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
+
+	// Update state labels
+	{
+		const auto RS = UEMCPPIE::FPIEInputRecorder::Get().GetStatus();
+		const FString RecText = FString::Printf(TEXT("%s  %s  F:%d  %.1fs"),
+			*RecorderStateStr(RS.State), *RS.Id, RS.CurrentFrame, RS.ElapsedSeconds);
+		const bool bRecActive = RS.State == UEMCPPIE::ERecorderState::Recording;
+		RecorderStateText->SetText(FText::FromString(RecText));
+		RecorderStateText->SetColorAndOpacity(StateColor(bRecActive));
+	}
+	{
+		const auto RS = UEMCPPIE::FPIEInputReplayer::Get().GetStatus();
+		const FString RepText = FString::Printf(TEXT("%s  %s  %d/%d  %.1fs"),
+			*ReplayerStateStr(RS.State), *RS.SourceRecordingId,
+			RS.CurrentStep, RS.TotalSteps, RS.ElapsedSeconds);
+		const bool bRepActive = RS.State == UEMCPPIE::EReplayerState::Replaying;
+		ReplayerStateText->SetText(FText::FromString(RepText));
+		ReplayerStateText->SetColorAndOpacity(StateColor(bRepActive));
+	}
+	{
+		const auto OS = UEMCPPIE::FPIEObserver::Get().GetStatus();
+		const FString ObsText = FString::Printf(TEXT("%s  %s  F:%d  %.1fs"),
+			*ObserverStateStr(OS.State),
+			*FPaths::GetBaseFilename(OS.ProfilePath),
+			OS.FramesSampled, OS.ElapsedSeconds);
+		const bool bObsActive = OS.State == UEMCPPIE::EObserverState::Observing;
+		ObserverStateText->SetText(FText::FromString(ObsText));
+		ObserverStateText->SetColorAndOpacity(StateColor(bObsActive));
+	}
+
+	// Auto-refresh lists every 5 seconds
+	if (InCurrentTime - LastRecordingsRefresh > 5.0)
+	{
+		RefreshRecordings();
+		LastRecordingsRefresh = InCurrentTime;
+	}
+	if (InCurrentTime - LastProfilesRefresh > 5.0)
+	{
+		RefreshProfiles();
+		LastProfilesRefresh = InCurrentTime;
+	}
+}
+
+void SMCPPIEPanel::RefreshRecordings()
+{
+	if (!RecordingsListBox.IsValid()) return;
+	RecordingsListBox->ClearChildren();
+	CachedRecordingIds.Reset();
+
+	const FString Root = UEMCPPIE::DefaultRecordingsRoot();
+	TArray<FString> Dirs;
+	IFileManager::Get().FindFiles(Dirs, *(Root / TEXT("*")), false, true);
+	Dirs.Sort([](const FString& A, const FString& B) { return A > B; });
+	if (Dirs.Num() > 50) Dirs.SetNum(50);
+
+	for (const FString& D : Dirs)
+	{
+		CachedRecordingIds.Add(D);
+		const FString Id = D;
+
+		RecordingsListBox->AddSlot().AutoHeight().Padding(0, 2)
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().FillWidth(1.f).VAlign(VAlign_Center)
+			[
+				SNew(STextBlock).Text(FText::FromString(Id))
+			]
+			+ SHorizontalBox::Slot().AutoWidth().Padding(4, 0)
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Replay")))
+				.OnClicked_Lambda([Id]()
+				{
+					UEMCPPIE::FReplayerArmConfig Cfg;
+					Cfg.SourceRecordingId = Id;
+					FString Err, Msg;
+					UEMCPPIE::FPIEInputReplayer::Get().Arm(Cfg, Err, Msg);
+					return FReply::Handled();
+				})
+			]
+		];
+	}
+
+	if (Dirs.Num() == 0)
+	{
+		RecordingsListBox->AddSlot().AutoHeight()
+		[
+			SNew(STextBlock)
+			.Text(FText::FromString(TEXT("No recordings found")))
+			.ColorAndOpacity(FSlateColor(FLinearColor::Gray))
+		];
+	}
+}
+
+void SMCPPIEPanel::RefreshProfiles()
+{
+	if (!ProfilesListBox.IsValid()) return;
+	ProfilesListBox->ClearChildren();
+	CachedProfilePaths.Reset();
+
+	FAssetRegistryModule& ARM = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
+	TArray<FAssetData> Assets;
+	ARM.Get().GetAssetsByClass(UMCPObservationProfile::StaticClass()->GetClassPathName(), Assets, true);
+
+	for (const FAssetData& A : Assets)
+	{
+		const FString Path = A.GetObjectPathString();
+		CachedProfilePaths.Add(Path);
+
+		ProfilesListBox->AddSlot().AutoHeight().Padding(0, 2)
+		[
+			SNew(SHorizontalBox)
+			+ SHorizontalBox::Slot().FillWidth(1.f).VAlign(VAlign_Center)
+			[
+				SNew(STextBlock).Text(FText::FromString(A.AssetName.ToString()))
+			]
+			+ SHorizontalBox::Slot().AutoWidth().Padding(4, 0)
+			[
+				SNew(SButton)
+				.Text(FText::FromString(TEXT("Observe")))
+				.OnClicked_Lambda([Path]()
+				{
+					UEMCPPIE::FObserverArmConfig Cfg;
+					Cfg.ProfilePath = Path;
+					FString Err, Msg;
+					UEMCPPIE::FPIEObserver::Get().Arm(Cfg, Err, Msg);
+					return FReply::Handled();
+				})
+			]
+		];
+	}
+
+	if (Assets.Num() == 0)
+	{
+		ProfilesListBox->AddSlot().AutoHeight()
+		[
+			SNew(STextBlock)
+			.Text(FText::FromString(TEXT("No profiles found")))
+			.ColorAndOpacity(FSlateColor(FLinearColor::Gray))
+		];
+	}
+}

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/UI/SMCPPIEPanel.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Widgets/SCompoundWidget.h"
+#include "Widgets/DeclarativeSyntaxSupport.h"
+
+class SMCPPIEPanel : public SCompoundWidget
+{
+public:
+	SLATE_BEGIN_ARGS(SMCPPIEPanel) {}
+	SLATE_END_ARGS()
+
+	void Construct(const FArguments& InArgs);
+
+	static void RegisterTab();
+	static void UnregisterTab();
+	static void OpenTab();
+
+	static const FName TabId;
+
+private:
+	virtual void Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime) override;
+
+	TSharedRef<SWidget> BuildRecorderSection();
+	TSharedRef<SWidget> BuildReplayerSection();
+	TSharedRef<SWidget> BuildObserverSection();
+	TSharedRef<SWidget> BuildRecordingsSection();
+	TSharedRef<SWidget> BuildProfilesSection();
+
+	void RefreshRecordings();
+	void RefreshProfiles();
+
+	// State text blocks updated per tick
+	TSharedPtr<STextBlock> RecorderStateText;
+	TSharedPtr<STextBlock> ReplayerStateText;
+	TSharedPtr<STextBlock> ObserverStateText;
+
+	// Recordings list
+	TSharedPtr<SVerticalBox> RecordingsListBox;
+	TArray<FString> CachedRecordingIds;
+	double LastRecordingsRefresh = 0.0;
+
+	// Profiles list
+	TSharedPtr<SVerticalBox> ProfilesListBox;
+	TArray<FString> CachedProfilePaths;
+	double LastProfilesRefresh = 0.0;
+};