Implement Phase 6R-I Magic120Cell runtime profile boundary

UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.cpp

@@ -0,0 +1,418 @@
+#include "HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h"
+
+namespace HyperTwistTrainingMagic120CellLibraryInternal
+{
+	const TCHAR* Magic120CellLicense = TEXT("MIT");
+
+	FHyperTwistTrainingSourceAttribution MakeAttribution(
+		const FString& TrackId,
+		const FString& Notes
+	)
+	{
+		FHyperTwistTrainingSourceAttribution Attribution;
+		Attribution.SourceMode = EHyperTwistTrainingSourceMode::DirectDonor;
+		Attribution.SourceRepo = TEXT("roice3/Magic120Cell");
+		Attribution.SourceLicense = Magic120CellLicense;
+		Attribution.SourceTrackId = TrackId;
+		Attribution.SourceNotes = Notes;
+		return Attribution;
+	}
+
+	FHyperTwistTrainingMagic120CellPackageReference MakePackageReference(
+		const FString& PackageId,
+		const FString& Label,
+		const FString& ExportPath,
+		const FString& OwnershipRole,
+		const FString& LicensePosture,
+		const FString& Summary,
+		const TArray<FString>& RetainedSurfaceTags,
+		const TArray<FString>& RequiredNoticeActions,
+		const TArray<FString>& ExplicitExclusions,
+		const FHyperTwistTrainingSourceAttribution& SourceAttribution
+	)
+	{
+		FHyperTwistTrainingMagic120CellPackageReference Reference;
+		Reference.PackageId = PackageId;
+		Reference.Label = Label;
+		Reference.ExportPath = ExportPath;
+		Reference.OwnershipRole = OwnershipRole;
+		Reference.LicensePosture = LicensePosture;
+		Reference.Summary = Summary;
+		Reference.RetainedSurfaceTags = RetainedSurfaceTags;
+		Reference.RequiredNoticeActions = RequiredNoticeActions;
+		Reference.ExplicitExclusions = ExplicitExclusions;
+		Reference.SourceAttribution = SourceAttribution;
+		return Reference;
+	}
+
+	void AppendJoined(FString& OutText, const TArray<FString>& Values)
+	{
+		for (int32 Index = 0; Index < Values.Num(); ++Index)
+		{
+			if (Index > 0)
+			{
+				OutText.Append(TEXT(", "));
+			}
+
+			OutText.Append(Values[Index]);
+		}
+	}
+}
+
+FHyperTwistTrainingMagic120CellReferenceBundle
+UHyperTwistTrainingMagic120CellLibrary::BuildBundledMagic120CellReferenceBundle()
+{
+	using namespace HyperTwistTrainingMagic120CellLibraryInternal;
+
+	FHyperTwistTrainingMagic120CellReferenceBundle Bundle;
+	Bundle.ReferenceUtc = TEXT("2026-05-22T09:15:00Z");
+	Bundle.PrimaryRuntimeProfileContractId = TEXT("magic120cell-runtime-profile");
+	Bundle.PrimaryPersistenceBoundaryId = TEXT("magic120cell-persistence-boundary");
+	Bundle.PrimaryAttributionBoundaryId = TEXT("magic120cell-mit-attribution-boundary");
+
+	const TArray<FString> CommonNoticeActions =
+	{
+		TEXT("preserve the upstream MIT license text in third-party notices or equivalent release/legal materials"),
+		TEXT("preserve the upstream copyright notice for Roice Nelson")
+	};
+
+	Bundle.PackageReferences =
+	{
+		MakePackageReference(
+			TEXT("package/magic120cell-family-core"),
+			TEXT("Magic120Cell/workFiles/magic120Cell"),
+			TEXT("./Magic120Cell/workFiles/magic120Cell.cpp"),
+			TEXT("120-cell-runtime-profile-anchor"),
+			TEXT("direct permissive donor"),
+			TEXT("Family-specific 120-cell organization, symmetry maps, hypercube overlay grouping, center-cell view control, and puzzle-type mode routing for the dedicated 4D megaminx analogue lane."),
+			{
+				TEXT("12-ring 120-cell organization"),
+				TEXT("torus symmetry groups"),
+				TEXT("hypercube symmetry groups"),
+				TEXT("layer symmetry groups"),
+				TEXT("ring symmetry groups"),
+				TEXT("center-cell view recentering")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("Hyperspeedcube runtime-base replacement"),
+				TEXT("generic non-Euclidean topology ownership"),
+				TEXT("WinForms/OpenGL host-shell ownership")
+			},
+			MakeAttribution(
+				TEXT("magic120cell/family-core"),
+				TEXT("Preserves the dedicated Magic120Cell family runtime profile beneath first-party HyperTwist runtime ownership without widening into a generic non-Euclidean shell.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magic120cell-settings"),
+			TEXT("Magic120Cell/workFiles/settings"),
+			TEXT("./Magic120Cell/workFiles/settings.cpp"),
+			TEXT("120-cell-mode-default-support"),
+			TEXT("direct permissive donor"),
+			TEXT("Family defaults for puzzle-type mode, symmetry mode, logical-visibility depth, center-cell selection, and physical visibility toggles."),
+			{
+				TEXT("full-color default"),
+				TEXT("layer-display default"),
+				TEXT("logical layer-depth default"),
+				TEXT("center-cell default"),
+				TEXT("group-visibility toggles")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("broad settings-platform ownership"),
+				TEXT("UI settings-dialog ownership"),
+				TEXT("provider-profile ownership")
+			},
+			MakeAttribution(
+				TEXT("magic120cell/settings"),
+				TEXT("Preserves the bounded Magic120Cell runtime-mode defaults without importing the legacy settings UI shell.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magic120cell-loader"),
+			TEXT("Magic120Cell/workFiles/loader"),
+			TEXT("./Magic120Cell/workFiles/loader.cpp"),
+			TEXT("120-cell-persistence-support"),
+			TEXT("direct permissive donor"),
+			TEXT("Family-specific header, scrambled-state persistence, hex facelet serialization, and twist-history load/save support for the dedicated Magic120Cell lane."),
+			{
+				TEXT("Magic120Cell Version1 header"),
+				TEXT("puzzle-type persistence"),
+				TEXT("scrambled-flag persistence"),
+				TEXT("hex facelet state serialization"),
+				TEXT("full_scramble.log cache")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("first-party canonical replay ownership"),
+				TEXT("host file-dialog ownership"),
+				TEXT("generic notation ownership")
+			},
+			MakeAttribution(
+				TEXT("magic120cell/loader"),
+				TEXT("Preserves the dedicated Magic120Cell persistence seam without adopting the host-dialog shell or promoting the format to a generic product-wide replay contract.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magic120cell-twist"),
+			TEXT("geometryLib/puzzle/twist"),
+			TEXT("./geometryLib/puzzle/twist.h"),
+			TEXT("120-cell-twist-ledger-support"),
+			TEXT("direct permissive donor"),
+			TEXT("Family-specific twist-hash and view-rotation support for Magic120Cell persistence and twist-history replay, including the explicit slicemask caveat."),
+			{
+				TEXT("twist-hash encoding"),
+				TEXT("view-rotation flag"),
+				TEXT("left-click direction flag"),
+				TEXT("slicemask caveat")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("generic move-notation ownership"),
+				TEXT("whole transformation-platform ownership"),
+				TEXT("generic puzzle-family twist ledger ownership")
+			},
+			MakeAttribution(
+				TEXT("magic120cell/twist"),
+				TEXT("Preserves the dedicated Magic120Cell twist-hash and view-rotation persistence seam without treating it as the generic transformation contract for all retained puzzle families.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magic120cell-twist-history"),
+			TEXT("geometryLib/puzzle/twistHistory"),
+			TEXT("./geometryLib/puzzle/twistHistory.cpp"),
+			TEXT("120-cell-history-undo-redo-support"),
+			TEXT("direct permissive donor"),
+			TEXT("Undo/redo and accumulated twist-ledger support for the dedicated Magic120Cell scramble and persistence lane."),
+			{
+				TEXT("undo ledger"),
+				TEXT("redo ledger"),
+				TEXT("twist accumulation"),
+				TEXT("scramble-history persistence")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("whole review-history ownership"),
+				TEXT("first-party analytics ownership"),
+				TEXT("generic persistence-platform ownership")
+			},
+			MakeAttribution(
+				TEXT("magic120cell/twist-history"),
+				TEXT("Preserves the dedicated Magic120Cell undo/redo and scramble-ledger seam without promoting it into the broader HyperTwist review or analytics stack.")
+			)
+		)
+	};
+
+	FHyperTwistTrainingMagic120CellRuntimeProfileContract RuntimeProfile;
+	RuntimeProfile.ContractId = TEXT("magic120cell-runtime-profile");
+	RuntimeProfile.Title = TEXT("Magic120Cell family runtime profile");
+	RuntimeProfile.Summary = TEXT("First-party HyperTwist contract for dedicated 120-cell family puzzle-type modes, symmetry-scoped visibility groups, and center-cell view semantics beneath the Hyperspeedcube runtime anchor.");
+	RuntimeProfile.RequiredPackageIds =
+	{
+		TEXT("package/magic120cell-family-core"),
+		TEXT("package/magic120cell-settings")
+	};
+	RuntimeProfile.PuzzleTypeSurfaceTags =
+	{
+		TEXT("ring-color puzzle type"),
+		TEXT("layer-color puzzle type"),
+		TEXT("torus-color puzzle type"),
+		TEXT("hypercube-color puzzle type"),
+		TEXT("full-color puzzle type"),
+		TEXT("antipodal-color puzzle type")
+	};
+	RuntimeProfile.SymmetrySurfaceTags =
+	{
+		TEXT("torus visibility groups"),
+		TEXT("hypercube visibility groups"),
+		TEXT("layer visibility groups"),
+		TEXT("ring visibility groups"),
+		TEXT("hypercube overlay points")
+	};
+	RuntimeProfile.VisibilitySurfaceTags =
+	{
+		TEXT("logical layer-depth visibility"),
+		TEXT("physical group visibility toggles"),
+		TEXT("center-cell recentering"),
+		TEXT("view-rotation guard rails")
+	};
+	RuntimeProfile.ExplicitExclusions =
+	{
+		TEXT("Hyperspeedcube runtime-base replacement"),
+		TEXT("generic non-Euclidean topology ownership"),
+		TEXT("WinForms/OpenGL host-shell ownership"),
+		TEXT("broad renderer ownership")
+	};
+	RuntimeProfile.SourceAttribution = MakeAttribution(
+		TEXT("magic120cell/runtime-profile"),
+		TEXT("Preserves the dedicated Magic120Cell runtime-profile lane while keeping HyperTwist first-party for the broader runtime, notation, replay, and viewer shell.")
+	);
+	Bundle.RuntimeProfileContracts = {RuntimeProfile};
+
+	FHyperTwistTrainingMagic120CellPersistenceBoundary PersistenceBoundary;
+	PersistenceBoundary.BoundaryId = TEXT("magic120cell-persistence-boundary");
+	PersistenceBoundary.Title = TEXT("Magic120Cell persistence and twist-history boundary");
+	PersistenceBoundary.Summary = TEXT("First-party HyperTwist boundary for the dedicated Magic120Cell file header, state serialization, scramble cache, and twist-history persistence seam.");
+	PersistenceBoundary.RequiredPackageIds =
+	{
+		TEXT("package/magic120cell-loader"),
+		TEXT("package/magic120cell-twist"),
+		TEXT("package/magic120cell-twist-history")
+	};
+	PersistenceBoundary.PersistenceSurfaceTags =
+	{
+		TEXT("Magic120Cell Version1 header"),
+		TEXT("puzzle-type persistence"),
+		TEXT("scrambled-flag persistence"),
+		TEXT("hex facelet state serialization"),
+		TEXT("full_scramble.log cache")
+	};
+	PersistenceBoundary.TwistHistorySurfaceTags =
+	{
+		TEXT("twist-hash serialization"),
+		TEXT("view-rotation and direction flags"),
+		TEXT("undo/redo twist ledger"),
+		TEXT("scramble-history replay")
+	};
+	PersistenceBoundary.ProvenanceCaveats =
+	{
+		TEXT("slice mask is not persisted in twist hash"),
+		TEXT("save/load dialog filter text still says MagicCube5D log files"),
+		TEXT("the full scramble shortcut assumes a sidecar full_scramble.log cache")
+	};
+	PersistenceBoundary.ExplicitExclusions =
+	{
+		TEXT("first-party canonical replay or verification ownership"),
+		TEXT("host file-dialog ownership"),
+		TEXT("generic puzzle-state persistence ownership"),
+		TEXT("generic move-notation ownership")
+	};
+	PersistenceBoundary.SourceAttribution = MakeAttribution(
+		TEXT("magic120cell/persistence-boundary"),
+		TEXT("Preserves the dedicated Magic120Cell persistence seam while keeping HyperTwist first-party for canonical replay, verification, and broader product-wide persistence contracts.")
+	);
+	Bundle.PersistenceBoundaries = {PersistenceBoundary};
+
+	FHyperTwistTrainingMagic120CellAttributionBoundary AttributionBoundary;
+	AttributionBoundary.BoundaryId = TEXT("magic120cell-mit-attribution-boundary");
+	AttributionBoundary.Title = TEXT("Magic120Cell donor attribution boundary");
+	AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using Magic120Cell as a direct permissive donor for the bounded family runtime-profile and persistence slice.");
+	AttributionBoundary.AllowedUseTags =
+	{
+		TEXT("first-party reauthored subsystem implementation"),
+		TEXT("direct permissive donor reference"),
+		TEXT("bounded family runtime-profile and persistence contract use")
+	};
+	AttributionBoundary.RequiredNoticeActions = CommonNoticeActions;
+	AttributionBoundary.ProvenanceCaveats =
+	{
+		TEXT("Magic120Cell is a dedicated 4D megaminx-analogue donor, not a generic topology platform"),
+		TEXT("MagicTile remains the generalized tiling and topology donor lane"),
+		TEXT("Hyperspeedcube remains the primary runtime anchor for retained hyper puzzle ownership")
+	};
+	AttributionBoundary.ExplicitExclusions =
+	{
+		TEXT("silent attribution removal"),
+		TEXT("pretending a broad non-Euclidean shell landed in this packet"),
+		TEXT("treating legacy host or renderer surfaces as incorporated")
+	};
+	AttributionBoundary.SourceAttribution = MakeAttribution(
+		TEXT("magic120cell/attribution-boundary"),
+		TEXT("Records MIT attribution and packet bounds for Magic120Cell while keeping the first slice narrowly scoped to the dedicated runtime-profile and persistence seam.")
+	);
+	Bundle.AttributionBoundaries = {AttributionBoundary};
+
+	return Bundle;
+}
+
+bool UHyperTwistTrainingMagic120CellLibrary::TryGetRuntimeProfileContractById(
+	const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle,
+	const FString& ContractId,
+	FHyperTwistTrainingMagic120CellRuntimeProfileContract& OutContract
+)
+{
+	for (const FHyperTwistTrainingMagic120CellRuntimeProfileContract& Contract : Bundle.RuntimeProfileContracts)
+	{
+		if (Contract.ContractId == ContractId)
+		{
+			OutContract = Contract;
+			return true;
+		}
+	}
+
+	OutContract = FHyperTwistTrainingMagic120CellRuntimeProfileContract();
+	return false;
+}
+
+bool UHyperTwistTrainingMagic120CellLibrary::TryGetPersistenceBoundaryById(
+	const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle,
+	const FString& BoundaryId,
+	FHyperTwistTrainingMagic120CellPersistenceBoundary& OutBoundary
+)
+{
+	for (const FHyperTwistTrainingMagic120CellPersistenceBoundary& Boundary : Bundle.PersistenceBoundaries)
+	{
+		if (Boundary.BoundaryId == BoundaryId)
+		{
+			OutBoundary = Boundary;
+			return true;
+		}
+	}
+
+	OutBoundary = FHyperTwistTrainingMagic120CellPersistenceBoundary();
+	return false;
+}
+
+bool UHyperTwistTrainingMagic120CellLibrary::TryGetAttributionBoundaryById(
+	const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle,
+	const FString& BoundaryId,
+	FHyperTwistTrainingMagic120CellAttributionBoundary& OutBoundary
+)
+{
+	for (const FHyperTwistTrainingMagic120CellAttributionBoundary& Boundary : Bundle.AttributionBoundaries)
+	{
+		if (Boundary.BoundaryId == BoundaryId)
+		{
+			OutBoundary = Boundary;
+			return true;
+		}
+	}
+
+	OutBoundary = FHyperTwistTrainingMagic120CellAttributionBoundary();
+	return false;
+}
+
+FString UHyperTwistTrainingMagic120CellLibrary::BuildPackageChecklistTsv(
+	const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle
+)
+{
+	using namespace HyperTwistTrainingMagic120CellLibraryInternal;
+
+	FString Checklist = TEXT("PackageId\tLabel\tExportPath\tOwnershipRole\tLicensePosture\tRetainedSurfaceTags\tRequiredNoticeActions\tExplicitExclusions\n");
+	for (const FHyperTwistTrainingMagic120CellPackageReference& Reference : Bundle.PackageReferences)
+	{
+		FString RetainedSurfaceTags;
+		AppendJoined(RetainedSurfaceTags, Reference.RetainedSurfaceTags);
+
+		FString NoticeActions;
+		AppendJoined(NoticeActions, Reference.RequiredNoticeActions);
+
+		FString Exclusions;
+		AppendJoined(Exclusions, Reference.ExplicitExclusions);
+
+		Checklist += FString::Printf(
+			TEXT("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"),
+			*Reference.PackageId,
+			*Reference.Label,
+			*Reference.ExportPath,
+			*Reference.OwnershipRole,
+			*Reference.LicensePosture,
+			*RetainedSurfaceTags,
+			*NoticeActions,
+			*Exclusions
+		);
+	}
+
+	return Checklist;
+}

UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp

@@ -520,6 +520,11 @@ FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetB
 	return UHyperTwistTrainingTilingLibrary::BuildBundledTilingReferenceBundle();
 }
 
+FHyperTwistTrainingMagic120CellReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledMagic120CellReferenceBundle()
+{
+	return UHyperTwistTrainingMagic120CellLibrary::BuildBundledMagic120CellReferenceBundle();
+}
+
 FHyperTwistTrainingSharedAssetReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledSharedAssetReferenceBundle()
 {
 	return UHyperTwistTrainingSharedAssetLibrary::BuildBundledSharedAssetReferenceBundle();
@@ -1146,6 +1151,49 @@ FString UHyperTwistTrainingRuntimeLibrary::BuildBundledTilingPackageChecklistTsv
 	);
 }
 
+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellRuntimeProfileContract(
+	const FString& ContractId,
+	FHyperTwistTrainingMagic120CellRuntimeProfileContract& OutContract
+)
+{
+	return UHyperTwistTrainingMagic120CellLibrary::TryGetRuntimeProfileContractById(
+		GetBundledMagic120CellReferenceBundle(),
+		ContractId,
+		OutContract
+	);
+}
+
+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellPersistenceBoundary(
+	const FString& BoundaryId,
+	FHyperTwistTrainingMagic120CellPersistenceBoundary& OutBoundary
+)
+{
+	return UHyperTwistTrainingMagic120CellLibrary::TryGetPersistenceBoundaryById(
+		GetBundledMagic120CellReferenceBundle(),
+		BoundaryId,
+		OutBoundary
+	);
+}
+
+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellAttributionBoundary(
+	const FString& BoundaryId,
+	FHyperTwistTrainingMagic120CellAttributionBoundary& OutBoundary
+)
+{
+	return UHyperTwistTrainingMagic120CellLibrary::TryGetAttributionBoundaryById(
+		GetBundledMagic120CellReferenceBundle(),
+		BoundaryId,
+		OutBoundary
+	);
+}
+
+FString UHyperTwistTrainingRuntimeLibrary::BuildBundledMagic120CellPackageChecklistTsv()
+{
+	return UHyperTwistTrainingMagic120CellLibrary::BuildPackageChecklistTsv(
+		GetBundledMagic120CellReferenceBundle()
+	);
+}
+
 bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledSharedAssetFixtureReference(
 	const FString& FixtureId,
 	FHyperTwistTrainingSharedAssetFixtureReference& OutReference

UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h

@@ -0,0 +1,231 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "HyperTwistTraining/HyperTwistTrainingTypes.h"
+#include "HyperTwistTrainingMagic120CellLibrary.generated.h"
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingMagic120CellPackageReference
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PackageId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Label;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString ExportPath;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString OwnershipRole;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString LicensePosture;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Summary;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RetainedSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RequiredNoticeActions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ExplicitExclusions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingSourceAttribution SourceAttribution;
+
+	bool IsStructurallyValid() const
+	{
+		return !PackageId.IsEmpty() && !Label.IsEmpty() && !ExportPath.IsEmpty()
+			&& !OwnershipRole.IsEmpty() && SourceAttribution.IsStructurallyValid();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingMagic120CellRuntimeProfileContract
+{
+	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> PuzzleTypeSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> SymmetrySurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> VisibilitySurfaceTags;
+
+	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 FHyperTwistTrainingMagic120CellPersistenceBoundary
+{
+	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> TwistHistorySurfaceTags;
+
+	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 FHyperTwistTrainingMagic120CellAttributionBoundary
+{
+	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> AllowedUseTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RequiredNoticeActions;
+
+	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 FHyperTwistTrainingMagic120CellReferenceBundle
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString ReferenceUtc;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryRuntimeProfileContractId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryPersistenceBoundaryId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryAttributionBoundaryId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingMagic120CellPackageReference> PackageReferences;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingMagic120CellRuntimeProfileContract> RuntimeProfileContracts;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingMagic120CellPersistenceBoundary> PersistenceBoundaries;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingMagic120CellAttributionBoundary> AttributionBoundaries;
+
+	bool IsStructurallyValid() const
+	{
+		return !PrimaryRuntimeProfileContractId.IsEmpty()
+			&& !PrimaryPersistenceBoundaryId.IsEmpty()
+			&& !PrimaryAttributionBoundaryId.IsEmpty()
+			&& PackageReferences.Num() > 0;
+	}
+};
+
+UCLASS()
+class UNREALHYPERTWIST_API UHyperTwistTrainingMagic120CellLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+
+public:
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Magic120Cell")
+	static FHyperTwistTrainingMagic120CellReferenceBundle BuildBundledMagic120CellReferenceBundle();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell")
+	static bool TryGetRuntimeProfileContractById(
+		const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle,
+		const FString& ContractId,
+		FHyperTwistTrainingMagic120CellRuntimeProfileContract& OutContract
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell")
+	static bool TryGetPersistenceBoundaryById(
+		const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle,
+		const FString& BoundaryId,
+		FHyperTwistTrainingMagic120CellPersistenceBoundary& OutBoundary
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell")
+	static bool TryGetAttributionBoundaryById(
+		const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle,
+		const FString& BoundaryId,
+		FHyperTwistTrainingMagic120CellAttributionBoundary& OutBoundary
+	);
+
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Magic120Cell")
+	static FString BuildPackageChecklistTsv(const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle);
+};

UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h

@@ -12,6 +12,7 @@
 #include "HyperTwistTraining/HyperTwistTrainingCoachLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingKnowledgeLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingLegacy4DLibrary.h"
+#include "HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingMediaExportLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingSharedAssetLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingSpatialLibrary.h"
@@ -178,6 +179,9 @@ public:
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
 	static FHyperTwistTrainingTilingReferenceBundle GetBundledTilingReferenceBundle();
 
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Magic120Cell")
+	static FHyperTwistTrainingMagic120CellReferenceBundle GetBundledMagic120CellReferenceBundle();
+
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|SharedAssets")
 	static FHyperTwistTrainingSharedAssetReferenceBundle GetBundledSharedAssetReferenceBundle();
 
@@ -434,6 +438,27 @@ public:
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
 	static FString BuildBundledTilingPackageChecklistTsv();
 
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell")
+	static bool TryGetBundledMagic120CellRuntimeProfileContract(
+		const FString& ContractId,
+		FHyperTwistTrainingMagic120CellRuntimeProfileContract& OutContract
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell")
+	static bool TryGetBundledMagic120CellPersistenceBoundary(
+		const FString& BoundaryId,
+		FHyperTwistTrainingMagic120CellPersistenceBoundary& OutBoundary
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell")
+	static bool TryGetBundledMagic120CellAttributionBoundary(
+		const FString& BoundaryId,
+		FHyperTwistTrainingMagic120CellAttributionBoundary& OutBoundary
+	);
+
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Magic120Cell")
+	static FString BuildBundledMagic120CellPackageChecklistTsv();
+
 	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|SharedAssets")
 	static bool TryGetBundledSharedAssetFixtureReference(
 		const FString& FixtureId,

UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagic120CellPhase6RIRuntimeProfileContractTest.cpp

@@ -0,0 +1,116 @@
+// Copyright HyperTwist, Inc. All Rights Reserved.
+
+#include "Misc/AutomationTest.h"
+
+#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h"
+
+#if WITH_AUTOMATION_TESTS
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagic120CellPhase6RIRuntimeProfileTest,
+	"HyperTwist.Permissive.Magic120Cell.Phase6R.I.RuntimeProfile",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagic120CellPhase6RIRuntimeProfileTest::RunTest(const FString& Parameters)
+{
+	const FHyperTwistTrainingMagic120CellReferenceBundle Bundle =
+		UHyperTwistTrainingRuntimeLibrary::GetBundledMagic120CellReferenceBundle();
+
+	TestTrue(TEXT("The Magic120Cell bundle must be structurally valid."), Bundle.IsStructurallyValid());
+	TestTrue(TEXT("The Magic120Cell bundle must preserve multiple package references."), Bundle.PackageReferences.Num() >= 5);
+
+	FHyperTwistTrainingMagic120CellRuntimeProfileContract Contract;
+	TestTrue(
+		TEXT("The primary Magic120Cell runtime profile must resolve from the runtime library."),
+		UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellRuntimeProfileContract(
+			Bundle.PrimaryRuntimeProfileContractId,
+			Contract
+		)
+	);
+	TestEqual(TEXT("The runtime profile id must stay stable."), Contract.ContractId, TEXT("magic120cell-runtime-profile"));
+	TestTrue(
+		TEXT("The runtime profile must keep the family-core package as a required input."),
+		Contract.RequiredPackageIds.Contains(TEXT("package/magic120cell-family-core"))
+	);
+	TestTrue(
+		TEXT("The runtime profile must preserve hypercube visibility groups."),
+		Contract.SymmetrySurfaceTags.Contains(TEXT("hypercube visibility groups"))
+	);
+	TestTrue(
+		TEXT("The runtime profile must preserve logical layer-depth visibility."),
+		Contract.VisibilitySurfaceTags.Contains(TEXT("logical layer-depth visibility"))
+	);
+	TestTrue(
+		TEXT("The runtime profile must keep generic non-Euclidean topology ownership excluded."),
+		Contract.ExplicitExclusions.Contains(TEXT("generic non-Euclidean topology ownership"))
+	);
+	TestEqual(TEXT("The runtime profile must keep the direct donor source repo."), Contract.SourceAttribution.SourceRepo, TEXT("roice3/Magic120Cell"));
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagic120CellPhase6RIPersistenceBoundaryTest,
+	"HyperTwist.Permissive.Magic120Cell.Phase6R.I.PersistenceBoundary",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagic120CellPhase6RIPersistenceBoundaryTest::RunTest(const FString& Parameters)
+{
+	const FHyperTwistTrainingMagic120CellReferenceBundle Bundle =
+		UHyperTwistTrainingRuntimeLibrary::GetBundledMagic120CellReferenceBundle();
+
+	FHyperTwistTrainingMagic120CellPersistenceBoundary Boundary;
+	TestTrue(
+		TEXT("The Magic120Cell persistence boundary must resolve from the runtime library."),
+		UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellPersistenceBoundary(
+			Bundle.PrimaryPersistenceBoundaryId,
+			Boundary
+		)
+	);
+	TestEqual(TEXT("The persistence boundary id must stay stable."), Boundary.BoundaryId, TEXT("magic120cell-persistence-boundary"));
+	TestTrue(
+		TEXT("The persistence boundary must preserve the Magic120Cell Version1 header tag."),
+		Boundary.PersistenceSurfaceTags.Contains(TEXT("Magic120Cell Version1 header"))
+	);
+	TestTrue(
+		TEXT("The persistence boundary must preserve twist-hash serialization."),
+		Boundary.TwistHistorySurfaceTags.Contains(TEXT("twist-hash serialization"))
+	);
+	TestTrue(
+		TEXT("The persistence boundary must preserve the slicemask provenance caveat."),
+		Boundary.ProvenanceCaveats.Contains(TEXT("slice mask is not persisted in twist hash"))
+	);
+	TestTrue(
+		TEXT("The persistence boundary must keep canonical replay ownership excluded."),
+		Boundary.ExplicitExclusions.Contains(TEXT("first-party canonical replay or verification ownership"))
+	);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagic120CellPhase6RIPackageChecklistTest,
+	"HyperTwist.Permissive.Magic120Cell.Phase6R.I.PackageChecklist",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagic120CellPhase6RIPackageChecklistTest::RunTest(const FString& Parameters)
+{
+	const FString Checklist = UHyperTwistTrainingRuntimeLibrary::BuildBundledMagic120CellPackageChecklistTsv();
+	TestTrue(TEXT("The Magic120Cell package checklist must not be empty."), !Checklist.IsEmpty());
+	TestTrue(
+		TEXT("The checklist must preserve the family-core package id."),
+		Checklist.Contains(TEXT("package/magic120cell-family-core"))
+	);
+	TestTrue(
+		TEXT("The checklist must preserve the loader export path."),
+		Checklist.Contains(TEXT("./Magic120Cell/workFiles/loader.cpp"))
+	);
+	TestTrue(
+		TEXT("The checklist must preserve the direct permissive donor posture."),
+		Checklist.Contains(TEXT("direct permissive donor"))
+	);
+	return true;
+}
+
+#endif

docs/REPO_LICENSE_TRACKING.md

@@ -2986,16 +2986,19 @@ Current licensing judgment:
 - direct donor candidate
 - standard `MIT`
 - the first narrower bounded implementation slice is now landed in current code:
-  - tiling topology and geometry-family contract
-  - loader/runtime-anchor boundary
+  - dedicated `120-cell` family runtime-profile contract
+  - family persistence and twist-history boundary
   - direct-donor attribution boundary
-- the row remains only partially incorporated; transform-aware macro remapping, broad
-  non-Euclidean interaction, and host-shell ownership stay deferred
+- the row remains only partially incorporated; host-shell ownership, broad renderer ownership,
+  generic topology ownership, and broad interaction-shell widening stay deferred
 
 Source basis:
 
 - `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\LICENSE`
 - `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\README.md`
+- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\Magic120Cell\workFiles\magic120Cell.cpp`
+- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\Magic120Cell\workFiles\loader.cpp`
+- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\geometryLib\puzzle\twist.h`
 
 Practical obligations:
 

docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_IMPLEMENTATION_PACKET_2026-05-22.md

@@ -0,0 +1,139 @@
+# HyperTwist Phase 6R-I roice3/Magic120Cell runtime profile and persistence implementation packet
+
+Created on `2026-05-22`
+
+## Status
+
+- first-party HyperTwist packet
+- bounded permissive `Phase 6R-I` implementation slice
+
+## Purpose
+
+This packet lands the first narrower bounded slice from the retained `roice3/Magic120Cell`
+hyper-engine row.
+
+The landed slice is:
+
+- first-party dedicated `120-cell` family runtime-profile and persistence boundary
+
+It is not:
+
+- a broad non-Euclidean platform packet
+- a renderer or viewer-shell packet
+- a generic topology packet
+- a generic notation or replay packet
+- a `MagicCube5D` widening 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_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_PREPARATION_PACKET_2026-05-22.md`
+
+The retained owner remains:
+
+- `roice3/Magic120Cell`
+
+The top-level runtime-anchor owner does not change here:
+
+- first-party HyperTwist with the retained `Hyperspeedcube` runtime anchor remains the broader
+  runtime owner
+- this packet keeps `roice3/Magic120Cell` bounded to the narrower `A1 / R1 / F2` dedicated
+  `120-cell` runtime-profile and persistence slice
+
+## Landed scope
+
+The current code now owns a retained `Magic120Cell` contract through:
+
+- a dedicated first-party `UHyperTwistTrainingMagic120CellLibrary`
+- retained package references for:
+  - family core
+  - settings defaults
+  - loader
+  - twist encoding
+  - twist-history ledger
+- one bounded runtime-profile contract for:
+  - puzzle-type modes
+  - symmetry-scoped visibility groups
+  - center-cell recentering and visibility guard rails
+- one bounded persistence boundary for:
+  - `Magic120Cell Version1` header semantics
+  - scramble-cache semantics
+  - twist-hash and undo/redo history caveats
+- one bounded donor-attribution boundary
+- runtime-library accessors and package-checklist export through:
+  - `UHyperTwistTrainingRuntimeLibrary`
+- focused automation coverage in:
+  - `HyperTwistMagic120CellPhase6RIRuntimeProfileContractTest.cpp`
+
+## Why this is still intentionally bounded
+
+This packet lands a dedicated family-specific donor seam, but it does not widen into neighboring
+retained families.
+
+Still deferred:
+
+- WinForms/OpenGL host-shell ownership
+- broad renderer ownership
+- generic non-Euclidean topology ownership
+- generic notation or replay ownership
+- broad interaction-shell widening
+- `MagicCube5D` deepening
+
+## Validation
+
+Build validation:
+
+- `Build.bat UnrealHyperTwistEditor Win64 Development -Project='C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject' -WaitMutex -NoHotReloadFromIDE`
+
+Focused automation validation:
+
+- `Automation RunTests HyperTwist.Permissive.Magic120Cell.Phase6R.I`
+
+Regression automation validation:
+
+- `Automation RunTests HyperTwist.Permissive.MagicTile.Phase6R.D`
+- `Automation RunTests HyperTwist.Permissive.Hyperspeedcube.Phase6R.A`
+- `Automation RunTests HyperTwist.CleanRoom.CubeDesk`
+
+Expected covered tests:
+
+- `RuntimeProfile`
+- `PersistenceBoundary`
+- `PackageChecklist`
+- existing `MagicTile`, `Hyperspeedcube`, and `CubeDesk` regression suites
+
+## Queue effect
+
+This packet consumes the current `Phase 6R-I` implementation slice.
+
+`roice3/Magic120Cell` remains only partially incorporated:
+
+- landed now:
+  - dedicated `120-cell` family runtime profile
+  - puzzle-type mode taxonomy
+  - symmetry and visibility group taxonomy
+  - persistence header and scramble-cache boundary
+  - twist-history caveat capture
+  - direct-donor attribution boundary
+- still deferred:
+  - WinForms/OpenGL host shell
+  - broad renderer ownership
+  - generic topology ownership
+  - generic notation or replay ownership
+  - broad interaction-shell widening
+
+The next clean move is:
+
+- source-backed `Phase 6R-J` `roice3/MagicCube5D` preparation/control pass
+
+Keep the future sequencing guards visible:
+
+- `roice3/Magic120Cell`
+  - keep the landed slice bounded to the dedicated `120-cell` family lane rather than a broad
+    non-Euclidean shell
+- `roice3/MagicCube5D`
+  - keep the code-license judgment anchored on the mirrored `MIT` repo while preserving the older
+    zip only as provenance context

docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_PREPARATION_PACKET_2026-05-22.md

@@ -0,0 +1,93 @@
+# HyperTwist Phase 6R-I roice3/Magic120Cell runtime profile and persistence preparation packet
+
+Created on `2026-05-22`
+
+## Status
+
+- first-party HyperTwist packet
+- source-backed permissive `Phase 6R-I` preparation/control slice
+
+## Purpose
+
+This packet narrows the retained `roice3/Magic120Cell` row before implementation.
+
+The retained first slice is:
+
+- dedicated `120-cell` family runtime-profile and persistence boundary beneath the retained
+  `Hyperspeedcube` runtime anchor
+
+It is not:
+
+- a broad non-Euclidean platform packet
+- a renderer or viewer-shell packet
+- a generalized topology packet
+- a generic notation or replay packet
+- a `MagicCube5D` widening packet
+
+## Source-backed basis
+
+Primary donor surfaces inspected:
+
+- `README.md`
+- `Magic120Cell/workFiles/magic120Cell.h`
+- `Magic120Cell/workFiles/magic120Cell.cpp`
+- `Magic120Cell/workFiles/settings.cpp`
+- `Magic120Cell/workFiles/loader.cpp`
+- `geometryLib/puzzle/twist.h`
+- `geometryLib/puzzle/twistHistory.cpp`
+
+## Narrowing decision
+
+The strongest bounded donor seam is not the host shell or the broad non-Euclidean interaction
+surface. `MagicTile` already owns the generalized tiling/topology lane and `Hyperspeedcube`
+already owns the primary retained runtime anchor.
+
+The smallest stronger `Magic120Cell` seam is:
+
+- dedicated `120-cell` family puzzle-type modes
+- symmetry-scoped visibility groups
+- center-cell recentering and bounded view-rotation guard rails
+- family-specific file-header, scramble-cache, and twist-history persistence
+
+The first bounded implementation packet should therefore land only:
+
+- a first-party `Magic120Cell` reference bundle with:
+  - source package references
+  - one runtime-profile contract
+  - one persistence boundary
+  - one attribution boundary
+- runtime-library accessors for that bounded reference bundle
+- focused automation around:
+  - runtime profile
+  - persistence boundary
+  - package checklist
+
+## Explicit deferrals
+
+Still deferred after this control pass:
+
+- WinForms/OpenGL host-shell ownership
+- broad renderer ownership
+- generic non-Euclidean topology ownership
+- generic notation or replay ownership
+- broad interaction-shell widening
+- `MagicCube5D` deepening
+
+## Queue effect
+
+This preparation packet authorizes one bounded permissive implementation packet:
+
+- `Phase 6R-I` dedicated `Magic120Cell` family runtime-profile and persistence boundary
+
+After that packet, move the queue head to:
+
+- source-backed `Phase 6R-J` `roice3/MagicCube5D` preparation/control pass
+
+Keep the legal and routing guards visible:
+
+- `roice3/Magic120Cell`
+  - keep the landed slice bounded to the dedicated `120-cell` family lane rather than a broad
+    non-Euclidean shell
+- `roice3/MagicCube5D`
+  - keep the code-license judgment anchored on the mirrored `MIT` repo while preserving the older
+    zip only as provenance context

docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md

@@ -80,10 +80,11 @@ Use these as the current governing docs:
 
 The next bounded move is now:
 
-1. source-backed `Phase 6R-I` `roice3/Magic120Cell` preparation/control pass
-2. keep it after the landed `whisper.cpp`, `faster-whisper`, `piper`, and `coqui-ai/TTS` bounded slices
-3. narrow the first widening slice to one bounded hyper-engine topology/runtime-anchor seam
-4. keep later non-Euclidean shell widening separate from the code-license judgment and retained row ownership
+1. source-backed `Phase 6R-J` `roice3/MagicCube5D` preparation/control pass
+2. keep it after the landed `Magic120Cell` family runtime-profile and persistence slice
+3. narrow the first widening slice to one bounded `5D` runtime/persistence seam
+4. keep later renderer, shell, and broad platform widening separate from the code-license judgment
+   and retained row ownership
 
 ## Memory-specific sequencing rule
 

docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md

@@ -173,6 +173,7 @@ 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. |
+| 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. |
 | Transform-aware macro remapping and broad non-Euclidean interaction shell | Deep-source grounded retained | `MagicTile` retained remainder | Not yet promoted into live broad interaction ownership. |
 
 ### 7. Speech input and voice sidecars

docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md

@@ -83,7 +83,11 @@ Canonical discovery surfaces for roadmap interpretation:
   landed in current code
 - `coqui-ai/TTS` remains partially incorporated; downloadable voice/model review, bundled voice
   asset shipping, voice conversion, and broad voice-platform ownership stay deferred
-- the current next bounded move is a source-backed `Phase 6R-I` `roice3/Magic120Cell`
+- the bounded permissive `Phase 6R-I` `roice3/Magic120Cell` family runtime-profile and
+  persistence packet is now landed in current code
+- `roice3/Magic120Cell` remains partially incorporated; host shell, renderer, generic topology,
+  and broad interaction-shell widening stay deferred
+- the current next bounded move is a source-backed `Phase 6R-J` `roice3/MagicCube5D`
   preparation/control pass for one bounded hyper-engine widening slice
 - the repo-row implementation queue is now live from that `Phase 6R-A` entry point rather than
   waiting on another first-party packet
@@ -112,8 +116,8 @@ Donor-strength rule:
 - route difficulty changes how retained value may enter the product, not whether it may win technically
 
 - current shallow-eval set: `75` repos
-- currently verified live/implemented in checked Unreal surfaces: `31`
-- permissive live lanes: `20`
+- currently verified live/implemented in checked Unreal surfaces: `32`
+- permissive live lanes: `21`
 - boundary-sensitive live lanes: `6`
 - restrictive live lanes: `5`
 - the restrictive landed lanes are:
@@ -143,17 +147,17 @@ Current routing truth:
 
 - retained rows total: `68`
 - discarded from the active retained set: `3`
-- active non-live implementation-board rows: `35`
+- 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-I`
-`roice3/Magic120Cell` preparation/control pass.
+The next bounded move is a source-backed `Phase 6R-J`
+`roice3/MagicCube5D` preparation/control pass.
 
 Queue interpretation after that packet:
 
 - then continue with the retained repo-row queue
 - highest current repo-row queue pressure sits in:
-  - the bounded speech-input / voice sidecar set
+  - the retained hyper-engine deepening set
 - `HactarCE/Hyperspeedcube` remains a partially landed row rather than a closed row:
   - landed:
     - puzzle catalog contract
@@ -168,6 +172,16 @@ Queue interpretation after that packet:
     - ordered face-observation contract
   - still deferred:
     - webcam UI shell
+- `roice3/Magic120Cell` remains a partially landed row rather than a closed row:
+  - landed:
+    - dedicated `120-cell` family runtime profile
+    - symmetry and visibility taxonomy
+    - persistence and twist-history boundary
+  - still deferred:
+    - host shell
+    - renderer ownership
+    - generic topology ownership
+    - broad interaction-shell widening
     - bundled-font redistribution and multilingual solve shell
     - multi-face reconstruction / correction / explanation
 - `vivaansinghvi07/rubix-cube-solver` remains a partially landed row rather than a closed row:
@@ -247,7 +261,7 @@ Queue interpretation after that packet:
     - viseme / gesture runtime integration
     - broad assistant-platform scope
 - the next queue shape is now:
-  - `roice3/Magic120Cell`
+  - `roice3/MagicCube5D`
 - 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: