diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp index 92ee31f..368de15 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp @@ -1270,6 +1270,30 @@ bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingAttributionBoundary( ); } +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingMacroRemappingContract( + const FString& ContractId, + FHyperTwistTrainingTilingMacroRemappingContract& OutContract +) +{ + return UHyperTwistTrainingTilingLibrary::TryGetMacroRemappingContractById( + GetBundledTilingReferenceBundle(), + ContractId, + OutContract + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingMacroPersistenceBoundary( + const FString& BoundaryId, + FHyperTwistTrainingTilingMacroPersistenceBoundary& OutBoundary +) +{ + return UHyperTwistTrainingTilingLibrary::TryGetMacroPersistenceBoundaryById( + GetBundledTilingReferenceBundle(), + BoundaryId, + OutBoundary + ); +} + FString UHyperTwistTrainingRuntimeLibrary::BuildBundledTilingPackageChecklistTsv() { return UHyperTwistTrainingTilingLibrary::BuildPackageChecklistTsv( diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp index 80fa0bd..8b66a12 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp @@ -64,10 +64,12 @@ FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingTilingLibrary::Build using namespace HyperTwistTrainingTilingLibraryInternal; FHyperTwistTrainingTilingReferenceBundle Bundle; - Bundle.ReferenceUtc = TEXT("2026-05-21T00:30:00Z"); + Bundle.ReferenceUtc = TEXT("2026-05-24T18:30:00Z"); Bundle.PrimaryTopologyContractId = TEXT("tiling-topology-stack"); Bundle.PrimaryLoaderBoundaryId = TEXT("tiling-loader-boundary"); Bundle.PrimaryAttributionBoundaryId = TEXT("tiling-mit-attribution-boundary"); + Bundle.PrimaryMacroRemappingContractId = TEXT("tiling-macro-remapping-stack"); + Bundle.PrimaryMacroPersistenceBoundaryId = TEXT("tiling-macro-persistence-boundary"); const TArray CommonNoticeActions = { @@ -218,6 +220,79 @@ FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingTilingLibrary::Build TEXT("tiling/h3-honeycomb"), TEXT("Preserves MagicTile hyperbolic honeycomb-family seams for later first-party HyperTwist tiling and non-Euclidean topology widening.") ) + ), + MakePackageReference( + TEXT("package/magictile-macro"), + TEXT("MagicTile/Puzzle/Twisting/Macro"), + TEXT("./MagicTile/Puzzle/Twisting/Macro.cs"), + TEXT("tiling-macro-remapping-anchor"), + TEXT("direct permissive donor"), + TEXT("Reference Mobius orientation, transformed twist lookup, reverse or reflection handling, and macro XML persistence for topology-aware advanced puzzle macros."), + { + TEXT("reference mobius transform"), + TEXT("clicked-cell canonical orientation"), + TEXT("view reflection parity"), + TEXT("transformed twist lookup"), + TEXT("macro XML persistence") + }, + CommonNoticeActions, + { + TEXT("whole macro editor shell"), + TEXT("broad non-Euclidean interaction shell ownership"), + TEXT("WinForms/OpenTK host-shell ownership") + }, + MakeAttribution( + TEXT("tiling/macro"), + TEXT("Preserves MagicTile reference Mobius setup, transformed twist lookup, reversal handling, and XML macro persistence beneath first-party HyperTwist macro-remapping ownership.") + ) + ), + MakePackageReference( + TEXT("package/magictile-twist-handler"), + TEXT("MagicTile/Puzzle/Twisting/TwistHandler"), + TEXT("./MagicTile/Puzzle/Twisting/TwistHandler.cs"), + TEXT("tiling-macro-playback-support"), + TEXT("direct permissive donor"), + TEXT("Macro playback, reverse execution, setup-move unwind, commutator playback, and grouped undo or redo handling for advanced tiling puzzles."), + { + TEXT("forward macro execution"), + TEXT("reverse macro execution"), + TEXT("setup-move unwind"), + TEXT("commutator playback"), + TEXT("grouped macro undo redo") + }, + CommonNoticeActions, + { + TEXT("whole click-input shell"), + TEXT("animation timing shell ownership"), + TEXT("legacy status or menu ownership") + }, + MakeAttribution( + TEXT("tiling/twist-handler"), + TEXT("Preserves MagicTile macro playback, reversal, setup-move, and grouped undo behavior without promoting the old desktop interaction shell into first-party HyperTwist ownership.") + ) + ), + MakePackageReference( + TEXT("package/magictile-setup-moves"), + TEXT("MagicTile/Puzzle/Twisting/SetupMoves"), + TEXT("./MagicTile/Puzzle/Twisting/SetupMoves.cs"), + TEXT("tiling-setup-move-support"), + TEXT("direct permissive donor"), + TEXT("Setup and commutator move recording that complements transform-aware macro remapping without owning the broader puzzle shell."), + { + TEXT("setup move recording"), + TEXT("commutator derivation"), + TEXT("macro reversal reuse") + }, + CommonNoticeActions, + { + TEXT("whole macro-pane shell"), + TEXT("legacy accelerator ownership"), + TEXT("runtime-base ownership") + }, + MakeAttribution( + TEXT("tiling/setup-moves"), + TEXT("Preserves MagicTile setup-move and commutator recording seams beneath first-party HyperTwist macro-remapping ownership.") + ) ) }; @@ -304,26 +379,119 @@ FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingTilingLibrary::Build ); Bundle.LoaderBoundaries = {LoaderBoundary}; + FHyperTwistTrainingTilingMacroRemappingContract MacroContract; + MacroContract.ContractId = TEXT("tiling-macro-remapping-stack"); + MacroContract.Title = TEXT("Tiling transform-aware macro remapping contract"); + MacroContract.Summary = TEXT("First-party HyperTwist contract for reference-cell macro orientation, transformed twist lookup, reflection-aware reversal, and bounded macro playback semantics for non-Euclidean tiling families."); + MacroContract.RequiredPackageIds = + { + TEXT("package/magictile-macro"), + TEXT("package/magictile-twist-handler"), + TEXT("package/magictile-setup-moves"), + TEXT("package/magictile-puzzle-core"), + TEXT("package/magictile-topology-analyzer") + }; + MacroContract.ReferenceSurfaceTags = + { + TEXT("reference mobius transform"), + TEXT("clicked-cell canonical orientation"), + TEXT("view reflection parity"), + TEXT("puzzle-specific macro ownership") + }; + MacroContract.TransformSurfaceTags = + { + TEXT("transformed twist lookup by closest center"), + TEXT("state-calc twist selection nearest origin after transform"), + TEXT("reverse XOR view-reflection handling"), + TEXT("identified twist-data remapping") + }; + MacroContract.PlaybackSurfaceTags = + { + TEXT("forward macro execution"), + TEXT("reverse macro execution"), + TEXT("setup-move unwind"), + TEXT("commutator second-half playback"), + TEXT("grouped macro undo redo") + }; + MacroContract.ExplicitExclusions = + { + TEXT("whole macro editor shell"), + TEXT("broad non-Euclidean interaction shell ownership"), + TEXT("WinForms/OpenTK host-shell ownership"), + TEXT("Hyperspeedcube runtime-base replacement") + }; + MacroContract.SourceAttribution = MakeAttribution( + TEXT("tiling/macro-remapping-contract"), + TEXT("Preserves MagicTile macro reference orientation, transformed twist remapping, and reversal semantics while keeping HyperTwist first-party for the broader macro UX, runtime, and product shell.") + ); + Bundle.MacroRemappingContracts = {MacroContract}; + + FHyperTwistTrainingTilingMacroPersistenceBoundary MacroPersistenceBoundary; + MacroPersistenceBoundary.BoundaryId = TEXT("tiling-macro-persistence-boundary"); + MacroPersistenceBoundary.Title = TEXT("Tiling macro persistence and compatibility boundary"); + MacroPersistenceBoundary.Summary = TEXT("First-party HyperTwist boundary for MagicTile-style macro XML persistence, puzzle compatibility checks, and macro block serialization beneath first-party macro ownership."); + MacroPersistenceBoundary.RequiredPackageIds = + { + TEXT("package/magictile-macro"), + TEXT("package/magictile-loader"), + TEXT("package/magictile-puzzle-core") + }; + MacroPersistenceBoundary.PersistenceSurfaceTags = + { + TEXT("MagicTileMacros XML root"), + TEXT("macro display name persistence"), + TEXT("Mobius persistence"), + TEXT("view-reflected persistence"), + TEXT("tab-delimited macro block serialization"), + TEXT("macro start and end markers") + }; + MacroPersistenceBoundary.CompatibilitySurfaceTags = + { + TEXT("active puzzle id compatibility"), + TEXT("puzzle display-name compatibility messaging"), + TEXT("edge or vertex twisting version compatibility"), + TEXT("saved version 2.0 and 2.1 handling"), + TEXT("load macros against all twist data") + }; + MacroPersistenceBoundary.ProvenanceCaveats = + { + TEXT("macro files are puzzle-specific and are not intended to travel across differently configured puzzles"), + TEXT("macro persistence uses XML blocks rather than the first-party canonical replay schema"), + TEXT("save and load dialog filter strings remain legacy host-shell details rather than first-party product contract") + }; + MacroPersistenceBoundary.ExplicitExclusions = + { + TEXT("generic replay or canonical notation ownership"), + TEXT("host file-dialog ownership"), + TEXT("whole macro-management pane shell"), + TEXT("legacy message-box choreography") + }; + MacroPersistenceBoundary.SourceAttribution = MakeAttribution( + TEXT("tiling/macro-persistence-boundary"), + TEXT("Preserves MagicTile macro XML persistence and compatibility checks while keeping HyperTwist first-party for canonical replay, notation, and broader persistence ownership.") + ); + Bundle.MacroPersistenceBoundaries = {MacroPersistenceBoundary}; + FHyperTwistTrainingTilingAttributionBoundary AttributionBoundary; AttributionBoundary.BoundaryId = TEXT("tiling-mit-attribution-boundary"); AttributionBoundary.Title = TEXT("Tiling donor attribution boundary"); - AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using MagicTile as a direct permissive donor for tiling topology and geometry-family contracts."); + AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using MagicTile as a direct permissive donor for tiling topology, loader, and bounded macro-remapping contracts."); AttributionBoundary.AllowedUseTags = { TEXT("first-party reauthored subsystem implementation"), TEXT("direct permissive donor reference"), - TEXT("bounded tiling topology and loader contract use") + TEXT("bounded tiling topology, loader, and macro-remapping contract use") }; AttributionBoundary.RequiredNoticeActions = CommonNoticeActions; AttributionBoundary.ExplicitExclusions = { TEXT("silent attribution removal"), TEXT("whole legacy app-shell adoption"), - TEXT("pretending macro transport or runtime-base ownership landed in this packet") + TEXT("pretending broad interaction-shell or runtime-base ownership landed in this packet") }; AttributionBoundary.SourceAttribution = MakeAttribution( TEXT("tiling/attribution-boundary"), - TEXT("Records MIT attribution and packet bounds for MagicTile while keeping non-owned shell and macro surfaces excluded from the first tiling contract slice.") + TEXT("Records MIT attribution and packet bounds for MagicTile while keeping non-owned shell surfaces excluded from the bounded tiling topology and macro-remapping slices.") ); Bundle.AttributionBoundaries = {AttributionBoundary}; @@ -387,6 +555,44 @@ bool UHyperTwistTrainingTilingLibrary::TryGetAttributionBoundaryById( return false; } +bool UHyperTwistTrainingTilingLibrary::TryGetMacroRemappingContractById( + const FHyperTwistTrainingTilingReferenceBundle& Bundle, + const FString& ContractId, + FHyperTwistTrainingTilingMacroRemappingContract& OutContract +) +{ + for (const FHyperTwistTrainingTilingMacroRemappingContract& Contract : Bundle.MacroRemappingContracts) + { + if (Contract.ContractId == ContractId) + { + OutContract = Contract; + return true; + } + } + + OutContract = FHyperTwistTrainingTilingMacroRemappingContract(); + return false; +} + +bool UHyperTwistTrainingTilingLibrary::TryGetMacroPersistenceBoundaryById( + const FHyperTwistTrainingTilingReferenceBundle& Bundle, + const FString& BoundaryId, + FHyperTwistTrainingTilingMacroPersistenceBoundary& OutBoundary +) +{ + for (const FHyperTwistTrainingTilingMacroPersistenceBoundary& Boundary : Bundle.MacroPersistenceBoundaries) + { + if (Boundary.BoundaryId == BoundaryId) + { + OutBoundary = Boundary; + return true; + } + } + + OutBoundary = FHyperTwistTrainingTilingMacroPersistenceBoundary(); + return false; +} + FString UHyperTwistTrainingTilingLibrary::BuildPackageChecklistTsv( const FHyperTwistTrainingTilingReferenceBundle& Bundle ) diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h index 8b3c211..23880dc 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h @@ -500,6 +500,18 @@ public: FHyperTwistTrainingTilingAttributionBoundary& OutBoundary ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling") + static bool TryGetBundledTilingMacroRemappingContract( + const FString& ContractId, + FHyperTwistTrainingTilingMacroRemappingContract& OutContract + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling") + static bool TryGetBundledTilingMacroPersistenceBoundary( + const FString& BoundaryId, + FHyperTwistTrainingTilingMacroPersistenceBoundary& OutBoundary + ); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling") static FString BuildBundledTilingPackageChecklistTsv(); diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h index 2499962..039248c 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h @@ -152,6 +152,82 @@ struct FHyperTwistTrainingTilingAttributionBoundary } }; +USTRUCT(BlueprintType) +struct FHyperTwistTrainingTilingMacroRemappingContract +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ContractId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Title; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Summary; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RequiredPackageIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ReferenceSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray TransformSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray PlaybackSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ExplicitExclusions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FHyperTwistTrainingSourceAttribution SourceAttribution; + + bool IsStructurallyValid() const + { + return !ContractId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid(); + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingTilingMacroPersistenceBoundary +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString BoundaryId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Title; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Summary; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RequiredPackageIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray PersistenceSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray CompatibilitySurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ProvenanceCaveats; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ExplicitExclusions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FHyperTwistTrainingSourceAttribution SourceAttribution; + + bool IsStructurallyValid() const + { + return !BoundaryId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid(); + } +}; + USTRUCT(BlueprintType) struct FHyperTwistTrainingTilingReferenceBundle { @@ -169,6 +245,12 @@ struct FHyperTwistTrainingTilingReferenceBundle UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") FString PrimaryAttributionBoundaryId; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryMacroRemappingContractId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryMacroPersistenceBoundaryId; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") TArray PackageReferences; @@ -181,10 +263,18 @@ struct FHyperTwistTrainingTilingReferenceBundle UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") TArray AttributionBoundaries; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray MacroRemappingContracts; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray MacroPersistenceBoundaries; + bool IsStructurallyValid() const { return !PrimaryTopologyContractId.IsEmpty() && !PrimaryLoaderBoundaryId.IsEmpty() - && !PrimaryAttributionBoundaryId.IsEmpty() && PackageReferences.Num() > 0; + && !PrimaryAttributionBoundaryId.IsEmpty() && !PrimaryMacroRemappingContractId.IsEmpty() + && !PrimaryMacroPersistenceBoundaryId.IsEmpty() && PackageReferences.Num() > 0 + && MacroRemappingContracts.Num() > 0 && MacroPersistenceBoundaries.Num() > 0; } }; @@ -218,6 +308,20 @@ public: FHyperTwistTrainingTilingAttributionBoundary& OutBoundary ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling") + static bool TryGetMacroRemappingContractById( + const FHyperTwistTrainingTilingReferenceBundle& Bundle, + const FString& ContractId, + FHyperTwistTrainingTilingMacroRemappingContract& OutContract + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling") + static bool TryGetMacroPersistenceBoundaryById( + const FHyperTwistTrainingTilingReferenceBundle& Bundle, + const FString& BoundaryId, + FHyperTwistTrainingTilingMacroPersistenceBoundary& OutBoundary + ); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling") static FString BuildPackageChecklistTsv(const FHyperTwistTrainingTilingReferenceBundle& Bundle); }; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RTMacroRemappingContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RTMacroRemappingContractTest.cpp new file mode 100644 index 0000000..378e266 --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RTMacroRemappingContractTest.cpp @@ -0,0 +1,124 @@ +// Copyright HyperTwist, Inc. All Rights Reserved. + +#include "Misc/AutomationTest.h" + +#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h" + +#if WITH_AUTOMATION_TESTS + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistMagicTilePhase6RTMacroRemappingContractTest, + "HyperTwist.Permissive.MagicTile.Phase6R.T.MacroRemappingContract", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistMagicTilePhase6RTMacroRemappingContractTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingTilingReferenceBundle Bundle = + UHyperTwistTrainingRuntimeLibrary::GetBundledTilingReferenceBundle(); + + TestTrue(TEXT("The MagicTile tiling bundle must stay structurally valid after Phase 6R-T."), Bundle.IsStructurallyValid()); + TestTrue(TEXT("The MagicTile tiling bundle must preserve multiple package references after the macro slice lands."), Bundle.PackageReferences.Num() >= 8); + + FHyperTwistTrainingTilingMacroRemappingContract Contract; + TestTrue( + TEXT("The primary tiling macro-remapping contract must resolve from the runtime library."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingMacroRemappingContract( + Bundle.PrimaryMacroRemappingContractId, + Contract + ) + ); + TestEqual(TEXT("The macro-remapping contract id must stay stable."), Contract.ContractId, TEXT("tiling-macro-remapping-stack")); + TestTrue( + TEXT("The macro-remapping contract must preserve the Macro package as a required input."), + Contract.RequiredPackageIds.Contains(TEXT("package/magictile-macro")) + ); + TestTrue( + TEXT("The macro-remapping contract must preserve the reference Mobius transform surface."), + Contract.ReferenceSurfaceTags.Contains(TEXT("reference mobius transform")) + ); + TestTrue( + TEXT("The macro-remapping contract must preserve reflection-aware reverse handling."), + Contract.TransformSurfaceTags.Contains(TEXT("reverse XOR view-reflection handling")) + ); + TestTrue( + TEXT("The macro-remapping contract must preserve commutator playback semantics."), + Contract.PlaybackSurfaceTags.Contains(TEXT("commutator second-half playback")) + ); + TestTrue( + TEXT("The macro-remapping contract must keep the whole macro editor shell excluded."), + Contract.ExplicitExclusions.Contains(TEXT("whole macro editor shell")) + ); + TestEqual(TEXT("The macro-remapping contract must keep the direct donor source repo."), Contract.SourceAttribution.SourceRepo, TEXT("roice3/MagicTile")); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistMagicTilePhase6RTMacroPersistenceBoundaryTest, + "HyperTwist.Permissive.MagicTile.Phase6R.T.MacroPersistenceBoundary", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistMagicTilePhase6RTMacroPersistenceBoundaryTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingTilingReferenceBundle Bundle = + UHyperTwistTrainingRuntimeLibrary::GetBundledTilingReferenceBundle(); + + FHyperTwistTrainingTilingMacroPersistenceBoundary Boundary; + TestTrue( + TEXT("The tiling macro persistence boundary must resolve from the runtime library."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingMacroPersistenceBoundary( + Bundle.PrimaryMacroPersistenceBoundaryId, + Boundary + ) + ); + TestEqual(TEXT("The macro persistence boundary id must stay stable."), Boundary.BoundaryId, TEXT("tiling-macro-persistence-boundary")); + TestTrue( + TEXT("The macro persistence boundary must preserve the MagicTile macro XML root tag."), + Boundary.PersistenceSurfaceTags.Contains(TEXT("MagicTileMacros XML root")) + ); + TestTrue( + TEXT("The macro persistence boundary must preserve active-puzzle compatibility checks."), + Boundary.CompatibilitySurfaceTags.Contains(TEXT("active puzzle id compatibility")) + ); + TestTrue( + TEXT("The macro persistence boundary must preserve puzzle-specific macro caveats."), + Boundary.ProvenanceCaveats.Contains(TEXT("macro files are puzzle-specific and are not intended to travel across differently configured puzzles")) + ); + TestTrue( + TEXT("The macro persistence boundary must keep canonical replay ownership excluded."), + Boundary.ExplicitExclusions.Contains(TEXT("generic replay or canonical notation ownership")) + ); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistMagicTilePhase6RTPackageChecklistTest, + "HyperTwist.Permissive.MagicTile.Phase6R.T.PackageChecklist", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistMagicTilePhase6RTPackageChecklistTest::RunTest(const FString& Parameters) +{ + const FString Checklist = UHyperTwistTrainingRuntimeLibrary::BuildBundledTilingPackageChecklistTsv(); + TestTrue(TEXT("The tiling package checklist must not be empty after Phase 6R-T."), !Checklist.IsEmpty()); + TestTrue( + TEXT("The checklist must preserve the macro package id."), + Checklist.Contains(TEXT("package/magictile-macro")) + ); + TestTrue( + TEXT("The checklist must preserve the Macro export path."), + Checklist.Contains(TEXT("./MagicTile/Puzzle/Twisting/Macro.cs")) + ); + TestTrue( + TEXT("The checklist must preserve the twist-handler package id."), + Checklist.Contains(TEXT("package/magictile-twist-handler")) + ); + TestTrue( + TEXT("The checklist must preserve the direct permissive donor posture."), + Checklist.Contains(TEXT("direct permissive donor")) + ); + return true; +} + +#endif diff --git a/docs/REPO_LICENSE_TRACKING.md b/docs/REPO_LICENSE_TRACKING.md index 2f17e2e..c29b35e 100644 --- a/docs/REPO_LICENSE_TRACKING.md +++ b/docs/REPO_LICENSE_TRACKING.md @@ -163,8 +163,12 @@ Status update on `2026-05-21`: control pass is now consumed - the bounded permissive `Phase 6R-S` shared classic-cube correction-resolution closure packet is now landed in current code -- the current next bounded move is a source-backed `Phase 6R-T` `roice3/MagicTile` - transform-aware macro remapping preparation/control pass, not a new restrictive packet by +- the generic source-backed `Phase 6R-T` `roice3/MagicTile` transform-aware macro remapping + control pass is now consumed +- the bounded permissive `Phase 6R-T` `roice3/MagicTile` transform-aware macro remapping packet + is now landed in current code +- the current next bounded move is a source-backed `Phase 6R-U` `ggml-org/whisper.cpp` + live microphone capture shell preparation/control pass, not a new restrictive packet by default - use the repo-row README census, the portfolio standing refresh backfill, and the `2R-A` ownership contract for the current queue after that correction @@ -269,8 +273,8 @@ Current practical interpretation: - the landed `PostHog/posthog` boundary-sensitive widening packet now lives in `docs/HYPERTWIST_PHASE_4R_PACKET_4R_D_POSTHOG_CONTROL_PLANE_IMPLEMENTATION_2026-05-13.md` - the landed `screenpipe/screenpipe` boundary-sensitive widening packet now lives in `docs/HYPERTWIST_PHASE_4R_PACKET_4R_E_SCREENPIPE_CAPTURE_HISTORY_IMPLEMENTATION_2026-05-13.md` - the landed `remotion-dev/remotion` boundary-sensitive widening packet now lives in `docs/HYPERTWIST_PHASE_4R_PACKET_4R_F_REMOTION_MEDIA_EXPORT_IMPLEMENTATION_2026-05-13.md` -- the next bounded move is a source-backed `Phase 6R-T` `roice3/MagicTile` - transform-aware macro remapping preparation/control pass +- the next bounded move is a source-backed `Phase 6R-U` `ggml-org/whisper.cpp` + live microphone capture shell preparation/control pass Companion docs: @@ -3152,10 +3156,12 @@ Approved working posture: - use the mirrored repo as the canonical local source - retain the local zip as duplicate source possession, not as a separate unresolved legal lane - keep ordinary third-party notices if code or substantial portions are incorporated -- keep the live widening bounded to the landed tiling-topology contract family rather than - flattening the row into blanket permission for full host-shell or runtime replacement use -- the next justified widening is now the bounded `Phase 6R-T` transform-aware macro remapping - control pass rather than blanket host-shell or runtime replacement use +- keep the live widening bounded to the landed tiling-topology and transform-aware macro + remapping contract families rather than flattening the row into blanket permission for full + host-shell or runtime replacement use +- after the landed `Phase 6R-T` slice, keep any future `MagicTile` widening closed by default + unless a narrower first-party gap is proven below broad interaction-shell or host-shell + ownership ### `superliminal.com/andrey/mc7d` diff --git a/docs/arch/HYPERTWIST_PHASE6R_T_MAGICTILE_TRANSFORM_AWARE_MACRO_REMAPPING_IMPLEMENTATION_PACKET_2026-05-24.md b/docs/arch/HYPERTWIST_PHASE6R_T_MAGICTILE_TRANSFORM_AWARE_MACRO_REMAPPING_IMPLEMENTATION_PACKET_2026-05-24.md new file mode 100644 index 0000000..b88fcfd --- /dev/null +++ b/docs/arch/HYPERTWIST_PHASE6R_T_MAGICTILE_TRANSFORM_AWARE_MACRO_REMAPPING_IMPLEMENTATION_PACKET_2026-05-24.md @@ -0,0 +1,158 @@ +# HyperTwist Phase 6R-T MagicTile transform-aware macro remapping implementation packet + +Created on `2026-05-24` + +## Status + +- first-party HyperTwist packet +- bounded permissive `Phase 6R-T` implementation slice + +## Purpose + +This packet lands the current retained `roice3/MagicTile` +transform-aware-macro seam: + +- first-party transform-aware macro remapping contract, macro persistence + boundary, and runtime lookup accessors above the already landed `Phase 6R-D` + tiling topology contract + +It is not: + +- a full `MagicTile` row transplant +- a `Hyperspeedcube` runtime-base replacement +- a broad non-Euclidean interaction shell +- a WinForms/OpenTK host-shell packet +- a generic notation or replay packet +- the speech-input / voice sidecar packet + +## Current authority basis + +This implementation packet stands on: + +- `docs/REPO_LICENSE_TRACKING.md` +- `docs/ops/HYPERTWIST_CROSS_LANE_AUTHORITY_HIERARCHY_AND_RECONCILIATION_2026-05-20.md` +- `docs/arch/HYPERTWIST_PHASE6R_T_MAGICTILE_TRANSFORM_AWARE_MACRO_REMAPPING_PREPARATION_PACKET_2026-05-24.md` + +The retained owner remains: + +- `roice3/MagicTile` + +The granted family remains bounded to: + +- transform-aware macro remapping +- reverse/setup-move/commutator playback support tags +- macro XML persistence boundary and puzzle-compatibility checks +- direct-donor attribution inside the already landed tiling reference bundle + +The top-level product-shell and hyper-runtime owners do not change here: + +- first-party HyperTwist remains the broader training and product-shell owner +- the retained `Hyperspeedcube` runtime anchor remains the generic + higher-dimensional runtime owner + +## Landed scope + +The current code now owns a bounded first-party macro-remapping slice through: + +- new first-party tiling contract types for: + - macro remapping contract + - macro persistence boundary +- expanded bundled `MagicTile` reference-bundle construction in: + - `UHyperTwistTrainingTilingLibrary` +- package-reference additions for: + - `Macro.cs` + - `TwistHandler.cs` + - `SetupMoves.cs` +- remapping-contract coverage for: + - reference Mobius transform + - clicked-cell canonical orientation + - view-reflection parity + - transformed twist lookup by nearest transformed center + - reverse XOR view-reflection handling + - puzzle-specific macro ownership +- persistence-boundary coverage for: + - `MagicTileMacros` XML root + - macro display-name, transform, and view-reflection persistence + - saved-version compatibility + - active-puzzle compatibility checks + - puzzle-specific macro-file caveats +- runtime-library accessors for: + - bundled macro remapping contract lookup + - bundled macro persistence-boundary lookup +- focused automation coverage in: + - `HyperTwistMagicTilePhase6RTMacroRemappingContractTest.cpp` + +## Why this is still intentionally bounded + +This packet lands the next narrow donor-backed `MagicTile` seam, but it does +not widen into neighboring retained families or broad host ownership. + +Still deferred: + +- broad non-Euclidean interaction shell +- WinForms/OpenTK host shell +- generic runtime-base replacement above `Hyperspeedcube` +- generic notation or replay ownership +- the speech-input / voice sidecar queue + +## Validation + +Build validation: + +- `C:\Program Files\Epic Games\UE_5.7\Engine\Build\BatchFiles\Build.bat UnrealHyperTwistEditor Win64 Development -Project='C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject' -WaitMutex -NoHotReloadFromIDE -NoUba` + +Focused automation validation: + +- `C:\Program Files\Epic Games\UE_5.7\Engine\Binaries\Win64\UnrealEditor-Cmd.exe C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject -unattended -nop4 -nosplash -NullRHI -log -stdout -FullStdOutLogOutput -AbsLog=C:\HyperTwist\UnrealHyperTwist\Saved\Logs\Phase6R-T-MagicTile-Verify.log -ReportExportPath=C:\HyperTwist\UnrealHyperTwist\Saved\AutomationReports\Phase6R-T-MagicTile-Verify -ExecCmds="Automation RunTests HyperTwist.Permissive.MagicTile.Phase6R.T; Quit" -TestExit="Automation Test Queue Empty"` + +Regression automation validation: + +- `HyperTwist.Permissive.MagicTile.Phase6R.D` +- `HyperTwist.Permissive.MagicCube5D.Phase6R.J` +- `HyperTwist.Permissive.Magic120Cell.Phase6R.I` +- `HyperTwist.CleanRoom.CubeDesk` + +Expected covered tests: + +- `MacroRemappingContract` +- `MacroPersistenceBoundary` +- `PackageChecklist` +- existing `Phase 6R-D`, `MagicCube5D`, `Magic120Cell`, and `CubeDesk` + regression suites + +## Queue effect + +This packet consumes the current bounded `Phase 6R-T` implementation slice. + +`roice3/MagicTile` remains partially incorporated: + +- landed now: + - tiling topology and geometry-family contract + - loader/runtime-anchor boundary + - direct-donor attribution boundary + - transform-aware macro remapping contract + - macro persistence boundary + - reverse/setup-move/commutator playback support tags +- still deferred: + - broad non-Euclidean interaction shell + - WinForms/OpenTK host shell + - generic runtime-base replacement + +The next clean move is: + +- a source-backed `Phase 6R-U` `ggml-org/whisper.cpp` live microphone capture + shell preparation/control pass + +Keep the future sequencing guards visible: + +- `roice3/MagicTile` + - keep broad non-Euclidean interaction or WinForms/OpenTK host ownership + closed by default unless a narrower first-party gap is proven above the + landed macro-remapping seam +- `ggml-org/whisper.cpp` + - keep code-license judgments separate from downloadable model or payload + license review in any future live microphone packet +- first-party HyperTwist + - keep the top-level provider/session contract first-party rather than + letting `whisper.cpp` or `faster-whisper` absorb that lane through a + narrower donor win diff --git a/docs/arch/HYPERTWIST_PHASE6R_T_MAGICTILE_TRANSFORM_AWARE_MACRO_REMAPPING_PREPARATION_PACKET_2026-05-24.md b/docs/arch/HYPERTWIST_PHASE6R_T_MAGICTILE_TRANSFORM_AWARE_MACRO_REMAPPING_PREPARATION_PACKET_2026-05-24.md new file mode 100644 index 0000000..de880b7 --- /dev/null +++ b/docs/arch/HYPERTWIST_PHASE6R_T_MAGICTILE_TRANSFORM_AWARE_MACRO_REMAPPING_PREPARATION_PACKET_2026-05-24.md @@ -0,0 +1,165 @@ +# HyperTwist Phase 6R-T MagicTile transform-aware macro remapping preparation packet + +Created on `2026-05-24` + +## Status + +- historical same-day preparation authority +- bounded post-`Phase 6R-S` control slice +- the first bounded implementation slice now lands separately under: + - `docs/arch/HYPERTWIST_PHASE6R_T_MAGICTILE_TRANSFORM_AWARE_MACRO_REMAPPING_IMPLEMENTATION_PACKET_2026-05-24.md` + +## Purpose + +This packet freezes the next widening order after the landed `Phase 6R-S` +shared classic-cube correction-resolution closure slice. + +The open task was: + +- define the next bounded source-backed widening packet for `roice3/MagicTile` + as the retained `Phase 6R-T` transform-aware macro remapping and macro + persistence seam + +It is not: + +- a full `MagicTile` row transplant +- a `Hyperspeedcube` runtime-base replacement packet +- a broad non-Euclidean interaction-shell packet +- a WinForms/OpenTK host-shell packet +- a generalized notation or replay packet +- the next speech-input / voice sidecar packet + +## Current authority basis + +This preparation packet stands on already-closed authority: + +- `docs/REPO_LICENSE_TRACKING.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md` +- `docs/arch/HYPERTWIST_PHASE6R_S_CLASSIC_CUBE_CORRECTION_RESOLUTION_CLOSURE_IMPLEMENTATION_PACKET_2026-05-24.md` + +The key accepted routing facts are: + +- `roice3/MagicTile` remains the retained non-Euclidean topology and macro + donor after the already landed `Phase 6R-D` topology slice +- the retained donor value strongest for the next narrow widening is: + - transform-aware macro remapping against puzzle-state transforms + - reverse macro execution and setup-move unwind support + - commutator playback reuse + - puzzle-specific macro ownership + - macro XML persistence and puzzle-compatibility checks +- ownership denied here is: + - do not widen into broad non-Euclidean interaction-shell ownership + - do not widen into the WinForms/OpenTK host shell + - do not let the row replace the retained `Hyperspeedcube` runtime anchor + - do not widen into generic notation or replay ownership + +## Required result + +The source-backed control pass for this packet is now complete. + +The first actual `6R-T` implementation packet should: + +- define one bounded transform-aware macro remapping slice above the landed + `Phase 6R-D` topology contract +- land a first-party macro remapping contract and macro persistence boundary +- preserve reverse/setup-move/commutator playback behavior as contract tags + rather than broad shell ownership +- add runtime-library lookup accessors and focused automation coverage +- explicitly state which neighboring retained families stay closed + +## Source-backed retained basis + +The queue-head decision is now source-backed rather than README-only. + +Inspected retained donor basis: + +- `C:\visual_studio_solutions\multi_project\GPT 5.4 HyperTwist parse\15-roice3-magictile-upstream-dossier.md` +- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\MagicTile\MagicTile\Puzzle\Twisting\Macro.cs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\MagicTile\MagicTile\Puzzle\Twisting\TwistHandler.cs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\MagicTile\MagicTile\Puzzle\Twisting\SetupMoves.cs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\MagicTile\MagicTile\Puzzle\Loader.cs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\MagicTile\MagicTile\Puzzle\Puzzle.cs` + +Inspected first-party receiving basis: + +- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h` +- `UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp` +- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h` +- `UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp` +- `UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingLegacy4DLibrary.cpp` + +## Narrowed 6R-T slice decision + +The next widening slice is fixed as: + +1. transform-aware macro remapping contract plus macro persistence boundary + +That narrowed slice covers: + +- first-party tiling package references for: + - macro remapping anchor + - twist-handler playback support + - setup-move support +- first-party remapping contract for: + - reference Mobius transform + - clicked-cell canonical orientation + - view-reflection parity + - transformed twist lookup by nearest transformed center + - reverse XOR view-reflection handling + - puzzle-specific macro ownership +- first-party persistence boundary for: + - `MagicTileMacros` XML root + - macro display-name, transform, and view-reflection persistence + - saved-version and active-puzzle compatibility checks +- runtime-library accessors and focused automation coverage + +## Deferred neighboring families + +The first `6R-T` implementation packet must keep these capability families +closed: + +- broad non-Euclidean interaction shell +- WinForms/OpenTK host shell +- generic runtime-base replacement +- generic notation or replay ownership +- the speech-input / voice sidecar queue + +Why this slice is next: + +- `MagicTile` exposes a narrower donor seam at transform-aware macro remapping + than at broad viewer/editor ownership +- the already landed `Phase 6R-D` topology contract provides the right local + receiving substrate for a bounded remapping/persistence layer +- broad interaction-shell or host-shell widening would blur ownership more than + clarify it at this point + +## Acceptance criteria + +- the packet records why the queue advanced from landed `Phase 6R-S` to + `Phase 6R-T` +- the packet records that the first `6R-T` widening slice is transform-aware + macro remapping plus macro persistence only +- the packet states exact out-of-scope families for the first `6R-T` pass +- the packet preserves the upstream `MIT` attribution boundary explicitly +- the packet leaves broad interaction-shell and host-shell ownership deferred + +## Validation checklist + +1. confirm the landed `Phase 6R-S` packet is the consumed prior queue head +2. confirm the retained `MagicTile` seam narrows cleanly to transform-aware + macro remapping and macro persistence +3. confirm the next implementation packet is framed as bounded source-backed + widening rather than a broad non-Euclidean transplant + +That is the packet. + +## Queue effect + +This preparation packet is now consumed by the landed bounded `Phase 6R-T` +implementation slice. + +Once that slice lands, the next clean move should return to the retained +speech-input / voice sidecar queue at: + +- a source-backed `Phase 6R-U` `ggml-org/whisper.cpp` live microphone capture + shell preparation/control pass diff --git a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md index a3c5c96..f2a5661 100644 --- a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md +++ b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md @@ -112,17 +112,20 @@ The next bounded move is now: control pass is now consumed 12. the bounded permissive `Phase 6R-S` shared classic-cube correction-resolution closure packet is now landed in current code -13. the next bounded move is a source-backed `Phase 6R-T` `roice3/MagicTile` - transform-aware macro remapping preparation/control pass -14. keep the `rubix-cube-solver` guard visible: - - do not copy or redistribute `frontend/lib/twistysim.min.js` without preserving or replacing - its upstream provenance/license in any future widening that would ship that asset -15. keep the `qbr` guard visible: - - do not copy or redistribute `src/assets/arial-unicode-ms.ttf` without separate confirmation - or replacement in any future widening that would ship that asset -16. keep the `MagicTile` guard visible: - - keep the next widening bounded to transform-aware macro remapping rather than broad - non-Euclidean interaction or WinForms/OpenTK host-shell ownership +13. the generic source-backed `Phase 6R-T` `roice3/MagicTile` transform-aware macro remapping + control pass is now consumed +14. the bounded permissive `Phase 6R-T` `roice3/MagicTile` transform-aware macro remapping + packet is now landed in current code +15. the next bounded move is a source-backed `Phase 6R-U` `ggml-org/whisper.cpp` + live microphone capture shell preparation/control pass +16. keep the speech-lane guard visible: + - keep code-license judgments separate from model, voice, and payload-license review +17. keep the provider-neutral speech-lane guard visible: + - first-party HyperTwist owns the top-level provider/session contract + - `whisper.cpp` and `faster-whisper` may win narrower donor slices without inheriting that lane +18. keep the `MagicTile` guard visible: + - keep broad non-Euclidean interaction or WinForms/OpenTK host-shell ownership closed by + default unless a narrower first-party gap is proven above the landed macro-remapping seam ## Memory-specific sequencing rule 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 fd615f9..a7c11e3 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md @@ -117,6 +117,7 @@ Do not collapse those three tiers into one undifferentiated "features" voice. | Hyper notation and replay-log serialization boundary | Implemented now | landed `Hyperspeedcube` `Phase 6R-K` | Narrow retained notation and log-serialization slice is live. | | Hyper replay verification boundary | Implemented now | landed `Hyperspeedcube` `Phase 6R-L` | Narrow retained replay-verification and solve-proof slice is live. | | Tiling topology and geometry-family contract | Implemented now | landed `MagicTile` `Phase 6R-D` | Narrow retained non-Euclidean topology slice is live. | +| Transform-aware tiling macro remapping and persistence boundary | Implemented now | landed `MagicTile` `Phase 6R-T` | First-party transform-aware remapping, reverse/setup-move playback tags, and macro XML compatibility boundary are live above the landed topology slice. | | Provider-backed recognition session boundary | Implemented now | first-party current code | `UHyperTwistHttpVisionClient` and normalized recognition envelopes are live first-party seams. | | Speech transcript session boundary | Implemented now | landed `whisper.cpp` `Phase 6R-E` | Transcript sessions, utterance envelopes, and speech-health seams are live. | | Analytics/reporting surfaces | Implemented now | landed analytics/reporting packets | Reporting is real, but bounded to accepted retained slices. | @@ -186,9 +187,10 @@ repo. |---|---|---|---| | Legacy `4D` interaction/history/macro/provenance boundary | Implemented now | landed `magiccube4d` packet | Already part of current product truth. | | Tiling topology and geometry-family contract | Implemented now | landed `MagicTile` packet | New bounded widening is live. | +| Transform-aware macro remapping and macro persistence boundary | Implemented now | landed `MagicTile` `Phase 6R-T` | Current bounded remapping contract, reverse/setup-move playback support, and macro XML compatibility boundary are live above the landed topology contract. | | Dedicated `120-cell` family runtime profile and persistence boundary | Implemented now | landed `Magic120Cell` packet | Current bounded family-specific widening is live beneath the retained `Hyperspeedcube` runtime anchor. | | 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. | -| Transform-aware macro remapping and broad non-Euclidean interaction shell | Deep-source grounded retained | `MagicTile` retained remainder | Transform-aware macro remapping is the current next bounded retained slice; broad interaction ownership is still deferred. | +| 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 48e8855..fe63a48 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md @@ -139,9 +139,13 @@ Canonical discovery surfaces for roadmap interpretation: control pass is now consumed - the bounded permissive `Phase 6R-S` shared classic-cube correction-resolution closure packet is now landed in current code -- the current next bounded move is a source-backed `Phase 6R-T` `roice3/MagicTile` - transform-aware macro remapping preparation/control pass, while keeping both classic-cube - bundled-asset guards explicit +- the generic source-backed `Phase 6R-T` `roice3/MagicTile` transform-aware macro remapping + control pass is now consumed +- the bounded permissive `Phase 6R-T` `roice3/MagicTile` transform-aware macro remapping packet + is now landed in current code +- the current next bounded move is a source-backed `Phase 6R-U` `ggml-org/whisper.cpp` + live microphone capture shell preparation/control pass, while keeping speech model/payload + review separate from the code-license judgment - the repo-row implementation queue is now live from that `Phase 6R-A` entry point rather than waiting on another first-party packet @@ -203,14 +207,14 @@ Current routing truth: - active non-live implementation-board rows: `34` - retained benchmark, oracle, or clean-room-later rows outside the active implementation board: `9` -The next bounded move is a source-backed `Phase 6R-T` `roice3/MagicTile` -transform-aware macro remapping preparation/control pass. +The next bounded move is a source-backed `Phase 6R-U` `ggml-org/whisper.cpp` +live microphone capture shell preparation/control pass. Queue interpretation after that control pass: - then continue with the retained repo-row queue - highest current repo-row queue pressure sits in: - - the retained `MagicTile` transform-aware macro remapping remainder + - the retained `whisper.cpp` live microphone capture shell remainder - `HactarCE/Hyperspeedcube` is now closed for the currently justified retained row: - landed: - puzzle catalog contract @@ -266,29 +270,28 @@ Queue interpretation after that control pass: - bundled `twistysim.min.js` redistribution - generalized solver backend ownership - broad playback-runtime ownership -- after the landed `Phase 6R-S` implementation packet, keep the future legal sequencing guards - visible: - - `vivaansinghvi07/rubix-cube-solver` - - do not copy or redistribute `frontend/lib/twistysim.min.js` without preserving or replacing - its upstream provenance/license in any future widening that would ship that asset - - `kkoomen/qbr` - - do not copy or redistribute `src/assets/arial-unicode-ms.ttf` without separate confirmation - or replacement in any future widening that would ship that asset - - `Phase 6R-S` - - keep `vivaansinghvi07/rubix-cube-solver` as the retained correction/explanation-semantic - owner and preserve `kkoomen/qbr` as the retained capture-state and re-scan adjunct without - reopening the shared correction shell unless a narrower first-party gap is proven above the - landed resolution-closure seam or widening into either bundled asset family or broad - playback/runtime ownership +- after the landed `Phase 6R-T` implementation packet, keep the future routing guards visible: + - `roice3/MagicTile` + - keep broad non-Euclidean interaction or WinForms/OpenTK host ownership closed by default + unless a narrower first-party gap is proven above the landed macro-remapping seam + - `ggml-org/whisper.cpp` + - keep code-license judgments separate from downloadable model or payload-license review in + any follow-on microphone packet + - first-party HyperTwist + - keep the top-level provider/session contract first-party rather than letting + `whisper.cpp` or `faster-whisper` absorb that lane through a narrower donor win - `roice3/MagicTile` remains a partially landed row rather than a closed row: - landed: - tiling topology and geometry-family contract - loader/runtime-anchor boundary - direct-donor attribution boundary + - transform-aware macro remapping contract + - macro persistence boundary + - reverse/setup-move/commutator playback support tags - still deferred: - - transform-aware macro remapping - broad non-Euclidean interaction shell - WinForms/OpenTK host shell + - generic runtime-base replacement - `ggml-org/whisper.cpp` remains a partially landed row rather than a closed row: - landed: - speech transcript session boundary @@ -344,11 +347,10 @@ Queue interpretation after that control pass: - viseme / gesture runtime integration - broad assistant-platform scope - the next queue shape is now: - - retained `MagicTile` transform-aware macro remapping assessment + - retained `whisper.cpp` live microphone capture shell assessment - the next bounded move should stay narrow: - - a source-backed `Phase 6R-T` control pass before any widening into broad non-Euclidean - interaction shell, WinForms/OpenTK host ownership, bundled `twistysim.min.js` - redistribution, or any `qbr` multilingual/font-shipping path + - a source-backed `Phase 6R-U` control pass before any widening into downloadable + model/payload shipping, broad voice-output ownership, or broad assistant-platform scope - keep the speech-input / voice sidecar legal sequencing guard visible: - keep code-license judgments separate from model, voice, and payload-license review - keep the provider-neutral speech-lane guard visible: