Land MagicTile Phase 7C behavior proof

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

@@ -7141,6 +7141,18 @@ bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingStateBridgeContract(
 	);
 }
 
+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingNativeBehaviorProofContract(
+	const FString& ContractId,
+	FHyperTwistTrainingTilingNativeBehaviorProofContract& OutContract
+)
+{
+	return UHyperTwistTrainingTilingLibrary::TryGetNativeBehaviorProofContractById(
+		GetBundledTilingReferenceBundle(),
+		ContractId,
+		OutContract
+	);
+}
+
 TArray<FString> UHyperTwistTrainingRuntimeLibrary::ParseBundledTilingSharedScrambleNotation(
 	const FString& SharedScrambleNotation
 )
@@ -7189,6 +7201,54 @@ bool UHyperTwistTrainingRuntimeLibrary::TryDeserializeBundledTilingStateEnvelope
 	);
 }
 
+FHyperTwistTrainingTilingNativeBehaviorProofProbe
+UHyperTwistTrainingRuntimeLibrary::CreateBundledTilingNativeBehaviorProofProbe(
+	const FHyperTwistTrainingTilingStateEnvelope& StateEnvelope,
+	const FString& SelectedCellId,
+	const TArray<FString>& CandidateTwistIds,
+	const FString& CommitTwistId,
+	const FString& PreviewTransformToken
+)
+{
+	return UHyperTwistTrainingTilingLibrary::CreateNativeBehaviorProofProbe(
+		StateEnvelope,
+		SelectedCellId,
+		CandidateTwistIds,
+		CommitTwistId,
+		PreviewTransformToken
+	);
+}
+
+FHyperTwistTrainingTilingNativeBehaviorProofProbe
+UHyperTwistTrainingRuntimeLibrary::NormalizeBundledTilingNativeBehaviorProofProbe(
+	const FHyperTwistTrainingTilingNativeBehaviorProofProbe& Probe
+)
+{
+	return UHyperTwistTrainingTilingLibrary::NormalizeNativeBehaviorProofProbe(Probe);
+}
+
+bool UHyperTwistTrainingRuntimeLibrary::TrySerializeBundledTilingNativeBehaviorProofProbeToJson(
+	const FHyperTwistTrainingTilingNativeBehaviorProofProbe& Probe,
+	FString& OutJson
+)
+{
+	return UHyperTwistTrainingTilingLibrary::TrySerializeNativeBehaviorProofProbeToJson(
+		Probe,
+		OutJson
+	);
+}
+
+bool UHyperTwistTrainingRuntimeLibrary::TryDeserializeBundledTilingNativeBehaviorProofProbeFromJson(
+	const FString& Json,
+	FHyperTwistTrainingTilingNativeBehaviorProofProbe& OutProbe
+)
+{
+	return UHyperTwistTrainingTilingLibrary::TryDeserializeNativeBehaviorProofProbeFromJson(
+		Json,
+		OutProbe
+	);
+}
+
 FString UHyperTwistTrainingRuntimeLibrary::BuildBundledTilingPackageChecklistTsv()
 {
 	return UHyperTwistTrainingTilingLibrary::BuildPackageChecklistTsv(

UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp

@@ -126,6 +126,37 @@ namespace HyperTwistTrainingTilingLibraryInternal
 
 		return Result;
 	}
+
+	TArray<FString> NormalizeUniqueNonEmptyStrings(const TArray<FString>& Values)
+	{
+		TArray<FString> Result;
+		Result.Reserve(Values.Num());
+		for (const FString& Value : Values)
+		{
+			const FString NormalizedValue = Value.TrimStartAndEnd();
+			if (NormalizedValue.IsEmpty())
+			{
+				continue;
+			}
+
+			bool bAlreadyPresent = false;
+			for (const FString& ExistingValue : Result)
+			{
+				if (ExistingValue.Equals(NormalizedValue, ESearchCase::CaseSensitive))
+				{
+					bAlreadyPresent = true;
+					break;
+				}
+			}
+
+			if (!bAlreadyPresent)
+			{
+				Result.Add(NormalizedValue);
+			}
+		}
+
+		return Result;
+	}
 }
 
 FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingTilingLibrary::BuildBundledTilingReferenceBundle()
@@ -141,6 +172,7 @@ FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingTilingLibrary::Build
 	Bundle.PrimaryMacroPersistenceBoundaryId = TEXT("tiling-macro-persistence-boundary");
 	Bundle.PrimaryHostDecisionId = TEXT("tiling-embedded-browser-host");
 	Bundle.PrimaryStateBridgeContractId = TEXT("tiling-browser-state-bridge");
+	Bundle.PrimaryNativeBehaviorProofContractId = TEXT("tiling-native-behavior-proof");
 
 	const TArray<FString> CommonNoticeActions =
 	{
@@ -660,6 +692,52 @@ FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingTilingLibrary::Build
 	);
 	Bundle.StateBridgeContracts = {StateBridgeContract};
 
+	FHyperTwistTrainingTilingNativeBehaviorProofContract NativeBehaviorProofContract;
+	NativeBehaviorProofContract.ContractId = TEXT("tiling-native-behavior-proof");
+	NativeBehaviorProofContract.HostDecisionId = HostDecision.DecisionId;
+	NativeBehaviorProofContract.StateBridgeContractId = StateBridgeContract.ContractId;
+	NativeBehaviorProofContract.Title = TEXT("Tiling native behavior proof contract");
+	NativeBehaviorProofContract.Summary = TEXT("First-party HyperTwist proof contract for modeling selected-cell focus, candidate-twist disambiguation, preview, commit or cancel, and timer continuity natively before any non-Euclidean renderer port is justified.");
+	NativeBehaviorProofContract.RequiredPackageIds =
+	{
+		TEXT("package/magictile-puzzle-core"),
+		TEXT("package/magictile-tiling-geometry"),
+		TEXT("package/magictile-macro"),
+		TEXT("package/magictile-twist-handler")
+	};
+	NativeBehaviorProofContract.NativeInputSurfaceTags =
+	{
+		TEXT("selected cell focus"),
+		TEXT("candidate twist disambiguation"),
+		TEXT("drag-to-twist intent"),
+		TEXT("commit or cancel interaction")
+	};
+	NativeBehaviorProofContract.NativeStateSurfaceTags =
+	{
+		TEXT("native preview transform token"),
+		TEXT("native twist commit token"),
+		TEXT("timer continuity during native interaction"),
+		TEXT("shared scramble token reuse")
+	};
+	NativeBehaviorProofContract.ReusedBridgeSurfaceTags =
+	{
+		TEXT("transport-neutral state envelope"),
+		TEXT("puzzle-state pass-through"),
+		TEXT("projection payload pass-through"),
+		TEXT("shared training live timer state")
+	};
+	NativeBehaviorProofContract.ExplicitExclusions =
+	{
+		TEXT("whole renderer port ownership"),
+		TEXT("whole WinForms/OpenTK host shell ownership"),
+		TEXT("generic non-Euclidean runtime-base replacement")
+	};
+	NativeBehaviorProofContract.SourceAttribution = MakeFirstPartyAttribution(
+		TEXT("tiling/native-behavior-proof"),
+		TEXT("Defines the smallest first-party native MagicTile behavior proof above the landed browser bridge so later renderer-port work can stay decision-gated rather than assumption-driven.")
+	);
+	Bundle.NativeBehaviorProofContracts = {NativeBehaviorProofContract};
+
 	return Bundle;
 }
 
@@ -796,6 +874,26 @@ bool UHyperTwistTrainingTilingLibrary::TryGetStateBridgeContractById(
 	return false;
 }
 
+bool UHyperTwistTrainingTilingLibrary::TryGetNativeBehaviorProofContractById(
+	const FHyperTwistTrainingTilingReferenceBundle& Bundle,
+	const FString& ContractId,
+	FHyperTwistTrainingTilingNativeBehaviorProofContract& OutContract
+)
+{
+	for (const FHyperTwistTrainingTilingNativeBehaviorProofContract& Contract :
+		Bundle.NativeBehaviorProofContracts)
+	{
+		if (Contract.ContractId == ContractId)
+		{
+			OutContract = Contract;
+			return true;
+		}
+	}
+
+	OutContract = FHyperTwistTrainingTilingNativeBehaviorProofContract();
+	return false;
+}
+
 TArray<FString> UHyperTwistTrainingTilingLibrary::ParseSharedScrambleNotation(
 	const FString& SharedScrambleNotation
 )
@@ -970,6 +1068,214 @@ bool UHyperTwistTrainingTilingLibrary::TryDeserializeStateEnvelopeFromJson(
 	return OutStateEnvelope.IsStructurallyValid();
 }
 
+FHyperTwistTrainingTilingNativeBehaviorProofProbe
+UHyperTwistTrainingTilingLibrary::CreateNativeBehaviorProofProbe(
+	const FHyperTwistTrainingTilingStateEnvelope& StateEnvelope,
+	const FString& SelectedCellId,
+	const TArray<FString>& CandidateTwistIds,
+	const FString& CommitTwistId,
+	const FString& PreviewTransformToken
+)
+{
+	const FHyperTwistTrainingTilingStateEnvelope NormalizedStateEnvelope =
+		NormalizeStateEnvelope(StateEnvelope);
+
+	FHyperTwistTrainingTilingNativeBehaviorProofProbe Probe;
+	Probe.ProofContractId = TEXT("tiling-native-behavior-proof");
+	Probe.HostDecisionId = NormalizedStateEnvelope.HostDecisionId;
+	Probe.StateBridgeContractId = NormalizedStateEnvelope.BridgeContractId;
+	Probe.SessionId = NormalizedStateEnvelope.SessionId;
+	Probe.PuzzleDefinitionId = NormalizedStateEnvelope.PuzzleDefinitionId;
+	Probe.SelectedCellId = SelectedCellId;
+	Probe.CandidateTwistIds = CandidateTwistIds;
+	Probe.PreviewTransformToken = PreviewTransformToken;
+	Probe.CommitTwistId = CommitTwistId;
+	Probe.SharedScrambleTokens = NormalizedStateEnvelope.SharedScrambleTokens;
+	Probe.SharedScrambleNotation = NormalizedStateEnvelope.SharedScrambleNotation;
+	Probe.PuzzleState = NormalizedStateEnvelope.PuzzleState;
+	Probe.TimerState = NormalizedStateEnvelope.TimerState;
+	Probe.CapturedAtUtc = NormalizedStateEnvelope.CapturedAtUtc;
+	return NormalizeNativeBehaviorProofProbe(Probe);
+}
+
+FHyperTwistTrainingTilingNativeBehaviorProofProbe
+UHyperTwistTrainingTilingLibrary::NormalizeNativeBehaviorProofProbe(
+	const FHyperTwistTrainingTilingNativeBehaviorProofProbe& Probe
+)
+{
+	FHyperTwistTrainingTilingNativeBehaviorProofProbe NormalizedProbe = Probe;
+
+	if (NormalizedProbe.SchemaVersion.IsEmpty())
+	{
+		NormalizedProbe.SchemaVersion = TEXT("ht-tiling-native-behavior-proof/v1");
+	}
+
+	if (NormalizedProbe.ProofContractId.IsEmpty())
+	{
+		NormalizedProbe.ProofContractId = TEXT("tiling-native-behavior-proof");
+	}
+
+	if (NormalizedProbe.HostDecisionId.IsEmpty())
+	{
+		NormalizedProbe.HostDecisionId = TEXT("tiling-embedded-browser-host");
+	}
+
+	if (NormalizedProbe.StateBridgeContractId.IsEmpty())
+	{
+		NormalizedProbe.StateBridgeContractId = TEXT("tiling-browser-state-bridge");
+	}
+
+	if (NormalizedProbe.PuzzleDefinitionId.IsEmpty()
+		&& NormalizedProbe.PuzzleState.Definition.IsStructurallyValid())
+	{
+		NormalizedProbe.PuzzleDefinitionId =
+			NormalizedProbe.PuzzleState.Definition.PuzzleId;
+	}
+
+	if (NormalizedProbe.SessionId.IsEmpty()
+		&& !NormalizedProbe.PuzzleState.SourceSessionId.IsEmpty())
+	{
+		NormalizedProbe.SessionId = NormalizedProbe.PuzzleState.SourceSessionId;
+	}
+
+	NormalizedProbe.SelectedCellId = NormalizedProbe.SelectedCellId.TrimStartAndEnd();
+	NormalizedProbe.CandidateTwistIds =
+		HyperTwistTrainingTilingLibraryInternal::NormalizeUniqueNonEmptyStrings(
+			NormalizedProbe.CandidateTwistIds
+		);
+	NormalizedProbe.CommitTwistId = NormalizedProbe.CommitTwistId.TrimStartAndEnd();
+
+	if (NormalizedProbe.CommitTwistId.IsEmpty()
+		&& NormalizedProbe.CandidateTwistIds.Num() > 0)
+	{
+		NormalizedProbe.CommitTwistId = NormalizedProbe.CandidateTwistIds[0];
+	}
+
+	NormalizedProbe.PreviewTransformToken =
+		NormalizedProbe.PreviewTransformToken.TrimStartAndEnd();
+	if (NormalizedProbe.PreviewTransformToken.IsEmpty()
+		&& !NormalizedProbe.SelectedCellId.IsEmpty()
+		&& !NormalizedProbe.CommitTwistId.IsEmpty())
+	{
+		NormalizedProbe.PreviewTransformToken = FString::Printf(
+			TEXT("native-preview::%s::%s"),
+			*NormalizedProbe.SelectedCellId,
+			*NormalizedProbe.CommitTwistId
+		);
+	}
+
+	if (NormalizedProbe.SharedScrambleTokens.Num() == 0
+		&& !NormalizedProbe.SharedScrambleNotation.IsEmpty())
+	{
+		NormalizedProbe.SharedScrambleTokens =
+			ParseSharedScrambleNotation(NormalizedProbe.SharedScrambleNotation);
+	}
+	else
+	{
+		NormalizedProbe.SharedScrambleTokens =
+			HyperTwistTrainingTilingLibraryInternal::NormalizeScrambleTokens(
+				NormalizedProbe.SharedScrambleTokens
+			);
+	}
+
+	NormalizedProbe.SharedScrambleNotation =
+		BuildSharedScrambleNotation(NormalizedProbe.SharedScrambleTokens);
+
+	if (NormalizedProbe.SourceRuntime.IsEmpty())
+	{
+		NormalizedProbe.SourceRuntime = TEXT("native-unreal-proof");
+	}
+
+	if (NormalizedProbe.CapturedAtUtc.IsEmpty())
+	{
+		if (!NormalizedProbe.PuzzleState.CapturedAtUtc.IsEmpty())
+		{
+			NormalizedProbe.CapturedAtUtc = NormalizedProbe.PuzzleState.CapturedAtUtc;
+		}
+		else if (!NormalizedProbe.TimerState.LastUpdatedAtUtc.IsEmpty())
+		{
+			NormalizedProbe.CapturedAtUtc = NormalizedProbe.TimerState.LastUpdatedAtUtc;
+		}
+		else if (!NormalizedProbe.TimerState.StartedAtUtc.IsEmpty())
+		{
+			NormalizedProbe.CapturedAtUtc = NormalizedProbe.TimerState.StartedAtUtc;
+		}
+	}
+
+	if (NormalizedProbe.TimerState.TrainingSessionId.IsEmpty()
+		&& !NormalizedProbe.SessionId.IsEmpty())
+	{
+		NormalizedProbe.TimerState.TrainingSessionId = NormalizedProbe.SessionId;
+	}
+
+	if (NormalizedProbe.TimerState.DeckId.IsEmpty())
+	{
+		NormalizedProbe.TimerState.DeckId = TEXT("Tiling");
+	}
+
+	if (NormalizedProbe.TimerState.CaseId.IsEmpty())
+	{
+		NormalizedProbe.TimerState.CaseId = NormalizedProbe.PuzzleDefinitionId;
+	}
+
+	if (NormalizedProbe.TimerState.LastUpdatedAtUtc.IsEmpty())
+	{
+		NormalizedProbe.TimerState.LastUpdatedAtUtc = NormalizedProbe.CapturedAtUtc;
+	}
+
+	if (NormalizedProbe.TimerState.DisplayedElapsedMs < NormalizedProbe.TimerState.SolveElapsedMs)
+	{
+		NormalizedProbe.TimerState.DisplayedElapsedMs =
+			NormalizedProbe.TimerState.SolveElapsedMs;
+	}
+
+	if (NormalizedProbe.PuzzleState.SourceSessionId.IsEmpty()
+		&& !NormalizedProbe.SessionId.IsEmpty())
+	{
+		NormalizedProbe.PuzzleState.SourceSessionId = NormalizedProbe.SessionId;
+	}
+
+	if (NormalizedProbe.PuzzleState.CapturedAtUtc.IsEmpty())
+	{
+		NormalizedProbe.PuzzleState.CapturedAtUtc = NormalizedProbe.CapturedAtUtc;
+	}
+
+	return NormalizedProbe;
+}
+
+bool UHyperTwistTrainingTilingLibrary::TrySerializeNativeBehaviorProofProbeToJson(
+	const FHyperTwistTrainingTilingNativeBehaviorProofProbe& Probe,
+	FString& OutJson
+)
+{
+	const FHyperTwistTrainingTilingNativeBehaviorProofProbe NormalizedProbe =
+		NormalizeNativeBehaviorProofProbe(Probe);
+	return NormalizedProbe.IsStructurallyValid()
+		&& HyperTwistTrainingTilingLibraryInternal::SerializeStructToJson(
+			NormalizedProbe,
+			OutJson
+		);
+}
+
+bool UHyperTwistTrainingTilingLibrary::TryDeserializeNativeBehaviorProofProbeFromJson(
+	const FString& Json,
+	FHyperTwistTrainingTilingNativeBehaviorProofProbe& OutProbe
+)
+{
+	OutProbe = FHyperTwistTrainingTilingNativeBehaviorProofProbe();
+
+	FHyperTwistTrainingTilingNativeBehaviorProofProbe ParsedProbe;
+	if (!HyperTwistTrainingTilingLibraryInternal::DeserializeStructFromJson(
+			Json,
+			ParsedProbe))
+	{
+		return false;
+	}
+
+	OutProbe = NormalizeNativeBehaviorProofProbe(ParsedProbe);
+	return OutProbe.IsStructurallyValid();
+}
+
 FString UHyperTwistTrainingTilingLibrary::BuildPackageChecklistTsv(
 	const FHyperTwistTrainingTilingReferenceBundle& Bundle
 )

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

@@ -3351,6 +3351,12 @@ public:
 		FHyperTwistTrainingTilingStateBridgeContract& OutContract
 	);
 
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryGetBundledTilingNativeBehaviorProofContract(
+		const FString& ContractId,
+		FHyperTwistTrainingTilingNativeBehaviorProofContract& OutContract
+	);
+
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
 	static TArray<FString> ParseBundledTilingSharedScrambleNotation(
 		const FString& SharedScrambleNotation
@@ -3378,6 +3384,34 @@ public:
 		FHyperTwistTrainingTilingStateEnvelope& OutStateEnvelope
 	);
 
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
+	static FHyperTwistTrainingTilingNativeBehaviorProofProbe
+	CreateBundledTilingNativeBehaviorProofProbe(
+		const FHyperTwistTrainingTilingStateEnvelope& StateEnvelope,
+		const FString& SelectedCellId,
+		const TArray<FString>& CandidateTwistIds,
+		const FString& CommitTwistId,
+		const FString& PreviewTransformToken
+	);
+
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
+	static FHyperTwistTrainingTilingNativeBehaviorProofProbe
+	NormalizeBundledTilingNativeBehaviorProofProbe(
+		const FHyperTwistTrainingTilingNativeBehaviorProofProbe& Probe
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TrySerializeBundledTilingNativeBehaviorProofProbeToJson(
+		const FHyperTwistTrainingTilingNativeBehaviorProofProbe& Probe,
+		FString& OutJson
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryDeserializeBundledTilingNativeBehaviorProofProbeFromJson(
+		const FString& Json,
+		FHyperTwistTrainingTilingNativeBehaviorProofProbe& OutProbe
+	);
+
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
 	static FString BuildBundledTilingPackageChecklistTsv();
 

UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h

@@ -321,6 +321,52 @@ struct FHyperTwistTrainingTilingStateBridgeContract
 	}
 };
 
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingTilingNativeBehaviorProofContract
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString ContractId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString HostDecisionId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString StateBridgeContractId;
+
+	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> NativeInputSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> NativeStateSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ReusedBridgeSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ExplicitExclusions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingSourceAttribution SourceAttribution;
+
+	bool IsStructurallyValid() const
+	{
+		return !ContractId.IsEmpty() && !HostDecisionId.IsEmpty()
+			&& !StateBridgeContractId.IsEmpty() && !Title.IsEmpty()
+			&& SourceAttribution.IsStructurallyValid();
+	}
+};
+
 USTRUCT(BlueprintType)
 struct FHyperTwistTrainingTilingStateEnvelope
 {
@@ -375,6 +421,70 @@ struct FHyperTwistTrainingTilingStateEnvelope
 	}
 };
 
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingTilingNativeBehaviorProofProbe
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString SchemaVersion = TEXT("ht-tiling-native-behavior-proof/v1");
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString ProofContractId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString HostDecisionId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString StateBridgeContractId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString SessionId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PuzzleDefinitionId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString SelectedCellId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> CandidateTwistIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PreviewTransformToken;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString CommitTwistId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> SharedScrambleTokens;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString SharedScrambleNotation;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistPuzzleState PuzzleState;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingLiveTimerState TimerState;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString SourceRuntime = TEXT("native-unreal-proof");
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString CapturedAtUtc;
+
+	bool IsStructurallyValid() const
+	{
+		return !SchemaVersion.IsEmpty() && !ProofContractId.IsEmpty()
+			&& !HostDecisionId.IsEmpty() && !StateBridgeContractId.IsEmpty()
+			&& !SessionId.IsEmpty() && !PuzzleDefinitionId.IsEmpty()
+			&& !SelectedCellId.IsEmpty() && CandidateTwistIds.Num() > 0
+			&& !PreviewTransformToken.IsEmpty() && !CommitTwistId.IsEmpty()
+			&& PuzzleState.IsStructurallyValid() && TimerState.IsStructurallyValid();
+	}
+};
+
 USTRUCT(BlueprintType)
 struct FHyperTwistTrainingTilingReferenceBundle
 {
@@ -404,6 +514,9 @@ struct FHyperTwistTrainingTilingReferenceBundle
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	FString PrimaryStateBridgeContractId;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryNativeBehaviorProofContractId;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	TArray<FHyperTwistTrainingTilingPackageReference> PackageReferences;
 
@@ -428,14 +541,19 @@ struct FHyperTwistTrainingTilingReferenceBundle
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	TArray<FHyperTwistTrainingTilingStateBridgeContract> StateBridgeContracts;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingTilingNativeBehaviorProofContract> NativeBehaviorProofContracts;
+
 	bool IsStructurallyValid() const
 	{
 		return !PrimaryTopologyContractId.IsEmpty() && !PrimaryLoaderBoundaryId.IsEmpty()
 			&& !PrimaryAttributionBoundaryId.IsEmpty() && !PrimaryMacroRemappingContractId.IsEmpty()
 			&& !PrimaryMacroPersistenceBoundaryId.IsEmpty() && !PrimaryHostDecisionId.IsEmpty()
-			&& !PrimaryStateBridgeContractId.IsEmpty() && PackageReferences.Num() > 0
+			&& !PrimaryStateBridgeContractId.IsEmpty() && !PrimaryNativeBehaviorProofContractId.IsEmpty()
+			&& PackageReferences.Num() > 0
 			&& MacroRemappingContracts.Num() > 0 && MacroPersistenceBoundaries.Num() > 0
-			&& HostDecisions.Num() > 0 && StateBridgeContracts.Num() > 0;
+			&& HostDecisions.Num() > 0 && StateBridgeContracts.Num() > 0
+			&& NativeBehaviorProofContracts.Num() > 0;
 	}
 };
 
@@ -497,6 +615,13 @@ public:
 		FHyperTwistTrainingTilingStateBridgeContract& OutContract
 	);
 
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryGetNativeBehaviorProofContractById(
+		const FHyperTwistTrainingTilingReferenceBundle& Bundle,
+		const FString& ContractId,
+		FHyperTwistTrainingTilingNativeBehaviorProofContract& OutContract
+	);
+
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
 	static TArray<FString> ParseSharedScrambleNotation(const FString& SharedScrambleNotation);
 
@@ -520,6 +645,32 @@ public:
 		FHyperTwistTrainingTilingStateEnvelope& OutStateEnvelope
 	);
 
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
+	static FHyperTwistTrainingTilingNativeBehaviorProofProbe CreateNativeBehaviorProofProbe(
+		const FHyperTwistTrainingTilingStateEnvelope& StateEnvelope,
+		const FString& SelectedCellId,
+		const TArray<FString>& CandidateTwistIds,
+		const FString& CommitTwistId,
+		const FString& PreviewTransformToken
+	);
+
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
+	static FHyperTwistTrainingTilingNativeBehaviorProofProbe NormalizeNativeBehaviorProofProbe(
+		const FHyperTwistTrainingTilingNativeBehaviorProofProbe& Probe
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TrySerializeNativeBehaviorProofProbeToJson(
+		const FHyperTwistTrainingTilingNativeBehaviorProofProbe& Probe,
+		FString& OutJson
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryDeserializeNativeBehaviorProofProbeFromJson(
+		const FString& Json,
+		FHyperTwistTrainingTilingNativeBehaviorProofProbe& OutProbe
+	);
+
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
 	static FString BuildPackageChecklistTsv(const FHyperTwistTrainingTilingReferenceBundle& Bundle);
 };

UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase7CNativeBehaviorProofTest.cpp

@@ -0,0 +1,237 @@
+// Copyright HyperTwist, Inc. All Rights Reserved.
+
+#include "Misc/AutomationTest.h"
+
+#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h"
+
+#if WITH_AUTOMATION_TESTS
+
+namespace HyperTwistMagicTilePhase7CTestInternal
+{
+	FHyperTwistTrainingTilingStateEnvelope MakeSampleStateEnvelope()
+	{
+		FHyperTwistTrainingTilingStateEnvelope Envelope;
+		Envelope.SessionId = TEXT("tiling-native-proof-session-001");
+		Envelope.SharedScrambleNotation = TEXT("  R,  U\nm(3,4)\u2019 ; reflect-x  ");
+
+		FHyperTwistPuzzleState& PuzzleState = Envelope.PuzzleState;
+		PuzzleState.Definition.PuzzleId = TEXT("tiling/{5,4}/native-proof");
+		PuzzleState.Definition.PuzzleFamily = EHyperTwistPuzzleFamily::Tiling;
+		PuzzleState.Definition.Dimension = 2;
+		PuzzleState.Definition.DefinitionVersion = TEXT("2026.06");
+		PuzzleState.Definition.NotationProfile = TEXT("magictile-shared");
+		PuzzleState.StateEncoding.EncodingProfile = TEXT("tiling-cells/v1");
+		PuzzleState.StateEncoding.PayloadJson =
+			TEXT("{\"cells\":[\"c17\",\"c18\"],\"selection\":\"face-17\"}");
+		PuzzleState.CapturedAtUtc = TEXT("2026-06-19T04:05:00Z");
+
+		FHyperTwistTrainingLiveTimerState& TimerState = Envelope.TimerState;
+		TimerState.Phase = EHyperTwistTrainingLiveTimerPhase::Solving;
+		TimerState.SolveElapsedMs = 24680;
+		TimerState.DisplayedElapsedMs = 1000;
+
+		return Envelope;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagicTilePhase7CNativeBehaviorProofContractTest,
+	"HyperTwist.FirstParty.MagicTile.Phase7C.NativeBehaviorProofContract",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagicTilePhase7CNativeBehaviorProofContractTest::RunTest(
+	const FString& Parameters
+)
+{
+	const FHyperTwistTrainingTilingReferenceBundle Bundle =
+		UHyperTwistTrainingRuntimeLibrary::GetBundledTilingReferenceBundle();
+
+	TestTrue(
+		TEXT("The tiling bundle must stay structurally valid after the native behavior proof lands."),
+		Bundle.IsStructurallyValid()
+	);
+	TestEqual(
+		TEXT("The primary native behavior proof contract id must stay stable."),
+		Bundle.PrimaryNativeBehaviorProofContractId,
+		TEXT("tiling-native-behavior-proof")
+	);
+
+	FHyperTwistTrainingTilingNativeBehaviorProofContract Contract;
+	TestTrue(
+		TEXT("The native behavior proof contract must resolve from the runtime library."),
+		UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingNativeBehaviorProofContract(
+			Bundle.PrimaryNativeBehaviorProofContractId,
+			Contract
+		)
+	);
+	TestEqual(
+		TEXT("The native behavior proof contract must stay anchored to the browser host decision."),
+		Contract.HostDecisionId,
+		Bundle.PrimaryHostDecisionId
+	);
+	TestEqual(
+		TEXT("The native behavior proof contract must stay anchored to the browser state bridge contract."),
+		Contract.StateBridgeContractId,
+		Bundle.PrimaryStateBridgeContractId
+	);
+	TestTrue(
+		TEXT("The native behavior proof contract must preserve selected-cell focus."),
+		Contract.NativeInputSurfaceTags.Contains(TEXT("selected cell focus"))
+	);
+	TestTrue(
+		TEXT("The native behavior proof contract must preserve candidate-twist disambiguation."),
+		Contract.NativeInputSurfaceTags.Contains(TEXT("candidate twist disambiguation"))
+	);
+	TestTrue(
+		TEXT("The native behavior proof contract must preserve a native preview token."),
+		Contract.NativeStateSurfaceTags.Contains(TEXT("native preview transform token"))
+	);
+	TestTrue(
+		TEXT("The native behavior proof contract must explicitly exclude full renderer-port ownership."),
+		Contract.ExplicitExclusions.Contains(TEXT("whole renderer port ownership"))
+	);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagicTilePhase7CNativeBehaviorProofProbeCreationTest,
+	"HyperTwist.FirstParty.MagicTile.Phase7C.NativeBehaviorProofProbeCreation",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagicTilePhase7CNativeBehaviorProofProbeCreationTest::RunTest(
+	const FString& Parameters
+)
+{
+	const FHyperTwistTrainingTilingNativeBehaviorProofProbe Probe =
+		UHyperTwistTrainingRuntimeLibrary::CreateBundledTilingNativeBehaviorProofProbe(
+			HyperTwistMagicTilePhase7CTestInternal::MakeSampleStateEnvelope(),
+			TEXT("  cell-17  "),
+			{TEXT(" twist/left "), TEXT(""), TEXT("twist/right"), TEXT("twist/left")},
+			FString(),
+			FString()
+		);
+
+	TestTrue(
+		TEXT("The created native behavior proof probe must be structurally valid."),
+		Probe.IsStructurallyValid()
+	);
+	TestEqual(
+		TEXT("The proof probe must keep the canonical contract id."),
+		Probe.ProofContractId,
+		TEXT("tiling-native-behavior-proof")
+	);
+	TestEqual(
+		TEXT("The proof probe must stay anchored to the browser-state bridge id."),
+		Probe.StateBridgeContractId,
+		TEXT("tiling-browser-state-bridge")
+	);
+	TestEqual(
+		TEXT("The proof probe must normalize the selected cell id."),
+		Probe.SelectedCellId,
+		TEXT("cell-17")
+	);
+	TestEqual(
+		TEXT("The proof probe must de-duplicate candidate twist ids."),
+		Probe.CandidateTwistIds.Num(),
+		2
+	);
+	if (Probe.CandidateTwistIds.Num() != 2)
+	{
+		return false;
+	}
+	TestEqual(
+		TEXT("The proof probe must preserve the first normalized candidate twist id."),
+		Probe.CandidateTwistIds[0],
+		TEXT("twist/left")
+	);
+	TestEqual(
+		TEXT("The proof probe must preserve the second normalized candidate twist id."),
+		Probe.CandidateTwistIds[1],
+		TEXT("twist/right")
+	);
+	TestEqual(
+		TEXT("The proof probe must normalize the shared scramble notation."),
+		Probe.SharedScrambleNotation,
+		TEXT("R U m(3,4)' reflect-x")
+	);
+	TestEqual(
+		TEXT("The proof probe must repair the timer session id from the proof session."),
+		Probe.TimerState.TrainingSessionId,
+		Probe.SessionId
+	);
+	TestEqual(
+		TEXT("The proof probe must align displayed elapsed time with solve elapsed time."),
+		Probe.TimerState.DisplayedElapsedMs,
+		24680
+	);
+	TestEqual(
+		TEXT("The proof probe must derive the preview token from the selected cell and committed twist when needed."),
+		Probe.PreviewTransformToken,
+		TEXT("native-preview::cell-17::twist/left")
+	);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagicTilePhase7CNativeBehaviorProofProbeSerializationTest,
+	"HyperTwist.FirstParty.MagicTile.Phase7C.NativeBehaviorProofProbeSerialization",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagicTilePhase7CNativeBehaviorProofProbeSerializationTest::RunTest(
+	const FString& Parameters
+)
+{
+	const FHyperTwistTrainingTilingNativeBehaviorProofProbe Probe =
+		UHyperTwistTrainingRuntimeLibrary::CreateBundledTilingNativeBehaviorProofProbe(
+			HyperTwistMagicTilePhase7CTestInternal::MakeSampleStateEnvelope(),
+			TEXT("cell-99"),
+			{TEXT("twist/up")},
+			TEXT("twist/up"),
+			TEXT("preview-token-99")
+		);
+
+	FString Json;
+	TestTrue(
+		TEXT("The native behavior proof probe must serialize to JSON."),
+		UHyperTwistTrainingRuntimeLibrary::TrySerializeBundledTilingNativeBehaviorProofProbeToJson(
+			Probe,
+			Json
+		)
+	);
+	TestFalse(TEXT("The serialized proof probe JSON must not be empty."), Json.IsEmpty());
+
+	FHyperTwistTrainingTilingNativeBehaviorProofProbe RoundTrippedProbe;
+	TestTrue(
+		TEXT("The native behavior proof probe must deserialize from JSON."),
+		UHyperTwistTrainingRuntimeLibrary::TryDeserializeBundledTilingNativeBehaviorProofProbeFromJson(
+			Json,
+			RoundTrippedProbe
+		)
+	);
+	TestEqual(
+		TEXT("The round-tripped proof probe must preserve the puzzle definition id."),
+		RoundTrippedProbe.PuzzleDefinitionId,
+		TEXT("tiling/{5,4}/native-proof")
+	);
+	TestEqual(
+		TEXT("The round-tripped proof probe must preserve the committed twist id."),
+		RoundTrippedProbe.CommitTwistId,
+		TEXT("twist/up")
+	);
+	TestEqual(
+		TEXT("The round-tripped proof probe must preserve the preview token."),
+		RoundTrippedProbe.PreviewTransformToken,
+		TEXT("preview-token-99")
+	);
+	TestEqual(
+		TEXT("The round-tripped proof probe must preserve the native source runtime."),
+		RoundTrippedProbe.SourceRuntime,
+		TEXT("native-unreal-proof")
+	);
+	return true;
+}
+
+#endif

docs/arch/HYPERTWIST_PHASE7C_MAGICTILE_NATIVE_BEHAVIOR_PROOF_IMPLEMENTATION_PACKET_2026-06-19.md

@@ -0,0 +1,111 @@
+# HyperTwist Phase 7C MagicTile native behavior proof implementation packet
+
+Created on `2026-06-19`
+
+## Status
+
+- first-party HyperTwist packet
+- bounded first-party `Phase 7C` implementation slice
+
+## Purpose
+
+This packet lands the smallest first-party native `MagicTile` behavior proof
+that can inform later renderer-port decisions without widening into renderer or
+legacy host ownership.
+
+The landed slice is:
+
+- a first-party native behavior proof contract above the landed `Phase 7B`
+  tiling bridge
+- a proof probe for selected-cell focus, candidate-twist disambiguation,
+  preview, commit, and timer continuity
+
+It is not:
+
+- a renderer port
+- a `WinForms` / `OpenTK` host-shell packet
+- a generic non-Euclidean runtime-base replacement
+
+## Current authority basis
+
+This implementation packet stands on:
+
+- `docs/arch/HYPERTWIST_PHASE7C_MAGICTILE_NATIVE_BEHAVIOR_PROOF_PREPARATION_PACKET_2026-06-19.md`
+- `docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md`
+- `docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md`
+
+## Landed scope
+
+The current code now owns a bounded first-party `Phase 7C` proof seam through:
+
+- new tiling contract and probe types for:
+  - native behavior proof contract
+  - native behavior proof probe
+- expanded bundled tiling reference-bundle construction in:
+  - `UHyperTwistTrainingTilingLibrary`
+- new runtime-library accessors for:
+  - bundled native behavior proof contract lookup
+  - bundled proof-probe creation
+  - bundled proof-probe normalization
+  - bundled proof-probe JSON serialization/deserialization
+- focused automation coverage in:
+  - `HyperTwistMagicTilePhase7CNativeBehaviorProofTest.cpp`
+
+The proof seam stays explicitly anchored to:
+
+- the landed embedded-browser host decision
+- the landed tiling browser-state bridge
+- first-party puzzle-state and timer continuity rather than renderer ownership
+
+## Why this is still intentionally bounded
+
+This packet proves the missing native behavior seam, but it still defers:
+
+- native spherical or hyperbolic renderer ownership
+- `WinForms` / `OpenTK` host-shell ownership
+- generic non-Euclidean runtime replacement
+
+## Validation
+
+Build validation:
+
+- `Build.bat UnrealHyperTwistEditor Win64 Development -Project='C:\HyperTwist_worktrees\phase10validate\UnrealHyperTwist\UnrealHyperTwist.uproject' -WaitMutex -NoHotReloadFromIDE -NoUba`
+- result on `2026-06-19`: `Result: Succeeded` with UnrealBuildTool `Total execution time: 3069.89 seconds` on isolated worktree `C:\HyperTwist_worktrees\phase10validate`
+
+Focused automation validation:
+
+- `Automation RunTests HyperTwist.FirstParty.MagicTile.Phase7C`
+- result on `2026-06-19`: exported `Saved\AutomationReports\Phase7C-NativeBehaviorProof` with all `3` `HyperTwist.FirstParty.MagicTile.Phase7C.*` tests passing
+
+Regression automation validation:
+
+- `Automation RunTests HyperTwist.FirstParty.MagicTile`
+- `Automation RunTests HyperTwist.Browser`
+- `Automation RunTests HyperTwist.Permissive.MagicTile`
+- result on `2026-06-19`: exported `Saved\AutomationReports\Phase7-MagicTile` with all `7` `HyperTwist.FirstParty.MagicTile.*` tests passing, `Saved\AutomationReports\Browser-Rerun` with all `4` `HyperTwist.Browser.*` tests passing, and `Saved\AutomationReports\Phase7-Permissive-MagicTile-Rerun` with all `6` `HyperTwist.Permissive.MagicTile.*` tests passing
+
+Expected covered tests:
+
+- `NativeBehaviorProofContract`
+- `NativeBehaviorProofProbeCreation`
+- `NativeBehaviorProofProbeSerialization`
+
+## Queue effect
+
+This packet consumes the bounded first-party `Phase 7C` proof slice.
+
+`MagicTile` still remains partially incorporated:
+
+- landed now:
+  - tiling topology and geometry-family contract
+  - transform-aware macro remapping contract
+  - embedded-browser host decision
+  - tiling browser-state bridge
+  - native behavior proof contract and proof probe
+- still deferred:
+  - renderer-port ownership
+  - legacy host-shell ownership
+  - broad non-Euclidean runtime replacement
+
+The next renderer-facing move, if ever reopened, must be a separate explicit
+decision packet rather than an automatic continuation.

docs/arch/HYPERTWIST_PHASE7C_MAGICTILE_NATIVE_BEHAVIOR_PROOF_PREPARATION_PACKET_2026-06-19.md

@@ -0,0 +1,106 @@
+# HyperTwist Phase 7C MagicTile native behavior proof preparation packet
+
+Created on `2026-06-19`
+
+## Status
+
+- first-party HyperTwist packet
+- bounded first-party `Phase 7C` preparation/control slice
+
+## Purpose
+
+This packet defines the next substantive but still bounded `MagicTile` move
+after the landed `Phase 7A` embedded-browser host decision, `Phase 7B`
+browser-state bridge, and the optional full-browser client spec packet.
+
+The granted slice is:
+
+- a first-party native behavior proof above the landed `MagicTile`
+  browser-state bridge
+- selected-cell focus, candidate-twist disambiguation, preview, commit or
+  cancel, and timer-continuity proof surfaces
+- explicit reuse of transport-neutral bridge/state vocabulary where that
+  vocabulary already exists in first-party terms
+
+It is not:
+
+- a native spherical or hyperbolic renderer port
+- a `WinForms` / `OpenTK` host-shell transplant
+- a generic non-Euclidean runtime-base replacement
+- a browser-host reversal away from the landed embedded-browser posture
+
+## Current authority basis
+
+This preparation packet stands on:
+
+- `docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md`
+- `docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md`
+- `docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md`
+- `docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md`
+- `docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md`
+
+The key routing facts are:
+
+- `Phase 7A` already chose the embedded browser/CEF shell as the live
+  `MagicTile` host posture
+- `Phase 7B` already established first-party tiling state envelopes, shared
+  scramble normalization, and unified timer continuity across Unreal and the
+  browser shell
+- the real remaining pre-renderer gap is not another browser decision; it is a
+  first-party native interaction/behavior proof that can later justify or deny
+  a renderer port on evidence
+
+## Granted family
+
+The bounded `Phase 7C` slice may land:
+
+1. a first-party native behavior proof contract
+2. a first-party proof probe derived from the landed tiling state envelope
+3. runtime-library accessors and JSON round-trip support for that proof probe
+4. focused automation proving the proof seam without claiming renderer
+   ownership
+
+The packet must stay out of:
+
+- renderer port ownership
+- legacy host-shell ownership
+- broad non-Euclidean shell replacement
+- generic replay/runtime widening outside the landed bridge seam
+
+## Proposed implementation shape
+
+Land the proof through:
+
+- a bounded native-behavior proof contract anchored to the landed browser host
+  decision and browser-state bridge
+- a compact proof probe carrying:
+  - selected cell
+  - candidate twist ids
+  - preview token
+  - committed twist id
+  - shared scramble tokens/notation
+  - puzzle-state and timer continuity
+- normalization/serialization helpers so later renderer work can target a
+  stable first-party proof seam
+- focused `Phase 7C` automation over the proof contract and proof probe
+
+## Validation target
+
+Validate with:
+
+- Windows Unreal build:
+  - `Build.bat UnrealHyperTwistEditor Win64 Development -Project='C:\HyperTwist_worktrees\phase10validate\UnrealHyperTwist\UnrealHyperTwist.uproject' -WaitMutex -NoHotReloadFromIDE -NoUba`
+- focused automation:
+  - `Automation RunTests HyperTwist.FirstParty.MagicTile.Phase7C`
+- regression guard:
+  - `HyperTwist.FirstParty.MagicTile.Phase7A`
+  - `HyperTwist.FirstParty.MagicTile.Phase7B`
+  - `HyperTwist.Browser.*`
+
+## Queue effect
+
+If this packet lands cleanly:
+
+- the native behavior question becomes evidence-backed instead of speculative
+- later renderer-port widening remains a separate explicit decision packet
+  rather than an automatic follow-on

docs/arch/HYPERTWIST_PHASE8B_OPTIONAL_FULL_BROWSER_CLIENT_HTTP_BACKEND_PREPARATION_PACKET_2026-06-19.md

@@ -0,0 +1,148 @@
+# HyperTwist Phase 8B optional full-browser client / Unreal backend preparation packet
+
+Created on `2026-06-19`
+
+## Status
+
+- first-party HyperTwist packet
+- spec-only `Phase 8B` preparation/control slice
+- no implementation widening is granted by this packet
+- adjacent follow-on status on `2026-06-19`: the separately bounded `Phase 7C`
+  native behavior proof is now landed in
+  `docs/arch/HYPERTWIST_PHASE7C_MAGICTILE_NATIVE_BEHAVIOR_PROOF_IMPLEMENTATION_PACKET_2026-06-19.md`
+
+## Purpose
+
+This packet freezes the optional full-browser client branch after the already
+landed embedded browser runtime and browser-state bridge posture.
+
+The granted slice is:
+
+- define the optional full-browser client path as a bounded first-party
+  architecture branch
+- clarify authority boundaries between a browser-owned client shell and the
+  Unreal runtime backend
+- define transport, persistence, and packaging seams without claiming live
+  implementation
+
+It is not:
+
+- a replacement for the current embedded browser/CEF shipping posture
+- a donor-backed browser rewrite
+- a browser-first authority inversion over puzzle or training state
+- a native `MagicTile` renderer port
+- a renderer-port widening packet of any kind
+
+## Current authority basis
+
+This preparation packet stands on:
+
+- `docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md`
+- `docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md`
+- `docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md`
+- `docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md`
+- `docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md`
+
+The accepted routing facts are:
+
+- the current landed browser posture is still the embedded browser/CEF shell
+  inside Unreal through `UHyperTwistBrowserWidget` and the authoritative
+  `Content/Browser/index.html` surface
+- Unreal remains the runtime center and the authority for puzzle state,
+  training state, timer continuity, replay, and persistence
+- the unchecked roadmap branch for a full browser client exists, but it had not
+  yet been frozen into a bounded first-party architecture seam
+- the next substantive `MagicTile` widening after this spec packet must still
+  be a narrow native behavior proof before any renderer-port widening
+
+## Required result
+
+The required outcome of this packet is a stable spec-only branch that later
+implementation can follow without reopening host or authority ambiguity.
+
+That branch must state:
+
+- the browser client may own rendering, local presentation, and input
+  composition
+- Unreal remains the authoritative backend over puzzle, session, timer,
+  replay, and persistence state
+- request/response plus optional push/update transport boundaries are explicit
+  first-party seams rather than implicit browser-shell inheritance
+- the branch stays optional and deferred rather than becoming the new default
+  shipping posture
+
+## Granted family
+
+The bounded `Phase 8B` spec slice may land:
+
+1. a first-party browser-client session boundary
+2. a first-party Unreal-backend request/response contract for catalog, launch,
+   state query, action submission, replay, and persistence surfaces
+3. a first-party optional push/update seam for timer, replay, and training
+   state continuity
+4. transport-neutral envelope reuse guidance where the landed embedded browser
+   bridge already expresses compatible state
+5. explicit deferrals for packaging, auth, offline, and renderer ownership
+
+The packet must stay out of:
+
+- live browser-client implementation
+- public-hosting or remote-auth rollout
+- offline-first conflict-resolution design
+- browser-owned solver or training authority
+- native `MagicTile` renderer ownership or porting
+
+## Proposed implementation shape
+
+Later implementation, if separately approved, should stay bounded by this
+shape:
+
+- Unreal remains the authoritative runtime host
+- the optional browser client talks to Unreal through explicit first-party
+  backend surfaces rather than direct donor/runtime coupling
+- the browser client may reuse the landed browser-state bridge vocabulary where
+  that vocabulary is transport-neutral and still owned in first-party terms
+- browser-specific rendering, layout, and interaction composition stay on the
+  client side
+- session creation, puzzle execution, timer state, replay persistence, and
+  training-state truth stay on the Unreal side
+
+## Deferred neighboring families
+
+This packet keeps the following families deferred:
+
+- current shipping-posture replacement
+- generic browser-first runtime inversion
+- native `MagicTile` behavior or renderer ownership
+- broader non-Euclidean host-shell replacement
+- renderer-port widening before a native behavior proof exists
+
+## Acceptance criteria
+
+- the packet records that the optional full-browser client path is now a
+  bounded first-party spec branch rather than a loose roadmap note
+- the packet records that the landed embedded browser/CEF shell remains the
+  current shipping posture
+- the packet records that Unreal stays authoritative for runtime state through
+  explicit backend seams
+- the packet records that the next substantive bounded `MagicTile` move is a
+  native behavior-proof spike before any renderer-port widening
+
+## Validation target
+
+Validate this packet through doc-consistency only:
+
+1. roadmap, architecture, feature-registry, and kickoff notes must agree on
+   the optional full-browser client branch
+2. no Unreal build or code validation claim is required for this spec-only
+   packet
+3. no implementation or packaging proof may be claimed from this document
+
+## Queue effect
+
+If this packet lands cleanly:
+
+- the optional full-browser client branch becomes explicitly defined and safely
+  deferrable
+- the immediately adjacent `MagicTile` native behavior-proof spike can land as a
+  separate packet before any renderer-port widening

docs/ops/HYPERTWIST_COMPREHENSIVE_RECONSTRUCTION_ROADMAP_2026-06-10.md

@@ -393,6 +393,13 @@ Closure read:
 - [x] Unified timer across puzzle types
 - Landed bridge on `2026-06-19`: first-party tiling state envelopes and bridge contracts now connect the runtime library, browser widget, and browser bridge surfaces with shared scramble normalization plus unified training-timer continuity
 
+### 7C — Native Behavior Proof Spike
+- [x] Land a first-party native behavior proof for selected-cell focus, candidate-twist disambiguation, preview, commit or cancel, and timer continuity above the landed browser host decision and state bridge
+- [x] Reuse the landed tiling state-envelope vocabulary only where it remains transport-neutral and first-party owned
+- [x] Keep renderer-port ownership, `WinForms` / `OpenTK` host-shell ownership, and generic non-Euclidean runtime-base replacement explicitly deferred
+- Landed proof on `2026-06-19`: current code now adds a bounded tiling native-behavior proof contract and proof probe, threads them through the training tiling/runtime libraries with normalization plus JSON round-trip helpers, and closes the pre-renderer interaction gap without claiming renderer ownership
+- Validation evidence on `2026-06-19`: the primary reverse-SSH `localhost:22022` lane rebuilt isolated worktree `C:\HyperTwist_worktrees\phase10validate` with `Result: Succeeded` and UnrealBuildTool `Total execution time: 3069.89 seconds`, then exported green automation reports for `7` `HyperTwist.FirstParty.MagicTile.*` tests at `Saved\AutomationReports\Phase7-MagicTile`, `4` `HyperTwist.Browser.*` tests at `Saved\AutomationReports\Browser-Rerun`, and `6` `HyperTwist.Permissive.MagicTile.*` tests at `Saved\AutomationReports\Phase7-Permissive-MagicTile-Rerun`
+
 **Estimated actions:** 80–150
 **Estimated time:** 1–2 weeks
 
@@ -411,6 +418,7 @@ Closure read:
 - [x] Bridge UE cube state to browser via embedded Unreal bridge object plus JavaScript `postMessage` fallback
 - [x] Browser shell surfaces adapter, analytics, viewer, and native-sidecar request flows while UE retains native input, game state, and puzzle logic ownership
 - [ ] Alternative: full browser client with HTTP API to UE backend
+- Spec-only branch frozen on `2026-06-19`: `docs/arch/HYPERTWIST_PHASE8B_OPTIONAL_FULL_BROWSER_CLIENT_HTTP_BACKEND_PREPARATION_PACKET_2026-06-19.md` now defines this as an optional first-party browser-owned client above explicit Unreal backend authority; the currently landed shipping posture remains the embedded browser/CEF shell, the adjacent `Phase 7C` native behavior proof is now landed separately, and any later full-browser-client implementation stays deferred
 
 **Estimated actions:** 50–80
 **Estimated time:** 3–5 days
@@ -471,7 +479,7 @@ Routing correction:
 - [x] The packaged validation helper now smoke-boots every cooked classic-cube training map by default instead of depending on a remembered second manual launch
 - [x] Validation evidence on `2026-06-13`: primary reverse-SSH `localhost:22022` lane, isolated Windows worktree `C:\HyperTwist_worktrees\phase10validate`, commandlet-safe `UnrealMCP` and `UnrealMCPChong` guards landed for unattended cook, `BuildCookRun` `ExitCode=0` with `BuildCookRun time: 164.59 s`, archive output in `C:\HyperTwist_worktrees\phase10validate_packaged`, packaged smoke boot on `L_HyperTwist_ClassicTraining`, and explicit packaged smoke boot on `/Game/HyperTwistTraining/Maps/L_HyperTwist_FollowAlongTraining`
 - [x] Repair validation evidence on `2026-06-13`: the maintained helper itself was re-run on the same primary reverse-SSH `localhost:22022` lane against isolated worktree `C:\HyperTwist_worktrees\phase10validate`, wrote archive output to `C:\HyperTwist_worktrees\phase10validate_packaged_repair`, completed `BuildCookRun` with `ExitCode=0` and `BuildCookRun time: 116.89 s`, then default-smoke-launched both `/Game/HyperTwistTraining/Maps/L_HyperTwist_ClassicTraining` and `/Game/HyperTwistTraining/Maps/L_HyperTwist_FollowAlongTraining` without a manual second launch step
-- [x] Focused validation evidence on `2026-06-19`: the same primary reverse-SSH `localhost:22022` lane rebuilt isolated worktree `C:\HyperTwist_worktrees\phase10validate` with `Result: Succeeded` in `1573.31` seconds, revalidated the warning-clean continuation in `34.65` seconds, and then passed `4` `HyperTwist.Browser.*` tests, `4` `HyperTwist.FirstParty.MagicTile.Phase7*` tests, and `6` `HyperTwist.Permissive.MagicTile.*` tests
+- [x] Focused validation evidence on `2026-06-19`: the same primary reverse-SSH `localhost:22022` lane rebuilt isolated worktree `C:\HyperTwist_worktrees\phase10validate` with `Result: Succeeded` and UnrealBuildTool `Total execution time: 3069.89 seconds`, then exported green automation reports for `7` `HyperTwist.FirstParty.MagicTile.*` tests, `4` `HyperTwist.Browser.*` tests, and `6` `HyperTwist.Permissive.MagicTile.*` tests while closing the bounded `Phase 7C` native behavior proof slice
 - [x] Continuation evidence on `2026-06-13`: after a prior aborted broad tar sync corrupted remote `HyperTwistWhisperCppPhase6RESpeechTranscriptContractTest.cpp`, the primary reverse-SSH `localhost:22022` lane hash-matched the changed slice files back into `C:\HyperTwist_worktrees\phase10validate`, completed the canonical `Build.bat` pass with `Result: Succeeded` and UnrealBuildTool `Total execution time: 2029.78 seconds`, passed all `7` `HyperTwist.Integration.ClassicCube` tests including `ReplayPersistenceNormalization`, `LeaderboardNormalization`, and `LeaderboardStatusLine`, refreshed `Phase 10B` coverage through green `Rotation`, `Solve`, `RandomClassicStates`, `Timer.Accuracy`, and `ClassicCubeMoveParsing` commandlet passes, and revalidated the maintained package helper in `-SkipBuild` mode with `BuildCookRun time: 69.16 s`, archive output in `C:\HyperTwist_worktrees\phase10validate_packaged_phase10b10c9a9c`, aggregate JSON at `validation\classic-cube-package-validation-report.json`, per-map smoke JSON under `validation\smoke\`, and successful smoke boots on both classic-cube training maps
 - [x] Hardening slice on `2026-06-18`: replay normalization now repairs missing replay/session ids, duplicate event ids, out-of-order sequences, and monotonic timestamp drift before persisted packets are reused; leaderboard normalization now repairs schema-light entries before best-time/status resolution; and the maintained package helper now fails fast on missing smoke JSON, unparseable smoke JSON, non-`passed` smoke results, or unexpected `mapUrl` drift.
 - [x] Validation evidence on `2026-06-18`: the same primary reverse-SSH `localhost:22022` lane rebuilt isolated worktree `C:\HyperTwist_worktrees\phase10validate` after the Phase 10B truthfulness correction and solver-wrapper distribution hardening, then refreshed `20` relevant tests with `0` failures in `134.97 s`, including green `HyperTwist.Simulation.ClassicCube.Behavior.*`, `HyperTwist.Solver.*`, `HyperTwist.Training.Timer.Accuracy`, `HyperTwist.Speech.Transcription.ClassicCubeMoveParsing`, and all `11` `HyperTwist.Integration.ClassicCube.*` cases. `RandomClassicStates` now records runtime facelet export, exact inverse-scramble verification, and runtime round-trip solve instead of pretending the native solver lane is a bounded 100-state benchmark; `Timer.Accuracy` remained green with environment-only unresolved `vision`/`speech` hostname warnings in the unattended lane.

docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md

@@ -127,9 +127,20 @@ Use these as the current governing docs:
 - `C:\HyperTwist\docs\ops\HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md`
 - `C:\HyperTwist\docs\ops\HYPERTWIST_REVERSE_SSH_WINDOWS_BUILD_LANE_VERIFICATION_2026-06-01.md`
 
-## Immediate next step
+## Current forward queue note on `2026-06-19`
 
-The next bounded move is now:
+- the optional full-browser client path is now frozen as a spec-only first-party branch in:
+  - [HYPERTWIST_PHASE8B_OPTIONAL_FULL_BROWSER_CLIENT_HTTP_BACKEND_PREPARATION_PACKET_2026-06-19.md](C:/HyperTwist/docs/arch/HYPERTWIST_PHASE8B_OPTIONAL_FULL_BROWSER_CLIENT_HTTP_BACKEND_PREPARATION_PACKET_2026-06-19.md:1)
+- current shipping/browser posture remains the landed embedded browser/CEF shell
+- `MagicTile` `Phase 7C` is now landed separately through the bundled tiling native-behavior
+  proof contract/probe seam, runtime-library proof helpers, and focused Windows validation on
+  isolated worktree `C:\HyperTwist_worktrees\phase10validate`
+- any later renderer-port widening remains a separate explicit decision and stays deferred
+
+## Historical landed continuity chain
+
+This retained list is historical continuity context rather than the active `MagicTile`
+forward queue.
 
 1. the bounded permissive `Phase 6R-K` `HactarCE/Hyperspeedcube` notation and replay-log
    serialization implementation packet is now landed in current code
@@ -1416,9 +1427,18 @@ The next bounded move is now:
 528. keep the prokeimenon-and-alleluia guard visible:
     - keep prokeimenon-state ledgers and ongoing-state alleluia scoped to bounded runtime evidence prokeimenon continuity
     - do not widen them into prokeimenon-state platforms, ongoing alleluia systems, generic dashboards, or release authority
+529. the retained structural `Phase J` ladder above is now historical-only validation lineage after
+    landed `Phase 10A`
+    - preserve it as deprecated disabled build-history ballast rather than current live validation authority
+    - route present validation truth through landed `Phase 10B` behavior coverage, landed `Phase 10C`
+      integration coverage, and later focused Windows-backed proof instead
+    - treat older `docs/arch/HYPERTWIST_PHASEJ_*` "next deliberate roadmap marker" wording as
+      historical-at-the-time context rather than current next-move guidance
 71. 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
+    - when returning to substantive `MagicTile` widening, make the next bounded proof target a
+      native behavior spike before any renderer-port widening
 
 ## Memory-specific sequencing rule
 

docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md

@@ -88,6 +88,37 @@ Keep bounded:
 - Python for sidecar inference/service orchestration when still practical
 - TypeScript/web only for thin adjunct surfaces
 
+## Browser delivery boundary
+
+Current shipping browser posture remains the landed embedded browser/CEF shell
+inside Unreal through `UHyperTwistBrowserWidget` and the authoritative
+`Content/Browser/index.html` surface.
+
+The optional full-browser client path now exists only as a spec-defined
+first-party branch:
+
+- the browser client may own rendering, local presentation, and input
+  composition
+- Unreal remains authoritative for puzzle state, training session state,
+  timer continuity, replay, and persistence through explicit backend seams
+- request/response plus optional push/update transport stay first-party
+  boundaries rather than implicit browser-shell inheritance
+- the landed browser-state bridge should be reused only where its vocabulary is
+  transport-neutral and still owned in first-party terms
+- this is not current shipping posture, not a general browser-first rewrite,
+  and not permission to widen into native `MagicTile` renderer-port work
+
+Canonical spec note:
+
+- `C:\HyperTwist\docs\arch\HYPERTWIST_PHASE8B_OPTIONAL_FULL_BROWSER_CLIENT_HTTP_BACKEND_PREPARATION_PACKET_2026-06-19.md`
+
+The narrow first-party `MagicTile` native behavior proof is now landed as the
+pre-renderer decision gate through the bundled tiling native-behavior proof
+contract/probe seam in the training tiling/runtime libraries.
+
+Any later native `MagicTile` renderer-port widening remains a separate explicit
+decision beyond that now-landed `Phase 7C` proof seam.
+
 ## Canonical product lanes
 
 ### 1. Physical cube pipeline

docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md

@@ -145,6 +145,7 @@ Do not collapse those three tiers into one undifferentiated "features" voice.
 | Analytics/reporting surfaces | Implemented now | landed analytics/reporting packets | Reporting is real, but bounded to accepted retained slices. |
 | Rewritten training analytics and report reference grounding | Implemented now | `apache/echarts` retained permissive lane + first-party current code | Current live `Training Analytics` reference side includes four rewritten first-party targets grounded in retained `apache/echarts`: session outcome and progress reporting, analytics data-view and export, timing-trend history and overview interaction, and the optional richer explainer or sidecar boundary. This does not displace the landed `Phase 3R-C` first-party analytics/reporting owner or elevate `ecomfe/echarts-gl` and `ecomfe/zrender` beyond support-only sidecars. |
 | Browser/spatial/media adjunct surfaces | Implemented now | landed `three.js`, `react-three-fiber`, `xr`, `model-viewer`, `remotion` packets | These are implemented bounded families, and the current Phase 1 browser-runtime landing now includes a first-party authoritative `Content/Browser/index.html` shell, bundled-runtime upgrade path, committed clean-checkout plain-JS fallback runtime, and embedded `UHyperTwistBrowserWidget` bridge. This still is not proof of unlimited browser-shell parity. |
+| Optional full-browser client path above Unreal backend authority | Deep-source grounded retained | landed first-party `Phase 8B` preparation packet | This branch is now defined only as a spec-only first-party option: a browser-owned rendering and input shell may sit above explicit Unreal backend seams while Unreal remains authoritative for puzzle, training, timer, replay, and persistence state. The landed embedded browser/CEF shell remains the current shipping posture, and this branch stays separate from any native `MagicTile` behavior or renderer widening. |
 | Rewritten browser spatial scene and renderer reference grounding | Implemented now | `mrdoob/three.js` retained permissive lane + first-party current code | Current live `Browser 3D and XR Support` reference side includes one rewritten first-party target grounded in retained `mrdoob/three.js`: the browser spatial scene and renderer contract. This does not displace the landed `Phase 3R-F` first-party browser spatial owner trio or absorb the adjacent `react-three-fiber` renderer-bridge and `xr` session slices. |
 | Rewritten React-side browser renderer and event-bridge grounding | Implemented now | `pmndrs/react-three-fiber` retained permissive lane + first-party current code | Current live `Browser 3D and XR Support` reference side includes one rewritten first-party target grounded in retained `react-three-fiber`: the React scene renderer and event bridge. This does not displace the landed `Phase 3R-F` first-party browser spatial owner trio or absorb the adjacent `three.js` scene substrate and `xr` session slices. |
 | Rewritten browser XR session and immersive-interaction grounding | Implemented now | `pmndrs/xr` retained permissive lane + first-party current code | Current live `Browser 3D and XR Support` reference side includes one rewritten first-party target grounded in retained `pmndrs/xr`: the browser XR session and immersive interaction contract. This does not displace the landed `Phase 3R-F` first-party browser spatial owner trio or absorb the adjacent `three.js` scene substrate and `react-three-fiber` renderer-bridge slices. |
@@ -268,6 +269,7 @@ repo.
 | 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. |
 | Embedded browser host decision for non-Euclidean tiling | Implemented now | landed first-party `MagicTile` `Phase 7A` | Current bounded `MagicTile` host posture routes live non-Euclidean interaction through the already-landed embedded browser/CEF shell with retained `three.js` and `react-three-fiber`, while native spherical/hyperbolic renderer ownership and the legacy `WinForms` / `OpenTK` host shell remain deferred. |
 | Tiling browser state bridge, shared scramble normalization, and unified timer transport | Implemented now | landed first-party `MagicTile` `Phase 7B` | First-party tiling state envelopes, bridge-contract descriptors, browser widget/bridge decoding, scramble normalization, and training-timer continuity are live above the embedded-browser host posture without reopening generic runtime-base replacement. |
+| Native MagicTile behavior proof contract and probe | Implemented now | landed first-party `MagicTile` `Phase 7C` | First-party native behavior proof contract/probe now carry selected-cell focus, candidate-twist disambiguation, preview token, commit or cancel semantics, and timer continuity above the landed browser host/bridge seam without claiming renderer-port or legacy host ownership. |
 | 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 `120-cell` symmetry-aware focus view profiles | Implemented now | landed `Magic120Cell` `Phase 6R-AL` | Current bounded settings-derived projection, symmetry preset, logical-visibility, per-cell visibility, and center-cell focus posture are live above the landed dedicated `120-cell` runtime-profile seam without widening into renderer, host-shell, or generic topology ownership. |
 | Dedicated `5D` family runtime profile and persistence boundary | Implemented now | landed `MagicCube5D` packet | Current bounded family-specific widening is live beneath the retained `Hyperspeedcube` runtime anchor. |
@@ -277,7 +279,7 @@ repo.
 | Higher-dimensional explicit dedicated-host seam | Implemented now | landed `Phase 6C` host-surface continuation packet | First-party current code then recorded the preferred dedicated-family `Magic120Cell` / `MagicCube5D` host-map targets in an explicit higher-dimensional host-surface catalog while the slice still kept the shared training map as the interim effective runtime fallback, mirrored that resolved host seam through the training runtime library plus the panel/session caches, and threaded the host-surface id into the launch/view-context surfaces and generated-mode lineage. The primary reverse-SSH `localhost:22022` Windows lane rebuilt this widened slice on `2026-06-18` with `Result: Succeeded`, UnrealBuildTool `Total execution time: 2858.02 seconds`, and passed all `9` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests, including the new `HostCatalog`; that interim fallback is now superseded by the later dedicated-family map ownership continuation. |
 | Higher-dimensional executed runtime session surface | Implemented now | landed `Phase 6C` session-surface continuation packet | First-party current code now merges the higher-dimensional launch, host, and view-context seams into an explicit runtime-session catalog for `Magic120Cell` and `MagicCube5D`, mirrors that session surface through the training runtime library plus the panel/session caches, upgrades generated-mode deck lineage to record the resolved session surface, and applies the merged launch-plus-view selector posture at start time instead of only the narrower launch defaults. The primary reverse-SSH `localhost:22022` Windows lane rebuilt this widened slice on `2026-06-18` with `Result: Succeeded`, UnrealBuildTool `Total execution time: 3541.98 seconds`, and passed all `10` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests, including the new `SessionCatalog`; the longer `LaunchExecution` quiet interval of `573.84 seconds` remained known-good. |
 | Higher-dimensional dedicated-family interactive scene ownership | Implemented now | landed `Phase 6C` interactive-scene and dedicated-host continuation packet | First-party current code now promotes the higher-dimensional runtime-session seams into explicit `Magic120Cell` and `MagicCube5D` interactive-scene surfaces with family-owned runtime-state, projection, and persistence envelopes, replaces the shared-map bridge with dedicated-family training-map assets plus dedicated host/launch/view-context/session surfaces, exposes explicit scene-envelope decoders through the runtime library, batches default selector application so generated-mode launch execution no longer rebuilds repository views once per selector, and then defers repository-view projection across the internal generated-mode handoff itself so only the final launch state forces a view refresh. The primary reverse-SSH `localhost:22022` Windows lane rebuilt the dedicated-family ownership slice on `2026-06-18` with `Result: Succeeded`, UnrealBuildTool `Total execution time: 1648.33 seconds`; the later projection-deferral hardening rebuild completed in `400.77 seconds`, and the exported automation report passed all `11` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests with `totalDuration` `41.88494873046875`, `LaunchExecution` duration `41.53509521484375`, and the controller quiet interval reduced to `41.52 seconds`. The current recovery-proof continuation now also deterministically reauthors the dedicated-family maps through `scripts/hypertwist_author_higher_dimensional_training_maps.py`, records manifest-backed owned hashes in `docs/generated/higher_dimensional_training_maps/phase6c_dedicated_family_map_manifest.json`, preserves the optional `AHyperTwistHigherDimensionalTrainingShellActor` for manual/editor authoring while intentionally skipping it on the headless commandlet lane because that spawn path still crashes `UnrealEditor-Cmd`, and passes all `13` `HyperTwist.FirstParty.HigherDimensional.Phase6C` tests through pulled proof in `docs/generated/higher_dimensional_training_maps/phase6c_dedicated_map_ownership_automation_report.json`, including `DedicatedMapAuthoringManifest` and `DedicatedMapOwnedShell`. |
-| Broad non-Euclidean interaction shell and host ownership | Deep-source grounded retained | `MagicTile` retained remainder | Broad interaction-shell, WinForms/OpenTK host ownership, native spherical/hyperbolic renderer ownership before first-party behavior proof, and generic runtime replacement remain deferred after the landed `Phase 6R-T`, `Phase 7A`, and `Phase 7B` slices. |
+| Broad non-Euclidean interaction shell and host ownership | Deep-source grounded retained | `MagicTile` retained remainder | Broad interaction-shell, WinForms/OpenTK host ownership, native spherical/hyperbolic renderer ownership beyond the landed first-party native behavior proof, and generic runtime replacement remain deferred after the landed `Phase 6R-T`, `Phase 7A`, `Phase 7B`, and `Phase 7C` slices. |
 
 ### 7. Speech input and voice sidecars
 

docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md

@@ -38,6 +38,16 @@ Current consolidated milestone snapshot:
 - no further structural-only `Phase J` widening is the current deliberate runtime target; the
   remaining optional branches are the alternative full-browser client path and any later native
   `MagicTile` interaction/runtime replacement work
+- the optional full-browser client path is now frozen as a spec-only first-party branch in
+  `C:\HyperTwist\docs\arch\HYPERTWIST_PHASE8B_OPTIONAL_FULL_BROWSER_CLIENT_HTTP_BACKEND_PREPARATION_PACKET_2026-06-19.md`;
+  the landed embedded browser/CEF shell remains current shipping posture
+- `MagicTile` `Phase 7C` is now also closed through a first-party native behavior proof contract
+  and proof probe for selected-cell focus, candidate-twist disambiguation, preview, commit or
+  cancel, and timer continuity, validated on `2026-06-19` on isolated worktree
+  `C:\HyperTwist_worktrees\phase10validate`
+- the remaining optional `MagicTile` widening branches are any later full-browser-client
+  implementation and any later renderer-port/native interaction replacement work, not another
+  pre-renderer proof gap
 - Unreal C++ slices are not considered fully validated from symbol/doc/whitespace checks alone;
   the canonical Windows Unreal build doctrine now lives in
   `C:\HyperTwist\docs\ops\HYPERTWIST_UNREAL_BUILD_VALIDATION_REQUIREMENT_2026-06-01.md`
@@ -78,6 +88,11 @@ Current consolidated milestone snapshot:
   envelopes, browser bridge/widget transport, shared scramble normalization,
   and unified training-timer continuity, validated on `2026-06-19` on isolated
   worktree `C:\HyperTwist_worktrees\phase10validate`
+- `MagicTile` `Phase 7C` is now closed through a first-party native behavior
+  proof contract/probe seam above the landed browser host/bridge posture,
+  including proof-probe normalization plus JSON round-trip helpers and live
+  Windows validation on isolated worktree
+  `C:\HyperTwist_worktrees\phase10validate`
 - classic-cube `Phase 9A` replay recording is now closed through first-party
   runtime capture, `.json` replay persistence, local playback reconstruction,
   schema-light replay normalization across save/load/viewer import, and live
@@ -137,6 +152,11 @@ Current consolidated milestone snapshot:
   alternative full-browser client path and any later dedicated native
   `MagicTile` interaction/runtime replacement work rather than new
   structural-only `Phase J` growth
+- that alternative full-browser client branch is now frozen as a spec-only
+  first-party packet in
+  `C:\HyperTwist\docs\arch\HYPERTWIST_PHASE8B_OPTIONAL_FULL_BROWSER_CLIENT_HTTP_BACKEND_PREPARATION_PACKET_2026-06-19.md`,
+  while the next substantive bounded `MagicTile` move remains a native
+  behavior proof before any renderer-port widening
 
 - `2026-06-13`: `Phase 6C` entered the owned clean-room lane through a
   first-party higher-dimensional activation catalog that resolves canonical
@@ -353,6 +373,8 @@ Current consolidated milestone snapshot:
   landed in current code
 - the bounded first-party `Phase 7B` `MagicTile` browser state-bridge packet is now landed in
   current code
+- the bounded first-party `Phase 7C` `MagicTile` native behavior proof packet is now landed in
+  current code
 - `roice3/MagicTile` remains partially incorporated; broader non-Euclidean interaction,
   dedicated native renderer ownership, and legacy host-shell ownership stay deferred
 - the generic source-backed `Phase 6R-E` speech-input / voice sidecar control pass is now
@@ -765,9 +787,11 @@ Queue interpretation after those control passes:
     - embedded browser host decision
     - browser state-bridge contract
     - shared scramble normalization and unified timer transport
+    - native behavior proof contract and proof probe
   - still deferred:
     - broad non-Euclidean interaction shell
     - WinForms/OpenTK host shell
+    - dedicated native spherical/hyperbolic renderer ownership
     - native spherical/hyperbolic renderer port before first-party behavior proof
     - generic runtime-base replacement
 - `ggml-org/whisper.cpp` remains a partially landed row rather than a closed row:
@@ -1046,8 +1070,21 @@ Canonical scoping note:
 ## J — Validation and benchmarking
 Correctness, replay integrity, performance, and benchmark harnesses.
 
-The first deliberate HyperTwist-native validation and benchmarking milestone is
-now landed as:
+Retained historical note:
+
+- the enumerated `Phase J-*` ladder below preserves the earlier structural
+  validation packet lineage for build history and archival traceability
+- after landed `Phase 10A`, that structural ladder is no longer current live
+  validation authority and is preserved only as deprecated disabled ballast
+- live validation truth now stays with landed `Phase 10B` behavior coverage,
+  landed `Phase 10C` integration coverage, and later focused Windows-backed
+  proof packets
+- treat older `docs/arch/HYPERTWIST_PHASEJ_*` packet wording such as
+  "next deliberate roadmap marker" as historical-at-the-time context rather
+  than current expansion guidance
+
+The first deliberate HyperTwist-native validation and benchmarking milestone
+was landed as:
 
 - `Phase J-A` replay integrity and validation benchmark foundations
 - `Phase J-B` regression snapshots and cross-run benchmark deltas