Close HyperTwist Phase 3R packet 3R-A

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

@@ -13,7 +13,6 @@
 #include "Components/TextBlock.h"
 #include "Components/VerticalBox.h"
 #include "Components/VerticalBoxSlot.h"
-#include "HAL/PlatformTime.h"
 
 namespace HyperTwistCoachDashboardWidgetInternal
 {
@@ -5755,24 +5754,7 @@ void UHyperTwistCoachDashboardWidget::NativeTick(const FGeometry& MyGeometry, fl
 void UHyperTwistCoachDashboardWidget::RefreshCoachDashboardView()
 {
 	RefreshTrainingState();
-	if (bHasLiveAttemptTimer
-		&& (!CachedRunState.Session.IsStructurallyValid()
-			|| !CachedRunState.CurrentSelection.TrainingCase.IsStructurallyValid()))
-	{
-		bHasLiveAttemptTimer = false;
-		LiveAttemptPhase = EHyperTwistCoachDashboardAttemptPhase::Idle;
-		LiveAttemptStartedAtSeconds = 0.0;
-		LiveAttemptSolveStartedAtSeconds = 0.0;
-		LiveAttemptStoredInspectionElapsedMs = 0;
-		LiveAttemptInspectionElapsedMs = 0;
-		LiveAttemptSolveElapsedMs = 0;
-		LiveAttemptDisplayedMs = 0;
-		LiveAttemptSplitCaptures.Reset();
-	}
-	else
-	{
-		RefreshLiveAttemptClock();
-	}
+	RefreshLiveAttemptClock();
 	RecordQueueSuppressionSnapshot();
 	RecordClosureRecoverySnapshot();
 	SyncRetainedRunRecap();
@@ -14220,6 +14202,8 @@ UHyperTwistCoachDashboardWidget::GetDisplayedRunActionLabelsInspectSurface() con
 		Surface.ContinueRunLabel == TEXT("Resolve Selectors");
 	Surface.bContinueUsesAttemptActiveLabel =
 		Surface.ContinueRunLabel == TEXT("Start Solve")
+		|| Surface.ContinueRunLabel == TEXT("Pause Timer")
+		|| Surface.ContinueRunLabel == TEXT("Resume Solve")
 		|| Surface.ContinueRunLabel == TEXT("Attempt Active");
 	Surface.bQueueActionRecommended =
 		Surface.QueuedRunLabel.StartsWith(TEXT("Recommended: "));
@@ -15304,6 +15288,8 @@ UHyperTwistCoachDashboardWidget::GetDisplayedActiveAttemptTimerStatusInspectSurf
 		&& TimingPolicy->InspectionDurationMs > 0;
 	const int32 InspectionLimitMs = bHasInspectionWindow ? FMath::Max(TimingPolicy->InspectionDurationMs, 0) : 0;
 	const bool bLiveInspectionPhase = IsLiveAttemptInspectionPhase();
+	const bool bLivePausedPhase = bHasLiveAttemptTimer
+		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Paused;
 	const bool bLiveSolvePhase = bHasLiveAttemptTimer
 		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Solving;
 	const bool bRunningSolveTimeHidden =
@@ -15338,7 +15324,7 @@ UHyperTwistCoachDashboardWidget::GetDisplayedActiveAttemptTimerStatusInspectSurf
 	Surface.DisplayedElapsedMs = LiveAttemptDisplayedMs;
 	Surface.TimerPhaseLabel = bLiveInspectionPhase
 		? TEXT("inspection")
-		: (bLiveSolvePhase ? TEXT("solving") : TEXT("idle"));
+		: (bLiveSolvePhase ? TEXT("solving") : (bLivePausedPhase ? TEXT("paused") : TEXT("idle")));
 	Surface.RunningSolveLabel = RunningSolveLabel;
 	Surface.InspectionWindowLabel = InspectionWindowLabel;
 	Surface.PendingPenaltyLabel =
@@ -15361,22 +15347,42 @@ UHyperTwistCoachDashboardWidget::GetDisplayedActiveAttemptTimerStatusInspectSurf
 			Surface.ResolvedFailureTimeMs,
 			Surface.ResolvedTimeoutTimeMs,
 			Surface.ResolvedDnfTimeMs);
-	Surface.TimerStatusLine = !DisplayedTimerStatusLine.IsEmpty()
-		? DisplayedTimerStatusLine
-		: (bLiveInspectionPhase
-			? FString::Printf(
-				TEXT("Phase: inspection | elapsed %d ms | remaining %d ms | pending penalty: %s | click Start Solve when ready"),
-				Surface.InspectionElapsedMs,
-				bHasInspectionWindow ? FMath::Max(InspectionLimitMs - LiveAttemptInspectionElapsedMs, 0) : 0,
-				*Surface.PendingPenaltyLabel)
-			: (bLiveSolvePhase
-				? FString::Printf(
-					TEXT("Phase: solving | inspection %d ms | solve %s ms | finish with Success / Failure / Timeout / DNF"),
-					Surface.InspectionElapsedMs,
-					*Surface.RunningSolveLabel)
-				: FString::Printf(
-					TEXT("Timer idle | %s | start a live attempt for less-synthetic run entry"),
-					*Surface.InspectionWindowLabel)));
+	if (!DisplayedTimerStatusLine.IsEmpty())
+	{
+		Surface.TimerStatusLine = DisplayedTimerStatusLine;
+	}
+	else if (bLiveInspectionPhase)
+	{
+		Surface.TimerStatusLine = FString::Printf(
+			TEXT("Phase: inspection | elapsed %d ms | remaining %d ms | pending penalty: %s | click Start Solve when ready"),
+			Surface.InspectionElapsedMs,
+			bHasInspectionWindow ? FMath::Max(InspectionLimitMs - LiveAttemptInspectionElapsedMs, 0) : 0,
+			*Surface.PendingPenaltyLabel
+		);
+	}
+	else if (bLiveSolvePhase)
+	{
+		Surface.TimerStatusLine = FString::Printf(
+			TEXT("Phase: solving | inspection %d ms | solve %s ms | finish with Success / Failure / Timeout / DNF"),
+			Surface.InspectionElapsedMs,
+			*Surface.RunningSolveLabel
+		);
+	}
+	else if (bLivePausedPhase)
+	{
+		Surface.TimerStatusLine = FString::Printf(
+			TEXT("Phase: paused | inspection %d ms | solve %d ms | click Resume Solve or Cancel Timer"),
+			Surface.InspectionElapsedMs,
+			Surface.SolveElapsedMs
+		);
+	}
+	else
+	{
+		Surface.TimerStatusLine = FString::Printf(
+			TEXT("Timer idle | %s | start a live attempt for less-synthetic run entry"),
+			*Surface.InspectionWindowLabel
+		);
+	}
 	return Surface;
 }
 
@@ -15535,6 +15541,8 @@ UHyperTwistCoachDashboardWidget::GetDisplayedLiveTimerSplitControlLabelInspectSu
 	const bool bHasRunnableCurrentCase =
 		bHasActiveRun && CachedRunState.CurrentSelection.TrainingCase.IsStructurallyValid();
 	const bool bLiveInspectionPhase = IsLiveAttemptInspectionPhase();
+	const bool bLivePausedPhase = bHasLiveAttemptTimer
+		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Paused;
 	const bool bLiveSolvePhase = bHasLiveAttemptTimer
 		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Solving;
 	const FHyperTwistTrainingSplitPhaseDefinition* NextSplitPhaseDefinition = FindNextSplitPhaseToCapture();
@@ -15548,7 +15556,9 @@ UHyperTwistCoachDashboardWidget::GetDisplayedLiveTimerSplitControlLabelInspectSu
 		? DisplayedStartTimerControlLabel
 		: (bLiveInspectionPhase
 			? TEXT("Start Solve")
-			: (bHasLiveAttemptTimer ? TEXT("Timer Active") : TEXT("Start Attempt")));
+			: (bLiveSolvePhase
+				? TEXT("Pause Timer")
+				: (bLivePausedPhase ? TEXT("Resume Solve") : TEXT("Start Attempt"))));
 	Surface.CancelTimerLabel = !DisplayedCancelTimerControlLabel.IsEmpty()
 		? DisplayedCancelTimerControlLabel
 		: TEXT("Cancel Timer");
@@ -15567,10 +15577,10 @@ UHyperTwistCoachDashboardWidget::GetDisplayedLiveTimerSplitControlLabelInspectSu
 	Surface.bLiveInspectionPhase = bLiveInspectionPhase;
 	Surface.bLiveSolvePhase = bLiveSolvePhase;
 	Surface.bCanStartOrAdvanceTimer =
-		bHasRunnableCurrentCase && (!bHasLiveAttemptTimer || bLiveInspectionPhase);
+		bHasRunnableCurrentCase && (!bHasLiveAttemptTimer || bLiveInspectionPhase || bLiveSolvePhase || bLivePausedPhase);
 	Surface.bCanCancelTimer = bHasLiveAttemptTimer;
 	Surface.bCanCaptureSplit = bLiveSolvePhase && NextSplitPhaseDefinition != nullptr;
-	Surface.bCanUndoSplit = bLiveSolvePhase && LiveAttemptSplitCaptures.Num() > 0;
+	Surface.bCanUndoSplit = (bLiveSolvePhase || bLivePausedPhase) && LiveAttemptSplitCaptures.Num() > 0;
 	Surface.TimerControlLine = FString::Printf(
 		TEXT("%s: %s | %s: %s"),
 		*Surface.StartTimerLabel,
@@ -15598,6 +15608,8 @@ UHyperTwistCoachDashboardWidget::GetDisplayedAttemptResultActionEnablementInspec
 		&& CachedRunState.ActiveDeck.IsStructurallyValid();
 	const bool bHasRunnableCurrentCase =
 		bHasActiveRun && CachedRunState.CurrentSelection.TrainingCase.IsStructurallyValid();
+	const bool bLivePausedPhase = bHasLiveAttemptTimer
+		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Paused;
 	const bool bLiveSolvePhase = bHasLiveAttemptTimer
 		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Solving;
 
@@ -15629,8 +15641,9 @@ UHyperTwistCoachDashboardWidget::GetDisplayedAttemptResultActionEnablementInspec
 		*Surface.TimeoutLabel,
 		*Surface.DnfLabel);
 	Surface.DetailLine = FString::Printf(
-		TEXT("Result-action detail: live solve %s | synthetic attempt entry %s | stop-live-attempt %s"),
+		TEXT("Result-action detail: live solve %s | live paused %s | synthetic attempt entry %s | stop-live-attempt %s"),
 		Surface.bLiveSolvePhase ? TEXT("yes") : TEXT("no"),
+		bLivePausedPhase ? TEXT("yes") : TEXT("no"),
 		Surface.bCanRecordSyntheticAttempt ? TEXT("enabled") : TEXT("disabled"),
 		Surface.bCanStopLiveTimedAttempt ? TEXT("enabled") : TEXT("disabled"));
 	return Surface;
@@ -17342,6 +17355,8 @@ UHyperTwistCoachDashboardWidget::GetDisplayedLiveSplitCaptureStatusInspectSurfac
 			: TimingPolicy->SplitPhases[MaxManualSplitCaptureCount].Label)
 		: TEXT("solve end");
 	const bool bLiveInspectionPhase = IsLiveAttemptInspectionPhase();
+	const bool bLivePausedPhase = bHasLiveAttemptTimer
+		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Paused;
 	const bool bLiveSolvePhase = bHasLiveAttemptTimer
 		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Solving;
 
@@ -17373,11 +17388,25 @@ UHyperTwistCoachDashboardWidget::GetDisplayedLiveSplitCaptureStatusInspectSurfac
 			*Surface.NextSplitLabel,
 			*Surface.FinalAutoCloseLabel,
 			*Surface.CapturedSummary);
-		Surface.StatusLine = bLiveSolvePhase
-			? SplitStateLine + TEXT(" | capture phase ends during solve; final phase closes on attempt stop")
-			: (bLiveInspectionPhase
-				? SplitStateLine + TEXT(" | split capture unlocks after solve start")
-				: SplitStateLine + TEXT(" | start a live attempt to record manual split boundaries"));
+		if (bLiveSolvePhase)
+		{
+			Surface.StatusLine =
+				SplitStateLine + TEXT(" | capture phase ends during solve; final phase closes on attempt stop");
+		}
+		else if (bLivePausedPhase)
+		{
+			Surface.StatusLine =
+				SplitStateLine + TEXT(" | split capture is paused; resume solve to capture the next phase");
+		}
+		else if (bLiveInspectionPhase)
+		{
+			Surface.StatusLine = SplitStateLine + TEXT(" | split capture unlocks after solve start");
+		}
+		else
+		{
+			Surface.StatusLine =
+				SplitStateLine + TEXT(" | start a live attempt to record manual split boundaries");
+		}
 	}
 	return Surface;
 }
@@ -17537,62 +17566,37 @@ bool UHyperTwistCoachDashboardWidget::SelectNextMethodDrillRecoveryMemoryHistory
 
 bool UHyperTwistCoachDashboardWidget::StartLiveAttemptTimer()
 {
-	if (!CachedRunState.Session.IsStructurallyValid() || !CachedRunState.CurrentSelection.TrainingCase.IsStructurallyValid())
+	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(this))
 	{
-		return false;
+		const bool bStarted = TrainingSubsystem->StartActiveLiveTimer();
+		RefreshLiveAttemptClock();
+		UpdateDashboardPresentation();
+		return bStarted;
 	}
 
-	if (bHasLiveAttemptTimer)
-	{
-		return AdvanceLiveAttemptToSolvePhase();
-	}
-
-	const FHyperTwistTrainingTimingPolicy* TimingPolicy = FindActiveTimingPolicy();
-	const bool bUseInspection = TimingPolicy != nullptr
-		&& TimingPolicy->bInspectionEnabled
-		&& TimingPolicy->InspectionDurationMs > 0;
-
-	bHasLiveAttemptTimer = true;
-	LiveAttemptPhase = bUseInspection
-		? EHyperTwistCoachDashboardAttemptPhase::Inspection
-		: EHyperTwistCoachDashboardAttemptPhase::Solving;
-	LiveAttemptStartedAtSeconds = FPlatformTime::Seconds();
-	LiveAttemptSolveStartedAtSeconds = bUseInspection ? 0.0 : LiveAttemptStartedAtSeconds;
-	LiveAttemptStoredInspectionElapsedMs = 0;
-	LiveAttemptInspectionElapsedMs = 0;
-	LiveAttemptSolveElapsedMs = 0;
-	LiveAttemptDisplayedMs = 0;
-	LiveAttemptSplitCaptures.Reset();
-	UpdateDashboardPresentation();
-	return true;
+	return false;
 }
 
 bool UHyperTwistCoachDashboardWidget::AdvanceLiveAttemptToSolvePhase()
 {
-	if (!bHasLiveAttemptTimer || LiveAttemptPhase != EHyperTwistCoachDashboardAttemptPhase::Inspection)
+	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(this))
 	{
-		return false;
+		const bool bAdvanced = TrainingSubsystem->AdvanceActiveLiveTimerToSolvePhase();
+		RefreshLiveAttemptClock();
+		UpdateDashboardPresentation();
+		return bAdvanced;
 	}
 
-	RefreshLiveAttemptClock();
-	LiveAttemptStoredInspectionElapsedMs = LiveAttemptInspectionElapsedMs;
-	LiveAttemptSolveStartedAtSeconds = FPlatformTime::Seconds();
-	LiveAttemptPhase = EHyperTwistCoachDashboardAttemptPhase::Solving;
-	UpdateDashboardPresentation();
-	return true;
+	return false;
 }
 
 void UHyperTwistCoachDashboardWidget::CancelLiveAttemptTimer()
 {
-	bHasLiveAttemptTimer = false;
-	LiveAttemptPhase = EHyperTwistCoachDashboardAttemptPhase::Idle;
-	LiveAttemptStartedAtSeconds = 0.0;
-	LiveAttemptSolveStartedAtSeconds = 0.0;
-	LiveAttemptStoredInspectionElapsedMs = 0;
-	LiveAttemptInspectionElapsedMs = 0;
-	LiveAttemptSolveElapsedMs = 0;
-	LiveAttemptDisplayedMs = 0;
-	LiveAttemptSplitCaptures.Reset();
+	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(this))
+	{
+		TrainingSubsystem->CancelActiveLiveTimer();
+	}
+	RefreshLiveAttemptClock();
 	UpdateDashboardPresentation();
 }
 
@@ -17600,88 +17604,45 @@ FHyperTwistTrainingRunStepResult UHyperTwistCoachDashboardWidget::SubmitLiveTime
 	const EHyperTwistTrainingAttemptResult Result
 )
 {
-	if (!bHasLiveAttemptTimer
-		|| LiveAttemptPhase != EHyperTwistCoachDashboardAttemptPhase::Solving
-		|| !CachedRunState.Session.IsStructurallyValid()
-		|| !CachedRunState.CurrentSelection.TrainingCase.IsStructurallyValid())
+	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(this))
 	{
-		return FHyperTwistTrainingRunStepResult();
+		const FHyperTwistTrainingRunStepResult StepResult = TrainingSubsystem->SubmitActiveLiveTimedAttempt(Result);
+		LastStepResult = StepResult;
+		RefreshTrainingState();
+		RefreshLiveAttemptClock();
+		SyncRetainedRunRecap();
+		SyncSelectedAttempt();
+		UpdateDashboardPresentation();
+		return StepResult;
 	}
 
-	RefreshLiveAttemptClock();
-
-	FHyperTwistTrainingAttempt Attempt;
-	Attempt.AttemptId = FString::Printf(
-		TEXT("attempt_%s_%s"),
-		*CachedRunState.Session.TrainingSessionId,
-		*FGuid::NewGuid().ToString(EGuidFormats::Digits)
-	);
-	Attempt.TrainingSessionId = CachedRunState.Session.TrainingSessionId;
-	Attempt.CaseId = CachedRunState.CurrentSelection.TrainingCase.CaseId;
-	Attempt.Result = Result;
-	Attempt.TotalTimeMs = FMath::Max(LiveAttemptSolveElapsedMs, 0);
-	Attempt.ExecutionTimeMs = FMath::Max(LiveAttemptSolveElapsedMs, 0);
-	Attempt.TimingBreakdown.InspectionElapsedMs = FMath::Max(LiveAttemptInspectionElapsedMs, 0);
-	Attempt.TimingBreakdown.RawSolveTimeMs = FMath::Max(LiveAttemptSolveElapsedMs, 0);
-	Attempt.TimingBreakdown.FinalTimeMs = FMath::Max(LiveAttemptSolveElapsedMs, 0);
-	Attempt.TimingBreakdown.SplitCaptures = LiveAttemptSplitCaptures;
-	Attempt.TimingBreakdown.bDidNotFinish =
-		Result == EHyperTwistTrainingAttemptResult::Timeout
-		|| Result == EHyperTwistTrainingAttemptResult::DNF
-		|| Result == EHyperTwistTrainingAttemptResult::Aborted;
-	if (Result == EHyperTwistTrainingAttemptResult::DNF)
-	{
-		Attempt.TimingBreakdown.ManualPenalty = EHyperTwistTrainingPenalty::DNF;
-		Attempt.TimingBreakdown.AppliedPenalty = EHyperTwistTrainingPenalty::DNF;
-	}
-	Attempt.ReplayId = CachedRunState.ReplayPacket.ReplayId;
-	Attempt.CompletedAtUtc = FDateTime::UtcNow().ToIso8601();
-
-	const FHyperTwistTrainingRunStepResult StepResult = SubmitTrainingAttempt(
-		Attempt,
-		FMath::Max(LiveAttemptSolveElapsedMs, 0)
-	);
-	SyncRetainedRunRecap();
-	SyncSelectedAttempt();
-	CancelLiveAttemptTimer();
-	return StepResult;
+	return FHyperTwistTrainingRunStepResult();
 }
 
 bool UHyperTwistCoachDashboardWidget::CaptureNextLiveAttemptSplit()
 {
-	if (!bHasLiveAttemptTimer || LiveAttemptPhase != EHyperTwistCoachDashboardAttemptPhase::Solving)
+	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(this))
 	{
-		return false;
+		const bool bCaptured = TrainingSubsystem->CaptureActiveLiveTimerSplit();
+		RefreshLiveAttemptClock();
+		UpdateDashboardPresentation();
+		return bCaptured;
 	}
 
-	const FHyperTwistTrainingSplitPhaseDefinition* NextPhaseDefinition = FindNextSplitPhaseToCapture();
-	if (NextPhaseDefinition == nullptr)
-	{
-		return false;
-	}
-
-	RefreshLiveAttemptClock();
-
-	FHyperTwistTrainingSplitCapture SplitCapture;
-	SplitCapture.PhaseId = NextPhaseDefinition->PhaseId;
-	SplitCapture.Label = NextPhaseDefinition->Label;
-	SplitCapture.TimestampMs = FMath::Max(LiveAttemptSolveElapsedMs, 0);
-
-	LiveAttemptSplitCaptures.Add(SplitCapture);
-	UpdateDashboardPresentation();
-	return true;
+	return false;
 }
 
 bool UHyperTwistCoachDashboardWidget::UndoLastLiveAttemptSplit()
 {
-	if (LiveAttemptSplitCaptures.Num() <= 0)
+	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(this))
 	{
-		return false;
+		const bool bUndid = TrainingSubsystem->UndoActiveLiveTimerSplit();
+		RefreshLiveAttemptClock();
+		UpdateDashboardPresentation();
+		return bUndid;
 	}
 
-	LiveAttemptSplitCaptures.RemoveAt(LiveAttemptSplitCaptures.Num() - 1);
-	UpdateDashboardPresentation();
-	return true;
+	return false;
 }
 
 void UHyperTwistCoachDashboardWidget::HandlePrimaryActionClicked()
@@ -18014,14 +17975,7 @@ void UHyperTwistCoachDashboardWidget::HandleUseAverageTimeClicked()
 
 void UHyperTwistCoachDashboardWidget::HandleStartTimerClicked()
 {
-	if (bHasLiveAttemptTimer && IsLiveAttemptInspectionPhase())
-	{
-		AdvanceLiveAttemptToSolvePhase();
-	}
-	else
-	{
-		StartLiveAttemptTimer();
-	}
+	StartLiveAttemptTimer();
 }
 
 void UHyperTwistCoachDashboardWidget::HandleCancelTimerClicked()
@@ -23928,6 +23882,8 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 		&& TimingPolicy->InspectionDurationMs > 0;
 	const int32 InspectionLimitMs = bHasInspectionWindow ? FMath::Max(TimingPolicy->InspectionDurationMs, 0) : 0;
 	const bool bLiveInspectionPhase = IsLiveAttemptInspectionPhase();
+	const bool bLivePausedPhase = bHasLiveAttemptTimer
+		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Paused;
 	const bool bLiveSolvePhase = bHasLiveAttemptTimer
 		&& LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Solving;
 	const int32 MaxManualSplitCaptureCount = GetMaxManualSplitCaptureCount();
@@ -24153,7 +24109,9 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 			TEXT("Transition: no run is active. Start recommended, follow-up, or queued coaching work from this screen.");
 	}
 	FString ContinueRunLabel = bHasLiveAttemptTimer
-		? (bLiveInspectionPhase ? TEXT("Start Solve") : TEXT("Attempt Active"))
+		? (bLiveInspectionPhase
+			? TEXT("Start Solve")
+			: (bLiveSolvePhase ? TEXT("Pause Timer") : (bLivePausedPhase ? TEXT("Resume Solve") : TEXT("Attempt Active"))))
 		: (bGeneratedModeLaunchDeck
 			? (bCanExecuteGeneratedModeLaunch ? TEXT("Execute Generated Run") : TEXT("Resolve Selectors"))
 			: (bRecognitionAssistedCurrentRun && !bRecognitionSessionOpenForCurrentRun
@@ -29479,6 +29437,14 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 			*RunningSolveLabel
 		);
 	}
+	else if (bLivePausedPhase)
+	{
+		DisplayedTimerStatusLine = FString::Printf(
+			TEXT("Phase: paused | inspection %d ms | solve %d ms | click Resume Solve or Cancel Timer"),
+			LiveAttemptInspectionElapsedMs,
+			LiveAttemptSolveElapsedMs
+		);
+	}
 	else
 	{
 		const FString InspectionLabel = bHasInspectionWindow
@@ -29514,11 +29480,26 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 				*FinalSplitLabel,
 				*CapturedSplitSummary
 			);
-			DisplayedSplitCaptureStatusLine = bLiveSolvePhase
-				? SplitStateLine + TEXT(" | capture phase ends during solve; final phase closes on attempt stop")
-				: (bLiveInspectionPhase
-					? SplitStateLine + TEXT(" | split capture unlocks after solve start")
-					: SplitStateLine + TEXT(" | start a live attempt to record manual split boundaries"));
+			if (bLiveSolvePhase)
+			{
+				DisplayedSplitCaptureStatusLine =
+					SplitStateLine + TEXT(" | capture phase ends during solve; final phase closes on attempt stop");
+			}
+			else if (bLivePausedPhase)
+			{
+				DisplayedSplitCaptureStatusLine =
+					SplitStateLine + TEXT(" | split capture is paused; resume solve to capture the next phase");
+			}
+			else if (bLiveInspectionPhase)
+			{
+				DisplayedSplitCaptureStatusLine =
+					SplitStateLine + TEXT(" | split capture unlocks after solve start");
+			}
+			else
+			{
+				DisplayedSplitCaptureStatusLine =
+					SplitStateLine + TEXT(" | start a live attempt to record manual split boundaries");
+			}
 		}
 		SplitStatusTextBlock->SetText(FText::FromString(DisplayedSplitCaptureStatusLine));
 	}
@@ -30180,14 +30161,14 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 	{
 		DisplayedStartTimerControlLabel =
 			bLiveInspectionPhase ? TEXT("Start Solve")
-			: (bHasLiveAttemptTimer ? TEXT("Timer Active") : TEXT("Start Attempt"));
+			: (bLiveSolvePhase ? TEXT("Pause Timer") : (bLivePausedPhase ? TEXT("Resume Solve") : TEXT("Start Attempt")));
 		StartTimerButtonLabel->SetText(FText::FromString(DisplayedStartTimerControlLabel));
 	}
 	if (StartTimerButton != nullptr)
 	{
 		StartTimerButton->SetIsEnabled(
 			bHasRunnableCurrentCase
-			&& (!bHasLiveAttemptTimer || bLiveInspectionPhase)
+			&& (!bHasLiveAttemptTimer || bLiveInspectionPhase || bLiveSolvePhase || bLivePausedPhase)
 		);
 	}
 	if (CancelTimerButtonLabel != nullptr)
@@ -30274,33 +30255,35 @@ void UHyperTwistCoachDashboardWidget::UpdateDashboardPresentation()
 
 void UHyperTwistCoachDashboardWidget::RefreshLiveAttemptClock()
 {
-	if (!bHasLiveAttemptTimer)
+	SyncLiveAttemptStateFromSubsystem();
+}
+
+void UHyperTwistCoachDashboardWidget::SyncLiveAttemptStateFromSubsystem()
+{
+	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(this))
 	{
-		LiveAttemptInspectionElapsedMs = 0;
-		LiveAttemptSolveElapsedMs = 0;
-		LiveAttemptDisplayedMs = 0;
+		const FHyperTwistTrainingLiveTimerState LiveTimerState = TrainingSubsystem->GetActiveLiveTimerState();
+		bHasLiveAttemptTimer = LiveTimerState.IsActive();
+		LiveAttemptPhase = LiveTimerState.Phase == EHyperTwistTrainingLiveTimerPhase::Inspection
+			? EHyperTwistCoachDashboardAttemptPhase::Inspection
+			: (LiveTimerState.Phase == EHyperTwistTrainingLiveTimerPhase::Paused
+				? EHyperTwistCoachDashboardAttemptPhase::Paused
+				: (LiveTimerState.Phase == EHyperTwistTrainingLiveTimerPhase::Solving
+					? EHyperTwistCoachDashboardAttemptPhase::Solving
+					: EHyperTwistCoachDashboardAttemptPhase::Idle));
+		LiveAttemptInspectionElapsedMs = FMath::Max(LiveTimerState.InspectionElapsedMs, 0);
+		LiveAttemptSolveElapsedMs = FMath::Max(LiveTimerState.SolveElapsedMs, 0);
+		LiveAttemptDisplayedMs = FMath::Max(LiveTimerState.DisplayedElapsedMs, 0);
+		LiveAttemptSplitCaptures = LiveTimerState.SplitCaptures;
 		return;
 	}
 
-	const double NowSeconds = FPlatformTime::Seconds();
-	if (LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Inspection)
-	{
-		LiveAttemptInspectionElapsedMs = FMath::Max(
-			0,
-			static_cast<int32>((NowSeconds - LiveAttemptStartedAtSeconds) * 1000.0)
-		);
-		LiveAttemptSolveElapsedMs = 0;
-		LiveAttemptDisplayedMs = LiveAttemptInspectionElapsedMs;
-	}
-	else if (LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Solving)
-	{
-		LiveAttemptInspectionElapsedMs = FMath::Max(LiveAttemptStoredInspectionElapsedMs, 0);
-		LiveAttemptSolveElapsedMs = FMath::Max(
-			0,
-			static_cast<int32>((NowSeconds - LiveAttemptSolveStartedAtSeconds) * 1000.0)
-		);
-		LiveAttemptDisplayedMs = LiveAttemptSolveElapsedMs;
-	}
+	bHasLiveAttemptTimer = false;
+	LiveAttemptPhase = EHyperTwistCoachDashboardAttemptPhase::Idle;
+	LiveAttemptInspectionElapsedMs = 0;
+	LiveAttemptSolveElapsedMs = 0;
+	LiveAttemptDisplayedMs = 0;
+	LiveAttemptSplitCaptures.Reset();
 }
 
 FString UHyperTwistCoachDashboardWidget::BuildDefaultDeferredUntilUtc() const

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

@@ -5806,7 +5806,8 @@ namespace HyperTwistTrainingRepositoryLibraryInternal
 		const TArray<FTimedSolveSample>& TimedSolveSamples,
 		const int32 StartIndex,
 		const int32 WindowSize,
-		const bool bUseRawSolveTime
+		const bool bUseRawSolveTime,
+		const bool bTrimExtremes = false
 	)
 	{
 		if (WindowSize <= 0 || StartIndex < 0 || StartIndex + WindowSize > TimedSolveSamples.Num())
@@ -5814,15 +5815,49 @@ namespace HyperTwistTrainingRepositoryLibraryInternal
 			return 0;
 		}
 
-		int64 MetricAccumulator = 0;
+		TArray<int32> MetricValues;
+		MetricValues.Reserve(WindowSize);
 		for (int32 Index = StartIndex; Index < StartIndex + WindowSize; ++Index)
 		{
-			MetricAccumulator += bUseRawSolveTime
+			MetricValues.Add(bUseRawSolveTime
 				? TimedSolveSamples[Index].RawSolveTimeMs
-				: TimedSolveSamples[Index].TotalTimeMs;
+				: TimedSolveSamples[Index].TotalTimeMs);
 		}
 
-		return static_cast<int32>(MetricAccumulator / WindowSize);
+		if (MetricValues.Num() == 0)
+		{
+			return 0;
+		}
+
+		int32 StartMetricIndex = 0;
+		int32 EndMetricIndex = MetricValues.Num();
+		if (bTrimExtremes && MetricValues.Num() >= 5)
+		{
+			MetricValues.Sort();
+			StartMetricIndex = 1;
+			EndMetricIndex = MetricValues.Num() - 1;
+		}
+
+		int64 MetricAccumulator = 0;
+		for (int32 MetricIndex = StartMetricIndex; MetricIndex < EndMetricIndex; ++MetricIndex)
+		{
+			MetricAccumulator += MetricValues[MetricIndex];
+		}
+
+		const int32 Divisor = EndMetricIndex - StartMetricIndex;
+		return Divisor > 0 ? static_cast<int32>(MetricAccumulator / Divisor) : 0;
+	}
+
+	bool ShouldTrimRollingWindowExtremes(const int32 WindowSize)
+	{
+		return WindowSize >= 5;
+	}
+
+	FString BuildRollingWindowLabel(const int32 WindowSize)
+	{
+		return WindowSize == 3
+			? TEXT("mo3")
+			: FString::Printf(TEXT("ao%d"), WindowSize);
 	}
 
 	FHyperTwistTrainingRollingWindowStat BuildRollingWindowStat(
@@ -5832,6 +5867,8 @@ namespace HyperTwistTrainingRepositoryLibraryInternal
 	{
 		FHyperTwistTrainingRollingWindowStat RollingWindowStat;
 		RollingWindowStat.WindowSize = WindowSize;
+		RollingWindowStat.WindowLabel = BuildRollingWindowLabel(WindowSize);
+		RollingWindowStat.bTrimExtremes = ShouldTrimRollingWindowExtremes(WindowSize);
 		if (WindowSize <= 0 || TimedSolveSamples.Num() == 0)
 		{
 			return RollingWindowStat;
@@ -5844,13 +5881,15 @@ namespace HyperTwistTrainingRepositoryLibraryInternal
 			TimedSolveSamples,
 			TimedSolveSamples.Num() - EffectiveWindowSize,
 			EffectiveWindowSize,
-			false
+			false,
+			RollingWindowStat.bTrimExtremes
 		);
 		RollingWindowStat.CurrentAverageRawSolveTimeMs = ComputeAverageMetricForSamples(
 			TimedSolveSamples,
 			TimedSolveSamples.Num() - EffectiveWindowSize,
 			EffectiveWindowSize,
-			true
+			true,
+			RollingWindowStat.bTrimExtremes
 		);
 
 		if (!RollingWindowStat.bWindowFilled)
@@ -5866,13 +5905,15 @@ namespace HyperTwistTrainingRepositoryLibraryInternal
 				TimedSolveSamples,
 				StartIndex,
 				WindowSize,
-				false
+				false,
+				RollingWindowStat.bTrimExtremes
 			);
 			const int32 AverageRawSolveTimeMs = ComputeAverageMetricForSamples(
 				TimedSolveSamples,
 				StartIndex,
 				WindowSize,
-				true
+				true,
+				RollingWindowStat.bTrimExtremes
 			);
 
 			if (AverageTotalTimeMs > 0
@@ -7155,20 +7196,31 @@ FHyperTwistTrainingTimingTrendSummary UHyperTwistTrainingRepositoryLibrary::Deri
 	Summary.LastSolveRawSolveTimeMs = LastSolveSample.RawSolveTimeMs;
 	Summary.LastSolveAtUtc = LastSolveSample.RecordedAtUtc;
 
+	int64 TotalTimeAccumulator = 0;
+	int64 RawSolveTimeAccumulator = 0;
 	for (const HyperTwistTrainingRepositoryLibraryInternal::FTimedSolveSample& TimedSolveSample : TimedSolveSamples)
 	{
+		TotalTimeAccumulator += TimedSolveSample.TotalTimeMs;
+		RawSolveTimeAccumulator += TimedSolveSample.RawSolveTimeMs;
+
 		if (Summary.BestSingleTotalTimeMs == 0 || TimedSolveSample.TotalTimeMs < Summary.BestSingleTotalTimeMs)
 		{
 			Summary.BestSingleTotalTimeMs = TimedSolveSample.TotalTimeMs;
 		}
+		Summary.WorstSingleTotalTimeMs = FMath::Max(Summary.WorstSingleTotalTimeMs, TimedSolveSample.TotalTimeMs);
 
 		if (Summary.BestSingleRawSolveTimeMs == 0 || TimedSolveSample.RawSolveTimeMs < Summary.BestSingleRawSolveTimeMs)
 		{
 			Summary.BestSingleRawSolveTimeMs = TimedSolveSample.RawSolveTimeMs;
 		}
+		Summary.WorstSingleRawSolveTimeMs =
+			FMath::Max(Summary.WorstSingleRawSolveTimeMs, TimedSolveSample.RawSolveTimeMs);
 	}
 
-	for (const int32 WindowSize : {3, 5, 12})
+	Summary.MeanTotalTimeMs = static_cast<int32>(TotalTimeAccumulator / TimedSolveSamples.Num());
+	Summary.MeanRawSolveTimeMs = static_cast<int32>(RawSolveTimeAccumulator / TimedSolveSamples.Num());
+
+	for (const int32 WindowSize : {3, 5, 12, 50, 100, 1000})
 	{
 		Summary.RollingWindows.Add(HyperTwistTrainingRepositoryLibraryInternal::BuildRollingWindowStat(
 			TimedSolveSamples,

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

@@ -107,6 +107,46 @@ namespace HyperTwistTrainingSubsystemInternal
 		return Fallback;
 	}
 
+	EHyperTwistTrainingPenalty CombinePenalties(
+		const EHyperTwistTrainingPenalty LeftPenalty,
+		const EHyperTwistTrainingPenalty RightPenalty
+	)
+	{
+		if (LeftPenalty == EHyperTwistTrainingPenalty::DNF || RightPenalty == EHyperTwistTrainingPenalty::DNF)
+		{
+			return EHyperTwistTrainingPenalty::DNF;
+		}
+		if (LeftPenalty == EHyperTwistTrainingPenalty::Plus2 || RightPenalty == EHyperTwistTrainingPenalty::Plus2)
+		{
+			return EHyperTwistTrainingPenalty::Plus2;
+		}
+
+		return EHyperTwistTrainingPenalty::None;
+	}
+
+	EHyperTwistTrainingPenalty ComputeInspectionPenalty(
+		const int32 InspectionElapsedMs,
+		const FHyperTwistTrainingTimingPolicy& TimingPolicy
+	)
+	{
+		if (!TimingPolicy.bInspectionEnabled
+			|| !TimingPolicy.bInspectionPenaltiesEnabled
+			|| TimingPolicy.InspectionDurationMs <= 0
+			|| InspectionElapsedMs <= TimingPolicy.InspectionDurationMs)
+		{
+			return EHyperTwistTrainingPenalty::None;
+		}
+
+		return InspectionElapsedMs <= TimingPolicy.InspectionDurationMs + 2000
+			? EHyperTwistTrainingPenalty::Plus2
+			: EHyperTwistTrainingPenalty::DNF;
+	}
+
+	int32 ResolveLiveTimerReplayTimeMs(const FHyperTwistTrainingLiveTimerState& LiveTimerState)
+	{
+		return FMath::Max(0, LiveTimerState.InspectionElapsedMs + LiveTimerState.SolveElapsedMs);
+	}
+
 	bool ShouldPreferRecognitionReplayReviewForActiveRun(
 		const FHyperTwistTrainingRunState& RunState,
 		const FHyperTwistTrainingCoachActionPlan& ActionPlan
@@ -1928,6 +1968,21 @@ FHyperTwistTrainingRunState UHyperTwistTrainingSubsystem::GetActiveRunState() co
 	return ActiveRunState;
 }
 
+bool UHyperTwistTrainingSubsystem::HasActiveLiveTimer() const
+{
+	return HasActiveRun()
+		&& ActiveRunState.Session.IsStructurallyValid()
+		&& ActiveLiveTimerState.IsActive()
+		&& ActiveLiveTimerState.TrainingSessionId == ActiveRunState.Session.TrainingSessionId
+		&& ActiveLiveTimerState.CaseId == ActiveRunState.CurrentSelection.TrainingCase.CaseId;
+}
+
+FHyperTwistTrainingLiveTimerState UHyperTwistTrainingSubsystem::GetActiveLiveTimerState()
+{
+	RefreshActiveLiveTimerState();
+	return ActiveLiveTimerState;
+}
+
 bool UHyperTwistTrainingSubsystem::TryGetActiveImportedRuntimeSurface(
 	FHyperTwistTrainingImportedRuntimeSurface& OutRuntimeSurface
 ) const
@@ -4687,6 +4742,7 @@ FHyperTwistTrainingRunState UHyperTwistTrainingSubsystem::StartTrainingRunFromDe
 	RetainedRepositoryViewUserId.Reset();
 	RetainedRepositoryViewDeckId.Reset();
 	RetainedRepositoryViewReferenceUtc.Reset();
+	ResetActiveLiveTimerState();
 	ActiveRunState = UHyperTwistTrainingLibrary::StartTrainingRun(Deck, UserId, SessionId, Mode);
 	ActiveRunState.ImportedGeneratedModeLaunchRequest = ActiveImportedGeneratedModeLaunchRequest;
 	bHasActiveRun = ActiveRunState.IsStructurallyValid();
@@ -4939,6 +4995,260 @@ FHyperTwistTrainingRunStepResult UHyperTwistTrainingSubsystem::SubmitTrainingAtt
 	return StepResult;
 }
 
+bool UHyperTwistTrainingSubsystem::StartActiveLiveTimer()
+{
+	if (HasActiveLiveTimer())
+	{
+		if (ActiveLiveTimerState.Phase == EHyperTwistTrainingLiveTimerPhase::Inspection)
+		{
+			return AdvanceActiveLiveTimerToSolvePhase();
+		}
+		if (ActiveLiveTimerState.Phase == EHyperTwistTrainingLiveTimerPhase::Solving)
+		{
+			return PauseActiveLiveTimer();
+		}
+		if (ActiveLiveTimerState.Phase == EHyperTwistTrainingLiveTimerPhase::Paused)
+		{
+			return ResumeActiveLiveTimer();
+		}
+	}
+
+	if (!HasActiveRun()
+		|| !ActiveRunState.Session.IsStructurallyValid()
+		|| !ActiveRunState.CurrentSelection.TrainingCase.IsStructurallyValid())
+	{
+		return false;
+	}
+
+	const FHyperTwistTrainingTimingPolicy TimingPolicy =
+		UHyperTwistTrainingLibrary::NormalizeTimingPolicy(ActiveRunState.ActiveDeck.TimingPolicy);
+	const bool bUseInspection = TimingPolicy.bInspectionEnabled && TimingPolicy.InspectionDurationMs > 0;
+	const double NowSeconds = FPlatformTime::Seconds();
+	const FString NowUtc = FDateTime::UtcNow().ToIso8601();
+
+	ResetActiveLiveTimerState();
+	ActiveLiveTimerState.TrainingSessionId = ActiveRunState.Session.TrainingSessionId;
+	ActiveLiveTimerState.UserId = ActiveRunState.Session.UserId;
+	ActiveLiveTimerState.DeckId = !ActiveRunState.ActiveDeck.DeckId.IsEmpty()
+		? ActiveRunState.ActiveDeck.DeckId
+		: ActiveRunState.Session.DeckId;
+	ActiveLiveTimerState.CaseId = ActiveRunState.CurrentSelection.TrainingCase.CaseId;
+	ActiveLiveTimerState.StartedAtUtc = NowUtc;
+	ActiveLiveTimerState.LastUpdatedAtUtc = NowUtc;
+	ActiveLiveTimerState.Phase = bUseInspection
+		? EHyperTwistTrainingLiveTimerPhase::Inspection
+		: EHyperTwistTrainingLiveTimerPhase::Solving;
+	ActiveLiveTimerState.ResumePhase = ActiveLiveTimerState.Phase;
+	ActiveLiveTimerState.TimingPolicy = TimingPolicy;
+	ActiveLiveTimerState.bHasInspectionWindow = bUseInspection;
+	ActiveLiveTimerState.InspectionLimitMs = bUseInspection ? FMath::Max(TimingPolicy.InspectionDurationMs, 0) : 0;
+	ActiveLiveTimerState.bHideRunningTime = TimingPolicy.bHideRunningTime;
+	ActiveLiveTimerStartedAtSeconds = NowSeconds;
+	ActiveLiveTimerSolveStartedAtSeconds = bUseInspection ? 0.0 : NowSeconds;
+	RefreshActiveLiveTimerState();
+	return HasActiveLiveTimer();
+}
+
+bool UHyperTwistTrainingSubsystem::AdvanceActiveLiveTimerToSolvePhase()
+{
+	RefreshActiveLiveTimerState();
+	if (!HasActiveLiveTimer() || ActiveLiveTimerState.Phase != EHyperTwistTrainingLiveTimerPhase::Inspection)
+	{
+		return false;
+	}
+
+	ActiveLiveTimerStoredInspectionElapsedMs = ActiveLiveTimerState.InspectionElapsedMs;
+	ActiveLiveTimerStoredSolveElapsedMs = 0;
+	ActiveLiveTimerSolveStartedAtSeconds = FPlatformTime::Seconds();
+	ActiveLiveTimerPausedAtSeconds = 0.0;
+	ActiveLiveTimerState.Phase = EHyperTwistTrainingLiveTimerPhase::Solving;
+	ActiveLiveTimerState.ResumePhase = EHyperTwistTrainingLiveTimerPhase::Solving;
+	RefreshActiveLiveTimerState();
+	return true;
+}
+
+bool UHyperTwistTrainingSubsystem::PauseActiveLiveTimer()
+{
+	RefreshActiveLiveTimerState();
+	if (!HasActiveLiveTimer() || ActiveLiveTimerState.Phase != EHyperTwistTrainingLiveTimerPhase::Solving)
+	{
+		return false;
+	}
+
+	ActiveLiveTimerStoredInspectionElapsedMs = ActiveLiveTimerState.InspectionElapsedMs;
+	ActiveLiveTimerStoredSolveElapsedMs = ActiveLiveTimerState.SolveElapsedMs;
+	ActiveLiveTimerPausedAtSeconds = FPlatformTime::Seconds();
+	ActiveLiveTimerState.Phase = EHyperTwistTrainingLiveTimerPhase::Paused;
+	ActiveLiveTimerState.ResumePhase = EHyperTwistTrainingLiveTimerPhase::Solving;
+	RefreshActiveLiveTimerState();
+
+	if (ActiveRunState.ReplayPacket.ReplayId.Len() > 0)
+	{
+		FHyperTwistReplayEvent ReplayEvent;
+		ReplayEvent.EventType = EHyperTwistReplayEventType::Pause;
+		ReplayEvent.TimeMs = HyperTwistTrainingSubsystemInternal::ResolveLiveTimerReplayTimeMs(ActiveLiveTimerState);
+		ActiveRunState.ReplayPacket = UHyperTwistReplayLibrary::AppendReplayEvent(ActiveRunState.ReplayPacket, ReplayEvent);
+		ActiveRunState.LastReplayEvent = ActiveRunState.ReplayPacket.Events.Last();
+	}
+
+	return true;
+}
+
+bool UHyperTwistTrainingSubsystem::ResumeActiveLiveTimer()
+{
+	RefreshActiveLiveTimerState();
+	if (!HasActiveLiveTimer() || ActiveLiveTimerState.Phase != EHyperTwistTrainingLiveTimerPhase::Paused)
+	{
+		return false;
+	}
+
+	const double NowSeconds = FPlatformTime::Seconds();
+	if (ActiveLiveTimerPausedAtSeconds > 0.0)
+	{
+		ActiveLiveTimerState.TotalPausedMs += FMath::Max(
+			0,
+			static_cast<int32>((NowSeconds - ActiveLiveTimerPausedAtSeconds) * 1000.0)
+		);
+	}
+
+	const EHyperTwistTrainingLiveTimerPhase ResumePhase =
+		ActiveLiveTimerState.ResumePhase == EHyperTwistTrainingLiveTimerPhase::Idle
+			? EHyperTwistTrainingLiveTimerPhase::Solving
+			: ActiveLiveTimerState.ResumePhase;
+	if (ResumePhase == EHyperTwistTrainingLiveTimerPhase::Inspection)
+	{
+		ActiveLiveTimerStartedAtSeconds = NowSeconds;
+	}
+	else
+	{
+		ActiveLiveTimerSolveStartedAtSeconds = NowSeconds;
+	}
+
+	ActiveLiveTimerPausedAtSeconds = 0.0;
+	ActiveLiveTimerState.Phase = ResumePhase;
+	ActiveLiveTimerState.ResumePhase = ResumePhase;
+	RefreshActiveLiveTimerState();
+
+	if (ActiveRunState.ReplayPacket.ReplayId.Len() > 0)
+	{
+		FHyperTwistReplayEvent ReplayEvent;
+		ReplayEvent.EventType = EHyperTwistReplayEventType::Resume;
+		ReplayEvent.TimeMs = HyperTwistTrainingSubsystemInternal::ResolveLiveTimerReplayTimeMs(ActiveLiveTimerState);
+		ActiveRunState.ReplayPacket = UHyperTwistReplayLibrary::AppendReplayEvent(ActiveRunState.ReplayPacket, ReplayEvent);
+		ActiveRunState.LastReplayEvent = ActiveRunState.ReplayPacket.Events.Last();
+	}
+
+	return true;
+}
+
+void UHyperTwistTrainingSubsystem::CancelActiveLiveTimer()
+{
+	ResetActiveLiveTimerState();
+}
+
+bool UHyperTwistTrainingSubsystem::CaptureActiveLiveTimerSplit()
+{
+	RefreshActiveLiveTimerState();
+	if (!HasActiveLiveTimer() || ActiveLiveTimerState.Phase != EHyperTwistTrainingLiveTimerPhase::Solving)
+	{
+		return false;
+	}
+
+	const int32 MaxManualSplitCaptureCount =
+		ActiveLiveTimerState.TimingPolicy.SplitPhases.Num() > 1
+			? ActiveLiveTimerState.TimingPolicy.SplitPhases.Num() - 1
+			: 0;
+	const int32 NextPhaseIndex = ActiveLiveTimerState.SplitCaptures.Num();
+	if (MaxManualSplitCaptureCount <= 0
+		|| NextPhaseIndex >= MaxManualSplitCaptureCount
+		|| !ActiveLiveTimerState.TimingPolicy.SplitPhases.IsValidIndex(NextPhaseIndex))
+	{
+		return false;
+	}
+
+	const FHyperTwistTrainingSplitPhaseDefinition& NextPhaseDefinition =
+		ActiveLiveTimerState.TimingPolicy.SplitPhases[NextPhaseIndex];
+	FHyperTwistTrainingSplitCapture SplitCapture;
+	SplitCapture.PhaseId = NextPhaseDefinition.PhaseId;
+	SplitCapture.Label = NextPhaseDefinition.Label;
+	SplitCapture.TimestampMs = FMath::Max(ActiveLiveTimerState.SolveElapsedMs, 0);
+	ActiveLiveTimerState.SplitCaptures.Add(SplitCapture);
+	ActiveLiveTimerState.LastUpdatedAtUtc = FDateTime::UtcNow().ToIso8601();
+	return true;
+}
+
+bool UHyperTwistTrainingSubsystem::UndoActiveLiveTimerSplit()
+{
+	RefreshActiveLiveTimerState();
+	if (!HasActiveLiveTimer()
+		|| (ActiveLiveTimerState.Phase != EHyperTwistTrainingLiveTimerPhase::Solving
+			&& ActiveLiveTimerState.Phase != EHyperTwistTrainingLiveTimerPhase::Paused)
+		|| ActiveLiveTimerState.SplitCaptures.Num() <= 0)
+	{
+		return false;
+	}
+
+	ActiveLiveTimerState.SplitCaptures.RemoveAt(ActiveLiveTimerState.SplitCaptures.Num() - 1);
+	ActiveLiveTimerState.LastUpdatedAtUtc = FDateTime::UtcNow().ToIso8601();
+	return true;
+}
+
+FHyperTwistTrainingRunStepResult UHyperTwistTrainingSubsystem::SubmitActiveLiveTimedAttempt(
+	const EHyperTwistTrainingAttemptResult Result
+)
+{
+	FHyperTwistTrainingRunStepResult StepResult;
+	RefreshActiveLiveTimerState();
+	if (!HasActiveLiveTimer()
+		|| (ActiveLiveTimerState.Phase != EHyperTwistTrainingLiveTimerPhase::Solving
+			&& ActiveLiveTimerState.Phase != EHyperTwistTrainingLiveTimerPhase::Paused)
+		|| !HasActiveRun()
+		|| !ActiveRunState.Session.IsStructurallyValid()
+		|| !ActiveRunState.CurrentSelection.TrainingCase.IsStructurallyValid())
+	{
+		return StepResult;
+	}
+
+	FHyperTwistTrainingAttempt Attempt;
+	Attempt.AttemptId = FString::Printf(
+		TEXT("attempt_%s_%s"),
+		*ActiveRunState.Session.TrainingSessionId,
+		*FGuid::NewGuid().ToString(EGuidFormats::Digits)
+	);
+	Attempt.TrainingSessionId = ActiveRunState.Session.TrainingSessionId;
+	Attempt.CaseId = ActiveRunState.CurrentSelection.TrainingCase.CaseId;
+	Attempt.Result = Result;
+	Attempt.TotalTimeMs = FMath::Max(ActiveLiveTimerState.SolveElapsedMs, 0);
+	Attempt.ExecutionTimeMs = FMath::Max(ActiveLiveTimerState.SolveElapsedMs, 0);
+	Attempt.TimingBreakdown.InspectionElapsedMs = FMath::Max(ActiveLiveTimerState.InspectionElapsedMs, 0);
+	Attempt.TimingBreakdown.RawSolveTimeMs = FMath::Max(ActiveLiveTimerState.SolveElapsedMs, 0);
+	Attempt.TimingBreakdown.FinalTimeMs = FMath::Max(ActiveLiveTimerState.SolveElapsedMs, 0);
+	Attempt.TimingBreakdown.InspectionPenalty = ActiveLiveTimerState.InspectionPenalty;
+	Attempt.TimingBreakdown.ManualPenalty =
+		Result == EHyperTwistTrainingAttemptResult::DNF
+			? EHyperTwistTrainingPenalty::DNF
+			: ActiveLiveTimerState.ManualPenalty;
+	Attempt.TimingBreakdown.AppliedPenalty =
+		Result == EHyperTwistTrainingAttemptResult::DNF
+			? EHyperTwistTrainingPenalty::DNF
+			: ActiveLiveTimerState.PendingPenalty;
+	Attempt.TimingBreakdown.SplitCaptures = ActiveLiveTimerState.SplitCaptures;
+	Attempt.TimingBreakdown.bDidNotFinish =
+		Result == EHyperTwistTrainingAttemptResult::Timeout
+		|| Result == EHyperTwistTrainingAttemptResult::DNF
+		|| Result == EHyperTwistTrainingAttemptResult::Aborted;
+	Attempt.ReplayId = ActiveRunState.ReplayPacket.ReplayId;
+	Attempt.CompletedAtUtc = FDateTime::UtcNow().ToIso8601();
+
+	StepResult = SubmitTrainingAttempt(Attempt, FMath::Max(ActiveLiveTimerState.SolveElapsedMs, 0));
+	if (StepResult.IsStructurallyValid())
+	{
+		ResetActiveLiveTimerState();
+	}
+
+	return StepResult;
+}
+
 FHyperTwistTrainingSession UHyperTwistTrainingSubsystem::CompleteActiveRun(bool bAbortSession)
 {
 	if (!HasActiveRun())
@@ -4952,6 +5262,8 @@ FHyperTwistTrainingSession UHyperTwistTrainingSubsystem::CompleteActiveRun(bool
 		CloseActiveRecognitionSession(CloseError);
 	}
 
+	ResetActiveLiveTimerState();
+
 	ActiveRunState.Session = UHyperTwistTrainingLibrary::CompleteTrainingSession(ActiveRunState.Session, bAbortSession);
 	ActiveRunState.CurrentSelection = FHyperTwistTrainingCaseSelection();
 	ActiveRunState.RemainingCaseIds.Reset();
@@ -5018,6 +5330,7 @@ void UHyperTwistTrainingSubsystem::ClearActiveRun()
 		FString CloseError;
 		CloseActiveRecognitionSession(CloseError);
 	}
+	ResetActiveLiveTimerState();
 	RetainedRepositoryViewUserId = !ActiveRunState.Session.UserId.IsEmpty()
 		? ActiveRunState.Session.UserId
 		: (!ActiveCoachBrief.UserId.IsEmpty() ? ActiveCoachBrief.UserId : ActiveCoachSessionQueueSummary.UserId);
@@ -5772,6 +6085,126 @@ void UHyperTwistTrainingSubsystem::RefreshSummary()
 	);
 }
 
+void UHyperTwistTrainingSubsystem::ResetActiveLiveTimerState()
+{
+	ActiveLiveTimerState = FHyperTwistTrainingLiveTimerState();
+	ActiveLiveTimerStartedAtSeconds = 0.0;
+	ActiveLiveTimerSolveStartedAtSeconds = 0.0;
+	ActiveLiveTimerPausedAtSeconds = 0.0;
+	ActiveLiveTimerStoredInspectionElapsedMs = 0;
+	ActiveLiveTimerStoredSolveElapsedMs = 0;
+}
+
+void UHyperTwistTrainingSubsystem::RefreshActiveLiveTimerState()
+{
+	if (!HasActiveRun()
+		|| !ActiveRunState.Session.IsStructurallyValid()
+		|| !ActiveRunState.CurrentSelection.TrainingCase.IsStructurallyValid())
+	{
+		ResetActiveLiveTimerState();
+		return;
+	}
+
+	if (ActiveLiveTimerState.Phase == EHyperTwistTrainingLiveTimerPhase::Idle)
+	{
+		return;
+	}
+
+	if (ActiveLiveTimerState.TrainingSessionId != ActiveRunState.Session.TrainingSessionId
+		|| ActiveLiveTimerState.CaseId != ActiveRunState.CurrentSelection.TrainingCase.CaseId)
+	{
+		ResetActiveLiveTimerState();
+		return;
+	}
+
+	ActiveLiveTimerState = BuildActiveLiveTimerStateSnapshot(
+		FPlatformTime::Seconds(),
+		FDateTime::UtcNow().ToIso8601()
+	);
+}
+
+FHyperTwistTrainingLiveTimerState UHyperTwistTrainingSubsystem::BuildActiveLiveTimerStateSnapshot(
+	const double NowSeconds,
+	const FString& NowUtc
+) const
+{
+	FHyperTwistTrainingLiveTimerState Snapshot = ActiveLiveTimerState;
+	if (!ActiveRunState.Session.IsStructurallyValid()
+		|| !ActiveRunState.CurrentSelection.TrainingCase.IsStructurallyValid()
+		|| Snapshot.Phase == EHyperTwistTrainingLiveTimerPhase::Idle)
+	{
+		return Snapshot;
+	}
+
+	Snapshot.TrainingSessionId = ActiveRunState.Session.TrainingSessionId;
+	Snapshot.UserId = ActiveRunState.Session.UserId;
+	Snapshot.DeckId = !ActiveRunState.ActiveDeck.DeckId.IsEmpty()
+		? ActiveRunState.ActiveDeck.DeckId
+		: ActiveRunState.Session.DeckId;
+	Snapshot.CaseId = ActiveRunState.CurrentSelection.TrainingCase.CaseId;
+	Snapshot.TimingPolicy = UHyperTwistTrainingLibrary::NormalizeTimingPolicy(ActiveRunState.ActiveDeck.TimingPolicy);
+	Snapshot.bHasInspectionWindow =
+		Snapshot.TimingPolicy.bInspectionEnabled && Snapshot.TimingPolicy.InspectionDurationMs > 0;
+	Snapshot.InspectionLimitMs = Snapshot.bHasInspectionWindow
+		? FMath::Max(Snapshot.TimingPolicy.InspectionDurationMs, 0)
+		: 0;
+	Snapshot.bHideRunningTime = Snapshot.TimingPolicy.bHideRunningTime;
+	Snapshot.LastUpdatedAtUtc = NowUtc;
+	if (Snapshot.StartedAtUtc.IsEmpty())
+	{
+		Snapshot.StartedAtUtc = NowUtc;
+	}
+
+	int32 InspectionElapsedMs = FMath::Max(ActiveLiveTimerStoredInspectionElapsedMs, 0);
+	int32 SolveElapsedMs = FMath::Max(ActiveLiveTimerStoredSolveElapsedMs, 0);
+	switch (Snapshot.Phase)
+	{
+	case EHyperTwistTrainingLiveTimerPhase::Inspection:
+		InspectionElapsedMs += FMath::Max(
+			0,
+			static_cast<int32>((NowSeconds - ActiveLiveTimerStartedAtSeconds) * 1000.0)
+		);
+		SolveElapsedMs = 0;
+		Snapshot.DisplayedElapsedMs = InspectionElapsedMs;
+		Snapshot.ResumePhase = EHyperTwistTrainingLiveTimerPhase::Inspection;
+		break;
+	case EHyperTwistTrainingLiveTimerPhase::Solving:
+		SolveElapsedMs += FMath::Max(
+			0,
+			static_cast<int32>((NowSeconds - ActiveLiveTimerSolveStartedAtSeconds) * 1000.0)
+		);
+		Snapshot.DisplayedElapsedMs = SolveElapsedMs;
+		Snapshot.ResumePhase = EHyperTwistTrainingLiveTimerPhase::Solving;
+		break;
+	case EHyperTwistTrainingLiveTimerPhase::Paused:
+		Snapshot.DisplayedElapsedMs =
+			Snapshot.ResumePhase == EHyperTwistTrainingLiveTimerPhase::Inspection
+				? InspectionElapsedMs
+				: SolveElapsedMs;
+		break;
+	case EHyperTwistTrainingLiveTimerPhase::Completed:
+		Snapshot.DisplayedElapsedMs = SolveElapsedMs;
+		break;
+	default:
+		InspectionElapsedMs = 0;
+		SolveElapsedMs = 0;
+		Snapshot.DisplayedElapsedMs = 0;
+		break;
+	}
+
+	Snapshot.InspectionElapsedMs = InspectionElapsedMs;
+	Snapshot.SolveElapsedMs = SolveElapsedMs;
+	Snapshot.InspectionPenalty = HyperTwistTrainingSubsystemInternal::ComputeInspectionPenalty(
+		InspectionElapsedMs,
+		Snapshot.TimingPolicy
+	);
+	Snapshot.PendingPenalty = HyperTwistTrainingSubsystemInternal::CombinePenalties(
+		Snapshot.InspectionPenalty,
+		Snapshot.ManualPenalty
+	);
+	return Snapshot;
+}
+
 void UHyperTwistTrainingSubsystem::RefreshMethodDrillSummary()
 {
 	if (!ActiveMethodDrillRunState.IsStructurallyValid())

UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h

@@ -13,6 +13,7 @@ enum class EHyperTwistCoachDashboardAttemptPhase : uint8
 {
 	Idle,
 	Inspection,
+	Paused,
 	Solving
 };
 
@@ -1983,6 +1984,7 @@ private:
 	void SyncPreferredGuidancePreviewLane(bool bForceAdoptPreferredLane);
 	void UpdateDashboardPresentation();
 	void RefreshLiveAttemptClock();
+	void SyncLiveAttemptStateFromSubsystem();
 	FString BuildDefaultDeferredUntilUtc() const;
 	FString FindFirstDeferredQueueEntryId() const;
 	bool TryParseAttemptTimeOverride(int32& OutTimeMs) const;
@@ -2102,9 +2104,6 @@ private:
 	const FHyperTwistTrainingSplitPhaseDefinition* FindNextSplitPhaseToCapture() const;
 
 	EHyperTwistCoachDashboardAttemptPhase LiveAttemptPhase = EHyperTwistCoachDashboardAttemptPhase::Idle;
-	double LiveAttemptStartedAtSeconds = 0.0;
-	double LiveAttemptSolveStartedAtSeconds = 0.0;
-	int32 LiveAttemptStoredInspectionElapsedMs = 0;
 	int32 LastObservedAttemptCount = INDEX_NONE;
 	bool bHasRetainedRunRecap = false;
 	FHyperTwistTrainingSessionSummary RetainedRunRecapSummary;

UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h

@@ -83,6 +83,12 @@ public:
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training")
 	FHyperTwistTrainingSessionSummary GetActiveRunSummary() const;
 
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training")
+	bool HasActiveLiveTimer() const;
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	FHyperTwistTrainingLiveTimerState GetActiveLiveTimerState();
+
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Drill")
 	FHyperTwistTrainingMethodDrillSummary GetActiveMethodDrillSummary() const;
 
@@ -544,6 +550,30 @@ public:
 		int32 TimeMs
 	);
 
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	bool StartActiveLiveTimer();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	bool AdvanceActiveLiveTimerToSolvePhase();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	bool PauseActiveLiveTimer();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	bool ResumeActiveLiveTimer();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	void CancelActiveLiveTimer();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	bool CaptureActiveLiveTimerSplit();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	bool UndoActiveLiveTimerSplit();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
+	FHyperTwistTrainingRunStepResult SubmitActiveLiveTimedAttempt(EHyperTwistTrainingAttemptResult Result);
+
 	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training")
 	FHyperTwistTrainingSession CompleteActiveRun(bool bAbortSession);
 
@@ -569,6 +599,12 @@ private:
 	void RefreshSummary();
 	void RefreshMethodDrillSummary();
 	void RefreshRepositoryViews();
+	void ResetActiveLiveTimerState();
+	void RefreshActiveLiveTimerState();
+	FHyperTwistTrainingLiveTimerState BuildActiveLiveTimerStateSnapshot(
+		double NowSeconds,
+		const FString& NowUtc
+	) const;
 	FHyperTwistVisionSessionConfig BuildActiveRecognitionSessionConfig() const;
 	UObject* ResolveRecognitionVisionClientObject();
 	void RefreshRecognitionServiceHealth();
@@ -596,6 +632,9 @@ private:
 	UPROPERTY()
 	FHyperTwistTrainingSessionSummary ActiveRunSummary;
 
+	UPROPERTY()
+	FHyperTwistTrainingLiveTimerState ActiveLiveTimerState;
+
 	UPROPERTY()
 	FString RetainedRepositoryViewUserId;
 
@@ -745,4 +784,10 @@ private:
 
 	UPROPERTY()
 	bool bHasActiveMethodDrillRun = false;
+
+	double ActiveLiveTimerStartedAtSeconds = 0.0;
+	double ActiveLiveTimerSolveStartedAtSeconds = 0.0;
+	double ActiveLiveTimerPausedAtSeconds = 0.0;
+	int32 ActiveLiveTimerStoredInspectionElapsedMs = 0;
+	int32 ActiveLiveTimerStoredSolveElapsedMs = 0;
 };

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

@@ -168,6 +168,16 @@ enum class EHyperTwistTrainingPenalty : uint8
 	DNF UMETA(DisplayName = "DNF")
 };
 
+UENUM(BlueprintType)
+enum class EHyperTwistTrainingLiveTimerPhase : uint8
+{
+	Idle UMETA(DisplayName = "Idle"),
+	Inspection UMETA(DisplayName = "Inspection"),
+	Solving UMETA(DisplayName = "Solving"),
+	Paused UMETA(DisplayName = "Paused"),
+	Completed UMETA(DisplayName = "Completed")
+};
+
 UENUM(BlueprintType)
 enum class EHyperTwistTrainingReviewGrade : uint8
 {
@@ -398,6 +408,85 @@ struct FHyperTwistTrainingTimingBreakdown
 	}
 };
 
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingLiveTimerState
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString TrainingSessionId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString UserId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString DeckId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString CaseId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString StartedAtUtc;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString LastUpdatedAtUtc;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	EHyperTwistTrainingLiveTimerPhase Phase = EHyperTwistTrainingLiveTimerPhase::Idle;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	EHyperTwistTrainingLiveTimerPhase ResumePhase = EHyperTwistTrainingLiveTimerPhase::Idle;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingTimingPolicy TimingPolicy;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 InspectionLimitMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 InspectionElapsedMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 SolveElapsedMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 DisplayedElapsedMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 TotalPausedMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	EHyperTwistTrainingPenalty InspectionPenalty = EHyperTwistTrainingPenalty::None;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	EHyperTwistTrainingPenalty ManualPenalty = EHyperTwistTrainingPenalty::None;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	EHyperTwistTrainingPenalty PendingPenalty = EHyperTwistTrainingPenalty::None;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingSplitCapture> SplitCaptures;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHasInspectionWindow = false;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bHideRunningTime = false;
+
+	bool IsStructurallyValid() const
+	{
+		return Phase == EHyperTwistTrainingLiveTimerPhase::Idle
+			|| (!TrainingSessionId.IsEmpty() && !DeckId.IsEmpty() && !CaseId.IsEmpty());
+	}
+
+	bool IsActive() const
+	{
+		return Phase == EHyperTwistTrainingLiveTimerPhase::Inspection
+			|| Phase == EHyperTwistTrainingLiveTimerPhase::Solving
+			|| Phase == EHyperTwistTrainingLiveTimerPhase::Paused;
+	}
+};
+
 USTRUCT(BlueprintType)
 struct FHyperTwistTrainingCase
 {
@@ -1848,6 +1937,9 @@ struct FHyperTwistTrainingRollingWindowStat
 {
 	GENERATED_BODY()
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString WindowLabel;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	int32 WindowSize = 0;
 
@@ -1857,6 +1949,9 @@ struct FHyperTwistTrainingRollingWindowStat
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	bool bWindowFilled = false;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	bool bTrimExtremes = false;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	int32 CurrentAverageTotalTimeMs = 0;
 
@@ -1899,6 +1994,18 @@ struct FHyperTwistTrainingTimingTrendSummary
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	int32 BestSingleRawSolveTimeMs = 0;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 WorstSingleTotalTimeMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 WorstSingleRawSolveTimeMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 MeanTotalTimeMs = 0;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	int32 MeanRawSolveTimeMs = 0;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	FString LastSolveAtUtc;
 

docs/EXTERNAL_MIRROR_WORKSPACE_AND_SUBMODULE_HANDOFF.md

@@ -241,12 +241,12 @@ Practical rule:
 For HyperTwist specifically, the mirror/handoff model must now carry one additional explicit truth:
 
 - current curated shallow-eval set: `71` repos
-- currently verified live in checked `UnrealHyperTwist` surfaces: `6`
-- permissive live lanes: `5`
+- currently verified live in checked `UnrealHyperTwist` surfaces: `7`
+- permissive live lanes: `6`
 - restrictive live lane: `1`
 - the restrictive live lane is `onionhoney/roux-trainers`
 - that lane is to be treated as properly clean-roomed and then implemented
-- `Phase 0R` is now closed for the remaining `65` non-live rows
+- `Phase 0R` is now closed for the remaining `64` non-live rows
 - `Phase 1R` is now closed as the retained-set contract and handoff layer
 - the six already-live rows now also have a dedicated source-backed preservation authority doc
 - `Phase 2R-A` is now closed as the core ownership and acceptance authority for the five retained permissive anchor rows

docs/HT_REPO_INCORPORATION_AUDIT_2026-05-11.md

@@ -8,6 +8,11 @@ Important correction added on `2026-05-11`:
 - the live restrictive surfaces found in this pass should therefore be read as evidence of a landed clean-room lane, not as proof of an unresolved accidental donor import.
 - the current next move for that lane is documentation parity and continued explicit custody, not mass quarantine by default.
 
+Important correction added on `2026-05-13`:
+
+- `Aarav2709/KubeTimr` is now a currently verified live permissive lane through `Phase 3R-A`.
+- it is live through first-party Unreal source implementation rather than the materialized training-catalog bundle path used by the earlier five permissive donor lanes in this audit.
+
 ## Scope
 
 - Current repo set audited: the 71 `HyperTwist` rows in `docs/repo_portfolio_unified_source_audit_v6_3.csv`.
@@ -56,7 +61,6 @@ Important correction added on `2026-05-11`:
     - `MagicTile`
     - `MagicCube5D`
     - `TalkingHead`
-    - `KubeTimr`
 
 ## Permissive bucket
 
@@ -74,6 +78,14 @@ These are not just planned in docs. They are materially present in `UnrealHyperT
 | `poliva/cubedex` | MIT | integrate | 199 | 1575 | Broadest live direct-donor deck manifest surface in this pass |
 | `newyork-anthonyng/rubiks-cross-trainer` | MIT | repurpose | 8 | 8000 | Large live repo-backed cross-training surface |
 
+### Live code-backed
+
+These rows are now materially present in checked first-party Unreal source, even though they are not represented through the materialized training-catalog donor manifests used by the earlier five permissive lanes.
+
+| Repo | License | Current docs posture | First-party evidence | Notes |
+| --- | --- | --- | --- | --- |
+| `Aarav2709/KubeTimr` | MIT | landed via `Phase 3R-A` | `HyperTwistTrainingTypes.h`; `HyperTwistTrainingSubsystem.h/.cpp`; `HyperTwistTrainingRepositoryLibrary.cpp`; `HyperTwistCoachDashboardWidget.h/.cpp` | Shared timer-state machine, pause/resume, split capture, timer-scoped replay, and deeper rolling stats now landed in first-party source |
+
 ### Partly implemented
 
 No exact `source_attribution_only` rows were found in the audited 71-repo set.
@@ -280,7 +292,7 @@ That does not make them legally cleared or deeply audited. It only means this pa
 
 ## Recommended next implementation slice
 
-The next clean bounded move is to preserve the six landed lanes as the current truth, make the `onionhoney/roux-trainers` clean-room status explicit everywhere, and then start the repo deep source integration evaluation reset for the remaining `65` rows. After that, do a second pass focused on the additional live non-71 surfaces (`SpeedCubeDB` and `CubingApp`) so the active training catalog has a complete provenance board before any further widening work resumes.
+The next clean bounded move is to preserve the seven landed lanes as the current truth, keep the `onionhoney/roux-trainers` clean-room status explicit everywhere, and continue from the closed retained-set packet sequence with `Phase 3R-B`. After that, do a second pass focused on the additional live non-71 surfaces (`SpeedCubeDB` and `CubingApp`) so the active training catalog has a complete provenance board before any further widening work resumes.
 
 For the readable all-rows follow-up board that pairs this audit with the reset schedule, use:
 

docs/HYPERTWIST_CANONICAL_RESTART_RECONCILIATION_2026-05-12.md

@@ -38,12 +38,13 @@ Current handling:
 The current reconciled HyperTwist truth is:
 
 - current curated HyperTwist shallow-eval set: `71` repos
-- currently verified live in checked `UnrealHyperTwist` surfaces: `6`
-- currently verified live permissive lanes: `5`
+- currently verified live in checked `UnrealHyperTwist` surfaces: `7`
+- currently verified live permissive lanes: `6`
 - currently verified live restrictive lanes: `1`
 
-The five currently verified live permissive lanes are:
+The six currently verified live permissive lanes are:
 
+- `Aarav2709/KubeTimr`
 - `abunickabhi/5style-Trainer`
 - `tao-yu/Alg-Trainer`
 - `Lykos/cube_trainer`
@@ -61,7 +62,7 @@ That restrictive lane must be treated as:
 - preserved as the current clean-room precedent
 - not to be reopened as an unresolved direct-donor contamination event
 
-The remaining `65` rows are not to be treated as already implemented.
+The remaining `64` rows are not to be treated as already implemented.
 
 `Phase 0R` is now closed for that non-live set.
 
@@ -108,7 +109,7 @@ The workspace repo remains the external control-plane and clean-room handoff sur
 
 It needed correction because:
 
-- the root `README.md` did not surface the current `71` / `6` / `5` / `1` truth
+- the root `README.md` did not surface the current `71` / `7` / `6` / `1` truth
 - clean-room notes still described `onionhoney/roux-trainers` as the current active next restrictive lane rather than the preserved already-landed restrictive precedent
 - `repos.manifest.json` did not surface the `Phase 0R` reset and still contained a stale app handoff pointer
 
@@ -146,14 +147,14 @@ Use the following only as lineage or historical context unless a restart doc exp
 
 The restart is not a mass revert.
 
-It is a provenance and planning reset around the remaining `65` rows while preserving the six already-landed lanes.
+It is a provenance and planning reset around the remaining `64` rows while preserving the seven already-landed lanes.
 
 Required standing rules:
 
-- preserve the six landed lanes
+- preserve the seven landed lanes
 - preserve `onionhoney/roux-trainers` as the only currently verified landed restrictive clean-room lane
 - do not collapse `selected`, `retained`, `integrate`, `repurpose`, or `donor bench` into `already implemented`
-- do not widen new donor-shaped implementation from the remaining `65` until `Phase 0R` and `Phase 1R` close
+- do not widen new donor-shaped implementation from the remaining `64` until the closed packet sequence routes it
 - before implementing any retained repo, read the packet-level deep-source authority doc for that repo class if one exists
 
 ## 2026-05-12 packet-depth correction
@@ -190,7 +191,7 @@ Practical implication:
 
 Goal:
 
-- deeply evaluate the remaining `65` rows repo by repo
+- deeply evaluate the remaining `64` rows repo by repo
 
 Required output per retained row:
 
@@ -463,15 +464,15 @@ Result:
 - `Packet 0R-D` is now the governance and Model A authority for the restrictive clean-room rows
 - `Packet 0R-E` is now the deep-source benchmark, reference, clean-room-later, and discard authority for its twelve rows
 - `Phase 1R` is now the retained-set contract and handoff authority for all post-`Phase 0R` routing
-- the six already-live rows now also have symmetric source-backed preservation authority through the live-lane audit
+- the seven already-live rows now also have symmetric source-backed preservation authority through the live-lane audit
 - `Phase 2R-A` is now the ownership and acceptance authority for the five core retained permissive rows
 - `Phase 2R-B` is now the ownership and acceptance authority for the primary retained permissive support-plane rows in scope
 - `Phase 2R-C` is now the ownership and acceptance authority for the final residual `0R-B` permissive rows
 - `Phase 2R` is now fully closed for the retained permissive set
-- none of those packet rows are currently proven live in checked Unreal surfaces
-- `Aarav2709/KubeTimr` is now the only `2R-A` row cleared for direct `Phase 3R` widening
+- `Phase 3R-A` is now the landed implementation authority for `Aarav2709/KubeTimr`
+- `Aarav2709/KubeTimr` is now the sixth permissive live lane and seventh live row overall
 - `HactarCE/Hyperspeedcube`, `kkoomen/qbr`, `vivaansinghvi07/rubix-cube-solver`, and `roice3/MagicTile` remain packetized for `Phase 6R`
-- `Aarav2709/KubeTimr` is the earliest straight permissive subsystem implementation candidate after `Phase 2R-A`
+- `Hypercubers/hypercubing.xyz` is now the next straight permissive implementation candidate after `Phase 3R-A`
 - `Hypercubers/hypercubing.xyz` is the retained knowledge/curriculum/community donor
 - `apache/echarts` is the retained analytics/reporting anchor
 - `google/model-viewer` plus `KhronosGroup/glTF-Sample-Viewer` are now the retained browser presentation/editor and standards-QA `3R-D` lane
@@ -503,6 +504,7 @@ License-tracking boundary:
 
 The next bounded move is:
 
-1. keep `Phase 3R+` widening frozen
-2. open `Phase 3R-A`
-3. widen `Aarav2709/KubeTimr` as the bounded timer, inspection, splits, stats, persistence, and timer-scoped replay entry lane
+1. preserve the seven landed rows as the current truth
+2. keep `Aarav2709/KubeTimr` on preserve-and-enhance footing through its landed packet
+3. open `Phase 3R-B`
+4. widen `Hypercubers/hypercubing.xyz` as the retained knowledge, curriculum, notation, and community lane

docs/HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md

@@ -6,12 +6,12 @@ Created on `2026-05-13`
 
 This audit is `closed`.
 
-It is the canonical source-backed preservation authority for the six HyperTwist rows that are already live in checked first-party Unreal surfaces.
+It is the canonical source-backed preservation authority for the seven HyperTwist rows that are already live in checked first-party Unreal surfaces.
 
 It closes the symmetry gap that remained after `Phase 0R` and `Phase 1R`:
 
-- the `65` non-live rows already have source-backed authority through `Packet 0R-A` through `Packet 0R-E`
-- the `6` live rows now have source-backed authority through this live-lane preservation audit
+- the `64` non-live rows already have source-backed authority through `Packet 0R-A` through `Packet 0R-E`
+- the `7` live rows now have source-backed authority through this live-lane preservation audit
 
 ## Purpose
 
@@ -27,7 +27,7 @@ Use this document to answer the live-lane questions that the `0R-*` packets do n
 
 This document intentionally separates permissive and restrictive handling:
 
-- the five permissive live lanes below are documented from donor mirror source plus first-party Unreal outputs
+- the six permissive live lanes below are documented from donor mirror source plus first-party Unreal outputs
 - the one restrictive live lane, `onionhoney/roux-trainers`, is documented here only from first-party Unreal outputs, `REPO_LICENSE_TRACKING.md`, and scrubbed clean-room materials
 
 Do not use this document as permission for `Model B` to read the restrictive mirror.
@@ -37,26 +37,28 @@ Do not use this document as permission for `Model B` to read the restrictive mir
 Current result:
 
 - current curated HyperTwist shallow-eval set: `71`
-- already covered by `0R-A` through `0R-E`: `65` non-live rows
-- covered by this audit: `6` live rows
+- already covered by `0R-A` through `0R-E`: `64` non-live rows
+- covered by this audit: `7` live rows
 - total rows with source-backed authority now visible in canonical docs: `71`
-- live permissive preserve lanes: `5`
+- live permissive preserve lanes: `6`
 - live restrictive clean-room preserve lanes: `1`
-- additional live rows discovered beyond the existing six: `0`
+- additional live rows discovered beyond the original six from the 2026-05-11 audit: `1`
 
 ## Authority order
 
 For future work on the already-live lanes, read in this order:
 
 1. this live-lane audit
-2. [HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md:1)
-3. [REPO_LICENSE_TRACKING.md](C:/HyperTwist/docs/REPO_LICENSE_TRACKING.md:1)
-4. [MODEL_B_SOURCE_ACCESS_BOUNDARY.md](C:/HyperTwist/docs/MODEL_B_SOURCE_ACCESS_BOUNDARY.md:1) for the `onionhoney/roux-trainers` lane
+2. the relevant landed implementation packet where one exists, currently [HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md:1) for `Aarav2709/KubeTimr`
+3. [HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md:1)
+4. [REPO_LICENSE_TRACKING.md](C:/HyperTwist/docs/REPO_LICENSE_TRACKING.md:1)
+5. [MODEL_B_SOURCE_ACCESS_BOUNDARY.md](C:/HyperTwist/docs/MODEL_B_SOURCE_ACCESS_BOUNDARY.md:1) for the `onionhoney/roux-trainers` lane
 
 ## Live-lane hierarchy
 
 | Repo | License posture | Current live role | Preserve as | Do not promote into |
 | --- | --- | --- | --- | --- |
+| `Aarav2709/KubeTimr` | `MIT` | landed timer, inspection, splits, persistence, and rolling-stats subsystem lane | the main landed permissive timer and timer-scoped replay preserve lane | general trainer-platform ownership, recognition ownership, or hyper-runtime ownership |
 | `tao-yu/Alg-Trainer` | `MIT` | broad algorithm-training shell and case-corpus foundation | the main landed permissive algorithm-trainer foundation | persisted coaching backend or smartcube-first review shell |
 | `Lykos/cube_trainer` | `MIT` | persisted coaching, weighted sampling, and BLD-domain lane | the main landed permissive training-session and coaching lane | broad front-end training-shell ownership |
 | `poliva/cubedex` | operational `MIT` posture in HyperTwist canon; checked mirror license surface incomplete | smartcube-aware practice, SRS, and review lane | the main landed permissive smartcube review and repetition lane | the sole case-corpus foundation or full backend owner |
@@ -165,6 +167,62 @@ Future widening rule:
 - widen only through ordinary first-party enhancement work
 - preserve the MIT notice and upstream credit to `Tao Yu`
 
+### `Aarav2709/KubeTimr`
+
+Current status:
+
+- `implemented_live_permissive`
+- preserve as a landed first-party permissive lane
+
+Licensing posture:
+
+- `MIT`
+- checked local `LICENSE` notice currently uses `Copyright (c) 2024 KubeTimr`
+
+Source surfaces inspected:
+
+- [README.md](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/README.md:1)
+- [LICENSE](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/LICENSE:1)
+- [src/timingEngine.ts](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/src/timingEngine.ts:3)
+- [src/statsEngine.ts](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/src/statsEngine.ts:189)
+- [src/splits.ts](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/src/splits.ts:26)
+- [src/persistence.ts](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/src/persistence.ts:3)
+
+First-party live evidence:
+
+- [HyperTwistTrainingTypes.h](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h:172)
+- [HyperTwistTrainingSubsystem.h](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h:87)
+- [HyperTwistTrainingSubsystem.cpp](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp:4998)
+- [HyperTwistTrainingRepositoryLibrary.cpp](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRepositoryLibrary.cpp:5856)
+- [HyperTwistCoachDashboardWidget.h](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h:1244)
+- [HyperTwistCoachDashboardWidget.cpp](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp:17566)
+
+Preserved landed value:
+
+- shared timer state ownership at the subsystem layer
+- inspection, pause, resume, and penalty semantics
+- split capture and ordered split undo behavior
+- local/offline persistence-facing timer behavior
+- rolling session statistics and deeper summary windows
+- timer-scoped replay pause and resume event behavior
+
+Excluded or non-promotion boundary:
+
+- do not promote this lane into broad training-platform ownership
+- do not promote it into recognition, correction, or camera-session ownership
+- do not promote it into hyper-runtime, topology, or general puzzle-runtime ownership
+
+Rationale:
+
+- this repo was retained and widened because it was the strongest bounded timer subsystem donor in the set
+- its strongest value is timer discipline, not broad product-shell ownership
+
+Future widening rule:
+
+- widen only through ordinary first-party enhancement work
+- preserve the MIT notice as checked locally
+- read the landed [HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md:1) before treating this lane as an open donor candidate again
+
 ### `Lykos/cube_trainer`
 
 Current status:

docs/HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md

@@ -66,20 +66,20 @@ Document responsibilities are now strict:
 Current post-`Phase 1R` truth:
 
 - curated HyperTwist shallow-eval set: `71`
-- currently verified live in checked Unreal surfaces: `6`
+- currently verified live in checked Unreal surfaces: `7`
 - rows with source-backed authority now visible in canonical docs: `71`
 - retained rows total: `68`
 - discarded from the active retained set: `3`
 
 Retained split:
 
-- landed/live preserve lanes: `6`
-- non-live active implementation-board rows: `53`
+- landed/live preserve lanes: `7`
+- non-live active implementation-board rows: `52`
 - non-live benchmark, oracle, or clean-room-later rows outside the active implementation board: `9`
 
-The `53` non-live active implementation-board rows break down as:
+The `52` non-live active implementation-board rows break down as:
 
-- straight permissive implementation candidates: `43`
+- straight permissive implementation candidates: `42`
 - boundary-sensitive adapter or sidecar candidates: `6`
 - restrictive clean-room-only candidates: `4`
 
@@ -87,7 +87,7 @@ The `53` non-live active implementation-board rows break down as:
 
 | Class | Count | Earliest next phase | Meaning |
 | --- | --- | --- | --- |
-| `landed_permissive_preserve` | `5` | ordinary first-party enhancement only | Already live. Preserve notices and attribution. Do not treat as speculative donor backlog. |
+| `landed_permissive_preserve` | `6` | ordinary first-party enhancement only | Already live. Preserve notices and attribution. Do not treat as speculative donor backlog. |
 | `landed_clean_room_preserve` | `1` | ordinary first-party enhancement only | Already live. Preserve the clean-room chain and work from first-party outputs, not the restrictive mirror. |
 | `phase3r_permissive_candidate` | `43` | `Phase 3R` | Retained for direct permissive implementation or bounded first-party adaptation. No clean-room lane is needed. |
 | `phase4r_boundary_candidate` | `6` | `Phase 4R` | Retained only through explicit adapter, allowlist, sidecar, or notice-sensitive use. |
@@ -106,10 +106,11 @@ The `53` non-live active implementation-board rows break down as:
 
 ## Landed preserve lanes
 
-These six rows are the only currently verified live rows in checked Unreal surfaces.
+These seven rows are the only currently verified live rows in checked Unreal surfaces.
 
 ### Landed permissive preserve
 
+- `Aarav2709/KubeTimr` — `MIT`
 - `abunickabhi/5style-Trainer` — `MIT`
 - `Lykos/cube_trainer` — `MIT`
 - `newyork-anthonyng/rubiks-cross-trainer` — `MIT`
@@ -143,7 +144,7 @@ These rows remain active for future widening, but only through their assigned cl
 - `HactarCE/Hyperspeedcube` — hyper runtime anchor -> `Phase 6R`
 - `kkoomen/qbr` — recognition anchor -> `Phase 6R`
 - `vivaansinghvi07/rubix-cube-solver` — recognition companion -> `Phase 6R`
-- `Aarav2709/KubeTimr` — earliest timer subsystem implementation candidate -> `Phase 3R`
+- `Aarav2709/KubeTimr` — landed timer subsystem preserve lane through `Phase 3R-A`
 - `roice3/MagicTile` — primary non-Euclidean/topology donor -> `Phase 6R`
 - `roice3/Magic120Cell` — later specialized `4D` donor
 - `roice3/MagicCube5D` — later specialized `5D` donor
@@ -152,9 +153,8 @@ Contract:
 
 - read `Packet 0R-A` before any widening
 - read [HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md:1) before implementing the five core rows above
-- route direct implementation only through:
-  - `Phase 3R` for `Aarav2709/KubeTimr`
-  - `Phase 6R` for `HactarCE/Hyperspeedcube`, `kkoomen/qbr`, `vivaansinghvi07/rubix-cube-solver`, and `roice3/MagicTile`
+- read [HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md:1) plus the live-lane audit before widening the already-landed `Aarav2709/KubeTimr` lane further
+- route remaining direct implementation only through `Phase 6R` for `HactarCE/Hyperspeedcube`, `kkoomen/qbr`, `vivaansinghvi07/rubix-cube-solver`, and `roice3/MagicTile`
 - do not reopen `Phase 0R` debate on these rows unless new source evidence appears
 
 ### `0R-B` retained permissive support set -> `Phase 2R-B` / `2R-C` split routing
@@ -313,19 +313,9 @@ Do not:
 
 ## Next move
 
-The next bounded move is `Phase 2R`:
+`Phase 2R` is now closed and `Phase 3R-A` is now also closed.
 
-- ratify the retained-set implementation board
-- turn these contract classes into concrete packets
-- define subsystem ownership, acceptance criteria, and packet entry points for `Phase 3R`, `4R`, and `5R`
+The next bounded move after those closures is `Phase 3R-B`:
 
-Current closure:
-
-- `Phase 2R-A` closes the core ownership and acceptance contracts for:
-  - `HactarCE/Hyperspeedcube`
-  - `kkoomen/qbr`
-  - `vivaansinghvi07/rubix-cube-solver`
-  - `Aarav2709/KubeTimr`
-  - `roice3/MagicTile`
-
-The next bounded move after that closure is `Phase 3R-A`.
+- widen `Hypercubers/hypercubing.xyz`
+- preserve `Aarav2709/KubeTimr` as the landed timer subsystem lane rather than reclassifying it as an open candidate

docs/HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md

@@ -254,4 +254,4 @@ The packeted dependency order is now explicit:
 
 This closes `Phase 2R` for the retained permissive set.
 
-The next bounded move is `Phase 3R-A`: widen `Aarav2709/KubeTimr` as the bounded timer, inspection, splits, stats, persistence, and timer-scoped replay entry lane. 
+The next bounded move is `Phase 3R-B`: widen `Hypercubers/hypercubing.xyz` as the retained knowledge, curriculum, notation, and community lane while preserving the landed `Aarav2709/KubeTimr` timer subsystem through its `3R-A` packet.

docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md

@@ -0,0 +1,149 @@
+# HyperTwist Phase 3R Packet 3R-A KubeTimr Implementation
+
+Created on `2026-05-13`
+
+## Status
+
+`Phase 3R / Packet 3R-A` is now `closed`.
+
+This packet converts `Aarav2709/KubeTimr` from a retained permissive implementation candidate into a landed first-party HyperTwist timer subsystem lane.
+
+It does not reopen `Phase 0R`, `Phase 1R`, or `Phase 2R-A`.
+
+Those earlier packets still own source-value extraction, retained-set routing, and ownership boundaries.
+
+This packet owns the next question instead:
+
+- what first-party implementation actually landed
+- which donor value was realized
+- what remains explicitly out of scope for this lane
+- what validation was completed
+- what the next bounded implementation move is after this landing
+
+## Authority order
+
+For future work on the `Aarav2709/KubeTimr` lane, read in this order:
+
+1. this packet for first-party landing scope, accepted widening, and validation result
+2. [HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md:1) for live-lane preserve posture
+3. [HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md:1) for ownership boundaries and pre-widening acceptance markers
+4. [HYPERTWIST_PHASE_0R_PACKET_0R_A_EVALUATION_2026-05-12.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_0R_PACKET_0R_A_EVALUATION_2026-05-12.md:1) for source-value extraction and non-promotion rationale
+5. [REPO_LICENSE_TRACKING.md](C:/HyperTwist/docs/REPO_LICENSE_TRACKING.md:1) for license and notice obligations
+
+## Packet licensing snapshot
+
+- `Aarav2709/KubeTimr`: `MIT`
+
+Checked local license note:
+
+- [LICENSE](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/LICENSE:1) currently uses the notice `Copyright (c) 2024 KubeTimr`
+
+## Packet result
+
+`3R-A` lands `Aarav2709/KubeTimr` as:
+
+- `implemented_live_permissive`
+- `landed_permissive_preserve`
+
+Current portfolio effect:
+
+- curated HyperTwist shallow-eval set: `71`
+- currently verified live in checked Unreal surfaces: `7`
+- permissive live lanes: `6`
+- restrictive live clean-room lanes: `1`
+- active non-live implementation-board rows: `52`
+
+## Donor source surfaces read
+
+The source read for this widening remained bounded to the retained timer/stats/splits/persistence domains:
+
+- [README.md](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/README.md:1)
+- [LICENSE](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/LICENSE:1)
+- [src/timingEngine.ts](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/src/timingEngine.ts:3)
+- [src/statsEngine.ts](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/src/statsEngine.ts:189)
+- [src/splits.ts](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/src/splits.ts:26)
+- [src/persistence.ts](C:/Workspaces/HyperTwist/mirrors/permissive/Aarav2709/KubeTimr/src/persistence.ts:3)
+
+## First-party landing surfaces
+
+The landed first-party Unreal surfaces are:
+
+- [HyperTwistTrainingTypes.h](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h:172)
+- [HyperTwistTrainingSubsystem.h](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h:87)
+- [HyperTwistTrainingSubsystem.cpp](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp:4998)
+- [HyperTwistTrainingRepositoryLibrary.cpp](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRepositoryLibrary.cpp:5856)
+- [HyperTwistCoachDashboardWidget.h](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h:1244)
+- [HyperTwistCoachDashboardWidget.cpp](C:/HyperTwist/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp:17566)
+
+## Landed implementation scope
+
+What landed:
+
+- a first-party shared live timer state machine with `Idle`, `Inspection`, `Solving`, `Paused`, and `Completed` phases
+- first-party inspection penalty handling and pause/resume behavior inside the training subsystem
+- first-party split capture and split undo behavior owned by the subsystem rather than the widget shell
+- timer-scoped replay pause/resume event emission
+- first-party widget delegation to the subsystem for start, solve-transition, pause, resume, submit, capture, and undo
+- expanded rolling-window and summary stats covering `mo3`, `ao5`, `ao12`, `ao50`, `ao100`, and `ao1000`
+- explicit worst and mean timing summary fields for total and raw solve time
+
+What that means in practice:
+
+- `Aarav2709/KubeTimr` now owns the landed permissive timer subsystem lane in HyperTwist
+- the coach dashboard no longer carries the live timer as widget-local hidden state
+- the timer/stats lane is now preserved as a first-party subsystem surface rather than a future donor candidate
+
+## Preserved landed value
+
+The donor value that was actually promoted is:
+
+- keyboard-first timer lifecycle discipline
+- inspection-window state and penalty semantics
+- split-phase capture and ordered split editing behavior
+- local/offline persistence posture
+- rolling session stats and PB-oriented summary behavior
+
+## Excluded or non-promotion boundary
+
+Do not promote this lane into:
+
+- the general training-platform owner
+- the case-corpus or curriculum owner
+- the recognition or reconstruction owner
+- the hyper-runtime or topology owner
+- a product-wide frontend-shell owner
+
+Rationale:
+
+- this repo was retained because it was the strongest focused timer subsystem donor in the set
+- its value is high precisely because it is bounded
+- broad trainer-shell ownership remains elsewhere in the landed and retained portfolio
+
+## Acceptance markers satisfied
+
+The `2R-A` acceptance markers for this row are now satisfied in first-party Unreal surfaces:
+
+- a first-party timer state contract exists
+- a first-party split contract exists
+- a first-party stats contract exists
+- a first-party persistence-facing timing lane exists
+- a first-party timer-scoped replay contract exists
+
+## Validation
+
+Validation completed for this packet:
+
+- `git diff --check` passed apart from CRLF conversion warnings
+- Unreal build succeeded with:
+  - `C:\Program Files\Epic Games\UE_5.7\Engine\Build\BatchFiles\Build.bat UnrealHyperTwistEditor Win64 Development C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject -WaitMutex -NoHotReloadFromIDE`
+
+Build result:
+
+- `Succeeded` on `2026-05-13`
+
+## Next move
+
+The next bounded move is `Phase 3R-B`:
+
+- widen `Hypercubers/hypercubing.xyz` as the retained knowledge, curriculum, notation, and community lane
+- keep the newly landed `KubeTimr` timer subsystem on preserve-and-enhance footing rather than treating it as an open donor candidate again

docs/HYPERTWIST_REPO_EVALUATION_RESET_AND_IMPLEMENTATION_SCHEDULE_2026-05-11.md

@@ -310,6 +310,32 @@ Next packet:
 
 - `3R-A`
 
+## 2026-05-13 Phase 3R-A status
+
+`Phase 3R / Packet 3R-A` is now closed.
+
+- `Phase 3R-A` result doc:
+  - `docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md`
+
+Implementation result:
+
+- `Aarav2709/KubeTimr` is now landed as a first-party timer, inspection, splits, stats, persistence, and timer-scoped replay lane
+- `Aarav2709/KubeTimr` is now `implemented_live_permissive`
+- current verified live rows are now:
+  - `7` total
+  - `6` permissive
+  - `1` restrictive clean-room
+- active non-live implementation-board rows are now `52`
+- `Phase 3R` is now open and no longer hypothetical
+
+Validation result:
+
+- `UnrealHyperTwistEditor` build succeeded for the landed widening packet
+
+Next packet:
+
+- `3R-B`
+
 Mandatory read rule before implementing, benchmarking against, or clean-rooming any `0R-E` repo:
 
 1. read `docs/HYPERTWIST_PHASE_0R_PACKET_0R_E_EVALUATION_2026-05-13.md`
@@ -337,23 +363,24 @@ Current curated HyperTwist shallow-eval set:
 
 Current verified live implementation state in checked `UnrealHyperTwist` source and materialized training surfaces:
 
-- `6` repos are implemented/live
-- `5` of those are permissive `MIT` lanes
+- `7` repos are implemented/live
+- `6` of those are permissive `MIT` lanes
 - `1` of those is a restrictive repo that was properly clean-roomed and then implemented
 
 Current 2026-05-11 repo-row reset counts:
 
-- `implemented_live_permissive`: `5`
+- `implemented_live_permissive`: `6`
 - `implemented_live_clean_room_verified`: `1`
-- `selected_not_live_permissive_candidate`: `43`
+- `selected_not_live_permissive_candidate`: `42`
 - `selected_not_live_boundary_sensitive`: `6`
 - `selected_not_live_clean_room_candidate`: `4`
 - `not_live_reference_or_discard_candidate`: `12`
 
-### The six currently implemented/live repos
+### The seven currently implemented/live repos
 
 Permissive `MIT` lanes already implemented/live:
 
+- `Aarav2709/KubeTimr`
 - `abunickabhi/5style-Trainer`
 - `tao-yu/Alg-Trainer`
 - `Lykos/cube_trainer`
@@ -367,7 +394,7 @@ Restrictive lane already properly clean-roomed and implemented/live:
 ### What this means
 
 - HyperTwist does **not** currently have dozens of donor repos already implemented in owned Unreal surfaces.
-- HyperTwist does **not** currently show live Unreal evidence for `cstimer`, `cubedesk`, `cubing/alg.js`, `cubing/twisty.js`, `cubing/cubing.js`, `Hyperspeedcube`, `qbr`, `KubeTimr`, `TalkingHead`, `MagicTile`, `MagicCube5D`, or `Magic120Cell`.
+- HyperTwist does **not** currently show live Unreal evidence for `cstimer`, `cubedesk`, `cubing/alg.js`, `cubing/twisty.js`, `cubing/cubing.js`, `Hyperspeedcube`, `qbr`, `TalkingHead`, `MagicTile`, `MagicCube5D`, or `Magic120Cell`.
 - The previous confusion came from mixing:
   - docs-state classifications such as `integrate`, `repurpose`, `donor bench`, and `locked strategic donor`
   - with actual live implementation evidence
@@ -408,7 +435,7 @@ At the moment, only one HyperTwist repo should be described this way:
 
 HyperTwist should now proceed from the following rule:
 
-- preserve the six live lanes
+- preserve the seven live lanes
 - do not reopen the `onionhoney/roux-trainers` lane as if it were an unresolved accidental donor import
 - do not widen new donor-shaped implementation from the remaining unevaluated rows yet
 - continue repo deep source integration evaluation for the remaining `12`
@@ -418,8 +445,8 @@ In practical terms:
 
 - yes, start again with a deliberate `Phase 0R`
 - yes, follow it with a deliberate `Phase 1R`
-- no, do **not** mass-revert the six landed lanes
-- no, do **not** pretend the remaining `65` are already implemented
+- no, do **not** mass-revert the seven landed lanes
+- no, do **not** pretend the remaining `64` are already implemented
 
 ## Phase reset sequence
 
@@ -784,7 +811,7 @@ Only after that:
 
 The clean practical sequence is:
 
-1. preserve the six landed lanes
+1. preserve the seven landed lanes
 2. make the current truth explicit everywhere
 3. deep-evaluate the remaining `65`
 4. discard what should not survive
@@ -797,7 +824,7 @@ Current status:
 - `Phase 2R-A` is now also complete
 - `Phase 2R-B` is now also complete
 - `Phase 2R-C` is now also complete
-- the next bounded move is `Phase 3R-A` for `Aarav2709/KubeTimr`
+- the next bounded move is `Phase 3R-B` for `Hypercubers/hypercubing.xyz`
 
 ## Companion docs
 

docs/HYPERTWIST_REPO_STATE_BOARD_2026-05-11.md

@@ -7,8 +7,8 @@ This board is the readable row-by-row companion to the v6.3 CSVs. It is derived
 ## Canonical summary
 
 - Current curated HyperTwist shallow-eval set: `71` repos
-- Currently verified live in checked `UnrealHyperTwist` surfaces: `6` repos
-- Live permissive lanes: `5`
+- Currently verified live in checked `UnrealHyperTwist` surfaces: `7` repos
+- Live permissive lanes: `6`
 - Live restrictive clean-room lanes: `1`
 - Remaining rows requiring `Phase 0R` deep repo evaluation: `0`
 
@@ -28,6 +28,7 @@ Read together with:
 - [HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md:1)
 - [HYPERTWIST_PHASE_2R_PACKET_2R_B_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_2R_PACKET_2R_B_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md:1)
 - [HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md:1)
+- [HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md](C:/HyperTwist/docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md:1)
 
 That overlay closes evaluation for:
 
@@ -47,12 +48,13 @@ Important authority correction:
 - `Packet 0R-C` is now the deep-source value-extraction and exclusion-rationale authority for its six boundary-sensitive repos
 - `Packet 0R-D` is now the governance and Model A authority for its four restrictive clean-room repos
 - `Packet 0R-E` is now the deep-source benchmark, reference, clean-room-later, and discard authority for its twelve rows
-- the live-lane preservation audit is now the source-backed authority for the six already-landed rows
+- the live-lane preservation audit is now the source-backed authority for the seven already-landed rows
 - `Phase 1R` is now the retained-set contract and handoff authority for all post-`Phase 0R` routing
 - `Phase 2R-A` is now the core ownership and acceptance authority for the five retained core permissive rows
 - `Phase 2R-B` is now the support-plane ownership and acceptance authority for the primary retained permissive support rows
 - `Phase 2R-C` is now the residual ownership and acceptance authority for the final retained permissive `0R-B` rows
-- future enhancement or preservation work for the six landed rows should start from the live-lane audit, not from this board alone
+- `Phase 3R-A` is now the landed implementation authority for `Aarav2709/KubeTimr`
+- future enhancement or preservation work for the seven landed rows should start from the live-lane audit, then the repo-specific landed packet where one exists, not from this board alone
 - future implementation of those seven repos should start from `Packet 0R-A`, not from this board alone
 - future implementation of the `0R-B` permissive set should start from `Packet 0R-B`, then the relevant closed `2R-B` or `2R-C` ownership packet, not from this board alone
 - future implementation of those six boundary-sensitive repos should start from `Packet 0R-C`, not from this board alone
@@ -67,24 +69,25 @@ Packet overlay result:
 - all `6` boundary-sensitive rows have now been packet-evaluated
 - all `4` restrictive clean-room rows have now been packet-evaluated
 - all `12` reference, benchmark, reserve, and discard rows have now been packet-evaluated
-- all `6` live rows now also have symmetric source-backed preservation authority
+- all `7` live rows now also have symmetric source-backed preservation authority
 - `Phase 2R-A` is now closed for the five core retained permissive rows
 - `Phase 2R-B` is now closed for the retained permissive support-plane owners, subordinate packages, and helper/dependency lanes in scope
 - `Phase 2R-C` is now closed for the final retained permissive `0R-B` residual rows
+- `Phase 3R-A` is now closed for the `Aarav2709/KubeTimr` timer, inspection, splits, stats, persistence, and timer-scoped replay lane
 - `Phase 2R` is now fully closed for the retained permissive set
-- none of those `65` packet-evaluated non-live rows are newly proven live in checked Unreal surfaces
+- `Aarav2709/KubeTimr` is now newly proven live in checked Unreal surfaces through `Phase 3R-A`
 - `Phase 0R` is now fully closed
 - `Phase 1R` is now fully closed
 - the `0R-E` result split is:
   - `9` retained benchmark, oracle, or clean-room-later rows
   - `3` discarded active-set rows
-- the next bounded move is `Phase 3R-A`
+- the next bounded move is `Phase 3R-B`
 
 ## Count by live-state class
 
-- `implemented_live_permissive`: `5`
+- `implemented_live_permissive`: `6`
 - `implemented_live_clean_room_verified`: `1`
-- `selected_not_live_permissive_candidate`: `43`
+- `selected_not_live_permissive_candidate`: `42`
 - `selected_not_live_boundary_sensitive`: `6`
 - `selected_not_live_clean_room_candidate`: `4`
 - `not_live_reference_or_discard_candidate`: `12`
@@ -100,10 +103,11 @@ Packet overlay result:
 
 These are currently verified live in checked Unreal surfaces and are permissive lanes already implemented.
 
-Count: `5`
+Count: `6`
 
 | Repo | License | Prior bucket | Prior action | Current live state | Reset lane | Next step |
 | --- | --- | --- | --- | --- | --- | --- |
+| `Aarav2709/KubeTimr` | `MIT` | Donor Bench | `repurpose` | `implemented_live_permissive` | `landed_permissive_preserve` | `Phase 3R-A` closed. Preserve as the landed first-party timer, inspection, splits, stats, persistence, and timer-scoped replay lane; start future widening from the live-lane audit, then the `3R-A` implementation packet, then `REPO_LICENSE_TRACKING.md`. |
 | `abunickabhi/5style-Trainer` | `MIT` | Donor Bench | `repurpose` | `implemented_live_permissive` | `landed_permissive_preserve` | Phase 1R closed. Preserve as a landed first-party permissive lane; keep notices and attribution visible; start future widening from the live-lane audit, then `REPO_LICENSE_TRACKING.md`, then ordinary owned enhancement work. |
 | `Lykos/cube_trainer` | `MIT` | Locked Strategic Donor | `integrate` | `implemented_live_permissive` | `landed_permissive_preserve` | Phase 1R closed. Preserve as a landed first-party permissive lane; keep notices and attribution visible; start future widening from the live-lane audit, then `REPO_LICENSE_TRACKING.md`, then ordinary owned enhancement work. |
 | `newyork-anthonyng/rubiks-cross-trainer` | `MIT` | Donor Bench | `repurpose` | `implemented_live_permissive` | `landed_permissive_preserve` | Phase 1R closed. Preserve as a landed first-party permissive lane; keep notices and attribution visible; start future widening from the live-lane audit, then `REPO_LICENSE_TRACKING.md`, then ordinary owned enhancement work. |
@@ -124,7 +128,7 @@ Count: `1`
 
 These rows are retained, not currently proven live, and have now cleared `Phase 0R` deep evaluation. `Phase 1R` places them on the active implementation board with earliest re-entry through `Phase 3R`.
 
-Count: `43`
+Count: `42`
 
 | Repo | License | Prior bucket | Prior action | Current live state | Reset lane | Next step |
 | --- | --- | --- | --- | --- | --- | --- |
@@ -134,7 +138,6 @@ Count: `43`
 | `@react-spring/rafz` | `MIT` | Merge Bench | `integrate` | `selected_not_live_permissive_candidate` | `phase0r_permissive_eval_then_implement` | `Phase 2R-B` closed. Retain only as the subordinate frame-loop and scheduling package beneath `pmndrs/react-spring` inside `Phase 3R-F`. |
 | `@react-spring/shared` | `MIT` | Merge Bench | `integrate` | `selected_not_live_permissive_candidate` | `phase0r_permissive_eval_then_implement` | `Phase 2R-B` closed. Retain only as the subordinate motion-utility package beneath `pmndrs/react-spring` inside `Phase 3R-F`. |
 | `@react-spring/types` | `MIT` | Merge Bench | `integrate` | `selected_not_live_permissive_candidate` | `phase0r_permissive_eval_then_implement` | `Phase 2R-B` closed. Retain only as the subordinate type-contract package beneath `pmndrs/react-spring` inside `Phase 3R-F`. |
-| `Aarav2709/KubeTimr` | `MIT` | Donor Bench | `repurpose` | `selected_not_live_permissive_candidate` | `phase0r_permissive_eval_then_implement` | `Phase 2R-A` closed. Freeze as the `Phase 3R-A` timer, inspection, splits, stats, and persistence entry point; start widening only from the `2R-A` ownership contract, then `0R-A`, then `REPO_LICENSE_TRACKING.md`. |
 | `apache/echarts` | `Apache-2.0` | Donor Bench | `repurpose` | `selected_not_live_permissive_candidate` | `phase0r_permissive_eval_then_implement` | `Phase 2R-B` closed. Freeze as the `Phase 3R-C` analytics and reporting anchor; widen only from the `2R-B` ownership contract, then `0R-B`, then `REPO_LICENSE_TRACKING.md`. |
 | `cahidenes/rubiks-cube-solver` | `MIT` | Locked Strategic Donor | `integrate` | `selected_not_live_permissive_candidate` | `phase0r_permissive_eval_then_implement` | `Phase 2R-C` closed. Freeze as part of the `Phase 6R-E` recognition-comparison adjunct lane for face placement and cube-string cross-checks behind the retained recognition anchors; do not widen in `Phase 3R`. |
 | `ecomfe/echarts-gl` | `BSD-3-Clause` | Merge Bench | `integrate` | `selected_not_live_permissive_candidate` | `phase0r_permissive_eval_then_implement` | `Phase 2R-B` closed. Retain as the optional `Phase 3R-C` `3D` analytics and explainer sidecar beneath `apache/echarts`; use only if reporting surfaces actually need it. |
@@ -223,8 +226,8 @@ Count: `12`
 
 ## Implementation rule going forward
 
-- Preserve the six landed lanes as current truth.
+- Preserve the seven landed lanes as current truth.
 - Keep `onionhoney/roux-trainers` explicitly marked as the only currently verified restrictive clean-room lane already implemented.
-- `Phase 0R` is now fully closed for the remaining `65` non-live rows.
+- `Phase 0R` is now fully closed for the remaining `64` non-live rows.
 - `Phase 1R` is now the routing authority for retained-set widening and benchmark exclusion.
-- The next bounded move is `Phase 3R-A` for the bounded `Aarav2709/KubeTimr` widening lane.
+- The next bounded move is `Phase 3R-B` for the retained `Hypercubers/hypercubing.xyz` widening lane.

docs/REPO_LICENSE_TRACKING.md

@@ -53,12 +53,13 @@ Do not use it as the primary architecture ledger. The architecture and donor dec
 This file now also preserves the current truth that future models must not lose:
 
 - current curated HyperTwist shallow-eval set: `71` repos
-- currently verified live/implemented in checked `UnrealHyperTwist` surfaces: `6`
-- permissive live lanes: `5`
+- currently verified live/implemented in checked `UnrealHyperTwist` surfaces: `7`
+- permissive live lanes: `6`
 - restrictive live lanes: `1`
 
-The five permissive live lanes are:
+The six permissive live lanes are:
 
+- `Aarav2709/KubeTimr`
 - `abunickabhi/5style-Trainer`
 - `tao-yu/Alg-Trainer`
 - `Lykos/cube_trainer`
@@ -109,7 +110,8 @@ Current practical interpretation:
 - core ownership and acceptance packetization now lives in `docs/HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
 - support-plane ownership and acceptance packetization now lives in `docs/HYPERTWIST_PHASE_2R_PACKET_2R_B_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
 - residual `0R-B` adjunct and alternative-lane packetization now lives in `docs/HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
-- the next bounded move is `Phase 3R-A`
+- the landed `Aarav2709/KubeTimr` widening packet now lives in `docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md`
+- the next bounded move is `Phase 3R-B`
 
 Companion docs:
 
@@ -121,6 +123,7 @@ Companion docs:
 - `docs/HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
 - `docs/HYPERTWIST_PHASE_2R_PACKET_2R_B_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
 - `docs/HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
+- `docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md`
 - `docs/HYPERTWIST_REPO_STATE_BOARD_2026-05-11.md`
 
 ## Landed live-lane legal records
@@ -181,6 +184,36 @@ Approved working posture:
 - preserve as a landed first-party permissive lane
 - widen only through ordinary owned enhancement work
 
+### `Aarav2709/KubeTimr`
+
+Decision date:
+
+- `2026-05-13`
+
+Current licensing judgment:
+
+- `MIT`
+- preserve the checked local license text exactly as present
+- the checked local license notice currently uses `Copyright (c) 2024 KubeTimr`
+
+Source basis:
+
+- `C:\Workspaces\HyperTwist\mirrors\permissive\Aarav2709\KubeTimr\LICENSE`
+- `C:\Workspaces\HyperTwist\mirrors\permissive\Aarav2709\KubeTimr\README.md`
+- `C:\HyperTwist\docs\HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md`
+- `C:\HyperTwist\docs\HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md`
+
+Practical obligations:
+
+- preserve the MIT text in third-party notices or equivalent release/legal materials
+- preserve the checked copyright notice exactly as present
+
+Approved working posture:
+
+- preserve as a landed first-party permissive timer subsystem lane
+- widen only through ordinary owned enhancement work
+- treat future work as preserve-and-enhance work, not as unresolved donor-candidate work
+
 ### `Lykos/cube_trainer`
 
 Decision date:

docs/repo_portfolio_unified_consolidation_and_init_prompt_v6_3.md

@@ -31,7 +31,7 @@ Rules:
 - For HyperTwist, keep implementation truth separate from donor posture.
 - HyperTwist currently has `71` shallow-eval rows but only `6` verified live/implemented rows in checked Unreal surfaces.
 - Of those `6`, `5` are permissive `MIT` lanes and `1` is the restrictive `onionhoney/roux-trainers` lane that is already properly clean-roomed and implemented.
-- The remaining `65` non-live rows have already cleared `Phase 0R`; route them only through the retained-set contract and the relevant `0R-*` packet.
+- The remaining `64` non-live rows have already cleared `Phase 0R`; route them only through the retained-set contract and the relevant `0R-*` packet.
 - Use the `2026-05-12` reconciliation doc for cross-location authority order and the `2026-05-13` `Phase 1R` contract doc for current retained-set routing.
 
 Read in order:

docs/repo_portfolio_unified_copyleft_strategy_matrix_v6_3.csv

@@ -36,7 +36,7 @@
 "onionhoney/roux-trainers","https://github.com/onionhoney/roux-trainers","HyperTwist","Donor Bench","donor bench","repurpose","architecture only","GPL-3.0","known_from_reference_material","uploaded_reference_docs","mixed_or_boundary_sensitive_known","reverse_engineer_preferred","The repo is GPLv3 and should not be used as direct donor code in the HyperTwist core. Its value is in selective behavior and subsystem extraction through a clean-room Model A / Model B process.","high","gpl-clean-room-donor","v6.3_final_source_of_truth","implemented_live_clean_room_verified","landed_clean_room_preserve","Phase 1R closed. Preserve as the landed restrictive clean-room precedent; keep the Model A/Model B chain explicit and work only from first-party outputs or scrubbed specs."
 "yakupbilen/drl-rubiks-cube","https://github.com/yakupbilen/drl-rubiks-cube","HyperTwist","Reserve Bench","Reserve Bench","future candidate","architecture only","MIT","known_from_reference_material","uploaded_reference_docs","permissive_or_noncopyleft_known","pattern_only_preferred","The repo is MIT and remains a research benchmark for learned heuristic search, ADI state generation, and offline experimentation rather than a near-term product donor.","high","strategic-or-implemented-component","v6.3_final_source_of_truth","not_live_reference_or_discard_candidate","phase0r_reference_benchmark_or_discard_eval","Packet 0R-E closed. Retain as an MIT research benchmark for learned heuristic search, ADI training loops, and offline experimentation rather than near-term product implementation."
 "Hypercubers/hypercubing.xyz","https://github.com/Hypercubers/hypercubing.xyz","HyperTwist","Locked Strategic Donor","locked strategic donor","repurpose","moderate modification","MIT","known_from_reference_material","uploaded_reference_docs","permissive_or_noncopyleft_known","direct_incorporation_ok","The repo is MIT and is retained as a high-value knowledge and curriculum donor. Direct use of code/content structures is legally straightforward where it materially helps HyperTwist.","high","permissive-knowledge-donor","v6.3_final_source_of_truth","selected_not_live_permissive_candidate","phase0r_permissive_eval_then_implement","Phase 1R closed. Retain as a Phase 3R permissive implementation candidate; implement only from its packet authority and the retained-set contract, not by reopening Phase 0R."
-"Aarav2709/KubeTimr","https://github.com/Aarav2709/KubeTimr","HyperTwist","Donor Bench","donor bench","repurpose","moderate modification","MIT","known_from_reference_material","uploaded_reference_docs","permissive_or_noncopyleft_known","direct_incorporation_ok","This repo is permissively licensed and currently best treated as a focused subsystem donor for timer-state logic, split-phase handling, local persistence, and keyboard-first practice flow. Selective incorporation is legally straightforward, but the product shell should still be reshaped to fit HyperTwist.","high","routine-review-only","v6.3_final_source_of_truth","selected_not_live_permissive_candidate","phase0r_permissive_eval_then_implement","Phase 1R closed. Retain as a Phase 3R permissive implementation candidate; implement only from its packet authority and the retained-set contract, not by reopening Phase 0R."
+"Aarav2709/KubeTimr","https://github.com/Aarav2709/KubeTimr","HyperTwist","Donor Bench","donor bench","repurpose","moderate modification","MIT","known_from_reference_material","uploaded_reference_docs","permissive_or_noncopyleft_known","direct_incorporation_ok","This repo is permissively licensed and currently best treated as a focused subsystem donor for timer-state logic, split-phase handling, local persistence, and keyboard-first practice flow. Selective incorporation is legally straightforward, but the product shell should still be reshaped to fit HyperTwist.","high","routine-review-only","v6.3_final_source_of_truth","implemented_live_permissive","landed_permissive_preserve","Phase 3R-A closed. Preserve as the landed first-party timer, inspection, splits, stats, persistence, and timer-scoped replay lane; start future widening from the live-lane audit, then the 3R-A implementation packet, then REPO_LICENSE_TRACKING.md."
 "roice3/MagicTile","https://github.com/roice3/MagicTile","HyperTwist","Locked Strategic Donor","locked strategic donor","repurpose","moderate modification","MIT","known_from_reference_material","uploaded_reference_docs","permissive_or_noncopyleft_known","direct_incorporation_ok","The repo is MIT and is explicitly retained as a top-tier geometry/topology donor. Direct donor use is legally straightforward if the architecture benefits from it.","high","permissive-top-tier-donor","v6.3_final_source_of_truth","selected_not_live_permissive_candidate","phase0r_permissive_eval_then_implement","Phase 1R closed. Retain as a Phase 3R permissive implementation candidate; implement only from its packet authority and the retained-set contract, not by reopening Phase 0R."
 "PostHog/posthog","https://github.com/PostHog/posthog","HyperTwist","","donor bench","repurpose","moderate modification","MIT outside ee/; enterprise-restricted in ee/","known_from_reference_material","uploaded_reference_docs","mixed_or_boundary_sensitive_known","bounded_sidecar_or_selective_reimplementation","The repo is mixed-license: MIT outside ee/ and enterprise-restricted inside ee/. Use only clearly MIT paths as bounded telemetry, replay, and feature-governance donor material, and exclude or reimplement enterprise-gated paths.","high","mixed-license-path-review-required","v6.3_final_source_of_truth","selected_not_live_boundary_sensitive","phase0r_boundary_sensitive_eval_then_adapter_or_sidecar","Phase 1R closed. Retain as a Phase 4R bounded telemetry and replay sidecar candidate; keep ee/ excluded and use explicit allowlists or first-party reimplementation where needed."
 "met4citizen/TalkingHead","https://github.com/met4citizen/TalkingHead","HyperTwist","Donor Bench","donor bench","repurpose","moderate modification","MIT","known_from_reference_material","uploaded_reference_docs","permissive_or_noncopyleft_known","direct_incorporation_ok","The code license is MIT and direct use is allowed. Treat it as a bounded browser-side donor for embodied coach presentation rather than as a product shell.","high","standard-notice-review","v6.3_markdown_backfill","selected_not_live_permissive_candidate","phase0r_permissive_eval_then_implement","Phase 1R closed. Retain as a Phase 3R permissive implementation candidate; implement only from its packet authority and the retained-set contract, not by reopening Phase 0R."

docs/repo_portfolio_unified_source_audit_v6_3.csv

@@ -219,7 +219,7 @@
 6) Best merge partners and exact coupling seam
 7) Reasons to promote / retain / demote
 8) Confidence change after source audit
-9) Open questions / blockers","Primary: Phase G v4 board (canonical ranking and current bucket); Operational v3 board filtered to this repo; Merger matrix rows involving this repo; VS Code packet row for this repo, if present. Optional: Cluster narratives row for matching cluster; Bookmark occurrence rows for this repo. Do not attach v1/v2 or preliminary memo unless a judgment conflict, lineage ambiguity, or rationale gap needs arbitration.","Aarav2709/KubeTimr is placed in Donor Bench for HyperTwist because it best serves the 'Focused subsystem donor' role; recommended action is 'repurpose' with repurposing scope 'moderate modification'. Confidence is medium because this remains a metadata-level judgment until source audit confirms hidden modules, plugin points, adapters, or architectural strengths.","Useful subsystem donor for timer-state logic, split-phase handling, local persistence, rolling stats, and keyboard-first offline practice flow.","Audit Aarav2709/KubeTimr as a cubing trainer / solver / timing candidate for HyperTwist. Do not stop at README-level features. Inspect: Inspect cube-state model; scramble generator; trainer weighting/scheduling; case database and metadata; replay/timer model; import/export of alg sets; smartcube or sensor adapters. Decide whether the best extraction path is moderate modification and whether it belongs as subsystem donor / training donor. Test the three merger paths in order: 1) tao-yu/Alg-Trainer [base + donor swarm]; 2) poliva/cubedex [specialized training UX donor]; 3) Lykos/cube_trainer [sampling/analytics donor]. Return hidden modules, reusable schemas, protocol layers, plugin hooks, render/state models, datasets/test fixtures, and any subsystem stronger than the visible product shell.","HT_training_stack_0015","HT_training_stack","aarav2709/kubetimr","","","","","","","Original global P0-P3 source audit retained","MIT","known_from_reference_material","uploaded_reference_docs","no","","","","Supplemental intake references are advisory only; v6 adjudication remains the source of truth.","Usually indirect","yes","v6 unified all-project source-of-truth pack","v5_carry_forward","","v6_unified_source_of_truth_pack","2","3","88.0","permissive_or_noncopyleft_known","direct_incorporation_ok","This repo is permissively licensed and currently best treated as a focused subsystem donor for timer-state logic, split-phase handling, local persistence, and keyboard-first practice flow. Selective incorporation is legally straightforward, but the product shell should still be reshaped to fit HyperTwist.","Direct embed, vendored module, package dependency, or tightly integrated adapter as the architecture requires.","Typically preserve notices, attribution, and license text where required; no special copyleft-driven disclosure posture is normally needed.","Usually unnecessary unless you later decide the existing implementation is too constraining architecturally.","high","routine-review-only","yes","","","","","","","","","","","","","v6.3_final_source_of_truth","Normalized legacy adjacency wording and stale clean-room boundary posture to dossier-backed focused subsystem donor on 2026-04-25.","selected_not_live_permissive_candidate","phase0r_permissive_eval_then_implement","Phase 1R closed. Retain as a Phase 3R permissive implementation candidate; implement only from its packet authority and the retained-set contract, not by reopening Phase 0R."
+9) Open questions / blockers","Primary: Phase G v4 board (canonical ranking and current bucket); Operational v3 board filtered to this repo; Merger matrix rows involving this repo; VS Code packet row for this repo, if present. Optional: Cluster narratives row for matching cluster; Bookmark occurrence rows for this repo. Do not attach v1/v2 or preliminary memo unless a judgment conflict, lineage ambiguity, or rationale gap needs arbitration.","Aarav2709/KubeTimr is placed in Donor Bench for HyperTwist because it best serves the 'Focused subsystem donor' role; recommended action is 'repurpose' with repurposing scope 'moderate modification'. Confidence is medium because this remains a metadata-level judgment until source audit confirms hidden modules, plugin points, adapters, or architectural strengths.","Useful subsystem donor for timer-state logic, split-phase handling, local persistence, rolling stats, and keyboard-first offline practice flow.","Audit Aarav2709/KubeTimr as a cubing trainer / solver / timing candidate for HyperTwist. Do not stop at README-level features. Inspect: Inspect cube-state model; scramble generator; trainer weighting/scheduling; case database and metadata; replay/timer model; import/export of alg sets; smartcube or sensor adapters. Decide whether the best extraction path is moderate modification and whether it belongs as subsystem donor / training donor. Test the three merger paths in order: 1) tao-yu/Alg-Trainer [base + donor swarm]; 2) poliva/cubedex [specialized training UX donor]; 3) Lykos/cube_trainer [sampling/analytics donor]. Return hidden modules, reusable schemas, protocol layers, plugin hooks, render/state models, datasets/test fixtures, and any subsystem stronger than the visible product shell.","HT_training_stack_0015","HT_training_stack","aarav2709/kubetimr","","","","","","","Original global P0-P3 source audit retained","MIT","known_from_reference_material","uploaded_reference_docs","no","","","","Supplemental intake references are advisory only; v6 adjudication remains the source of truth.","Usually indirect","yes","v6 unified all-project source-of-truth pack","v5_carry_forward","","v6_unified_source_of_truth_pack","2","3","88.0","permissive_or_noncopyleft_known","direct_incorporation_ok","This repo is permissively licensed and currently best treated as a focused subsystem donor for timer-state logic, split-phase handling, local persistence, and keyboard-first practice flow. Selective incorporation is legally straightforward, but the product shell should still be reshaped to fit HyperTwist.","Direct embed, vendored module, package dependency, or tightly integrated adapter as the architecture requires.","Typically preserve notices, attribution, and license text where required; no special copyleft-driven disclosure posture is normally needed.","Usually unnecessary unless you later decide the existing implementation is too constraining architecturally.","high","routine-review-only","yes","","","","","","","","","","","","","v6.3_final_source_of_truth","Normalized legacy adjacency wording and stale clean-room boundary posture to dossier-backed focused subsystem donor on 2026-04-25.","implemented_live_permissive","landed_permissive_preserve","Phase 3R-A closed. Preserve as the landed first-party timer, inspection, splits, stats, persistence, and timer-scoped replay lane; start future widening from the live-lane audit, then the 3R-A implementation packet, then REPO_LICENSE_TRACKING.md."
 "roice3/MagicTile","https://github.com/roice3/MagicTile","HyperTwist","Locked Strategic Donor","Top-tier non-Euclidean geometry and topology donor","P1","7487","9242","2.0","88.0","97.0","medium","Retain the valuable internal engine, but expect to replace UI/product shell, adapt schemas/APIs, and refactor boundaries so it can plug into the target anchors cleanly. For this repo class, that usually means preserving collectors/adapters/runtime topology logic while integrating into a larger control plane.","repurpose","moderate modification","Determine whether roice3/MagicTile should stay donor/merge-tier for HyperTwist, be promoted, or be demoted; identify concrete salvageable modules and best merge path.","puzzle model, learning flow, UX loops, data schema, replay/export, plugin/hooks","Inspect package manifests, README/docs, src tree, examples, tests, CI workflows, config files, migrations/schemas, and hidden feature flags or experimental modules. Look for algorithm databases, spaced-repetition logic, scramble generation, timer/stat code, virtual cube components, smartcube adapters, and custom-trainer configuration support.","Inspect topology/service schema; collectors/agents; auth/integration adapters; caching/state sync; deployment/runtime abstractions; metrics/event correlation; config layering.","Repurpose selected subsystems rather than the whole product. Mine the repo for scramble generation, algorithm database, recognition/training loop, timing/statistics, virtual cube, smartcube hooks, spaced repetition; keep what materially shortens build time, but rebind data contracts, permissions, UI shell, storage, and deployment to the HyperTwist architecture. Best first pairing order: tao-yu/Alg-Trainer, poliva/cubedex, Lykos/cube_trainer.","Consolidate under the Hyperspeedcube + cubing.js + qbr nucleus, not beside it as a separate silo. Normalize data contracts, auth/permissions, storage, and telemetry; then attach as a service, plugin, canvas layer, trainer, or analysis module. Descending combination order: tao-yu/Alg-Trainer, poliva/cubedex, Lykos/cube_trainer.","Repurpose here means: turn it into a trainer engine, solver/timer backend, recognition drill module, or method-specific practice mode for HyperTwist.","project-local anchor","base + donor","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","shared portfolio utility","augmenter","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","cross-project transfer candidate","future merger","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","project-local first","Cross-project transfer is possible, but the value is clearest inside the assigned project until source audit exposes more reusable primitives.","Upgrade if source reveals clean modular architecture, reusable core abstractions, strong adapters/plugins, robust tests, and direct fit to a locked stack.","Demote if reusable value is mostly superficial, undocumented complexity overwhelms salvage value, or higher-ranked repos clearly dominate the same role.","Capability inventory + salvage targets + promotion/demotion verdict","1) Confirmed visible capabilities
 2) Hidden capabilities found only in source
 3) Best salvageable modules/files/packages

docs/repo_portfolio_unified_v6_3_README.txt

@@ -13,7 +13,7 @@ Why this matters:
 
 * the v6.3 pack is excellent at repo selection, donor posture, and legal/architectural strategy
 * it is **not** by itself a proof of current live implementation state
-* HyperTwist currently has `71` shallow-eval rows, but only `6` currently verified live repos in checked `UnrealHyperTwist` surfaces
+* HyperTwist currently has `71` shallow-eval rows, but only `7` currently verified live repos in checked `UnrealHyperTwist` surfaces
 * `5` of those `6` are permissive `MIT` lanes
 * `1` of those `6` is the restrictive `onionhoney/roux-trainers` lane, which must now be treated as the only currently verified restrictive repo that was properly clean-roomed and then implemented
 

docs/v6_5_deep_manual_pack/HyperTwist/AGENTS.md

@@ -75,8 +75,8 @@ For any HyperTwist repo, the coding model must determine:
 For HyperTwist, keep this explicit:
 
 - current shallow-eval set: `71` repos
-- currently verified live/implemented in checked Unreal surfaces: `6`
-- permissive live lanes: `5`
+- currently verified live/implemented in checked Unreal surfaces: `7`
+- permissive live lanes: `6`
 - restrictive live lane: `1`
 - the restrictive landed lane is `onionhoney/roux-trainers`, and it is to be treated as properly clean-roomed and then implemented
 
@@ -93,8 +93,8 @@ into:
 
 ## Reset rule
 
-Before recommending new HyperTwist donor-shaped widening from the remaining `65` rows:
+Before recommending new HyperTwist donor-shaped widening from the remaining `64` non-live rows:
 
-- run the repo deep source integration evaluation reset
-- refresh contracts and handoff docs
-- then reopen later implementation waves
+- do not reopen the already closed `Phase 0R`, `Phase 1R`, or `Phase 2R` packets
+- preserve the seven landed rows as current truth
+- continue from the closed packet sequence, currently `Phase 3R-B`

docs/v6_5_deep_manual_pack/HyperTwist/DEVELOPMENT.md

@@ -15,18 +15,20 @@ Do not reopen broad donor-driven widening as if the whole retained portfolio wer
 
 Current truth:
 
-- `6` repos are currently verified live in checked Unreal surfaces
-- `5` are permissive `MIT`
+- `7` repos are currently verified live in checked Unreal surfaces
+- `6` are permissive `MIT`
 - `1` is the restrictive `onionhoney/roux-trainers` lane that is already properly clean-roomed and implemented
-- `Phase 0R` is now closed for the remaining `65` non-live rows
+- `Phase 0R` is now closed for the remaining `64` non-live rows
 - `Phase 1R` is now closed as the retained-set contract and handoff overhaul
+- `Phase 2R` is now closed as the retained-set ownership and acceptance packet sequence
+- `Phase 3R-A` is now closed as the landed `Aarav2709/KubeTimr` widening packet
 
 Next sequence:
 
-1. preserve the six landed lanes
+1. preserve the seven landed lanes
 2. use the retained-set contract as the only legal/roadmap routing surface for non-live rows
-3. run `Phase 2R` retained-set ratification and packet design
-4. only then reopen broader implementation waves
+3. keep `Aarav2709/KubeTimr` on preserve-and-enhance footing through its landed packet
+4. continue broader permissive widening from `Phase 3R-B`
 
 ## Suggested repo structure
 
@@ -52,7 +54,7 @@ Next sequence:
 1. preserve and document landed implementation truth
 2. completed `Phase 0R` deep source evaluation reset for remaining rows
 3. completed `Phase 1R` contract / handoff / provenance overhaul
-4. retained-set ratification and packet design
+4. completed retained-set ratification and packet design
 5. permissive implementation waves from retained rows
 6. boundary-sensitive adapter or sidecar waves
 7. restrictive clean-room waves from retained rows

docs/v6_5_deep_manual_pack/HyperTwist/LICENSETRACKING.md

@@ -42,12 +42,13 @@ They still must point back to `C:\HyperTwist\docs\REPO_LICENSE_TRACKING.md` for
 At the moment, HyperTwist should be described this way:
 
 - current curated shallow-eval set: `71` repos
-- currently verified live/implemented in checked Unreal surfaces: `6`
-- permissive live lanes: `5`
+- currently verified live/implemented in checked Unreal surfaces: `7`
+- permissive live lanes: `6`
 - restrictive live lanes: `1`
 
-The five permissive live lanes are:
+The six permissive live lanes are:
 
+- `Aarav2709/KubeTimr`
 - `abunickabhi/5style-Trainer`
 - `tao-yu/Alg-Trainer`
 - `Lykos/cube_trainer`
@@ -111,12 +112,13 @@ Current practical interpretation:
 - `Phase 2R-B` is now fully closed for the primary retained permissive support-plane rows in scope
 - `Phase 2R-C` is now fully closed for the final residual `0R-B` permissive rows
 - `Phase 2R` is now fully closed for the retained permissive set
-- the six already-live rows now have source-backed preservation authority in `C:\HyperTwist\docs\HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md`
+- the seven already-live rows now have source-backed preservation authority in `C:\HyperTwist\docs\HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md`
 - the retained-set contract now lives in `C:\HyperTwist\docs\HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md`
 - the core ownership and acceptance packet now lives in `C:\HyperTwist\docs\HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
 - the support-plane ownership and acceptance packet now lives in `C:\HyperTwist\docs\HYPERTWIST_PHASE_2R_PACKET_2R_B_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
 - the residual `0R-B` adjunct and alternative-lane packet now lives in `C:\HyperTwist\docs\HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
-- the next bounded move is `Phase 3R-A`
+- the landed `Aarav2709/KubeTimr` widening packet now lives in `C:\HyperTwist\docs\HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md`
+- the next bounded move is `Phase 3R-B`
 
 Read together with:
 
@@ -144,7 +146,7 @@ These are often strategic donors or comparators rather than foundations.
 
 Current HyperTwist correction:
 
-- five trainer-style permissive lanes are already live
+- six trainer-style permissive lanes are already live
 - `onionhoney/roux-trainers` is the one restrictive training lane already landed through clean-room implementation
 - timer comparators such as `cstimer` still remain benchmark/reference rows until deep evaluation says otherwise
 

docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md

@@ -5,21 +5,23 @@
 Before widening new HyperTwist donor-driven implementation beyond the already landed lanes, preserve this current truth:
 
 - current shallow-eval set: `71` repos
-- currently verified live/implemented in checked Unreal surfaces: `6`
-- permissive live lanes: `5`
+- currently verified live/implemented in checked Unreal surfaces: `7`
+- permissive live lanes: `6`
 - restrictive live lane: `1`
 - the restrictive landed lane is `onionhoney/roux-trainers`, and it is to be treated as properly clean-roomed and then implemented
-- `Phase 0R` is now closed for the remaining `65` non-live rows
+- `Phase 0R` is now closed for the remaining `64` non-live rows
 - `Phase 1R` is now closed as the retained-set contract and handoff overhaul
+- `Phase 2R` is now closed as the retained-set ownership and acceptance packet sequence
+- `Phase 3R-A` is now closed as the landed `Aarav2709/KubeTimr` timer subsystem widening packet
 
 Current routing truth:
 
 - retained rows total: `68`
 - discarded from the active retained set: `3`
-- active non-live implementation-board rows: `53`
+- active non-live implementation-board rows: `52`
 - retained benchmark, oracle, or clean-room-later rows outside the active implementation board: `9`
 
-The next bounded move is `Phase 2R`, not renewed donor widening.
+The next bounded move is `Phase 3R-B`, not renewed donor evaluation or pre-packet ratification.
 
 ## Reset phases