Expose gameplay selector owned-execution delivery preview surface

2026-05-08 15:36:06 +02:00 · 2026-05-08 15:36:06 +02:00 · 9ece8389bc
commit 9ece8389bc
parent 7da3d8ca8e
9 changed files with 835 additions and 2 deletions
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingCoachLibrary.cpp
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingCoachLibrary.cpp
@ -12163,3 +12163,471 @@ UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionOwnedExec

 	return Surface;
 }
+
+FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface
+UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
+	const FHyperTwistTrainingRunState& RunState,
+	const FString& SelectorId,
+	const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface& OptionMenuSurface,
+	const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface&
+		OptionLaunchRequestPreviewSurface
+)
+{
+	FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface Surface;
+	Surface.SelectorId = SelectorId;
+	Surface.SelectorLabel = OptionMenuSurface.SelectorLabel;
+	Surface.BindingLabel = OptionMenuSurface.BindingLabel;
+	Surface.Headline = TEXT("Generated Mode Selector Option Owned-Execution Delivery Preview");
+	Surface.bHasSelector = OptionMenuSurface.bHasSelector;
+
+	if (!SelectorId.IsEmpty())
+	{
+		Surface.Headline = OptionMenuSurface.SelectorLabel.IsEmpty()
+			? FString::Printf(
+				TEXT("Generated Mode Selector Option Owned-Execution Delivery Preview: %s"),
+				*SelectorId
+			)
+			: FString::Printf(
+				TEXT("Generated Mode Selector Option Owned-Execution Delivery Preview: %s"),
+				*OptionMenuSurface.SelectorLabel
+			);
+	}
+
+	if (SelectorId.IsEmpty())
+	{
+		Surface.StatusLine =
+			TEXT("Generated-mode selector option owned-execution delivery preview requires a selector id from the active selector roster.");
+		Surface.DeliveryModeSummaryLine = TEXT("Delivery mode: n/a");
+		Surface.RevealPostureSummaryLine = TEXT("Reveal posture: n/a");
+		Surface.TimeTargetSummaryLine = TEXT("Time target: n/a");
+		Surface.CurrentSelectionExecutionLine = TEXT("Current selection: n/a");
+		Surface.DetailLine = OptionLaunchRequestPreviewSurface.StatusLine.IsEmpty()
+			? TEXT("Launch-request preview: n/a")
+			: FString::Printf(
+				TEXT("Launch-request preview: %s"),
+				*OptionLaunchRequestPreviewSurface.StatusLine
+			);
+		return Surface;
+	}
+
+	const FHyperTwistTrainingImportedRuntimeSurface& RuntimeSurface =
+		RunState.ActiveDeck.ImportedRuntimeSurface;
+	const bool bHasGeneratedModeSurface = RuntimeSurface.IsStructurallyValid()
+		&& RuntimeSurface.SurfaceKind.Equals(TEXT("generated-mode"), ESearchCase::IgnoreCase);
+	const FHyperTwistTrainingCase* SeedCase = RunState.ActiveDeck.Cases.FindByPredicate(
+		[](const FHyperTwistTrainingCase& Candidate)
+		{
+			return Candidate.IsStructurallyValid();
+		}
+	);
+
+	const auto DescribeDeliveryMode = [](
+		const EHyperTwistTrainingDeliveryMode DeliveryMode
+	) -> FString
+	{
+		switch (DeliveryMode)
+		{
+			case EHyperTwistTrainingDeliveryMode::Timer:
+				return TEXT("Timer");
+			case EHyperTwistTrainingDeliveryMode::VirtualCube:
+				return TEXT("Virtual Cube");
+			case EHyperTwistTrainingDeliveryMode::SmartDevice:
+				return TEXT("Smart Device");
+			case EHyperTwistTrainingDeliveryMode::RecognitionAssisted:
+				return TEXT("Recognition Assisted");
+			case EHyperTwistTrainingDeliveryMode::CoachReviewed:
+				return TEXT("Coach Reviewed");
+			default:
+				return TEXT("Unknown");
+		}
+	};
+
+	const auto BuildDeliveryModeLine = [&DescribeDeliveryMode](
+		const EHyperTwistTrainingDeliveryMode DeliveryMode
+	) -> FString
+	{
+		return FString::Printf(
+			TEXT("Delivery mode on execute: %s"),
+			*DescribeDeliveryMode(DeliveryMode)
+		);
+	};
+
+	const auto BuildTimeTargetLine = [](
+		const int32 TimeTargetMs
+	) -> FString
+	{
+		return TimeTargetMs > 0
+			? FString::Printf(TEXT("Time target on execute: %d ms"), TimeTargetMs)
+			: TEXT("Time target on execute: none");
+	};
+
+	const auto IncrementDeliveryModeCount = [&Surface](
+		const EHyperTwistTrainingDeliveryMode DeliveryMode
+	)
+	{
+		switch (DeliveryMode)
+		{
+			case EHyperTwistTrainingDeliveryMode::Timer:
+				++Surface.TimerDeliveryOptionCount;
+				break;
+			case EHyperTwistTrainingDeliveryMode::VirtualCube:
+				++Surface.VirtualCubeDeliveryOptionCount;
+				break;
+			case EHyperTwistTrainingDeliveryMode::SmartDevice:
+				++Surface.SmartDeviceDeliveryOptionCount;
+				break;
+			case EHyperTwistTrainingDeliveryMode::RecognitionAssisted:
+				++Surface.RecognitionAssistedDeliveryOptionCount;
+				break;
+			case EHyperTwistTrainingDeliveryMode::CoachReviewed:
+				++Surface.CoachReviewedDeliveryOptionCount;
+				break;
+			default:
+				break;
+		}
+	};
+
+	const auto IncrementRevealCounts = [&Surface](
+		const bool bSupportsAlgorithmRevealOnExecute,
+		const bool bRevealConfiguredByDeckPolicy,
+		const bool bHasRevealNotation
+	)
+	{
+		if (bSupportsAlgorithmRevealOnExecute)
+		{
+			++Surface.RevealEnabledOptionCount;
+		}
+		else if (bRevealConfiguredByDeckPolicy && !bHasRevealNotation)
+		{
+			++Surface.MissingRevealNotationOptionCount;
+		}
+		else
+		{
+			++Surface.RevealDisabledOptionCount;
+		}
+	};
+
+	const auto IncrementTimeTargetCounts = [&Surface](const bool bHasTimeTarget)
+	{
+		if (bHasTimeTarget)
+		{
+			++Surface.TimedOptionCount;
+		}
+		else
+		{
+			++Surface.UntargetedOptionCount;
+		}
+	};
+
+	if (!RunState.IsStructurallyValid() || !bHasGeneratedModeSurface)
+	{
+		Surface.StatusLine = OptionMenuSurface.StatusLine.IsEmpty()
+			? TEXT("Generated-mode selector option owned-execution delivery preview is not currently available.")
+			: OptionMenuSurface.StatusLine;
+		Surface.DeliveryModeSummaryLine = TEXT("Delivery mode: n/a");
+		Surface.RevealPostureSummaryLine = TEXT("Reveal posture: n/a");
+		Surface.TimeTargetSummaryLine = TEXT("Time target: n/a");
+		Surface.CurrentSelectionExecutionLine = OptionMenuSurface.bHasUnresolvedSelectionDetail
+			? OptionMenuSurface.UnresolvedSelectionLine
+			: (OptionMenuSurface.bHasSelection
+				? TEXT("Current selection remains cached, but no active owned-execution delivery preview is available.")
+				: TEXT("Current selection: unresolved"));
+		Surface.DetailLine = FString::Printf(
+			TEXT("Launch-request preview: %s"),
+			OptionLaunchRequestPreviewSurface.StatusLine.IsEmpty()
+				? TEXT("n/a")
+				: *OptionLaunchRequestPreviewSurface.StatusLine
+		);
+		return Surface;
+	}
+
+	for (const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewEntrySurface&
+		PreviewEntry : OptionLaunchRequestPreviewSurface.OptionEntries)
+	{
+		FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewEntrySurface
+			Entry;
+		Entry.OptionId = PreviewEntry.OptionId;
+		Entry.Label = PreviewEntry.Label;
+		Entry.OptionValue = PreviewEntry.OptionValue;
+		Entry.LaunchRequestPreviewKind = PreviewEntry.LaunchRequestPreviewKind;
+		Entry.bMatchesCurrentSelection = PreviewEntry.bMatchesCurrentSelection;
+		Entry.bStartsOwnedCaseImmediately = PreviewEntry.bStartsOwnedCaseImmediately;
+
+		switch (PreviewEntry.LaunchRequestPreviewKind)
+		{
+			case EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::
+				DirectOwnedCaseStart:
+			{
+				FHyperTwistTrainingCase MatchingCase;
+				if (UHyperTwistTrainingCatalogLibrary::TryGetImportedRuntimeSelectorOptionCaseFromDeck(
+						RunState.ActiveDeck,
+						SelectorId,
+						PreviewEntry.OptionId,
+						MatchingCase))
+				{
+					Entry.PreviewDeliveryMode = RunState.Session.Mode;
+					Entry.PreviewDeliveryModeLabel = DescribeDeliveryMode(Entry.PreviewDeliveryMode);
+					Entry.DeliveryModeLine = BuildDeliveryModeLine(Entry.PreviewDeliveryMode);
+					Entry.bRevealConfiguredByDeckPolicy =
+						RunState.ActiveDeck.bSupportsAlgorithmReveal;
+					Entry.bHasRevealNotation = !MatchingCase.CanonicalNotation.IsEmpty();
+					Entry.bSupportsAlgorithmRevealOnExecute =
+						Entry.bRevealConfiguredByDeckPolicy && Entry.bHasRevealNotation;
+					Entry.RevealPostureLine = !Entry.bRevealConfiguredByDeckPolicy
+						? TEXT("Reveal posture on execute: disabled by the active deck reveal policy.")
+						: (Entry.bHasRevealNotation
+							? TEXT("Reveal posture on execute: algorithm reveal remains enabled on the covered owned case.")
+							: TEXT("Reveal posture on execute: the active deck keeps reveal enabled, but the covered owned case has no canonical notation."));
+					Entry.PreviewTimeTargetMs = MatchingCase.TimeTargetMs;
+					Entry.bHasTimeTarget = Entry.PreviewTimeTargetMs > 0;
+					Entry.TimeTargetLine = BuildTimeTargetLine(Entry.PreviewTimeTargetMs);
+					Entry.DeliverySourceLine =
+						TEXT("Delivery source: exact direct covered-case execution posture from the active session mode and covered case.");
+					Entry.PreviewStabilityLine =
+						TEXT("Preview stability: exact direct owned-case execution posture from covered-case launch.");
+					Entry.bHasExactDeliveryPreview = true;
+					Entry.bCanPreview = true;
+					++Surface.DirectExactOptionCount;
+					IncrementDeliveryModeCount(Entry.PreviewDeliveryMode);
+					IncrementRevealCounts(
+						Entry.bSupportsAlgorithmRevealOnExecute,
+						Entry.bRevealConfiguredByDeckPolicy,
+						Entry.bHasRevealNotation
+					);
+					IncrementTimeTargetCounts(Entry.bHasTimeTarget);
+				}
+				else
+				{
+					Entry.DeliveryModeLine = TEXT("Delivery mode on execute: unavailable");
+					Entry.RevealPostureLine = TEXT("Reveal posture on execute: unavailable");
+					Entry.TimeTargetLine = TEXT("Time target on execute: unavailable");
+					Entry.DeliverySourceLine =
+						TEXT("Delivery source: unavailable because the covered case could not be re-resolved from the active deck.");
+					Entry.PreviewStabilityLine = TEXT("Preview stability: unavailable");
+					Entry.bCanPreview = false;
+					++Surface.UnavailableOptionCount;
+				}
+				break;
+			}
+
+			case EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::
+				StoredRequestReusable:
+			case EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::
+				RefreshRequired:
+				if (SeedCase == nullptr)
+				{
+					Entry.DeliveryModeLine = TEXT("Delivery mode on execute: unavailable");
+					Entry.RevealPostureLine = TEXT("Reveal posture on execute: unavailable");
+					Entry.TimeTargetLine = TEXT("Time target on execute: unavailable");
+					Entry.DeliverySourceLine =
+						TEXT("Delivery source: unavailable because the active generated-mode surface has no structurally valid seed case.");
+					Entry.PreviewStabilityLine = TEXT("Preview stability: unavailable");
+					Entry.bCanPreview = false;
+					++Surface.UnavailableOptionCount;
+					break;
+				}
+
+				Entry.PreviewDeliveryMode = PreviewEntry.HypotheticalDeliveryMode;
+				Entry.PreviewDeliveryModeLabel = DescribeDeliveryMode(Entry.PreviewDeliveryMode);
+				Entry.DeliveryModeLine = BuildDeliveryModeLine(Entry.PreviewDeliveryMode);
+				Entry.bRevealConfiguredByDeckPolicy = false;
+				Entry.bHasRevealNotation = false;
+				Entry.bSupportsAlgorithmRevealOnExecute = false;
+				Entry.RevealPostureLine =
+					TEXT("Reveal posture on execute: disabled because generated owned execution clears canonical notation.");
+				Entry.PreviewTimeTargetMs = SeedCase->TimeTargetMs;
+				Entry.bHasTimeTarget = Entry.PreviewTimeTargetMs > 0;
+				Entry.TimeTargetLine = BuildTimeTargetLine(Entry.PreviewTimeTargetMs);
+				Entry.DeliverySourceLine =
+					TEXT("Delivery source: exact generated-mode owned execution posture from the selector payload and execute launch config.");
+				Entry.PreviewStabilityLine =
+					PreviewEntry.LaunchRequestPreviewKind
+						== EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::
+							StoredRequestReusable
+					? TEXT("Preview stability: exact while execute reuses the current stored request.")
+					: TEXT("Preview stability: exact even though execute still needs launch-request refresh.");
+				Entry.bHasExactDeliveryPreview = true;
+				Entry.bCanPreview = true;
+				++Surface.GeneratedExactOptionCount;
+				IncrementDeliveryModeCount(Entry.PreviewDeliveryMode);
+				IncrementRevealCounts(
+					Entry.bSupportsAlgorithmRevealOnExecute,
+					Entry.bRevealConfiguredByDeckPolicy,
+					Entry.bHasRevealNotation
+				);
+				IncrementTimeTargetCounts(Entry.bHasTimeTarget);
+				break;
+
+			case EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::
+				UnresolvedAfterChoice:
+				Entry.DeliveryModeLine =
+					TEXT("Delivery mode on execute: blocked until every required selector is resolved.");
+				Entry.RevealPostureLine =
+					TEXT("Reveal posture on execute: blocked until every required selector is resolved.");
+				Entry.TimeTargetLine =
+					TEXT("Time target on execute: blocked until every required selector is resolved.");
+				Entry.DeliverySourceLine =
+					TEXT("Delivery source: blocked while selector coverage remains incomplete.");
+				Entry.PreviewStabilityLine =
+					TEXT("Preview stability: blocked while selector coverage remains incomplete.");
+				Entry.bPreviewBlocked = true;
+				Entry.bCanPreview = true;
+				++Surface.BlockedOptionCount;
+				break;
+
+			case EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::
+				PayloadUnavailable:
+				Entry.DeliveryModeLine =
+					TEXT("Delivery mode on execute: blocked until a structurally valid launch payload can be derived.");
+				Entry.RevealPostureLine =
+					TEXT("Reveal posture on execute: blocked until a structurally valid launch payload can be derived.");
+				Entry.TimeTargetLine =
+					TEXT("Time target on execute: blocked until a structurally valid launch payload can be derived.");
+				Entry.DeliverySourceLine =
+					TEXT("Delivery source: blocked while the hypothetical generated-mode payload remains structurally invalid.");
+				Entry.PreviewStabilityLine =
+					TEXT("Preview stability: blocked while the hypothetical generated-mode payload remains structurally invalid.");
+				Entry.bPreviewBlocked = true;
+				Entry.bCanPreview = true;
+				++Surface.BlockedOptionCount;
+				break;
+
+			case EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::Unavailable:
+			case EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::None:
+			default:
+				Entry.DeliveryModeLine = TEXT("Delivery mode on execute: unavailable");
+				Entry.RevealPostureLine = TEXT("Reveal posture on execute: unavailable");
+				Entry.TimeTargetLine = TEXT("Time target on execute: unavailable");
+				Entry.DeliverySourceLine = TEXT("Delivery source: unavailable");
+				Entry.PreviewStabilityLine = TEXT("Preview stability: unavailable");
+				Entry.bCanPreview = false;
+				++Surface.UnavailableOptionCount;
+				break;
+		}
+
+		Entry.DetailLine = PreviewEntry.DetailLine.IsEmpty()
+			? Entry.PreviewStabilityLine
+			: FString::Printf(
+				TEXT("%s | %s"),
+				*Entry.PreviewStabilityLine,
+				*PreviewEntry.DetailLine
+			);
+
+		if (Entry.bMatchesCurrentSelection)
+		{
+			Surface.bCurrentSelectionHasExactDeliveryPreview =
+				Entry.bHasExactDeliveryPreview;
+			Surface.bCurrentSelectionSupportsAlgorithmRevealOnExecute =
+				Entry.bSupportsAlgorithmRevealOnExecute;
+			Surface.bCurrentSelectionHasRevealNotation = Entry.bHasRevealNotation;
+			Surface.bCurrentSelectionHasTimeTarget = Entry.bHasTimeTarget;
+			Surface.CurrentSelectionExecutionLine = FString::Printf(
+				TEXT("%s | %s | %s"),
+				*Entry.DeliveryModeLine,
+				*Entry.RevealPostureLine,
+				*Entry.TimeTargetLine
+			);
+		}
+
+		Surface.OptionEntries.Add(MoveTemp(Entry));
+	}
+
+	Surface.bHasOwnedExecutionDeliveryPreviewOptions = Surface.OptionEntries.Num() > 0;
+	Surface.bHasDirectDeliveryPreviewOptions = Surface.DirectExactOptionCount > 0;
+	Surface.bHasGeneratedDeliveryPreviewOptions = Surface.GeneratedExactOptionCount > 0;
+	Surface.bHasBlockedDeliveryPreviewOptions = Surface.BlockedOptionCount > 0;
+
+	Surface.DeliveryModeSummaryLine = Surface.OptionEntries.Num() > 0
+		? FString::Printf(
+			TEXT("Delivery mode: %d timer | %d virtual-cube | %d smart-device | %d recognition-assisted | %d coach-reviewed"),
+			Surface.TimerDeliveryOptionCount,
+			Surface.VirtualCubeDeliveryOptionCount,
+			Surface.SmartDeviceDeliveryOptionCount,
+			Surface.RecognitionAssistedDeliveryOptionCount,
+			Surface.CoachReviewedDeliveryOptionCount
+		)
+		: TEXT("Delivery mode: no imported options");
+	Surface.RevealPostureSummaryLine = Surface.OptionEntries.Num() > 0
+		? FString::Printf(
+			TEXT("Reveal posture: %d enabled | %d disabled | %d missing-notation | %d blocked | %d unavailable"),
+			Surface.RevealEnabledOptionCount,
+			Surface.RevealDisabledOptionCount,
+			Surface.MissingRevealNotationOptionCount,
+			Surface.BlockedOptionCount,
+			Surface.UnavailableOptionCount
+		)
+		: TEXT("Reveal posture: no imported options");
+	Surface.TimeTargetSummaryLine = Surface.OptionEntries.Num() > 0
+		? FString::Printf(
+			TEXT("Time target: %d targeted | %d untargeted | %d blocked | %d unavailable"),
+			Surface.TimedOptionCount,
+			Surface.UntargetedOptionCount,
+			Surface.BlockedOptionCount,
+			Surface.UnavailableOptionCount
+		)
+		: TEXT("Time target: no imported options");
+
+	if (Surface.CurrentSelectionExecutionLine.IsEmpty())
+	{
+		if (OptionMenuSurface.bHasUnresolvedSelectionDetail)
+		{
+			Surface.CurrentSelectionExecutionLine = OptionMenuSurface.UnresolvedSelectionLine;
+		}
+		else if (OptionMenuSurface.bHasSelection)
+		{
+			Surface.CurrentSelectionExecutionLine =
+				TEXT("Current selection has no additional owned-execution delivery preview.");
+		}
+		else if (OptionMenuSurface.bHasSelector)
+		{
+			Surface.CurrentSelectionExecutionLine = TEXT("Current selection: unresolved");
+		}
+		else
+		{
+			Surface.CurrentSelectionExecutionLine = TEXT("Current selection: n/a");
+		}
+	}
+
+	if (OptionMenuSurface.bHasSelector && Surface.OptionEntries.Num() > 0)
+	{
+		Surface.StatusLine = FString::Printf(
+			TEXT("Generated-mode selector option owned-execution delivery preview exposes %d direct-case exact option%s, %d generated exact option%s, %d blocked option%s, and %d unavailable option%s."),
+			Surface.DirectExactOptionCount,
+			Surface.DirectExactOptionCount == 1 ? TEXT("") : TEXT("s"),
+			Surface.GeneratedExactOptionCount,
+			Surface.GeneratedExactOptionCount == 1 ? TEXT("") : TEXT("s"),
+			Surface.BlockedOptionCount,
+			Surface.BlockedOptionCount == 1 ? TEXT("") : TEXT("s"),
+			Surface.UnavailableOptionCount,
+			Surface.UnavailableOptionCount == 1 ? TEXT("") : TEXT("s")
+		);
+	}
+	else if (OptionMenuSurface.bHasSelector)
+	{
+		Surface.StatusLine =
+			TEXT("Generated-mode selector option owned-execution delivery preview is active, but this selector does not expose imported options.");
+	}
+	else
+	{
+		Surface.StatusLine = OptionMenuSurface.StatusLine.IsEmpty()
+			? TEXT("Generated-mode selector option owned-execution delivery preview is not currently available.")
+			: OptionMenuSurface.StatusLine;
+	}
+
+	const FString SelectorSummary = Surface.SelectorLabel.IsEmpty()
+		? (Surface.SelectorId.IsEmpty() ? FString(TEXT("n/a")) : Surface.SelectorId)
+		: Surface.SelectorLabel;
+	const FString BindingSummary = Surface.BindingLabel.IsEmpty()
+		? FString(TEXT("n/a"))
+		: Surface.BindingLabel;
+	Surface.DetailLine = FString::Printf(
+		TEXT("Launch-request preview: %s | Selector: %s | Binding: %s"),
+		OptionLaunchRequestPreviewSurface.StatusLine.IsEmpty()
+			? TEXT("n/a")
+			: *OptionLaunchRequestPreviewSurface.StatusLine,
+		*SelectorSummary,
+		*BindingSummary
+	);
+
+	return Surface;
+}
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingPanelWidget.cpp
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingPanelWidget.cpp
@ -910,6 +910,25 @@ UHyperTwistTrainingPanelWidget::GetDisplayedCoachGeneratedModeSelectorOptionOwne
 		);
 }

+FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface
+UHyperTwistTrainingPanelWidget::GetDisplayedCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
+	const FString& SelectorId
+) const
+{
+	const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
+		GetDisplayedCoachGeneratedModeSelectorOptionMenuSurface(SelectorId);
+	const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
+		OptionLaunchRequestPreviewSurface =
+			GetDisplayedCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(SelectorId);
+	return UHyperTwistTrainingCoachLibrary::
+		DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
+			CachedRunState,
+			SelectorId,
+			OptionMenuSurface,
+			OptionLaunchRequestPreviewSurface
+		);
+}
+
 FHyperTwistTrainingRunState UHyperTwistTrainingPanelWidget::StartCoachRecommendedRun(
 	const int32 MaxCases,
 	const FString& StartActionSourceLabel
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSessionActor.cpp
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSessionActor.cpp
@ -891,6 +891,25 @@ AHyperTwistTrainingSessionActor::GetDisplayedCoachGeneratedModeSelectorOptionOwn
 		);
 }

+FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface
+AHyperTwistTrainingSessionActor::GetDisplayedCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
+	const FString& SelectorId
+) const
+{
+	const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
+		GetDisplayedCoachGeneratedModeSelectorOptionMenuSurface(SelectorId);
+	const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
+		OptionLaunchRequestPreviewSurface =
+			GetDisplayedCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(SelectorId);
+	return UHyperTwistTrainingCoachLibrary::
+		DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
+			CachedRunState,
+			SelectorId,
+			OptionMenuSurface,
+			OptionLaunchRequestPreviewSurface
+		);
+}
+
 FHyperTwistTrainingRunState AHyperTwistTrainingSessionActor::StartCoachRecommendedTrainingRun(
 	const int32 MaxCases
 )
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingCoachLibrary.h
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingCoachLibrary.h
@ -797,4 +797,14 @@ public:
 		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface&
 			OptionLaunchRequestPreviewSurface
 	);
+
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Coach")
+	static FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface
+	DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
+		const FHyperTwistTrainingRunState& RunState,
+		const FString& SelectorId,
+		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface& OptionMenuSurface,
+		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface&
+			OptionLaunchRequestPreviewSurface
+	);
 };
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingPanelWidget.h
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingPanelWidget.h
@ -308,6 +308,12 @@ public:
 		const FString& SelectorId
 	) const;

+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Coach")
+	FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface
+	GetDisplayedCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
+		const FString& SelectorId
+	) const;
+
 	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Coach")
 	FHyperTwistTrainingRunState StartCoachRecommendedRun(
 		int32 MaxCases,
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSessionActor.h
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSessionActor.h
@ -289,6 +289,12 @@ public:
 		const FString& SelectorId
 	) const;

+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Coach")
+	FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface
+	GetDisplayedCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
+		const FString& SelectorId
+	) const;
+
 	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Coach")
 	FHyperTwistTrainingRunState StartCoachRecommendedTrainingRun(int32 MaxCases);

--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h
@ -10476,3 +10476,206 @@ struct FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionPromptPr
 			|| bHasOwnedExecutionPromptPreviewOptions;
 	}
 };
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewEntrySurface
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString OptionId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Label;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString OptionValue;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind LaunchRequestPreviewKind =
+		EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::None;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString DeliveryModeLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString RevealPostureLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString TimeTargetLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString DeliverySourceLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PreviewStabilityLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString DetailLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	EHyperTwistTrainingDeliveryMode PreviewDeliveryMode = EHyperTwistTrainingDeliveryMode::Timer;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PreviewDeliveryModeLabel;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 PreviewTimeTargetMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bMatchesCurrentSelection = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bStartsOwnedCaseImmediately = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasExactDeliveryPreview = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bSupportsAlgorithmRevealOnExecute = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bRevealConfiguredByDeckPolicy = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasRevealNotation = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasTimeTarget = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bPreviewBlocked = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bCanPreview = false;
+
+	bool IsStructurallyValid() const
+	{
+		return !OptionId.IsEmpty()
+			|| !Label.IsEmpty()
+			|| !DeliveryModeLine.IsEmpty()
+			|| !RevealPostureLine.IsEmpty()
+			|| !TimeTargetLine.IsEmpty()
+			|| LaunchRequestPreviewKind
+				!= EHyperTwistTrainingCoachGeneratedModeOptionLaunchRequestPreviewKind::None
+			|| bCanPreview;
+	}
+};
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString SelectorId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString SelectorLabel;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString BindingLabel;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Headline;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString StatusLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString DeliveryModeSummaryLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString RevealPostureSummaryLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString TimeTargetSummaryLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString CurrentSelectionExecutionLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString DetailLine;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewEntrySurface>
+		OptionEntries;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 DirectExactOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 GeneratedExactOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 BlockedOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 UnavailableOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 TimerDeliveryOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 VirtualCubeDeliveryOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 SmartDeviceDeliveryOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 RecognitionAssistedDeliveryOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 CoachReviewedDeliveryOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 RevealEnabledOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 RevealDisabledOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 MissingRevealNotationOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 TimedOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 UntargetedOptionCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasSelector = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasOwnedExecutionDeliveryPreviewOptions = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasDirectDeliveryPreviewOptions = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasGeneratedDeliveryPreviewOptions = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasBlockedDeliveryPreviewOptions = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bCurrentSelectionHasExactDeliveryPreview = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bCurrentSelectionSupportsAlgorithmRevealOnExecute = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bCurrentSelectionHasRevealNotation = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bCurrentSelectionHasTimeTarget = false;
+
+	bool IsStructurallyValid() const
+	{
+		return !StatusLine.IsEmpty()
+			|| !SelectorId.IsEmpty()
+			|| OptionEntries.Num() > 0
+			|| bHasSelector
+			|| bHasOwnedExecutionDeliveryPreviewOptions;
+	}
+};
--- a/docs/HYPERTWIST_ROADMAP_OVERHAUL_EXPANSION_GUIDE.md
+++ b/docs/HYPERTWIST_ROADMAP_OVERHAUL_EXPANSION_GUIDE.md
@ -68,8 +68,8 @@ Current correction call from the source-exposed audit and current execution refr
  - the imported generated-mode gap is closed; request/config/selection plumbing and the bounded clean-room executor are already landed in first-party code
  - the latest landed bounded `Phase 4` packet closes the retained-idle comparison/outcome actionability gap at the end of the recognition-assisted coach-to-review continuity lane, and the final retained-surface confirmation pass now leaves that closure lane functionally complete
  - the retained idle widget surface now keeps retained comparison and decision history inspectable without continuing to advertise live launch or guidance-outcome actions once the coach-to-review loop has already collapsed to truthful closed-loop idle
-  - the latest landed bounded `Phase 4` packet stays on that same gameplay-facing consumer lane and adds one thin generated-mode selector option owned execution prompt-label / prompt-kind preview surface over the already-cached selector/runtime/request state, so gameplay/Blueprint callers can render exact direct-case prompt presentation and exact generated owned prompt composition for a chosen option without rebuilding generated deck composition rules directly
-  - the current next bounded packet is to expose one thin generated-mode selector option owned execution delivery-mode / reveal-posture / time-target preview surface on those same two consumer surfaces so gameplay/Blueprint callers can render the resulting owned execution modality and reveal posture for a chosen option without rebuilding generated deck composition rules directly
+  - the latest landed bounded `Phase 4` packet stays on that same gameplay-facing consumer lane and adds one thin generated-mode selector option owned execution delivery-mode / reveal-posture / time-target preview surface over the already-cached selector/runtime/request state, so gameplay/Blueprint callers can render exact direct-case delivery posture and exact generated owned execution modality, reveal posture, and target time for a chosen option without rebuilding generated deck composition rules directly
+  - the current next bounded packet is to expose one thin generated-mode selector option owned execution puzzle-id / subset-id / difficulty preview surface on those same two consumer surfaces so gameplay/Blueprint callers can render the resulting owned execution scope and difficulty posture for a chosen option without rebuilding generated deck composition rules directly
  - the current execution-discipline rule that broad refactor / monolith-splitting work should not interrupt the active bounded roadmap packet unless structure is actually blocking it

 ## Current execution-reality references
--- a/docs/arch/HYPERTWIST_PHASE4_GAMEPLAY_GENERATED_MODE_SELECTOR_OPTION_OWNED_EXECUTION_DELIVERY_MODE_REVEAL_POSTURE_TIME_TARGET_PREVIEW_SURFACE_PACKET_2026-05-08.md
+++ b/docs/arch/HYPERTWIST_PHASE4_GAMEPLAY_GENERATED_MODE_SELECTOR_OPTION_OWNED_EXECUTION_DELIVERY_MODE_REVEAL_POSTURE_TIME_TARGET_PREVIEW_SURFACE_PACKET_2026-05-08.md
@ -0,0 +1,102 @@
+# HyperTwist Phase 4 gameplay generated-mode selector option owned execution delivery-mode / reveal-posture / time-target preview surface packet
+
+Created on `2026-05-08`
+
+Status:
+
+- first-party HyperTwist packet
+- bounded Phase `4` gameplay-facing consumer slice
+
+## Purpose
+
+This packet closes the next thin gameplay-facing consumer seam above the panel-widget and session-actor generated-mode selector option owned execution prompt-label / prompt-kind preview surface by exposing one parameterized owned execution delivery-mode / reveal-posture / time-target preview surface for a chosen selector id.
+
+The open tasks were:
+
+- stop forcing gameplay / Blueprint callers to rebuild generated deck execution posture rules just to explain how a chosen imported option would actually run
+- expose exact direct covered-case delivery posture plus exact generated owned execution delivery mode, reveal posture, and time target whenever the generated-mode payload is previewable
+- keep the surface derived from already-cached gameplay consumer run, selector, and launch-request preview state instead of widening into backend logic
+
+It is not:
+
+- a selector-dispatch behavior change
+- a generated-mode launch-request persistence behavior change
+- a generated-mode execution deck synthesis change
+- a broader gameplay UI composition pass
+
+## Scope
+
+Bounded lane:
+
+- add first-party owned execution delivery preview surfaces in shared training types
+- add a coach-library helper that projects delivery mode, reveal posture, and time target over the already-landed launch-request preview surface
+- expose that parameterized delivery preview surface on `HyperTwistTrainingPanelWidget` and `HyperTwistTrainingSessionActor`
+- keep the derivation presentation-only and rooted in the already-owned selector/runtime/request surfaces
+
+Out of scope:
+
+- changing selector-choice apply behavior
+- changing stored launch-request creation, refresh, or execute behavior
+- changing generated-mode execution deck synthesis
+- widening into dashboard-only or broader gameplay composition work
+
+## Why this was the right next packet
+
+Before this slice:
+
+- gameplay-facing panel/session consumers already exposed truthful owned case identity, canonical-state, and prompt presentation preview for imported selector options
+- callers could tell which owned case target and prompt presentation would result from a chosen option
+
+But one thin consumer seam was still open:
+
+- callers still had to reconstruct delivery mode, reveal posture, and target-time behavior from direct covered-case launch rules, active session mode, and generated-mode execution deck synthesis rules if they wanted to explain how the resulting owned execution would actually run
+
+That meant:
+
+- target identity and prompt presentation were already thin and reusable
+- but concrete execution posture still leaked generated deck composition and direct launch rules into callers
+
+So the next bounded move was:
+
+- keep the already-landed owned execution case and prompt preview surfaces unchanged in behavior
+- reuse the already-cached launch-request preview surface to expose one narrow owned execution delivery preview surface above it
+
+## What landed
+
+Primary code changes:
+
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h`
+  - added `FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewEntrySurface`
+  - added `FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingCoachLibrary.h`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingCoachLibrary.cpp`
+  - added `DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(...)`
+  - delivery preview is derived from cached run state plus the already-landed launch-request preview surface
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingPanelWidget.h`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingPanelWidget.cpp`
+  - added `GetDisplayedCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(const FString& SelectorId)`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSessionActor.h`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSessionActor.cpp`
+  - added `GetDisplayedCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(const FString& SelectorId)`
+
+Surface behavior:
+
+- reports exact direct covered-case delivery posture from the active session mode plus the resolved covered case
+- reports exact generated owned execution delivery mode and seed-case time target whenever the chosen option yields a previewable generated-mode payload
+- reports truthful reveal posture, including the generated owned-execution rule that reveal is disabled because the synthetic case clears canonical notation
+- keeps unresolved or payload-invalid choices inspectable as blocked delivery-preview states instead of collapsing them into a generic unavailable branch
+- keeps the surface presentation-only and compatible with the already-landed launch / execution, request-alignment, stored-request delta, launch-request payload / refresh-preview, launch-request metadata / origin-notes preview, launch-request envelope / request-source preview, owned execution case / canonical-state preview, and owned execution prompt preview surfaces
+
+## Validation
+
+Validation target:
+
+- full `Development Editor|Win64` build of `C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.sln`
+
+Result:
+
+- passed with `0` warnings and `0` errors
+
+## Follow-on
+
+The next bounded packet on this same gameplay-facing consumer lane should stay thin and expose one generated-mode selector option owned execution puzzle-id / subset-id / difficulty preview surface so callers can render the resulting owned execution scope and difficulty posture for a chosen option without rebuilding generated deck composition rules directly.