Implement Phase 6R-T MagicTile macro remapping contract

2026-05-24 19:34:34 +02:00 · 2026-05-24 19:34:34 +02:00 · 5ff4937a6e
commit 5ff4937a6e
parent 4ea9e9683d
11 changed files with 857 additions and 51 deletions
--- 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(
--- 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<FString> 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
 )
--- 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();

--- 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<FString> RequiredPackageIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ReferenceSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> TransformSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> PlaybackSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> 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<FString> RequiredPackageIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> PersistenceSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> CompatibilitySurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ProvenanceCaveats;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> 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<FHyperTwistTrainingTilingPackageReference> PackageReferences;

@ -181,10 +263,18 @@ struct FHyperTwistTrainingTilingReferenceBundle
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	TArray<FHyperTwistTrainingTilingAttributionBoundary> AttributionBoundaries;

+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingTilingMacroRemappingContract> MacroRemappingContracts;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingTilingMacroPersistenceBoundary> 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);
 };
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RTMacroRemappingContractTest.cpp
+++ 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
--- 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`

--- 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
@ -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
--- 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
@ -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
--- 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

--- 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

--- 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: