diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistBootstrap/HyperTwistContractLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistBootstrap/HyperTwistContractLibrary.cpp index d2887d2..d89df35 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistBootstrap/HyperTwistContractLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistBootstrap/HyperTwistContractLibrary.cpp @@ -4032,6 +4032,21 @@ FHyperTwistSkillAnalyzerWrapperState UHyperTwistContractLibrary::MakeSampleSkill ); } +FHyperTwistSkillCleanRoomCommandContractState +UHyperTwistContractLibrary::MakeSampleSkillCleanRoomCommandContractState() +{ + const FHyperTwistSkillRegistryState RegistryState = MakeSampleSkillRegistryState(); + const FHyperTwistSkillControlState ControlState = MakeSampleSkillControlState(); + const FHyperTwistSkillAuthoringHarnessState AuthoringHarnessState = + MakeSampleSkillAuthoringHarnessState(); + + return UHyperTwistSkillCoreLibrary::DeriveSkillCleanRoomCommandContractState( + RegistryState, + ControlState, + AuthoringHarnessState + ); +} + FHyperTwistTrainingRepositoryIntegrityReport UHyperTwistContractLibrary::MakeSampleTrainingRepositoryIntegrityReport() { FHyperTwistTrainingRepositoryState RepositoryState = MakeSampleTrainingRepositoryState(); @@ -5186,6 +5201,15 @@ FString UHyperTwistContractLibrary::SerializeSkillAnalyzerWrapperStateToJson( ); } +FString UHyperTwistContractLibrary::SerializeSkillCleanRoomCommandContractStateToJson( + const FHyperTwistSkillCleanRoomCommandContractState& SkillCleanRoomCommandContractState +) +{ + return HyperTwistContractLibraryInternal::SerializeStructToJson( + SkillCleanRoomCommandContractState + ); +} + FString UHyperTwistContractLibrary::SerializeTrainingTimerExportPacketToJson( const FHyperTwistTrainingTimerExportPacket& TimerExportPacket ) @@ -5363,6 +5387,17 @@ bool UHyperTwistContractLibrary::DeserializeSkillAnalyzerWrapperStateFromJson( ); } +bool UHyperTwistContractLibrary::DeserializeSkillCleanRoomCommandContractStateFromJson( + const FString& Json, + FHyperTwistSkillCleanRoomCommandContractState& OutSkillCleanRoomCommandContractState +) +{ + return HyperTwistContractLibraryInternal::DeserializeStructFromJson( + Json, + OutSkillCleanRoomCommandContractState + ); +} + bool UHyperTwistContractLibrary::DeserializeTrainingTimerExportPacketFromJson( const FString& Json, FHyperTwistTrainingTimerExportPacket& OutTimerExportPacket diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistSkills/HyperTwistSkillCoreLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistSkills/HyperTwistSkillCoreLibrary.cpp index 0f992f0..fc2cb2c 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistSkills/HyperTwistSkillCoreLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistSkills/HyperTwistSkillCoreLibrary.cpp @@ -351,18 +351,39 @@ namespace HyperTwistSkillCoreLibraryInternal ); } + bool HasEvalValidationCaseWithMode( + const FHyperTwistSkillAuthoringHarnessState& HarnessState, + const FString& SkillId, + const EHyperTwistSkillValidationExecutionMode ExecutionMode + ); + + TArray MakeRequiredAuthoringSectionIds(); + bool HasLiveEvalValidationCase( const FHyperTwistSkillAuthoringHarnessState& HarnessState, const FString& SkillId ) + { + return HasEvalValidationCaseWithMode( + HarnessState, + SkillId, + EHyperTwistSkillValidationExecutionMode::LiveContract + ); + } + + bool HasEvalValidationCaseWithMode( + const FHyperTwistSkillAuthoringHarnessState& HarnessState, + const FString& SkillId, + const EHyperTwistSkillValidationExecutionMode ExecutionMode + ) { const FHyperTwistSkillValidationContractCase* ValidationCase = HarnessState.ValidationCases.FindByPredicate( - [&SkillId](const FHyperTwistSkillValidationContractCase& Entry) + [&SkillId, ExecutionMode](const FHyperTwistSkillValidationContractCase& Entry) { return Entry.SkillId == SkillId && Entry.Kind == EHyperTwistSkillValidationContractKind::Eval - && Entry.ExecutionMode == EHyperTwistSkillValidationExecutionMode::LiveContract; + && Entry.ExecutionMode == ExecutionMode; } ); @@ -401,6 +422,11 @@ namespace HyperTwistSkillCoreLibraryInternal || SkillId == TEXT("skill/provider-routing-inspector"); } + bool IsCleanRoomCommandContractSkill(const FString& SkillId) + { + return SkillId == TEXT("skill/roux-session-review"); + } + FString MakeAnalyzerWrapperOutputKindId(const FString& ArtifactKind) { if (ArtifactKind == TEXT("artifact/architecture-scan")) @@ -480,6 +506,44 @@ namespace HyperTwistSkillCoreLibraryInternal return Output; } + FHyperTwistSkillCleanRoomCommandContractSpec MakeCleanRoomCommandContractSpec( + const FHyperTwistSkillManifestEntry& Entry + ) + { + FHyperTwistSkillCleanRoomCommandContractSpec Spec; + Spec.SpecId = TEXT("clean-room-command-spec/") + MakeInvocationSlug(Entry.SkillId); + Spec.SkillId = Entry.SkillId; + Spec.DisplayLabel = Entry.DisplayLabel + TEXT(" Command Contract"); + Spec.CommandSurfaceId = Entry.CommandBindings[0].CommandSurfaceId; + Spec.ServiceBindingId = Entry.CommandBindings[0].ServiceBindingId; + Spec.OwnerLaneId = Entry.OwnerLaneId; + Spec.OwnerFeatureId = Entry.OwnerFeatureId; + Spec.InvocationPattern = Entry.CommandBindings[0].InvocationPattern; + Spec.ArtifactKind = Entry.Provenance.ProducedArtifactKinds[0]; + Spec.PermissionScopeIds = MakePermissionScopeIds(Entry); + Spec.RequiredTemplateSectionIds = MakeRequiredAuthoringSectionIds(); + Spec.SafetyRuleIds = { + TEXT("safety/skills/first-party-terms-only"), + TEXT("safety/skills/optional-assistive-off-state-preserved"), + TEXT("safety/skills/derived-output-only"), + TEXT("safety/skills/provenance-ledger-required"), + TEXT("safety/skills/no-product-truth-mutation") + }; + Spec.SmokeExecutionMode = EHyperTwistSkillValidationExecutionMode::DeclarationOnly; + Spec.EvalExecutionMode = + EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSkillSpec; + Spec.bUsesFirstPartyTermsOnly = true; + Spec.bAvoidsDonorWording = true; + Spec.bPreservesOptionalAssistiveOffState = true; + Spec.bDerivedAssistiveOnly = true; + Spec.bRequiresProvenanceLedger = true; + Spec.bNoProductTruthMutation = true; + Spec.bFutureWrapperMayBindWithoutContractRewrite = true; + Spec.Summary = + TEXT("First-party clean-room command contract for a bounded Roux session review brief."); + return Spec; + } + FHyperTwistSkillCommandProvenanceState MakeCommandProvenanceState( const FHyperTwistSkillManifestEntry& Entry ) @@ -742,6 +806,7 @@ namespace HyperTwistSkillCoreLibraryInternal return EHyperTwistSkillValidationExecutionMode::LiveContract; case EHyperTwistSkillStatus::CommandContractPending: case EHyperTwistSkillStatus::CleanRoomSpecPending: + case EHyperTwistSkillStatus::CleanRoomCommandContractSpecified: return EHyperTwistSkillValidationExecutionMode::DeclarationOnly; case EHyperTwistSkillStatus::PlaceholderFamily: return EHyperTwistSkillValidationExecutionMode::PlaceholderStructureOnly; @@ -762,6 +827,8 @@ namespace HyperTwistSkillCoreLibraryInternal return EHyperTwistSkillValidationExecutionMode::DeferredUntilWrapper; case EHyperTwistSkillStatus::CleanRoomSpecPending: return EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSpec; + case EHyperTwistSkillStatus::CleanRoomCommandContractSpecified: + return EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSkillSpec; case EHyperTwistSkillStatus::PlaceholderFamily: return EHyperTwistSkillValidationExecutionMode::PlaceholderStructureOnly; default: @@ -814,11 +881,11 @@ namespace HyperTwistSkillCoreLibraryInternal FHyperTwistSkillRegistryState RegistryState; RegistryState.RegistryId = TEXT("skill-registry/first-party"); - RegistryState.ManifestVersion = TEXT("s2a-v1"); - RegistryState.ReferenceUtc = TEXT("2026-05-28T23:55:00Z"); + RegistryState.ManifestVersion = TEXT("s2b-v1"); + RegistryState.ReferenceUtc = TEXT("2026-05-29T00:45:00Z"); RegistryState.CommandSurfaceRootId = TEXT("command-surface/skills"); RegistryState.Summary = - TEXT("First-party skill registry and manifest contract with landed permissive analyzer wrappers."); + TEXT("First-party skill registry and manifest contract with landed permissive analyzer wrappers and landed clean-room command contracts."); RegistryState.Entries = { MakeSkillEntry( @@ -994,17 +1061,17 @@ namespace HyperTwistSkillCoreLibraryInternal TEXT("lane/skillization/training-clean-room"), TEXT("feature/skills/roux-session-review"), EHyperTwistSkillFamily::TrainingCoaching, - EHyperTwistSkillStatus::CleanRoomSpecPending, + EHyperTwistSkillStatus::CleanRoomCommandContractSpecified, false, false, { MakeCommandBinding( TEXT("command/skills/roux-session-review"), - TEXT("service/deferred/roux-session-review"), + TEXT("service/specs/training-review/roux-session-review"), TEXT("feature/skills/roux-session-review"), - TEXT("clean-room-command-spec"), + TEXT("contract/training-review-brief"), false, - TEXT("Restrictive lane remains spec-only until a later clean-room command contract lands.") + TEXT("First-party clean-room command contract for a bounded Roux session review brief.") ) }, { @@ -1025,9 +1092,9 @@ namespace HyperTwistSkillCoreLibraryInternal EHyperTwistSkillLogPolicy::InvocationLedgerRequired, {TEXT("artifact/training-review-brief")}, true, - TEXT("Restrictive skill outputs must stay provenance-visible if later clean-roomed.") + TEXT("Restrictive skill outputs must stay provenance-visible under any later clean-room wrapper.") ), - TEXT("Declared clean-room-pending training/coaching skill family.") + TEXT("Declared clean-room command-contract-specified training/coaching skill family.") ), MakeSkillEntry( TEXT("skill/curriculum-draft-pack"), @@ -1086,7 +1153,7 @@ namespace HyperTwistSkillCoreLibraryInternal RegistryState.StatusCounts = { MakeStatusCount(EHyperTwistSkillStatus::ImplementedNow, 4), - MakeStatusCount(EHyperTwistSkillStatus::CleanRoomSpecPending, 1), + MakeStatusCount(EHyperTwistSkillStatus::CleanRoomCommandContractSpecified, 1), MakeStatusCount(EHyperTwistSkillStatus::PlaceholderFamily, 1) }; @@ -1392,7 +1459,7 @@ FHyperTwistSkillAuthoringHarnessState UHyperTwistSkillCoreLibrary::DeriveSkillAu TEXT("field/eval-contract"), TEXT("Eval Contract"), TEXT("validation-harness"), - TEXT("LiveContract / DeferredUntilWrapper / DeferredUntilCleanRoomSpec"), + TEXT("LiveContract / DeferredUntilWrapper / DeferredUntilCleanRoomSpec / DeferredUntilCleanRoomSkillSpec"), TEXT("Per-skill eval validation mode.") ) }, @@ -1538,3 +1605,112 @@ FHyperTwistSkillAnalyzerWrapperState UHyperTwistSkillCoreLibrary::DeriveSkillAna return WrapperState; } + +FHyperTwistSkillCleanRoomCommandContractState +UHyperTwistSkillCoreLibrary::DeriveSkillCleanRoomCommandContractState( + const FHyperTwistSkillRegistryState& RegistryState, + const FHyperTwistSkillControlState& ControlState, + const FHyperTwistSkillAuthoringHarnessState& AuthoringHarnessState +) +{ + using namespace HyperTwistSkillCoreLibraryInternal; + + if (!RegistryState.IsStructurallyValid() + || !ControlState.IsStructurallyValid() + || !AuthoringHarnessState.IsStructurallyValid() + || RegistryState.RegistryId != ControlState.RegistryId + || RegistryState.RegistryId != AuthoringHarnessState.RegistryId + || RegistryState.CommandSurfaceRootId != ControlState.CommandSurfaceRootId + || RegistryState.CommandSurfaceRootId != AuthoringHarnessState.CommandSurfaceRootId) + { + return FHyperTwistSkillCleanRoomCommandContractState(); + } + + FHyperTwistSkillCleanRoomCommandContractState ContractState; + ContractState.RegistryId = RegistryState.RegistryId; + ContractState.ManifestVersion = TEXT("s2b-v1"); + ContractState.ReferenceUtc = TEXT("2026-05-29T00:47:00Z"); + ContractState.CommandSurfaceRootId = RegistryState.CommandSurfaceRootId; + ContractState.TemplateVersion = TEXT("skill-clean-room-command-contract-v1"); + ContractState.bEverySpecUsesFirstPartyTerms = true; + ContractState.bEverySpecAvoidsDonorWording = true; + ContractState.bEverySpecPreservesOptionalAssistiveOffState = true; + ContractState.bEverySpecRestrictsToDerivedAssistiveOutput = true; + ContractState.bEverySpecRequiresProvenanceLedger = true; + ContractState.bEverySpecAvoidsProductTruthMutation = true; + ContractState.bEverySpecMayBindFutureWrapperWithoutContractRewrite = true; + ContractState.bEverySpecHasAuthoringHarnessCoverage = true; + ContractState.bEverySpecDefersEvalUntilCleanRoomSkillSpec = true; + ContractState.Summary = + TEXT("First-party clean-room command-contract state for restrictive skill lanes."); + + for (const FHyperTwistSkillManifestEntry& Entry : RegistryState.Entries) + { + if (Entry.Status != EHyperTwistSkillStatus::CleanRoomCommandContractSpecified + || !IsCleanRoomCommandContractSkill(Entry.SkillId)) + { + continue; + } + + const FHyperTwistSkillControlStateEntry* ControlEntry = + FindControlStateEntryById(ControlState, Entry.SkillId); + const FHyperTwistSkillAuthoringExampleState* ExampleState = + FindAuthoringExampleBySkillId(AuthoringHarnessState, Entry.SkillId); + if (ControlEntry == nullptr + || !ControlEntry->IsStructurallyValid() + || !ControlEntry->bInstalled + || !ControlEntry->bOptionalAssistive + || ControlEntry->bEffectiveEnabled + || ExampleState == nullptr + || !ExampleState->IsStructurallyValid() + || !HasEvalValidationCaseWithMode( + AuthoringHarnessState, + Entry.SkillId, + EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSkillSpec + )) + { + return FHyperTwistSkillCleanRoomCommandContractState(); + } + + const FHyperTwistSkillCleanRoomCommandContractSpec Spec = + MakeCleanRoomCommandContractSpec(Entry); + if (!Spec.IsStructurallyValid()) + { + return FHyperTwistSkillCleanRoomCommandContractState(); + } + + ContractState.Specs.Add(Spec); + } + + TArray SkillIds; + TArray SafetyRuleIds; + for (const FHyperTwistSkillCleanRoomCommandContractSpec& Spec : ContractState.Specs) + { + SkillIds.AddUnique(Spec.SkillId); + ContractState.bEverySpecUsesFirstPartyTerms &= Spec.bUsesFirstPartyTermsOnly; + ContractState.bEverySpecAvoidsDonorWording &= Spec.bAvoidsDonorWording; + ContractState.bEverySpecPreservesOptionalAssistiveOffState + &= Spec.bPreservesOptionalAssistiveOffState; + ContractState.bEverySpecRestrictsToDerivedAssistiveOutput &= Spec.bDerivedAssistiveOnly; + ContractState.bEverySpecRequiresProvenanceLedger &= Spec.bRequiresProvenanceLedger; + ContractState.bEverySpecAvoidsProductTruthMutation &= Spec.bNoProductTruthMutation; + ContractState.bEverySpecMayBindFutureWrapperWithoutContractRewrite + &= Spec.bFutureWrapperMayBindWithoutContractRewrite; + ContractState.bEverySpecHasAuthoringHarnessCoverage + &= Spec.RequiredTemplateSectionIds.Num() > 0; + ContractState.bEverySpecDefersEvalUntilCleanRoomSkillSpec + &= Spec.EvalExecutionMode + == EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSkillSpec; + + for (const FString& SafetyRuleId : Spec.SafetyRuleIds) + { + SafetyRuleIds.AddUnique(SafetyRuleId); + } + } + + ContractState.SkillCount = SkillIds.Num(); + ContractState.SpecCount = ContractState.Specs.Num(); + ContractState.SafetyRuleCount = SafetyRuleIds.Num(); + + return ContractState; +} diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistBootstrap/HyperTwistContractLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistBootstrap/HyperTwistContractLibrary.h index 66f877d..d9297f5 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistBootstrap/HyperTwistContractLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistBootstrap/HyperTwistContractLibrary.h @@ -182,6 +182,10 @@ public: UFUNCTION(BlueprintPure, Category = "HyperTwist|Skills") static FHyperTwistSkillAnalyzerWrapperState MakeSampleSkillAnalyzerWrapperState(); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Skills") + static FHyperTwistSkillCleanRoomCommandContractState + MakeSampleSkillCleanRoomCommandContractState(); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training") static FHyperTwistTrainingRepositoryIntegrityReport MakeSampleTrainingRepositoryIntegrityReport(); @@ -396,6 +400,11 @@ public: const FHyperTwistSkillAnalyzerWrapperState& SkillAnalyzerWrapperState ); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Serialization") + static FString SerializeSkillCleanRoomCommandContractStateToJson( + const FHyperTwistSkillCleanRoomCommandContractState& SkillCleanRoomCommandContractState + ); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Serialization") static FString SerializeTrainingTimerExportPacketToJson(const FHyperTwistTrainingTimerExportPacket& TimerExportPacket); @@ -498,6 +507,12 @@ public: FHyperTwistSkillAnalyzerWrapperState& OutSkillAnalyzerWrapperState ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Serialization") + static bool DeserializeSkillCleanRoomCommandContractStateFromJson( + const FString& Json, + FHyperTwistSkillCleanRoomCommandContractState& OutSkillCleanRoomCommandContractState + ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Serialization") static bool DeserializeTrainingTimerExportPacketFromJson(const FString& Json, FHyperTwistTrainingTimerExportPacket& OutTimerExportPacket); }; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistSkills/HyperTwistSkillCoreLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistSkills/HyperTwistSkillCoreLibrary.h index b029117..f526e54 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistSkills/HyperTwistSkillCoreLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistSkills/HyperTwistSkillCoreLibrary.h @@ -39,4 +39,11 @@ public: const FHyperTwistSkillControlState& ControlState, const FHyperTwistSkillAuthoringHarnessState& AuthoringHarnessState ); + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Skills") + static FHyperTwistSkillCleanRoomCommandContractState DeriveSkillCleanRoomCommandContractState( + const FHyperTwistSkillRegistryState& RegistryState, + const FHyperTwistSkillControlState& ControlState, + const FHyperTwistSkillAuthoringHarnessState& AuthoringHarnessState + ); }; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistSkills/HyperTwistSkillTypes.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistSkills/HyperTwistSkillTypes.h index 520f885..1e669db 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistSkills/HyperTwistSkillTypes.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistSkills/HyperTwistSkillTypes.h @@ -10,6 +10,7 @@ enum class EHyperTwistSkillStatus : uint8 ImplementedNow UMETA(DisplayName = "Implemented Now"), CommandContractPending UMETA(DisplayName = "Command Contract Pending"), CleanRoomSpecPending UMETA(DisplayName = "Clean-Room Spec Pending"), + CleanRoomCommandContractSpecified UMETA(DisplayName = "Clean-Room Command Contract Specified"), PlaceholderFamily UMETA(DisplayName = "Placeholder Family") }; @@ -58,6 +59,7 @@ enum class EHyperTwistSkillValidationExecutionMode : uint8 DeclarationOnly UMETA(DisplayName = "Declaration Only"), DeferredUntilWrapper UMETA(DisplayName = "Deferred Until Wrapper"), DeferredUntilCleanRoomSpec UMETA(DisplayName = "Deferred Until Clean-Room Spec"), + DeferredUntilCleanRoomSkillSpec UMETA(DisplayName = "Deferred Until Clean-Room Skill Spec"), PlaceholderStructureOnly UMETA(DisplayName = "Placeholder Structure Only") }; @@ -1836,3 +1838,272 @@ struct FHyperTwistSkillAnalyzerWrapperState == bComputedOnlyImplementedPermissiveWrappersIncluded; } }; + +USTRUCT(BlueprintType) +struct FHyperTwistSkillCleanRoomCommandContractSpec +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString SpecId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString SkillId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString DisplayLabel; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CommandSurfaceId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ServiceBindingId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString OwnerLaneId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString OwnerFeatureId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString InvocationPattern; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ArtifactKind; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray PermissionScopeIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RequiredTemplateSectionIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray SafetyRuleIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + EHyperTwistSkillValidationExecutionMode SmokeExecutionMode = + EHyperTwistSkillValidationExecutionMode::None; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + EHyperTwistSkillValidationExecutionMode EvalExecutionMode = + EHyperTwistSkillValidationExecutionMode::None; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bUsesFirstPartyTermsOnly = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bAvoidsDonorWording = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bPreservesOptionalAssistiveOffState = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bDerivedAssistiveOnly = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bRequiresProvenanceLedger = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bNoProductTruthMutation = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bFutureWrapperMayBindWithoutContractRewrite = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Summary; + + bool IsStructurallyValid() const + { + if (SpecId.IsEmpty() + || SkillId.IsEmpty() + || DisplayLabel.IsEmpty() + || CommandSurfaceId.IsEmpty() + || ServiceBindingId.IsEmpty() + || OwnerLaneId.IsEmpty() + || OwnerFeatureId.IsEmpty() + || InvocationPattern.IsEmpty() + || ArtifactKind.IsEmpty() + || PermissionScopeIds.Num() == 0 + || RequiredTemplateSectionIds.Num() == 0 + || SafetyRuleIds.Num() == 0 + || SmokeExecutionMode != EHyperTwistSkillValidationExecutionMode::DeclarationOnly + || EvalExecutionMode + != EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSkillSpec + || !bUsesFirstPartyTermsOnly + || !bAvoidsDonorWording + || !bPreservesOptionalAssistiveOffState + || !bDerivedAssistiveOnly + || !bRequiresProvenanceLedger + || !bNoProductTruthMutation + || !bFutureWrapperMayBindWithoutContractRewrite) + { + return false; + } + + for (const FString& ScopeId : PermissionScopeIds) + { + if (ScopeId.IsEmpty()) + { + return false; + } + } + + for (const FString& SectionId : RequiredTemplateSectionIds) + { + if (SectionId.IsEmpty()) + { + return false; + } + } + + for (const FString& SafetyRuleId : SafetyRuleIds) + { + if (SafetyRuleId.IsEmpty()) + { + return false; + } + } + + return true; + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistSkillCleanRoomCommandContractState +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString RegistryId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ManifestVersion; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ReferenceUtc; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString CommandSurfaceRootId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString TemplateVersion; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray Specs; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + int32 SkillCount = 0; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + int32 SpecCount = 0; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + int32 SafetyRuleCount = 0; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecUsesFirstPartyTerms = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecAvoidsDonorWording = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecPreservesOptionalAssistiveOffState = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecRestrictsToDerivedAssistiveOutput = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecRequiresProvenanceLedger = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecAvoidsProductTruthMutation = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecMayBindFutureWrapperWithoutContractRewrite = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecHasAuthoringHarnessCoverage = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + bool bEverySpecDefersEvalUntilCleanRoomSkillSpec = false; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString Summary; + + bool IsStructurallyValid() const + { + if (RegistryId.IsEmpty() + || ManifestVersion.IsEmpty() + || ReferenceUtc.IsEmpty() + || CommandSurfaceRootId.IsEmpty() + || TemplateVersion.IsEmpty() + || Specs.Num() == 0 + || SkillCount <= 0 + || SpecCount != Specs.Num() + || SafetyRuleCount <= 0 + || !bEverySpecUsesFirstPartyTerms + || !bEverySpecAvoidsDonorWording + || !bEverySpecPreservesOptionalAssistiveOffState + || !bEverySpecRestrictsToDerivedAssistiveOutput + || !bEverySpecRequiresProvenanceLedger + || !bEverySpecAvoidsProductTruthMutation + || !bEverySpecMayBindFutureWrapperWithoutContractRewrite + || !bEverySpecHasAuthoringHarnessCoverage + || !bEverySpecDefersEvalUntilCleanRoomSkillSpec) + { + return false; + } + + TArray SeenSpecIds; + TArray SeenSkillIds; + TArray SeenSafetyRuleIds; + bool bComputedFirstPartyTerms = true; + bool bComputedAvoidsDonorWording = true; + bool bComputedPreservesOffState = true; + bool bComputedDerivedAssistiveOnly = true; + bool bComputedRequiresProvenanceLedger = true; + bool bComputedAvoidsProductTruthMutation = true; + bool bComputedMayBindWithoutRewrite = true; + bool bComputedHasHarnessCoverage = true; + bool bComputedDefersEvalUntilSkillSpec = true; + + for (const FHyperTwistSkillCleanRoomCommandContractSpec& Spec : Specs) + { + if (!Spec.IsStructurallyValid() || SeenSpecIds.Contains(Spec.SpecId)) + { + return false; + } + + SeenSpecIds.Add(Spec.SpecId); + SeenSkillIds.AddUnique(Spec.SkillId); + bComputedFirstPartyTerms &= Spec.bUsesFirstPartyTermsOnly; + bComputedAvoidsDonorWording &= Spec.bAvoidsDonorWording; + bComputedPreservesOffState &= Spec.bPreservesOptionalAssistiveOffState; + bComputedDerivedAssistiveOnly &= Spec.bDerivedAssistiveOnly; + bComputedRequiresProvenanceLedger &= Spec.bRequiresProvenanceLedger; + bComputedAvoidsProductTruthMutation &= Spec.bNoProductTruthMutation; + bComputedMayBindWithoutRewrite &= Spec.bFutureWrapperMayBindWithoutContractRewrite; + bComputedHasHarnessCoverage &= Spec.RequiredTemplateSectionIds.Num() > 0; + bComputedDefersEvalUntilSkillSpec &= + Spec.EvalExecutionMode + == EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSkillSpec; + + for (const FString& SafetyRuleId : Spec.SafetyRuleIds) + { + SeenSafetyRuleIds.AddUnique(SafetyRuleId); + } + } + + return SkillCount == SeenSkillIds.Num() + && SafetyRuleCount == SeenSafetyRuleIds.Num() + && bEverySpecUsesFirstPartyTerms == bComputedFirstPartyTerms + && bEverySpecAvoidsDonorWording == bComputedAvoidsDonorWording + && bEverySpecPreservesOptionalAssistiveOffState == bComputedPreservesOffState + && bEverySpecRestrictsToDerivedAssistiveOutput == bComputedDerivedAssistiveOnly + && bEverySpecRequiresProvenanceLedger == bComputedRequiresProvenanceLedger + && bEverySpecAvoidsProductTruthMutation == bComputedAvoidsProductTruthMutation + && bEverySpecMayBindFutureWrapperWithoutContractRewrite == bComputedMayBindWithoutRewrite + && bEverySpecHasAuthoringHarnessCoverage == bComputedHasHarnessCoverage + && bEverySpecDefersEvalUntilCleanRoomSkillSpec == bComputedDefersEvalUntilSkillSpec; + } +}; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS1ARegistryManifestContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS1ARegistryManifestContractTest.cpp index 8b6d6ad..e1762df 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS1ARegistryManifestContractTest.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS1ARegistryManifestContractTest.cpp @@ -93,6 +93,14 @@ bool FHyperTwistSkillPhaseS1ARegistryManifestTest::RunTest(const FString& Parame ), 4 ); + TestEqual( + TEXT("The sample S1-A registry must keep one clean-room command-contract-specified entry after S2-B lands."), + HyperTwistSkillPhaseS1ATestInternal::FindStatusCount( + RegistryState, + EHyperTwistSkillStatus::CleanRoomCommandContractSpecified + ), + 1 + ); TestEqual( TEXT("The sample S1-A registry must expose one governance-family entry."), HyperTwistSkillPhaseS1ATestInternal::FindFamilyCount( @@ -188,6 +196,29 @@ bool FHyperTwistSkillPhaseS1ADisabledSkillsRemainInstalledTest::RunTest( ); } + const FHyperTwistSkillManifestEntry* RouxSkill = + HyperTwistSkillPhaseS1ATestInternal::FindSkillById( + RegistryState, + TEXT("skill/roux-session-review") + ); + TestNotNull( + TEXT("A Roux session review skill entry must exist."), + RouxSkill + ); + if (RouxSkill != nullptr) + { + TestEqual( + TEXT("The Roux skill should now carry a clean-room command-contract-specified status."), + RouxSkill->Status, + EHyperTwistSkillStatus::CleanRoomCommandContractSpecified + ); + TestEqual( + TEXT("The Roux skill should now point to the first-party clean-room contract service id."), + RouxSkill->CommandBindings[0].ServiceBindingId, + FString(TEXT("service/specs/training-review/roux-session-review")) + ); + } + return true; } diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS1DAuthoringValidationHarnessContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS1DAuthoringValidationHarnessContractTest.cpp index 8fbd82c..75c89b8 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS1DAuthoringValidationHarnessContractTest.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS1DAuthoringValidationHarnessContractTest.cpp @@ -167,9 +167,9 @@ bool FHyperTwistSkillPhaseS1DValidationHarnessCoverageTest::RunTest(const FStrin if (RouxEval != nullptr) { TestEqual( - TEXT("The Roux skill eval contract should stay deferred until a clean-room spec lands."), + TEXT("The Roux skill eval contract should now defer only until the clean-room skill spec lands."), RouxEval->ExecutionMode, - EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSpec + EHyperTwistSkillValidationExecutionMode::DeferredUntilCleanRoomSkillSpec ); } diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS2BCleanRoomCommandContractSpecTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS2BCleanRoomCommandContractSpecTest.cpp new file mode 100644 index 0000000..7ab53a7 --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS2BCleanRoomCommandContractSpecTest.cpp @@ -0,0 +1,186 @@ +// Copyright HyperTwist, Inc. All Rights Reserved. + +#include "Misc/AutomationTest.h" + +#include "HyperTwistBootstrap/HyperTwistContractLibrary.h" + +#if WITH_AUTOMATION_TESTS + +namespace HyperTwistSkillPhaseS2BTestInternal +{ + const FHyperTwistSkillCleanRoomCommandContractSpec* FindSpecBySkillId( + const FHyperTwistSkillCleanRoomCommandContractState& ContractState, + const FString& SkillId + ) + { + for (const FHyperTwistSkillCleanRoomCommandContractSpec& Spec : ContractState.Specs) + { + if (Spec.SkillId == SkillId) + { + return &Spec; + } + } + + return nullptr; + } +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistSkillPhaseS2BCommandContractSpecTest, + "HyperTwist.FirstParty.Skill.PhaseS2B.CommandContractSpec", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistSkillPhaseS2BCommandContractSpecTest::RunTest(const FString& Parameters) +{ + const FHyperTwistSkillCleanRoomCommandContractState ContractState = + UHyperTwistContractLibrary::MakeSampleSkillCleanRoomCommandContractState(); + + TestTrue( + TEXT("The sample S2-B clean-room command-contract state should be structurally valid."), + ContractState.IsStructurallyValid() + ); + TestEqual( + TEXT("S2-B should land one restrictive clean-room command spec for the current skill family."), + ContractState.SkillCount, + 1 + ); + TestEqual( + TEXT("S2-B should expose one clean-room command spec."), + ContractState.SpecCount, + 1 + ); + + const FHyperTwistSkillCleanRoomCommandContractSpec* RouxSpec = + HyperTwistSkillPhaseS2BTestInternal::FindSpecBySkillId( + ContractState, + TEXT("skill/roux-session-review") + ); + TestNotNull( + TEXT("The Roux clean-room command spec should exist."), + RouxSpec + ); + if (RouxSpec != nullptr) + { + TestEqual( + TEXT("The Roux clean-room command spec should use the first-party contract service id."), + RouxSpec->ServiceBindingId, + FString(TEXT("service/specs/training-review/roux-session-review")) + ); + TestEqual( + TEXT("The Roux clean-room command spec should use the first-party training-review contract pattern."), + RouxSpec->InvocationPattern, + FString(TEXT("contract/training-review-brief")) + ); + } + + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistSkillPhaseS2BSafetyModelTest, + "HyperTwist.FirstParty.Skill.PhaseS2B.SafetyModel", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistSkillPhaseS2BSafetyModelTest::RunTest(const FString& Parameters) +{ + const FHyperTwistSkillCleanRoomCommandContractState ContractState = + UHyperTwistContractLibrary::MakeSampleSkillCleanRoomCommandContractState(); + + TestTrue( + TEXT("The sample S2-B clean-room command-contract state should be structurally valid."), + ContractState.IsStructurallyValid() + ); + TestTrue( + TEXT("Every S2-B spec should stay in first-party terms."), + ContractState.bEverySpecUsesFirstPartyTerms + ); + TestTrue( + TEXT("Every S2-B spec should avoid donor wording."), + ContractState.bEverySpecAvoidsDonorWording + ); + TestTrue( + TEXT("Every S2-B spec should preserve the optional-assistive off-state."), + ContractState.bEverySpecPreservesOptionalAssistiveOffState + ); + TestTrue( + TEXT("Every S2-B spec should stay derived-assistive only."), + ContractState.bEverySpecRestrictsToDerivedAssistiveOutput + ); + TestTrue( + TEXT("Every S2-B spec should keep provenance-ledger requirements."), + ContractState.bEverySpecRequiresProvenanceLedger + ); + TestTrue( + TEXT("Every S2-B spec should avoid product-truth mutation."), + ContractState.bEverySpecAvoidsProductTruthMutation + ); + TestTrue( + TEXT("Every S2-B spec should allow a future wrapper to bind without rewriting the contract."), + ContractState.bEverySpecMayBindFutureWrapperWithoutContractRewrite + ); + TestTrue( + TEXT("Every S2-B spec should already have authoring-harness coverage."), + ContractState.bEverySpecHasAuthoringHarnessCoverage + ); + TestTrue( + TEXT("Every S2-B spec should defer eval only until the clean-room skill spec phase."), + ContractState.bEverySpecDefersEvalUntilCleanRoomSkillSpec + ); + + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistSkillPhaseS2BSerializationRoundTripTest, + "HyperTwist.FirstParty.Skill.PhaseS2B.SerializationRoundTrip", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistSkillPhaseS2BSerializationRoundTripTest::RunTest(const FString& Parameters) +{ + const FHyperTwistSkillCleanRoomCommandContractState ContractState = + UHyperTwistContractLibrary::MakeSampleSkillCleanRoomCommandContractState(); + + TestTrue( + TEXT("The sample S2-B clean-room command-contract state should be structurally valid before serialization."), + ContractState.IsStructurallyValid() + ); + + const FString Json = + UHyperTwistContractLibrary::SerializeSkillCleanRoomCommandContractStateToJson( + ContractState + ); + TestTrue( + TEXT("Serialized S2-B JSON should include the future-wrapper binding guard field."), + Json.Contains(TEXT("bEverySpecMayBindFutureWrapperWithoutContractRewrite")) + ); + + FHyperTwistSkillCleanRoomCommandContractState RoundTrippedState; + TestTrue( + TEXT("Deserializing the S2-B clean-room command-contract JSON should succeed."), + UHyperTwistContractLibrary::DeserializeSkillCleanRoomCommandContractStateFromJson( + Json, + RoundTrippedState + ) + ); + TestTrue( + TEXT("Round-tripped S2-B clean-room command-contract state should remain structurally valid."), + RoundTrippedState.IsStructurallyValid() + ); + TestEqual( + TEXT("Round-tripped S2-B spec count should match the original sample."), + RoundTrippedState.SpecCount, + ContractState.SpecCount + ); + TestEqual( + TEXT("Round-tripped S2-B safety-rule count should match the original sample."), + RoundTrippedState.SafetyRuleCount, + ContractState.SafetyRuleCount + ); + + return true; +} + +#endif diff --git a/docs/arch/HYPERTWIST_PHASES2_B_FIRST_PARTY_CLEAN_ROOM_COMMAND_CONTRACT_SPECS_IMPLEMENTATION_PACKET_2026-05-29.md b/docs/arch/HYPERTWIST_PHASES2_B_FIRST_PARTY_CLEAN_ROOM_COMMAND_CONTRACT_SPECS_IMPLEMENTATION_PACKET_2026-05-29.md new file mode 100644 index 0000000..2b2c90d --- /dev/null +++ b/docs/arch/HYPERTWIST_PHASES2_B_FIRST_PARTY_CLEAN_ROOM_COMMAND_CONTRACT_SPECS_IMPLEMENTATION_PACKET_2026-05-29.md @@ -0,0 +1,92 @@ +# HyperTwist Phase S2-B first-party clean-room command-contract specs implementation packet + +Created on `2026-05-29` + +## Status + +- first-party HyperTwist packet +- bounded `Phase S2-B` implementation slice + +## Purpose + +This packet lands the bounded first-party clean-room command-contract seam +under the canonical `Skillization And Command Surface` doctrine. + +The landed slice is: + +- first-party command-contract specs for restrictive lanes +- bounded safety model for future clean-room skill work + +It is not: + +- live clean-room skill implementation +- donor command promotion +- broader training/coaching pack widening + +## Current authority basis + +This implementation packet stands on: + +- `docs/ops/HYPERTWIST_SKILLIZATION_AND_COMMAND_SURFACE_DOCTRINE_2026-05-21.md` +- `docs/ops/HYPERTWIST_OPTIONAL_ASSISTIVE_FEATURE_DEACTIVATION_AND_REMOVABILITY_DOCTRINE_2026-05-21.md` +- `docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/SKILLS.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/PROVENANCE_AND_TRUST_MODEL.md` +- `docs/arch/HYPERTWIST_PHASES2_B_FIRST_PARTY_CLEAN_ROOM_COMMAND_CONTRACT_SPECS_PREPARATION_PACKET_2026-05-29.md` + +## Landed scope + +The current code now owns a bounded first-party clean-room command seam +through: + +- registry promotion for: + - `skill/roux-session-review` +- stable first-party command/service contract declarations for: + - bounded Roux session review briefing +- canonical clean-room command-contract and aggregate state contracts in: + - `HyperTwistSkillTypes.h` +- first-party command-contract derivation over the landed registry, control-state, and authoring-harness seams in: + - `UHyperTwistSkillCoreLibrary` +- sample contract helpers in: + - `UHyperTwistContractLibrary::MakeSampleSkillCleanRoomCommandContractState()` + - `UHyperTwistContractLibrary::SerializeSkillCleanRoomCommandContractStateToJson(...)` + - `UHyperTwistContractLibrary::DeserializeSkillCleanRoomCommandContractStateFromJson(...)` +- focused automation coverage in: + - `HyperTwistSkillPhaseS2BCleanRoomCommandContractSpecTest.cpp` + +## Why this is still intentionally bounded + +This packet lands clean-room command contracts and safety rules only. + +Still deferred: + +- live clean-room skill wrappers +- broader training/coaching pack widening + +## Validation + +Build validation: + +- `UnrealHyperTwistEditor Win64 Development` + +Focused automation validation: + +- `HyperTwist.FirstParty.Skill.PhaseS2B.CommandContractSpec` +- `HyperTwist.FirstParty.Skill.PhaseS2B.SafetyModel` +- `HyperTwist.FirstParty.Skill.PhaseS2B.SerializationRoundTrip` + +Observed: + +- `3` focused `Phase S2-B` automation tests succeeded + +## Queue effect + +This packet consumes the current `Phase S2-B` implementation slice. + +After this landing: + +- `S2-B` is landed in current code +- `S2-C` is the next clean skillization move +- live clean-room skill behavior still remains deferred behind `S2-C` diff --git a/docs/arch/HYPERTWIST_PHASES2_B_FIRST_PARTY_CLEAN_ROOM_COMMAND_CONTRACT_SPECS_PREPARATION_PACKET_2026-05-29.md b/docs/arch/HYPERTWIST_PHASES2_B_FIRST_PARTY_CLEAN_ROOM_COMMAND_CONTRACT_SPECS_PREPARATION_PACKET_2026-05-29.md new file mode 100644 index 0000000..ec61731 --- /dev/null +++ b/docs/arch/HYPERTWIST_PHASES2_B_FIRST_PARTY_CLEAN_ROOM_COMMAND_CONTRACT_SPECS_PREPARATION_PACKET_2026-05-29.md @@ -0,0 +1,86 @@ +# HyperTwist Phase S2-B first-party clean-room command-contract specs preparation packet + +Created on `2026-05-29` + +## Status + +- first-party HyperTwist packet +- source-backed `Phase S2-B` preparation/control slice + +## Purpose + +This packet scopes the bounded clean-room command-contract seam under the +canonical `Skillization And Command Surface` doctrine. + +The granted slice is: + +- first-party command-contract specs for restrictive lanes +- bounded safety model for future clean-room skill work + +It is not: + +- live clean-room skill implementation +- donor command promotion +- broader training/coaching pack widening + +## Current authority basis + +This control pass stands on: + +- `docs/ops/HYPERTWIST_SKILLIZATION_AND_COMMAND_SURFACE_DOCTRINE_2026-05-21.md` +- `docs/ops/HYPERTWIST_OPTIONAL_ASSISTIVE_FEATURE_DEACTIVATION_AND_REMOVABILITY_DOCTRINE_2026-05-21.md` +- `docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/SKILLS.md` +- `docs/v6_5_deep_manual_pack/HyperTwist/PROVENANCE_AND_TRUST_MODEL.md` +- `docs/arch/HYPERTWIST_PHASES2_A_FIRST_PARTY_PERMISSIVE_ANALYZER_WRAPPERS_IMPLEMENTATION_PACKET_2026-05-28.md` + +## Granted family + +The bounded `Phase S2-B` slice may land: + +1. first-party clean-room command-contract spec state for restrictive skill lanes +2. first-party safety rules for off-state preservation, provenance, derived-only output, and no product-truth mutation +3. registry/state-model promotion from generic clean-room pending to clean-room contract specified +4. sample contract helpers and JSON round-trip coverage + +The packet must stay out of: + +- live clean-room skill wrappers +- broader training/coaching domain-pack widening +- donor-derived wording or contract shapes + +## Proposed implementation shape + +Land the narrower first-party boundary through: + +- registry promotion for the current restrictive skillization lane: + - `skill/roux-session-review` +- first-party command/service binding update for the current restrictive skill contract +- explicit clean-room command-contract spec types and aggregate state +- first-party spec derivation over the landed registry, control, and authoring-harness seams +- sample contract helpers for: + - command-contract-state derivation + - JSON serialization + - JSON deserialization +- focused automation in: + - `HyperTwistSkillPhaseS2BCleanRoomCommandContractSpecTest.cpp` + +## Validation target + +Validate with: + +- Unreal build for `UnrealHyperTwistEditor Win64 Development` +- focused automation: + - `HyperTwist.FirstParty.Skill.PhaseS2B.CommandContractSpec` + - `HyperTwist.FirstParty.Skill.PhaseS2B.SafetyModel` + - `HyperTwist.FirstParty.Skill.PhaseS2B.SerializationRoundTrip` + +## Queue effect + +If this packet lands cleanly: + +- `S2-B` is consumed +- `S2-C` becomes the next clean move +- live clean-room skill behavior still remains deferred behind `S2-C` diff --git a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md index f805c0c..9d9540b 100644 --- a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md +++ b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md @@ -281,4 +281,6 @@ Specifically: packet is now landed in current code - the bounded first-party `Phase S2-A` permissive analyzer wrapper packet is now landed in current code -- `S2-B` clean-room command-contract specs are now the next clean move +- the bounded first-party `Phase S2-B` clean-room command-contract packet is + now landed in current code +- `S2-C` clean-room skill specs are now the next clean move diff --git a/docs/ops/HYPERTWIST_SKILLIZATION_AND_COMMAND_SURFACE_DOCTRINE_2026-05-21.md b/docs/ops/HYPERTWIST_SKILLIZATION_AND_COMMAND_SURFACE_DOCTRINE_2026-05-21.md index 656170d..0064644 100644 --- a/docs/ops/HYPERTWIST_SKILLIZATION_AND_COMMAND_SURFACE_DOCTRINE_2026-05-21.md +++ b/docs/ops/HYPERTWIST_SKILLIZATION_AND_COMMAND_SURFACE_DOCTRINE_2026-05-21.md @@ -269,7 +269,8 @@ Current state: packet is now landed in current code - the bounded first-party `Phase S2-A` permissive analyzer wrapper packet is now landed in current code -- restrictive clean-room command-contract specs remain deferred to `S2-B` +- the bounded first-party `Phase S2-B` clean-room command-contract packet is + now landed in current code ### S2 - refactor and analyzer skills @@ -295,6 +296,8 @@ Current state: - review/analyzer wrappers now own architecture scan and policy scan output - provider/ops wrappers now own route inspection output - memory/continuity wrappers now own watch-and-recheck output +- restrictive training/coaching lanes now have first-party clean-room + command-contract specs and a bounded safety model #### `S2-B` clean-room command-contract spec @@ -311,6 +314,13 @@ Acceptance gates: - a future skill can wrap the first-party contract without donor wording +Current state: + +- the bounded first-party `Phase S2-B` packet is now landed in current code +- restrictive training/coaching lanes now carry first-party command-contract + specs in HyperTwist-owned terms +- eval posture now defers only until `S2-C` clean-room skill specs + #### `S2-C` clean-room skill specs Outputs: @@ -491,7 +501,7 @@ These are target-shape command families, not claims of implemented reality. The next correct sequence is: -1. `S2-B` clean-room command-contract specs for restrictive lanes +1. `S2-C` clean-room skill specs for restrictive lanes 2. broader memory, browser, workflow, provider, and domain skill widening Broader memory, browser, workflow, provider, and domain skill widening should diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md b/docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md index e5a7b59..4055afe 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/ARCHITECTURE.md @@ -247,3 +247,5 @@ Future skill growth must follow: fresh structure - the bounded first-party `Phase S2-A` permissive analyzer wrapper seam is now the live product base before restrictive command-spec widening +- the bounded first-party `Phase S2-B` clean-room command-contract seam is now + the live spec-only safety layer before restrictive skill-spec widening 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 58a9dba..1526513 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md @@ -304,10 +304,11 @@ repo. | Feature | Status | Primary authority | Notes | |---|---|---|---| -| First-party skill registry and enable/disable governance | Implemented now | landed first-party `Phase S1-A`, `Phase S1-B`, `Phase S1-C`, `Phase S1-D`, and `Phase S2-A` packets | Current bounded first-party skill status/family contracts, command/service binding declarations, permission/scope declarations, provenance/log declarations, manifest entries, registry counts, durable master-switch/per-skill control-state, family visibility groups, disabled-but-installed inert-off-state truth, invocation-record format, command/service provenance, failure/cancel audit-ledger storage, authoring-template sections, registry-grounded examples, per-skill smoke/eval validation-harness contracts, and structured permissive wrapper-output contracts are live. `S2-B` is now the next bounded skillization seam. | +| First-party skill registry and enable/disable governance | Implemented now | landed first-party `Phase S1-A`, `Phase S1-B`, `Phase S1-C`, `Phase S1-D`, `Phase S2-A`, and `Phase S2-B` packets | Current bounded first-party skill status/family contracts, command/service binding declarations, permission/scope declarations, provenance/log declarations, manifest entries, registry counts, durable master-switch/per-skill control-state, family visibility groups, disabled-but-installed inert-off-state truth, invocation-record format, command/service provenance, failure/cancel audit-ledger storage, authoring-template sections, registry-grounded examples, per-skill smoke/eval validation-harness contracts, structured permissive wrapper-output contracts, and first-party clean-room command-contract specs with a bounded safety model are live. `S2-C` is now the next bounded skillization seam. | | Review/analyzer skill family | Implemented now | landed first-party `Phase S2-A` packet | Current bounded first-party review/analyzer wrappers are live for architecture scan and policy scan output over permissive product evidence. Broader review/diff/plan helper widening still remains future work. | | Memory/continuity skill family | Deep-source grounded retained + bounded live wrapper | landed first-party `Phase S2-A` packet + skillization + memory doctrine | Current bounded watch-and-recheck wrapper output is live above the landed first-party memory seams, while broader memory/continuity skill widening still remains retained. | | Provider/ops skill family | Deep-source grounded retained + bounded live wrapper | landed first-party `Phase S2-A` packet + skillization + provider doctrine | Current bounded route-inspection wrapper output is live above the landed provider-neutral speech/provider seams, while broader provider/ops skill widening still remains retained. | +| Restrictive training/coaching skill command-contract family | Implemented now, spec-only bounded seam | landed first-party `Phase S2-B` packet + skillization doctrine | Current restrictive training/coaching skillization seam is command-contract-only and safety-model-only. HyperTwist now owns the first-party clean-room Roux session review contract in product terms, while live clean-room skill behavior still remains deferred until `S2-C` clean-room skill specs. | | Domain/creative skill packs | Shallow placeholder | skillization doctrine only | Keep internal until source-grounded. | ## Shallow-known placeholder families diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/PROVENANCE_AND_TRUST_MODEL.md b/docs/v6_5_deep_manual_pack/HyperTwist/PROVENANCE_AND_TRUST_MODEL.md index 2d46660..7d9b67d 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/PROVENANCE_AND_TRUST_MODEL.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/PROVENANCE_AND_TRUST_MODEL.md @@ -112,6 +112,9 @@ The landed bounded first-party `Phase S1-A` packet keeps: architecture scan, policy scan, route inspection, and watch-and-recheck wrapper outputs provenance-visible through first-party command/service bindings rather than deferred wrapper prose +- the landed bounded first-party `Phase S2-B` packet now keeps restrictive + skill command contracts first-party, provenance-visible, and explicitly + unable to mutate product truth ## Memory-specific consequence diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md index e26243b..010b752 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md @@ -177,7 +177,9 @@ Canonical discovery surfaces for roadmap interpretation: pass is now consumed - the bounded first-party `Phase S2-A` permissive analyzer wrapper packet is now landed in current code -- `S2-B` clean-room command-contract specs are now the next clean move +- the bounded first-party `Phase S2-B` clean-room command-contract packet is + now landed in current code +- `S2-C` clean-room skill specs are now the next clean move - the generic source-backed `Phase 6R-R` shared classic-cube recognition multi-face correction/explanation control pass is now consumed - the bounded permissive `Phase 6R-R` shared classic-cube recognition multi-face diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/SKILLS.md b/docs/v6_5_deep_manual_pack/HyperTwist/SKILLS.md index 2ffab0f..0205f56 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/SKILLS.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/SKILLS.md @@ -130,8 +130,8 @@ A coding model working on HyperTwist should still be able to: The next correct skillization sequence is: -1. permissive analyzer wrappers -2. clean-room command-contract specs for restrictive lanes +1. clean-room skill specs for restrictive lanes +2. continuity and resume skills Broader memory, provider, and domain skill widening should wait until that base exists.