Implement Phase S2-B clean-room command-contract specs

2026-05-29 00:37:43 +02:00 · 2026-05-29 00:37:43 +02:00 · 5cc553d0d4
commit 5cc553d0d4
parent 28b546eb69
17 changed files with 941 additions and 22 deletions
--- 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
--- 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<FString> 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<FString> SkillIds;
+	TArray<FString> 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;
+}
--- 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);
 };
--- 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
+	);
 };
--- 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<FString> PermissionScopeIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RequiredTemplateSectionIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> 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<FHyperTwistSkillCleanRoomCommandContractSpec> 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<FString> SeenSpecIds;
+		TArray<FString> SeenSkillIds;
+		TArray<FString> 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;
+	}
+};
--- 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;
 }

--- 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
 		);
 	}

--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistSkillPhaseS2BCleanRoomCommandContractSpecTest.cpp
+++ 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
--- 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
@ -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`
--- 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
@ -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`
--- 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
--- 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
--- 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
--- 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
--- 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

--- 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
--- 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.