diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp index 67aab76..64ebf91 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp @@ -6475,6 +6475,18 @@ FHyperTwistCoachDashboardDecisionWeighting UHyperTwistCoachDashboardWidget::Buil } constexpr int32 MaxMatchedDecisionEntries = 6; + Weighting.ReliableAlignedTrustedTightPlanOutcomeHistoryCount = + CachedCoachPanelState + .ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount; + Weighting.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount = + CachedCoachPanelState + .ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount; + Weighting.ReliableAlignedTrustedTightPlanOutcomeAverageScore = + CachedCoachPanelState + .ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore; + Weighting.ReliableAlignedTrustedBroadPlanOutcomeAverageScore = + CachedCoachPanelState + .ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore; for (int32 Index = GuidanceDecisionHistoryEntries.Num() - 1; Index >= 0 && Weighting.MatchingDecisionCount < MaxMatchedDecisionEntries; --Index) @@ -6510,19 +6522,39 @@ FHyperTwistCoachDashboardDecisionWeighting UHyperTwistCoachDashboardWidget::Buil ++Weighting.TightenedLaunchCount; Weighting.TightenedLaunchAverageSuccessRate += Entry.SuccessRate; } + const bool bEntryUsesReliableAlignedTrustedTightPlanOutcomeHistory = + Entry.bUsedReliableAlignedTrustedTightPlanOutcomeHistory; + const bool bEntryUsesReliableAlignedTrustedBroadPlanOutcomeHistory = + Entry.bUsedReliableAlignedTrustedBroadPlanOutcomeHistory; switch (Entry.AppliedAction) { case EHyperTwistCoachDashboardOutcomeAction::RepeatSelectedCase: + if (bEntryUsesReliableAlignedTrustedTightPlanOutcomeHistory) + { + ++Weighting.ReliableAlignedTrustedTightContinuationDecisionCount; + } ++Weighting.RepeatSelectedCaseCount; break; case EHyperTwistCoachDashboardOutcomeAction::RepeatPreviewDeck: + if (bEntryUsesReliableAlignedTrustedTightPlanOutcomeHistory) + { + ++Weighting.ReliableAlignedTrustedTightContinuationDecisionCount; + } ++Weighting.RepeatPreviewDeckCount; break; case EHyperTwistCoachDashboardOutcomeAction::BroadenPreviewDeck: + if (bEntryUsesReliableAlignedTrustedBroadPlanOutcomeHistory) + { + ++Weighting.ReliableAlignedTrustedBroadRedirectDecisionCount; + } ++Weighting.BroadenPreviewDeckCount; break; case EHyperTwistCoachDashboardOutcomeAction::RedirectCoachGuidance: + if (bEntryUsesReliableAlignedTrustedBroadPlanOutcomeHistory) + { + ++Weighting.ReliableAlignedTrustedBroadRedirectDecisionCount; + } ++Weighting.RedirectCoachGuidanceCount; break; default: @@ -6564,9 +6596,51 @@ FHyperTwistCoachDashboardDecisionWeighting UHyperTwistCoachDashboardWidget::Buil Weighting.DeferredOverflowCaseCount = CachedCoachPanelState.DeferredLaunchHistoryCaseCount; } + const int32 ReliableAlignedTrustedTightPlanOutcomeSignalScore = + (Weighting.ReliableAlignedTrustedTightPlanOutcomeHistoryCount >= 2 + && Weighting.ReliableAlignedTrustedTightPlanOutcomeAverageScore >= 60.0f) + ? FMath::Clamp( + Weighting.ReliableAlignedTrustedTightPlanOutcomeHistoryCount + - Weighting.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount + + Weighting.ReliableAlignedTrustedTightContinuationDecisionCount + - Weighting.ReliableAlignedTrustedBroadRedirectDecisionCount + + (Weighting.ReliableAlignedTrustedTightPlanOutcomeAverageScore >= 80.0f ? 1 : 0), + 1, + 5) + : 0; + const int32 ReliableAlignedTrustedBroadPlanOutcomeSignalScore = + (Weighting.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount >= 2 + && Weighting.ReliableAlignedTrustedBroadPlanOutcomeAverageScore >= 58.0f) + ? FMath::Clamp( + Weighting.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount + - Weighting.ReliableAlignedTrustedTightPlanOutcomeHistoryCount + + Weighting.ReliableAlignedTrustedBroadRedirectDecisionCount + - Weighting.ReliableAlignedTrustedTightContinuationDecisionCount + + (Weighting.ReliableAlignedTrustedBroadPlanOutcomeAverageScore >= 78.0f ? 1 : 0), + 1, + 5) + : 0; if (bDisplayedGuidanceComparisonSingleCase) { + if (BaseAction == EHyperTwistCoachDashboardOutcomeAction::BroadenPreviewDeck + && ReliableAlignedTrustedTightPlanOutcomeSignalScore + > ReliableAlignedTrustedBroadPlanOutcomeSignalScore + && Weighting.AverageSuccessRate < 0.95f) + { + Weighting.WeightedAction = EHyperTwistCoachDashboardOutcomeAction::RepeatSelectedCase; + Weighting.bHasOverride = true; + Weighting.bUsedReliableAlignedPlanOutcomeSignal = true; + } + else if (BaseAction == EHyperTwistCoachDashboardOutcomeAction::RepeatSelectedCase + && ReliableAlignedTrustedBroadPlanOutcomeSignalScore + > ReliableAlignedTrustedTightPlanOutcomeSignalScore + && Weighting.AverageSuccessRate >= 0.70f) + { + Weighting.WeightedAction = EHyperTwistCoachDashboardOutcomeAction::BroadenPreviewDeck; + Weighting.bHasOverride = true; + Weighting.bUsedReliableAlignedPlanOutcomeSignal = true; + } if (BaseAction == EHyperTwistCoachDashboardOutcomeAction::BroadenPreviewDeck && Weighting.RepeatSelectedCaseCount >= 2 && Weighting.AverageSuccessRate < 0.90f) @@ -6602,6 +6676,24 @@ FHyperTwistCoachDashboardDecisionWeighting UHyperTwistCoachDashboardWidget::Buil } else { + if (BaseAction == EHyperTwistCoachDashboardOutcomeAction::RedirectCoachGuidance + && ReliableAlignedTrustedTightPlanOutcomeSignalScore + > ReliableAlignedTrustedBroadPlanOutcomeSignalScore + && Weighting.AverageSuccessRate < 0.92f) + { + Weighting.WeightedAction = EHyperTwistCoachDashboardOutcomeAction::RepeatPreviewDeck; + Weighting.bHasOverride = true; + Weighting.bUsedReliableAlignedPlanOutcomeSignal = true; + } + else if (BaseAction == EHyperTwistCoachDashboardOutcomeAction::RepeatPreviewDeck + && ReliableAlignedTrustedBroadPlanOutcomeSignalScore + > ReliableAlignedTrustedTightPlanOutcomeSignalScore + && Weighting.AverageSuccessRate >= 0.68f) + { + Weighting.WeightedAction = EHyperTwistCoachDashboardOutcomeAction::RedirectCoachGuidance; + Weighting.bHasOverride = true; + Weighting.bUsedReliableAlignedPlanOutcomeSignal = true; + } if (BaseAction == EHyperTwistCoachDashboardOutcomeAction::RedirectCoachGuidance && Weighting.RepeatPreviewDeckCount >= 2 && Weighting.AverageSuccessRate < 0.80f) @@ -6707,6 +6799,18 @@ FHyperTwistCoachDashboardGuidanceLanePreference UHyperTwistCoachDashboardWidget: float RecommendedSuccessRateSum = 0.0f; float FollowUpSuccessRateSum = 0.0f; + Preference.ReliableAlignedTrustedTightPlanOutcomeHistoryCount = + CachedCoachPanelState + .ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount; + Preference.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount = + CachedCoachPanelState + .ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount; + Preference.ReliableAlignedTrustedTightPlanOutcomeAverageScore = + CachedCoachPanelState + .ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore; + Preference.ReliableAlignedTrustedBroadPlanOutcomeAverageScore = + CachedCoachPanelState + .ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore; constexpr int32 MaxDecisionEntriesToInspect = 8; int32 InspectedDecisionEntries = 0; for (int32 Index = GuidanceDecisionHistoryEntries.Num() - 1; @@ -6731,6 +6835,11 @@ FHyperTwistCoachDashboardGuidanceLanePreference UHyperTwistCoachDashboardWidget: default: break; } + if (Entry.bUsedReliableAlignedTrustedBroadPlanOutcomeHistory) + { + ++Preference.ReliableAlignedTrustedBroadRedirectBias; + ++Preference.RecommendedContinueBias; + } ++InspectedDecisionEntries; } else if (Entry.GuidanceLane == EHyperTwistCoachDashboardGuidancePreviewLane::FollowUp) @@ -6750,6 +6859,11 @@ FHyperTwistCoachDashboardGuidanceLanePreference UHyperTwistCoachDashboardWidget: default: break; } + if (Entry.bUsedReliableAlignedTrustedTightPlanOutcomeHistory) + { + ++Preference.ReliableAlignedTrustedTightContinuationBias; + ++Preference.FollowUpContinueBias; + } ++InspectedDecisionEntries; } } @@ -6764,6 +6878,50 @@ FHyperTwistCoachDashboardGuidanceLanePreference UHyperTwistCoachDashboardWidget: Preference.FollowUpAverageSuccessRate = FollowUpSuccessRateSum / static_cast(Preference.FollowUpDecisionCount); } + const int32 ReliableAlignedTrustedTightPlanOutcomeSignalScore = + (Preference.ReliableAlignedTrustedTightPlanOutcomeHistoryCount >= 2 + && Preference.ReliableAlignedTrustedTightPlanOutcomeAverageScore >= 60.0f) + ? FMath::Clamp( + Preference.ReliableAlignedTrustedTightPlanOutcomeHistoryCount + - Preference.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount + + (Preference.ReliableAlignedTrustedTightPlanOutcomeAverageScore >= 80.0f ? 1 : 0), + 1, + 4) + : 0; + const int32 ReliableAlignedTrustedBroadPlanOutcomeSignalScore = + (Preference.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount >= 2 + && Preference.ReliableAlignedTrustedBroadPlanOutcomeAverageScore >= 58.0f) + ? FMath::Clamp( + Preference.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount + - Preference.ReliableAlignedTrustedTightPlanOutcomeHistoryCount + + (Preference.ReliableAlignedTrustedBroadPlanOutcomeAverageScore >= 78.0f ? 1 : 0), + 1, + 4) + : 0; + if (ReliableAlignedTrustedTightPlanOutcomeSignalScore + > ReliableAlignedTrustedBroadPlanOutcomeSignalScore) + { + Preference.ReliableAlignedTrustedTightContinuationBias = + Preference.ReliableAlignedTrustedTightContinuationBias + + ReliableAlignedTrustedTightPlanOutcomeSignalScore; + Preference.FollowUpContinueBias += ReliableAlignedTrustedTightPlanOutcomeSignalScore; + Preference.bHasReliableAlignedPlanOutcomeSignal = true; + } + else if (ReliableAlignedTrustedBroadPlanOutcomeSignalScore + > ReliableAlignedTrustedTightPlanOutcomeSignalScore) + { + Preference.ReliableAlignedTrustedBroadRedirectBias = + Preference.ReliableAlignedTrustedBroadRedirectBias + + ReliableAlignedTrustedBroadPlanOutcomeSignalScore; + Preference.RecommendedContinueBias += ReliableAlignedTrustedBroadPlanOutcomeSignalScore; + Preference.bHasReliableAlignedPlanOutcomeSignal = true; + } + if (!Preference.bHasReliableAlignedPlanOutcomeSignal) + { + Preference.bHasReliableAlignedPlanOutcomeSignal = + Preference.ReliableAlignedTrustedTightContinuationBias > 0 + || Preference.ReliableAlignedTrustedBroadRedirectBias > 0; + } const HyperTwistCoachDashboardWidgetInternal::FClosureRecoveryDashboardBias ClosureBias = HyperTwistCoachDashboardWidgetInternal::DeriveClosureRecoveryDashboardBias( @@ -7712,6 +7870,28 @@ void UHyperTwistCoachDashboardWidget::RecordGuidanceOutcomeDecision( : (Entry.bTightenedLaunchScope ? TEXT("launch scope stayed tighter than the comparison context") : TEXT("launch scope stayed aligned with the comparison context"))); + Entry.ReliableAlignedTrustedTightPlanOutcomeHistoryCount = + CachedCoachPanelState + .ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount; + Entry.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount = + CachedCoachPanelState + .ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount; + Entry.ReliableAlignedTrustedTightPlanOutcomeAverageScore = + CachedCoachPanelState + .ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore; + Entry.ReliableAlignedTrustedBroadPlanOutcomeAverageScore = + CachedCoachPanelState + .ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore; + Entry.bUsedReliableAlignedTrustedTightPlanOutcomeHistory = + CachedCoachPanelState.PreferredGuidanceSourceLabel + == TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-outcome") + || CachedCoachPanelState.PreferredCoachHandoffSourceLabel + == TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-outcome"); + Entry.bUsedReliableAlignedTrustedBroadPlanOutcomeHistory = + CachedCoachPanelState.PreferredGuidanceSourceLabel + == TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-outcome") + || CachedCoachPanelState.PreferredCoachHandoffSourceLabel + == TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-outcome"); if (Entry.IsStructurallyValid()) { @@ -10715,16 +10895,33 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation() : (GuidanceLanePreference.PreferredLane == EHyperTwistCoachDashboardGuidancePreviewLane::FollowUp ? TEXT("follow-up") : TEXT("none")); - const FString GuidancePreferenceSourceLabel = GuidanceLanePreference.bHasDecisionSignal - ? (GuidanceLanePreference.bHasClosureHistorySignal - ? TEXT("decision + closure-history") - : TEXT("decision-informed")) - : (GuidanceLanePreference.bHasClosureHistorySignal - ? TEXT("closure-history + memory") - : (CachedCoachPanelState.PreferredGuidanceSourceLabel.IsEmpty() + const FString GuidancePreferenceSourceLabel = [&]() -> FString + { + if (GuidanceLanePreference.bHasDecisionSignal) + { + if (GuidanceLanePreference.bHasReliableAlignedPlanOutcomeSignal) + { + return GuidanceLanePreference.bHasClosureHistorySignal + ? TEXT("decision + closure-history + aligned-plan-outcome") + : TEXT("decision + aligned-plan-outcome"); + } + return GuidanceLanePreference.bHasClosureHistorySignal + ? TEXT("decision + closure-history") + : TEXT("decision-informed"); + } + if (GuidanceLanePreference.bHasReliableAlignedPlanOutcomeSignal) + { + return TEXT("aligned-plan-outcome + memory"); + } + if (GuidanceLanePreference.bHasClosureHistorySignal) + { + return TEXT("closure-history + memory"); + } + return CachedCoachPanelState.PreferredGuidanceSourceLabel.IsEmpty() ? TEXT("availability fallback") : HyperTwistCoachDashboardWidgetInternal::DescribeCoachMemorySourceLabel( - CachedCoachPanelState.PreferredGuidanceSourceLabel))); + CachedCoachPanelState.PreferredGuidanceSourceLabel); + }(); const FString GuidancePreferenceStatusLine = GuidanceLanePreference.IsStructurallyValid() ? FString::Printf( @@ -10764,6 +10961,28 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation() { GuidancePreferenceDetailLine += MethodDrillUpstreamMemoryLine; } + if (GuidanceLanePreference.ReliableAlignedTrustedTightPlanOutcomeHistoryCount > 0 + || GuidanceLanePreference.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount > 0 + || GuidanceLanePreference.ReliableAlignedTrustedTightContinuationBias > 0 + || GuidanceLanePreference.ReliableAlignedTrustedBroadRedirectBias > 0) + { + GuidancePreferenceDetailLine += FString::Printf( + TEXT(" | Aligned launched-plan trust: tight history %d (avg %.2f, continuation bias %d) | broad history %d (avg %.2f, redirect bias %d)%s"), + GuidanceLanePreference.ReliableAlignedTrustedTightPlanOutcomeHistoryCount, + GuidanceLanePreference.ReliableAlignedTrustedTightPlanOutcomeAverageScore, + GuidanceLanePreference.ReliableAlignedTrustedTightContinuationBias, + GuidanceLanePreference.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount, + GuidanceLanePreference.ReliableAlignedTrustedBroadPlanOutcomeAverageScore, + GuidanceLanePreference.ReliableAlignedTrustedBroadRedirectBias, + GuidanceLanePreference.ReliableAlignedTrustedTightContinuationBias + > GuidanceLanePreference.ReliableAlignedTrustedBroadRedirectBias + ? TEXT(" | Tight launched-plan trust is currently reinforcing the follow-up lane.") + : (GuidanceLanePreference.ReliableAlignedTrustedBroadRedirectBias + > GuidanceLanePreference.ReliableAlignedTrustedTightContinuationBias + ? TEXT(" | Broad launched-plan redirect trust is currently reinforcing the recommended lane.") + : TEXT("")) + ); + } const bool bQueueRecoveryMemorySource = HyperTwistCoachDashboardWidgetInternal::IsQueueRecoveryMemorySource( CachedCoachPanelState.PreferredGuidanceSourceLabel); @@ -11861,7 +12080,7 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation() *BuildGuidanceOutcomeActionLabel(GuidanceDecisionWeighting.LastAppliedAction) ) : TEXT("Weighting: no matching authored decision history yet; the current outcome action is recap-derived only."); - const FString GuidanceDecisionWeightingDetailLine = + FString GuidanceDecisionWeightingDetailLine = GuidanceDecisionWeighting.IsStructurallyValid() ? FString::Printf( TEXT("Decision weighting for this lane/scope: repeat case %d | repeat deck %d | broaden %d | redirect %d | Avg success %.2f | Avg launch cases %.2f | broadened launches %d (avg %.2f) | tightened launches %d (avg %.2f) | Closure continue bias %d | Closure suppress bias %d | Deferred overflow bias %d | Deferred overflow cases %d | %s"), @@ -11888,6 +12107,24 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation() : TEXT("Recent authored choices reinforced the recap-derived guidance-outcome action.") ) : TEXT("Weighting detail: apply outcome actions on the same guidance lane and scope to let the dashboard bias future recommendations."); + if (GuidanceDecisionWeighting.ReliableAlignedTrustedTightPlanOutcomeHistoryCount > 0 + || GuidanceDecisionWeighting.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount > 0 + || GuidanceDecisionWeighting.ReliableAlignedTrustedTightContinuationDecisionCount > 0 + || GuidanceDecisionWeighting.ReliableAlignedTrustedBroadRedirectDecisionCount > 0) + { + GuidanceDecisionWeightingDetailLine += FString::Printf( + TEXT(" | Aligned launched-plan trust: tight history %d (avg %.2f, continuation decisions %d) | broad history %d (avg %.2f, redirect decisions %d)%s"), + GuidanceDecisionWeighting.ReliableAlignedTrustedTightPlanOutcomeHistoryCount, + GuidanceDecisionWeighting.ReliableAlignedTrustedTightPlanOutcomeAverageScore, + GuidanceDecisionWeighting.ReliableAlignedTrustedTightContinuationDecisionCount, + GuidanceDecisionWeighting.ReliableAlignedTrustedBroadPlanOutcomeHistoryCount, + GuidanceDecisionWeighting.ReliableAlignedTrustedBroadPlanOutcomeAverageScore, + GuidanceDecisionWeighting.ReliableAlignedTrustedBroadRedirectDecisionCount, + GuidanceDecisionWeighting.bUsedReliableAlignedPlanOutcomeSignal + ? TEXT(" | Aligned launched-plan trust adjusted the current guidance-outcome action.") + : TEXT("") + ); + } const FHyperTwistCoachDashboardDecisionHistoryEntry* SelectedGuidanceDecisionEntry = SelectedGuidanceDecisionIndex >= 0 && SelectedGuidanceDecisionIndex < GuidanceDecisionHistoryEntries.Num() @@ -11913,7 +12150,7 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation() *SelectedGuidanceDecisionEntry->RecordedAtUtc ) : TEXT("Decision history: no applied guidance-outcome decisions recorded yet."); - const FString GuidanceDecisionHistoryDetailLine = + FString GuidanceDecisionHistoryDetailLine = SelectedGuidanceDecisionEntry != nullptr ? FString::Printf( TEXT("Session: %s | Brief: %s | Recommended: %s | Applied: %s | Selected case: %s | Launch cases: %d/%d | Scope: %s | Success rate: %.2f | Completed attempts: %d | Mistakes: %d | Budget reason: %s"), @@ -11937,6 +12174,25 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation() : *SelectedGuidanceDecisionEntry->LaunchBudgetReasonLine ) : TEXT("Decision detail: apply a guidance outcome from the dashboard to retain the authored choice history."); + if (SelectedGuidanceDecisionEntry != nullptr + && (SelectedGuidanceDecisionEntry->ReliableAlignedTrustedTightPlanOutcomeHistoryCount > 0 + || SelectedGuidanceDecisionEntry->ReliableAlignedTrustedBroadPlanOutcomeHistoryCount > 0 + || SelectedGuidanceDecisionEntry->bUsedReliableAlignedTrustedTightPlanOutcomeHistory + || SelectedGuidanceDecisionEntry->bUsedReliableAlignedTrustedBroadPlanOutcomeHistory)) + { + GuidanceDecisionHistoryDetailLine += FString::Printf( + TEXT(" | Aligned launched-plan trust: tight history %d (avg %.2f) | broad history %d (avg %.2f)%s"), + SelectedGuidanceDecisionEntry->ReliableAlignedTrustedTightPlanOutcomeHistoryCount, + SelectedGuidanceDecisionEntry->ReliableAlignedTrustedTightPlanOutcomeAverageScore, + SelectedGuidanceDecisionEntry->ReliableAlignedTrustedBroadPlanOutcomeHistoryCount, + SelectedGuidanceDecisionEntry->ReliableAlignedTrustedBroadPlanOutcomeAverageScore, + SelectedGuidanceDecisionEntry->bUsedReliableAlignedTrustedTightPlanOutcomeHistory + ? TEXT(" | This decision was taken while tight aligned launched-plan trust was active.") + : (SelectedGuidanceDecisionEntry->bUsedReliableAlignedTrustedBroadPlanOutcomeHistory + ? TEXT(" | This decision was taken while broad aligned launched-plan redirect trust was active.") + : TEXT("")) + ); + } const bool bCanStartPreviewDeck = !bHasLiveAttemptTimer && !bHasActiveRun && ActivePreviewDeck != nullptr && ActivePreviewDeck->IsStructurallyValid(); const bool bCanStartPreviewCase = bCanStartPreviewDeck && SelectedGuidancePreviewCase != nullptr; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h index 2b0cb61..57de56f 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h @@ -55,6 +55,12 @@ struct FHyperTwistCoachDashboardDecisionHistoryEntry bool bBroadenedLaunchScope = false; bool bTightenedLaunchScope = false; FString LaunchBudgetReasonLine; + int32 ReliableAlignedTrustedTightPlanOutcomeHistoryCount = 0; + int32 ReliableAlignedTrustedBroadPlanOutcomeHistoryCount = 0; + float ReliableAlignedTrustedTightPlanOutcomeAverageScore = 0.0f; + float ReliableAlignedTrustedBroadPlanOutcomeAverageScore = 0.0f; + bool bUsedReliableAlignedTrustedTightPlanOutcomeHistory = false; + bool bUsedReliableAlignedTrustedBroadPlanOutcomeHistory = false; bool IsStructurallyValid() const { @@ -78,6 +84,10 @@ struct FHyperTwistCoachDashboardDecisionWeighting int32 ClosureSuppressionBias = 0; int32 DeferredOverflowContinuationBias = 0; int32 DeferredOverflowCaseCount = 0; + int32 ReliableAlignedTrustedTightPlanOutcomeHistoryCount = 0; + int32 ReliableAlignedTrustedBroadPlanOutcomeHistoryCount = 0; + int32 ReliableAlignedTrustedTightContinuationDecisionCount = 0; + int32 ReliableAlignedTrustedBroadRedirectDecisionCount = 0; EHyperTwistCoachDashboardOutcomeAction BaseAction = EHyperTwistCoachDashboardOutcomeAction::None; EHyperTwistCoachDashboardOutcomeAction WeightedAction = @@ -88,9 +98,12 @@ struct FHyperTwistCoachDashboardDecisionWeighting float AverageLaunchCaseCount = 0.0f; float BroadenedLaunchAverageSuccessRate = 0.0f; float TightenedLaunchAverageSuccessRate = 0.0f; + float ReliableAlignedTrustedTightPlanOutcomeAverageScore = 0.0f; + float ReliableAlignedTrustedBroadPlanOutcomeAverageScore = 0.0f; bool bHasOverride = false; bool bUsedClosureHistorySignal = false; bool bUsedDeferredOverflowSignal = false; + bool bUsedReliableAlignedPlanOutcomeSignal = false; bool IsStructurallyValid() const { @@ -110,10 +123,17 @@ struct FHyperTwistCoachDashboardGuidanceLanePreference int32 FollowUpContinueBias = 0; int32 ClosureContinuationBias = 0; int32 ClosureSuppressionBias = 0; + int32 ReliableAlignedTrustedTightPlanOutcomeHistoryCount = 0; + int32 ReliableAlignedTrustedBroadPlanOutcomeHistoryCount = 0; + int32 ReliableAlignedTrustedTightContinuationBias = 0; + int32 ReliableAlignedTrustedBroadRedirectBias = 0; float RecommendedAverageSuccessRate = 0.0f; float FollowUpAverageSuccessRate = 0.0f; + float ReliableAlignedTrustedTightPlanOutcomeAverageScore = 0.0f; + float ReliableAlignedTrustedBroadPlanOutcomeAverageScore = 0.0f; bool bHasDecisionSignal = false; bool bHasClosureHistorySignal = false; + bool bHasReliableAlignedPlanOutcomeSignal = false; bool IsStructurallyValid() const {