Implement Phase 6R-L replay verification boundary

UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.cpp

@@ -65,9 +65,11 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun
 	using namespace HyperTwistTrainingHyperspeedcubeLibraryInternal;
 
 	FHyperTwistTrainingHyperspeedcubeReferenceBundle Bundle;
-	Bundle.ReferenceUtc = TEXT("2026-05-22T18:20:00Z");
+	Bundle.ReferenceUtc = TEXT("2026-05-22T21:25:00Z");
 	Bundle.PrimaryNotationContractId = TEXT("hyperspeedcube-notation-contract");
 	Bundle.PrimarySerializationBoundaryId = TEXT("hyperspeedcube-log-serialization-boundary");
+	Bundle.PrimaryReplayVerificationContractId = TEXT("hyperspeedcube-replay-verification-contract");
+	Bundle.PrimaryReplayVerificationBoundaryId = TEXT("hyperspeedcube-replay-verification-boundary");
 	Bundle.PrimaryAttributionBoundaryId = TEXT("hyperspeedcube-dual-license-attribution-boundary");
 
 	const TArray<FString> CommonNoticeActions =
@@ -201,6 +203,114 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun
 				TEXT("hyperspeedcube/app-log-adapter"),
 				TEXT("Preserves the bounded donor app save/load seam while keeping host dialogs, desktop shell, and broader runtime ownership outside HyperTwist product contract.")
 			)
+		),
+		MakePackageReference(
+			TEXT("package/hyperspeedcube-log-verifier"),
+			TEXT("crates/hyperpuzzle_log/src/verify.rs"),
+			TEXT("./crates/hyperpuzzle_log/src/verify.rs"),
+			TEXT("hyper-replay-verification-anchor"),
+			TEXT("direct dual-license donor"),
+			TEXT("Retained replay verification seam for scramble-seed validation, solved-state checks, randomness-beacon verification, timestamp verification, and verification error routing above the bounded HyperTwist replay contract."),
+			{
+				TEXT("full verification options"),
+				TEXT("quick verification options"),
+				TEXT("scramble seed verification"),
+				TEXT("solved-state verification"),
+				TEXT("randomness-beacon verification"),
+				TEXT("TSA completion timestamp verification")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("puzzle-definition DSL ownership"),
+				TEXT("whole puzzle-runtime ownership"),
+				TEXT("stats dashboard ownership"),
+				TEXT("host network-service ownership")
+			},
+			MakeAttribution(
+				TEXT("hyperspeedcube/log-verifier"),
+				TEXT("Preserves the retained replay-verification seam without promoting the donor network, shell, or analytics stack into first-party HyperTwist product truth.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/hyperspeedcube-verification-types"),
+			TEXT("crates/hyperspeedcube_cli_types/src/verification.rs"),
+			TEXT("./crates/hyperspeedcube_cli_types/src/verification.rs"),
+			TEXT("hyper-replay-verification-result-shape"),
+			TEXT("direct dual-license donor"),
+			TEXT("Retained solve-verification result shape for canonical puzzle id, solution STM, timestamp ranges, duration eligibility, and surfaced verification errors."),
+			{
+				TEXT("puzzle canonical id"),
+				TEXT("solution STM"),
+				TEXT("verified scramble range"),
+				TEXT("verified completion timestamp"),
+				TEXT("duration eligibility"),
+				TEXT("verification error list")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("broader stats-shape ownership"),
+				TEXT("leaderboard policy ownership"),
+				TEXT("generic analytics ownership")
+			},
+			MakeAttribution(
+				TEXT("hyperspeedcube/verification-types"),
+				TEXT("Preserves the retained verification result shape for the bounded replay-verification lane without treating it as HyperTwist's whole stats or leaderboard contract.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/hyperspeedcube-replay-simulation"),
+			TEXT("crates/hyperpuzzle_view/src/simulation/mod.rs"),
+			TEXT("./crates/hyperpuzzle_view/src/simulation/mod.rs"),
+			TEXT("hyper-replay-reconstruction-support"),
+			TEXT("direct dual-license donor"),
+			TEXT("Retained replay serialize/deserialize seam for grouped twist strings, replay-mode logs, interaction events, and session-end reconstruction beneath the bounded HyperTwist verification contract."),
+			{
+				TEXT("replay serialize"),
+				TEXT("replay deserialize"),
+				TEXT("grouped twist-string emission"),
+				TEXT("grouped twist parse"),
+				TEXT("replay-mode flag persistence"),
+				TEXT("session-end append on replay export")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("viewer shell ownership"),
+				TEXT("whole simulation-platform ownership"),
+				TEXT("desktop replay UI ownership")
+			},
+			MakeAttribution(
+				TEXT("hyperspeedcube/replay-simulation"),
+				TEXT("Preserves the retained replay reconstruction seam without promoting the donor viewer, simulation shell, or desktop replay UI into first-party HyperTwist product ownership.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/hyperspeedcube-replay-events"),
+			TEXT("crates/hyperpuzzle_view/src/replay_event.rs"),
+			TEXT("./crates/hyperpuzzle_view/src/replay_event.rs"),
+			TEXT("hyper-replay-event-taxonomy-support"),
+			TEXT("direct dual-license donor"),
+			TEXT("Retained replay-event taxonomy for undo, redo, scramble, interaction, twist, blindfold, solve, and session events that feed the bounded verification lane."),
+			{
+				TEXT("undo event"),
+				TEXT("redo event"),
+				TEXT("scramble event"),
+				TEXT("gizmo click event"),
+				TEXT("drag twist event"),
+				TEXT("twists event"),
+				TEXT("blindfold event"),
+				TEXT("solve start/end events"),
+				TEXT("session start/end events")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("generic review-shell ownership"),
+				TEXT("device telemetry ownership"),
+				TEXT("broad workflow-history ownership")
+			},
+			MakeAttribution(
+				TEXT("hyperspeedcube/replay-events"),
+				TEXT("Preserves the retained replay-event taxonomy for the bounded verification seam without overclaiming broader review, telemetry, or workflow-history ownership.")
+			)
 		)
 	};
 
@@ -295,34 +405,153 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun
 	);
 	Bundle.SerializationBoundaries = {SerializationBoundary};
 
+	FHyperTwistTrainingHyperspeedcubeReplayVerificationContract ReplayVerificationContract;
+	ReplayVerificationContract.ContractId = TEXT("hyperspeedcube-replay-verification-contract");
+	ReplayVerificationContract.Title = TEXT("Hyperspeedcube replay verification and solve-proof contract");
+	ReplayVerificationContract.Summary = TEXT("First-party HyperTwist contract for retained replay verification, replay reconstruction, timestamp proof routing, and bounded solve-proof diagnostics beneath the broader Hyperspeedcube runtime anchor.");
+	ReplayVerificationContract.RequiredPackageIds =
+	{
+		TEXT("package/hyperspeedcube-log-verifier"),
+		TEXT("package/hyperspeedcube-verification-types"),
+		TEXT("package/hyperspeedcube-replay-simulation"),
+		TEXT("package/hyperspeedcube-replay-events")
+	};
+	ReplayVerificationContract.VerificationSurfaceTags =
+	{
+		TEXT("full verification options"),
+		TEXT("quick verification options"),
+		TEXT("scramble seed verification"),
+		TEXT("solved-state verification"),
+		TEXT("randomness-beacon verification"),
+		TEXT("TSA completion timestamp verification"),
+		TEXT("unsupported scramble-version guard"),
+		TEXT("notation parse verification")
+	};
+	ReplayVerificationContract.ReplaySurfaceTags =
+	{
+		TEXT("replay event reconstruction"),
+		TEXT("grouped twist-string emission"),
+		TEXT("grouped twist parse"),
+		TEXT("undo/redo verification"),
+		TEXT("blindsolve validity gate"),
+		TEXT("single-session duration gate")
+	};
+	ReplayVerificationContract.TimestampSurfaceTags =
+	{
+		TEXT("scramble generation timestamp"),
+		TEXT("inspection start timestamp"),
+		TEXT("blindfold on timestamp"),
+		TEXT("solve start timestamp"),
+		TEXT("solve completion timestamp"),
+		TEXT("verified scramble range"),
+		TEXT("verified completion timestamp")
+	};
+	ReplayVerificationContract.ProvenanceCaveats =
+	{
+		TEXT("verification may block while constructing a puzzle and performing network-backed timestamp or randomness checks"),
+		TEXT("quick verification skips expensive and network-dependent checks and is only safe for already trusted solves"),
+		TEXT("duration derivation is only surfaced for replay logs that remain single-session"),
+		TEXT("macro use is surfaced as verification error text rather than normalized into supported product behavior"),
+		TEXT("used_filters and used_macros remain diagnostic facts rather than an approval policy")
+	};
+	ReplayVerificationContract.ExplicitExclusions =
+	{
+		TEXT("puzzle-definition DSL ownership"),
+		TEXT("broader stats-shape ownership"),
+		TEXT("leaderboard policy ownership"),
+		TEXT("generic replay UI shell ownership"),
+		TEXT("host network-service ownership")
+	};
+	ReplayVerificationContract.SourceAttribution = MakeAttribution(
+		TEXT("hyperspeedcube/replay-verification-contract"),
+		TEXT("Preserves the retained Hyperspeedcube replay-verification seam while keeping DSL authoring, broader stats-shape, and host shell ownership outside this packet.")
+	);
+	Bundle.ReplayVerificationContracts = {ReplayVerificationContract};
+
+	FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary ReplayVerificationBoundary;
+	ReplayVerificationBoundary.BoundaryId = TEXT("hyperspeedcube-replay-verification-boundary");
+	ReplayVerificationBoundary.Title = TEXT("Hyperspeedcube replay reconstruction and verification boundary");
+	ReplayVerificationBoundary.Summary = TEXT("First-party HyperTwist boundary for retained replay-event reconstruction, grouped twist serialization, verification diagnostics, and proof-caveat reporting above the bounded replay contract.");
+	ReplayVerificationBoundary.RequiredPackageIds =
+	{
+		TEXT("package/hyperspeedcube-log-verifier"),
+		TEXT("package/hyperspeedcube-replay-simulation"),
+		TEXT("package/hyperspeedcube-replay-events")
+	};
+	ReplayVerificationBoundary.ReplayEventSurfaceTags =
+	{
+		TEXT("replay-mode flag persistence"),
+		TEXT("scramble event"),
+		TEXT("gizmo click event"),
+		TEXT("drag twist event"),
+		TEXT("twists event"),
+		TEXT("blindfold event"),
+		TEXT("solve start/end events"),
+		TEXT("session start/end events"),
+		TEXT("session-end append on replay export")
+	};
+	ReplayVerificationBoundary.DiagnosticsSurfaceTags =
+	{
+		TEXT("puzzle build error surface"),
+		TEXT("notation parse error surface"),
+		TEXT("solution STM"),
+		TEXT("used_filters flag"),
+		TEXT("used_macros flag"),
+		TEXT("blindsolve validity gate"),
+		TEXT("single-session duration gate")
+	};
+	ReplayVerificationBoundary.ProvenanceCaveats =
+	{
+		TEXT("verification assumes replay or solve logs already persist scramble metadata and solved state"),
+		TEXT("the donor app load path still only consumes the first solve from a log bundle"),
+		TEXT("click and drag events remain interaction diagnostics and do not themselves apply twists"),
+		TEXT("replay export appends an EndSession marker on the replay path"),
+		TEXT("unsupported notation and macro behavior remain surfaced as verification errors rather than product-owned macro support")
+	};
+	ReplayVerificationBoundary.ExplicitExclusions =
+	{
+		TEXT("whole simulation-platform ownership"),
+		TEXT("desktop replay UI ownership"),
+		TEXT("broader review-shell ownership"),
+		TEXT("generic analytics dashboard ownership"),
+		TEXT("host TSA or randomness-service ownership")
+	};
+	ReplayVerificationBoundary.SourceAttribution = MakeAttribution(
+		TEXT("hyperspeedcube/replay-verification-boundary"),
+		TEXT("Preserves the retained replay reconstruction and verification diagnostics seam without promoting the donor viewer shell, service configuration, or broader analytics stack into first-party product truth.")
+	);
+	Bundle.ReplayVerificationBoundaries = {ReplayVerificationBoundary};
+
 	FHyperTwistTrainingHyperspeedcubeAttributionBoundary AttributionBoundary;
 	AttributionBoundary.BoundaryId = TEXT("hyperspeedcube-dual-license-attribution-boundary");
 	AttributionBoundary.Title = TEXT("Hyperspeedcube dual-license donor attribution boundary");
-	AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using Hyperspeedcube as a direct dual-license donor for the bounded notation and serialization slice.");
+	AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using Hyperspeedcube as a direct dual-license donor for the bounded notation, serialization, and replay-verification slices.");
 	AttributionBoundary.AllowedUseTags =
 	{
 		TEXT("first-party reauthored subsystem implementation"),
 		TEXT("direct permissive donor reference"),
-		TEXT("bounded notation and serialization contract use")
+		TEXT("bounded notation and serialization contract use"),
+		TEXT("bounded replay verification contract use")
 	};
 	AttributionBoundary.RequiredNoticeActions = CommonNoticeActions;
 	AttributionBoundary.ProvenanceCaveats =
 	{
 		TEXT("Hyperspeedcube remains a partial retained row rather than a closed runtime platform"),
 		TEXT("the landed puzzle-catalog contract remains a separate bounded Phase 6R-A slice"),
-		TEXT("later replay verification and stats-shape widening remain separate packets"),
+		TEXT("the landed replay verification contract remains a separate bounded Phase 6R-L slice"),
+		TEXT("later stats-shape widening remains a separate packet"),
 		TEXT("the retained dual-license posture does not transfer generic hyper-runtime or host-shell ownership")
 	};
 	AttributionBoundary.ExplicitExclusions =
 	{
 		TEXT("silent attribution removal"),
-		TEXT("pretending replay verification landed in this packet"),
+		TEXT("pretending whole-row stats-shape ownership landed in these packets"),
 		TEXT("pretending whole-app runtime ownership transferred"),
 		TEXT("treating DSL authoring as already incorporated")
 	};
 	AttributionBoundary.SourceAttribution = MakeAttribution(
 		TEXT("hyperspeedcube/attribution-boundary"),
-		TEXT("Records dual-license attribution and packet bounds for the retained Hyperspeedcube notation and serialization slice without overclaiming whole-row incorporation.")
+		TEXT("Records dual-license attribution and packet bounds for the retained Hyperspeedcube notation, serialization, and replay-verification slices without overclaiming whole-row incorporation.")
 	);
 	Bundle.AttributionBoundaries = {AttributionBoundary};
 
@@ -367,6 +596,44 @@ bool UHyperTwistTrainingHyperspeedcubeLibrary::TryGetSerializationBoundaryById(
 	return false;
 }
 
+bool UHyperTwistTrainingHyperspeedcubeLibrary::TryGetReplayVerificationContractById(
+	const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle,
+	const FString& ContractId,
+	FHyperTwistTrainingHyperspeedcubeReplayVerificationContract& OutContract
+)
+{
+	for (const FHyperTwistTrainingHyperspeedcubeReplayVerificationContract& Contract : Bundle.ReplayVerificationContracts)
+	{
+		if (Contract.ContractId == ContractId)
+		{
+			OutContract = Contract;
+			return true;
+		}
+	}
+
+	OutContract = FHyperTwistTrainingHyperspeedcubeReplayVerificationContract();
+	return false;
+}
+
+bool UHyperTwistTrainingHyperspeedcubeLibrary::TryGetReplayVerificationBoundaryById(
+	const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle,
+	const FString& BoundaryId,
+	FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary& OutBoundary
+)
+{
+	for (const FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary& Boundary : Bundle.ReplayVerificationBoundaries)
+	{
+		if (Boundary.BoundaryId == BoundaryId)
+		{
+			OutBoundary = Boundary;
+			return true;
+		}
+	}
+
+	OutBoundary = FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary();
+	return false;
+}
+
 bool UHyperTwistTrainingHyperspeedcubeLibrary::TryGetAttributionBoundaryById(
 	const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle,
 	const FString& BoundaryId,

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

@@ -1143,6 +1143,30 @@ bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeSerialization
 	);
 }
 
+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeReplayVerificationContract(
+	const FString& ContractId,
+	FHyperTwistTrainingHyperspeedcubeReplayVerificationContract& OutContract
+)
+{
+	return UHyperTwistTrainingHyperspeedcubeLibrary::TryGetReplayVerificationContractById(
+		GetBundledHyperspeedcubeReferenceBundle(),
+		ContractId,
+		OutContract
+	);
+}
+
+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeReplayVerificationBoundary(
+	const FString& BoundaryId,
+	FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary& OutBoundary
+)
+{
+	return UHyperTwistTrainingHyperspeedcubeLibrary::TryGetReplayVerificationBoundaryById(
+		GetBundledHyperspeedcubeReferenceBundle(),
+		BoundaryId,
+		OutBoundary
+	);
+}
+
 bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeAttributionBoundary(
 	const FString& BoundaryId,
 	FHyperTwistTrainingHyperspeedcubeAttributionBoundary& OutBoundary

UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.h

@@ -123,6 +123,85 @@ struct FHyperTwistTrainingHyperspeedcubeSerializationBoundary
 	}
 };
 
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingHyperspeedcubeReplayVerificationContract
+{
+	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> VerificationSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ReplaySurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> TimestampSurfaceTags;
+
+	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 !ContractId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary
+{
+	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> ReplayEventSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> DiagnosticsSurfaceTags;
+
+	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 FHyperTwistTrainingHyperspeedcubeAttributionBoundary
 {
@@ -172,6 +251,12 @@ struct FHyperTwistTrainingHyperspeedcubeReferenceBundle
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	FString PrimarySerializationBoundaryId;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryReplayVerificationContractId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryReplayVerificationBoundaryId;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	FString PrimaryAttributionBoundaryId;
 
@@ -184,6 +269,12 @@ struct FHyperTwistTrainingHyperspeedcubeReferenceBundle
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	TArray<FHyperTwistTrainingHyperspeedcubeSerializationBoundary> SerializationBoundaries;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingHyperspeedcubeReplayVerificationContract> ReplayVerificationContracts;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary> ReplayVerificationBoundaries;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	TArray<FHyperTwistTrainingHyperspeedcubeAttributionBoundary> AttributionBoundaries;
 
@@ -191,6 +282,8 @@ struct FHyperTwistTrainingHyperspeedcubeReferenceBundle
 	{
 		return !PrimaryNotationContractId.IsEmpty()
 			&& !PrimarySerializationBoundaryId.IsEmpty()
+			&& !PrimaryReplayVerificationContractId.IsEmpty()
+			&& !PrimaryReplayVerificationBoundaryId.IsEmpty()
 			&& !PrimaryAttributionBoundaryId.IsEmpty()
 			&& PackageReferences.Num() > 0;
 	}
@@ -219,6 +312,20 @@ public:
 		FHyperTwistTrainingHyperspeedcubeSerializationBoundary& OutBoundary
 	);
 
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube")
+	static bool TryGetReplayVerificationContractById(
+		const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle,
+		const FString& ContractId,
+		FHyperTwistTrainingHyperspeedcubeReplayVerificationContract& OutContract
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube")
+	static bool TryGetReplayVerificationBoundaryById(
+		const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle,
+		const FString& BoundaryId,
+		FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary& OutBoundary
+	);
+
 	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube")
 	static bool TryGetAttributionBoundaryById(
 		const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle,

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

@@ -437,6 +437,18 @@ public:
 		FHyperTwistTrainingHyperspeedcubeSerializationBoundary& OutBoundary
 	);
 
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube")
+	static bool TryGetBundledHyperspeedcubeReplayVerificationContract(
+		const FString& ContractId,
+		FHyperTwistTrainingHyperspeedcubeReplayVerificationContract& OutContract
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube")
+	static bool TryGetBundledHyperspeedcubeReplayVerificationBoundary(
+		const FString& BoundaryId,
+		FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary& OutBoundary
+	);
+
 	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube")
 	static bool TryGetBundledHyperspeedcubeAttributionBoundary(
 		const FString& BoundaryId,

UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHyperspeedcubePhase6RLReplayVerificationContractTest.cpp

@@ -0,0 +1,132 @@
+// Copyright HyperTwist, Inc. All Rights Reserved.
+
+#include "Misc/AutomationTest.h"
+
+#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h"
+
+#if WITH_AUTOMATION_TESTS
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistHyperspeedcubePhase6RLReplayVerificationContractTest,
+	"HyperTwist.Permissive.Hyperspeedcube.Phase6R.L.ReplayVerificationContract",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistHyperspeedcubePhase6RLReplayVerificationContractTest::RunTest(const FString& Parameters)
+{
+	const FHyperTwistTrainingHyperspeedcubeReferenceBundle Bundle =
+		UHyperTwistTrainingRuntimeLibrary::GetBundledHyperspeedcubeReferenceBundle();
+
+	TestTrue(TEXT("The Hyperspeedcube bundle must stay structurally valid."), Bundle.IsStructurallyValid());
+	TestTrue(TEXT("The Hyperspeedcube bundle must preserve the expanded donor package set."), Bundle.PackageReferences.Num() >= 9);
+
+	FHyperTwistTrainingHyperspeedcubeReplayVerificationContract Contract;
+	TestTrue(
+		TEXT("The primary Hyperspeedcube replay verification contract must resolve from the runtime library."),
+		UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeReplayVerificationContract(
+			Bundle.PrimaryReplayVerificationContractId,
+			Contract
+		)
+	);
+	TestEqual(
+		TEXT("The replay verification contract id must stay stable."),
+		Contract.ContractId,
+		TEXT("hyperspeedcube-replay-verification-contract")
+	);
+	TestTrue(
+		TEXT("The replay verification contract must require the retained verifier package."),
+		Contract.RequiredPackageIds.Contains(TEXT("package/hyperspeedcube-log-verifier"))
+	);
+	TestTrue(
+		TEXT("The replay verification contract must preserve scramble seed verification."),
+		Contract.VerificationSurfaceTags.Contains(TEXT("scramble seed verification"))
+	);
+	TestTrue(
+		TEXT("The replay verification contract must preserve replay event reconstruction."),
+		Contract.ReplaySurfaceTags.Contains(TEXT("replay event reconstruction"))
+	);
+	TestTrue(
+		TEXT("The replay verification contract must preserve verified completion timestamps."),
+		Contract.TimestampSurfaceTags.Contains(TEXT("verified completion timestamp"))
+	);
+	TestTrue(
+		TEXT("The replay verification contract must keep broader stats-shape ownership excluded."),
+		Contract.ExplicitExclusions.Contains(TEXT("broader stats-shape ownership"))
+	);
+	TestEqual(
+		TEXT("The replay verification contract must keep the direct donor source repo."),
+		Contract.SourceAttribution.SourceRepo,
+		TEXT("HactarCE/Hyperspeedcube")
+	);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistHyperspeedcubePhase6RLReplayVerificationBoundaryTest,
+	"HyperTwist.Permissive.Hyperspeedcube.Phase6R.L.ReplayVerificationBoundary",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistHyperspeedcubePhase6RLReplayVerificationBoundaryTest::RunTest(const FString& Parameters)
+{
+	const FHyperTwistTrainingHyperspeedcubeReferenceBundle Bundle =
+		UHyperTwistTrainingRuntimeLibrary::GetBundledHyperspeedcubeReferenceBundle();
+
+	FHyperTwistTrainingHyperspeedcubeReplayVerificationBoundary Boundary;
+	TestTrue(
+		TEXT("The Hyperspeedcube replay verification boundary must resolve from the runtime library."),
+		UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeReplayVerificationBoundary(
+			Bundle.PrimaryReplayVerificationBoundaryId,
+			Boundary
+		)
+	);
+	TestEqual(
+		TEXT("The replay verification boundary id must stay stable."),
+		Boundary.BoundaryId,
+		TEXT("hyperspeedcube-replay-verification-boundary")
+	);
+	TestTrue(
+		TEXT("The replay verification boundary must preserve session-end append on replay export."),
+		Boundary.ReplayEventSurfaceTags.Contains(TEXT("session-end append on replay export"))
+	);
+	TestTrue(
+		TEXT("The replay verification boundary must preserve the used_macros diagnostic."),
+		Boundary.DiagnosticsSurfaceTags.Contains(TEXT("used_macros flag"))
+	);
+	TestTrue(
+		TEXT("The replay verification boundary must preserve the replay export caveat."),
+		Boundary.ProvenanceCaveats.Contains(TEXT("replay export appends an EndSession marker on the replay path"))
+	);
+	TestTrue(
+		TEXT("The replay verification boundary must keep the broader review shell excluded."),
+		Boundary.ExplicitExclusions.Contains(TEXT("broader review-shell ownership"))
+	);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistHyperspeedcubePhase6RLPackageChecklistTest,
+	"HyperTwist.Permissive.Hyperspeedcube.Phase6R.L.PackageChecklist",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistHyperspeedcubePhase6RLPackageChecklistTest::RunTest(const FString& Parameters)
+{
+	const FString Checklist = UHyperTwistTrainingRuntimeLibrary::BuildBundledHyperspeedcubePackageChecklistTsv();
+	TestTrue(TEXT("The Hyperspeedcube package checklist must not be empty."), !Checklist.IsEmpty());
+	TestTrue(
+		TEXT("The checklist must preserve the replay verifier package id."),
+		Checklist.Contains(TEXT("package/hyperspeedcube-log-verifier"))
+	);
+	TestTrue(
+		TEXT("The checklist must preserve the replay simulation export path."),
+		Checklist.Contains(TEXT("./crates/hyperpuzzle_view/src/simulation/mod.rs"))
+	);
+	TestTrue(
+		TEXT("The checklist must preserve the direct dual-license donor posture."),
+		Checklist.Contains(TEXT("direct dual-license donor"))
+	);
+	return true;
+}
+
+#endif

docs/REPO_LICENSE_TRACKING.md

@@ -119,6 +119,8 @@ Status update on `2026-05-21`:
   packet is now landed in current code
 - the bounded permissive `Phase 6R-K` `HactarCE/Hyperspeedcube` notation and replay-log
   serialization packet is now landed in current code
+- the bounded permissive `Phase 6R-L` `HactarCE/Hyperspeedcube` replay verification packet is now
+  landed in current code
 - `HactarCE/Hyperspeedcube` remains partially incorporated
 - the bounded permissive `Phase 6R-B` `kkoomen/qbr` classic-cube recognition calibration and
   ordered face-observation packet is now landed in current code
@@ -142,9 +144,8 @@ Status update on `2026-05-21`:
 - the bounded permissive `Phase 6R-G` `rhasspy/piper` local narration sidecar packet is now
   landed in current code
 - `rhasspy/piper` remains partially incorporated
-- the current next bounded move is a source-backed `Phase 6R-H` `coqui-ai/TTS`
-  preparation/control pass for a richer bounded voice-output seam, not a new restrictive packet
-  by default
+- the current next bounded move is a source-backed `Phase 6R-M` `HactarCE/Hyperspeedcube`
+  stats-shape and solve-record preparation/control pass, not a new restrictive packet by default
 - use the repo-row README census, the portfolio standing refresh backfill, and the `2R-A`
   ownership contract for the current queue after that correction
 
@@ -1267,8 +1268,9 @@ Current licensing judgment:
   - hyper puzzle catalog contract
   - hyper notation contract
   - replay-log serialization boundary
-- the row remains only partially incorporated; DSL authoring, replay verification, and stats-shape
-  widening remain deferred
+  - replay verification boundary
+- the row remains only partially incorporated; DSL authoring and stats-shape widening remain
+  deferred
 
 Source basis:
 
@@ -1281,6 +1283,10 @@ Source basis:
 - `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hypuz_notation\src\spanned.rs`
 - `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hypuz_notation\src\parse.rs`
 - `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzle_log\src\lib.rs`
+- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzle_log\src\verify.rs`
+- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperspeedcube_cli_types\src\verification.rs`
+- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzle_view\src\simulation\mod.rs`
+- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzle_view\src\replay_event.rs`
 - `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperspeedcube\src\app.rs`
 
 Important distinction:
@@ -1296,6 +1302,7 @@ Important distinction:
 - the currently landed bounded slices inside that contract are:
   - puzzle catalog contract
   - notation grammar and replay-log serialization boundary
+  - replay verification and solve-proof diagnostics boundary
 - the workspace includes a `hypercubing_leaderboards_client` crate, but that does not transfer
   remote service ownership or reorder the queued `Phase 6R-A` packet by itself
 

docs/arch/HYPERTWIST_PHASE6R_L_HYPERSPEEDCUBE_REPLAY_VERIFICATION_IMPLEMENTATION_PACKET_2026-05-22.md

@@ -0,0 +1,135 @@
+# HyperTwist Phase 6R-L HactarCE/Hyperspeedcube replay verification implementation packet
+
+Created on `2026-05-22`
+
+## Status
+
+- first-party HyperTwist packet
+- bounded permissive `Phase 6R-L` implementation slice
+
+## Purpose
+
+This packet lands the next narrower bounded slice from the retained `HactarCE/Hyperspeedcube`
+runtime-anchor row.
+
+The landed slice is:
+
+- first-party hyper replay verification and solve-proof diagnostics boundary
+
+It is not:
+
+- a whole `Hyperspeedcube` runtime transplant
+- a puzzle-definition DSL packet
+- a stats-shape packet
+- a donor replay UI shell packet
+- a donor network-service ownership 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_L_HYPERSPEEDCUBE_REPLAY_VERIFICATION_PREPARATION_PACKET_2026-05-22.md`
+
+The retained owner remains:
+
+- `HactarCE/Hyperspeedcube`
+
+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 `HactarCE/Hyperspeedcube` bounded to the narrower `A1 / R1 / F2` replay
+  verification and solve-proof diagnostics slice
+
+## Landed scope
+
+The current code now owns a retained `Hyperspeedcube` contract through:
+
+- the existing first-party `UHyperTwistTrainingHyperspeedcubeLibrary`
+- retained package references for:
+  - log verifier
+  - verification result types
+  - replay simulation
+  - replay-event taxonomy
+- one bounded replay-verification contract for:
+  - full vs quick verification options
+  - scramble seed, solved-state, and notation-parse checks
+  - randomness-beacon and completion-timestamp proof routing
+  - replay reconstruction and single-session duration eligibility
+- one bounded replay-verification boundary for:
+  - replay-event taxonomy
+  - grouped twist reconstruction
+  - used-filters and used-macros diagnostics
+  - blindsolve validity and proof-caveat reporting
+- updated donor-attribution boundary
+- runtime-library accessors and package-checklist export through:
+  - `UHyperTwistTrainingRuntimeLibrary`
+- focused automation coverage in:
+  - `HyperTwistHyperspeedcubePhase6RLReplayVerificationContractTest.cpp`
+
+## Why this is still intentionally bounded
+
+This packet lands the retained replay-verification seam, but it does not widen into neighboring
+retained families or broader product ownership.
+
+Still deferred:
+
+- puzzle-definition DSL parsing or authoring
+- stats-shape and solve-record ownership
+- donor replay UI shell ownership
+- donor desktop shell and host-network-service ownership
+- broader `Hyperspeedcube` runtime-anchor widening beyond the next bounded packet
+
+## Validation
+
+Build validation:
+
+- `Build.bat UnrealHyperTwistEditor Win64 Development -Project='C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject' -WaitMutex -NoHotReloadFromIDE`
+
+Focused automation validation:
+
+- `Automation RunTests HyperTwist.Permissive.Hyperspeedcube.Phase6R.L`
+
+Regression automation validation:
+
+- `Automation RunTests HyperTwist.Permissive.MagicCube5D.Phase6R.J`
+- `Automation RunTests HyperTwist.Permissive.Magic120Cell.Phase6R.I`
+- `Automation RunTests HyperTwist.Permissive.MagicTile.Phase6R.D`
+- `Automation RunTests HyperTwist.Permissive.Hyperspeedcube.Phase6R.A`
+- `Automation RunTests HyperTwist.CleanRoom.CubeDesk`
+
+Expected covered tests:
+
+- `ReplayVerificationContract`
+- `ReplayVerificationBoundary`
+- `PackageChecklist`
+- existing `MagicCube5D`, `Magic120Cell`, `MagicTile`, `Hyperspeedcube`, and `CubeDesk`
+  regression suites
+
+## Queue effect
+
+This packet consumes the current `Phase 6R-L` implementation slice.
+
+`HactarCE/Hyperspeedcube` remains only partially incorporated:
+
+- landed now:
+  - puzzle catalog contract
+  - notation contract
+  - replay-log serialization boundary
+  - replay verification boundary
+- still deferred:
+  - puzzle-definition DSL authoring
+  - stats-shape
+
+The next clean move is:
+
+- source-backed `Phase 6R-M` `HactarCE/Hyperspeedcube` stats-shape and solve-record
+  preparation/control pass
+
+Keep the future sequencing guards visible:
+
+- keep the next widening slice on stats-shape and solve-record rather than reopening DSL
+  authoring in the same packet
+- keep generic hyper-runtime ownership first-party and broader than this donor slice

docs/arch/HYPERTWIST_PHASE6R_L_HYPERSPEEDCUBE_REPLAY_VERIFICATION_PREPARATION_PACKET_2026-05-22.md

@@ -0,0 +1,99 @@
+# HyperTwist Phase 6R-L HactarCE/Hyperspeedcube replay verification preparation packet
+
+Created on `2026-05-22`
+
+## Status
+
+- first-party HyperTwist packet
+- source-backed bounded permissive `Phase 6R-L` preparation and control pass
+
+## Purpose
+
+This packet narrows the retained `HactarCE/Hyperspeedcube` runtime-anchor remainder to one first
+bounded widening slice.
+
+The controlled slice is:
+
+- replay verification and solve-proof diagnostics boundary
+
+It is not:
+
+- puzzle-definition DSL authoring
+- stats-shape widening
+- a whole `Hyperspeedcube` runtime transplant
+- a donor replay UI or desktop-shell packet
+- a donor network-service ownership packet
+
+## Authority basis
+
+This preparation packet stands on:
+
+- `docs/HYPERTWIST_PHASE_0R_PACKET_0R_A_EVALUATION_2026-05-12.md`
+- `docs/HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
+- `docs/REPO_LICENSE_TRACKING.md`
+- `docs/arch/HYPERTWIST_PHASE6R_K_HYPERSPEEDCUBE_NOTATION_SERIALIZATION_IMPLEMENTATION_PACKET_2026-05-22.md`
+
+Retained owner:
+
+- `HactarCE/Hyperspeedcube`
+
+Retained row remainder before this packet:
+
+- puzzle-definition DSL boundary
+- replay-event taxonomy and verification boundary
+- stats-shape and solve-record contract
+
+## Source-backed control result
+
+The controlling donor seam is narrower than the whole row:
+
+- `crates/hyperpuzzle_log/src/verify.rs`
+- `crates/hyperspeedcube_cli_types/src/verification.rs`
+- `crates/hyperpuzzle_view/src/simulation/mod.rs`
+- `crates/hyperpuzzle_view/src/replay_event.rs`
+
+Why this wins as the next slice:
+
+- the retained catalog, notation, and replay-log serialization contracts are already landed and
+  stable
+- replay verification is the next adjacent retained runtime-anchor seam above the landed
+  notation/log boundary
+- the donor seam already isolates verification options, replay reconstruction, timestamp proof
+  routing, and solve diagnostics
+- stats-shape still remains a separate downstream product-owned lane
+- DSL authoring is broader than the current safe widening budget
+
+## Implementation target
+
+The implementation packet may land:
+
+- an expanded first-party `Hyperspeedcube` reference-bundle contract
+- package references for retained replay-verification and replay-reconstruction donor files
+- one bounded replay-verification contract
+- one bounded replay-verification boundary
+- an updated donor-attribution boundary
+- runtime-library accessors and package-checklist export
+- focused automation coverage
+
+## Explicit non-goals
+
+Do not land in `Phase 6R-L`:
+
+- puzzle-definition DSL ownership
+- broader stats-shape ownership
+- leaderboard policy ownership
+- donor replay UI or desktop shell ownership
+- host TSA, randomness-beacon, or network-service ownership
+
+## Queue effect
+
+If the bounded implementation lands cleanly, the next clean move becomes:
+
+- source-backed `Phase 6R-M` `HactarCE/Hyperspeedcube` stats-shape and solve-record
+  preparation/control pass
+
+Keep the later widening guards visible:
+
+- stats-shape stays separate
+- DSL stays separate
+- generic hyper-runtime ownership stays first-party and broader than this donor slice

docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md

@@ -88,12 +88,14 @@ The next bounded move is now:
 
 1. the bounded permissive `Phase 6R-K` `HactarCE/Hyperspeedcube` notation and replay-log
    serialization implementation packet is now landed in current code
-2. source-backed `Phase 6R-L` `HactarCE/Hyperspeedcube` replay verification
+2. the bounded permissive `Phase 6R-L` `HactarCE/Hyperspeedcube` replay verification
+   implementation packet is now landed in current code
+3. source-backed `Phase 6R-M` `HactarCE/Hyperspeedcube` stats-shape and solve-record
    preparation/control pass is now the next bounded move
-3. keep it after the landed `MagicCube5D` family runtime-profile and persistence slice and the
-   landed `Phase 6R-K` notation/log-serialization slice
-4. keep later DSL authoring, stats-shape, and broader runtime-anchor widening separate from the
-   replay-verification packet
+4. keep it after the landed `MagicCube5D` family runtime-profile and persistence slice and the
+   landed `Phase 6R-K` notation/log-serialization plus `Phase 6R-L` replay-verification slices
+5. keep later DSL authoring and broader runtime-anchor widening separate from the stats-shape
+   packet
 
 ## Memory-specific sequencing rule
 

docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md

@@ -110,6 +110,7 @@ Do not collapse those three tiers into one undifferentiated "features" voice.
 | Committed-face reconstruction and final classic-net shaping | Implemented now | landed `rubix-cube-solver` packet | Reconstruction session boundary is live. |
 | Hyper puzzle catalog contract | Implemented now | landed `Hyperspeedcube` `Phase 6R-A` | Narrow retained hyper-puzzle catalog slice is live. |
 | Hyper notation and replay-log serialization boundary | Implemented now | landed `Hyperspeedcube` `Phase 6R-K` | Narrow retained notation and log-serialization slice is live. |
+| Hyper replay verification boundary | Implemented now | landed `Hyperspeedcube` `Phase 6R-L` | Narrow retained replay-verification and solve-proof slice is live. |
 | Tiling topology and geometry-family contract | Implemented now | landed `MagicTile` `Phase 6R-D` | Narrow retained non-Euclidean topology slice is live. |
 | Provider-backed recognition session boundary | Implemented now | first-party current code | `UHyperTwistHttpVisionClient` and normalized recognition envelopes are live first-party seams. |
 | Speech transcript session boundary | Implemented now | landed `whisper.cpp` `Phase 6R-E` | Transcript sessions, utterance envelopes, and speech-health seams are live. |
@@ -131,7 +132,8 @@ repo.
 | Algorithm/training semantic lane | Implemented now | landed `cubing/alg.js` bounded packets | Semantic/training contract is real. |
 | Hyper puzzle catalog | Implemented now | `Hyperspeedcube` bounded packet | Current realized hyper-puzzle entry slice. |
 | Hyper notation and replay-log serialization | Implemented now | landed `Hyperspeedcube` `Phase 6R-K` | Retained notation parse/format and log-serialization boundary are live. |
-| Hyper puzzle DSL, replay verification, and stats-shape | Deep-source grounded retained | `Hyperspeedcube` retained row | Still deferred after the bounded `Phase 6R-K` landing. |
+| Hyper replay verification and solve-proof diagnostics | Implemented now | landed `Hyperspeedcube` `Phase 6R-L` | Retained replay verification, timestamp proof routing, and bounded solve diagnostics are live. |
+| Hyper puzzle DSL and stats-shape | Deep-source grounded retained | `Hyperspeedcube` retained row | Still deferred after the bounded `Phase 6R-L` landing. |
 
 ### 2. Physical recognition and reconstruction
 

docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md

@@ -49,8 +49,10 @@ Canonical discovery surfaces for roadmap interpretation:
   packet is now landed in current code
 - the bounded permissive `Phase 6R-K` `HactarCE/Hyperspeedcube` notation and replay-log
   serialization packet is now landed in current code
-- `HactarCE/Hyperspeedcube` remains partially incorporated; DSL authoring, replay verification,
-  and stats-shape families stay deferred
+- the bounded permissive `Phase 6R-L` `HactarCE/Hyperspeedcube` replay verification packet is now
+  landed in current code
+- `HactarCE/Hyperspeedcube` remains partially incorporated; DSL authoring and stats-shape
+  families stay deferred
 - the generic source-backed `Phase 6R-B` `kkoomen/qbr` control pass is now consumed
 - the bounded permissive `Phase 6R-B` `kkoomen/qbr` classic-cube recognition calibration and
   ordered face-observation packet is now landed in current code
@@ -102,10 +104,13 @@ Canonical discovery surfaces for roadmap interpretation:
   shell widening stay deferred
 - the bounded permissive `Phase 6R-K` `HactarCE/Hyperspeedcube` notation and replay-log
   serialization packet is now landed in current code
-- `HactarCE/Hyperspeedcube` remains partially incorporated; DSL authoring, replay verification,
-  and stats-shape widening stay deferred
-- the current next bounded move is a source-backed `Phase 6R-L` `HactarCE/Hyperspeedcube` replay
-  verification preparation/control pass for one bounded runtime-anchor widening slice
+- the bounded permissive `Phase 6R-L` `HactarCE/Hyperspeedcube` replay verification packet is now
+  landed in current code
+- `HactarCE/Hyperspeedcube` remains partially incorporated; DSL authoring and stats-shape
+  widening stay deferred
+- the current next bounded move is a source-backed `Phase 6R-M` `HactarCE/Hyperspeedcube`
+  stats-shape and solve-record preparation/control pass for one bounded runtime-anchor 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
 
@@ -133,8 +138,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: `33`
-- permissive live lanes: `22`
+- currently verified live/implemented in checked Unreal surfaces: `34`
+- permissive live lanes: `23`
 - boundary-sensitive live lanes: `6`
 - restrictive live lanes: `5`
 - the restrictive landed lanes are:
@@ -167,8 +172,8 @@ Current routing truth:
 - active non-live implementation-board rows: `34`
 - retained benchmark, oracle, or clean-room-later rows outside the active implementation board: `9`
 
-The next bounded move is a source-backed `Phase 6R-L`
-`HactarCE/Hyperspeedcube` replay verification preparation/control pass.
+The next bounded move is a source-backed `Phase 6R-M`
+`HactarCE/Hyperspeedcube` stats-shape and solve-record preparation/control pass.
 
 Queue interpretation after that packet:
 
@@ -184,6 +189,7 @@ Queue interpretation after that packet:
     - DSL
     - replay verification
     - stats-shape
+    - stats-shape
 - `kkoomen/qbr` remains a partially landed row rather than a closed row:
   - landed:
     - classic-cube recognition calibration contract
@@ -291,7 +297,7 @@ Queue interpretation after that packet:
 - the next queue shape is now:
   - `HactarCE/Hyperspeedcube` deferred runtime-anchor remainder
 - the next bounded packet should stay narrow:
-  - replay verification before reopening DSL authoring and stats-shape in the same packet
+  - stats-shape and solve-record contract before reopening DSL authoring in the same packet
 - 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: