diff --git a/Source/Flow/Private/Asset/FlowDeferredTransitionScope.cpp b/Source/Flow/Private/Asset/FlowDeferredTransitionScope.cpp
new file mode 100644
index 00000000..c5ac2b4d
--- /dev/null
+++ b/Source/Flow/Private/Asset/FlowDeferredTransitionScope.cpp
@@ -0,0 +1,32 @@
+// Copyright https://github.com/MothCocoon/FlowGraph/graphs/contributors
+
+#include "Asset/FlowDeferredTransitionScope.h"
+#include "FlowAsset.h"
+#include "Interfaces/FlowExecutionGate.h"
+
+void FFlowDeferredTransitionScope::EnqueueDeferredTrigger(const FFlowDeferredTriggerInput& Entry)
+{
+	check(bIsOpen);
+
+	DeferredTriggers.Add(Entry);
+}
+
+bool FFlowDeferredTransitionScope::TryFlushDeferredTriggers(UFlowAsset& OwningFlowAsset)
+{
+	// Ensure the scope is closed before beginning flushing
+	CloseScope();
+
+	// Remove and trigger each deferred trigger input
+	while (!DeferredTriggers.IsEmpty() && !FFlowExecutionGate::IsHalted())
+	{
+		const FFlowDeferredTriggerInput Entry = DeferredTriggers[0];
+		DeferredTriggers.RemoveAt(0, 1, EAllowShrinking::No);
+
+		OwningFlowAsset.TriggerInput(Entry.NodeGuid, Entry.PinName, Entry.FromPin);
+	}
+
+	check(DeferredTriggers.IsEmpty() || FFlowExecutionGate::IsHalted());
+
+	// Return true if everything flushed without being interrupted by an ExecutionGate
+	return DeferredTriggers.IsEmpty();
+}
\ No newline at end of file
diff --git a/Source/Flow/Private/FlowAsset.cpp b/Source/Flow/Private/FlowAsset.cpp
index a6d32fb4..f0899a72 100644
--- a/Source/Flow/Private/FlowAsset.cpp
+++ b/Source/Flow/Private/FlowAsset.cpp
@@ -8,6 +8,7 @@
 #include "AddOns/FlowNodeAddOn.h"
 #include "Asset/FlowAssetParams.h"
 #include "Asset/FlowAssetParamsUtils.h"
+#include "Interfaces/FlowExecutionGate.h"
 #include "Nodes/FlowNodeBase.h"
 #include "Nodes/Graph/FlowNode_CustomInput.h"
 #include "Nodes/Graph/FlowNode_CustomOutput.h"
@@ -970,6 +971,9 @@ void UFlowAsset::InitializeInstance(const TWeakObjectPtr<UObject> InOwner, UFlow
 
 void UFlowAsset::DeinitializeInstance()
 {
+	// These should have been flushed in FinishFlow()
+	check(DeferredTransitionScopes.IsEmpty());
+
 	if (IsInstanceInitialized())
 	{
 		for (const TPair<FGuid, UFlowNode*>& Node : ObjectPtrDecay(Nodes))
@@ -1012,6 +1016,11 @@ void UFlowAsset::PreStartFlow()
 
 void UFlowAsset::StartFlow(IFlowDataPinValueSupplierInterface* DataPinValueSupplier)
 {
+	if (FFlowExecutionGate::IsHalted())
+	{
+		return;
+	}
+
 	PreStartFlow();
 
 	if (UFlowNode* ConnectedEntryNode = GetDefaultEntryNode())
@@ -1031,6 +1040,8 @@ void UFlowAsset::FinishFlow(const EFlowFinishPolicy InFinishPolicy, const bool b
 {
 	FinishPolicy = InFinishPolicy;
 
+	CancelAndWarnForUnflushedDeferredTriggers();
+
 	// end execution of this asset and all of its nodes
 	for (UFlowNode* Node : ActiveNodes)
 	{
@@ -1052,6 +1063,62 @@ void UFlowAsset::FinishFlow(const EFlowFinishPolicy InFinishPolicy, const bool b
 	}
 }
 
+void UFlowAsset::CancelAndWarnForUnflushedDeferredTriggers()
+{
+	// Aggressively drop any pending deferred triggers — graph is done
+	// In normal execution these should have been flushed via PopDeferredTransitionScope() in TriggerInputDirect
+	// In the debugger they should have been flushed by ResumePIE
+	// Remaining scopes here usually mean:
+	//   - early/abnormal termination (e.g. FinishFlow called from unexpected place)
+	//   - exception/early return before Pop
+	//   - forced deinitialization during active execution (e.g. PIE stop, subsystem cleanup)
+	if (!DeferredTransitionScopes.IsEmpty())
+	{
+		int32 TotalDroppedTriggers = 0;
+
+		for (const TSharedPtr<FFlowDeferredTransitionScope>& ScopePtr : DeferredTransitionScopes)
+		{
+			if (!ScopePtr.IsValid())
+			{
+				continue;
+			}
+
+			const TArray<FFlowDeferredTriggerInput>& Triggers = ScopePtr->GetDeferredTriggers();
+
+			if (TotalDroppedTriggers == 0 && !Triggers.IsEmpty())
+			{
+				UE_LOG(LogFlow, Warning, TEXT("FlowAsset '%s' is finishing with %d lingering deferred transition scope(s) — dropping them. "
+					"This is usually unexpected and may indicate a bug or abnormal termination."),
+					*GetName(), DeferredTransitionScopes.Num());
+			}
+
+			TotalDroppedTriggers += Triggers.Num();
+
+			for (const FFlowDeferredTriggerInput& Trigger : Triggers)
+			{
+				const UFlowNode* ToNode = GetNode(Trigger.NodeGuid);
+				const UFlowNode* FromNode = Trigger.FromPin.NodeGuid.IsValid() ? GetNode(Trigger.FromPin.NodeGuid) : nullptr;
+
+				UE_LOG(LogFlow, Error,
+					TEXT("  → Dropped deferred trigger:\n")
+					TEXT("      To Node: %s (%s)\n")
+					TEXT("      To Pin:  %s\n")
+					TEXT("      From Node: %s (%s)\n")
+					TEXT("      From Pin:  %s"),
+					*ToNode->GetName(),
+					*Trigger.NodeGuid.ToString(),
+					*Trigger.PinName.ToString(),
+					*FromNode->GetName(),
+					*Trigger.FromPin.NodeGuid.ToString(),
+					*Trigger.FromPin.PinName.ToString()
+				);
+			}
+		}
+
+		ClearAllDeferredTriggerScopes();
+	}
+}
+
 bool UFlowAsset::HasStartedFlow() const
 {
 	return RecordedNodes.Num() > 0;
@@ -1126,6 +1193,34 @@ void UFlowAsset::TriggerCustomOutput(const FName& EventName)
 }
 
 void UFlowAsset::TriggerInput(const FGuid& NodeGuid, const FName& PinName, const FConnectedPin& FromPin)
+{
+	if (ShouldDeferTriggersForDebugger())
+	{
+		EnqueueDeferredTrigger(NodeGuid, PinName, FromPin);
+	}
+	else if (ShouldUseStandardDeferTriggers())
+	{
+		// Defer only if we have an open top scope
+		if (!DeferredTransitionScopes.IsEmpty() && DeferredTransitionScopes.Top()->IsOpen())
+		{
+			EnqueueDeferredTrigger(NodeGuid, PinName, FromPin);
+		}
+		else
+		{
+			const TSharedPtr<FFlowDeferredTransitionScope> CurScope = PushDeferredTransitionScope();
+
+			TriggerInputDirect(NodeGuid, PinName, FromPin);
+
+			PopDeferredTransitionScope(CurScope);
+		}
+	}
+	else
+	{
+		TriggerInputDirect(NodeGuid, PinName, FromPin);
+	}
+}
+
+void UFlowAsset::TriggerInputDirect(const FGuid& NodeGuid, const FName& PinName, const FConnectedPin& FromPin)
 {
 	if (UFlowNode* Node = Nodes.FindRef(NodeGuid))
 	{
@@ -1139,6 +1234,86 @@ void UFlowAsset::TriggerInput(const FGuid& NodeGuid, const FName& PinName, const
 	}
 }
 
+bool UFlowAsset::ShouldDeferTriggersForDebugger() const
+{
+	// Halt always takes precedence for debugger correctness
+	return FFlowExecutionGate::IsHalted();
+}
+
+bool UFlowAsset::ShouldUseStandardDeferTriggers() const
+{
+	return UFlowSettings::Get()->bDeferTriggeredOutputsWhileTriggering;
+}
+
+TSharedPtr<FFlowDeferredTransitionScope> UFlowAsset::PushDeferredTransitionScope()
+{
+	// Close the former top scope (if any)
+	if (!DeferredTransitionScopes.IsEmpty())
+	{
+		const TSharedPtr<FFlowDeferredTransitionScope>& FormerTop = DeferredTransitionScopes.Top();
+		FormerTop->CloseScope();
+	}
+
+	// Push a fresh open scope
+	return DeferredTransitionScopes.Add_GetRef(MakeShared<FFlowDeferredTransitionScope>());
+}
+
+bool UFlowAsset::TryFlushAndRemoveDeferredTransitionScope(const TSharedPtr<FFlowDeferredTransitionScope>& ScopeToFlush)
+{
+	if (ScopeToFlush->TryFlushDeferredTriggers(*this))
+	{
+		// Remove the exact instance we were holding (handles nested push/pop cases)
+		DeferredTransitionScopes.RemoveSingle(ScopeToFlush);
+		return true;
+	}
+	else
+	{
+		// Flush was interrupted — should only happen due to execution gate halt
+		check(FFlowExecutionGate::IsHalted());
+		return false;
+	}
+}
+
+void UFlowAsset::EnqueueDeferredTrigger(const FGuid& NodeGuid, const FName& PinName, const FConnectedPin& FromPin)
+{
+	if (DeferredTransitionScopes.IsEmpty() || !DeferredTransitionScopes.Top()->IsOpen())
+	{
+		// This should only occur when halted at an execution gate
+		check(FFlowExecutionGate::IsHalted());
+		PushDeferredTransitionScope();
+	}
+
+	// Always enqueue to the current innermost (top) scope
+	DeferredTransitionScopes.Top()->EnqueueDeferredTrigger(FFlowDeferredTriggerInput{ NodeGuid, PinName, FromPin });
+}
+
+bool UFlowAsset::TryFlushAllDeferredTriggerScopes()
+{
+	while (const TSharedPtr<FFlowDeferredTransitionScope> TopScope = GetTopDeferredTransitionScope())
+	{
+		if (!TryFlushAndRemoveDeferredTransitionScope(TopScope))
+		{
+			break;
+		}
+
+		// Keep flushing until stack is empty or we hit an ExecutionGate halt
+	}
+
+	check(DeferredTransitionScopes.IsEmpty() || FFlowExecutionGate::IsHalted());
+
+	return DeferredTransitionScopes.IsEmpty();
+}
+
+void UFlowAsset::ClearAllDeferredTriggerScopes()
+{
+	DeferredTransitionScopes.Reset();
+}
+
+TSharedPtr<FFlowDeferredTransitionScope> UFlowAsset::GetTopDeferredTransitionScope() const
+{
+	return !DeferredTransitionScopes.IsEmpty() ? DeferredTransitionScopes.Top() : nullptr;
+}
+
 void UFlowAsset::FinishNode(UFlowNode* Node)
 {
 	if (ActiveNodes.Contains(Node))
diff --git a/Source/Flow/Private/FlowSettings.cpp b/Source/Flow/Private/FlowSettings.cpp
index e098071f..e6f835f4 100644
--- a/Source/Flow/Private/FlowSettings.cpp
+++ b/Source/Flow/Private/FlowSettings.cpp
@@ -11,6 +11,7 @@ UFlowSettings::UFlowSettings(const FObjectInitializer& ObjectInitializer)
 	, bWarnAboutMissingIdentityTags(true)
 	, bLogOnSignalDisabled(true)
 	, bLogOnSignalPassthrough(true)
+	, bDeferTriggeredOutputsWhileTriggering(true)
 	, bUseAdaptiveNodeTitles(false)
 	, DefaultExpectedOwnerClass(UFlowComponent::StaticClass())
 {
diff --git a/Source/Flow/Private/FlowSubsystem.cpp b/Source/Flow/Private/FlowSubsystem.cpp
index 70a88eaf..9a3cf1ec 100644
--- a/Source/Flow/Private/FlowSubsystem.cpp
+++ b/Source/Flow/Private/FlowSubsystem.cpp
@@ -7,6 +7,7 @@
 #include "FlowLogChannels.h"
 #include "FlowSave.h"
 #include "FlowSettings.h"
+#include "Interfaces/FlowExecutionGate.h"
 #include "Nodes/Graph/FlowNode_SubGraph.h"
 
 #include "Engine/GameInstance.h"
@@ -159,6 +160,63 @@ void UFlowSubsystem::FinishAllRootFlows(UObject* Owner, const EFlowFinishPolicy
 	}
 }
 
+bool UFlowSubsystem::TryFlushAllDeferredTriggerScopes()
+{
+	// Flush deferred triggers on all active runtime instances.
+	// Flush order follows InstancedTemplates iteration + per-template ActiveInstances.
+	// This provides reasonable per-asset FIFO but is not a strict global FIFO across assets.
+	// A more precise global queue could be implemented later if cross-asset ordering becomes critical.
+	const TArray<UFlowAsset*> CapturedInstancedTemplates = InstancedTemplates;
+	for (UFlowAsset* Template : CapturedInstancedTemplates)
+	{
+		if (!IsValid(Template))
+		{
+			continue;
+		}
+
+		for (UFlowAsset* Instance : Template->GetActiveInstances())
+		{
+			if (FFlowExecutionGate::IsHalted())
+			{
+				break;
+			}
+
+			if (IsValid(Instance))
+			{
+				const bool bFlushed = Instance->TryFlushAllDeferredTriggerScopes();
+
+				// The only case where we allow a flush to stop before completing
+				// is if we hit an execution gate halt
+				check(bFlushed || FFlowExecutionGate::IsHalted());
+			}
+		}
+	}
+
+	// The only case where we allow a flush to stop before completing
+	// is if we hit an execution gate halt
+	const bool bCompletedFlushAll = !FFlowExecutionGate::IsHalted();
+	return bCompletedFlushAll;
+}
+
+void UFlowSubsystem::ClearAllDeferredTriggerScopes()
+{
+	for (UFlowAsset* Template : InstancedTemplates)
+	{
+		if (!IsValid(Template))
+		{
+			continue;
+		}
+
+		for (UFlowAsset* Instance : Template->GetActiveInstances())
+		{
+			if (IsValid(Instance))
+			{
+				Instance->ClearAllDeferredTriggerScopes();
+			}
+		}
+	}
+}
+
 UFlowAsset* UFlowSubsystem::CreateSubFlow(UFlowNode_SubGraph* SubGraphNode, const FString& SavedInstanceName, const bool bPreloading /* = false */)
 {
 	UFlowAsset* NewInstance = nullptr;
diff --git a/Source/Flow/Private/Interfaces/FlowExecutionGate.cpp b/Source/Flow/Private/Interfaces/FlowExecutionGate.cpp
new file mode 100644
index 00000000..e09b7d02
--- /dev/null
+++ b/Source/Flow/Private/Interfaces/FlowExecutionGate.cpp
@@ -0,0 +1,23 @@
+// Copyright https://github.com/MothCocoon/FlowGraph/graphs/contributors
+
+#include "Interfaces/FlowExecutionGate.h"
+
+#include "FlowAsset.h"
+#include "Nodes/FlowPin.h"
+
+IFlowExecutionGate* FFlowExecutionGate::Gate = nullptr;
+
+void FFlowExecutionGate::SetGate(IFlowExecutionGate* InGate)
+{
+	Gate = InGate;
+}
+
+IFlowExecutionGate* FFlowExecutionGate::GetGate()
+{
+	return Gate;
+}
+
+bool FFlowExecutionGate::IsHalted()
+{
+	return (Gate != nullptr) && Gate->IsFlowExecutionHalted();
+}
\ No newline at end of file
diff --git a/Source/Flow/Private/Nodes/FlowPin.cpp b/Source/Flow/Private/Nodes/FlowPin.cpp
index 84a3351a..8c2a34cd 100644
--- a/Source/Flow/Private/Nodes/FlowPin.cpp
+++ b/Source/Flow/Private/Nodes/FlowPin.cpp
@@ -18,7 +18,6 @@
 // Pin Record
 
 #if !UE_BUILD_SHIPPING
-FString FPinRecord::NoActivations = TEXT("No activations");
 FString FPinRecord::PinActivations = TEXT("Pin activations");
 FString FPinRecord::ForcedActivation = TEXT(" (forced activation)");
 FString FPinRecord::PassThroughActivation = TEXT(" (pass-through activation)");
diff --git a/Source/Flow/Private/Types/FlowDataPinValue.cpp b/Source/Flow/Private/Types/FlowDataPinValue.cpp
index b10c3e20..34de3e9f 100644
--- a/Source/Flow/Private/Types/FlowDataPinValue.cpp
+++ b/Source/Flow/Private/Types/FlowDataPinValue.cpp
@@ -8,7 +8,7 @@
 
 #include UE_INLINE_GENERATED_CPP_BY_NAME(FlowDataPinValue)
 
-const FString FFlowDataPinValue::StringArraySeparator = TEXT(",");
+const FString FFlowDataPinValue::StringArraySeparator = TEXT(", ");
 
 const FFlowPinType* FFlowDataPinValue::LookupPinType() const
 {
diff --git a/Source/Flow/Private/Types/FlowDataPinValuesStandard.cpp b/Source/Flow/Private/Types/FlowDataPinValuesStandard.cpp
index 5e1e7627..a31bd141 100644
--- a/Source/Flow/Private/Types/FlowDataPinValuesStandard.cpp
+++ b/Source/Flow/Private/Types/FlowDataPinValuesStandard.cpp
@@ -495,6 +495,44 @@ FFlowDataPinValue_InstancedStruct::FFlowDataPinValue_InstancedStruct(const TArra
 #endif
 }
 
+bool FFlowDataPinValue_InstancedStruct::TryConvertValuesToString(FString& OutString) const
+{
+	const FInstancedStruct DefaultValue;
+
+	OutString = FlowArray::FormatArrayString<FInstancedStruct>(
+		Values,
+		[&DefaultValue](const FInstancedStruct& InstancedStruct)
+		{
+			FString ExportedString;
+
+			constexpr UObject* ParentObject = nullptr;
+			constexpr UObject* ExportRootScope = nullptr;
+
+			const bool bExported = InstancedStruct.ExportTextItem(
+				ExportedString,
+				DefaultValue,
+				ParentObject,
+				PPF_None,
+				ExportRootScope);
+
+			if (!bExported)
+			{
+				// Fallback: just show the contained struct type name (or None)
+				if (const UScriptStruct* ScriptStruct = InstancedStruct.GetScriptStruct())
+				{
+					return ScriptStruct->GetName();
+				}
+
+				return FString();
+			}
+
+			return ExportedString;
+		},
+		StringArraySeparator);
+
+	return true;
+}
+
 //======================================================================
 // Object
 //======================================================================
diff --git a/Source/Flow/Public/AddOns/FlowNodeAddOn.h b/Source/Flow/Public/AddOns/FlowNodeAddOn.h
index 1fe43bd6..abe446cf 100644
--- a/Source/Flow/Public/AddOns/FlowNodeAddOn.h
+++ b/Source/Flow/Public/AddOns/FlowNodeAddOn.h
@@ -38,7 +38,9 @@ class UFlowNodeAddOn : public UFlowNodeBase
 #endif
 
 public:
-  // AddOns may opt in to be eligible for a given parent
+	// UFlowNodeBase
+
+	// AddOns may opt in to be eligible for a given parent
 	// - ParentTemplate - the template of the FlowNode or FlowNodeAddOn that is being considered as a potential parent
 	// - AdditionalAddOnsToAssumeAreChildren - other AddOns to assume that are already child AddOns for the purposes of this test.
 	//   This list will be populated with the 'other' AddOns in a multi-paste operation in the editor,
diff --git a/Source/Flow/Public/Asset/FlowDeferredTransitionScope.h b/Source/Flow/Public/Asset/FlowDeferredTransitionScope.h
new file mode 100644
index 00000000..66a3783b
--- /dev/null
+++ b/Source/Flow/Public/Asset/FlowDeferredTransitionScope.h
@@ -0,0 +1,36 @@
+// Copyright https://github.com/MothCocoon/FlowGraph/graphs/contributors
+
+#pragma once
+
+#include "Misc/Guid.h"
+
+#include "Nodes/FlowPin.h"
+
+class UFlowAsset;
+
+struct FFlowDeferredTriggerInput
+{
+	FGuid NodeGuid;
+	FName PinName;
+	FConnectedPin FromPin;
+};
+
+struct FLOW_API FFlowDeferredTransitionScope
+{
+public:
+	void EnqueueDeferredTrigger(const FFlowDeferredTriggerInput& Entry);
+	bool TryFlushDeferredTriggers(UFlowAsset& OwningFlowAsset);
+
+	void CloseScope() { bIsOpen = false; }
+	bool IsOpen() const { return bIsOpen; }
+
+	const TArray<FFlowDeferredTriggerInput>& GetDeferredTriggers() const { return DeferredTriggers; }
+
+protected:
+
+	// Deferred triggers for this scope
+	TArray<FFlowDeferredTriggerInput> DeferredTriggers;
+
+	// Is currently accepting new deferred triggers
+	bool bIsOpen = true;
+};
diff --git a/Source/Flow/Public/FlowAsset.h b/Source/Flow/Public/FlowAsset.h
index ee470558..ec5d2098 100644
--- a/Source/Flow/Public/FlowAsset.h
+++ b/Source/Flow/Public/FlowAsset.h
@@ -5,13 +5,15 @@
 #include "FlowSave.h"
 #include "FlowTypes.h"
 #include "Asset/FlowAssetParamsTypes.h"
+#include "Asset/FlowDeferredTransitionScope.h"
 #include "Nodes/FlowNode.h"
 
 #if WITH_EDITOR
 #include "FlowMessageLog.h"
 #endif
-
+#include "Templates/SharedPointer.h"
 #include "UObject/ObjectKey.h"
+
 #include "FlowAsset.generated.h"
 
 class UFlowNode_CustomOutput;
@@ -26,7 +28,7 @@ class UFlowAssetParams;
 
 #if !UE_BUILD_SHIPPING
 DECLARE_DELEGATE(FFlowGraphEvent);
-DECLARE_DELEGATE_TwoParams(FFlowSignalEvent, const UFlowNode* /*Node*/, const FName& /*PinName*/);
+DECLARE_DELEGATE_TwoParams(FFlowSignalEvent, UFlowNode* /*FlowNode*/, const FName& /*PinName*/);
 #endif
 
 /**
@@ -46,6 +48,7 @@ class FLOW_API UFlowAsset : public UObject
 	friend class FFlowAssetDetails;
 	friend class FFlowNode_SubGraphDetails;
 	friend class UFlowGraphSchema;
+	friend struct FFlowDeferredTransitionScope;
 
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Flow Asset")
 	FGuid AssetGuid;
@@ -358,6 +361,10 @@ class FLOW_API UFlowAsset : public UObject
 	// Get Flow Asset instance created by the given SubGraph node
 	TWeakObjectPtr<UFlowAsset> GetFlowInstance(UFlowNode_SubGraph* SubGraphNode) const;
 
+	// Public trigger input signature for the FFlowExecutionGate mechanism in the Flow Debugger
+	FORCEINLINE void TriggerDeferredInputFromDebugger(const FGuid& NodeGuid, const FName& PinName, const FConnectedPin& FromPin)
+		{ TriggerInput(NodeGuid, PinName, FromPin); }
+
 protected:
 	void TriggerCustomInput_FromSubGraph(UFlowNode_SubGraph* Node, const FName& EventName) const;
 	void TriggerCustomOutput(const FName& EventName);
@@ -392,6 +399,44 @@ class FLOW_API UFlowAsset : public UObject
 	UFUNCTION(BlueprintPure, Category = "Flow")
 	const TArray<UFlowNode*>& GetRecordedNodes() const { return RecordedNodes; }
 
+//////////////////////////////////////////////////////////////////////////
+// Deferred trigger support
+
+public:
+	// Try to flush (and clear) all Deferred Trigger scopes
+	// (can fail to flush all if a FFlowExecutionGate causes a new halt)
+	bool TryFlushAllDeferredTriggerScopes();
+
+	// Clear (do not trigger) any remaining deferred transitions
+	// (for shutdown cases)
+	void ClearAllDeferredTriggerScopes();
+
+protected:
+	/** Stack of active deferred transition scopes (innermost = top).
+	 *  Stored as TSharedPtr so callers can safely cache a reference to a specific scope
+	 *  without it being invalidated by array reallocations/resizes during nested triggers. */
+	TArray<TSharedPtr<FFlowDeferredTransitionScope>> DeferredTransitionScopes;
+
+	bool ShouldDeferTriggersForDebugger() const;
+
+	// Allow subclasses to disable the standard defer trigger mechanism
+	virtual bool ShouldUseStandardDeferTriggers() const;
+
+	void EnqueueDeferredTrigger(const FGuid& NodeGuid, const FName& PinName, const FConnectedPin& FromPin);
+	bool TryFlushAndRemoveDeferredTransitionScope(const TSharedPtr<FFlowDeferredTransitionScope>& Scope);
+
+	TSharedPtr<FFlowDeferredTransitionScope> PushDeferredTransitionScope();
+	void PopDeferredTransitionScope(const TSharedPtr<FFlowDeferredTransitionScope>& Scope) { TryFlushAndRemoveDeferredTransitionScope(Scope); }
+
+	void CancelAndWarnForUnflushedDeferredTriggers();
+
+	/** Returns a shared pointer to the current top (innermost) deferred transition scope,
+	 *  or nullptr if there is no active scope. Safe to cache and use later. */
+	TSharedPtr<FFlowDeferredTransitionScope> GetTopDeferredTransitionScope() const;
+
+	// Trigger the node directly (no deferral, no new scope)
+	void TriggerInputDirect(const FGuid& NodeGuid, const FName& PinName, const FConnectedPin& FromPin);
+
 //////////////////////////////////////////////////////////////////////////
 // Expected Owner Class support (for use with CallOwnerFunction nodes)
 
diff --git a/Source/Flow/Public/FlowSettings.h b/Source/Flow/Public/FlowSettings.h
index 1a8468bb..fc9cd9b0 100644
--- a/Source/Flow/Public/FlowSettings.h
+++ b/Source/Flow/Public/FlowSettings.h
@@ -39,6 +39,12 @@ class FLOW_API UFlowSettings : public UDeveloperSettings
 	UPROPERTY(Config, EditAnywhere, Category = "Flow")
 	bool bLogOnSignalPassthrough;
 
+	// If enabled, defer the Triggered Outputs for a FlowAsset while it is currently processing a TriggeredInput.
+	// This is the new default in Flow, but the old behavior is provided (via false, here)
+	// for backward compatability during the transition.
+	UPROPERTY(Config, EditAnywhere, Category = "Flow")
+	bool bDeferTriggeredOutputsWhileTriggering;
+
 	// Adjust the Titles for FlowNodes to be more expressive than default
 	// by incorporating data that would otherwise go in the Description
 	UPROPERTY(EditAnywhere, config, Category = "Nodes")
diff --git a/Source/Flow/Public/FlowSubsystem.h b/Source/Flow/Public/FlowSubsystem.h
index 49274221..201e4e85 100644
--- a/Source/Flow/Public/FlowSubsystem.h
+++ b/Source/Flow/Public/FlowSubsystem.h
@@ -59,6 +59,15 @@ class FLOW_API UFlowSubsystem : public UGameInstanceSubsystem
 	static FNativeFlowAssetEvent OnInstancedTemplateRemoved;
 #endif
 
+public:
+	// Try to flush (and clear) all Deferred Trigger scopes
+	// (can fail to flush all if a FFlowExecutionGate causes a new halt)
+	bool TryFlushAllDeferredTriggerScopes();
+
+	// Clear (do not trigger) any remaining deferred transitions
+	// (for shutdown cases)
+	void ClearAllDeferredTriggerScopes();
+
 protected:
 	UPROPERTY()
 	TObjectPtr<UFlowSaveGame> LoadedSaveGame;
diff --git a/Source/Flow/Public/Interfaces/FlowExecutionGate.h b/Source/Flow/Public/Interfaces/FlowExecutionGate.h
new file mode 100644
index 00000000..8859dc26
--- /dev/null
+++ b/Source/Flow/Public/Interfaces/FlowExecutionGate.h
@@ -0,0 +1,36 @@
+// Copyright https://github.com/MothCocoon/FlowGraph/graphs/contributors
+
+#pragma once
+
+#include "CoreMinimal.h"
+
+class UFlowAsset;
+
+/**
+ * Implemented by a debugger/runtime system (in another module) that can halt Flow execution.
+ * Flow runtime queries this through FFlowExecutionGate without depending on the debugger module.
+ */
+class FLOW_API IFlowExecutionGate
+{
+public:
+	virtual ~IFlowExecutionGate() = default;
+
+	/** Return true when Flow execution should be halted globally. */
+	virtual bool IsFlowExecutionHalted() const = 0;
+};
+
+/**
+ * Global registry + minimal deferred-execution queue for Flow runtime.
+ */
+class FLOW_API FFlowExecutionGate
+{
+public:
+	static void SetGate(IFlowExecutionGate* InGate);
+	static IFlowExecutionGate* GetGate();
+
+	/** True if a gate exists and it currently wants Flow execution halted. */
+	static bool IsHalted();
+
+private:
+	static IFlowExecutionGate* Gate;
+};
\ No newline at end of file
diff --git a/Source/Flow/Public/Nodes/Developer/FlowNode_Log.h b/Source/Flow/Public/Nodes/Developer/FlowNode_Log.h
index 0fdf3fa7..3c782560 100644
--- a/Source/Flow/Public/Nodes/Developer/FlowNode_Log.h
+++ b/Source/Flow/Public/Nodes/Developer/FlowNode_Log.h
@@ -57,4 +57,7 @@ class FLOW_API UFlowNode_Log : public UFlowNode_DefineProperties
 
 	virtual void UpdateNodeConfigText_Implementation() override;
 #endif
+
+public:
+	EFlowLogVerbosity GetVerbosity() const { return Verbosity; }
 };
diff --git a/Source/Flow/Public/Nodes/FlowPin.h b/Source/Flow/Public/Nodes/FlowPin.h
index 465a2cf1..9aa88d48 100644
--- a/Source/Flow/Public/Nodes/FlowPin.h
+++ b/Source/Flow/Public/Nodes/FlowPin.h
@@ -388,7 +388,6 @@ struct FLOW_API FPinRecord
 	FString HumanReadableTime;
 	EFlowPinActivationType ActivationType;
 
-	static FString NoActivations;
 	static FString PinActivations;
 	static FString ForcedActivation;
 	static FString PassThroughActivation;
diff --git a/Source/Flow/Public/Types/FlowDataPinValuesStandard.h b/Source/Flow/Public/Types/FlowDataPinValuesStandard.h
index 245921e5..ff731e65 100644
--- a/Source/Flow/Public/Types/FlowDataPinValuesStandard.h
+++ b/Source/Flow/Public/Types/FlowDataPinValuesStandard.h
@@ -35,8 +35,8 @@ struct FFlowDataPinValue_Bool : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Bool(ValueType InValue);
 	FLOW_API FFlowDataPinValue_Bool(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -58,8 +58,8 @@ struct FFlowDataPinValue_Int : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Int(ValueType InValue);
 	FLOW_API FFlowDataPinValue_Int(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -81,8 +81,8 @@ struct FFlowDataPinValue_Int64 : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Int64(ValueType InValue);
 	FLOW_API FFlowDataPinValue_Int64(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -104,8 +104,8 @@ struct FFlowDataPinValue_Float : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Float(ValueType InValue);
 	FLOW_API FFlowDataPinValue_Float(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -127,8 +127,8 @@ struct FFlowDataPinValue_Double : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Double(ValueType InValue);
 	FLOW_API FFlowDataPinValue_Double(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -150,8 +150,8 @@ struct FFlowDataPinValue_Name : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Name(const ValueType& InValue);
 	FLOW_API FFlowDataPinValue_Name(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -173,8 +173,8 @@ struct FFlowDataPinValue_String : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_String(const ValueType& InValue);
 	FLOW_API FFlowDataPinValue_String(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -196,8 +196,8 @@ struct FFlowDataPinValue_Text : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Text(const ValueType& InValue);
 	FLOW_API FFlowDataPinValue_Text(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -235,9 +235,9 @@ struct FFlowDataPinValue_Enum : public FFlowDataPinValue
 	FLOW_API void OnEnumNameChanged();
 #endif
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
 	virtual UField* GetFieldType() const override;
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 
 	// Helper templates
 	template <typename TUnrealNativeEnumType>
@@ -317,8 +317,8 @@ struct FFlowDataPinValue_Vector : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Vector(const ValueType& InValue);
 	FLOW_API FFlowDataPinValue_Vector(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -340,8 +340,8 @@ struct FFlowDataPinValue_Rotator : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Rotator(const ValueType& InValue);
 	FLOW_API FFlowDataPinValue_Rotator(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -363,8 +363,8 @@ struct FFlowDataPinValue_Transform : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Transform(const ValueType& InValue);
 	FLOW_API FFlowDataPinValue_Transform(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -386,8 +386,8 @@ struct FFlowDataPinValue_GameplayTag : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_GameplayTag(const ValueType& InValue);
 	FLOW_API FFlowDataPinValue_GameplayTag(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -411,8 +411,8 @@ struct FFlowDataPinValue_GameplayTagContainer : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_GameplayTagContainer(const TArray<FGameplayTag>& InValues);
 	FLOW_API FFlowDataPinValue_GameplayTagContainer(const TArray<FGameplayTagContainer>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -434,7 +434,8 @@ struct FFlowDataPinValue_InstancedStruct : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_InstancedStruct(const ValueType& InValue);
 	FLOW_API FFlowDataPinValue_InstancedStruct(const TArray<ValueType>& InValues);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -464,8 +465,8 @@ struct FFlowDataPinValue_Object : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Object(AActor* InActor, UClass* InClassFilter = nullptr /* nullptr here defaults to AActor::StaticClass() */ );
 	FLOW_API FFlowDataPinValue_Object(const TArray<AActor*>& InActors, UClass* InClassFilter = nullptr /* nullptr here defaults to AActor::StaticClass() */);
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
 
 //======================================================================
@@ -494,6 +495,6 @@ struct FFlowDataPinValue_Class : public FFlowDataPinValue
 	FLOW_API FFlowDataPinValue_Class(const UClass* InClass, UClass* InClassFilter = UObject::StaticClass());
 	FLOW_API FFlowDataPinValue_Class(const TArray<UClass*>& InClasses, UClass* InClassFilter = UObject::StaticClass());
 
-	virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
-	virtual bool TryConvertValuesToString(FString& OutString) const override;
+	FLOW_API virtual const FFlowPinTypeName& GetPinTypeName() const override { return PinType::GetPinTypeNameStatic(); }
+	FLOW_API virtual bool TryConvertValuesToString(FString& OutString) const override;
 };
\ No newline at end of file
diff --git a/Source/FlowDebugger/Private/Debugger/FlowDebuggerSubsystem.cpp b/Source/FlowDebugger/Private/Debugger/FlowDebuggerSubsystem.cpp
index 6711c5c8..4a731fe1 100644
--- a/Source/FlowDebugger/Private/Debugger/FlowDebuggerSubsystem.cpp
+++ b/Source/FlowDebugger/Private/Debugger/FlowDebuggerSubsystem.cpp
@@ -16,12 +16,32 @@
 #include UE_INLINE_GENERATED_CPP_BY_NAME(FlowDebuggerSubsystem)
 
 UFlowDebuggerSubsystem::UFlowDebuggerSubsystem()
-	: bPausedAtFlowBreakpoint(false)
 {
 	UFlowSubsystem::OnInstancedTemplateAdded.BindUObject(this, &ThisClass::OnInstancedTemplateAdded);
 	UFlowSubsystem::OnInstancedTemplateRemoved.BindUObject(this, &ThisClass::OnInstancedTemplateRemoved);
 }
 
+void UFlowDebuggerSubsystem::Initialize(FSubsystemCollectionBase& Collection)
+{
+	Super::Initialize(Collection);
+
+	FFlowExecutionGate::SetGate(this);
+
+	SetFlowDebuggerState(EFlowDebuggerState::InitialRunning, nullptr);
+}
+
+void UFlowDebuggerSubsystem::Deinitialize()
+{
+	if (FFlowExecutionGate::GetGate() == this)
+	{
+		FFlowExecutionGate::SetGate(nullptr);
+	}
+
+	SetFlowDebuggerState(EFlowDebuggerState::Invalid, nullptr);
+
+	Super::Deinitialize();
+}
+
 bool UFlowDebuggerSubsystem::ShouldCreateSubsystem(UObject* Outer) const
 {
 	// Only create an instance if there is no override implementation defined elsewhere
@@ -37,26 +57,29 @@ bool UFlowDebuggerSubsystem::ShouldCreateSubsystem(UObject* Outer) const
 
 void UFlowDebuggerSubsystem::OnInstancedTemplateAdded(UFlowAsset* AssetTemplate)
 {
+	check(IsValid(AssetTemplate));
+
 	AssetTemplate->OnPinTriggered.BindUObject(this, &ThisClass::OnPinTriggered);
 }
 
-void UFlowDebuggerSubsystem::OnInstancedTemplateRemoved(UFlowAsset* AssetTemplate) const
+void UFlowDebuggerSubsystem::OnInstancedTemplateRemoved(UFlowAsset* AssetTemplate)
 {
+	check(IsValid(AssetTemplate));
+
 	AssetTemplate->OnPinTriggered.Unbind();
+
+	OnDebuggerFlowAssetTemplateRemoved.Broadcast(*AssetTemplate);
 }
 
-void UFlowDebuggerSubsystem::OnPinTriggered(const UFlowNode* Node, const FName& PinName)
+void UFlowDebuggerSubsystem::OnPinTriggered(UFlowNode* FlowNode, const FName& PinName)
 {
-	if (bPausedAtFlowBreakpoint)
+	if (FindBreakpoint(FlowNode->NodeGuid, PinName))
 	{
-		return;
+		MarkAsHit(FlowNode, PinName);
 	}
 
-	if (!TryMarkAsHit(Node, PinName))
-	{
-		// Node breakpoints waits on any pin triggered, but check it only if there is no hit pin breakpoint
-		TryMarkAsHit(Node);
-	}
+	// Node breakpoints waits on any pin triggered
+	MarkAsHit(FlowNode);
 }
 
 void UFlowDebuggerSubsystem::AddBreakpoint(const FGuid& NodeGuid)
@@ -158,15 +181,23 @@ void UFlowDebuggerSubsystem::RemoveObsoletePinBreakpoints(const UEdGraphNode* No
 			PinNames.Emplace(Pin->PinName);
 		}
 
-		for (TPair<FName, FFlowBreakpoint>& PinBreakpoint : NodeBreakpoint->PinBreakpoints)
+		TArray<FName> PinsToRemove;
+		PinsToRemove.Reserve(NodeBreakpoint->PinBreakpoints.Num());
+
+		for (const TPair<FName, FFlowBreakpoint>& PinBreakpoint : NodeBreakpoint->PinBreakpoints)
 		{
 			if (!PinNames.Contains(PinBreakpoint.Key))
 			{
-				NodeBreakpoint->PinBreakpoints.Remove(PinBreakpoint.Key);
-				bAnythingRemoved = true;
+				PinsToRemove.Add(PinBreakpoint.Key);
 			}
 		}
 
+		for (const FName& PinName : PinsToRemove)
+		{
+			NodeBreakpoint->PinBreakpoints.Remove(PinName);
+			bAnythingRemoved = true;
+		}
+
 		if (NodeBreakpoint->IsEmpty())
 		{
 			Settings->NodeBreakpoints.Remove(Node->NodeGuid);
@@ -298,21 +329,44 @@ bool UFlowDebuggerSubsystem::IsBreakpointEnabled(const FGuid& NodeGuid, const FN
 	return false;
 }
 
-bool UFlowDebuggerSubsystem::HasAnyBreakpointsEnabled(const TWeakObjectPtr<UFlowAsset> FlowAsset)
+bool UFlowDebuggerSubsystem::HasAnyBreakpointsEnabled(const TWeakObjectPtr<UFlowAsset>& FlowAsset)
 {
-	UFlowDebuggerSettings* Settings = GetMutableDefault<UFlowDebuggerSettings>();
-	for (const TPair<FGuid, UFlowNode*>& Node : FlowAsset->GetNodes())
+	return HasAnyBreakpointsMatching(FlowAsset, true);
+}
+
+bool UFlowDebuggerSubsystem::HasAnyBreakpointsDisabled(const TWeakObjectPtr<UFlowAsset>& FlowAsset)
+{
+	return HasAnyBreakpointsMatching(FlowAsset, false);
+}
+
+bool UFlowDebuggerSubsystem::HasAnyBreakpointsMatching(const TWeakObjectPtr<UFlowAsset>& FlowAsset, bool bDesiresEnabled)
+{
+	if (!FlowAsset.IsValid())
 	{
-		if (FNodeBreakpoint* NodeBreakpoint = Settings->NodeBreakpoints.Find(Node.Key))
+		return false;
+	}
+
+	const UFlowDebuggerSettings* Settings = GetDefault<UFlowDebuggerSettings>();
+	if (!Settings)
+	{
+		return false;
+	}
+
+	for (const TPair<FGuid, UFlowNode*>& NodePair : FlowAsset->GetNodes())
+	{
+		if (const FNodeBreakpoint* NodeBreakpoint = Settings->NodeBreakpoints.Find(NodePair.Key))
 		{
-			if (NodeBreakpoint->Breakpoint.IsActive() && NodeBreakpoint->Breakpoint.IsEnabled())
+			// Node-level breakpoint must be active to count (matches original behavior)
+			if (NodeBreakpoint->Breakpoint.IsActive() &&
+				(NodeBreakpoint->Breakpoint.IsEnabled() == bDesiresEnabled))
 			{
 				return true;
 			}
 
-			for (auto& [Name, PinBreakpoint] : NodeBreakpoint->PinBreakpoints)
+			// Pin-level breakpoints
+			for (const auto& PinPair : NodeBreakpoint->PinBreakpoints)
 			{
-				if (PinBreakpoint.IsEnabled())
+				if (PinPair.Value.IsEnabled() == bDesiresEnabled)
 				{
 					return true;
 				}
@@ -323,111 +377,94 @@ bool UFlowDebuggerSubsystem::HasAnyBreakpointsEnabled(const TWeakObjectPtr<UFlow
 	return false;
 }
 
-bool UFlowDebuggerSubsystem::HasAnyBreakpointsDisabled(const TWeakObjectPtr<UFlowAsset> FlowAsset)
+void UFlowDebuggerSubsystem::ClearLastHitBreakpoint()
 {
-	UFlowDebuggerSettings* Settings = GetMutableDefault<UFlowDebuggerSettings>();
-	for (const TPair<FGuid, UFlowNode*>& Node : FlowAsset->GetNodes())
+	if (!LastHitNodeGuid.IsValid())
 	{
-		if (FNodeBreakpoint* NodeBreakpoint = Settings->NodeBreakpoints.Find(Node.Key))
-		{
-			if (NodeBreakpoint->Breakpoint.IsActive() && !NodeBreakpoint->Breakpoint.IsEnabled())
-			{
-				return true;
-			}
+		return;
+	}
 
-			for (auto& [Name, PinBreakpoint] : NodeBreakpoint->PinBreakpoints)
-			{
-				if (!PinBreakpoint.IsEnabled())
-				{
-					return true;
-				}
-			}
+	// Pin breakpoint "hit" state lives in the PinBreakpoints map, node breakpoint "hit" lives on NodeBreakpoint.Breakpoint.
+	if (!LastHitPinName.IsNone())
+	{
+		if (FFlowBreakpoint* PinBreakpoint = FindBreakpoint(LastHitNodeGuid, LastHitPinName))
+		{
+			PinBreakpoint->MarkAsHit(false);
+		}
+	}
+	else
+	{
+		if (FFlowBreakpoint* NodeBreakpoint = FindBreakpoint(LastHitNodeGuid))
+		{
+			NodeBreakpoint->MarkAsHit(false);
 		}
 	}
 
-	return false;
+	LastHitNodeGuid.Invalidate();
+	LastHitPinName = NAME_None;
 }
 
-bool UFlowDebuggerSubsystem::TryMarkAsHit(const UFlowNode* Node)
+void UFlowDebuggerSubsystem::MarkAsHit(const UFlowNode* FlowNode)
 {
-	if (FFlowBreakpoint* NodeBreakpoint = FindBreakpoint(Node->NodeGuid))
+	if (FFlowBreakpoint* NodeBreakpoint = FindBreakpoint(FlowNode->NodeGuid))
 	{
 		if (NodeBreakpoint->IsEnabled())
 		{
+			// Ensure only one breakpoint location is "hit" at a time.
+			ClearLastHitBreakpoint();
+
 			NodeBreakpoint->MarkAsHit(true);
-			PauseSession(Node);
-			return true;
+
+			LastHitNodeGuid = FlowNode->NodeGuid;
+			LastHitPinName = NAME_None;
+
+			OnDebuggerBreakpointHit.Broadcast(FlowNode);
+
+			PauseSession(*FlowNode->GetFlowAsset());
 		}
 	}
-
-	return false;
 }
 
-bool UFlowDebuggerSubsystem::TryMarkAsHit(const UFlowNode* Node, const FName& PinName)
+void UFlowDebuggerSubsystem::MarkAsHit(const UFlowNode* FlowNode, const FName& PinName)
 {
-	if (FFlowBreakpoint* PinBreakpoint = FindBreakpoint(Node->NodeGuid, PinName))
+	if (FFlowBreakpoint* PinBreakpoint = FindBreakpoint(FlowNode->NodeGuid, PinName))
 	{
 		if (PinBreakpoint->IsEnabled())
 		{
+			// Ensure only one breakpoint location is "hit" at a time.
+			ClearLastHitBreakpoint();
+
 			PinBreakpoint->MarkAsHit(true);
-			PauseSession(Node);
-			return true;
+
+			LastHitNodeGuid = FlowNode->NodeGuid;
+			LastHitPinName = PinName;
+
+			OnDebuggerBreakpointHit.Broadcast(FlowNode);
+
+			PauseSession(*FlowNode->GetFlowAsset());
 		}
 	}
-
-	return false;
 }
 
-void UFlowDebuggerSubsystem::PauseSession(const UFlowNode* Node)
+void UFlowDebuggerSubsystem::PauseSession(UFlowAsset& FlowAssetInstance)
 {
-	SetPause(true);
+	SetFlowDebuggerState(EFlowDebuggerState::Paused, &FlowAssetInstance);
 }
 
-void UFlowDebuggerSubsystem::ResumeSession()
+void UFlowDebuggerSubsystem::ResumeSession(UFlowAsset& FlowAssetInstance)
 {
-	SetPause(false);
+	SetFlowDebuggerState(EFlowDebuggerState::Resumed, &FlowAssetInstance);
 }
 
-void UFlowDebuggerSubsystem::SetPause(const bool bPause)
+void UFlowDebuggerSubsystem::StopSession()
 {
-	// experimental implementation, untested, shows intent for future development
-	// here be dragons: same as APlayerController::SetPause, but we allow debugger to pause on clients
-	if (const UWorld* World = GEngine->GetWorldFromContextObject(this, EGetWorldErrorMode::LogAndReturnNull))
-	{
-		if (const UGameInstance* GameInstance = World->GetGameInstance())
-		{
-			if (APlayerController* PlayerController = GameInstance->GetFirstLocalPlayerController())
-			{
-				if (AGameModeBase* const GameMode = GetWorld()->GetAuthGameMode())
-				{
-					const bool bCurrentPauseState = PlayerController->IsPaused();
-					if (bPause && !bCurrentPauseState)
-					{
-						GameMode->SetPause(PlayerController);
-
-						if (AWorldSettings* WorldSettings = PlayerController->GetWorldSettings())
-						{
-							WorldSettings->ForceNetUpdate();
-						}
-					}
-					else if (!bPause && bCurrentPauseState)
-					{
-						if (GameMode->ClearPause())
-						{
-							ClearHitBreakpoints();
-						}
-					}
-				}
-			}
-		}
-	}
+	SetFlowDebuggerState(EFlowDebuggerState::Invalid, nullptr);
 }
 
 void UFlowDebuggerSubsystem::ClearHitBreakpoints()
 {
-	bPausedAtFlowBreakpoint = false;
-
 	UFlowDebuggerSettings* Settings = GetMutableDefault<UFlowDebuggerSettings>();
+
 	for (TPair<FGuid, FNodeBreakpoint>& NodeBreakpoint : Settings->NodeBreakpoints)
 	{
 		NodeBreakpoint.Value.Breakpoint.MarkAsHit(false);
@@ -437,6 +474,8 @@ void UFlowDebuggerSubsystem::ClearHitBreakpoints()
 			PinBreakpoint.Value.MarkAsHit(false);
 		}
 	}
+
+	ClearLastHitBreakpoint();
 }
 
 bool UFlowDebuggerSubsystem::IsBreakpointHit(const FGuid& NodeGuid)
@@ -464,3 +503,77 @@ void UFlowDebuggerSubsystem::SaveSettings()
 	UFlowDebuggerSettings* Settings = GetMutableDefault<UFlowDebuggerSettings>();
 	Settings->SaveConfig();
 }
+
+void UFlowDebuggerSubsystem::SetFlowDebuggerState(EFlowDebuggerState NextState, UFlowAsset* FlowAssetInstance)
+{
+	if (FlowDebuggerState == NextState)
+	{
+		return;
+	}
+
+	const EFlowDebuggerState PrevState = FlowDebuggerState;
+	FlowDebuggerState = NextState;
+
+	ManageGameModePaused(PrevState, NextState, FlowAssetInstance);
+
+	// OnFlowDebuggerStateChanged MUST be the final operation in SetFlowDebuggerState
+	// as it could potentially cause a new FlowDebuggerState entered
+	{
+		OnFlowDebuggerStateChanged(PrevState, NextState, FlowAssetInstance);
+		return;
+	}
+}
+
+void UFlowDebuggerSubsystem::ManageGameModePaused(EFlowDebuggerState PrevState, EFlowDebuggerState NextState, UFlowAsset* FlowAssetInstance)
+{
+	if (!IsValid(FlowAssetInstance))
+	{
+		return;
+	}
+
+	const UWorld* World = FlowAssetInstance->GetWorld();
+	AGameModeBase* GameMode = World->GetAuthGameMode();
+	if (!IsValid(GameMode))
+	{
+		// No game mode on non-server instances
+		return;
+	}
+
+	using namespace EFlowDebuggerState_Classifiers;
+
+	const bool bIsPauseGameModeStatePrev = IsPausedGameState(PrevState);
+	const bool bIsPauseGameModeStateNext = IsPausedGameState(NextState);
+
+	if (bIsPauseGameModeStatePrev == bIsPauseGameModeStateNext)
+	{
+		return;
+	}
+
+	// Gather some pointers
+	const UGameInstance* GameInstance = World->GetGameInstance();
+	APlayerController* FirstLocalPlayerController = nullptr;
+	if (IsValid(GameInstance))
+	{
+		FirstLocalPlayerController = GameInstance->GetFirstLocalPlayerController();
+	}
+
+	// Change the GameMode pause state
+	if (bIsPauseGameModeStateNext)
+	{
+		if (FirstLocalPlayerController)
+		{
+			GameMode->SetPause(FirstLocalPlayerController);
+
+			if (AWorldSettings* WorldSettings = World->GetWorldSettings())
+			{
+				WorldSettings->ForceNetUpdate();
+			}
+		}
+	}
+	else
+	{
+		// Intentionally do NOT clear hit flags here. The editor-specific resume path will clear the last-hit
+		// breakpoint safely (without racing against immediate breakpoint hits during flush).
+		(void)GameMode->ClearPause();
+	}
+}
diff --git a/Source/FlowDebugger/Public/Debugger/FlowDebuggerSubsystem.h b/Source/FlowDebugger/Public/Debugger/FlowDebuggerSubsystem.h
index 705b49d2..ef454af6 100644
--- a/Source/FlowDebugger/Public/Debugger/FlowDebuggerSubsystem.h
+++ b/Source/FlowDebugger/Public/Debugger/FlowDebuggerSubsystem.h
@@ -5,6 +5,9 @@
 #include "Subsystems/EngineSubsystem.h"
 
 #include "Debugger/FlowDebuggerTypes.h"
+#include "Interfaces/FlowExecutionGate.h"
+#include "Types/FlowEnumUtils.h"
+
 #include "FlowDebuggerSubsystem.generated.h"
 
 class UEdGraphNode;
@@ -12,30 +15,68 @@ class UEdGraphNode;
 class UFlowAsset;
 class UFlowNode;
 
+UENUM()
+enum class EFlowDebuggerState
+{
+	// Initialized, running, but never halted
+	InitialRunning,
+
+	// Running after being pausing
+	Resumed,
+	
+	// Currently paused at a breakpoint
+	Paused,
+
+	Max UMETA(Hidden),
+	Invalid = -1 UMETA(Hidden),
+	Min = 0 UMETA(Hidden),
+
+	// Subranges for classifier checks
+	PausedGameFirst = Paused UMETA(Hidden),
+	PausedGameLast = Paused UMETA(Hidden),
+
+	FlushDeferredTriggersFirst = Resumed UMETA(Hidden),
+	FlushDeferredTriggersLast = Resumed UMETA(Hidden),
+};
+FLOW_ENUM_RANGE_VALUES(EFlowDebuggerState);
+
+namespace EFlowDebuggerState_Classifiers
+{
+	FORCEINLINE bool IsPausedGameState(EFlowDebuggerState State) { return FLOW_IS_ENUM_IN_SUBRANGE(State, EFlowDebuggerState::PausedGame); }
+	FORCEINLINE bool IsFlushDeferredTriggersState(EFlowDebuggerState State) { return FLOW_IS_ENUM_IN_SUBRANGE(State, EFlowDebuggerState::FlushDeferredTriggers); }
+}
+
+DECLARE_MULTICAST_DELEGATE_OneParam(FFlowAssetDebuggerEvent, const UFlowAsset& /*FlowAsset*/);
+DECLARE_MULTICAST_DELEGATE_OneParam(FFlowAssetDebuggerBreakpointHitEvent, const UFlowNode* /*FlowNode*/);
+
 /**
- * Persistent subsystem supporting Flow Graph debugging.
- * It might be utilized to use cook-specific graph debugger.
- */
+* Persistent subsystem supporting Flow Graph debugging.
+* It might be utilized to use cook-specific graph debugger.
+*/
 UCLASS()
-class FLOWDEBUGGER_API UFlowDebuggerSubsystem : public UEngineSubsystem
+class FLOWDEBUGGER_API UFlowDebuggerSubsystem : public UEngineSubsystem, public IFlowExecutionGate
 {
 	GENERATED_BODY()
 
 public:
 	UFlowDebuggerSubsystem();
 
-	virtual bool ShouldCreateSubsystem(UObject* Outer) const override;
+	virtual void Initialize(FSubsystemCollectionBase& Collection) override;
+	virtual void Deinitialize() override;
 
-protected:
-	bool bPausedAtFlowBreakpoint;
+	virtual bool ShouldCreateSubsystem(UObject* Outer) const override;
 
 protected:
 	virtual void OnInstancedTemplateAdded(UFlowAsset* AssetTemplate);
-	virtual void OnInstancedTemplateRemoved(UFlowAsset* AssetTemplate) const;
+	virtual void OnInstancedTemplateRemoved(UFlowAsset* AssetTemplate);
 
-	virtual void OnPinTriggered(const UFlowNode* Node, const FName& PinName);
+	virtual void OnPinTriggered(UFlowNode* FlowNode, const FName& PinName);
 
 public:
+	// IFlowExecutionGate
+	virtual bool IsFlowExecutionHalted() const override { return EFlowDebuggerState_Classifiers::IsPausedGameState(FlowDebuggerState); }
+	// --
+
 	virtual void AddBreakpoint(const FGuid& NodeGuid);
 	virtual void AddBreakpoint(const FGuid& NodeGuid, const FName& PinName);
 
@@ -62,24 +103,51 @@ class FLOWDEBUGGER_API UFlowDebuggerSubsystem : public UEngineSubsystem
 
 	virtual bool IsBreakpointEnabled(const FGuid& NodeGuid);
 	virtual bool IsBreakpointEnabled(const FGuid& NodeGuid, const FName& PinName);
-	static bool HasAnyBreakpointsEnabled(const TWeakObjectPtr<UFlowAsset> FlowAsset);
-	static bool HasAnyBreakpointsDisabled(const TWeakObjectPtr<UFlowAsset> FlowAsset);
+	static bool HasAnyBreakpointsEnabled(const TWeakObjectPtr<UFlowAsset>& FlowAsset);
+	static bool HasAnyBreakpointsDisabled(const TWeakObjectPtr<UFlowAsset>& FlowAsset);
+	static bool HasAnyBreakpointsMatching(const TWeakObjectPtr<UFlowAsset>& FlowAsset, bool bDesiresEnabled);
 
 protected:
-	virtual bool TryMarkAsHit(const UFlowNode* Node);
-	virtual bool TryMarkAsHit(const UFlowNode* Node, const FName& PinName);
+	virtual void MarkAsHit(const UFlowNode* FlowNode);
+	virtual void MarkAsHit(const UFlowNode* FlowNode, const FName& PinName);
 
-	virtual void PauseSession(const UFlowNode* Node);
-	virtual void ResumeSession();
-	void SetPause(const bool bPause);
+	virtual void PauseSession(UFlowAsset& FlowAssetInstance);
+	virtual void ResumeSession(UFlowAsset& FlowAssetInstance);
+	virtual void StopSession();
 
+	/**
+	 * Clears the "currently hit" breakpoint only (node or pin).
+	 * This avoids races where blanket-clearing all hit flags can erase a newly-hit breakpoint during resume/flush.
+	 */
+	void ClearLastHitBreakpoint();
+
+	/** Clears hit state for all breakpoints. Prefer ClearLastHitBreakpoint() for resume/step logic. */
 	virtual void ClearHitBreakpoints();
 
+private:
+	void SetFlowDebuggerState(EFlowDebuggerState NextState, UFlowAsset* FlowAssetInstance);
+	void ManageGameModePaused(EFlowDebuggerState PrevState, EFlowDebuggerState NextState, UFlowAsset* FlowAssetInstance);
+
+protected:
+	virtual void OnFlowDebuggerStateChanged(EFlowDebuggerState PrevState, EFlowDebuggerState NextState, UFlowAsset* FlowAssetInstance) {}
+
 public:
 	virtual bool IsBreakpointHit(const FGuid& NodeGuid);
 	virtual bool IsBreakpointHit(const FGuid& NodeGuid, const FName& PinName);
 
-private:
+	// Delegates for debugger events (broadcast when pausing, resuming, or hitting breakpoints)
+	FFlowAssetDebuggerEvent OnDebuggerPaused;
+	FFlowAssetDebuggerEvent OnDebuggerResumed;
+	FFlowAssetDebuggerBreakpointHitEvent OnDebuggerBreakpointHit;
+	FFlowAssetDebuggerEvent OnDebuggerFlowAssetTemplateRemoved;
+
+protected:
+	EFlowDebuggerState FlowDebuggerState = EFlowDebuggerState::Invalid;
+
+	// Track the single breakpoint location that is currently "hit" (node or pin).
+	FGuid LastHitNodeGuid;
+	FName LastHitPinName;
+
 	/** Saves any modifications made to breakpoints */
 	virtual void SaveSettings();
-};
+};
\ No newline at end of file
diff --git a/Source/FlowEditor/Private/Asset/FlowAssetToolbar.cpp b/Source/FlowEditor/Private/Asset/FlowAssetToolbar.cpp
index 7c0d96fc..860aeabe 100644
--- a/Source/FlowEditor/Private/Asset/FlowAssetToolbar.cpp
+++ b/Source/FlowEditor/Private/Asset/FlowAssetToolbar.cpp
@@ -11,6 +11,7 @@
 #include "FlowAsset.h"
 #include "Nodes/Graph/FlowNode_SubGraph.h"
 
+#include "Brushes/SlateRoundedBoxBrush.h"
 #include "Kismet2/DebuggerCommands.h"
 #include "Misc/Attribute.h"
 #include "Misc/MessageDialog.h"
diff --git a/Source/FlowEditor/Private/Asset/FlowDebugEditorSubsystem.cpp b/Source/FlowEditor/Private/Asset/FlowDebugEditorSubsystem.cpp
index 63b68d04..eed0440a 100644
--- a/Source/FlowEditor/Private/Asset/FlowDebugEditorSubsystem.cpp
+++ b/Source/FlowEditor/Private/Asset/FlowDebugEditorSubsystem.cpp
@@ -3,12 +3,19 @@
 #include "Asset/FlowDebugEditorSubsystem.h"
 #include "Asset/FlowAssetEditor.h"
 #include "Asset/FlowMessageLogListing.h"
+#include "Graph/FlowGraph.h"
+#include "Graph/FlowGraphEditor.h"
 #include "Graph/FlowGraphUtils.h"
+#include "Graph/Nodes/FlowGraphNode.h"
+#include "Interfaces/FlowExecutionGate.h"
+#include "FlowAsset.h"
+#include "FlowSubsystem.h"
 
 #include "Editor/UnrealEdEngine.h"
 #include "Engine/Engine.h"
 #include "Engine/World.h"
 #include "Framework/Notifications/NotificationManager.h"
+#include "Subsystems/AssetEditorSubsystem.h"
 #include "Templates/Function.h"
 #include "UnrealEdGlobals.h"
 #include "Widgets/Notifications/SNotificationList.h"
@@ -22,6 +29,8 @@ UFlowDebugEditorSubsystem::UFlowDebugEditorSubsystem()
 	FEditorDelegates::BeginPIE.AddUObject(this, &ThisClass::OnBeginPIE);
 	FEditorDelegates::ResumePIE.AddUObject(this, &ThisClass::OnResumePIE);
 	FEditorDelegates::EndPIE.AddUObject(this, &ThisClass::OnEndPIE);
+
+	OnDebuggerBreakpointHit.AddUObject(this, &ThisClass::OnBreakpointHit);
 }
 
 void UFlowDebugEditorSubsystem::OnInstancedTemplateAdded(UFlowAsset* AssetTemplate)
@@ -35,7 +44,7 @@ void UFlowDebugEditorSubsystem::OnInstancedTemplateAdded(UFlowAsset* AssetTempla
 	}
 }
 
-void UFlowDebugEditorSubsystem::OnInstancedTemplateRemoved(UFlowAsset* AssetTemplate) const
+void UFlowDebugEditorSubsystem::OnInstancedTemplateRemoved(UFlowAsset* AssetTemplate)
 {
 	AssetTemplate->OnRuntimeMessageAdded().RemoveAll(this);
 
@@ -54,19 +63,32 @@ void UFlowDebugEditorSubsystem::OnRuntimeMessageAdded(const UFlowAsset* AssetTem
 
 void UFlowDebugEditorSubsystem::OnBeginPIE(const bool bIsSimulating)
 {
-	// clear all logs from a previous session
+	// Clear all logs from a previous session
 	RuntimeLogs.Empty();
+
+	// Clear any stale "hit" state from previous run
+	ClearHitBreakpoints();
 }
 
 void UFlowDebugEditorSubsystem::OnResumePIE(const bool bIsSimulating)
 {
-	ClearHitBreakpoints();
+	// Editor-level resume event (also used by Advance Single Frame).
+	// This does not necessarily flow through AGameModeBase::ClearPause(), so we must unhalt Flow here.
+	ClearLastHitBreakpoint();
+
+	if (HaltedOnFlowAssetInstance.IsValid())
+	{
+		ResumeSession(*HaltedOnFlowAssetInstance.Get());
+	}
 }
 
 void UFlowDebugEditorSubsystem::OnEndPIE(const bool bIsSimulating)
 {
+	// Ensure we don't carry over a halted state between PIE sessions.
 	ClearHitBreakpoints();
 
+	StopSession();
+
 	for (const TPair<TWeakObjectPtr<UFlowAsset>, TSharedPtr<class IMessageLogListing>>& Log : RuntimeLogs)
 	{
 		if (Log.Key.IsValid() && Log.Value->NumMessages(EMessageSeverity::Warning) > 0)
@@ -93,35 +115,143 @@ void UFlowDebugEditorSubsystem::OnEndPIE(const bool bIsSimulating)
 	}
 }
 
-void UFlowDebugEditorSubsystem::PauseSession(const UFlowNode* Node)
+void UFlowDebugEditorSubsystem::PauseSession(UFlowAsset& FlowAssetInstance)
 {
-	if (GEditor->ShouldEndPlayMap())
+	HaltedOnFlowAssetInstance = &FlowAssetInstance;
+
+	Super::PauseSession(FlowAssetInstance);
+}
+
+void UFlowDebugEditorSubsystem::ResumeSession(UFlowAsset& FlowAssetInstance)
+{
+	HaltedOnFlowAssetInstance = &FlowAssetInstance;
+
+	Super::ResumeSession(FlowAssetInstance);
+}
+
+void UFlowDebugEditorSubsystem::StopSession()
+{
+	// Drop any pending deferred triggers — we are stopping the session entirely
+	if (HaltedOnFlowAssetInstance.IsValid())
 	{
-		return;
+		UFlowSubsystem* FlowSubsystem = HaltedOnFlowAssetInstance->GetFlowSubsystem();
+
+		if (IsValid(FlowSubsystem))
+		{
+			FlowSubsystem->ClearAllDeferredTriggerScopes();
+		}
 	}
 
-	if (GUnrealEd->SetPIEWorldsPaused(true))
+	HaltedOnFlowAssetInstance.Reset();
+
+	Super::StopSession();
+}
+
+void UFlowDebugEditorSubsystem::OnFlowDebuggerStateChanged(EFlowDebuggerState PrevState, EFlowDebuggerState NextState, UFlowAsset* FlowAssetInstance)
+{
+	check(PrevState != NextState);
+
+	using namespace EFlowDebuggerState_Classifiers;
+
+	const bool bIsPausedGameStatePrev = IsPausedGameState(PrevState);
+	const bool bIsPausedGameStateNext = IsPausedGameState(NextState);
+
+	// Handle Pause/Unpause of the game & pie systems
+	if (bIsPausedGameStatePrev != bIsPausedGameStateNext)
 	{
-		bPausedAtFlowBreakpoint = true;
+		const bool bWasPaused = GUnrealEd->SetPIEWorldsPaused(bIsPausedGameStateNext);
 
-		const UFlowAsset* HitInstance = Node->GetFlowAsset();
-		if (ensure(HitInstance))
+		if (bIsPausedGameStateNext && !bWasPaused)
+		{
+			GUnrealEd->PlaySessionPaused();
+		}
+		else if (!bIsPausedGameStateNext && bWasPaused)
 		{
-			UFlowAsset* AssetTemplate = HitInstance->GetTemplateAsset();
-			AssetTemplate->SetInspectedInstance(HitInstance);
+			GUnrealEd->PlaySessionResumed();
+		}
+	}
 
-			UAssetEditorSubsystem* AssetEditorSubsystem = GEditor->GetEditorSubsystem<UAssetEditorSubsystem>();
-			if (AssetEditorSubsystem->OpenEditorForAsset(AssetTemplate))
-			{
-				if (const TSharedPtr<FFlowAssetEditor> FlowAssetEditor = FFlowGraphUtils::GetFlowAssetEditor(AssetTemplate))
-				{
-					FlowAssetEditor->JumpToNode(Node->GetGraphNode());
-				}
-			}
+	// Issue the broadcasts for specific state entry
+	FLOW_ASSERT_ENUM_MAX(EFlowDebuggerState, 3);
+	if (NextState == EFlowDebuggerState::Paused)
+	{
+		OnDebuggerPaused.Broadcast(*FlowAssetInstance);
+	}
+	else if (NextState == EFlowDebuggerState::Resumed)
+	{
+		OnDebuggerResumed.Broadcast(*FlowAssetInstance);
+	}
+
+	UFlowSubsystem* FlowSubsystem =
+		IsValid(FlowAssetInstance) ?
+			FlowAssetInstance->GetFlowSubsystem() :
+			nullptr;
+
+	if (FlowSubsystem && IsFlushDeferredTriggersState(NextState))
+	{
+		// Flush any deferred triggers now that halt is cleared.
+		FlowSubsystem->TryFlushAllDeferredTriggerScopes();
+
+		// NOTE (gtaylor) this flush needs to be the last thing we do in this function 
+		// (thus the explicit return to emphasize it), as this flush can be interrupted by another breakpoint
+		return;
+	}
+}
+
+void UFlowDebugEditorSubsystem::OnBreakpointHit(const UFlowNode* FlowNode) const
+{
+	UFlowAsset* TemplateAsset = const_cast<UFlowAsset*>(FlowNode->GetFlowAsset()->GetTemplateAsset());
+	if (!IsValid(TemplateAsset))
+	{
+		return;
+	}
+
+	UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr;
+	if (!AssetEditorSubsystem)
+	{
+		return;
+	}
+
+	if (!AssetEditorSubsystem->OpenEditorForAsset(TemplateAsset))
+	{
+		return;
+	}
+
+	TemplateAsset->SetInspectedInstance(FlowNode->GetFlowAsset());
+
+	UFlowGraph* FlowGraph = Cast<UFlowGraph>(TemplateAsset->GetGraph());
+	if (!IsValid(FlowGraph))
+	{
+		return;
+	}
+
+	// NOTE: This may be redundant call, but it ensures Slate re-queries breakpoint hit state and updates node overlays immediately.
+	FlowGraph->NotifyGraphChanged();
+
+	UEdGraphNode* NodeToFocus = nullptr;
+	for (UEdGraphNode* Node : FlowGraph->Nodes)
+	{
+		UFlowGraphNode* FlowGraphNode = Cast<UFlowGraphNode>(Node);
+		if (IsValid(FlowGraphNode) && FlowGraphNode->NodeGuid == FlowNode->NodeGuid)
+		{
+			NodeToFocus = FlowGraphNode;
+			break;
 		}
+	}
+
+	if (!NodeToFocus)
+	{
+		return;
+	}
+
+	const TSharedPtr<SFlowGraphEditor> GraphEditor = FFlowGraphUtils::GetFlowGraphEditor(FlowGraph);
+	if (GraphEditor.IsValid())
+	{
+		constexpr bool bRequestRename = false;
+		constexpr bool bSelectNode = true;
 
-		GUnrealEd->PlaySessionPaused();
+		GraphEditor->JumpToNode(NodeToFocus, bRequestRename, bSelectNode);
 	}
 }
 
-#undef LOCTEXT_NAMESPACE
+#undef LOCTEXT_NAMESPACE
\ No newline at end of file
diff --git a/Source/FlowEditor/Private/Graph/FlowGraphEditor.cpp b/Source/FlowEditor/Private/Graph/FlowGraphEditor.cpp
index 4d14f5b5..0e9a97c8 100644
--- a/Source/FlowEditor/Private/Graph/FlowGraphEditor.cpp
+++ b/Source/FlowEditor/Private/Graph/FlowGraphEditor.cpp
@@ -19,6 +19,9 @@
 #include "LevelEditor.h"
 #include "Modules/ModuleManager.h"
 #include "ScopedTransaction.h"
+#include "ToolMenu.h"
+#include "ToolMenuDelegates.h"
+#include "ToolMenus.h"
 #include "UnrealEdGlobals.h"
 #include "Widgets/Docking/SDockTab.h"
 #include "Algo/AnyOf.h"
@@ -54,6 +57,69 @@ void SFlowGraphEditor::Construct(const FArguments& InArgs, const TSharedPtr<FFlo
 	SGraphEditor::Construct(Arguments);
 }
 
+bool SFlowGraphEditor::GetValidExecBreakpointPinContext(const UEdGraphPin* Pin, FGuid& OutNodeGuid, FName& OutPinName)
+{
+	if (!Pin)
+	{
+		return false;
+	}
+
+	if (!FFlowPin::IsExecPinCategory(Pin->PinType.PinCategory))
+	{
+		return false;
+	}
+
+	// - If the owning node is not a UFlowGraphNode, allow it.
+	// - If it is a UFlowGraphNode, require it to allow breakpoints.
+	const UEdGraphNode* EdNode = Pin->GetOwningNode();
+	if (!EdNode)
+	{
+		return false;
+	}
+
+	const UFlowGraphNode* FlowNode = Cast<const UFlowGraphNode>(EdNode);
+	if (FlowNode && !FlowNode->CanPlaceBreakpoints())
+	{
+		return false;
+	}
+
+	OutNodeGuid = EdNode->NodeGuid;
+	OutPinName = Pin->PinName;
+	return true;
+}
+
+const FFlowBreakpoint* SFlowGraphEditor::FindPinBreakpoint(UFlowDebuggerSubsystem* InDebuggerSubsystem, const UEdGraphPin* Pin)
+{
+	if (!InDebuggerSubsystem)
+	{
+		return nullptr;
+	}
+
+	FGuid NodeGuid;
+	FName PinName;
+	if (!GetValidExecBreakpointPinContext(Pin, NodeGuid, PinName))
+	{
+		return nullptr;
+	}
+
+	return InDebuggerSubsystem->FindBreakpoint(NodeGuid, PinName);
+}
+
+bool SFlowGraphEditor::HasPinBreakpoint(UFlowDebuggerSubsystem* InDebuggerSubsystem, const UEdGraphPin* Pin)
+{
+	return FindPinBreakpoint(InDebuggerSubsystem, Pin) != nullptr;
+}
+
+bool SFlowGraphEditor::HasEnabledPinBreakpoint(UFlowDebuggerSubsystem* InDebuggerSubsystem, const UEdGraphPin* Pin)
+{
+	if (const FFlowBreakpoint* BP = FindPinBreakpoint(InDebuggerSubsystem, Pin))
+	{
+		return BP->IsEnabled();
+	}
+
+	return false;
+}
+
 void SFlowGraphEditor::BindGraphCommands()
 {
 	FGraphEditorCommands::Register();
@@ -1148,11 +1214,14 @@ void SFlowGraphEditor::OnAddPinBreakpoint()
 	check(DebuggerSubsystem.IsValid());
 	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
 	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
+		FGuid NodeGuid;
+		FName PinName;
+		if (!GetValidExecBreakpointPinContext(Pin, NodeGuid, PinName))
 		{
-			DebuggerSubsystem->AddBreakpoint(Pin->GetOwningNode()->NodeGuid, Pin->PinName);
+			return;
 		}
+
+		DebuggerSubsystem->AddBreakpoint(NodeGuid, PinName);
 	}
 }
 
@@ -1178,11 +1247,14 @@ bool SFlowGraphEditor::CanAddPinBreakpoint()
 	check(DebuggerSubsystem.IsValid());
 	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
 	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
+		FGuid NodeGuid;
+		FName PinName;
+		if (!GetValidExecBreakpointPinContext(Pin, NodeGuid, PinName))
 		{
-			return DebuggerSubsystem->FindBreakpoint(Pin->GetOwningNode()->NodeGuid, Pin->PinName) == nullptr;
+			return false;
 		}
+
+		return DebuggerSubsystem->FindBreakpoint(NodeGuid, PinName) == nullptr;
 	}
 
 	return false;
@@ -1205,11 +1277,14 @@ void SFlowGraphEditor::OnRemovePinBreakpoint()
 	check(DebuggerSubsystem.IsValid());
 	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
 	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
+		FGuid NodeGuid;
+		FName PinName;
+		if (!GetValidExecBreakpointPinContext(Pin, NodeGuid, PinName))
 		{
-			DebuggerSubsystem->RemovePinBreakpoint(Pin->GetOwningNode()->NodeGuid, Pin->PinName);
+			return;
 		}
+
+		DebuggerSubsystem->RemovePinBreakpoint(NodeGuid, PinName);
 	}
 }
 
@@ -1233,16 +1308,7 @@ bool SFlowGraphEditor::CanRemoveBreakpoint() const
 bool SFlowGraphEditor::CanRemovePinBreakpoint()
 {
 	check(DebuggerSubsystem.IsValid());
-	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
-	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
-		{
-			return DebuggerSubsystem->FindBreakpoint(Pin->GetOwningNode()->NodeGuid, Pin->PinName) != nullptr;
-		}
-	}
-
-	return false;
+	return HasPinBreakpoint(DebuggerSubsystem.Get(), GetGraphPinForMenu());
 }
 
 void SFlowGraphEditor::OnEnableBreakpoint() const
@@ -1262,11 +1328,14 @@ void SFlowGraphEditor::OnEnablePinBreakpoint()
 	check(DebuggerSubsystem.IsValid());
 	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
 	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
+		FGuid NodeGuid;
+		FName PinName;
+		if (!GetValidExecBreakpointPinContext(Pin, NodeGuid, PinName))
 		{
-			DebuggerSubsystem->SetBreakpointEnabled(Pin->GetOwningNode()->NodeGuid, Pin->PinName, true);
+			return;
 		}
+
+		DebuggerSubsystem->SetBreakpointEnabled(NodeGuid, PinName, true);
 	}
 }
 
@@ -1289,17 +1358,8 @@ bool SFlowGraphEditor::CanEnableBreakpoint() const
 
 bool SFlowGraphEditor::CanEnablePinBreakpoint()
 {
-	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
-	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
-		{
-			const FFlowBreakpoint* Breakpoint = DebuggerSubsystem->FindBreakpoint(Pin->GetOwningNode()->NodeGuid, Pin->PinName);
-			return Breakpoint && !Breakpoint->IsEnabled();
-		}
-	}
-
-	return false;
+	return HasPinBreakpoint(DebuggerSubsystem.Get(), GetGraphPinForMenu())
+		&& !HasEnabledPinBreakpoint(DebuggerSubsystem.Get(), GetGraphPinForMenu());
 }
 
 void SFlowGraphEditor::OnDisableBreakpoint() const
@@ -1319,11 +1379,14 @@ void SFlowGraphEditor::OnDisablePinBreakpoint()
 	check(DebuggerSubsystem.IsValid());
 	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
 	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
+		FGuid NodeGuid;
+		FName PinName;
+		if (!GetValidExecBreakpointPinContext(Pin, NodeGuid, PinName))
 		{
-			DebuggerSubsystem->SetBreakpointEnabled(Pin->GetOwningNode()->NodeGuid, Pin->PinName, false);
+			return;
 		}
+
+		DebuggerSubsystem->SetBreakpointEnabled(NodeGuid, PinName, false);
 	}
 }
 
@@ -1348,17 +1411,7 @@ bool SFlowGraphEditor::CanDisableBreakpoint() const
 bool SFlowGraphEditor::CanDisablePinBreakpoint()
 {
 	check(DebuggerSubsystem.IsValid());
-	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
-	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
-		{
-			const FFlowBreakpoint* Breakpoint = DebuggerSubsystem->FindBreakpoint(Pin->GetOwningNode()->NodeGuid, Pin->PinName);
-			return Breakpoint && Breakpoint->IsEnabled();
-		}
-	}
-
-	return false;
+	return HasEnabledPinBreakpoint(DebuggerSubsystem.Get(), GetGraphPinForMenu());
 }
 
 void SFlowGraphEditor::OnToggleBreakpoint() const
@@ -1378,11 +1431,14 @@ void SFlowGraphEditor::OnTogglePinBreakpoint()
 	check(DebuggerSubsystem.IsValid());
 	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
 	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
+		FGuid NodeGuid;
+		FName PinName;
+		if (!GetValidExecBreakpointPinContext(Pin, NodeGuid, PinName))
 		{
-			DebuggerSubsystem->ToggleBreakpoint(Pin->GetOwningNode()->NodeGuid, Pin->PinName);
+			return;
 		}
+
+		DebuggerSubsystem->ToggleBreakpoint(NodeGuid, PinName);
 	}
 }
 
@@ -1403,11 +1459,9 @@ bool SFlowGraphEditor::CanTogglePinBreakpoint()
 {
 	if (const UEdGraphPin* Pin = GetGraphPinForMenu())
 	{
-		const UFlowGraphNode* OwningNode = Cast<const UFlowGraphNode>(Pin->GetOwningNode());
-		if (!OwningNode || OwningNode->CanPlaceBreakpoints())
-		{
-			return true;
-		}
+		FGuid NodeGuid;
+		FName PinName;
+		return GetValidExecBreakpointPinContext(Pin, NodeGuid, PinName);
 	}
 
 	return false;
diff --git a/Source/FlowEditor/Private/Graph/Nodes/FlowGraphNode.cpp b/Source/FlowEditor/Private/Graph/Nodes/FlowGraphNode.cpp
index 9864a54e..6626c817 100644
--- a/Source/FlowEditor/Private/Graph/Nodes/FlowGraphNode.cpp
+++ b/Source/FlowEditor/Private/Graph/Nodes/FlowGraphNode.cpp
@@ -15,6 +15,8 @@
 #include "Graph/FlowGraphSettings.h"
 #include "Graph/Widgets/SFlowGraphNode.h"
 #include "Graph/Widgets/SGraphEditorActionMenuFlow.h"
+#include "Interfaces/FlowDataPinValueSupplierInterface.h"
+#include "Types/FlowDataPinValue.h"
 
 #include "BlueprintNodeHelpers.h"
 #include "Developer/ToolMenus/Public/ToolMenus.h"
@@ -1082,8 +1084,10 @@ void UFlowGraphNode::GetPinHoverText(const UEdGraphPin& Pin, FString& HoverTextO
 	// start with the default hover text (from the pin's tool-tip)
 	Super::GetPinHoverText(Pin, HoverTextOut);
 
+	const bool bHasValidPlayWorld = IsValid(GEditor->PlayWorld);
+
 	// add information on pin activations
-	if (GEditor->PlayWorld)
+	if (bHasValidPlayWorld)
 	{
 		if (const UFlowNode* InspectedNodeInstance = GetInspectedNodeInstance())
 		{
@@ -1093,11 +1097,7 @@ void UFlowGraphNode::GetPinHoverText(const UEdGraphPin& Pin, FString& HoverTextO
 			}
 
 			const TArray<FPinRecord>& PinRecords = InspectedNodeInstance->GetPinRecords(Pin.PinName, Pin.Direction);
-			if (PinRecords.Num() == 0)
-			{
-				HoverTextOut.Append(FPinRecord::NoActivations);
-			}
-			else
+			if (PinRecords.Num() > 0)
 			{
 				HoverTextOut.Append(FPinRecord::PinActivations);
 				for (int32 i = 0; i < PinRecords.Num(); i++)
@@ -1107,22 +1107,78 @@ void UFlowGraphNode::GetPinHoverText(const UEdGraphPin& Pin, FString& HoverTextO
 
 					switch (PinRecords[i].ActivationType)
 					{
-						case EFlowPinActivationType::Default:
-							break;
-						case EFlowPinActivationType::Forced:
-							HoverTextOut.Append(FPinRecord::ForcedActivation);
-							break;
-						case EFlowPinActivationType::PassThrough:
-							HoverTextOut.Append(FPinRecord::PassThroughActivation);
-							break;
-						default: ;
+					case EFlowPinActivationType::Default:
+						break;
+					case EFlowPinActivationType::Forced:
+						HoverTextOut.Append(FPinRecord::ForcedActivation);
+						break;
+					case EFlowPinActivationType::PassThrough:
+						HoverTextOut.Append(FPinRecord::PassThroughActivation);
+						break;
+					default:;
 					}
 				}
 			}
 		}
 	}
-}
 
+	// add information on data pin values (only for data pins)
+	const bool bIsDataPinCategory = !FFlowPin::IsExecPinCategory(Pin.PinType.PinCategory);
+	if (bIsDataPinCategory)
+	{
+		const UEdGraphPin* GraphPinObj = &Pin;
+
+		// Prefer showing runtime values when PIE (consistent with activation history)
+		const UFlowNodeBase* FlowNodeBase = GetFlowNodeBase();
+
+		if (bHasValidPlayWorld)
+		{
+			FlowNodeBase = GetInspectedNodeInstance();
+		}
+
+		FFlowDataPinResult DataResult(EFlowDataPinResolveResult::FailedNullFlowNodeBase);
+
+		if (IsValid(FlowNodeBase))
+		{
+			if (GraphPinObj->Direction == EGPD_Input)
+			{
+				// Input pins: do a pin resolve to source the value
+				DataResult = FlowNodeBase->TryResolveDataPin(GraphPinObj->PinName);
+			}
+			else
+			{
+				// Output pins: ask this node what it supplies for that output data pin
+				const UFlowNode* FlowNode = Cast<UFlowNode>(FlowNodeBase);
+				if (FlowNode)
+				{
+					DataResult = IFlowDataPinValueSupplierInterface::Execute_TrySupplyDataPin(FlowNode, GraphPinObj->PinName);
+				}
+			}
+		}
+
+		FString ValueString;
+
+		if (FlowPinType::IsSuccess(DataResult.Result) && DataResult.ResultValue.IsValid())
+		{
+			const FFlowDataPinValue& Value = DataResult.ResultValue.Get<FFlowDataPinValue>();
+			if (!Value.TryConvertValuesToString(ValueString))
+			{
+				ValueString = TEXT("<unformattable>");
+			}
+		}
+		else
+		{
+			ValueString = TEXT("<unresolved>");
+		}
+
+		if (!HoverTextOut.IsEmpty())
+		{
+			HoverTextOut.Append(LINE_TERMINATOR).Append(LINE_TERMINATOR);
+		}
+
+		HoverTextOut.Appendf(TEXT("Value: %s"), *ValueString);
+	}
+}
 
 void UFlowGraphNode::ForcePinActivation(const FEdGraphPinReference PinReference) const
 {
@@ -1991,4 +2047,4 @@ bool UFlowGraphNode::CanAcceptSubNodeAsChild(const UFlowGraphNode& OtherSubNode,
 	return false;
 }
 
-#undef LOCTEXT_NAMESPACE
+#undef LOCTEXT_NAMESPACE
\ No newline at end of file
diff --git a/Source/FlowEditor/Public/Asset/FlowAssetEditor.h b/Source/FlowEditor/Public/Asset/FlowAssetEditor.h
index 881f6c26..630cec7d 100644
--- a/Source/FlowEditor/Public/Asset/FlowAssetEditor.h
+++ b/Source/FlowEditor/Public/Asset/FlowAssetEditor.h
@@ -121,7 +121,7 @@ class FLOWEDITOR_API FFlowAssetEditor : public FAssetEditorToolkit, public FEdit
 
 public:
 	/** Edits the specified FlowAsset object */
-	void InitFlowAssetEditor(const EToolkitMode::Type Mode, const TSharedPtr<class IToolkitHost>& InitToolkitHost, UObject* ObjectToEdit);
+	virtual void InitFlowAssetEditor(const EToolkitMode::Type Mode, const TSharedPtr<class IToolkitHost>& InitToolkitHost, UObject* ObjectToEdit);
 
 protected:
 	virtual void CreateToolbar();
diff --git a/Source/FlowEditor/Public/Asset/FlowDebugEditorSubsystem.h b/Source/FlowEditor/Public/Asset/FlowDebugEditorSubsystem.h
index b05d1551..6833c057 100644
--- a/Source/FlowEditor/Public/Asset/FlowDebugEditorSubsystem.h
+++ b/Source/FlowEditor/Public/Asset/FlowDebugEditorSubsystem.h
@@ -24,8 +24,10 @@ class FLOWEDITOR_API UFlowDebugEditorSubsystem : public UFlowDebuggerSubsystem
 protected:
 	TMap<TWeakObjectPtr<UFlowAsset>, TSharedPtr<class IMessageLogListing>> RuntimeLogs;
 
+	TWeakObjectPtr<UFlowAsset> HaltedOnFlowAssetInstance;
+
 	virtual void OnInstancedTemplateAdded(UFlowAsset* AssetTemplate) override;
-	virtual void OnInstancedTemplateRemoved(UFlowAsset* AssetTemplate) const override;
+	virtual void OnInstancedTemplateRemoved(UFlowAsset* AssetTemplate) override;
 
 	void OnRuntimeMessageAdded(const UFlowAsset* AssetTemplate, const TSharedRef<FTokenizedMessage>& Message) const;
 
@@ -33,5 +35,10 @@ class FLOWEDITOR_API UFlowDebugEditorSubsystem : public UFlowDebuggerSubsystem
 	virtual void OnResumePIE(const bool bIsSimulating);
 	virtual void OnEndPIE(const bool bIsSimulating);
 
-	virtual void PauseSession(const UFlowNode* Node) override;
+	virtual void PauseSession(UFlowAsset& FlowAssetInstance) override;
+	virtual void ResumeSession(UFlowAsset& FlowAssetInstance) override;
+	virtual void StopSession() override;
+	virtual void OnFlowDebuggerStateChanged(EFlowDebuggerState PrevState, EFlowDebuggerState NextState, UFlowAsset* FlowAssetInstance);
+
+	void OnBreakpointHit(const UFlowNode* FlowNode) const;
 };
diff --git a/Source/FlowEditor/Public/FlowEditorModule.h b/Source/FlowEditor/Public/FlowEditorModule.h
index 9e32e660..b75187d9 100644
--- a/Source/FlowEditor/Public/FlowEditorModule.h
+++ b/Source/FlowEditor/Public/FlowEditorModule.h
@@ -30,6 +30,7 @@ class FLOWEDITOR_API FFlowEditorModule : public IModuleInterface, public IHasMen
 	TArray<TSharedRef<IAssetTypeActions>> RegisteredAssetActions;
 	TSet<FName> CustomClassLayouts;
 	TSet<FName> CustomStructLayouts;
+
 	bool bIsRegisteredForAssetChanges = false;
 
 public:
diff --git a/Source/FlowEditor/Public/Graph/FlowGraphEditor.h b/Source/FlowEditor/Public/Graph/FlowGraphEditor.h
index 15c6ee9b..8c292ece 100644
--- a/Source/FlowEditor/Public/Graph/FlowGraphEditor.h
+++ b/Source/FlowEditor/Public/Graph/FlowGraphEditor.h
@@ -10,7 +10,9 @@
 
 class FFlowAssetEditor;
 class IDetailsView;
+class UEdGraphPin;
 class UFlowDebuggerSubsystem;
+struct FFlowBreakpoint;
 
 /**
  *
@@ -109,6 +111,12 @@ class FLOWEDITOR_API SFlowGraphEditor : public SGraphEditor
 	virtual void ReconstructNode() const;
 	virtual bool CanReconstructNode() const;
 
+	// ---- Pin breakpoint helpers ----
+	static bool GetValidExecBreakpointPinContext(const UEdGraphPin* Pin, FGuid& OutNodeGuid, FName& OutPinName);
+	static const FFlowBreakpoint* FindPinBreakpoint(UFlowDebuggerSubsystem* InDebuggerSubsystem, const UEdGraphPin* Pin);
+	static bool HasPinBreakpoint(UFlowDebuggerSubsystem* InDebuggerSubsystem, const UEdGraphPin* Pin);
+	static bool HasEnabledPinBreakpoint(UFlowDebuggerSubsystem* InDebuggerSubsystem, const UEdGraphPin* Pin);
+
 private:
 	void AddInput() const;
 	bool CanAddInput() const;