diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.cpp index 295f079..e3283b6 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.cpp +++ b/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 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, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp index 8ee1111..d186587 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp +++ b/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 diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.h index 6cf4c49..5af59a5 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.h +++ b/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 RequiredPackageIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray VerificationSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ReplaySurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray TimestampSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ProvenanceCaveats; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ExplicitExclusions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FHyperTwistTrainingSourceAttribution SourceAttribution; + + bool IsStructurallyValid() const + { + return !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 RequiredPackageIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ReplayEventSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray DiagnosticsSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ProvenanceCaveats; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ExplicitExclusions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FHyperTwistTrainingSourceAttribution SourceAttribution; + + bool IsStructurallyValid() const + { + return !BoundaryId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid(); + } +}; + USTRUCT(BlueprintType) struct 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 SerializationBoundaries; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ReplayVerificationContracts; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ReplayVerificationBoundaries; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") TArray 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, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h index f354ca0..ee89719 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h +++ b/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, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHyperspeedcubePhase6RLReplayVerificationContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHyperspeedcubePhase6RLReplayVerificationContractTest.cpp new file mode 100644 index 0000000..4690adc --- /dev/null +++ b/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 diff --git a/docs/REPO_LICENSE_TRACKING.md b/docs/REPO_LICENSE_TRACKING.md index 7ceaa77..84855be 100644 --- a/docs/REPO_LICENSE_TRACKING.md +++ b/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 diff --git a/docs/arch/HYPERTWIST_PHASE6R_L_HYPERSPEEDCUBE_REPLAY_VERIFICATION_IMPLEMENTATION_PACKET_2026-05-22.md b/docs/arch/HYPERTWIST_PHASE6R_L_HYPERSPEEDCUBE_REPLAY_VERIFICATION_IMPLEMENTATION_PACKET_2026-05-22.md new file mode 100644 index 0000000..315cdd2 --- /dev/null +++ b/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 diff --git a/docs/arch/HYPERTWIST_PHASE6R_L_HYPERSPEEDCUBE_REPLAY_VERIFICATION_PREPARATION_PACKET_2026-05-22.md b/docs/arch/HYPERTWIST_PHASE6R_L_HYPERSPEEDCUBE_REPLAY_VERIFICATION_PREPARATION_PACKET_2026-05-22.md new file mode 100644 index 0000000..f4c1768 --- /dev/null +++ b/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 diff --git a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md index cb87b16..cafd1c9 100644 --- a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md +++ b/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 diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md index 862e4a9..15176e7 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md +++ b/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 diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md index 6db735e..a91766d 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md +++ b/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: