feat: add generated scene skill platform hardening

tests/scene_generator_family_policy_test.rs

@@ -0,0 +1,121 @@
+use std::fs;
+
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct FamilyResults {
+    #[serde(rename = "generatedAt")]
+    generated_at: String,
+    scope: String,
+    families: Vec<FamilyResult>,
+}
+
+#[derive(Debug, Deserialize)]
+struct FamilyResult {
+    id: String,
+    group: String,
+    #[serde(rename = "familyName")]
+    family_name: String,
+    #[serde(rename = "representativeRuns")]
+    representative_runs: u32,
+    #[serde(rename = "expansionRuns", default)]
+    expansion_runs: u32,
+    #[serde(rename = "candidateBatchCount", default)]
+    candidate_batch_count: u32,
+    #[serde(rename = "passedRuns")]
+    passed_runs: u32,
+    #[serde(rename = "failedRuns")]
+    failed_runs: u32,
+    #[serde(rename = "successRate")]
+    success_rate: f64,
+    #[serde(rename = "failureTaxonomy")]
+    failure_taxonomy: Vec<String>,
+    notes: Vec<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct FamilyExpansionPolicy {
+    #[serde(rename = "policyVersion")]
+    policy_version: String,
+    scope: String,
+    #[serde(rename = "mainlineGroups")]
+    mainline_groups: Vec<GroupPolicy>,
+    #[serde(rename = "boundaryGroups", default)]
+    boundary_groups: Vec<GroupPolicy>,
+    #[serde(rename = "deferredGroups")]
+    deferred_groups: Vec<GroupPolicy>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GroupPolicy {
+    group: String,
+    policy: String,
+    #[serde(rename = "executionRule")]
+    execution_rule: String,
+    #[serde(rename = "acceptanceFocus", default)]
+    acceptance_focus: Vec<String>,
+}
+
+#[test]
+fn family_results_asset_is_actionable() {
+    let results: FamilyResults = serde_json::from_str(
+        &fs::read_to_string("tests/fixtures/generated_scene/p1_family_results.json").unwrap(),
+    )
+    .unwrap();
+
+    assert!(!results.generated_at.is_empty());
+    assert!(results.scope.contains("representative"));
+    assert_eq!(results.families.len(), 7);
+
+    for family in results.families {
+        assert!(matches!(
+            family.group.as_str(),
+            "G1" | "G2" | "G3" | "G6" | "G7" | "G8"
+        ));
+        assert!(!family.id.is_empty());
+        assert!(!family.family_name.is_empty());
+        assert!(family.representative_runs >= 1);
+        assert!(family.candidate_batch_count <= 102);
+        assert_eq!(
+            family.representative_runs + family.expansion_runs,
+            family.passed_runs + family.failed_runs
+        );
+        assert!(family.success_rate >= 0.0 && family.success_rate <= 1.0);
+        assert!(!family.failure_taxonomy.is_empty());
+        assert!(!family.notes.is_empty());
+    }
+}
+
+#[test]
+fn family_expansion_policy_matches_mainline_scope() {
+    let policy: FamilyExpansionPolicy = serde_json::from_str(
+        &fs::read_to_string("tests/fixtures/generated_scene/family_expansion_policy.json").unwrap(),
+    )
+    .unwrap();
+
+    assert!(!policy.policy_version.is_empty());
+    assert_eq!(policy.scope, "roadmap-plan-track-e");
+    assert_eq!(policy.mainline_groups.len(), 3);
+    assert_eq!(policy.boundary_groups.len(), 3);
+    assert_eq!(policy.deferred_groups.len(), 2);
+
+    for group in &policy.mainline_groups {
+        assert!(matches!(group.group.as_str(), "G1" | "G2" | "G3"));
+        assert_eq!(group.policy, "mainline");
+        assert!(!group.execution_rule.is_empty());
+        assert!(!group.acceptance_focus.is_empty());
+    }
+
+    for group in &policy.boundary_groups {
+        assert!(matches!(group.group.as_str(), "G6" | "G7" | "G8"));
+        assert_eq!(group.policy, "boundary-runtime");
+        assert!(!group.execution_rule.is_empty());
+        assert!(!group.acceptance_focus.is_empty());
+    }
+
+    for group in &policy.deferred_groups {
+        assert!(matches!(group.group.as_str(), "G4" | "G5"));
+        assert!(matches!(group.policy.as_str(), "deferred" | "degraded"));
+        assert!(!group.execution_rule.is_empty());
+    }
+}