Learn reliable accepted packet outcomes upstream

UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp

@@ -7373,6 +7373,47 @@ FHyperTwistCoachDashboardQueueRecoveryWeighting UHyperTwistCoachDashboardWidget:
 				1,
 				3)
 			: 0;
+	const int32 AcceptedAlignedTightPacketReliableOutcomeBias =
+		(CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount >= 2
+			&& CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
+				>= 68.0f)
+			? FMath::Clamp(
+				CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
+					- CachedCoachPanelState
+							.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+					+ (CachedCoachPanelState
+							   .AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
+						   >= 84.0f
+						? 1
+						: 0),
+				1,
+				4)
+			: 0;
+	const int32 AcceptedAlignedBroadPacketReliableOutcomeBias =
+		(CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+				>= 2
+			&& CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+				>= 66.0f)
+			? FMath::Clamp(
+				CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+					- CachedCoachPanelState
+							.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
+					+ (CachedCoachPanelState
+							   .AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+						   >= 82.0f
+						? 1
+						: 0),
+				1,
+				4)
+			: 0;
+	const int32 AcceptedAlignedTightPacketReliableCompositeBias =
+		FMath::Max(
+			AcceptedAlignedTightPacketReliableTrustBias,
+			AcceptedAlignedTightPacketReliableOutcomeBias);
+	const int32 AcceptedAlignedBroadPacketReliableCompositeBias =
+		FMath::Max(
+			AcceptedAlignedBroadPacketReliableTrustBias,
+			AcceptedAlignedBroadPacketReliableOutcomeBias);
 	if (AcceptedAlignedTightPacketOutcomeTrustBias > AcceptedAlignedBroadPacketOutcomeTrustBias)
 	{
 		HandoffHistoryBias.FollowUpScore += AcceptedAlignedTightPacketOutcomeTrustBias * 4;
@@ -7406,21 +7447,22 @@ FHyperTwistCoachDashboardQueueRecoveryWeighting UHyperTwistCoachDashboardWidget:
 			HandoffHistoryBias.QueueScore += AcceptedAlignedBroadPacketRetainedTrustBias;
 		}
 	}
-	if (AcceptedAlignedTightPacketReliableTrustBias > AcceptedAlignedBroadPacketReliableTrustBias)
+	if (AcceptedAlignedTightPacketReliableCompositeBias
+		> AcceptedAlignedBroadPacketReliableCompositeBias)
 	{
-		HandoffHistoryBias.FollowUpScore += AcceptedAlignedTightPacketReliableTrustBias * 4;
+		HandoffHistoryBias.FollowUpScore += AcceptedAlignedTightPacketReliableCompositeBias * 4;
 		if (bQueueLooksFollowUpOrRecovery)
 		{
-			HandoffHistoryBias.QueueScore += AcceptedAlignedTightPacketReliableTrustBias * 2;
+			HandoffHistoryBias.QueueScore += AcceptedAlignedTightPacketReliableCompositeBias * 2;
 		}
 	}
-	else if (AcceptedAlignedBroadPacketReliableTrustBias
-		> AcceptedAlignedTightPacketReliableTrustBias)
+	else if (AcceptedAlignedBroadPacketReliableCompositeBias
+		> AcceptedAlignedTightPacketReliableCompositeBias)
 	{
-		HandoffHistoryBias.RecommendedScore += AcceptedAlignedBroadPacketReliableTrustBias * 4;
+		HandoffHistoryBias.RecommendedScore += AcceptedAlignedBroadPacketReliableCompositeBias * 4;
 		if (bQueueLooksRecommendedOrPrimary)
 		{
-			HandoffHistoryBias.QueueScore += AcceptedAlignedBroadPacketReliableTrustBias * 2;
+			HandoffHistoryBias.QueueScore += AcceptedAlignedBroadPacketReliableCompositeBias * 2;
 		}
 	}
 	{
@@ -7457,14 +7499,16 @@ FHyperTwistCoachDashboardQueueRecoveryWeighting UHyperTwistCoachDashboardWidget:
 			HandoffHistoryBias.FollowUpAcceptedDeltaCount
 				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount
 				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount
-				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableHistoryCount);
+				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableHistoryCount
+				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount);
 		ConsiderKind(
 			HyperTwistCoachDashboardWidgetInternal::EHandoffRecommendationKind::Recommended,
 			HandoffHistoryBias.RecommendedScore,
 			HandoffHistoryBias.RecommendedAcceptedDeltaCount
 				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount
 				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount
-				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableHistoryCount);
+				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableHistoryCount
+				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount);
 	}
 	const HyperTwistCoachDashboardWidgetInternal::FMethodDrillRecoveryPacketDashboardBias
 		MethodDrillRecoveryPacketBias =
@@ -10156,6 +10200,47 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 				1,
 				3)
 			: 0;
+	const int32 AcceptedAlignedTightPacketReliableOutcomeBias =
+		(CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount >= 2
+			&& CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
+				>= 68.0f)
+			? FMath::Clamp(
+				CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
+					- CachedCoachPanelState
+							.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+					+ (CachedCoachPanelState
+							   .AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
+						   >= 84.0f
+						? 1
+						: 0),
+				1,
+				4)
+			: 0;
+	const int32 AcceptedAlignedBroadPacketReliableOutcomeBias =
+		(CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+				>= 2
+			&& CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+				>= 66.0f)
+			? FMath::Clamp(
+				CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+					- CachedCoachPanelState
+							.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
+					+ (CachedCoachPanelState
+							   .AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+						   >= 82.0f
+						? 1
+						: 0),
+				1,
+				4)
+			: 0;
+	const int32 AcceptedAlignedTightPacketReliableCompositeBias =
+		FMath::Max(
+			AcceptedAlignedTightPacketReliableTrustBias,
+			AcceptedAlignedTightPacketReliableOutcomeBias);
+	const int32 AcceptedAlignedBroadPacketReliableCompositeBias =
+		FMath::Max(
+			AcceptedAlignedBroadPacketReliableTrustBias,
+			AcceptedAlignedBroadPacketReliableOutcomeBias);
 	if (AcceptedAlignedTightPacketOutcomeTrustBias
 		> AcceptedAlignedBroadPacketOutcomeTrustBias)
 	{
@@ -10192,22 +10277,22 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 			HandoffHistoryBias.QueueScore += AcceptedAlignedBroadPacketRetainedTrustBias;
 		}
 	}
-	if (AcceptedAlignedTightPacketReliableTrustBias
-		> AcceptedAlignedBroadPacketReliableTrustBias)
+	if (AcceptedAlignedTightPacketReliableCompositeBias
+		> AcceptedAlignedBroadPacketReliableCompositeBias)
 	{
-		HandoffHistoryBias.FollowUpScore += AcceptedAlignedTightPacketReliableTrustBias * 4;
+		HandoffHistoryBias.FollowUpScore += AcceptedAlignedTightPacketReliableCompositeBias * 4;
 		if (bQueueReadyForHandoff && bQueueLooksFollowUpOrRecovery)
 		{
-			HandoffHistoryBias.QueueScore += AcceptedAlignedTightPacketReliableTrustBias * 2;
+			HandoffHistoryBias.QueueScore += AcceptedAlignedTightPacketReliableCompositeBias * 2;
 		}
 	}
-	else if (AcceptedAlignedBroadPacketReliableTrustBias
-		> AcceptedAlignedTightPacketReliableTrustBias)
+	else if (AcceptedAlignedBroadPacketReliableCompositeBias
+		> AcceptedAlignedTightPacketReliableCompositeBias)
 	{
-		HandoffHistoryBias.RecommendedScore += AcceptedAlignedBroadPacketReliableTrustBias * 4;
+		HandoffHistoryBias.RecommendedScore += AcceptedAlignedBroadPacketReliableCompositeBias * 4;
 		if (bQueueReadyForHandoff && bQueueLooksRecommendedOrPrimary)
 		{
-			HandoffHistoryBias.QueueScore += AcceptedAlignedBroadPacketReliableTrustBias * 2;
+			HandoffHistoryBias.QueueScore += AcceptedAlignedBroadPacketReliableCompositeBias * 2;
 		}
 	}
 	{
@@ -10244,14 +10329,16 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 			HandoffHistoryBias.FollowUpAcceptedDeltaCount
 				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount
 				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount
-				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableHistoryCount);
+				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableHistoryCount
+				+ CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount);
 		ConsiderKind(
 			HyperTwistCoachDashboardWidgetInternal::EHandoffRecommendationKind::Recommended,
 			HandoffHistoryBias.RecommendedScore,
 			HandoffHistoryBias.RecommendedAcceptedDeltaCount
 				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount
 				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount
-				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableHistoryCount);
+				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableHistoryCount
+				+ CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount);
 	}
 	bool bHandoffRecommendationUsedHistory = false;
 	bool bHandoffRecommendationUsedDeferredOverflowHistory = false;
@@ -11026,16 +11113,16 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 						== EHyperTwistTrainingCoachHandoffKind::Queue
 					&& bQueueLooksRecommendedOrPrimary));
 		bDisplayedCoachHandoffRecommendationUsedReliableAcceptedAlignedTightPacketOutcomeTrust =
-			AcceptedAlignedTightPacketReliableTrustBias
-				> AcceptedAlignedBroadPacketReliableTrustBias
+			AcceptedAlignedTightPacketReliableCompositeBias
+				> AcceptedAlignedBroadPacketReliableCompositeBias
 			&& (DisplayedCoachHandoffRecommendationKind
 					== EHyperTwistTrainingCoachHandoffKind::FollowUp
 				|| (DisplayedCoachHandoffRecommendationKind
 						== EHyperTwistTrainingCoachHandoffKind::Queue
 					&& bQueueLooksFollowUpOrRecovery));
 		bDisplayedCoachHandoffRecommendationUsedReliableAcceptedAlignedBroadPacketOutcomeTrust =
-			AcceptedAlignedBroadPacketReliableTrustBias
-				> AcceptedAlignedTightPacketReliableTrustBias
+			AcceptedAlignedBroadPacketReliableCompositeBias
+				> AcceptedAlignedTightPacketReliableCompositeBias
 			&& (DisplayedCoachHandoffRecommendationKind
 					== EHyperTwistTrainingCoachHandoffKind::Recommended
 				|| (DisplayedCoachHandoffRecommendationKind
@@ -11266,6 +11353,13 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 			CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableAverageOutcomeScore,
 			CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableAverageOutcomeScore
 		);
+		CoachHandoffRecommendationDetailLine += FString::Printf(
+			TEXT(" | reliable accepted packet launched-plan outcomes tight/broad %d/%d avg %.1f/%.1f"),
+			CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount,
+			CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount,
+			CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore,
+			CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+		);
 		if (HandoffHistoryBias.AlignedTightFollowUpOutcomeAcceptedDeltaCount > 0
 			&& HandoffHistoryBias.PreferredKind
 				== HyperTwistCoachDashboardWidgetInternal::EHandoffRecommendationKind::FollowUp)
@@ -11926,6 +12020,18 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 					: TEXT(""))
 		);
 	}
+	if (CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount > 0
+		|| CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+			> 0)
+	{
+		GuidancePreferenceDetailLine += FString::Printf(
+			TEXT(" | Reliable accepted aligned packet launched-plan outcomes: tight follow-up-first %d (avg %.2f) | broad recommended-first %d (avg %.2f)"),
+			CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount,
+			CachedCoachPanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore,
+			CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount,
+			CachedCoachPanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+		);
+	}
 	const bool bQueueRecoveryMemorySource =
 		HyperTwistCoachDashboardWidgetInternal::IsQueueRecoveryMemorySource(
 			CachedCoachPanelState.PreferredGuidanceSourceLabel);

UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRepositoryLibrary.cpp

@@ -504,6 +504,23 @@ namespace HyperTwistTrainingRepositoryLibraryInternal
 				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-"));
 	}
 
+	bool IsReliableAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(const FString& SourceLabel)
+	{
+		return SourceLabel.StartsWith(
+				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-"))
+			|| SourceLabel.StartsWith(
+				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-reliable-"));
+	}
+
+	bool IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
+		const FString& SourceLabel)
+	{
+		return SourceLabel.StartsWith(
+				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-"))
+			|| SourceLabel.StartsWith(
+				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-reliable-"));
+	}
+
 	FString ResolveMethodDrillFollowUpPacketStructureRecoverySourceLabel(
 		const FString& PreferredCoachHandoffSourceLabel,
 		const FString& PreferredGuidanceSourceLabel)
@@ -7915,6 +7932,14 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustOutcomeAverageScore;
 		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore =
 			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore;
+		Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount =
+			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount;
+		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount =
+			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount;
+		Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore =
+			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore;
+		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore =
+			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore;
 		Snapshot.bHasRepeatRecommendationPressure = RecommendationHistory.bHasRepeatRecommendationPressure;
 		const int32 DeferredTightenedLaunchBias = FMath::Clamp(
 			RecommendationHistory.DeferredTightenedLaunchPlanCount,
@@ -9666,6 +9691,45 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 						1,
 						3)
 					: 0;
+			const int32 AcceptedAlignedTightPacketReliableOutcomeSignal =
+				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount >= 2
+					&& Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
+						>= 68.0f)
+					? FMath::Clamp(
+						Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
+							- Snapshot
+									.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+							+ (Snapshot
+									   .AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
+								   >= 84.0f
+								? 1
+								: 0),
+						1,
+						4)
+					: 0;
+			const int32 AcceptedAlignedBroadPacketReliableOutcomeSignal =
+				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount >= 2
+					&& Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+						>= 66.0f)
+					? FMath::Clamp(
+						Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+							- Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
+							+ (Snapshot
+									   .AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+								   >= 82.0f
+								? 1
+								: 0),
+						1,
+						4)
+					: 0;
+			const int32 AcceptedAlignedTightPacketReliableCompositeSignal =
+				FMath::Max(
+					AcceptedAlignedTightPacketReliableTrustSignal,
+					AcceptedAlignedTightPacketReliableOutcomeSignal);
+			const int32 AcceptedAlignedBroadPacketReliableCompositeSignal =
+				FMath::Max(
+					AcceptedAlignedBroadPacketReliableTrustSignal,
+					AcceptedAlignedBroadPacketReliableOutcomeSignal);
 			if (AcceptedAlignedTightPacketOutcomeTrustSignal
 				> AcceptedAlignedBroadPacketOutcomeTrustSignal)
 			{
@@ -9798,15 +9862,17 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-recommended");
 				}
 			}
-			if (AcceptedAlignedTightPacketReliableTrustSignal
-				> AcceptedAlignedBroadPacketReliableTrustSignal)
+			if (AcceptedAlignedTightPacketReliableCompositeSignal
+				> AcceptedAlignedBroadPacketReliableCompositeSignal)
 			{
-				Snapshot.FollowUpGuidanceContinueBias += AcceptedAlignedTightPacketReliableTrustSignal;
+				Snapshot.FollowUpGuidanceContinueBias +=
+					AcceptedAlignedTightPacketReliableCompositeSignal;
 				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
 					1,
-					AcceptedAlignedTightPacketReliableTrustSignal - 1);
+					AcceptedAlignedTightPacketReliableCompositeSignal - 1);
 				ExplicitFollowUpHandoffSignal = FMath::Clamp(
-					ExplicitFollowUpHandoffSignal + (AcceptedAlignedTightPacketReliableTrustSignal * 2),
+					ExplicitFollowUpHandoffSignal
+						+ (AcceptedAlignedTightPacketReliableCompositeSignal * 2),
 					0,
 					6);
 				if (QueueExecutionSummary.bHasOutstandingDeferredWork
@@ -9835,15 +9901,16 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 							true);
 				}
 			}
-			else if (AcceptedAlignedBroadPacketReliableTrustSignal
-				> AcceptedAlignedTightPacketReliableTrustSignal)
+			else if (AcceptedAlignedBroadPacketReliableCompositeSignal
+				> AcceptedAlignedTightPacketReliableCompositeSignal)
 			{
-				Snapshot.RecommendedGuidanceContinueBias += AcceptedAlignedBroadPacketReliableTrustSignal;
+				Snapshot.RecommendedGuidanceContinueBias +=
+					AcceptedAlignedBroadPacketReliableCompositeSignal;
 				Snapshot.SuppressedFollowUpQueuePressureCount +=
-					AcceptedAlignedBroadPacketReliableTrustSignal;
+					AcceptedAlignedBroadPacketReliableCompositeSignal;
 				ExplicitRecommendedHandoffSignal = FMath::Clamp(
 					ExplicitRecommendedHandoffSignal
-						+ (AcceptedAlignedBroadPacketReliableTrustSignal * 2),
+						+ (AcceptedAlignedBroadPacketReliableCompositeSignal * 2),
 					0,
 					6);
 				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
@@ -10044,8 +10111,8 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
 								EHyperTwistTrainingCoachHandoffKind::Queue,
 								true,
-								AcceptedAlignedTightPacketReliableTrustSignal
-									> AcceptedAlignedBroadPacketReliableTrustSignal);
+								AcceptedAlignedTightPacketReliableCompositeSignal
+									> AcceptedAlignedBroadPacketReliableCompositeSignal);
 					}
 					else if (AcceptedAlignedBroadPacketOutcomeTrustSignal
 							> AcceptedAlignedTightPacketOutcomeTrustSignal)
@@ -10054,8 +10121,8 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
 								EHyperTwistTrainingCoachHandoffKind::Queue,
 								false,
-								AcceptedAlignedBroadPacketReliableTrustSignal
-									> AcceptedAlignedTightPacketReliableTrustSignal);
+								AcceptedAlignedBroadPacketReliableCompositeSignal
+									> AcceptedAlignedTightPacketReliableCompositeSignal);
 					}
 					else if (bAlignedTightFollowUpPacketQueuedHandoff)
 					{
@@ -10135,8 +10202,8 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
 								EHyperTwistTrainingCoachHandoffKind::FollowUp,
 								true,
-								AcceptedAlignedTightPacketReliableTrustSignal
-									> AcceptedAlignedBroadPacketReliableTrustSignal);
+								AcceptedAlignedTightPacketReliableCompositeSignal
+									> AcceptedAlignedBroadPacketReliableCompositeSignal);
 					}
 					else if (AcceptedAlignedBroadPacketOutcomeTrustSignal
 							> AcceptedAlignedTightPacketOutcomeTrustSignal)
@@ -10145,8 +10212,8 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
 								EHyperTwistTrainingCoachHandoffKind::FollowUp,
 								false,
-								AcceptedAlignedBroadPacketReliableTrustSignal
-									> AcceptedAlignedTightPacketReliableTrustSignal);
+								AcceptedAlignedBroadPacketReliableCompositeSignal
+									> AcceptedAlignedTightPacketReliableCompositeSignal);
 					}
 					else if (bAlignedTightFollowUpPacketFollowUpHandoff)
 					{
@@ -10226,8 +10293,8 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
 								EHyperTwistTrainingCoachHandoffKind::Recommended,
 								true,
-								AcceptedAlignedTightPacketReliableTrustSignal
-									> AcceptedAlignedBroadPacketReliableTrustSignal);
+								AcceptedAlignedTightPacketReliableCompositeSignal
+									> AcceptedAlignedBroadPacketReliableCompositeSignal);
 					}
 					else if (AcceptedAlignedBroadPacketOutcomeTrustSignal
 							> AcceptedAlignedTightPacketOutcomeTrustSignal)
@@ -10236,8 +10303,8 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
 								EHyperTwistTrainingCoachHandoffKind::Recommended,
 								false,
-								AcceptedAlignedBroadPacketReliableTrustSignal
-									> AcceptedAlignedTightPacketReliableTrustSignal);
+								AcceptedAlignedBroadPacketReliableCompositeSignal
+									> AcceptedAlignedTightPacketReliableCompositeSignal);
 					}
 					else if (bAlignedTightFollowUpPacketRecommendedHandoff)
 					{
@@ -10750,8 +10817,8 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 						? HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
 							EHyperTwistTrainingCoachHandoffKind::FollowUp,
 							true,
-							AcceptedAlignedTightPacketReliableTrustSignal
-								> AcceptedAlignedBroadPacketReliableTrustSignal)
+							AcceptedAlignedTightPacketReliableCompositeSignal
+								> AcceptedAlignedBroadPacketReliableCompositeSignal)
 						: HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
 							EHyperTwistTrainingCoachHandoffKind::FollowUp,
 							ExplicitDeferredOverflowFollowUpHandoffSignal > 0,
@@ -10772,8 +10839,8 @@ FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::Der
 						? HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
 							EHyperTwistTrainingCoachHandoffKind::Recommended,
 							false,
-							AcceptedAlignedBroadPacketReliableTrustSignal
-								> AcceptedAlignedTightPacketReliableTrustSignal)
+							AcceptedAlignedBroadPacketReliableCompositeSignal
+								> AcceptedAlignedTightPacketReliableCompositeSignal)
 						: HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
 							EHyperTwistTrainingCoachHandoffKind::Recommended,
 							ExplicitDeferredOverflowRecommendedHandoffSignal > 0
@@ -14135,6 +14202,8 @@ FHyperTwistTrainingCoachRecommendationHistorySummary UHyperTwistTrainingReposito
 	float AcceptedAlignedBroadRecommendedPacketOutcomeAccumulator = 0.0f;
 	float AcceptedAlignedTightFollowUpPacketTrustOutcomeAccumulator = 0.0f;
 	float AcceptedAlignedBroadRecommendedPacketTrustOutcomeAccumulator = 0.0f;
+	float AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAccumulator = 0.0f;
+	float AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAccumulator = 0.0f;
 	FString LatestPlanSortUtc;
 
 	for (const FHyperTwistTrainingCoachActionPlan& Plan : UserPlans)
@@ -14381,6 +14450,20 @@ FHyperTwistTrainingCoachRecommendationHistorySummary UHyperTwistTrainingReposito
 				Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount += 1;
 				AcceptedAlignedBroadRecommendedPacketTrustOutcomeAccumulator += OutcomeSummary.OutcomeScore;
 			}
+			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
+					OutcomeSummary.PreferredCoachHandoffSourceLabel))
+			{
+				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount += 1;
+				AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAccumulator +=
+					OutcomeSummary.OutcomeScore;
+			}
+			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
+					OutcomeSummary.PreferredCoachHandoffSourceLabel))
+			{
+				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount += 1;
+				AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAccumulator +=
+					OutcomeSummary.OutcomeScore;
+			}
 			if (OutcomeSummary.PlannedLaunchCaseCount > 0)
 			{
 				PlannedLaunchCaseCountAccumulator +=
@@ -14591,6 +14674,20 @@ FHyperTwistTrainingCoachRecommendationHistorySummary UHyperTwistTrainingReposito
 			/ static_cast<float>(
 				Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount);
 	}
+	if (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount > 0)
+	{
+		Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore =
+			AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAccumulator
+			/ static_cast<float>(
+				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount);
+	}
+	if (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount > 0)
+	{
+		Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore =
+			AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAccumulator
+			/ static_cast<float>(
+				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount);
+	}
 	const int32 AcceptedAlignedTightPacketOutcomeLaneSignal =
 		(Summary.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount >= 2
 			&& Summary.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore >= 60.0f)
@@ -14635,6 +14732,32 @@ FHyperTwistTrainingCoachRecommendationHistorySummary UHyperTwistTrainingReposito
 				1,
 				3)
 			: 0;
+	const int32 AcceptedAlignedTightPacketReliableOutcomeLaneSignal =
+		(Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount >= 2
+			&& Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore >= 68.0f)
+			? FMath::Clamp(
+				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
+					- Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+					+ (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
+							>= 84.0f
+						? 1
+						: 0),
+				1,
+				4)
+			: 0;
+	const int32 AcceptedAlignedBroadPacketReliableOutcomeLaneSignal =
+		(Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount >= 2
+			&& Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore >= 66.0f)
+			? FMath::Clamp(
+				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
+					- Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
+					+ (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
+							>= 82.0f
+						? 1
+						: 0),
+				1,
+				4)
+			: 0;
 	if (AcceptedAlignedTightPacketOutcomeLaneSignal > AcceptedAlignedBroadPacketOutcomeLaneSignal)
 	{
 		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
@@ -14681,6 +14804,32 @@ FHyperTwistTrainingCoachRecommendationHistorySummary UHyperTwistTrainingReposito
 			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
 		}
 	}
+	if (AcceptedAlignedTightPacketReliableOutcomeLaneSignal
+		> AcceptedAlignedBroadPacketReliableOutcomeLaneSignal)
+	{
+		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
+			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
+		{
+			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
+		}
+		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
+		Summary.FollowUpLaneContinueBias += AcceptedAlignedTightPacketReliableOutcomeLaneSignal;
+	}
+	else if (AcceptedAlignedBroadPacketReliableOutcomeLaneSignal
+		> AcceptedAlignedTightPacketReliableOutcomeLaneSignal)
+	{
+		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
+			&& Summary.EscalatedSequenceCount == 0
+			&& Summary.FollowUpReadySequenceCount == 0)
+		{
+			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
+		}
+		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
+		{
+			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
+		}
+		Summary.RecommendedLaneContinueBias += AcceptedAlignedBroadPacketReliableOutcomeLaneSignal;
+	}
 	Summary.bHasRepeatRecommendationPressure =
 		Summary.RepeatRecommendationSequenceCount > 0
 		&& (Summary.RecurringCaseCount > 0

UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp

@@ -896,6 +896,14 @@ FHyperTwistTrainingCoachPanelState UHyperTwistTrainingSubsystem::GetActiveCoachP
 		ActiveCoachMemorySnapshot.AcceptedAlignedTightFollowUpPacketTrustReliableAverageOutcomeScore;
 	PanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableAverageOutcomeScore =
 		ActiveCoachMemorySnapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableAverageOutcomeScore;
+	PanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount =
+		ActiveCoachMemorySnapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount;
+	PanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount =
+		ActiveCoachMemorySnapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount;
+	PanelState.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore =
+		ActiveCoachMemorySnapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore;
+	PanelState.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore =
+		ActiveCoachMemorySnapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore;
 	PanelState.bRepositoryVerificationPassed = ActiveRepositoryRoundTripVerification.bDidRoundTripPass;
 	PanelState.bRepositoryVerificationNeedsAttention = ActiveRepositoryRoundTripVerification.ResolvedPath.IsEmpty()
 		|| !ActiveRepositoryRoundTripVerification.bDidRoundTripPass;

UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h

@@ -2079,6 +2079,18 @@ struct FHyperTwistTrainingCoachMemorySnapshot
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	float AcceptedAlignedBroadRecommendedPacketTrustReliableAverageOutcomeScore = 0.0f;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	float AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore = 0.0f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	float AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore = 0.0f;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	bool bNeedsCoachIntervention = false;
 
@@ -4657,6 +4669,18 @@ struct FHyperTwistTrainingCoachRecommendationHistorySummary
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	float AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore = 0.0f;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	float AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore = 0.0f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	float AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore = 0.0f;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	TArray<FString> RecurringCaseIds;
 
@@ -5368,6 +5392,18 @@ struct FHyperTwistTrainingCoachPanelState
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	float AcceptedAlignedBroadRecommendedPacketTrustReliableAverageOutcomeScore = 0.0f;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	float AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore = 0.0f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	float AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore = 0.0f;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	int32 SignalCount = 0;