aero-agent-roles 1.0.0

package/roles/flight-test-performance-engineer/templates/performance-report-template.md

@@ -0,0 +1,105 @@
+# Flight Test Performance Data Analysis Report
+
+**Aircraft:** FT-2 Worked-Example Turbofan Regional Jet
+**Sortie:** SORTIE-FT2-047
+**Basis:** FAR/CS-25 (context only)
+**Status:** draft-for-review
+
+_Flight data below are SIMULATED for the worked example and must be replaced by recorded flight data._
+
+## 1. Test conditions and data quality
+
+- Field pressure altitude: 152 m (500 ft); OAT 22.0 C (ISA deviation +8.0 K).
+- Test-day density ratio sigma = 0.9588 (rho = 1.1745 kg/m^3); density altitude 436 m (1432 ft).
+- Reference gross weight for corrections: 250000 N. Wing area 122.6 m^2; drag polar cd0 = 0.020, k = 0.042.
+- Data quality: takeoff trace ok; level-acceleration trace ok.
+
+## 2. Takeoff performance
+
+Run TO-1 at W = 240000 N: liftoff 46.0 m/s at a mean acceleration of 2.30 m/s^2.
+
+| Leg | Measured (m) | Predicted (m) |
+|---|---|---|
+| Ground roll (to rotation) | 440.0 | 460.0 |
+| Rotation | 130.2 | 130.2 |
+| Airborne to 35 ft | 81.8 | 81.8 |
+| **Takeoff distance** | **652.1** | **672.0** |
+
+Engine-out (OEI) continued takeoff at V1 = 38.0 m/s, V2 = 46.3 m/s: failure leg 293.5 m + recognition 38.0 m + continued ground 159.0 m + climb 176.4 m = **666.9 m**.
+Accelerate-stop at V1 = 38.0 m/s: accelerate 313.9 m + stop 175.3 m = **489.2 m**.
+
+## 3. Landing performance
+
+Run LD-1 at W = 232000 N: Vs0 at run weight 33.83 m/s EAS, Vref = 41.61 m/s EAS (1.23 x Vs0), 42.49 m/s TAS at the test-day density ratio.
+
+| Segment | Measured (m) | Model (m) |
+|---|---|---|
+| Airborne (flare) | 212.5 | 212.5 |
+| Ground roll (braking) | 231.5 | 219.2 |
+| **Demonstrated total** | **443.9** | 431.7 |
+
+Certified field length = 1.67 x demonstrated = **741.4 m** against a 900 m runway: FITS (margin +158.6 m).
+
+## 4. Level-acceleration thrust determination
+
+Run LA-1 at 8000 m (ISA density 0.5252 kg/m^3), W = 250000 N, trace smoothed over a 5-sample window; assessment region samples 4-18.
+
+| Quantity | Value |
+|---|---|
+| Mean acceleration | 1.000 m/s^2 |
+| Mean specific excess power P_s | 16.315 m/s |
+| Mean excess thrust (drag gap) | 25492.9 N |
+| Mean drag (polar) | 19686.8 N |
+| **Mean thrust available** | **45179.8 N** |
+| Sustained acceleration over band | PASS |
+| P_s at reference weight and standard density | 13.773 m/s |
+
+## 5. Cruise performance (fuel flow reduction)
+
+Measured fuel flows corrected from the test weight to the reference weight with the sqrt(w_ref/w_test) correction at 10668 m; range performance rp = V_tas / wf_corrected.
+
+| Mach | wf (kg/s) | wf corr (kg/s) | rp (m/kg) | fitted rp |
+|---|---|---|---|---|
+| 0.70 | 0.455 | 0.464 | 447.0 | 445.6 |
+| 0.74 | 0.442 | 0.453 | 484.4 | 488.6 |
+| 0.78 | 0.448 | 0.461 | 501.6 | 497.4 |
+| 0.82 | 0.500 | 0.517 | 470.5 | 471.9 |
+
+Quadratic range-performance fit rp(M) = -10708.552 M^2 +16496.371 M -5854.7; maximum range cruise at M = 0.770; long range cruise (99% of max rp) at M = 0.792.
+Fit residuals RMS: 3.1 m/kg (mean rp 475.9 m/kg).
+
+## 6. Stall speeds and V-speed corrections
+
+| Config | Vs measured (m/s EAS) | Vs predicted at run weight (m/s EAS) | Delta | Margin |
+|---|---|---|---|---|
+| clean | 39.90 | 39.98 | -0.19% | -0.002 |
+| landing | 34.10 | 33.83 | +0.81% | +0.008 |
+
+Weight correction v(w) = v_ref * sqrt(w/w_ref) applied to the reference stall speeds Vs1g = 40.80 m/s EAS and Vs0 = 35.11 m/s EAS.
+
+## 7. Computed vs predicted scatter
+
+| Item | Measured | Predicted | Delta (%) | Within %+10.0 |
+|---|---|---|---|---|
+| takeoff ground roll | 440.0 | 460.0 | +4.53 | PASS |
+| takeoff distance (35 ft) | 652.1 | 672.0 | +3.06 | PASS |
+| landing ground roll | 231.5 | 219.2 | -5.31 | PASS |
+| landing distance | 443.9 | 431.7 | -2.77 | PASS |
+| cruise rp M=0.70 | 447.0 | 445.6 | -0.32 | PASS |
+| cruise rp M=0.74 | 484.4 | 488.6 | +0.87 | PASS |
+| cruise rp M=0.78 | 501.6 | 497.4 | -0.84 | PASS |
+| cruise rp M=0.82 | 470.5 | 471.9 | +0.30 | PASS |
+| Vs1g clean | 39.9 | 40.0 | +0.19 | PASS |
+| Vs1g landing | 34.1 | 33.8 | -0.80 | PASS |
+
+Maximum absolute scatter: +5.31% (band +10%) -> within band.
+
+## 8. Findings
+
+- Takeoff distance legs are complete and the measured ground roll agrees with the constant-acceleration model within the band.
+- Landing certified field length (1.67 x demonstrated) fits the available runway (margin +159 m).
+- Level-acceleration thrust determination is internally consistent (drag-polar closure) and reduces to the reference conditions.
+- Cruise maximum-range Mach and long-range-cruise Mach read off the fitted range-performance curve with an RMS residual of 3.1 m/kg.
+
+---
+*Generated by Aero Agent Roles flight-test-performance-engineer core. DRAFT for human review by the flight test / performance lead. Not an approval document and not a performance guarantee.*

package/roles/flight-test-performance-engineer/tests/test_flight_test_performance_engineer_core.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""Test flight_test_performance_core: the executable engine of the
+Flight Test Performance Engineer role.
+
+Proves the role can DO its job standalone (no AeroSkills needed):
+ISA reduction to standard conditions, takeoff/landing distance
+reductions, level-acceleration thrust determination, cruise fuel-flow
+reduction, speed corrections, report generation, and evidence gates.
+Anchors are real worked values (ISA physics, leaf-documented method
+anchors, and the deterministic worked-example sortie).
+"""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "core"))
+from flight_test_performance_core import (  # noqa: E402
+    APPROACH_FACTOR, FIELD_LENGTH_FACTOR, G0, OBSTACLE_35FT_M,
+    analyze_sortie, build_report, check_report, check_report_markdown,
+    constant_accel_distance, corrected_fuel_flow, density_altitude_m,
+    drag_from_polar, engine_failure_distance, example_item,
+    example_report_markdown, example_report_model, excess_thrust_from_ps,
+    ground_roll_integrate, isa_conditions, isa_density_ratio_m,
+    ps_at_reference_conditions, range_performance, reduce_accelerate_stop,
+    reduce_cruise_points, reduce_landing_run, reduce_level_accel_run,
+    reduce_oei_takeoff, reduce_takeoff_run, render_report_markdown,
+    specific_excess_power, stall_margin, tas_from_eas, tas_from_mach,
+    day_sigma_from_alt_oat, vs1g_from_wing_loading,
+    weight_corrected_ps,
+    weight_corrected_speed,
+)
+
+
+class TestIsaAtmosphere(unittest.TestCase):
+    """Reduction to ISA / standard conditions: real physics anchors."""
+
+    def test_isa_sea_level_anchor(self):
+        t, p, rho = isa_conditions(0.0)
+        self.assertAlmostEqual(t, 288.15, places=2)
+        self.assertAlmostEqual(p, 101325.0, places=1)
+        self.assertAlmostEqual(rho, 1.225, places=5)
+
+    def test_isa_8000m_anchor(self):
+        t, p, rho = isa_conditions(8000.0)
+        self.assertAlmostEqual(t, 236.15, places=2)
+        self.assertAlmostEqual(rho, 0.52517, places=4)
+
+    def test_isa_density_ratio_tropopause(self):
+        self.assertAlmostEqual(isa_density_ratio_m(11000.0), 0.29707,
+                               places=4)
+
+    def test_tas_from_eas_anchor(self):
+        # 110 m/s EAS at the 8000 m ISA density -> 168.0 m/s TAS
+        self.assertAlmostEqual(tas_from_eas(110.0, 0.52517), 168.0,
+                               places=1)
+
+    def test_day_sigma_below_one_hot_day(self):
+        sigma = day_sigma_from_alt_oat(152.4, 22.0)
+        self.assertGreater(sigma, 0.9)
+        self.assertLess(sigma, 1.0)
+
+    def test_density_altitude_isa_day(self):
+        # On the ISA day density altitude ~ pressure altitude (152.4 m).
+        da = density_altitude_m(152.4, 14.0)
+        self.assertAlmostEqual(da, 152.4, delta=5.0)
+
+
+class TestSpeedCorrections(unittest.TestCase):
+    """Stall/V-speed corrections (stall-speed leaf methods)."""
+
+    def test_vs1g_from_wing_loading_anchor(self):
+        # W/S = 250000/122.6 N/m^2, CLmax 2.0 at standard density.
+        vs = vs1g_from_wing_loading(250000.0 / 122.6, 1.225, 2.0)
+        self.assertAlmostEqual(vs, 40.799, places=2)
+
+    def test_weight_corrected_speed_sqrt_law(self):
+        v = weight_corrected_speed(50.0, 250000.0, 225000.0)
+        self.assertAlmostEqual(v, 50.0 * 0.948683, places=4)
+
+    def test_stall_margin(self):
+        self.assertAlmostEqual(stall_margin(50.0, 55.0), 0.1, places=6)
+        self.assertLess(stall_margin(50.0, 45.0), 0.0)
+
+
+class TestTakeoffReduction(unittest.TestCase):
+    """Takeoff legs: trapezoid ground roll, rotation, 35-ft climb."""
+
+    def test_ground_roll_linear_ramp_anchor(self):
+        # Linear ramp 0 -> 20 m/s over 10 s integrates to exactly 100 m.
+        speeds = [2.0 * i for i in range(11)]
+        times = [float(i) for i in range(11)]
+        self.assertAlmostEqual(ground_roll_integrate(speeds, times), 100.0,
+                               places=6)
+
+    def test_ground_roll_validates(self):
+        with self.assertRaises(ValueError):
+            ground_roll_integrate([1.0, 2.0], [0.0, 0.0])
+
+    def test_constant_accel_distance_anchor(self):
+        self.assertAlmostEqual(constant_accel_distance(46.0, 2.3), 460.0,
+                               places=3)
+
+    def test_engine_failure_distance_linear_anchor(self):
+        # v = 2t sampled each second; failure at v=10 m/s -> 25 m.
+        speeds = [2.0 * i for i in range(11)]
+        times = [float(i) for i in range(11)]
+        self.assertAlmostEqual(engine_failure_distance(speeds, times, 10.0),
+                               25.0, places=3)
+
+    def test_oei_takeoff_legs_chain(self):
+        res = reduce_oei_takeoff(250.0, 38.0, 46.3, 1.0, 2.2, 2.8)
+        expect = 250.0 + 38.0 + (46.3 ** 2 - 38.0 ** 2) / (2.0 * 2.2) \
+            + 46.3 * OBSTACLE_35FT_M / 2.8
+        self.assertAlmostEqual(res["total_m"], expect, places=3)
+        self.assertEqual(res["total_m"], res["failure_m"]
+                         + res["recognition_m"] + res["ground_continue_m"]
+                         + res["climb_m"])
+
+    def test_accelerate_stop_total(self):
+        res = reduce_accelerate_stop(38.0, 2.3, 0.42 * G0)
+        self.assertAlmostEqual(res["total_m"], res["accelerate_m"]
+                               + res["stop_m"], places=6)
+
+    def test_example_takeoff_run_reduces(self):
+        item = example_item()
+        res = reduce_takeoff_run(item.takeoff_run)
+        self.assertGreater(res["ground_roll_m"], 300.0)
+        self.assertGreater(res["total_m"], res["ground_roll_m"])
+        self.assertAlmostEqual(res["total_m"], res["ground_roll_m"]
+                               + res["rotation_m"] + res["climb_35ft_m"],
+                               places=3)
+        # measured trapezoid vs constant-acceleration model differ a bit
+        self.assertNotAlmostEqual(res["ground_roll_m"],
+                                  res["ground_roll_predicted_m"], places=0)
+
+
+class TestLandingReduction(unittest.TestCase):
+    """Landing distance: Vref = 1.23 Vs0, 1.67 certified factor."""
+
+    def test_approach_factor(self):
+        self.assertEqual(APPROACH_FACTOR, 1.23)
+        self.assertEqual(FIELD_LENGTH_FACTOR, 1.67)
+
+    def test_example_landing_certified(self):
+        item = example_item()
+        res = reduce_landing_run(item.landing_run,
+                                 item.vs0_ref_eas_ms(), item.w_ref_n,
+                                 day_sigma_from_alt_oat(item.field_pressure_alt_m,
+                                                item.field_oat_c),
+                                 runway_m=item.runway_m)
+        self.assertAlmostEqual(res["certified_field_length_m"],
+                               1.67 * res["demonstrated_m"], places=3)
+        self.assertAlmostEqual(res["vref_eas_ms"],
+                               1.23 * res["vs0_run_eas_ms"], places=6)
+        self.assertTrue(res["fits"])
+
+    def test_short_runway_flagged(self):
+        item = example_item()
+        res = reduce_landing_run(item.landing_run,
+                                 item.vs0_ref_eas_ms(), item.w_ref_n,
+                                 day_sigma_from_alt_oat(item.field_pressure_alt_m,
+                                                item.field_oat_c),
+                                 runway_m=100.0)
+        self.assertFalse(res["fits"])
+
+
+class TestLevelAcceleration(unittest.TestCase):
+    """Total-energy method: P_s, excess thrust, determined thrust."""
+
+    def test_specific_excess_power_anchor(self):
+        # Leaf-documented anchor: 160 m/s at 1 m/s^2 -> 16.3155 m/s.
+        self.assertAlmostEqual(specific_excess_power(160.0, 1.0),
+                               16.3155, places=3)
+
+    def test_excess_thrust_anchor(self):
+        # W 250000 N, P_s 16.3155 m/s at 160 m/s -> 25492.9 N.
+        self.assertAlmostEqual(excess_thrust_from_ps(16.3155, 160.0,
+                                                     250000.0),
+                               25492.97, places=1)
+
+    def test_weight_and_density_corrections(self):
+        ps_ref_w = weight_corrected_ps(16.3155, 250000.0, 240000.0)
+        self.assertAlmostEqual(ps_ref_w, 16.9953, places=3)
+        ps_std = ps_at_reference_conditions(16.3155, 250000.0, 240000.0,
+                                            1.225 * 0.9)
+        self.assertAlmostEqual(ps_std, 16.6409, places=3)
+
+    def test_example_level_accel_reduces(self):
+        item = example_item()
+        la = item.level_accel_run
+        res = reduce_level_accel_run(
+            la["times_s"], la["speeds_tas_ms"], la["weight_n"],
+            isa_conditions(8000.0)[2], item.s_m2, item.cd0, item.k,
+            w_ref_n=item.w_ref_n, rho_std=1.225, window=la["window"])
+        self.assertAlmostEqual(res["mean_acceleration"], 1.0, places=3)
+        self.assertAlmostEqual(res["mean_specific_excess_power"], 16.3155,
+                               places=2)
+        self.assertTrue(res["sustained_over_band"])
+        self.assertGreater(res["mean_thrust_available"],
+                           res["mean_drag"])
+
+
+class TestCruiseReduction(unittest.TestCase):
+    """Fuel flow reduction: sqrt weight correction + quadratic fit."""
+
+    def test_corrected_fuel_flow_sqrt(self):
+        # wf * sqrt(w_ref/w_test): heavier test weight -> lower correction.
+        self.assertAlmostEqual(corrected_fuel_flow(0.5, 200000.0,
+                                                   180000.0),
+                               0.5 * 0.948683, places=5)
+
+    def test_range_performance(self):
+        rp = range_performance(230.0, 0.45)
+        self.assertAlmostEqual(rp, 511.11, places=1)
+
+    def test_tas_from_mach_fl350(self):
+        # Mach 0.78 at 10668 m (troposphere, T = 218.8 K) -> ~231.3 m/s
+        self.assertAlmostEqual(tas_from_mach(0.78, 10668.0), 231.3,
+                               delta=0.3)
+
+    def test_example_cruise_fit_finds_maximum(self):
+        item = example_item()
+        res = reduce_cruise_points(item.cruise_points, item.w_ref_n / G0)
+        self.assertEqual(res["verdict"], "maximum-found")
+        self.assertIsNotNone(res["max_rp_mach"])
+        self.assertTrue(0.7 < res["max_rp_mach"] < 0.85)
+        self.assertIsNotNone(res["lrc_mach"])
+        self.assertGreater(res["lrc_mach"], res["max_rp_mach"])
+        self.assertEqual(len(res["points"]), len(item.cruise_points))
+
+
+class TestReportBuilder(unittest.TestCase):
+    """The report: content model, rendering, worked-example numbers."""
+
+    def test_analyze_sortie_full(self):
+        model = build_report(example_item())
+        res = model["results"]
+        # every discipline present with real numbers
+        self.assertGreater(res["takeoff"]["run"]["total_m"], 0.0)
+        self.assertGreater(res["takeoff"]["oei"]["total_m"], 0.0)
+        self.assertGreater(res["landing"]["certified_field_length_m"], 0.0)
+        self.assertGreater(res["level_accel"]["mean_thrust_available"], 0.0)
+        self.assertTrue(0.7 < res["cruise"]["max_rp_mach"] < 0.85)
+        self.assertTrue(res["speeds"]["stall_rows"])
+        self.assertTrue(res["scatter"]["rows"])
+        self.assertTrue(res["scatter"]["within_band"])
+
+    def test_conditions_recorded(self):
+        res = analyze_sortie(example_item())
+        c = res["conditions"]
+        self.assertGreater(c["density_altitude_m"], 0.0)
+        self.assertGreater(c["sigma_test"], 0.9)
+        self.assertLess(c["sigma_test"], 1.0)
+
+    def test_render_has_sections_and_numbers(self):
+        md = example_report_markdown()
+        for sec in ["## 1. Test conditions", "## 2. Takeoff performance",
+                    "## 3. Landing performance",
+                    "## 4. Level-acceleration thrust determination",
+                    "## 5. Cruise performance",
+                    "## 6. Stall speeds and V-speed corrections",
+                    "## 7. Computed vs predicted scatter",
+                    "## 8. Findings"]:
+            self.assertIn(sec, md)
+        self.assertIn("density altitude", md)
+        self.assertIn("1.67", md)
+        self.assertIn("thrust available", md)
+        self.assertIn("not an approval", md.lower())
+        self.assertIn("draft", md)
+        self.assertNotIn("___", md)
+
+    def test_model_json_roundtrip_plain(self):
+        import json
+        model = example_report_model()
+        text = json.dumps(model)  # must not raise (plain JSON types)
+        self.assertGreater(len(text), 2000)
+        self.assertIn("draft-for-review", text)
+
+
+class TestGates(unittest.TestCase):
+    def test_core_gates_all_pass(self):
+        model = build_report(example_item())
+        gates = check_report(model)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_markdown_gates_all_pass(self):
+        md = example_report_markdown()
+        gates = check_report_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_sign_off_honest_model(self):
+        model = build_report(example_item())
+        self.assertEqual(model["status"], "draft-for-review")
+
+
+class TestStandalone(unittest.TestCase):
+    def test_no_skills_repo_required(self):
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = build_report(example_item())
+        self.assertEqual(model["document_type"],
+                         "Flight Test Performance Data Analysis Report")
+        md = render_report_markdown(model)
+        self.assertGreater(len(md), 2000)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/flight-test-performance-engineer/tests/test_role_flight_test_performance_engineer.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Role test: Flight Test Performance Engineer.
+
+Verifies (offline, no network):
+1. Every skill bound in ROLE.md frontmatter RESOLVES to a real leaf in
+   the aero-agent-skills repo (the pinned skills_release band).
+2. The workflow stage order is deterministic and complete.
+3. The filled deliverable template (worked example) has zero blanks,
+   numbered sections, and the honest DRAFT / not-an-approval markers.
+4. The role carries the executable core + cli (100% standard) and the
+   boundary/forbidden lines, and metadata credits the author.
+"""
+import os
+import re
+import sys
+import unittest
+
+ROLES_REPO = os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.dirname(os.path.abspath(__file__)))))          # repo root
+sys.path.insert(0, os.path.join(ROLES_REPO, "roles",
+                                "flight-test-performance-engineer", "core"))
+import flight_test_performance_core as core  # noqa: E402
+# Deterministic across midnight: pin fresh renders to the date the
+# committed template carries (CI override wins).
+os.environ.setdefault("ROLE_GEN_DATE", "2026-09-05")
+AEROSKILLS = os.environ.get("AEROSKILLS_DEV",
+                            os.path.expanduser("~/AeroSkills"))
+HAS_SKILLS = os.path.isdir(os.path.join(AEROSKILLS, "skills"))
+ROLE_DIR = os.path.join(ROLES_REPO, "roles",
+                        "flight-test-performance-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates",
+                        "performance-report-template.md")
+
+EXPECTED_BOUND = [
+    "flight-test-operations/performance/takeoff-distance-determination",
+    "flight-test-operations/performance/accelerate-stop-distance",
+    "flight-test-operations/performance/engine-failure-takeoff-flight-test",
+    "flight-test-operations/performance/landing-distance-determination",
+    "flight-test-operations/performance/level-acceleration-test",
+    "flight-test-operations/performance/cruise-performance-flight-test",
+    "flight-test-operations/performance/climb-performance-flight-test",
+    "flight-test-operations/performance/engine-flight-test",
+    "flight-test-operations/performance/stall-speed-determination",
+    "flight-test-operations/performance/glide-flight-test",
+    "flight-test-operations/performance/fuel-jettison-flight-test",
+    "flight-test-operations/performance/in-flight-engine-relight-test",
+    "flight-test-operations/performance/rotorcraft-performance-flight-test",
+    "flight-test-operations/performance/"
+    "rotorcraft-forward-flight-performance-test",
+    "flight-test-operations/planning/flight-test-data-reduction",
+]
+
+EXPECTED_STAGES = [
+    "1. Data reduction prep", "2. Conditions", "3. Takeoff",
+    "4. Landing", "5. Level accel", "6. Cruise", "7. Speeds",
+    "8. Climb / other", "9. Rotorcraft (if rotary)", "10. Report",
+]
+
+
+def read_role_md():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    if not os.path.exists(p):
+        return None
+    return open(p).read()
+
+
+class TestFlightTestPerformanceRole(unittest.TestCase):
+
+    def test_bound_skills_resolve_in_aeroskills(self):
+        if not HAS_SKILLS:
+            self.skipTest("Aero Agent Skills checkout not present "
+                          "(cross-repo dev check)")
+        for leaf in EXPECTED_BOUND:
+            sk = os.path.join(AEROSKILLS, "skills", leaf, "SKILL.md")
+            self.assertTrue(
+                os.path.exists(sk),
+                "bound skill not found in aero-agent-skills: %s" % leaf)
+
+    def test_bound_skills_listed_in_frontmatter(self):
+        role = read_role_md()
+        self.assertIsNotNone(role)
+        for leaf in EXPECTED_BOUND:
+            self.assertIn(leaf, role,
+                          "missing in ROLE.md skills_bound: %s" % leaf)
+
+    def test_workflow_stages_deterministic(self):
+        role = read_role_md()
+        idx = [role.find(stage) for stage in EXPECTED_STAGES]
+        self.assertTrue(all(i >= 0 for i in idx), "a stage is missing")
+        self.assertEqual(idx, sorted(idx),
+                         "stage order not deterministic")
+
+    def test_deliverable_template_complete(self):
+        if not os.path.exists(TEMPLATE):
+            self.fail("performance-report-template.md missing")
+        text = open(TEMPLATE).read()
+        self.assertNotIn("___", text, "template has blank fields")
+        # numbered sections 1..8 present
+        for n in range(1, 9):
+            self.assertTrue(
+                re.search(r"^## %d\. " % n, text, re.M),
+                "section %d missing" % n)
+        self.assertIn("Flight Test Performance Data Analysis Report", text)
+        low = text.lower()
+        self.assertIn("draft", low)
+        self.assertIn("not an approval", low)
+        self.assertIn("performance guarantee", low)
+
+    def test_template_is_the_worked_example(self):
+        """The filled template matches the core's example render."""
+        template = open(TEMPLATE).read().strip()
+        rendered = core.example_report_markdown().strip()
+        self.assertEqual(template, rendered)
+
+    def test_forbidden_lines_present(self):
+        role = read_role_md()
+        for phrase in ["clear an envelope", "declare airworthiness",
+                       "authorize flight", "performance guarantee",
+                       "sign_off_required: true", "reproduce proprietary"]:
+            self.assertIn(phrase, role, "missing boundary: %s" % phrase)
+
+    def test_author_ashfordeou(self):
+        role = read_role_md()
+        self.assertIn("ashfordeOU", role)
+
+    def test_sources_register_exists(self):
+        p = os.path.join(ROLE_DIR, "SOURCES.md")
+        self.assertTrue(os.path.exists(p), "SOURCES.md missing for role")
+
+    def test_core_engine_exists(self):
+        """100% standard: every role ships an executable core + cli."""
+        for f in ["core", "cli.py"]:
+            self.assertTrue(os.path.exists(os.path.join(ROLE_DIR, f)),
+                            "%s missing - role is not executable" % f)
+        core_files = [f for f in os.listdir(os.path.join(ROLE_DIR, "core"))
+                      if f.endswith("_core.py")]
+        self.assertEqual(len(core_files), 1)
+
+    def test_standalone_cli_smoke(self):
+        """cli.py build must run with no AeroSkills checkout."""
+        import subprocess
+        env = dict(os.environ)
+        env["AEROSKILLS_DEV"] = "/nonexistent"
+        out = os.path.join(ROLE_DIR, "tests", ".smoke-report.md")
+        try:
+            r = subprocess.run(
+                [sys_executable(), os.path.join(ROLE_DIR, "cli.py"),
+                 "build", "--out", out],
+                capture_output=True, text=True, env=env, cwd=ROLE_DIR)
+            self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+            md = open(out).read()
+            self.assertIn("Flight Test Performance Data Analysis Report",
+                          md)
+        finally:
+            if os.path.exists(out):
+                os.remove(out)
+
+
+def sys_executable():
+    import sys
+    return sys.executable
+
+
+if __name__ == "__main__":
+    unittest.main()