From 046653703ea078344071fa61880ef63db8e7fa7d Mon Sep 17 00:00:00 2001 From: axiomlogicnexus Date: Sat, 13 Jun 2026 00:44:53 +0000 Subject: [PATCH] Land Phase 6C higher-dimensional activation catalog --- ...rainingHigherDimensionalRuntimeLibrary.cpp | 311 ++++++++++++++++++ .../HyperTwistTrainingLibrary.cpp | 21 ++ .../HyperTwistTrainingRuntimeLibrary.cpp | 42 +++ ...tTrainingHigherDimensionalRuntimeLibrary.h | 211 ++++++++++++ .../HyperTwistTrainingRuntimeLibrary.h | 23 ++ ...mensionalPhase6CActivationContractTest.cpp | 140 ++++++++ ...NSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md | 12 +- ...SE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md | 25 ++ ...DOWS_BUILD_LANE_VERIFICATION_2026-06-01.md | 31 ++ ...BUILD_VALIDATION_REQUIREMENT_2026-06-01.md | 16 + .../HyperTwist/FEATURE_REGISTRY.md | 1 + .../HyperTwist/ROADMAP.md | 13 +- 12 files changed, 840 insertions(+), 6 deletions(-) create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.cpp create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHigherDimensionalPhase6CActivationContractTest.cpp diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.cpp new file mode 100644 index 0000000..ce5769c --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.cpp @@ -0,0 +1,311 @@ +#include "HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h" + +namespace HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal +{ + template + void AppendUniqueStrings(TArray& OutValues, const TStringArrayType& InValues) + { + for (const FString& Value : InValues) + { + if (!Value.IsEmpty()) + { + OutValues.AddUnique(Value); + } + } + } + + FHyperTwistTrainingSourceAttribution MakeActivationAttribution( + const FString& ActivationProfileId, + const FString& Notes + ) + { + FHyperTwistTrainingSourceAttribution Attribution; + Attribution.SourceMode = EHyperTwistTrainingSourceMode::FirstParty; + Attribution.SourceTrackId = TEXT("phase6c/higher-dimensional-runtime-activation"); + Attribution.SourceCaseId = ActivationProfileId; + Attribution.SourceNotes = Notes; + return Attribution; + } + + void AppendMagic120CellCapabilityTags( + const FHyperTwistTrainingMagic120CellRuntimeProfileContract& RuntimeProfile, + const FHyperTwistTrainingMagic120CellPersistenceBoundary& PersistenceBoundary, + const FHyperTwistTrainingMagic120CellViewProfileContract& ViewProfile, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile + ) + { + AppendUniqueStrings(OutProfile.RequiredPackageIds, RuntimeProfile.RequiredPackageIds); + AppendUniqueStrings(OutProfile.RequiredPackageIds, PersistenceBoundary.RequiredPackageIds); + AppendUniqueStrings(OutProfile.RequiredPackageIds, ViewProfile.RequiredPackageIds); + + AppendUniqueStrings(OutProfile.CapabilityTags, RuntimeProfile.PuzzleTypeSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, RuntimeProfile.SymmetrySurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, RuntimeProfile.VisibilitySurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, PersistenceBoundary.PersistenceSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, PersistenceBoundary.TwistHistorySurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, ViewProfile.ProjectionSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, ViewProfile.SymmetryPresetTags); + AppendUniqueStrings(OutProfile.CapabilityTags, ViewProfile.VisibilityPresetTags); + AppendUniqueStrings(OutProfile.CapabilityTags, ViewProfile.FocusSurfaceTags); + } + + void AppendMagicCube5DCapabilityTags( + const FHyperTwistTrainingMagicCube5DRuntimeProfileContract& RuntimeProfile, + const FHyperTwistTrainingMagicCube5DPersistenceBoundary& PersistenceBoundary, + const FHyperTwistTrainingMagicCube5DViewProfileContract& ViewProfile, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile + ) + { + AppendUniqueStrings(OutProfile.RequiredPackageIds, RuntimeProfile.RequiredPackageIds); + AppendUniqueStrings(OutProfile.RequiredPackageIds, PersistenceBoundary.RequiredPackageIds); + AppendUniqueStrings(OutProfile.RequiredPackageIds, ViewProfile.RequiredPackageIds); + + AppendUniqueStrings(OutProfile.CapabilityTags, RuntimeProfile.OrderSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, RuntimeProfile.InteractionSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, RuntimeProfile.ProgressSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, PersistenceBoundary.PersistenceSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, PersistenceBoundary.TwistHistorySurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, PersistenceBoundary.MacroSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, ViewProfile.ProjectionSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, ViewProfile.StereoSurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, ViewProfile.VisibilitySurfaceTags); + AppendUniqueStrings(OutProfile.CapabilityTags, ViewProfile.FocusSurfaceTags); + } + + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile BuildMagic120CellActivationProfile() + { + const FHyperTwistTrainingMagic120CellReferenceBundle Bundle = + UHyperTwistTrainingMagic120CellLibrary::BuildBundledMagic120CellReferenceBundle(); + + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (!Bundle.IsStructurallyValid()) + { + return Profile; + } + + FHyperTwistTrainingMagic120CellRuntimeProfileContract RuntimeProfile; + FHyperTwistTrainingMagic120CellPersistenceBoundary PersistenceBoundary; + FHyperTwistTrainingMagic120CellViewProfileContract ViewProfile; + FHyperTwistTrainingMagic120CellAttributionBoundary AttributionBoundary; + if (!UHyperTwistTrainingMagic120CellLibrary::TryGetRuntimeProfileContractById( + Bundle, + Bundle.PrimaryRuntimeProfileContractId, + RuntimeProfile + ) + || !UHyperTwistTrainingMagic120CellLibrary::TryGetPersistenceBoundaryById( + Bundle, + Bundle.PrimaryPersistenceBoundaryId, + PersistenceBoundary + ) + || !UHyperTwistTrainingMagic120CellLibrary::TryGetViewProfileContractById( + Bundle, + Bundle.PrimaryViewProfileContractId, + ViewProfile + ) + || !UHyperTwistTrainingMagic120CellLibrary::TryGetAttributionBoundaryById( + Bundle, + Bundle.PrimaryAttributionBoundaryId, + AttributionBoundary + )) + { + return FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); + } + + Profile.ActivationProfileId = TEXT("magic120cell-cleanroom-runtime-activation"); + Profile.Title = TEXT("Magic120Cell clean-room runtime activation"); + Profile.Summary = TEXT("First-party HyperTwist activation profile for the dedicated Magic120Cell family above the bounded retained donor contracts and the retained Hyperspeedcube runtime anchor."); + Profile.PuzzleId = TEXT("polychoron/magic120cell"); + Profile.RuntimeModeId = TEXT("magic120cell-full-color-runtime-v1"); + Profile.RuntimeStrategyId = TEXT("phase6c/unreal-cleanroom-family-runtime"); + Profile.RuntimeAnchorId = TEXT("retained/hyperspeedcube-runtime-anchor"); + Profile.PuzzleFamily = EHyperTwistPuzzleFamily::Other; + Profile.Dimension = 4; + Profile.DefinitionVersion = TEXT("2026.06"); + Profile.NotationProfile = TEXT("magic120cell-family"); + Profile.Variant = TEXT("full-color"); + Profile.bRequiresExternalProcess = false; + Profile.PrimaryRuntimeProfileContractId = RuntimeProfile.ContractId; + Profile.PrimaryPersistenceBoundaryId = PersistenceBoundary.BoundaryId; + Profile.PrimaryViewProfileContractId = ViewProfile.ContractId; + Profile.PrimaryAttributionBoundaryId = AttributionBoundary.BoundaryId; + Profile.DefaultSelectionTags = + { + TEXT("full-color puzzle type"), + TEXT("full-puzzle default mode"), + TEXT("logical visibility depth ladder"), + TEXT("center-cell recentering") + }; + + AppendMagic120CellCapabilityTags(RuntimeProfile, PersistenceBoundary, ViewProfile, Profile); + Profile.RequiredNoticeActions = AttributionBoundary.RequiredNoticeActions; + AppendUniqueStrings(Profile.ExplicitExclusions, RuntimeProfile.ExplicitExclusions); + AppendUniqueStrings(Profile.ExplicitExclusions, PersistenceBoundary.ExplicitExclusions); + AppendUniqueStrings(Profile.ExplicitExclusions, ViewProfile.ExplicitExclusions); + AppendUniqueStrings(Profile.ExplicitExclusions, AttributionBoundary.ExplicitExclusions); + Profile.SourceAttribution = MakeActivationAttribution( + Profile.ActivationProfileId, + TEXT("First-party Phase 6C clean-room activation profile layered above the bounded Magic120Cell donor contracts without widening into a generic topology shell or external-process host.") + ); + return Profile; + } + + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile BuildMagicCube5DActivationProfile() + { + const FHyperTwistTrainingMagicCube5DReferenceBundle Bundle = + UHyperTwistTrainingMagicCube5DLibrary::BuildBundledMagicCube5DReferenceBundle(); + + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + if (!Bundle.IsStructurallyValid()) + { + return Profile; + } + + FHyperTwistTrainingMagicCube5DRuntimeProfileContract RuntimeProfile; + FHyperTwistTrainingMagicCube5DPersistenceBoundary PersistenceBoundary; + FHyperTwistTrainingMagicCube5DViewProfileContract ViewProfile; + FHyperTwistTrainingMagicCube5DAttributionBoundary AttributionBoundary; + if (!UHyperTwistTrainingMagicCube5DLibrary::TryGetRuntimeProfileContractById( + Bundle, + Bundle.PrimaryRuntimeProfileContractId, + RuntimeProfile + ) + || !UHyperTwistTrainingMagicCube5DLibrary::TryGetPersistenceBoundaryById( + Bundle, + Bundle.PrimaryPersistenceBoundaryId, + PersistenceBoundary + ) + || !UHyperTwistTrainingMagicCube5DLibrary::TryGetViewProfileContractById( + Bundle, + Bundle.PrimaryViewProfileContractId, + ViewProfile + ) + || !UHyperTwistTrainingMagicCube5DLibrary::TryGetAttributionBoundaryById( + Bundle, + Bundle.PrimaryAttributionBoundaryId, + AttributionBoundary + )) + { + return FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); + } + + Profile.ActivationProfileId = TEXT("magiccube5d-cleanroom-runtime-activation"); + Profile.Title = TEXT("MagicCube5D clean-room runtime activation"); + Profile.Summary = TEXT("First-party HyperTwist activation profile for the bounded order-three MagicCube5D launch posture above the retained donor contracts and the retained Hyperspeedcube runtime anchor."); + Profile.PuzzleId = TEXT("hypercube/magiccube5d/order3"); + Profile.RuntimeModeId = TEXT("magiccube5d-order3-runtime-v1"); + Profile.RuntimeStrategyId = TEXT("phase6c/unreal-cleanroom-family-runtime"); + Profile.RuntimeAnchorId = TEXT("retained/hyperspeedcube-runtime-anchor"); + Profile.PuzzleFamily = EHyperTwistPuzzleFamily::Hypercube; + Profile.Dimension = 5; + Profile.DefinitionVersion = TEXT("2026.06"); + Profile.NotationProfile = TEXT("magiccube5d-family"); + Profile.SizeVector = {3, 3, 3, 3, 3}; + Profile.Variant = TEXT("order-3"); + Profile.bRequiresExternalProcess = false; + Profile.PrimaryRuntimeProfileContractId = RuntimeProfile.ContractId; + Profile.PrimaryPersistenceBoundaryId = PersistenceBoundary.BoundaryId; + Profile.PrimaryViewProfileContractId = ViewProfile.ContractId; + Profile.PrimaryAttributionBoundaryId = AttributionBoundary.BoundaryId; + Profile.DefaultSelectionTags = + { + TEXT("order-three default family mode"), + TEXT("stereo disabled default"), + TEXT("all-faces visible default"), + TEXT("control-click fifth-axis view rotation") + }; + + AppendMagicCube5DCapabilityTags(RuntimeProfile, PersistenceBoundary, ViewProfile, Profile); + Profile.RequiredNoticeActions = AttributionBoundary.RequiredNoticeActions; + AppendUniqueStrings(Profile.ExplicitExclusions, RuntimeProfile.ExplicitExclusions); + AppendUniqueStrings(Profile.ExplicitExclusions, PersistenceBoundary.ExplicitExclusions); + AppendUniqueStrings(Profile.ExplicitExclusions, ViewProfile.ExplicitExclusions); + AppendUniqueStrings(Profile.ExplicitExclusions, AttributionBoundary.ExplicitExclusions); + Profile.SourceAttribution = MakeActivationAttribution( + Profile.ActivationProfileId, + TEXT("First-party Phase 6C clean-room activation profile layered above the bounded MagicCube5D donor contracts without widening into a generic hyper-runtime shell or external-process host.") + ); + return Profile; + } +} + +FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog +UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog() +{ + FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog Catalog; + Catalog.Profiles = + { + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::BuildMagic120CellActivationProfile(), + HyperTwistTrainingHigherDimensionalRuntimeLibraryInternal::BuildMagicCube5DActivationProfile() + }; + return Catalog; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeActivationProfileById( + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog& Catalog, + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile +) +{ + if (ActivationProfileId.IsEmpty()) + { + OutProfile = FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); + return false; + } + + for (const FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& Profile : Catalog.Profiles) + { + if (Profile.MatchesActivationProfileId(ActivationProfileId)) + { + OutProfile = Profile; + return true; + } + } + + OutProfile = FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); + return false; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeActivationProfileByPuzzleId( + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog& Catalog, + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile +) +{ + if (PuzzleId.IsEmpty()) + { + OutProfile = FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); + return false; + } + + for (const FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& Profile : Catalog.Profiles) + { + if (Profile.MatchesPuzzleId(PuzzleId)) + { + OutProfile = Profile; + return true; + } + } + + OutProfile = FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile(); + return false; +} + +bool UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryResolvePuzzleDefinition( + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog& Catalog, + const FString& ActivationProfileIdOrPuzzleId, + FHyperTwistPuzzleDefinitionRef& OutDefinition +) +{ + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + const bool bResolved = + TryGetRuntimeActivationProfileById(Catalog, ActivationProfileIdOrPuzzleId, Profile) + || TryGetRuntimeActivationProfileByPuzzleId(Catalog, ActivationProfileIdOrPuzzleId, Profile); + if (!bResolved) + { + OutDefinition = FHyperTwistPuzzleDefinitionRef(); + return false; + } + + OutDefinition = Profile.ToDefinitionRef(); + return OutDefinition.IsStructurallyValid(); +} diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingLibrary.cpp index 037dc94..a516ce2 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingLibrary.cpp @@ -1,6 +1,7 @@ #include "HyperTwistTraining/HyperTwistTrainingLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingCatalogLibrary.h" +#include "HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h" #include "HyperTwistReplay/HyperTwistReplayLibrary.h" #include "JsonObjectConverter.h" @@ -349,6 +350,16 @@ namespace HyperTwistTrainingLibraryInternal return RetainedHyperDefinition; } + FHyperTwistPuzzleDefinitionRef HigherDimensionalDefinition; + if (UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryResolvePuzzleDefinition( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog(), + TrainingCase.PuzzleId, + HigherDimensionalDefinition + )) + { + return HigherDimensionalDefinition; + } + FHyperTwistPuzzleDefinitionRef Definition; Definition.PuzzleId = TrainingCase.PuzzleId; Definition.DefinitionVersion = TEXT("2026.04"); @@ -472,6 +483,16 @@ namespace HyperTwistTrainingLibraryInternal return RetainedHyperDefinition.PuzzleFamily == PuzzleFamily; } + FHyperTwistPuzzleDefinitionRef HigherDimensionalDefinition; + if (UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryResolvePuzzleDefinition( + UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog(), + PuzzleId, + HigherDimensionalDefinition + )) + { + return HigherDimensionalDefinition.PuzzleFamily == PuzzleFamily; + } + switch (PuzzleFamily) { case EHyperTwistPuzzleFamily::ClassicCube: diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp index d39ca87..8dee190 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp @@ -542,6 +542,12 @@ FHyperTwistTrainingMagicCube5DReferenceBundle UHyperTwistTrainingRuntimeLibrary: return UHyperTwistTrainingMagicCube5DLibrary::BuildBundledMagicCube5DReferenceBundle(); } +FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog +UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeActivationCatalog() +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::BuildBundledHigherDimensionalRuntimeActivationCatalog(); +} + FHyperTwistTrainingLearnedSearchReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledLearnedSearchReferenceBundle() { @@ -7011,6 +7017,42 @@ FString UHyperTwistTrainingRuntimeLibrary::BuildBundledMagicCube5DPackageCheckli ); } +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeActivationProfileById( + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeActivationProfileById( + GetBundledHigherDimensionalRuntimeActivationCatalog(), + ActivationProfileId, + OutProfile + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeActivationProfileByPuzzleId( + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryGetRuntimeActivationProfileByPuzzleId( + GetBundledHigherDimensionalRuntimeActivationCatalog(), + PuzzleId, + OutProfile + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryResolveBundledHigherDimensionalPuzzleDefinition( + const FString& ActivationProfileIdOrPuzzleId, + FHyperTwistPuzzleDefinitionRef& OutDefinition +) +{ + return UHyperTwistTrainingHigherDimensionalRuntimeLibrary::TryResolvePuzzleDefinition( + GetBundledHigherDimensionalRuntimeActivationCatalog(), + ActivationProfileIdOrPuzzleId, + OutDefinition + ); +} + bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledLearnedSearchExperimentProfileContract( const FString& ContractId, FHyperTwistTrainingLearnedSearchExperimentProfileContract& OutContract diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h new file mode 100644 index 0000000..98331fc --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h @@ -0,0 +1,211 @@ +#pragma once + +#include "CoreMinimal.h" +#include "Kismet/BlueprintFunctionLibrary.h" +#include "HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h" +#include "HyperTwistTraining/HyperTwistTrainingMagicCube5DLibrary.h" +#include "HyperTwistTrainingHigherDimensionalRuntimeLibrary.generated.h" + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ActivationProfileId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Title; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Summary; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PuzzleId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString RuntimeModeId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString RuntimeStrategyId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString RuntimeAnchorId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + EHyperTwistPuzzleFamily PuzzleFamily = EHyperTwistPuzzleFamily::Other; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + int32 Dimension = 4; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString DefinitionVersion = TEXT("2026.06"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString NotationProfile; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray SizeVector; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Variant; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bRequiresExternalProcess = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryRuntimeProfileContractId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryPersistenceBoundaryId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryViewProfileContractId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryAttributionBoundaryId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray DefaultSelectionTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RequiredPackageIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray CapabilityTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RequiredNoticeActions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ExplicitExclusions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FHyperTwistTrainingSourceAttribution SourceAttribution; + + bool IsStructurallyValid() const + { + return !ActivationProfileId.IsEmpty() + && !Title.IsEmpty() + && !PuzzleId.IsEmpty() + && !RuntimeModeId.IsEmpty() + && !RuntimeStrategyId.IsEmpty() + && !RuntimeAnchorId.IsEmpty() + && Dimension > 0 + && !DefinitionVersion.IsEmpty() + && !NotationProfile.IsEmpty() + && !PrimaryRuntimeProfileContractId.IsEmpty() + && !PrimaryPersistenceBoundaryId.IsEmpty() + && !PrimaryViewProfileContractId.IsEmpty() + && !PrimaryAttributionBoundaryId.IsEmpty() + && RequiredPackageIds.Num() > 0 + && SourceAttribution.IsStructurallyValid(); + } + + bool MatchesActivationProfileId(const FString& CandidateId) const + { + return !CandidateId.IsEmpty() + && CandidateId.Equals(ActivationProfileId, ESearchCase::IgnoreCase); + } + + bool MatchesPuzzleId(const FString& CandidatePuzzleId) const + { + return !CandidatePuzzleId.IsEmpty() + && CandidatePuzzleId.Equals(PuzzleId, ESearchCase::IgnoreCase); + } + + FHyperTwistPuzzleDefinitionRef ToDefinitionRef() const + { + FHyperTwistPuzzleDefinitionRef Definition; + Definition.PuzzleId = PuzzleId; + Definition.PuzzleFamily = PuzzleFamily; + Definition.Dimension = Dimension; + Definition.DefinitionVersion = DefinitionVersion; + Definition.NotationProfile = NotationProfile; + Definition.SizeVector = SizeVector; + Definition.Variant = Variant; + return Definition; + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CatalogId = TEXT("phase6c/higher-dimensional-runtime-activation"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CatalogVersion = TEXT("2026.06.13"); + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray Profiles; + + bool IsStructurallyValid() const + { + if (CatalogId.IsEmpty() || CatalogVersion.IsEmpty() || Profiles.Num() == 0) + { + return false; + } + + TSet SeenProfileIds; + TSet SeenPuzzleIds; + for (const FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& Profile : Profiles) + { + if (!Profile.IsStructurallyValid()) + { + return false; + } + + const FString NormalizedProfileId = Profile.ActivationProfileId.ToLower(); + if (SeenProfileIds.Contains(NormalizedProfileId)) + { + return false; + } + + const FString NormalizedPuzzleId = Profile.PuzzleId.ToLower(); + if (SeenPuzzleIds.Contains(NormalizedPuzzleId)) + { + return false; + } + + SeenProfileIds.Add(NormalizedProfileId); + SeenPuzzleIds.Add(NormalizedPuzzleId); + } + + return true; + } +}; + +UCLASS() +class UNREALHYPERTWIST_API UHyperTwistTrainingHigherDimensionalRuntimeLibrary : public UBlueprintFunctionLibrary +{ + GENERATED_BODY() + +public: + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + static FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog + BuildBundledHigherDimensionalRuntimeActivationCatalog(); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetRuntimeActivationProfileById( + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog& Catalog, + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetRuntimeActivationProfileByPuzzleId( + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog& Catalog, + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryResolvePuzzleDefinition( + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog& Catalog, + const FString& ActivationProfileIdOrPuzzleId, + FHyperTwistPuzzleDefinitionRef& OutDefinition + ); +}; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h index e710cd6..6b7d600 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h @@ -10,6 +10,7 @@ #include "HyperTwistTraining/HyperTwistTrainingCompanionLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingControlPlaneLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingCoachLibrary.h" +#include "HyperTwistTraining/HyperTwistTrainingHigherDimensionalRuntimeLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingImmersiveEnvironmentLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingKnowledgeLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingLegacy4DLibrary.h" @@ -196,6 +197,10 @@ public: UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|MagicCube5D") static FHyperTwistTrainingMagicCube5DReferenceBundle GetBundledMagicCube5DReferenceBundle(); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|HigherDimensional") + static FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog + GetBundledHigherDimensionalRuntimeActivationCatalog(); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|LearnedSearch") static FHyperTwistTrainingLearnedSearchReferenceBundle GetBundledLearnedSearchReferenceBundle(); @@ -3371,6 +3376,24 @@ public: UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|MagicCube5D") static FString BuildBundledMagicCube5DPackageChecklistTsv(); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetBundledHigherDimensionalRuntimeActivationProfileById( + const FString& ActivationProfileId, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryGetBundledHigherDimensionalRuntimeActivationProfileByPuzzleId( + const FString& PuzzleId, + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile& OutProfile + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|HigherDimensional") + static bool TryResolveBundledHigherDimensionalPuzzleDefinition( + const FString& ActivationProfileIdOrPuzzleId, + FHyperTwistPuzzleDefinitionRef& OutDefinition + ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|LearnedSearch") static bool TryGetBundledLearnedSearchExperimentProfileContract( const FString& ContractId, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHigherDimensionalPhase6CActivationContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHigherDimensionalPhase6CActivationContractTest.cpp new file mode 100644 index 0000000..e88bfaa --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHigherDimensionalPhase6CActivationContractTest.cpp @@ -0,0 +1,140 @@ +// Copyright HyperTwist, Inc. All Rights Reserved. + +#include "Misc/AutomationTest.h" + +#include "HyperTwistTraining/HyperTwistTrainingLibrary.h" +#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h" + +#if WITH_AUTOMATION_TESTS + +namespace HyperTwistHigherDimensionalPhase6CTestInternal +{ + FHyperTwistTrainingDeck MakeDeck(const FString& DeckId, const FString& PuzzleId) + { + FHyperTwistTrainingDeck Deck; + Deck.DeckId = DeckId; + Deck.Title = DeckId; + Deck.DeliveryModes = {EHyperTwistTrainingDeliveryMode::VirtualCube}; + + FHyperTwistTrainingCase TrainingCase; + TrainingCase.CaseId = FString::Printf(TEXT("%s/case"), *DeckId); + TrainingCase.PuzzleId = PuzzleId; + TrainingCase.PromptLabel = PuzzleId; + TrainingCase.AllowedDeliveryModes = {EHyperTwistTrainingDeliveryMode::VirtualCube}; + Deck.Cases = {TrainingCase}; + return Deck; + } +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHigherDimensionalPhase6CActivationCatalogTest, + "HyperTwist.FirstParty.HigherDimensional.Phase6C.ActivationCatalog", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHigherDimensionalPhase6CActivationCatalogTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingHigherDimensionalRuntimeActivationCatalog Catalog = + UHyperTwistTrainingRuntimeLibrary::GetBundledHigherDimensionalRuntimeActivationCatalog(); + + TestTrue(TEXT("The Phase 6C higher-dimensional activation catalog must be structurally valid."), Catalog.IsStructurallyValid()); + TestEqual(TEXT("The Phase 6C higher-dimensional activation catalog must expose both retained family activations."), Catalog.Profiles.Num(), 2); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHigherDimensionalPhase6CMagic120CellActivationProfileTest, + "HyperTwist.FirstParty.HigherDimensional.Phase6C.Magic120CellActivationProfile", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHigherDimensionalPhase6CMagic120CellActivationProfileTest::RunTest(const FString& Parameters) +{ + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + TestTrue( + TEXT("The Magic120Cell Phase 6C activation profile must resolve by puzzle id."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeActivationProfileByPuzzleId( + TEXT("polychoron/magic120cell"), + Profile + ) + ); + TestEqual(TEXT("The Magic120Cell activation profile id must stay stable."), Profile.ActivationProfileId, TEXT("magic120cell-cleanroom-runtime-activation")); + TestFalse(TEXT("The Magic120Cell activation must stay on the in-process Unreal clean-room lane."), Profile.bRequiresExternalProcess); + TestEqual(TEXT("The Magic120Cell activation must remain anchored to retained Hyperspeedcube ownership."), Profile.RuntimeAnchorId, TEXT("retained/hyperspeedcube-runtime-anchor")); + TestEqual(TEXT("The Magic120Cell definition must stay 4D."), Profile.ToDefinitionRef().Dimension, 4); + TestEqual(TEXT("The Magic120Cell definition must stay in the Other puzzle family until a broader family enum lands."), Profile.ToDefinitionRef().PuzzleFamily, EHyperTwistPuzzleFamily::Other); + TestTrue(TEXT("The Magic120Cell activation must keep the family-core package required."), Profile.RequiredPackageIds.Contains(TEXT("package/magic120cell-family-core"))); + TestTrue(TEXT("The Magic120Cell activation must preserve the full-color default runtime selection."), Profile.DefaultSelectionTags.Contains(TEXT("full-color puzzle type"))); + TestTrue(TEXT("The Magic120Cell activation must preserve center-cell recentering capability."), Profile.CapabilityTags.Contains(TEXT("center-cell recentering"))); + TestTrue(TEXT("The Magic120Cell activation must keep broad runtime replacement excluded."), Profile.ExplicitExclusions.Contains(TEXT("Hyperspeedcube runtime-base replacement"))); + TestEqual(TEXT("The Magic120Cell activation must remain first-party owned."), Profile.SourceAttribution.SourceMode, EHyperTwistTrainingSourceMode::FirstParty); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHigherDimensionalPhase6CMagicCube5DActivationProfileTest, + "HyperTwist.FirstParty.HigherDimensional.Phase6C.MagicCube5DActivationProfile", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHigherDimensionalPhase6CMagicCube5DActivationProfileTest::RunTest(const FString& Parameters) +{ + FHyperTwistTrainingHigherDimensionalRuntimeActivationProfile Profile; + TestTrue( + TEXT("The MagicCube5D Phase 6C activation profile must resolve by profile id."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHigherDimensionalRuntimeActivationProfileById( + TEXT("magiccube5d-cleanroom-runtime-activation"), + Profile + ) + ); + TestEqual(TEXT("The MagicCube5D activation must stay mapped to the order-three launch posture."), Profile.PuzzleId, TEXT("hypercube/magiccube5d/order3")); + TestFalse(TEXT("The MagicCube5D activation must stay on the in-process Unreal clean-room lane."), Profile.bRequiresExternalProcess); + TestEqual(TEXT("The MagicCube5D definition must stay 5D."), Profile.ToDefinitionRef().Dimension, 5); + TestEqual(TEXT("The MagicCube5D definition must stay inside the hypercube family."), Profile.ToDefinitionRef().PuzzleFamily, EHyperTwistPuzzleFamily::Hypercube); + TestEqual(TEXT("The MagicCube5D definition must preserve the order-three size vector."), Profile.ToDefinitionRef().SizeVector, TArray({3, 3, 3, 3, 3})); + TestTrue(TEXT("The MagicCube5D activation must keep the state-transformer package required."), Profile.RequiredPackageIds.Contains(TEXT("package/magiccube5d-state-transformer"))); + TestTrue(TEXT("The MagicCube5D activation must preserve the order-three default selection."), Profile.DefaultSelectionTags.Contains(TEXT("order-three default family mode"))); + TestTrue(TEXT("The MagicCube5D activation must preserve fifth-axis focus capability."), Profile.CapabilityTags.Contains(TEXT("control-click fifth-axis view rotation"))); + TestTrue(TEXT("The MagicCube5D activation must keep broad runtime replacement excluded."), Profile.ExplicitExclusions.Contains(TEXT("Hyperspeedcube runtime-base replacement"))); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHigherDimensionalPhase6CTrainingRunDefinitionBridgeTest, + "HyperTwist.FirstParty.HigherDimensional.Phase6C.TrainingRunDefinitionBridge", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHigherDimensionalPhase6CTrainingRunDefinitionBridgeTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingRunState Magic120CellRun = UHyperTwistTrainingLibrary::StartTrainingRun( + HyperTwistHigherDimensionalPhase6CTestInternal::MakeDeck( + TEXT("phase6c/magic120cell"), + TEXT("polychoron/magic120cell") + ), + TEXT("phase6c-user"), + TEXT("phase6c-magic120cell-session"), + EHyperTwistTrainingDeliveryMode::VirtualCube + ); + TestTrue(TEXT("The Magic120Cell activation deck must start a structurally valid run."), Magic120CellRun.IsStructurallyValid()); + TestEqual(TEXT("The Magic120Cell run must keep the canonical Phase 6C puzzle id."), Magic120CellRun.ReplayPacket.PuzzleDefinition.PuzzleId, TEXT("polychoron/magic120cell")); + TestEqual(TEXT("The Magic120Cell run must keep the 4D dimension."), Magic120CellRun.ReplayPacket.PuzzleDefinition.Dimension, 4); + TestEqual(TEXT("The Magic120Cell run must keep the dedicated notation profile."), Magic120CellRun.ReplayPacket.PuzzleDefinition.NotationProfile, TEXT("magic120cell-family")); + + const FHyperTwistTrainingRunState MagicCube5DRun = UHyperTwistTrainingLibrary::StartTrainingRun( + HyperTwistHigherDimensionalPhase6CTestInternal::MakeDeck( + TEXT("phase6c/magiccube5d"), + TEXT("hypercube/magiccube5d/order3") + ), + TEXT("phase6c-user"), + TEXT("phase6c-magiccube5d-session"), + EHyperTwistTrainingDeliveryMode::VirtualCube + ); + TestTrue(TEXT("The MagicCube5D activation deck must start a structurally valid run."), MagicCube5DRun.IsStructurallyValid()); + TestEqual(TEXT("The MagicCube5D run must keep the canonical Phase 6C puzzle id."), MagicCube5DRun.ReplayPacket.PuzzleDefinition.PuzzleId, TEXT("hypercube/magiccube5d/order3")); + TestEqual(TEXT("The MagicCube5D run must keep the 5D dimension."), MagicCube5DRun.ReplayPacket.PuzzleDefinition.Dimension, 5); + TestEqual(TEXT("The MagicCube5D run must preserve the order-three size vector."), MagicCube5DRun.ReplayPacket.PuzzleDefinition.SizeVector, TArray({3, 3, 3, 3, 3})); + return true; +} + +#endif diff --git a/docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md b/docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md index f72e2c5..12f0480 100644 --- a/docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md +++ b/docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md @@ -350,9 +350,10 @@ Closure read: `C:\Users\Anthracite Ace\HyperTwist_phase6a_validate` ### 6C — Magic120Cell & MagicCube5D -- [ ] Decision gate: port roice3 code (Java/C#) or implement clean-room in UE -- [ ] If port: host as external process, stream state via IPC -- [ ] If clean-room: implement 120-cell dodecahedral projection from spec +- [x] Resolve the Phase `6C` widening posture as an Unreal clean-room activation lane above the bounded retained `Magic120Cell` / `MagicCube5D` donor contracts and the retained `Hyperspeedcube` runtime anchor +- [x] Land a first-party higher-dimensional runtime-activation catalog with canonical `Magic120Cell` and `MagicCube5D` launch definitions, primary contract ids, default selection posture, and no external-process requirement +- [ ] Implement the full owned interactive `120-cell` and `5D` projection/runtime surfaces in Unreal above the new activation catalog +- [ ] Widen the new activation catalog into actual map-level launch, interaction, and persistence execution for the dedicated families **Estimated actions:** 100–200 **Estimated time:** 1–2 weeks @@ -502,4 +503,9 @@ Already-proven dedicated-map package lane: Recommended next widening order: - `Phase 6C` decision gate and bounded runtime widening for `Magic120Cell` / `MagicCube5D` now that the visible `3x3x3x3` packet is landed and validated +- `2026-06-13`: `Phase 6C` entered the owned clean-room lane through a new + first-party higher-dimensional runtime-activation catalog that resolves + canonical `polychoron/magic120cell` and `hypercube/magiccube5d/order3` + puzzle definitions, primary donor-boundary contract ids, and default + launch-selection posture without widening into an external-process bridge - later classic-cube polish only when a concrete presentation gap remains, not as the default next move diff --git a/docs/ops/HYPERTWIST_REVERSE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md b/docs/ops/HYPERTWIST_REVERSE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md index 4caa5b4..0c88d61 100644 --- a/docs/ops/HYPERTWIST_REVERSE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md +++ b/docs/ops/HYPERTWIST_REVERSE_SSH_LIVE_CONNECTION_FACTS_2026-06-04.md @@ -212,6 +212,31 @@ Current interpretation after this follow-up: - keep treating commandlet-safe plugin startup as a live packaging concern when editor-side bridge plugins remain present in the project +## Addendum - 2026-06-13 (primary-lane Phase 6C activation validation pass) + +Live follow-up on `2026-06-13` established these additional current facts: + +- the same primary `22022` lane was also healthy for the current `Phase 6C` + higher-dimensional activation pass +- the lane again carried the isolated Windows validation tree + `C:\HyperTwist_worktrees\phase10validate` +- because the slice introduced a new translation unit, the editor makefile was + invalidated and a fresh `Build.bat` pass was required there +- that `Build.bat` run still succeeded with UnrealBuildTool `Total execution + time: 2829.95 seconds` +- targeted `UnrealEditor-Cmd` automation then found `4` tests under + `HyperTwist.FirstParty.HigherDimensional.Phase6C` +- all `4` tests succeeded, including the real training-run bridge check, and + the run closed with `**** TEST COMPLETE. EXIT CODE: 0 ****` + +Current interpretation after this follow-up: + +- keep treating `localhost:22022` as sufficient for owned higher-dimensional + compile-plus-automation proof as long as the lane passes a fresh login check +- for a clean-room activation-catalog slice, do not stop at direct profile + lookup tests; also prove that real training-run puzzle-definition resolution + follows the same lane + ## Maintenance rule If the live listener set, accepted login shape, or command family changes, diff --git a/docs/ops/HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md b/docs/ops/HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md index 701a6de..a554a6f 100644 --- a/docs/ops/HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md +++ b/docs/ops/HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md @@ -335,6 +335,37 @@ Operational rules reinforced by this proof: startup assumption directly and rerun the full package/archive/smoke chain on the same isolated worktree before calling the slice closed +## Addendum - 2026-06-13 (Phase 6C primary-lane build and automation proof) + +Live follow-up on `2026-06-13` established these additional facts: + +- the primary `localhost:22022` lane remained healthy for the current `Phase 6C` + higher-dimensional validation pass +- the validated route again used the isolated Windows tree + `C:\HyperTwist_worktrees\phase10validate` +- the new `Phase 6C` source files invalidated the existing makefile because a + new translation unit was added, after which a fresh `Build.bat` pass for + `UnrealHyperTwistEditor` still succeeded there with `Result: Succeeded` and + UnrealBuildTool `Total execution time: 2829.95 seconds` +- targeted headless automation then found `4` tests under + `HyperTwist.FirstParty.HigherDimensional.Phase6C` +- all `4` of those tests succeeded: + - `ActivationCatalog` + - `Magic120CellActivationProfile` + - `MagicCube5DActivationProfile` + - `TrainingRunDefinitionBridge` +- the command-line run closed with + `**** TEST COMPLETE. EXIT CODE: 0 ****` + +Operational rules reinforced by this proof: + +- for an owned higher-dimensional widening packet like `Phase 6C`, the landing + bar can remain compile proof plus focused contract automation before any + interactive projection shell exists +- when a new higher-dimensional slice lands as a catalog/definition bridge + first, validate both direct profile resolution and real training-run + definition propagation on the same Windows Unreal lane + ## Addendum - 2026-06-03 (stale-listener recovery) Live follow-up on `2026-06-03` established this additional operational rule: diff --git a/docs/ops/HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md b/docs/ops/HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md index 9098d1a..5c5903f 100644 --- a/docs/ops/HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md +++ b/docs/ops/HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md @@ -139,6 +139,18 @@ smoke boots succeeded on both `L_HyperTwist_ClassicTraining` and build-plus-integration proof to primary-lane package/archive/launch proof on the same current source state. +Additional live proof on `2026-06-13` also validated the new `Phase 6C` +higher-dimensional activation packet on that same primary lane: the isolated +Windows worktree `C:\HyperTwist_worktrees\phase10validate` invalidated its +editor makefile because the slice added a new translation unit, the resulting +fresh `Build.bat` pass still completed with `Result: Succeeded` and +UnrealBuildTool `Total execution time: 2829.95 seconds`, and targeted +`UnrealEditor-Cmd` automation then found `4` tests under +`HyperTwist.FirstParty.HigherDimensional.Phase6C` and passed all `4` with +`**** TEST COMPLETE. EXIT CODE: 0 ****`. This extends the doctrine from generic +compile proof to current higher-dimensional activation-catalog proof on the +same primary reverse-SSH lane. + Operational reading: - use `localhost:22022` as the primary reverse-SSH lane @@ -161,6 +173,10 @@ Operational reading: guard toolbar, Slate, and local bridge startup paths for commandlet/unattended execution instead of assuming interactive editor-only behavior +- when a higher-dimensional Unreal slice lands first as a first-party + activation catalog rather than a full interactive renderer, validate both the + direct contract-resolution tests and the training-run definition bridge on the + real Windows lane before widening into projection/runtime ownership - when streaming a Linux-side tar delta into an isolated Windows worktree, use `tar -xf ... -m` or explicitly clear the affected generated-header directory before building; preserving old mtimes can leave stale diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md index 3485af9..e3dc8d7 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md @@ -266,6 +266,7 @@ repo. | Dedicated `120-cell` symmetry-aware focus view profiles | Implemented now | landed `Magic120Cell` `Phase 6R-AL` | Current bounded settings-derived projection, symmetry preset, logical-visibility, per-cell visibility, and center-cell focus posture are live above the landed dedicated `120-cell` runtime-profile seam without widening into renderer, host-shell, or generic topology ownership. | | Dedicated `5D` family runtime profile and persistence boundary | Implemented now | landed `MagicCube5D` packet | Current bounded family-specific widening is live beneath the retained `Hyperspeedcube` runtime anchor. | | Dedicated `5D` projection and focus view profiles | Implemented now | landed `MagicCube5D` `Phase 6R-AM` | Current bounded settings-derived projection-distance, stereo posture, per-face visibility, accent emphasis, and fifth-axis focus posture are live above the landed dedicated `5D` runtime-profile seam without widening into renderer, host-shell, or generic hyper-runtime ownership. | +| Higher-dimensional clean-room runtime activation catalog | Implemented now | landed `Phase 6C` activation packet | First-party current code now resolves canonical `polychoron/magic120cell` and `hypercube/magiccube5d/order3` puzzle definitions, default launch posture, primary donor-boundary contract ids, and the no-external-process clean-room stance above the retained `Magic120Cell` / `MagicCube5D` contracts and the retained `Hyperspeedcube` runtime anchor. | | Broad non-Euclidean interaction shell and host ownership | Deep-source grounded retained | `MagicTile` retained remainder | Broad interaction-shell, WinForms/OpenTK host ownership, and generic runtime replacement remain deferred after the landed `Phase 6R-T` slice. | ### 7. Speech input and voice sidecars diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md index c840162..b5363e3 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md @@ -83,9 +83,16 @@ Current consolidated milestone snapshot: `BuildCookRun`/archive proof on `C:\HyperTwist_worktrees\phase10validate`, and packaged smoke launches on both `L_HyperTwist_ClassicTraining` and `L_HyperTwist_FollowAlongTraining` -- the next best deliberate widening move is `Phase 6C` decision-gated - `Magic120Cell` / `MagicCube5D` runtime widening now that the owned visible - hypercube packet extends past `2x2x2x2` +- the next best deliberate widening move is the now-opened `Phase 6C` + clean-room `Magic120Cell` / `MagicCube5D` runtime widening lane, starting + from the first-party higher-dimensional activation catalog now that the owned + visible hypercube packet extends past `2x2x2x2` + +- `2026-06-13`: `Phase 6C` entered the owned clean-room lane through a + first-party higher-dimensional activation catalog that resolves canonical + `Magic120Cell` and `MagicCube5D` puzzle definitions above the retained donor + bundles and the retained `Hyperspeedcube` runtime anchor; the remaining gap + is the actual interactive runtime, not the posture decision - the canonical HyperTwist repo-row portfolio is now treated as `75` rows, not `71` - currently implemented rows are now `35`, not `20`