From 12f8d969d94bd06b4d967cf1b7f2d33236ec2bdf Mon Sep 17 00:00:00 2001 From: axiomlogicnexus Date: Wed, 13 May 2026 04:33:26 +0200 Subject: [PATCH] Close HyperTwist Phase 3R packet 3R-A --- .../HyperTwistCoachDashboardWidget.cpp | 365 +++++++-------- .../HyperTwistTrainingRepositoryLibrary.cpp | 72 ++- .../HyperTwistTrainingSubsystem.cpp | 433 ++++++++++++++++++ .../HyperTwistCoachDashboardWidget.h | 5 +- .../HyperTwistTrainingSubsystem.h | 45 ++ .../HyperTwistTrainingTypes.h | 107 +++++ ..._MIRROR_WORKSPACE_AND_SUBMODULE_HANDOFF.md | 6 +- .../HT_REPO_INCORPORATION_AUDIT_2026-05-11.md | 16 +- ...NICAL_RESTART_RECONCILIATION_2026-05-12.md | 34 +- ...OURCE_AND_PRESERVATION_AUDIT_2026-05-13.md | 80 +++- ...NED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md | 40 +- ...SHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md | 2 +- ...3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md | 149 ++++++ ..._AND_IMPLEMENTATION_SCHEDULE_2026-05-11.md | 49 +- .../HYPERTWIST_REPO_STATE_BOARD_2026-05-11.md | 33 +- docs/REPO_LICENSE_TRACKING.md | 41 +- ...fied_consolidation_and_init_prompt_v6_3.md | 2 +- ..._unified_copyleft_strategy_matrix_v6_3.csv | 2 +- ...epo_portfolio_unified_operational_v6_3.csv | 2 +- docs/repo_portfolio_unified_phase_g_v6_3.csv | 2 +- ...po_portfolio_unified_source_audit_v6_3.csv | 2 +- docs/repo_portfolio_unified_v6_3_README.txt | 2 +- .../HyperTwist/AGENTS.md | 12 +- .../HyperTwist/DEVELOPMENT.md | 16 +- .../HyperTwist/LICENSETRACKING.md | 14 +- .../HyperTwist/ROADMAP.md | 12 +- 26 files changed, 1221 insertions(+), 322 deletions(-) create mode 100644 docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp index 7d4234d..150c49d 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistCoachDashboardWidget.cpp +++ b/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((NowSeconds - LiveAttemptStartedAtSeconds) * 1000.0) - ); - LiveAttemptSolveElapsedMs = 0; - LiveAttemptDisplayedMs = LiveAttemptInspectionElapsedMs; - } - else if (LiveAttemptPhase == EHyperTwistCoachDashboardAttemptPhase::Solving) - { - LiveAttemptInspectionElapsedMs = FMath::Max(LiveAttemptStoredInspectionElapsedMs, 0); - LiveAttemptSolveElapsedMs = FMath::Max( - 0, - static_cast((NowSeconds - LiveAttemptSolveStartedAtSeconds) * 1000.0) - ); - LiveAttemptDisplayedMs = LiveAttemptSolveElapsedMs; - } + bHasLiveAttemptTimer = false; + LiveAttemptPhase = EHyperTwistCoachDashboardAttemptPhase::Idle; + LiveAttemptInspectionElapsedMs = 0; + LiveAttemptSolveElapsedMs = 0; + LiveAttemptDisplayedMs = 0; + LiveAttemptSplitCaptures.Reset(); } FString UHyperTwistCoachDashboardWidget::BuildDefaultDeferredUntilUtc() const diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRepositoryLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRepositoryLibrary.cpp index 0c95404..b267ce3 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRepositoryLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRepositoryLibrary.cpp @@ -5806,7 +5806,8 @@ namespace HyperTwistTrainingRepositoryLibraryInternal const TArray& 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 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(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(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(TotalTimeAccumulator / TimedSolveSamples.Num()); + Summary.MeanRawSolveTimeMs = static_cast(RawSolveTimeAccumulator / TimedSolveSamples.Num()); + + for (const int32 WindowSize : {3, 5, 12, 50, 100, 1000}) { Summary.RollingWindows.Add(HyperTwistTrainingRepositoryLibraryInternal::BuildRollingWindowStat( TimedSolveSamples, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp index 769442c..63a5013 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingSubsystem.cpp +++ b/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((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((NowSeconds - ActiveLiveTimerStartedAtSeconds) * 1000.0) + ); + SolveElapsedMs = 0; + Snapshot.DisplayedElapsedMs = InspectionElapsedMs; + Snapshot.ResumePhase = EHyperTwistTrainingLiveTimerPhase::Inspection; + break; + case EHyperTwistTrainingLiveTimerPhase::Solving: + SolveElapsedMs += FMath::Max( + 0, + static_cast((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()) diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h index d996944..c9098dc 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistCoachDashboardWidget.h +++ b/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; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h index ad0e861..760d192 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingSubsystem.h +++ b/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; }; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h index 6cc686b..af9b951 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTypes.h +++ b/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 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; diff --git a/docs/EXTERNAL_MIRROR_WORKSPACE_AND_SUBMODULE_HANDOFF.md b/docs/EXTERNAL_MIRROR_WORKSPACE_AND_SUBMODULE_HANDOFF.md index f9b457e..a113343 100644 --- a/docs/EXTERNAL_MIRROR_WORKSPACE_AND_SUBMODULE_HANDOFF.md +++ b/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 diff --git a/docs/HT_REPO_INCORPORATION_AUDIT_2026-05-11.md b/docs/HT_REPO_INCORPORATION_AUDIT_2026-05-11.md index 19fb414..657cfdf 100644 --- a/docs/HT_REPO_INCORPORATION_AUDIT_2026-05-11.md +++ b/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: diff --git a/docs/HYPERTWIST_CANONICAL_RESTART_RECONCILIATION_2026-05-12.md b/docs/HYPERTWIST_CANONICAL_RESTART_RECONCILIATION_2026-05-12.md index d1c6b28..33ff38b 100644 --- a/docs/HYPERTWIST_CANONICAL_RESTART_RECONCILIATION_2026-05-12.md +++ b/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 diff --git a/docs/HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md b/docs/HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md index 846b477..f1be8aa 100644 --- a/docs/HYPERTWIST_LIVE_LANES_SOURCE_AND_PRESERVATION_AUDIT_2026-05-13.md +++ b/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: diff --git a/docs/HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md b/docs/HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md index 7d9d1e3..814f513 100644 --- a/docs/HYPERTWIST_PHASE_1R_RETAINED_SET_CONTRACT_AND_HANDOFF_2026-05-13.md +++ b/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 diff --git a/docs/HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md b/docs/HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md index 8826c18..3269659 100644 --- a/docs/HYPERTWIST_PHASE_2R_PACKET_2R_C_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md +++ b/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. diff --git a/docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md b/docs/HYPERTWIST_PHASE_3R_PACKET_3R_A_KUBETIMR_IMPLEMENTATION_2026-05-13.md new file mode 100644 index 0000000..28d17d6 --- /dev/null +++ b/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 diff --git a/docs/HYPERTWIST_REPO_EVALUATION_RESET_AND_IMPLEMENTATION_SCHEDULE_2026-05-11.md b/docs/HYPERTWIST_REPO_EVALUATION_RESET_AND_IMPLEMENTATION_SCHEDULE_2026-05-11.md index f6c23e3..dbfe16c 100644 --- a/docs/HYPERTWIST_REPO_EVALUATION_RESET_AND_IMPLEMENTATION_SCHEDULE_2026-05-11.md +++ b/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 diff --git a/docs/HYPERTWIST_REPO_STATE_BOARD_2026-05-11.md b/docs/HYPERTWIST_REPO_STATE_BOARD_2026-05-11.md index 025cc22..c7165c2 100644 --- a/docs/HYPERTWIST_REPO_STATE_BOARD_2026-05-11.md +++ b/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. diff --git a/docs/REPO_LICENSE_TRACKING.md b/docs/REPO_LICENSE_TRACKING.md index 83d4ddc..b874a18 100644 --- a/docs/REPO_LICENSE_TRACKING.md +++ b/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: diff --git a/docs/repo_portfolio_unified_consolidation_and_init_prompt_v6_3.md b/docs/repo_portfolio_unified_consolidation_and_init_prompt_v6_3.md index 2585001..e8d0f3a 100644 --- a/docs/repo_portfolio_unified_consolidation_and_init_prompt_v6_3.md +++ b/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: diff --git a/docs/repo_portfolio_unified_copyleft_strategy_matrix_v6_3.csv b/docs/repo_portfolio_unified_copyleft_strategy_matrix_v6_3.csv index 9e3a8ab..fe68dff 100644 --- a/docs/repo_portfolio_unified_copyleft_strategy_matrix_v6_3.csv +++ b/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." diff --git a/docs/repo_portfolio_unified_operational_v6_3.csv b/docs/repo_portfolio_unified_operational_v6_3.csv index d3e40dc..7319f9b 100644 --- a/docs/repo_portfolio_unified_operational_v6_3.csv +++ b/docs/repo_portfolio_unified_operational_v6_3.csv @@ -36,7 +36,7 @@ "11933","onionhoney/roux-trainers","https://github.com/onionhoney/roux-trainers","HyperTwist","30.0","117.0","132.0","B","method-specific training donor","restrictive donor","clean-room donor","donor bench","repurpose","architecture only","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 cube-state, scramble, scheduling, or timer internals while adapting pedagogy, analytics, and UI.","Focused restrictive clean-room donor target. Retain the stage-specific training modes, solver-backed analyzer behavior, recognition masking, favorites/batch-drill flow, and 2D/3D training visualization ideas through Model A / Model B separation.","Keep in restrictive custody and route value through clean-room extraction only. Use it as a method-specific training and analyzer donor, not as direct donor code.","Do not merge this repo into the HyperTwist core as source. Convert the valuable training-state-machine and analyzer behaviors into first-party subsystems behind a clean-room boundary.","Repurpose here means: translate stage-specific training and analyzer behaviors into first-party implementations through a clean-room process.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Extract cube-state model; Normalize trainer/case schema; Expose analytics and replay hooks","deep source audit","Hidden value sits in state-machine-driven training flows, solver-backed analyzer behavior, recognition masking, favorites persistence, and batch-drill mechanics.","Which Roux-specific training and analyzer behaviors are strategically worth reproducing in first-party code through a clean-room handoff?","Inspect blockbuilding micro-trainers, stage-specific state machines, solver-backed analyzer logic, recognition masking, favorites/batch-drill persistence, and 2D/3D visualization boundaries.","Audit onionhoney/roux-trainers as a focused restrictive clean-room donor for HyperTwist. Preserve method-specific training-state-machine, analyzer, recognition-masking, and drill-loop behavior in a scrubbed Model A handoff only.","tao-yu/Alg-Trainer","base + donor swarm","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","poliva/cubedex","specialized training UX 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.","Lykos/cube_trainer","sampling/analytics 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.","HyperTwist only","Restrictive clean-room donor value is real, but it should flow through Model A to a first-party implementation rather than through direct source sharing.","exclude from direct code use, keep as clean-room donor","The repo is GPLv3 and too method-specific for direct incorporation, but it still contains real training/analyzer subsystem value worth preserving through a clean-room donor path.","high","The dossier-backed classification is stable: stronger than a passive benchmark, but clearly a restrictive clean-room donor rather than direct donor code.","high","The dossier-backed classification is stable: stronger than a passive benchmark, but clearly a restrictive clean-room donor rather than direct donor code.","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","","","","onionhoney/roux-trainers — GPLv3 Roux trainer; keep as a focused restrictive clean-room donor, not direct donor code.","onionhoney/roux-trainers remains valuable because it contains stage-specific training-state machines, solver-backed analyzer modes, recognition masking, and batch-drill patterns. That value should flow through a clean-room donor path, not direct incorporation.","memo","False","True","0.0","1.0","HT_training_clean_room","HT_training_clean_room_0006","Focused restrictive clean-room donor target","Focused restrictive clean-room donor target for HyperTwist; stronger than a passive benchmark, but still not direct donor code.","HyperTwist","Focused restrictive clean-room donor target","repurpose","architecture only","medium","onionhoney/roux-trainers","HyperTwist","","","","","","","","","","","","","","","","Original global operational v3 retained","GPL-3.0","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","","30.0","5","117.0","Donor Bench","Focused restrictive clean-room donor target","Included","P2","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.","Model A inspects the restrictive source; Model B implements only from a scrubbed first-party specification and must not access the repo directly.","Direct incorporation would require GPL-compatible distribution/compliance and is not the planned HyperTwist path.","Yes — preferred path for selectively reproducing stage-specific training and analyzer behavior in first-party code.","high","gpl-clean-room-donor","no","","","","","","","","","","","","","v6.3_final_source_of_truth","Corrected on 2026-04-25 from stale donor posture to dossier-backed focused restrictive clean-room donor status.","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." "11936","yakupbilen/drl-rubiks-cube","https://github.com/yakupbilen/drl-rubiks-cube","HyperTwist","31.0","117.0","132.0","B","vision / perception / AR","subsystem donor","vision donor","Reserve Bench","future candidate","architecture only","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 calibration/detection/state-reconstruction logic while replacing camera UX and integration surfaces.","yakupbilen/drl-rubiks-cube — MIT — RL solver with PyQt5 + webcam input.","Integrate as a cubing / algorithm training subsystem for HyperTwist. Preserve the strongest existing pieces — scramble generation, algorithm database, recognition/training loop, timing/statistics, virtual cube, smartcube hooks, spaced repetition — and expose them behind a portfolio-stable interface. Wire first into tao-yu/Alg-Trainer, then into poliva/cubedex for orchestration, visualization, or data exchange.","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.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Benchmark calibration pipeline; Extract state reconstruction; Wrap with camera/AR adapter","deep source audit","Hidden value often sits in calibration, preprocessing, stabilization, object/state reconstruction, replay artifacts, and camera-to-domain state pipelines that are not obvious from demos.","Inspect preprocessing/calibration; tracking stabilization; state reconstruction; replay/event model; camera abstraction; fallback heuristics; testing assets/videos; performance shortcuts.","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.","Audit yakupbilen/drl-rubiks-cube as a vision / perception / AR candidate for HyperTwist. Do not stop at README-level features. Inspect: Inspect preprocessing/calibration; tracking stabilization; state reconstruction; replay/event model; camera abstraction; fallback heuristics; testing assets/videos; performance shortcuts. Decide whether the best extraction path is moderate modification and whether it belongs as subsystem donor / vision donor. Test the three merger paths in order: 1) kkoomen/qbr [foundation + perception donor]; 2) vivaansinghvi07/rubix-cube-solver [perception + replay donor]; 3) cubing/cubing.js [state/render backend]. Return hidden modules, reusable schemas, protocol layers, plugin hooks, render/state models, datasets/test fixtures, and any subsystem stronger than the visible product shell.","kkoomen/qbr","foundation + perception donor","Use this repo against the partner as an augmenting layer; preserve the partner as the likely base and mine this repo for capabilities that improve breadth, UX, or specialization.","vivaansinghvi07/rubix-cube-solver","perception + replay 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.","cubing/cubing.js","state/render backend","Use the partner for canonical state or rendering abstractions and merge this repo's specialized logic on top.","VectorShell | ScriptoriumAI","VectorShell can borrow spatial/rendering and perception primitives; ScriptoriumAI can borrow tutorial/educational visualization patterns rather than the full engine.","exclude from standalone? no","Not necessarily the final base, but keep as an active subsystem candidate or major donor.","medium","single-source signal; clear taxonomy; active integration value","medium","memo mentions: 1","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","","","","yakupbilen/drl-rubiks-cube — MIT — RL solver with PyQt5 + webcam input.","yakupbilen/drl-rubiks-cube is treated as a future candidate for HyperTwist because the current dossier retains it mainly for learned-heuristic search, batched A-star style experimentation, and training-loop ideas, not as part of the committed perception core.","memo","False","True","0.0","1.0","HT_cube_vision","HT_cube_vision_0008","cubing / algorithm training","Integrate primarily for HyperTwist. Its memo and bookmark signals place it in the cubing / algorithm training layer.","HyperTwist","cubing / algorithm training","integrate","moderate modification","medium","yakupbilen/drl-rubiks-cube","HyperTwist","","","","","","","","","","","","","","","","Original global operational v3 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","","31.0","5","117.0","Reserve Bench","Search/training systems bench","","","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.","Reference only: benchmark learned heuristic search and training experiments without near-term direct incorporation.","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","strategic-or-implemented-component","yes","","","","","","","","","","","","","v6.3_final_source_of_truth","Normalized legacy merge-bench wording to dossier-backed below-core benchmark posture on 2026-04-25.","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." "11939","Hypercubers/hypercubing.xyz","https://github.com/Hypercubers/hypercubing.xyz","HyperTwist","32.0","92.0","101.0","C","hypercubing / nD engine","subsystem donor","simulation donor","locked strategic donor","repurpose","moderate modification","Treat this as a mineable codebase: keep selected internals (algorithms, renderers, adapters, parsers, schedulers) while replacing the surrounding product assumptions and architecture. For this repo class, that usually means preserving generalized puzzle/state/render logic while building a new application shell around it.","Website for the Hypercubing community","Repurpose selected subsystems rather than the whole product. Mine the repo for nD state model, move notation, renderer, projection controls, solver/traversal logic, puzzle serialization, replay; keep what materially shortens build time, but rebind data contracts, permissions, UI shell, storage, and deployment to the HyperTwist architecture. Best first pairing order: HactarCE/Hyperspeedcube, cubing/cubing.js, tao-yu/Alg-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: HactarCE/Hyperspeedcube, cubing/cubing.js, tao-yu/Alg-Trainer.","Repurpose here means: turn it into a higher-dimensional renderer/simulator donor and shared interaction grammar for HyperTwist and long-horizon VectorShell.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Isolate puzzle/state core; Extract render/input abstractions; Document notation and save format","deep source audit","Hidden value is likely in generalized puzzle/state representations, higher-dimensional transforms, notation systems, save formats, puzzle generators, and rendering abstractions.","Inspect generalized puzzle/state model; notation parser; transform math; rendering abstraction; save/load format; puzzle generator; input mapping; performance optimizations.","Inspect package manifests, README/docs, src tree, examples, tests, CI workflows, config files, migrations/schemas, and hidden feature flags or experimental modules. Look for higher-dimensional state/notation representations, projection math, renderer abstractions, puzzle serialization, controls, and replay/training hooks.","Audit Hypercubers/hypercubing.xyz as a hypercubing / nD engine candidate for HyperTwist. Do not stop at README-level features. Inspect: Inspect generalized puzzle/state model; notation parser; transform math; rendering abstraction; save/load format; puzzle generator; input mapping; performance optimizations. Decide whether the best extraction path is heavy modification and whether it belongs as subsystem donor / simulation donor. Test the three merger paths in order: 1) HactarCE/Hyperspeedcube [foundation + donor]; 2) cubing/cubing.js [3D engine + notation/state donor]; 3) tao-yu/Alg-Trainer [training UX 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.","HactarCE/Hyperspeedcube","foundation + donor","Use this repo against the partner as an augmenting layer; preserve the partner as the likely base and mine this repo for capabilities that improve breadth, UX, or specialization.","cubing/cubing.js","3D engine + notation/state donor","Use the partner for canonical state or rendering abstractions and merge this repo's specialized logic on top.","tao-yu/Alg-Trainer","training UX 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.","VectorShell | ScriptoriumAI","VectorShell can borrow spatial/rendering and perception primitives; ScriptoriumAI can borrow tutorial/educational visualization patterns rather than the full engine.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium-low","single-source signal; clear taxonomy; mostly donor/reference role","medium","explicit bookmark description available","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","HyperTwist(1)","HyperTwist Consider","Website for the Hypercubing community","","Hypercubers/hypercubing.xyz is treated as repurpose for HyperTwist because visible metadata points to the hypercubing / nD simulation layer. Surface signal: Website for the Hypercubing community The fit looks real, but more as a donor/augmenter than as a standalone foundation.","bookmarks","True","False","1.0","0.0","HT_hyper_engine","HT_hyper_engine_0006","hypercubing / nD simulation","Integrate primarily for HyperTwist. Its description and bookmark placement under ""HyperTwist Consider"" place it in the hypercubing / nD simulation layer.","HyperTwist","hypercubing / nD simulation","integrate","heavy modification","medium","hypercubers/hypercubing.xyz","HyperTwist","","","","","","","","","","","","","","","","Original global operational v3 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","","32.0","5","92.0","Locked Strategic Donor","Knowledge and curriculum donor","","P1","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.","Use selectively as a donor for knowledge structures, notation, taxonomy, and leaderboard-generation logic; do not confuse the site snapshot with the canonical repo.","Preserve MIT notices and attribution where required.","Usually unnecessary unless later replacing a narrow implementation seam is cleaner than carrying the upstream code.","high","permissive-knowledge-donor","yes","","","","","","","","","","","","","v6.3_final_source_of_truth","Corrected on 2026-04-25 from stale unknown-license donor-bench posture to dossier-backed MIT knowledge/curriculum donor status.","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." -"11945","Aarav2709/KubeTimr","https://github.com/Aarav2709/KubeTimr","HyperTwist","34.0","88.0","97.0","C","cubing trainer / solver / timing","subsystem donor","training donor","donor bench","repurpose","moderate modification","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 cube-state, scramble, scheduling, or timer internals while adapting pedagogy, analytics, and UI.","Aarav2709/KubeTimr — MIT — Keyboard-first offline timer. | Aarav2709/KubeTimr — MIT — Offline timer.","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.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Extract cube-state model; Normalize trainer/case schema; Expose analytics and replay hooks","deep source audit","Hidden value often sits in cube-state representation, scramble generation, weighted drill scheduling, recognition datasets, replay/timer internals, and case database schemas.","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.","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.","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.","tao-yu/Alg-Trainer","base + donor swarm","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","poliva/cubedex","specialized training UX 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.","Lykos/cube_trainer","sampling/analytics 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.","project-local first","Cross-project transfer is possible, but the value is clearest inside the assigned project until source audit exposes more reusable primitives.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium","single-source signal; clear taxonomy; mostly donor/reference role","medium","strong adjacency to identified core stack; memo mentions: 2","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","","","","Aarav2709/KubeTimr — MIT — Keyboard-first offline timer. | Aarav2709/KubeTimr — MIT — Offline timer.","Aarav2709/KubeTimr is treated as repurpose for HyperTwist because the current dossier keeps it as a focused subsystem donor for timer-state logic, split-phase handling, local persistence, rolling stats, and keyboard-first offline practice flow rather than as a broader training-platform anchor.","memo","False","True","0.0","2.0","HT_training_stack","HT_training_stack_0015","cubing / algorithm training","Integrate primarily for HyperTwist. Its memo and bookmark signals place it in the cubing / algorithm training layer.","HyperTwist","cubing / algorithm training","integrate","moderate modification","medium","aarav2709/kubetimr","HyperTwist","","","","","","","","","","","","","","","","Original global operational v3 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","","34.0","5","88.0","Donor Bench","Focused subsystem donor","","","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." +"11945","Aarav2709/KubeTimr","https://github.com/Aarav2709/KubeTimr","HyperTwist","34.0","88.0","97.0","C","cubing trainer / solver / timing","subsystem donor","training donor","donor bench","repurpose","moderate modification","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 cube-state, scramble, scheduling, or timer internals while adapting pedagogy, analytics, and UI.","Aarav2709/KubeTimr — MIT — Keyboard-first offline timer. | Aarav2709/KubeTimr — MIT — Offline timer.","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.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Extract cube-state model; Normalize trainer/case schema; Expose analytics and replay hooks","deep source audit","Hidden value often sits in cube-state representation, scramble generation, weighted drill scheduling, recognition datasets, replay/timer internals, and case database schemas.","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.","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.","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.","tao-yu/Alg-Trainer","base + donor swarm","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","poliva/cubedex","specialized training UX 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.","Lykos/cube_trainer","sampling/analytics 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.","project-local first","Cross-project transfer is possible, but the value is clearest inside the assigned project until source audit exposes more reusable primitives.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium","single-source signal; clear taxonomy; mostly donor/reference role","medium","strong adjacency to identified core stack; memo mentions: 2","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","","","","Aarav2709/KubeTimr — MIT — Keyboard-first offline timer. | Aarav2709/KubeTimr — MIT — Offline timer.","Aarav2709/KubeTimr is treated as repurpose for HyperTwist because the current dossier keeps it as a focused subsystem donor for timer-state logic, split-phase handling, local persistence, rolling stats, and keyboard-first offline practice flow rather than as a broader training-platform anchor.","memo","False","True","0.0","2.0","HT_training_stack","HT_training_stack_0015","cubing / algorithm training","Integrate primarily for HyperTwist. Its memo and bookmark signals place it in the cubing / algorithm training layer.","HyperTwist","cubing / algorithm training","integrate","moderate modification","medium","aarav2709/kubetimr","HyperTwist","","","","","","","","","","","","","","","","Original global operational v3 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","","34.0","5","88.0","Donor Bench","Focused subsystem donor","","","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." "11951","roice3/MagicTile","https://github.com/roice3/MagicTile","HyperTwist","36.0","88.0","97.0","C","infra / runtime / observability / integration","subsystem donor","integration utility","locked strategic donor","repurpose","moderate modification","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.","Non-euclidean Rubik's Cube Analogues","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.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Extract collectors/adapters; Normalize topology/config schema; Bridge into control-plane API","deep source audit","Hidden value usually sits in service topology schemas, collector agents, auth/integration adapters, caching, deployment abstractions, and metrics/event correlation.","Inspect topology/service schema; collectors/agents; auth/integration adapters; caching/state sync; deployment/runtime abstractions; metrics/event correlation; config layering.","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.","Audit roice3/MagicTile as a infra / runtime / observability / integration candidate for HyperTwist. Do not stop at README-level features. Inspect: Inspect topology/service schema; collectors/agents; auth/integration adapters; caching/state sync; deployment/runtime abstractions; metrics/event correlation; config layering. Decide whether the best extraction path is moderate modification and whether it belongs as subsystem donor / integration utility. Test the three merger paths in order: 1) project-local anchor [base + donor]; 2) shared portfolio utility [augmenter]; 3) cross-project transfer candidate [future merger]. Return hidden modules, reusable schemas, protocol layers, plugin hooks, render/state models, datasets/test fixtures, and any subsystem stronger than the visible product shell.","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.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium-low","single-source signal; clear taxonomy; mostly donor/reference role","medium","explicit bookmark description available","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","HyperTwist(1)","HyperTwist Consider","Non-euclidean Rubik's Cube Analogues","","roice3/MagicTile is treated as repurpose for HyperTwist because visible metadata points to the cubing / algorithm training layer. Surface signal: Non-euclidean Rubik's Cube Analogues The fit looks real, but more as a donor/augmenter than as a standalone foundation.","bookmarks","True","False","1.0","0.0","HT_hyper_engine","HT_hyper_engine_0007","cubing / algorithm training","Integrate primarily for HyperTwist. Its description and bookmark placement under ""HyperTwist Consider"" place it in the cubing / algorithm training layer.","HyperTwist","cubing / algorithm training","integrate","moderate modification","medium","roice3/magictile","HyperTwist","","","","","","","","","","","","","","","","Original global operational v3 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","","36.0","5","88.0","Locked Strategic Donor","Top-tier non-Euclidean geometry and topology donor","","P1","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.","Direct donor use or bounded adapter extraction are both acceptable; choose the seam that best preserves the topology and twist infrastructure.","Preserve MIT notices and attribution where required.","Usually unnecessary unless later replacing a narrow seam is cleaner than carrying the upstream code.","high","permissive-top-tier-donor","yes","","","","","","","","","","","","","v6.3_final_source_of_truth","Assigned from legacy HY_misc to HT_hyper_engine during cluster normalization 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." "11967","PostHog/posthog","https://github.com/PostHog/posthog","HyperTwist","41.0","72.0","81.0","C","telemetry / replay / feature governance","subsystem donor","telemetry donor","donor bench","repurpose","moderate modification","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 calibration/detection/state-reconstruction logic while replacing camera UX and integration surfaces.","🦔 PostHog is an all-in-one developer platform for building successful products. We offer product analytics, web analytics, session replay, error tracking, feature flags, experimentation, surveys, data warehouse, a CDP, and an AI product ...","Repurpose selected subsystems rather than the whole product. Mine the repo for telemetry and event schemas, replay diagnostics, replay query surfaces, feature-flag governance, activity logs, and product/service boundary patterns; keep what materially shortens build time, but rebind data contracts, permissions, storage, and deployment to the HyperTwist architecture. Best first pairing order: HactarCE/Hyperspeedcube, cubing/cubing.js, kkoomen/qbr.","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: HactarCE/Hyperspeedcube, cubing/cubing.js, kkoomen/qbr.","Repurpose here means: turn it into a telemetry spine, replay diagnostics donor, feature-governance donor, or control-plane integration layer.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Benchmark calibration pipeline; Extract state reconstruction; Wrap with camera/AR adapter","deep source audit","Hidden value often sits in calibration, preprocessing, stabilization, object/state reconstruction, replay artifacts, and camera-to-domain state pipelines that are not obvious from demos.","Inspect replay routes and deep links; replay diagnostics; feature-flag CRUD, dependencies, and evaluation; telemetry and event schemas; product and service boundaries; MIT versus ee path splits.","Inspect package manifests, README/docs, product slices, services, tests, migrations/schemas, and hidden feature flags or experimental modules. Look for replay diagnostics, replay query surfaces, feature-flag governance, activity logs, event schemas, service boundaries, and MIT versus ee/ path splits.","Audit PostHog/posthog as a telemetry / replay / feature-governance candidate for HyperTwist. Do not stop at README-level features. Inspect: replay routes and deep links, replay diagnostics, feature-flag CRUD/dependencies/evaluation, telemetry and event schemas, product/service boundaries, and MIT versus ee/ path splits. Decide whether the best extraction path remains moderate modification and which seams should stay bounded due mixed licensing or mission misfit. Return hidden modules, reusable schemas, protocol layers, plugin hooks, replay/debugging surfaces, and any subsystem stronger than the visible product shell.","kkoomen/qbr","foundation + perception donor","Use this repo against the partner as an augmenting layer; preserve the partner as the likely base and mine this repo for capabilities that improve breadth, UX, or specialization.","vivaansinghvi07/rubix-cube-solver","perception + replay 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.","cubing/cubing.js","state/render backend","Use the partner for canonical state or rendering abstractions and merge this repo's specialized logic on top.","VectorShell | ScriptoriumAI","VectorShell can borrow spatial/rendering and perception primitives; ScriptoriumAI can borrow tutorial/educational visualization patterns rather than the full engine.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium-low","single-source signal; clear taxonomy; mostly donor/reference role","medium","explicit bookmark description available","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","HyperTwist(1)","HyperTwist Consider","🦔 PostHog is an all-in-one developer platform for building successful products. We offer product analytics, web analytics, session replay, error tracking, feature flags, experimentation, surveys, data warehouse, a CDP, and an AI product assistant to help debug your code, ship features faster, and keep all your usage and customer data in one stack.","","PostHog/posthog is treated as repurpose for HyperTwist because visible metadata points to the cloud / infra / observability / api layer. Surface signal: 🦔 PostHog is an all-in-one developer platform for building successful products. We offer product analytics, web analytics, session replay, error tracking, feature flags, experimentation, surveys, data warehouse, a CDP, and an AI product ... The fit looks real, but more as a donor/augmenter than as a standalone foundation.","bookmarks","True","False","1.0","0.0","HT_control_plane","HT_control_plane_0001","cloud / infra / observability / api","Repurpose selectively for HyperTwist. Its visible platform signal and source audit place it in telemetry, replay, and feature-governance rather than computer vision or AR.","HyperTwist","telemetry / replay / feature governance","repurpose","moderate modification","medium","posthog/posthog","HyperTwist","","","","","","","","","","","","","","","","Original global operational v3 retained","MIT outside ee/; enterprise-restricted in ee/","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","","41.0","5","72.0","","Telemetry / replay / feature-governance donor","","","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.","Use only clearly MIT paths outside ee/ as bounded telemetry, replay, and feature-governance donor surfaces; exclude enterprise paths or reimplement equivalent seams.","Keep MIT notices for reused paths and do not incorporate ee/ without separate commercial rights; verify path provenance before shipping.","Sometimes useful for enterprise-gated or off-mission slices, but not required for clearly MIT paths.","high","mixed-license-path-review-required","no","","","","","","","","","","","","","v6.3_final_source_of_truth","Assigned to HT_control_plane and normalized telemetry/replay/feature-governance wording on 2026-04-25.","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","","","","","interface / visualization / shell surface","subsystem donor","interface donor","donor bench","repurpose","moderate modification","Retain the reusable avatar, lip-sync, and retargeting layers, but replace the demo shell, asset assumptions, and voice-service integration with HyperTwist-owned surfaces.","","Repurpose selected subsystems rather than the whole product. Mine the repo for embodied coach avatar runtime, lip-sync and subtitle timing, avatar-only embedding, retargeting, and streamed speech playback; keep what shortens build time, but rebind assets, voice services, and UI shell to the HyperTwist architecture.","","Repurpose here means: turn it into a browser-side embodied coach or companion layer.","","","","Inspect talkinghead runtime; speech queueing and streaming; viseme and blendshape flow; avatarOnly embedding; retargeting; and audio worklet behavior.","Inspect modules, examples, tests, site config, streaming demos, retargeter, and playback worklet code. Look for embodied-coach embedding, lip-sync, subtitle timing, gesture and expression surfaces, and asset assumptions.","Audit met4citizen/TalkingHead as a browser embodied-coach candidate for HyperTwist. Inspect the avatar runtime, streaming lip-sync, subtitle timing, avatarOnly embedding, retargeting, and audio worklet behavior. Decide which seams can be used directly and which must remain bounded behind the HyperTwist coaching shell.","","","","","","","","","","","","","","medium","Canonized Markdown dossier exists and the repo has been source-backed, but CSV backfill is later than the original v6.3 board generation.","medium","Source-backed dossier exists and the repo has been reconciled into the later Markdown authority stack.","","","","","","","","","","","","HT_browser_surface","HT_browser_surface_0001","browser / 3D / XR / presentation","Repurpose selectively for HyperTwist. Its source-backed role is an embodied coach and companion presentation donor, not a generic avatar product shell.","HyperTwist","browser / 3D / XR / presentation","repurpose","moderate modification","medium","met4citizen/talkinghead","","","","","","","","","","","","","","","","","","MIT","known_from_reference_material","uploaded_reference_docs","","","","","","","","","","","","","","Donor Bench","Browser embodied coach surface","Included","P2","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.","Use directly as a bounded browser-side dependency or adapter layer; keep voice services, product logic, and asset provenance outside the upstream shell.","Typically preserve notices, attribution, and license text where required; review sample avatars or media separately from the code license.","Usually unnecessary unless you later replace a narrow upstream layer for product-shaping reasons.","high","standard-notice-review","yes","","","","","","","","","","","","","v6.3_markdown_backfill","Backfilled from canonized Markdown dossier pass on 2026-04-24.","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." diff --git a/docs/repo_portfolio_unified_phase_g_v6_3.csv b/docs/repo_portfolio_unified_phase_g_v6_3.csv index 55aafb7..e696652 100644 --- a/docs/repo_portfolio_unified_phase_g_v6_3.csv +++ b/docs/repo_portfolio_unified_phase_g_v6_3.csv @@ -36,7 +36,7 @@ "30.0","onionhoney/roux-trainers","https://github.com/onionhoney/roux-trainers","HyperTwist","30.0","117.0","132.0","B","method-specific training donor","restrictive donor","clean-room donor","donor bench","repurpose","architecture only","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 cube-state, scramble, scheduling, or timer internals while adapting pedagogy, analytics, and UI.","Focused restrictive clean-room donor target. Retain the stage-specific training modes, solver-backed analyzer behavior, recognition masking, favorites/batch-drill flow, and 2D/3D training visualization ideas through Model A / Model B separation.","Keep in restrictive custody and route value through clean-room extraction only. Use it as a method-specific training and analyzer donor, not as direct donor code.","Do not merge this repo into the HyperTwist core as source. Convert the valuable training-state-machine and analyzer behaviors into first-party subsystems behind a clean-room boundary.","Repurpose here means: translate stage-specific training and analyzer behaviors into first-party implementations through a clean-room process.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Extract cube-state model; Normalize trainer/case schema; Expose analytics and replay hooks","deep source audit","Hidden value sits in state-machine-driven training flows, solver-backed analyzer behavior, recognition masking, favorites persistence, and batch-drill mechanics.","Which Roux-specific training and analyzer behaviors are strategically worth reproducing in first-party code through a clean-room handoff?","Inspect blockbuilding micro-trainers, stage-specific state machines, solver-backed analyzer logic, recognition masking, favorites/batch-drill persistence, and 2D/3D visualization boundaries.","Audit onionhoney/roux-trainers as a focused restrictive clean-room donor for HyperTwist. Preserve method-specific training-state-machine, analyzer, recognition-masking, and drill-loop behavior in a scrubbed Model A handoff only.","tao-yu/Alg-Trainer","base + donor swarm","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","poliva/cubedex","specialized training UX 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.","Lykos/cube_trainer","sampling/analytics 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.","HyperTwist only","Restrictive clean-room donor value is real, but it should flow through Model A to a first-party implementation rather than through direct source sharing.","exclude from direct code use, keep as clean-room donor","The repo is GPLv3 and too method-specific for direct incorporation, but it still contains real training/analyzer subsystem value worth preserving through a clean-room donor path.","high","The dossier-backed classification is stable: stronger than a passive benchmark, but clearly a restrictive clean-room donor rather than direct donor code.","high","The dossier-backed classification is stable: stronger than a passive benchmark, but clearly a restrictive clean-room donor rather than direct donor code.","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","","","","onionhoney/roux-trainers — GPLv3 Roux trainer; keep as a focused restrictive clean-room donor, not direct donor code.","onionhoney/roux-trainers remains valuable because it contains stage-specific training-state machines, solver-backed analyzer modes, recognition masking, and batch-drill patterns. That value should flow through a clean-room donor path, not direct incorporation.","memo","False","True","0.0","1.0","HT_training_clean_room","HT_training_clean_room_0006","Focused restrictive clean-room donor target","Focused restrictive clean-room donor target for HyperTwist; stronger than a passive benchmark, but still not direct donor code.","HyperTwist","Focused restrictive clean-room donor target","repurpose","architecture only","medium","onionhoney/roux-trainers","1.0","Donor Bench","5.0","GPLv3 method-specific trainer with real subsystem value that should be preserved through clean-room extraction rather than donor use.","Focused restrictive clean-room donor target","Included","P2","Keep in canon as a focused restrictive clean-room donor for method-specific training and analyzer behavior.","2.0","3.0","3.0","11934.0","132.0","","onionhoney/roux-trainers","HyperTwist","","","","","","","","","","Original global Phase G v4 retained","GPL-3.0","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","30.0","3","5.0","117.0","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.","Model A inspects the restrictive source; Model B implements only from a scrubbed first-party specification and must not access the repo directly.","Direct incorporation would require GPL-compatible distribution/compliance and is not the planned HyperTwist path.","Yes — preferred path for selectively reproducing stage-specific training and analyzer behavior in first-party code.","high","gpl-clean-room-donor","no","","","","","","","","","","","","","v6.3_final_source_of_truth","Corrected on 2026-04-25 from stale donor posture to dossier-backed focused restrictive clean-room donor status.","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." "31.0","yakupbilen/drl-rubiks-cube","https://github.com/yakupbilen/drl-rubiks-cube","HyperTwist","31.0","117.0","132.0","B","vision / perception / AR","subsystem donor","vision donor","Reserve Bench","future candidate","architecture only","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 calibration/detection/state-reconstruction logic while replacing camera UX and integration surfaces.","yakupbilen/drl-rubiks-cube — MIT — RL solver with PyQt5 + webcam input.","Integrate as a cubing / algorithm training subsystem for HyperTwist. Preserve the strongest existing pieces — scramble generation, algorithm database, recognition/training loop, timing/statistics, virtual cube, smartcube hooks, spaced repetition — and expose them behind a portfolio-stable interface. Wire first into tao-yu/Alg-Trainer, then into poliva/cubedex for orchestration, visualization, or data exchange.","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.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Benchmark calibration pipeline; Extract state reconstruction; Wrap with camera/AR adapter","deep source audit","Hidden value often sits in calibration, preprocessing, stabilization, object/state reconstruction, replay artifacts, and camera-to-domain state pipelines that are not obvious from demos.","Inspect preprocessing/calibration; tracking stabilization; state reconstruction; replay/event model; camera abstraction; fallback heuristics; testing assets/videos; performance shortcuts.","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.","Audit yakupbilen/drl-rubiks-cube as a vision / perception / AR candidate for HyperTwist. Do not stop at README-level features. Inspect: Inspect preprocessing/calibration; tracking stabilization; state reconstruction; replay/event model; camera abstraction; fallback heuristics; testing assets/videos; performance shortcuts. Decide whether the best extraction path is moderate modification and whether it belongs as subsystem donor / vision donor. Test the three merger paths in order: 1) kkoomen/qbr [foundation + perception donor]; 2) vivaansinghvi07/rubix-cube-solver [perception + replay donor]; 3) cubing/cubing.js [state/render backend]. Return hidden modules, reusable schemas, protocol layers, plugin hooks, render/state models, datasets/test fixtures, and any subsystem stronger than the visible product shell.","kkoomen/qbr","foundation + perception donor","Use this repo against the partner as an augmenting layer; preserve the partner as the likely base and mine this repo for capabilities that improve breadth, UX, or specialization.","vivaansinghvi07/rubix-cube-solver","perception + replay 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.","cubing/cubing.js","state/render backend","Use the partner for canonical state or rendering abstractions and merge this repo's specialized logic on top.","VectorShell | ScriptoriumAI","VectorShell can borrow spatial/rendering and perception primitives; ScriptoriumAI can borrow tutorial/educational visualization patterns rather than the full engine.","exclude from standalone? no","Not necessarily the final base, but keep as an active subsystem candidate or major donor.","medium","single-source signal; clear taxonomy; active integration value","medium","memo mentions: 1","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","","","","yakupbilen/drl-rubiks-cube — MIT — RL solver with PyQt5 + webcam input.","yakupbilen/drl-rubiks-cube is treated as a future candidate for HyperTwist because the current dossier retains it mainly for learned-heuristic search, batched A-star style experimentation, and training-loop ideas, not as part of the committed perception core.","memo","False","True","0.0","1.0","HT_cube_vision","HT_cube_vision_0008","cubing / algorithm training","Integrate primarily for HyperTwist. Its memo and bookmark signals place it in the cubing / algorithm training layer.","HyperTwist","cubing / algorithm training","integrate","moderate modification","medium","yakupbilen/drl-rubiks-cube","1.0","Reserve Bench","5.0","Useful MIT search and training benchmark for learned-heuristic search, state generation, and experimentation loops, but explicitly below the committed perception and training core.","Search/training systems bench","Included","P2","yakupbilen/drl-rubiks-cube is placed in Reserve Bench for HyperTwist because it best serves the 'Search/training systems bench' role; recommended action is 'future candidate' with repurposing scope 'architecture only'. Confidence is medium because this remains a metadata-level judgment until source audit confirms hidden modules, plugin points, adapters, or architectural strengths.","2.0","3.0","3.0","11937.0","133.0","","yakupbilen/drl-rubiks-cube","HyperTwist","","","","","","","","","","Original global Phase G v4 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","31.0","3","5.0","117.0","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.","Reference only: benchmark learned heuristic search and training experiments without near-term direct incorporation.","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","strategic-or-implemented-component","yes","","","","","","","","","","","","","v6.3_final_source_of_truth","Normalized legacy merge-bench wording to dossier-backed below-core benchmark posture on 2026-04-25.","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." "32.0","Hypercubers/hypercubing.xyz","https://github.com/Hypercubers/hypercubing.xyz","HyperTwist","32.0","92.0","101.0","C","hypercubing / nD engine","subsystem donor","simulation donor","locked strategic donor","repurpose","moderate modification","Treat this as a mineable codebase: keep selected internals (algorithms, renderers, adapters, parsers, schedulers) while replacing the surrounding product assumptions and architecture. For this repo class, that usually means preserving generalized puzzle/state/render logic while building a new application shell around it.","Website for the Hypercubing community","Repurpose selected subsystems rather than the whole product. Mine the repo for nD state model, move notation, renderer, projection controls, solver/traversal logic, puzzle serialization, replay; keep what materially shortens build time, but rebind data contracts, permissions, UI shell, storage, and deployment to the HyperTwist architecture. Best first pairing order: HactarCE/Hyperspeedcube, cubing/cubing.js, tao-yu/Alg-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: HactarCE/Hyperspeedcube, cubing/cubing.js, tao-yu/Alg-Trainer.","Repurpose here means: turn it into a higher-dimensional renderer/simulator donor and shared interaction grammar for HyperTwist and long-horizon VectorShell.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Isolate puzzle/state core; Extract render/input abstractions; Document notation and save format","deep source audit","Hidden value is likely in generalized puzzle/state representations, higher-dimensional transforms, notation systems, save formats, puzzle generators, and rendering abstractions.","Inspect generalized puzzle/state model; notation parser; transform math; rendering abstraction; save/load format; puzzle generator; input mapping; performance optimizations.","Inspect package manifests, README/docs, src tree, examples, tests, CI workflows, config files, migrations/schemas, and hidden feature flags or experimental modules. Look for higher-dimensional state/notation representations, projection math, renderer abstractions, puzzle serialization, controls, and replay/training hooks.","Audit Hypercubers/hypercubing.xyz as a hypercubing / nD engine candidate for HyperTwist. Do not stop at README-level features. Inspect: Inspect generalized puzzle/state model; notation parser; transform math; rendering abstraction; save/load format; puzzle generator; input mapping; performance optimizations. Decide whether the best extraction path is heavy modification and whether it belongs as subsystem donor / simulation donor. Test the three merger paths in order: 1) HactarCE/Hyperspeedcube [foundation + donor]; 2) cubing/cubing.js [3D engine + notation/state donor]; 3) tao-yu/Alg-Trainer [training UX 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.","HactarCE/Hyperspeedcube","foundation + donor","Use this repo against the partner as an augmenting layer; preserve the partner as the likely base and mine this repo for capabilities that improve breadth, UX, or specialization.","cubing/cubing.js","3D engine + notation/state donor","Use the partner for canonical state or rendering abstractions and merge this repo's specialized logic on top.","tao-yu/Alg-Trainer","training UX 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.","VectorShell | ScriptoriumAI","VectorShell can borrow spatial/rendering and perception primitives; ScriptoriumAI can borrow tutorial/educational visualization patterns rather than the full engine.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium-low","single-source signal; clear taxonomy; mostly donor/reference role","medium","explicit bookmark description available","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","HyperTwist(1)","HyperTwist Consider","Website for the Hypercubing community","","Hypercubers/hypercubing.xyz is treated as repurpose for HyperTwist because visible metadata points to the hypercubing / nD simulation layer. Surface signal: Website for the Hypercubing community The fit looks real, but more as a donor/augmenter than as a standalone foundation.","bookmarks","True","False","1.0","0.0","HT_hyper_engine","HT_hyper_engine_0006","hypercubing / nD simulation","Integrate primarily for HyperTwist. Its description and bookmark placement under ""HyperTwist Consider"" place it in the hypercubing / nD simulation layer.","HyperTwist","hypercubing / nD simulation","integrate","heavy modification","medium","hypercubers/hypercubing.xyz","1.0","Locked Strategic Donor","4.0","MIT knowledge/curriculum donor with canonical notation, progression, taxonomy, and leaderboard-generation value.","Knowledge and curriculum donor","Included","P1","Keep as one of the strongest non-runtime donors in the hypercubing half of HyperTwist; the dossier-backed MIT posture and content value justify promotion above the old donor-bench treatment.","2.0","2.0","2.0","11938.0","134.0","Thin-fit assignment; verify project mapping during source audit","hypercubers/hypercubing.xyz","HyperTwist","","","","","","","","","","Original global Phase G v4 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","32.0","3","4.0","92.0","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.","Use selectively as a donor for knowledge structures, notation, taxonomy, and leaderboard-generation logic; do not confuse the site snapshot with the canonical repo.","Preserve MIT notices and attribution where required.","Usually unnecessary unless later replacing a narrow implementation seam is cleaner than carrying the upstream code.","high","permissive-knowledge-donor","yes","","","","","","","","","","","","","v6.3_final_source_of_truth","Corrected on 2026-04-25 from stale unknown-license donor-bench posture to dossier-backed MIT knowledge/curriculum donor status.","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." -"34.0","Aarav2709/KubeTimr","https://github.com/Aarav2709/KubeTimr","HyperTwist","34.0","88.0","97.0","C","cubing trainer / solver / timing","subsystem donor","training donor","donor bench","repurpose","moderate modification","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 cube-state, scramble, scheduling, or timer internals while adapting pedagogy, analytics, and UI.","Aarav2709/KubeTimr — MIT — Keyboard-first offline timer. | Aarav2709/KubeTimr — MIT — Offline timer.","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.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Extract cube-state model; Normalize trainer/case schema; Expose analytics and replay hooks","deep source audit","Hidden value often sits in cube-state representation, scramble generation, weighted drill scheduling, recognition datasets, replay/timer internals, and case database schemas.","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.","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.","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.","tao-yu/Alg-Trainer","base + donor swarm","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","poliva/cubedex","specialized training UX 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.","Lykos/cube_trainer","sampling/analytics 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.","project-local first","Cross-project transfer is possible, but the value is clearest inside the assigned project until source audit exposes more reusable primitives.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium","single-source signal; clear taxonomy; mostly donor/reference role","medium","strong adjacency to identified core stack; memo mentions: 2","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","","","","Aarav2709/KubeTimr — MIT — Keyboard-first offline timer. | Aarav2709/KubeTimr — MIT — Offline timer.","Aarav2709/KubeTimr is treated as repurpose for HyperTwist because the current dossier keeps it as a focused subsystem donor for timer-state logic, split-phase handling, local persistence, rolling stats, and keyboard-first offline practice flow rather than as a broader training-platform anchor.","memo","False","True","0.0","2.0","HT_training_stack","HT_training_stack_0015","cubing / algorithm training","Integrate primarily for HyperTwist. Its memo and bookmark signals place it in the cubing / algorithm training layer.","HyperTwist","cubing / algorithm training","integrate","moderate modification","medium","aarav2709/kubetimr","1.0","Donor Bench","4.0","Useful subsystem donor for timer-state logic, split-phase handling, local persistence, rolling stats, and keyboard-first offline practice flow.","Focused subsystem donor","Included","P2","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.","2.0","3.0","2.0","11944.0","135.0","","aarav2709/kubetimr","HyperTwist","","","","","","","","","","Original global Phase G v4 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","34.0","3","4.0","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." +"34.0","Aarav2709/KubeTimr","https://github.com/Aarav2709/KubeTimr","HyperTwist","34.0","88.0","97.0","C","cubing trainer / solver / timing","subsystem donor","training donor","donor bench","repurpose","moderate modification","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 cube-state, scramble, scheduling, or timer internals while adapting pedagogy, analytics, and UI.","Aarav2709/KubeTimr — MIT — Keyboard-first offline timer. | Aarav2709/KubeTimr — MIT — Offline timer.","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.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Extract cube-state model; Normalize trainer/case schema; Expose analytics and replay hooks","deep source audit","Hidden value often sits in cube-state representation, scramble generation, weighted drill scheduling, recognition datasets, replay/timer internals, and case database schemas.","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.","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.","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.","tao-yu/Alg-Trainer","base + donor swarm","Treat this pairing as a candidate donor merge rather than a replacement decision; inspect module boundaries to determine which side owns the final shell.","poliva/cubedex","specialized training UX 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.","Lykos/cube_trainer","sampling/analytics 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.","project-local first","Cross-project transfer is possible, but the value is clearest inside the assigned project until source audit exposes more reusable primitives.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium","single-source signal; clear taxonomy; mostly donor/reference role","medium","strong adjacency to identified core stack; memo mentions: 2","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","","","","Aarav2709/KubeTimr — MIT — Keyboard-first offline timer. | Aarav2709/KubeTimr — MIT — Offline timer.","Aarav2709/KubeTimr is treated as repurpose for HyperTwist because the current dossier keeps it as a focused subsystem donor for timer-state logic, split-phase handling, local persistence, rolling stats, and keyboard-first offline practice flow rather than as a broader training-platform anchor.","memo","False","True","0.0","2.0","HT_training_stack","HT_training_stack_0015","cubing / algorithm training","Integrate primarily for HyperTwist. Its memo and bookmark signals place it in the cubing / algorithm training layer.","HyperTwist","cubing / algorithm training","integrate","moderate modification","medium","aarav2709/kubetimr","1.0","Donor Bench","4.0","Useful subsystem donor for timer-state logic, split-phase handling, local persistence, rolling stats, and keyboard-first offline practice flow.","Focused subsystem donor","Included","P2","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.","2.0","3.0","2.0","11944.0","135.0","","aarav2709/kubetimr","HyperTwist","","","","","","","","","","Original global Phase G v4 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","34.0","3","4.0","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." "36.0","roice3/MagicTile","https://github.com/roice3/MagicTile","HyperTwist","36.0","88.0","97.0","C","infra / runtime / observability / integration","subsystem donor","integration utility","locked strategic donor","repurpose","moderate modification","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.","Non-euclidean Rubik's Cube Analogues","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.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Extract collectors/adapters; Normalize topology/config schema; Bridge into control-plane API","deep source audit","Hidden value usually sits in service topology schemas, collector agents, auth/integration adapters, caching, deployment abstractions, and metrics/event correlation.","Inspect topology/service schema; collectors/agents; auth/integration adapters; caching/state sync; deployment/runtime abstractions; metrics/event correlation; config layering.","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.","Audit roice3/MagicTile as a infra / runtime / observability / integration candidate for HyperTwist. Do not stop at README-level features. Inspect: Inspect topology/service schema; collectors/agents; auth/integration adapters; caching/state sync; deployment/runtime abstractions; metrics/event correlation; config layering. Decide whether the best extraction path is moderate modification and whether it belongs as subsystem donor / integration utility. Test the three merger paths in order: 1) project-local anchor [base + donor]; 2) shared portfolio utility [augmenter]; 3) cross-project transfer candidate [future merger]. Return hidden modules, reusable schemas, protocol layers, plugin hooks, render/state models, datasets/test fixtures, and any subsystem stronger than the visible product shell.","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.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium-low","single-source signal; clear taxonomy; mostly donor/reference role","medium","explicit bookmark description available","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","HyperTwist(1)","HyperTwist Consider","Non-euclidean Rubik's Cube Analogues","","roice3/MagicTile is treated as repurpose for HyperTwist because visible metadata points to the cubing / algorithm training layer. Surface signal: Non-euclidean Rubik's Cube Analogues The fit looks real, but more as a donor/augmenter than as a standalone foundation.","bookmarks","True","False","1.0","0.0","HT_hyper_engine","HT_hyper_engine_0007","cubing / algorithm training","Integrate primarily for HyperTwist. Its description and bookmark placement under ""HyperTwist Consider"" place it in the cubing / algorithm training layer.","HyperTwist","cubing / algorithm training","integrate","moderate modification","medium","roice3/magictile","1.0","Locked Strategic Donor","4.0","MIT donor with unusually strong non-Euclidean tiling, topology, and generalized twist infrastructure value.","Top-tier non-Euclidean geometry and topology donor","Included","P1","Keep as a top-tier non-Euclidean geometry and topology donor for HyperTwist; the dossier-backed MIT posture and source richness justify promotion above the old donor-bench treatment.","2.0","2.0","2.0","11950.0","136.0","Thin-fit assignment; verify project mapping during source audit","roice3/magictile","HyperTwist","","","","","","","","","","Original global Phase G v4 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","36.0","3","4.0","88.0","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.","Direct donor use or bounded adapter extraction are both acceptable; choose the seam that best preserves the topology and twist infrastructure.","Preserve MIT notices and attribution where required.","Usually unnecessary unless later replacing a narrow seam is cleaner than carrying the upstream code.","high","permissive-top-tier-donor","yes","","","","","","","","","","","","","v6.3_final_source_of_truth","Assigned from legacy HY_misc to HT_hyper_engine during cluster normalization 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." "41.0","PostHog/posthog","https://github.com/PostHog/posthog","HyperTwist","41.0","72.0","81.0","C","telemetry / replay / feature governance","subsystem donor","telemetry donor","donor bench","repurpose","moderate modification","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 calibration/detection/state-reconstruction logic while replacing camera UX and integration surfaces.","🦔 PostHog is an all-in-one developer platform for building successful products. We offer product analytics, web analytics, session replay, error tracking, feature flags, experimentation, surveys, data warehouse, a CDP, and an AI product ...","Repurpose selected subsystems rather than the whole product. Mine the repo for telemetry and event schemas, replay diagnostics, replay query surfaces, feature-flag governance, activity logs, and product/service boundary patterns; keep what materially shortens build time, but rebind data contracts, permissions, storage, and deployment to the HyperTwist architecture. Best first pairing order: HactarCE/Hyperspeedcube, cubing/cubing.js, kkoomen/qbr.","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: HactarCE/Hyperspeedcube, cubing/cubing.js, kkoomen/qbr.","Repurpose here means: turn it into a telemetry spine, replay diagnostics donor, feature-governance donor, or control-plane integration layer.","Map module boundaries; Identify hidden reusable internals; Define adapter/API boundary to target anchors; Write extraction tests against upstream behavior; Benchmark calibration pipeline; Extract state reconstruction; Wrap with camera/AR adapter","deep source audit","Hidden value often sits in calibration, preprocessing, stabilization, object/state reconstruction, replay artifacts, and camera-to-domain state pipelines that are not obvious from demos.","Inspect replay routes and deep links; replay diagnostics; feature-flag CRUD, dependencies, and evaluation; telemetry and event schemas; product and service boundaries; MIT versus ee path splits.","Inspect package manifests, README/docs, product slices, services, tests, migrations/schemas, and hidden feature flags or experimental modules. Look for replay diagnostics, replay query surfaces, feature-flag governance, activity logs, event schemas, service boundaries, and MIT versus ee/ path splits.","Audit PostHog/posthog as a telemetry / replay / feature-governance candidate for HyperTwist. Do not stop at README-level features. Inspect: replay routes and deep links, replay diagnostics, feature-flag CRUD/dependencies/evaluation, telemetry and event schemas, product/service boundaries, and MIT versus ee/ path splits. Decide whether the best extraction path remains moderate modification and which seams should stay bounded due mixed licensing or mission misfit. Return hidden modules, reusable schemas, protocol layers, plugin hooks, replay/debugging surfaces, and any subsystem stronger than the visible product shell.","kkoomen/qbr","foundation + perception donor","Use this repo against the partner as an augmenting layer; preserve the partner as the likely base and mine this repo for capabilities that improve breadth, UX, or specialization.","vivaansinghvi07/rubix-cube-solver","perception + replay 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.","cubing/cubing.js","state/render backend","Use the partner for canonical state or rendering abstractions and merge this repo's specialized logic on top.","VectorShell | ScriptoriumAI","VectorShell can borrow spatial/rendering and perception primitives; ScriptoriumAI can borrow tutorial/educational visualization patterns rather than the full engine.","exclude from core, keep as donor","Do not let it consume roadmap as a full product shell; mine reusable engines, adapters, schemas, UX patterns, or datasets.","medium-low","single-source signal; clear taxonomy; mostly donor/reference role","medium","explicit bookmark description available","Licensing intentionally ignored as a decision filter in this canonical evaluation; assess only architecture, capability, donor value, and concept transfer.","HyperTwist(1)","HyperTwist Consider","🦔 PostHog is an all-in-one developer platform for building successful products. We offer product analytics, web analytics, session replay, error tracking, feature flags, experimentation, surveys, data warehouse, a CDP, and an AI product assistant to help debug your code, ship features faster, and keep all your usage and customer data in one stack.","","PostHog/posthog is treated as repurpose for HyperTwist because visible metadata points to the cloud / infra / observability / api layer. Surface signal: 🦔 PostHog is an all-in-one developer platform for building successful products. We offer product analytics, web analytics, session replay, error tracking, feature flags, experimentation, surveys, data warehouse, a CDP, and an AI product ... The fit looks real, but more as a donor/augmenter than as a standalone foundation.","bookmarks","True","False","1.0","0.0","HT_control_plane","HT_control_plane_0001","cloud / infra / observability / api","Repurpose selectively for HyperTwist. Its visible platform signal and source audit place it in telemetry, replay, and feature-governance rather than computer vision or AR.","HyperTwist","telemetry / replay / feature governance","repurpose","moderate modification","medium","posthog/posthog","1.0","Donor Bench","4.0","Useful subsystem donor for HyperTwist in telemetry, replay diagnostics, feature flags, event-schema design, and vertical-slice control-plane patterns rather than the core runtime or product shell.","Telemetry / replay / feature-governance donor","Included","P2","PostHog/posthog is placed in Donor Bench for HyperTwist because it best serves the 'Telemetry / replay / feature-governance donor' role; recommended action remains 'repurpose' with repurposing scope 'moderate modification'. Its real retained value is replay diagnostics, flag governance, event-schema thinking, and service-boundary patterns rather than any vision or perception role.","2.0","2.0","2.0","11966.0","139.0","Thin-fit assignment; verify project mapping during source audit","posthog/posthog","HyperTwist","","","","","","","","","","Original global Phase G v4 retained","MIT outside ee/; enterprise-restricted in ee/","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","41.0","3","4.0","72.0","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.","Use only clearly MIT paths outside ee/ as bounded telemetry, replay, and feature-governance donor surfaces; exclude enterprise paths or reimplement equivalent seams.","Keep MIT notices for reused paths and do not incorporate ee/ without separate commercial rights; verify path provenance before shipping.","Sometimes useful for enterprise-gated or off-mission slices, but not required for clearly MIT paths.","high","mixed-license-path-review-required","no","","","","","","","","","","","","","v6.3_final_source_of_truth","Assigned to HT_control_plane and normalized telemetry/replay/feature-governance wording on 2026-04-25.","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","","","","","interface / visualization / shell surface","subsystem donor","interface donor","donor bench","repurpose","moderate modification","Retain the reusable avatar, lip-sync, and retargeting layers, but replace the demo shell, asset assumptions, and voice-service integration with HyperTwist-owned surfaces.","","Repurpose selected subsystems rather than the whole product. Mine the repo for embodied coach avatar runtime, lip-sync and subtitle timing, avatar-only embedding, retargeting, and streamed speech playback; keep what shortens build time, but rebind assets, voice services, and UI shell to the HyperTwist architecture.","","Repurpose here means: turn it into a browser-side embodied coach or companion layer.","","","","Inspect talkinghead runtime; speech queueing and streaming; viseme and blendshape flow; avatarOnly embedding; retargeting; and audio worklet behavior.","Inspect modules, examples, tests, site config, streaming demos, retargeter, and playback worklet code. Look for embodied-coach embedding, lip-sync, subtitle timing, gesture and expression surfaces, and asset assumptions.","Audit met4citizen/TalkingHead as a browser embodied-coach candidate for HyperTwist. Inspect the avatar runtime, streaming lip-sync, subtitle timing, avatarOnly embedding, retargeting, and audio worklet behavior. Decide which seams can be used directly and which must remain bounded behind the HyperTwist coaching shell.","","","","","","","","","","","","","","medium","Canonized Markdown dossier exists and the repo has been source-backed, but CSV backfill is later than the original v6.3 board generation.","medium","Source-backed dossier exists and the repo has been reconciled into the later Markdown authority stack.","","","","","","","","","","","","HT_browser_surface","HT_browser_surface_0001","browser / 3D / XR / presentation","Repurpose selectively for HyperTwist. Its source-backed role is an embodied coach and companion presentation donor, not a generic avatar product shell.","HyperTwist","browser / 3D / XR / presentation","repurpose","moderate modification","medium","met4citizen/talkinghead","","Donor Bench","4.0","Useful subsystem donor for HyperTwist, primarily in the browser companion layer; strongest embodied coach and avatar presentation donor in the current stack.","Browser embodied coach surface","Included","P2","met4citizen/TalkingHead is placed in Donor Bench for HyperTwist because it provides embodied coach UI, streaming lip-sync, retargeting, and avatar-only embedding behavior. Recommended action remains repurpose, but the retained value is a bounded browser coach surface rather than a general avatar product.","","","","","","","met4citizen/talkinghead","","","","","","","","","","","","MIT","known_from_reference_material","uploaded_reference_docs","","","","","","","","","","","v6_unified_source_of_truth_pack","","","","","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.","Use directly as a bounded browser-side dependency or adapter layer; keep voice services, product logic, and asset provenance outside the upstream shell.","Typically preserve notices, attribution, and license text where required; review sample avatars or media separately from the code license.","Usually unnecessary unless you later replace a narrow upstream layer for product-shaping reasons.","high","standard-notice-review","yes","","","","","","","","","","","","","v6.3_markdown_backfill","Backfilled from canonized Markdown dossier pass on 2026-04-24.","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." diff --git a/docs/repo_portfolio_unified_source_audit_v6_3.csv b/docs/repo_portfolio_unified_source_audit_v6_3.csv index 07a222f..b22ecf0 100644 --- a/docs/repo_portfolio_unified_source_audit_v6_3.csv +++ b/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 diff --git a/docs/repo_portfolio_unified_v6_3_README.txt b/docs/repo_portfolio_unified_v6_3_README.txt index 27c9c5c..3cbb5ff 100644 --- a/docs/repo_portfolio_unified_v6_3_README.txt +++ b/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 diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/AGENTS.md b/docs/v6_5_deep_manual_pack/HyperTwist/AGENTS.md index 9ce613c..a53cf5e 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/AGENTS.md +++ b/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` diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/DEVELOPMENT.md b/docs/v6_5_deep_manual_pack/HyperTwist/DEVELOPMENT.md index 80b34f7..a0b2282 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/DEVELOPMENT.md +++ 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 diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/LICENSETRACKING.md b/docs/v6_5_deep_manual_pack/HyperTwist/LICENSETRACKING.md index 0482d5f..4ca4ff8 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/LICENSETRACKING.md +++ b/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 diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md index 80ac6c5..271f2d4 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md +++ b/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