aero-agent-roles 1.0.0

package/roles/aerodynamics-engineer/templates/aero-design-report-template.md

@@ -0,0 +1,72 @@
+# Aerodynamic Design Report
+
+**Aircraft:** TAC-150 twin-jet transport (reference configuration)
+**Status:** draft-for-review (generated 2026-09-05)
+
+## 1. Configuration summary
+
+- Aircraft: TAC-150 twin-jet transport (reference configuration) - 150-seat short/medium-haul transport, wing-body-tail configuration, underlying podded engines
+- Mission: short/medium-haul transport - cruise M 0.78 at 10668 m; dive M 0.89 (V_D 263.9 m/s TAS); MTOW 735 kN, cruise weight 622 kN
+- Selected airfoil + rationale: representative supercritical section (t/c 0.105), Korn drag-divergence benefit over a conventional section; section cl_max 1.55 from the stage-1 XFOIL-style analysis
+- Wing planform: area 122.6 m2 - AR 8.0 - span 31.3 m - MAC 3.91 m - quarter-chord sweep 25 deg - taper 0.30
+- High-lift system: full-span leading-edge slat + single-slotted trailing-edge flap (deflections in section 4)
+
+## 2. Airfoil analysis
+
+- Operating Reynolds range (MAC-based, clean wing): 2.36e+07 (sea-level low-speed) to 2.40e+07 (cruise M 0.78)
+- Section: representative supercritical section; thin-airfoil section slope a0 = 6.283/rad
+- CL_max clean (wing-level): 1.264 (0.9 x section 1.55 x cos(sweep)); with high-lift: 2.273 landing / 1.910 takeoff
+- Drag divergence (Korn rule, supercritical t/c 0.105 at cruise CL 0.500): M_DD = 0.795
+- Source tool + settings: stage-1 XFOIL viscous analysis (transition) on the candidate sections; tool sanity anchor NACA 0012 at Re = 6e6 (cl ~0.82 at 10 deg, cd0 ~0.0079 band, xfoil-analysis leaf) recorded in the analysis evidence set
+
+## 3. Drag buildup
+
+| Component | Cf | FF | Q | S_wet (m2) | Cd0 term | Basis |
+|---|---|---|---|---|---|---|
+| wing | 0.00255 | 1.2222 | 1.00 | 218.5 | 0.005562 | Cf x FF x Q x S_wet/S_ref (Re 2.40e+07) |
+| fuselage | 0.00189 | 1.0934 | 1.00 | 401.0 | 0.006764 | Cf x FF x Q x S_wet/S_ref (Re 2.30e+08) |
+| nacelles x2 | 0.00265 | 1.2414 | 1.20 | 29.0 | 0.000935 | Cf x FF x Q x S_wet/S_ref (Re 1.78e+07) |
+| horizontal tail | 0.00270 | 1.2100 | 1.00 | 50.6 | 0.001347 | Cf x FF x Q x S_wet/S_ref (Re 1.56e+07) |
+| vertical tail | 0.00264 | 1.2100 | 1.00 | 39.4 | 0.001028 | Cf x FF x Q x S_wet/S_ref (Re 1.84e+07) |
+- Total Cd0: 0.01564 - Oswald/span efficiency: 0.80 - equivalent skin friction Cf_e = 0.00260 (Cd0 x S_ref / S_wet_total = 738 m2)
+- Full polar: CD = 0.01564 + 0.04974 x CL^2; at cruise CL 0.500: CD = 0.02805, L/D = 17.81; polar peak L/D 17.93 at CL_opt 0.561
+
+## 4. High-lift assessment
+
+- Device + deflections: full-span slat (span fraction 0.85) + slotted flap (chord fraction 0.25, span fraction 0.70); takeoff 15 deg, landing 35 deg (max 40 deg for the slotted flap)
+- Section increments: flap +0.366 (TO) / +0.812 (landing), slat +0.425 (K_delta x K_chord x K_span x reference increment, high-lift leaf)
+- CL_max with device: takeoff 1.910, landing 2.273 (0.9 x section cl_max x cos(sweep)) vs clean 1.264
+- Stall speeds (sea level): clean 88.0 m/s at MTOW, takeoff 71.6 m/s at MTOW, landing 60.9 m/s at landing weight; landing reference speed 1.23 x V_S = 74.9 m/s (CS/FAR 25.125 minimum reference-speed practice)
+
+## 5. CFD evidence
+
+- Case: ONERA M6 wing validation + 3-mesh grid study on the transport wing-body at cruise M 0.78 / CL 0.500
+- Validation target: ONERA M6 wing at M 0.84, Re 1.17e+07, alpha 3.06 deg (reference CD 0.0163); computed CD 0.0169 -> relative error 3.7% vs 5% band: PASS
+- Mesh convergence: 1.9e+07 / 4.8e+06 / 1.2e+06 cells (refinement ratio 2.0); CD 0.02840 / 0.02910 / 0.03060; apparent order 1.10, Richardson-extrapolated CD 0.02779, GCI 0.00077 (2.7% of the fine-mesh value)
+- Turbulence model + wall treatment: RANS (SA) on the fine mesh, resolved near-wall layer (y+ <= 1); fine-mesh total drag 0.02840 vs component-buildup polar 0.02805 at the same condition (1.2% apart)
+
+## 6. Transonic behavior
+
+- Effective section Mach at cruise: M cos(sweep) = M 0.78 x cos(25 deg) = 0.707
+- Drag-divergence Mach (Korn, supercritical): M_DD = 0.95 - t/c (0.105) - CL/10 (0.0500) = 0.7950
+- Wave drag at cruise: 0.0000 penalty index (0 below M_DD; (M - M_DD)^3 above) - cruise holds 0.0150 below drag divergence; shock location: no terminating shock at cruise (no supercritical pocket closure case)
+- Supercritical behavior notes: flat-top section holds the local Mach just-supersonic with a weak terminating shock; transonic similarity parameter K = (1 - M^2)/tau^(2/3) = 1.759
+
+## 7. Aeroelastic screening
+
+- Flutter speed estimate: 364.2 m/s (V-g typical-section flutter speed, outboard wing at the dive condition, flutter-speed-prediction leaf analysis) vs V_D 263.9 m/s -> margin 1.38 (PASS >= 1.15)
+- Static divergence: no static-divergence mechanism for the swept-back wing (aerodynamic center aft of the elastic axis, divergence-speed leaf domain e <= 0)
+- Gust response (load factor): discrete-gust screening at cruise, U_de = 12.5 m/s, quasi-steady Delta CL = a x U_de/V -> Delta n = 0.49, n = 1.49 g. NOTE: aeroelastic results are SCREENING inputs for the loads/structures role - not final flutter or gust clearance
+
+## 8. Margin summary
+
+| Margin | Value | Requirement | Source (stage) |
+|---|---|---|---|
+| Flutter margin (V_F / V_D) | 1.380 | >= 1.15 x V_D (flutter-speed leaf clearance practice) | stage 10: V-g typical-section flutter speed 364.2 m/s vs design dive speed 263.9 m/s |
+| Drag-divergence margin (M_DD - M_cruise) | 0.015 | > 0 (cruise below drag divergence; wave-drag penalty = 0) | stage 8: Korn rule M_DD = 0.795 at cruise C_L 0.4996 |
+| Stall margin, clean (CL_max clean / C_L cruise) | 2.530 | > 1 (no stall at the cruise point, sea-level MTOW V_s = 88 m/s) | stage 4: wing CLmax = 0.9 x section clmax x cos(sweep) |
+| High-lift CL_max gain (landing - clean) | 1.009 | > 0 (flap + slat increments from high-lift leaf) | stage 4: slotted flap dcl 0.812 + slat dcl 0.425 (section), 3D/sweep factor 0.9 x cos(25 deg) |
+| L/D efficiency margin ((L/D_max - L/D_cruise) / L/D_max) | 0.007 | >= 0 (cruise lift coefficient within the polar peak) | stage 5: polar peak L/D 17.93 at C_L 0.561 vs cruise L/D 17.81 |
+
+---
+*DRAFT - for human aerodynamics lead review. Not an approval document.*

package/roles/aerodynamics-engineer/tests/test_aerodynamics_core.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""Test aerodynamics_core: the executable engine of the Aerodynamics role.
+
+Proves the role can DO its job standalone (no AeroSkills checkout needed):
+formula correctness against known values (the same anchors used by the
+bound Aero Agent Skills leaves), ISA atmosphere, drag buildup, drag polar,
+lift curve slope, high lift, transonic limits, aeroelastic margins, CFD
+validation metrics, report generation, and evidence-gate checks.
+"""
+import math
+import os
+import re
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "core"))
+import aerodynamics_core as ac
+
+
+class TestFormulaKnownValues(unittest.TestCase):
+    """Formula anchors from the bound AeroSkills leaf contract tests."""
+
+    def test_reynolds_and_skin_friction_anchors(self):
+        # Re = rho*V*L/mu: sea-level air, V = 70 m/s, length 2.5 m
+        # (parasite-drag leaf test).
+        self.assertAlmostEqual(ac.reynolds(1.225, 70.0, 2.5, 1.7894e-5),
+                               11980272.717, delta=1.0)
+        with self.assertRaises(ValueError):
+            ac.reynolds(0.0, 70.0, 2.5, 1.7894e-5)
+        # Blasius, Schlichting and the mixed transition formula (leaf tests).
+        self.assertAlmostEqual(ac.cf_laminar(1e5), 0.0041995047, delta=1e-9)
+        self.assertAlmostEqual(ac.cf_turbulent(1e7), 0.0030037131, delta=1e-9)
+        self.assertAlmostEqual(ac.cf_mixed(1e7, 5e5), 0.0028423311, delta=1e-9)
+        with self.assertRaises(ValueError):
+            ac.cf_turbulent(5.0)
+
+    def test_form_factor_and_component_drag_anchors(self):
+        # FF wing = 1 + 2(t/c) + 100(t/c)^4, fuselage/nacelle l/d forms.
+        self.assertAlmostEqual(ac.form_factor("wing", t_over_c=0.12), 1.260736)
+        self.assertAlmostEqual(ac.form_factor("tail", t_over_c=0.10), 1.21)
+        self.assertAlmostEqual(ac.form_factor("fuselage", l_over_d=8.0), 1.1371875)
+        self.assertAlmostEqual(ac.form_factor("nacelle", l_over_d=3.0),
+                               1.1166666667, delta=1e-9)
+        # CD_i = Cf * FF * Q * S_wet / S_ref (leaf test value).
+        self.assertAlmostEqual(ac.component_drag(0.003, 1.26, 1.1, 50.0, 20.0),
+                               0.010395)
+        # assembled buildup: total Cd0 is the sum of the component terms
+        buildup = ac.parasite_drag(
+            [{"name": "wing", "kind": "wing", "length": 2.5, "s_wet": 218.5,
+              "t_over_c": 0.105, "q": 1.0},
+             {"name": "fuselage", "kind": "fuselage", "length": 37.6,
+              "s_wet": 401.0, "l_over_d": 9.5, "q": 1.0}],
+            s_ref=122.6, rho=1.225, v=70.0, mu=1.7894e-5)
+        self.assertEqual(len(buildup["components"]), 2)
+        self.assertAlmostEqual(buildup["cd0"],
+                               sum(r["cd"] for r in buildup["components"]))
+        self.assertGreater(buildup["cd0"], 0.0)
+
+    def test_drag_polar_and_lift_slope_formulas(self):
+        # k = 1/(pi*e*AR) with e = 0.8, AR = 8; CD = Cd0 + k*CL^2
+        e, ar, cd0 = 0.8, 8.0, 0.01564
+        k = 1.0 / (math.pi * e * ar)
+        self.assertAlmostEqual(ac.induced_drag_factor(e, ar), k)
+        cl = 0.5
+        polar = ac.drag_polar(cd0, e, ar, cl)
+        self.assertAlmostEqual(polar["cd"], cd0 + k * cl * cl)
+        # cl_opt = sqrt(cd0/k), L/D_max = 1/(2*sqrt(cd0*k))
+        self.assertAlmostEqual(polar["cl_opt"], math.sqrt(cd0 / k))
+        self.assertAlmostEqual(polar["ld_max"], 1.0 / (2.0 * math.sqrt(cd0 * k)))
+        self.assertAlmostEqual(polar["l_over_d"], cl / (cd0 + k * cl * cl))
+        # lifting line with a0 = 2*pi and e = 1 reduces to a = a0*AR/(AR+2)
+        slope = ac.lift_curve_slope(8.0, e=1.0, sweep_deg=0.0, mach=0.0)
+        self.assertAlmostEqual(slope["a_finite"], 2 * math.pi * 8.0 / 10.0)
+        # simple sweep theory: a_swept = a * cos(sweep)
+        self.assertAlmostEqual(slope["a_finite"] * math.cos(math.radians(25.0)),
+                               ac.lift_curve_slope(8.0, e=1.0,
+                                                   sweep_deg=25.0)["a_swept"])
+        # Prandtl-Glauert: a_mach = a / sqrt(1 - M^2), valid M < 0.7
+        base = ac.lift_curve_slope(8.0, e=1.0, sweep_deg=25.0, mach=0.0)
+        pg = ac.lift_curve_slope(8.0, e=1.0, sweep_deg=25.0, mach=0.5)
+        self.assertAlmostEqual(pg["a_mach"], base["a_swept"] / math.sqrt(0.75))
+        with self.assertRaises(ValueError):
+            ac.lift_curve_slope(8.0, mach=0.8)  # P-G valid only M < 0.7
+
+    def test_flutter_and_divergence_margins(self):
+        # Classic typical-section anchors (flutter-speed leaf tests):
+        # V_F = 88.8511 m/s.
+        margin, ok = ac.flutter_margin(88.8511, 80.0)
+        self.assertAlmostEqual(margin, 1.1106, delta=1e-3)
+        self.assertFalse(ok)
+        margin, ok = ac.flutter_margin(88.8511, 70.0)
+        self.assertAlmostEqual(margin, 1.2693, delta=1e-3)
+        self.assertTrue(ok)
+        # Divergence: 40000/(16*2*5.0*0.2) = 1250 Pa exactly (divergence leaf)
+        q = ac.divergence_dynamic_pressure(40000.0, 16.0, 2.0, 5.0, 0.2)
+        self.assertAlmostEqual(q, 1250.0)
+        self.assertAlmostEqual(ac.divergence_speed(q), 45.1754, delta=1e-3)
+        with self.assertRaises(ValueError):
+            ac.divergence_dynamic_pressure(40000.0, 16.0, 2.0, 5.0, 0.0)
+
+    def test_high_lift_formulas(self):
+        # Slotted flap at full deflection: reference increment 1.3 at the
+        # reference flap chord fraction and full span.
+        self.assertAlmostEqual(ac.flap_clmax_increment("slotted", 40.0), 1.3)
+        # partial deflection scales with sin(delta)/sin(delta_max)
+        inc_20 = ac.flap_clmax_increment("slotted", 20.0)
+        self.assertAlmostEqual(inc_20, 1.3 * math.sin(math.radians(20.0))
+                               / math.sin(math.radians(40.0)))
+        # wing CLmax = 0.9 * clmax_section * cos(sweep)
+        self.assertAlmostEqual(ac.wing_clmax(1.55, 25.0),
+                               0.9 * 1.55 * math.cos(math.radians(25.0)))
+        # stall speed sqrt(2W/(rho*S*CLmax)) - clean config ~88 m/s example
+        vs = ac.stall_speed(735000.0, 122.6, 1.225,
+                            ac.wing_clmax(1.55, 25.0))
+        self.assertAlmostEqual(vs, 88.0, delta=1.5)
+
+    def test_transonic_rules(self):
+        # Korn rule: M_DD = 0.95 - t/c - CL/10 (supercritical base)
+        self.assertAlmostEqual(ac.drag_divergence_mach(0.105, 0.5, True),
+                               0.95 - 0.105 - 0.05)
+        # conventional section uses the 0.90 base
+        self.assertAlmostEqual(ac.drag_divergence_mach(0.105, 0.5, False),
+                               0.90 - 0.105 - 0.05)
+        # wave drag penalty: 0 below M_DD, (M - M_DD)^3 above
+        self.assertEqual(ac.wave_drag_penalty(0.78, 0.795), 0.0)
+        self.assertAlmostEqual(ac.wave_drag_penalty(0.84, 0.795), 0.045 ** 3)
+        # effective Mach M*cos(sweep)
+        self.assertAlmostEqual(ac.effective_mach(0.78, 25.0),
+                               0.78 * math.cos(math.radians(25.0)))
+
+    def test_cfd_validation_metrics(self):
+        # Richardson on the example mesh series [fine, medium, coarse]
+        rich = ac.richardson_extrapolation([0.02840, 0.02910, 0.03060], 2.0)
+        p = math.log(0.0015 / 0.0007) / math.log(2.0)
+        self.assertAlmostEqual(rich["apparent_order"], p)
+        denom = 2.0 ** p - 1.0
+        self.assertAlmostEqual(rich["extrapolated"], 0.02840 - 0.0007 / denom)
+        self.assertAlmostEqual(rich["gci"], 1.25 * 0.0007 / denom)
+        self.assertTrue(rich["monotone"])
+        # validation verdict PASS inside the 5% band, FAIL outside
+        v = ac.validation_verdict(0.0169, 0.0163)
+        self.assertEqual(v["verdict"], "PASS")
+        self.assertAlmostEqual(v["error"], 0.0006 / 0.0163)
+        v2 = ac.validation_verdict(0.0185, 0.0163)
+        self.assertEqual(v2["verdict"], "FAIL")
+        with self.assertRaises(ValueError):
+            ac.richardson_extrapolation([0.03, 0.02, 0.03])  # non-monotone
+
+
+class TestIsaAtmosphere(unittest.TestCase):
+
+    def test_isa_sea_level_and_cruise(self):
+        sl = ac.atmosphere(0.0)
+        self.assertAlmostEqual(sl["density"], 1.225, delta=1e-3)
+        self.assertAlmostEqual(sl["pressure"], 101325.0, delta=5.0)
+        self.assertAlmostEqual(sl["speed_of_sound"], 340.29, delta=0.2)
+        # cruise at 10668 m (FL 350): rho ~0.38, a ~296.5 (used by the report)
+        cr = ac.atmosphere(10668.0)
+        self.assertAlmostEqual(cr["density"], 0.3796, delta=0.005)
+        self.assertAlmostEqual(cr["speed_of_sound"], 296.5, delta=0.5)
+        with self.assertRaises(ValueError):
+            ac.atmosphere(-5.0)
+
+
+class TestReportBuilder(unittest.TestCase):
+
+    def test_example_report_numbers(self):
+        model = ac.build_report(ac.example_item())
+        # cruise CL ~0.50 at M 0.78/FL350 with W_cruise/S = 622000/122.6
+        self.assertAlmostEqual(model["cl_cruise"], 0.5, delta=1e-2)
+        self.assertAlmostEqual(model["span"], math.sqrt(8.0 * 122.6), delta=1e-6)
+        self.assertAlmostEqual(model["mac"], 122.6 / math.sqrt(8.0 * 122.6),
+                               delta=1e-6)
+        # polar consistency: CD = Cd0 + k*CL^2 with k = 1/(pi*e*AR)
+        expected_cd = (model["cd0"]
+                       + model["cl_cruise"] ** 2
+                       / (math.pi * model["oswald_e"] * model["aspect_ratio"]))
+        self.assertAlmostEqual(model["cd_cruise"], expected_cd, delta=1e-6)
+        self.assertGreater(model["ld_max"], model["ld_cruise"])
+        # transonic: cruise below Korn M_DD, penalty zero
+        self.assertGreater(model["m_dd"], model["cruise_mach"])
+        self.assertEqual(model["wave_drag_penalty"], 0.0)
+        # high lift: landing CLmax above clean; stall speeds ordered
+        hl = model["high_lift"]
+        self.assertGreater(hl["clmax_wing_land"], hl["clmax_wing_clean"])
+        self.assertLess(hl["vs_land"], hl["vs_to"])
+        self.assertLess(hl["vs_to"], hl["vs_clean"])
+
+    def test_core_gates_all_pass(self):
+        model = ac.build_report(ac.example_item())
+        gates = ac.check_report(model)
+        self.assertTrue(gates["all_pass"], gates)
+        self.assertTrue(model["flutter_ok"])
+        self.assertGreaterEqual(model["flutter_margin"], 1.15)
+        self.assertGreaterEqual(len(model["margins"]), 4)
+        # every margin names its workflow-stage source
+        for m in model["margins"]:
+            self.assertIn("stage ", m["source"])
+
+    def test_report_markdown_complete_gates_and_no_blanks(self):
+        md = ac.example_report_markdown()
+        for n in range(1, 9):
+            self.assertTrue(re.search(rf"^## {n}\. ", md, re.M),
+                            "section %d missing" % n)
+        for banned in ["___", "TBD", "OPEN item"]:
+            self.assertNotIn(banned, md)
+        self.assertIn("DRAFT", md)
+        self.assertIn("not an approval", md.lower())
+        self.assertIn("Flutter margin", md)
+        self.assertIn("Drag-divergence Mach", md)
+        self.assertGreater(len(md), 3000)
+        gates = ac.check_report_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+        self.assertTrue(gates["has_no_blanks"])
+
+    def test_standalone_no_skills_repo(self):
+        # Core must work with no AeroSkills present: env points nowhere.
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = ac.build_report(ac.example_item())
+        md = ac.render_report_markdown(model)
+        self.assertTrue(ac.check_report(model)["all_pass"])
+        self.assertGreater(len(md), 3000)
+        self.assertIn("TAC-150", md)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/aerodynamics-engineer/tests/test_role_aerodynamics.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Role test: Aerodynamics Engineer.
+
+Offline verification: bound skills resolve, workflow deterministic,
+report template complete, boundaries present, SOURCES present.
+"""
+import os
+import re
+import unittest
+
+ROLES_REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))
+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", "aerodynamics-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates", "aero-design-report-template.md")
+
+EXPECTED_BOUND = [
+    "aerodynamics/airfoil/xfoil-analysis",
+    "aerodynamics/airfoil/airfoil-selection",
+    "aerodynamics/wing-design/wing-planform-design",
+    "aerodynamics/drag-polars/drag-polar",
+    "aerodynamics/drag-polars/parasite-drag",
+    "aerodynamics/drag-polars/lift-curve-slope",
+    "aerodynamics/high-lift/high-lift-systems",
+    "aerodynamics/cfd/vortex-lattice-method",
+    "aerodynamics/cfd/cfd-validation",
+    "aerodynamics/cfd/cfd-convergence",
+    "aerodynamics/cfd/cfd-mesh-generation",
+    "aerodynamics/cfd/cfd-turbulence-modeling",
+    "aerodynamics/high-speed/swept-wing-aerodynamics",
+    "aerodynamics/high-speed/transonic-similarity",
+    "aerodynamics/high-speed/supercritical-airfoil",
+    "aerodynamics/high-speed/wave-drag-area-rule",
+    "aerodynamics/high-speed/normal-shock",
+    "aerodynamics/boundary-layer/boundary-layer-theory",
+    "aerodynamics/boundary-layer/boundary-layer-transition",
+    "aerodynamics/aeroelasticity/flutter-speed-prediction",
+    "aerodynamics/aeroelasticity/aeroelastic-gust-response",
+    "aerodynamics/ground-effects/ground-effect",
+    "aerodynamics/wind-tunnel/windtunnel-data-reduction",
+    "aerodynamics/wind-tunnel/windtunnel-wall-corrections",
+]
+
+STAGES = ["Airfoil analysis", "Airfoil optimization", "Wing planform",
+          "High-lift", "Drag buildup", "Winglet / 3D", "CFD validation",
+          "Transonic", "Boundary layer", "Aeroelastic screen",
+          "Ground/wind tunnel", "Report"]
+
+
+def role_text():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    return open(p).read() if os.path.exists(p) else None
+
+
+class TestAerodynamicsRole(unittest.TestCase):
+
+    def test_bound_skills_resolve(self):
+        if not HAS_SKILLS:
+            self.skipTest("skills checkout absent")
+        for leaf in EXPECTED_BOUND:
+            self.assertTrue(
+                os.path.exists(os.path.join(AEROSKILLS, "skills", leaf, "SKILL.md")),
+                f"bound skill missing: {leaf}")
+
+    def test_stages_ordered(self):
+        role = role_text()
+        self.assertIsNotNone(role)
+        # check order within the Workflow section only
+        wf = role[role.find("## Workflow"):role.find("## Evidence gates")]
+        idx = [wf.find(s) for s in STAGES]
+        self.assertTrue(all(i >= 0 for i in idx), "a stage missing in workflow")
+        self.assertEqual(idx, sorted(idx), "stage order not deterministic")
+
+    def test_template_sections(self):
+        if not os.path.exists(TEMPLATE):
+            self.fail("template missing")
+        text = open(TEMPLATE).read()
+        for n in range(1, 9):
+            self.assertTrue(re.search(rf"^## {n}\. ", text, re.M), f"section {n}")
+        self.assertIn("DRAFT", text)
+
+    def test_boundaries(self):
+        role = role_text()
+        self.assertIsNotNone(role)
+        for phrase in ["claim certification approval", "sign_off_required: true"]:
+            self.assertIn(phrase, role)
+
+    def test_sources(self):
+        self.assertTrue(os.path.exists(os.path.join(ROLE_DIR, "SOURCES.md")))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/aircraft-design-engineer/ROLE.md

@@ -0,0 +1,138 @@
+---
+type: role
+name: aircraft-design-engineer
+title: "Aircraft Conceptual Design Engineer"
+status: draft
+domain: vehicle-design
+deliverable_type: "concept design package (sizing + layout + cost)"
+standards_bound:
+  - id: far-25
+    tier: TIER-1
+    reference-only: false
+skills_bound:
+  - vehicle-design/conceptual/constraint-analysis
+  - vehicle-design/conceptual/sizing-mission-profile
+  - vehicle-design/conceptual/payload-range-diagram
+  - vehicle-design/conceptual/tow-estimation
+  - vehicle-design/conceptual/openvsp-geometry
+  - vehicle-design/sizing/ws-tw-trade
+  - vehicle-design/sizing/weight-estimation
+  - vehicle-design/sizing/engine-sizing
+  - vehicle-design/sizing/fuselage-sizing
+  - vehicle-design/sizing/wing-planform-sizing
+  - vehicle-design/sizing/tail-sizing
+  - vehicle-design/sizing/landing-gear-sizing
+  - vehicle-design/sizing/control-surface-sizing
+  - vehicle-design/sizing/fuel-tank-sizing
+  - vehicle-design/sizing/battery-sizing
+  - vehicle-design/sizing/environmental-control-sizing
+  - vehicle-design/sizing/electrical-wire-sizing
+  - vehicle-design/sizing/apu-fuel-burn-sizing
+  - vehicle-design/sizing/bleed-air-system-sizing
+  - vehicle-design/sizing/fire-protection-sizing
+  - vehicle-design/sizing/ice-protection-sizing
+  - vehicle-design/sizing/hydraulic-system-sizing
+  - vehicle-design/sizing/landing-gear-retraction-sizing
+  - vehicle-design/mass-properties/mass-budget
+  - vehicle-design/mass-properties/cg-envelope
+  - vehicle-design/mass-properties/inertia-estimation
+  - vehicle-design/mdo/design-of-experiments
+  - vehicle-design/mdo/multidisciplinary-optimization
+  - vehicle-design/mdo/surrogate-modeling
+  - vehicle-design/cost-estimation/parametric-cost
+  - vehicle-design/cost-estimation/operating-cost
+  - vehicle-design/cost-estimation/life-cycle-cost
+  - vehicle-design/structures-integration/wing-box-sizing
+  - vehicle-design/structures-integration/fuselage-skin-stringer
+tools_allowed: [stdlib, offline-file-processing, openvsp-cli]
+forbidden:
+  - "claim certification approval"
+  - "release a configuration for production"
+  - "reproduce proprietary standard text"
+sign_off_required: true
+license: Apache-2.0
+compatibility: "agentskills.io ROLE.md; any SKILL.md host"
+metadata:
+  version: 0.1.0
+  author: Aero Agent Roles
+  skills_release: "v1.3.0+"
+---
+
+# Aircraft Conceptual Design Engineer
+
+## Role identity
+
+Owns the conceptual design phase: turn a top-level requirement (payload,
+range, speed, field length) into a sized, balanced, costed aircraft
+configuration. Runs the sizing loop, the W/S vs T/W trade, mass and CG
+buildup, subsystem sizing, and the MDO exploration that closes the
+design. Use when a project must produce a defensible concept with a
+takeoff weight, a wing/engine selection, and a cost estimate. Do NOT use
+for detailed structural analysis (structures role), aerodynamic
+refinement (aero role), or certification workflow (cert roles).
+
+## Deliverable contract
+
+1. **Concept design package** - requirements, constraint diagram
+   (W/S vs T/W), sizing mission, selected configuration, mass statement,
+   CG envelope, subsystem summary, cost estimate.
+2. **Sensitivity/MDO evidence** - the trade studies and optimization
+   runs that justify the selection.
+
+## Workflow (stages -> bound skills)
+
+| Stage | Loads skill | Produces |
+|---|---|---|
+| 1. Requirements framing | constraint-analysis | constraint diagram, feasible design space |
+| 2. Sizing mission | sizing-mission-profile | mission segments, reserves, fuel fractions |
+| 3. Initial layout | openvsp-geometry | 3-view baseline geometry |
+| 4. W/S vs T/W trade | ws-tw-trade | design point selection |
+| 5. Weight iteration | weight-estimation + tow-estimation | MTOW convergence |
+| 6. Component sizing | engine-sizing + fuselage-sizing + wing-planform-sizing + tail-sizing + landing-gear-sizing + control-surface-sizing | component dimensions/weights |
+| 7. Subsystem sizing | fuel-tank-sizing + battery-sizing + environmental-control-sizing + electrical-wire-sizing + apu-fuel-burn-sizing + bleed-air-system-sizing + fire-protection-sizing + ice-protection-sizing + hydraulic-system-sizing + landing-gear-retraction-sizing | subsystem sizes/power/weight |
+| 8. Mass + CG | mass-budget + cg-envelope + inertia-estimation | mass statement, CG travel, inertias |
+| 9. MDO exploration | design-of-experiments + multidisciplinary-optimization + surrogate-modeling | trade space, chosen optimum |
+| 10. Payload-range | payload-range-diagram | payload-range curve |
+| 11. Cost | parametric-cost + operating-cost + life-cycle-cost | DOC/LCC estimates |
+| 12. Structures check | wing-box-sizing + fuselage-skin-stringer | structural feasibility input |
+| 13. Package | (all above) | the concept design package |
+
+## Evidence gates
+
+- Stage 5 done = MTOW converged (two iterations within tolerance).
+- Stage 8 done = mass statement sums to MTOW; CG within limits at
+  critical loading conditions.
+- Stage 9 done = the chosen point is a real optimum in the trade data,
+  not an arbitrary pick.
+- FINAL = every configuration choice traces to a trade study result.
+
+## Boundary / forbidden
+
+- NEVER release a configuration for production or claim certification
+  approval.
+- Conceptual results are FEASIBILITY, not detailed design.
+- Cost estimates are parametric-class (accuracy band stated), not quotes.
+
+## Verification
+
+- Engine suite `tests/test_aircraft_design_core.py` (stdlib unittest,
+  offline, standalone): constraint T/W formulas match the bound
+  constraint-analysis/ws-tw-trade leaves; segment fuel fractions match
+  the sizing-mission-profile models (Breguet cruise + endurance holds,
+  weight chaining); class-I empty-weight fraction fit sits inside the
+  transport band; the MTOW loop genuinely iterates and converges within
+  0.5%; the concept package model is complete and its mass statement
+  balances; core + markdown evidence gates all pass with zero blanks.
+- Run: `python3 -m unittest tests.test_aircraft_design_core -v`
+- CLI contract: `python3 cli.py build --out package.md` (exit 0, gates
+  all_pass) and `python3 cli.py check --file package.md` (prints PASS).
+- Standalone proof: `AEROSKILLS_DEV=/nonexistent python3 cli.py build`
+  produces a converged concept package - no AeroSkills checkout needed.
+- tests/test_role_aircraft_design_engineer.py (offline): bound skills
+  resolve; workflow deterministic; package template complete (filled
+  generated deliverable, zero blanks); boundaries present.
+
+## Compliance
+
+- far-25 TIER-1 context. Data references summary-not-copy.
+- SOURCES.md records standards referenced.

package/roles/aircraft-design-engineer/SOURCES.md

@@ -0,0 +1,12 @@
+# SOURCES.md - Aircraft Conceptual Design Engineer
+
+| Source | Role use | Gated |
+|---|---|---|
+| 14 CFR Part 25 | certification context for sizing constraints | false |
+| Raymer, Aircraft Design: A Conceptual Approach | sizing methodology reference (book) | true |
+| Torenbeek, Synthesis of Subsonic Airplane Design | synthesis methods reference (book) | true |
+| Roskam, Airplane Design series | component sizing reference (book) | true |
+| NASA OpenVSP docs | geometry tooling docs | false |
+
+Summary-not-copy per STANDARDS.md. Methodology is encoded as original
+workflow; book content is referenced, never reproduced.