aero-agent-roles 1.0.0

package/roles/high-speed-aerodynamics-engineer/templates/high-speed-memo-template.md

@@ -0,0 +1,75 @@
+# High-Speed Aerodynamic Analysis Memo
+
+**Vehicle:** HSX-1 supersonic cruiser (reference flight condition)
+**Status:** draft-for-review (generated 2026-09-05)
+
+## 1. Flight condition summary
+
+- Vehicle: HSX-1 supersonic cruiser (reference flight condition) - Mach 2.0 supersonic transport configuration, subsonic-leading-edge swept wing, mixed-compression intake, high-temperature aluminium airframe
+- Flight condition: cruise M 2.00 at 18288 m; transonic climb check M 0.85 at 12192 m
+- ISA state at cruise: T 216.65 K, p 7172 Pa, rho 0.1153 kg/m3, a 295.07 m/s, mu 1.42e-05 kg/(m s)
+- Flow state: V = M a = 590.1 m/s, q = 20081 Pa
+- Configuration: swept wing (subsonic leading edge, sweep 66 deg), mixed-compression intake (ramp deflection 10.0 deg), equivalent body length 62 m
+
+## 2. Freestream total conditions and Mach-area
+
+- Isentropic total-to-static ratios at M 2.00: T0/T = 1.8000, p0/p = 7.8244, rho0/rho = 4.3469
+- Total conditions (isentropic, no shock): p0 = 56114 Pa, T0 = 389.97 K
+- Mach-area: A/A* at M 2.00 = 1.6875 (throat needed for isentropic capture); subsonic-branch root for the same ratio M = 0.3722
+- Use: intake contraction and nozzle expansion sizing (isentropic-flow-relations stage).
+
+## 3. Compressibility corrections and transonic limit
+
+- Karman-Tsien corrected peak suction at M 0.70: Cp = -0.55 / (sqrt(1-M^2) + (M^2/(1+sqrt(1-M^2))) x Cp/2) = -0.8654 (vs Prandtl-Glauert -0.7702)
+- Critical pressure coefficient at climb M 0.85: Cp* = -0.3020
+- Section critical Mach from Cp0 = -0.55: M_cr = 0.7017 (Cp* crossing solve)
+- Sweep effect: M_eff = M cos(Lambda): climb M 0.85 x cos(66 deg) = 0.3457; cruise M_eff = 0.8135 (subsonic leading edge)
+- Korn drag-divergence Mach (t/c 0.030, cruise CL 0.12): M_DD = 0.908; transonic wave-drag penalty at climb M 0.85 = 0.0000 (0 below M_DD), parabolic rise 0.0000
+- Terminating-shock strength at local M 1.30: p2/p1 = 1.8050
+- Transonic similarity parameter K = (1 - M^2)/tau^(2/3) = 2.874
+
+## 4. Shock system at the cruise Mach
+
+- Normal shock at nose/inlet face, M1 = 2.00: M2 = 0.5774, p2/p1 = 4.5000, T2/T1 = 1.6875, rho2/rho1 = 2.6667, p02/p01 = 0.7209
+- Intake ramp oblique shock, theta = 10.0 deg at M 2.00 (weak): beta = 39.31 deg, M2 = 1.641, p2/p1 = 1.7066, p02/p01 = 0.9846; theta_max = 22.97 deg
+- Terminal normal shock at M2 = 1.641: p02/p01 = 0.8797
+- Intake recovery: 2-shock p02/p01 = 0.8662 vs single normal shock 0.7209 (gain +0.1453)
+- Regular shock reflection at (M 1.641, theta 10.0 deg): verdict mach (required reflected deflection reaches the reflected-shock detachment limit at M2 (or M2 <= 1): Mach reflection)
+- Aft expansion (Prandtl-Meyer), turn 10.0 deg from M 1.641: M = 1.988, p2/p1 = 0.5875
+- Detached bow shock at the nose (sphere, R = 0.050 m): standoff Delta = 0.0161 m (Billig correlation, Delta/R = 0.3215)
+
+## 5. Supersonic section analysis and wave drag
+
+- Shock-expansion diamond airfoil at M 2.00, alpha 2.0 deg, half-angle 2.0 deg: cl = 0.0808, cd_wave = 0.00565, cm_le = 0.0387
+- Surface Cp (uf/ur/lf/lr): 0.0000 / -0.0738 / 0.0881 / 0.0000
+- Zero-lift wave drag area (Sears-Haack equivalent body, L = 62 m, r_max = 1.6 m): D/q = (9 pi/2)(A_max/L)^2 = 0.2379 m2
+
+## 6. Boundary layer and skin friction
+
+- Station x = 6.0 m at cruise: Re = rho V x / mu = 2.872e+07 (turbulent flat-plate regime)
+- Flat-plate thickness: delta = 0.07157 m, delta* = 0.00895 m, theta = 0.00696 m, H = 1.286
+- Skin friction: Cf_local = 0.00191 (1/7 power), Cf_avg = 0.00239, log-law Cf = 0.00255
+- Transition: Michel/Thwaites flat-plate natural transition at x_tr = 0.349 m (6% of the analysis station)
+- Attachment-line (Hiemenz 2-D) layer at the nose: a = 2U/R = 23606 1/s, delta = 0.000173 m, Cf = 0.00713
+- Surface roughness: k_s = 6.0e-06 m -> k+ = 0.887 (smooth; smooth retained below k+ = 5)
+
+## 7. Aerodynamic heating screen
+
+- Stagnation point (Sutton-Graves): q_s = C_SG sqrt(rho/Rn) V^3 = 57119 W/m2; radiation-equilibrium T = 1043 K (eps 0.85)
+- Flat-plate skin: recovery factor r = Pr^(1/3) = 0.8921 (turbulent); adiabatic wall temperature T_aw = T (1 + r (g-1)/2 M^2) = 371.3 K
+- Cold-wall skin flux at x = 6.0 m (Eckert reference temp, T_wall 300 K): q = 3838 W/m2, Cf = 0.00213 at Re* = 1.668e+07
+- Screening margins: skin 51.7 K below the 423 K limit; nose 210 K below the 600 K limit
+
+## 8. Margin summary
+
+| Margin | Value | Requirement | Source (stage) |
+|---|---|---|---|
+| Intake total-pressure recovery (2-shock system) | 0.8662 | > single normal-shock recovery 0.7209 at M 2.00 | stage 4: ramp oblique p02/p01 0.98464 x terminal normal p02/p01 0.87972 |
+| Oblique-shock attachment margin (theta_max - theta) | 12.9735 | > 0 deg (attached weak shock; detached above) | stage 4: theta_max 22.97 deg at M 2.00 (oblique-shock leaf) |
+| Section drag-divergence margin at cruise (M_DD - M_eff,cruise) | 0.0945 | > 0 (supercritical section subcritical at the cruise effective Mach M_eff 0.813) | stage 7: Korn rule M_DD = 0.908 (t/c 0.030, CL 0.12, supercritical) vs swept section M_eff = M cos(Lambda) |
+| Section critical-Mach margin at climb (M_cr,section - M_eff,climb) | 0.3560 | > 0 (wing section subcritical through the transonic climb leg, M_eff 0.346) | stage 3: Cp* crossing M_cr = 0.702 for Cp0 = -0.55; climb M_eff = M cos(Lambda) = 0.346 |
+| Skin kinetic-heating margin (T_limit - T_aw) | 51.7291 | > 0 (skin screening limit 423 K vs recovery temp) | stage 10: T_aw = T (1 + r (g-1)/2 M^2) = 371.3 K at M 2.00, recovery r = 0.8921 |
+| Nose stagnation-temperature margin (T_limit - T0) | 210.0300 | > 0 (nose screening limit 600 K vs stagnation-line recovery temperature T0) | stage 10: T0 = T (1 + (g-1)/2 M^2) = 390.0 K at M 2.00 (hot-wall ceiling; Sutton-Graves cold-wall flux 57119 W/m2 screened separately) |
+
+---
+*DRAFT - for human high-speed aerodynamics lead review. Not an approval document.*

package/roles/high-speed-aerodynamics-engineer/tests/test_bundle_protocol.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Test the evidence bundle + skill-dispatch protocol (PROTOCOL.md v1).
+
+Verifies:
+- build --bundle emits evidence/{model,gates,provenance}.json
+- bundle JSON parses, model contains computed numbers, gates all_pass
+- skill dispatch cross-checks the core against bound AeroSkills leaf
+  logic (isentropic ratios, normal shock, oblique shock, boundary
+  layer) when AeroSkills is present
+- standalone (no AeroSkills) emits the bundle honestly with
+  cross_checked=false
+"""
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+ROLE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CLI = os.path.join(ROLE_DIR, "cli.py")
+
+AEROSKILLS = os.environ.get("AEROSKILLS_DEV", os.path.expanduser("~/AeroSkills"))
+HAS_SKILLS = os.path.isdir(os.path.join(AEROSKILLS, "skills"))
+
+
+def run_build(outdir, env_extra=None, extra_args=None):
+    env = dict(os.environ)
+    if env_extra:
+        env.update(env_extra)
+    args = [sys.executable, CLI, "build", "--out",
+            os.path.join(outdir, "memo.md"), "--bundle"]
+    if extra_args:
+        args.extend(extra_args)
+    r = subprocess.run(args, capture_output=True, text=True, env=env)
+    return r
+
+
+class TestBundleProtocol(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_bundle_emits_three_files(self):
+        r = run_build(self.tmp)
+        self.assertEqual(r.returncode, 0, r.stderr[-500:])
+        ev = os.path.join(self.tmp, "evidence")
+        for f in ("model.json", "gates.json", "provenance.json"):
+            self.assertTrue(os.path.exists(os.path.join(ev, f)), f + " missing")
+
+    def test_model_has_numbers_and_status(self):
+        run_build(self.tmp)
+        m = json.load(open(os.path.join(self.tmp, "evidence", "model.json")))
+        self.assertIn("area_ratio", m)
+        self.assertIn("shocks", m)
+        self.assertIn("recovery_total", m["shocks"])
+        self.assertEqual(m.get("status"), "draft-for-review")
+        self.assertIn("role", m)
+
+    def test_gates_all_pass_exit_zero(self):
+        r = run_build(self.tmp)
+        g = json.load(open(os.path.join(self.tmp, "evidence", "gates.json")))
+        self.assertTrue(g["all_pass"])
+        self.assertEqual(g["exit_code"], 0)
+        self.assertGreaterEqual(len(g["gates"]), 4)
+
+    def test_dispatch_crosschecks_when_skills_present(self):
+        if not HAS_SKILLS:
+            self.skipTest("AeroSkills not present")
+        r = run_build(self.tmp)
+        p = json.load(open(os.path.join(self.tmp, "evidence",
+                                        "provenance.json")))
+        self.assertTrue(p["cross_checked"])
+        self.assertGreaterEqual(len(p["skills"]), 3)
+        for row in p["skills"]:
+            self.assertTrue(row["dispatched"])
+            self.assertTrue(row["agrees"],
+                            "core/skill disagree: %s" % row)
+            self.assertLessEqual(row["delta"], 1e-4)
+
+    def test_standalone_honest_no_skills(self):
+        r = run_build(self.tmp, env_extra={"AEROSKILLS_DEV": "/nonexistent"})
+        self.assertEqual(r.returncode, 0)
+        p = json.load(open(os.path.join(self.tmp, "evidence",
+                                        "provenance.json")))
+        self.assertFalse(p["cross_checked"])
+        self.assertEqual(len(p["skills"]), 0)
+
+    def test_check_still_works(self):
+        run_build(self.tmp)
+        md = os.path.join(self.tmp, "memo.md")
+        c = subprocess.run([sys.executable, CLI, "check", "--file", md],
+                           capture_output=True, text=True)
+        self.assertEqual(c.returncode, 0, c.stdout)
+        self.assertIn("RESULT: PASS", c.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/high-speed-aerodynamics-engineer/tests/test_high_speed_aero_core.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""Test high_speed_aero_core: the executable engine of the High-Speed
+Aerodynamics role.
+
+Proves the role can DO its job standalone (no AeroSkills checkout
+needed): formula correctness against the same known anchors the bound
+Aero Agent Skills leaves verify (isentropic ratios, Mach-area, normal
+and oblique shocks, Prandtl-Meyer, Karman-Tsien, Korn rule, boundary
+layer, heating, standoff), the memo builder, evidence gates, markdown
+completeness, and STANDALONE mode.
+"""
+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 high_speed_aero_core as hs
+
+
+class TestIsentropicAndMachArea(unittest.TestCase):
+    """Anchors from the isentropic-flow-relations leaf contract tests."""
+
+    def test_total_static_ratios_anchor_m2(self):
+        r = hs.total_static_ratios(2.0)
+        self.assertAlmostEqual(r["t0_over_t"], 1.8, delta=1e-9)
+        self.assertAlmostEqual(r["p0_over_p"], 7.8244490669, delta=1e-9)
+        self.assertAlmostEqual(r["rho0_over_rho"], 4.3469161483, delta=1e-9)
+        sl = hs.total_static_ratios(0.0)
+        self.assertEqual(sl["t0_over_t"], 1.0)
+
+    def test_area_ratio_anchors(self):
+        # A/A* at M2 = 1.6875 exactly (leaf test anchor)
+        self.assertAlmostEqual(hs.area_ratio(2.0), 1.6875, delta=1e-12)
+        self.assertAlmostEqual(hs.area_ratio(0.5), 1.33984375, delta=1e-12)
+        self.assertEqual(hs.area_ratio(1.0), 1.0)
+        # inverse on both branches round-trips (leaf anchors)
+        self.assertAlmostEqual(hs.mach_from_area_ratio(1.6875, subsonic=False),
+                               2.0, delta=1e-9)
+        self.assertAlmostEqual(hs.mach_from_area_ratio(1.6875, subsonic=True),
+                               0.372244486203, delta=1e-9)
+        with self.assertRaises(ValueError):
+            hs.area_ratio(0.0)
+
+    def test_static_to_total_and_choked_flow(self):
+        # leaf anchor: static 30000 Pa, 200 K, M 2 -> p0 ~ 234733
+        tot = hs.static_to_total(30000.0, 200.0, 2.0)
+        self.assertAlmostEqual(tot["p0"], 234733.472, delta=1e-2)
+        # choked mass flow at the leaf anchor p0 1e5, T0 300, A* 0.01
+        self.assertAlmostEqual(hs.choked_mass_flow(100000.0, 300.0, 0.01),
+                               2.3335585606, delta=1e-8)
+
+
+class TestCompressibilityCorrections(unittest.TestCase):
+    """Anchors from the transonic-similarity leaf logic."""
+
+    def test_pg_factor_and_kt_correction(self):
+        self.assertAlmostEqual(hs.prandtl_glauert_factor(0.5),
+                               1.0 / math.sqrt(0.75))
+        # leaf anchor: Karman-Tsien at cp0 -0.6, M 0.5 -> -0.7265391
+        self.assertAlmostEqual(hs.karman_tsien_correction(-0.6, 0.5),
+                               -0.7265391210, delta=1e-9)
+        with self.assertRaises(ValueError):
+            hs.karman_tsien_correction(-0.6, 0.9)  # documented to M ~ 0.85
+
+    def test_critical_pressure_and_mach(self):
+        # Cp* at M 0.8134 is negative; critical Mach from Cp0 -0.55 ~ 0.702
+        self.assertAlmostEqual(hs.critical_pressure_coefficient(0.8134),
+                               -0.3969978925, delta=1e-9)
+        self.assertAlmostEqual(hs.critical_mach_number(-0.55),
+                               0.7017202167, delta=1e-6)
+        with self.assertRaises(ValueError):
+            hs.critical_mach_number(0.1)
+
+    def test_transonic_similarity_and_sweep(self):
+        k = hs.transonic_similarity_parameter(0.85, 0.03)
+        self.assertAlmostEqual(k, (1 - 0.85 ** 2) / 0.03 ** (2.0 / 3.0))
+        self.assertAlmostEqual(hs.effective_mach(0.85, 66.0),
+                               0.85 * math.cos(math.radians(66.0)))
+        with self.assertRaises(ValueError):
+            hs.effective_mach(1.1, 45.0)  # subsonic only
+
+
+class TestShockRelations(unittest.TestCase):
+    """Anchors from the normal-shock and oblique-shock leaf tests."""
+
+    def test_normal_shock_anchor_m2(self):
+        # Anderson table A.2 anchor at M1 = 2: M2 0.5774, p2/p1 4.5 ...
+        p = hs.normal_shock(2.0)
+        self.assertAlmostEqual(p["m2"], 0.5773503, places=6)
+        self.assertAlmostEqual(p["p2_p1"], 4.5, places=6)
+        self.assertAlmostEqual(p["rho2_rho1"], 2.6666667, places=6)
+        self.assertAlmostEqual(p["t2_t1"], 1.6875, places=6)
+        self.assertAlmostEqual(p["p02_p01"], 0.7208739, places=6)
+        with self.assertRaises(ValueError):
+            hs.normal_shock(1.0)
+
+    def test_oblique_shock_anchor(self):
+        # Anderson example 4.2: M1 2, theta 10 deg -> weak beta 39.31,
+        # M2 1.64, p2/p1 1.707 (leaf contract anchor)
+        p = hs.oblique_shock(2.0, 10.0)
+        self.assertAlmostEqual(p["beta_deg"], 39.31393, delta=1e-3)
+        self.assertAlmostEqual(p["m2"], 1.64052, delta=1e-3)
+        self.assertAlmostEqual(p["p2_p1"], 1.70658, delta=1e-3)
+        self.assertAlmostEqual(p["p02_p01"], 0.984644, delta=1e-4)
+        self.assertAlmostEqual(hs.deflection_limit(2.0), 22.9735, delta=1e-2)
+        self.assertGreater(p["theta_max_deg"], 10.0)  # attached
+        # detached above theta_max
+        with self.assertRaises(ValueError):
+            hs.oblique_shock(2.0, 40.0)
+
+    def test_mach_angle_and_regular_reflection(self):
+        self.assertAlmostEqual(hs.mach_angle(2.0), 30.0, delta=1e-9)
+        v = hs.shock_reflection_verdict(2.0, 10.0)
+        self.assertEqual(v["verdict"], "regular")   # leaf anchor
+        v2 = hs.shock_reflection_verdict(hs.oblique_shock(2.0, 10.0)["m2"], 10.0)
+        self.assertEqual(v2["verdict"], "mach")     # leaf anchor @ M2 1.64
+
+    def test_prandtl_meyer(self):
+        # nu(2.0) = 0.460414 rad = 26.3799 deg (leaf anchor, Anderson A.5)
+        self.assertAlmostEqual(hs.prandtl_meyer_function(2.0),
+                               0.4604136821, delta=1e-9)
+        self.assertAlmostEqual(hs.prandtl_meyer_function(1.0), 0.0)
+        # expansion from M 1.64 through 10 deg -> ~ M 1.988 (leaf anchor)
+        exp = hs.expansion_properties(1.6405222, 10.0)
+        self.assertAlmostEqual(exp["m2"], 1.987794, delta=1e-3)
+        self.assertLess(exp["pressure_ratio_p2_p1"], 1.0)  # expansion drops p
+
+    def test_shock_expansion_airfoil_anchor(self):
+        # diamond airfoil M2, alpha 2, eps 2 (shock-expansion-airfoil leaf)
+        r = hs.shock_expansion_airfoil(2.0, 2.0, 2.0)
+        self.assertAlmostEqual(r["cl"], 0.0808190, delta=1e-4)
+        self.assertAlmostEqual(r["cd_wave"], 0.0056500, delta=1e-4)
+        self.assertAlmostEqual(r["cm_le"], 0.0386972, delta=1e-4)
+        self.assertGreater(r["cd_wave"], 0.0)
+
+
+class TestTransonicAndWaveDrag(unittest.TestCase):
+    """Anchors from supercritical-airfoil and wave-drag-area-rule leaves."""
+
+    def test_korn_and_terminating_shock(self):
+        self.assertAlmostEqual(hs.drag_divergence_mach(0.03, 0.12, True),
+                               0.95 - 0.03 - 0.012)
+        self.assertAlmostEqual(hs.drag_divergence_mach(0.035, 0.12, False),
+                               0.90 - 0.035 - 0.012)
+        # terminating shock strength: p2/p1 at local M 1.3 = 1.805,
+        # at 1.15 = 1.37625 (leaf anchors)
+        self.assertAlmostEqual(hs.terminating_shock_strength(1.3), 1.805)
+        self.assertAlmostEqual(hs.terminating_shock_strength(1.15),
+                               1.37625, delta=1e-9)
+
+    def test_wave_drag_penalty_and_sears_haack(self):
+        # penalty index zero below M_DD, (M-M_DD)^3 above (supercritical leaf)
+        self.assertEqual(hs.wave_drag_penalty(0.85, 0.908), 0.0)
+        self.assertAlmostEqual(hs.wave_drag_penalty(0.95, 0.853),
+                               0.097 ** 3, delta=1e-9)
+        # Sears-Haack zero-lift wave drag area (area-rule leaf anchor):
+        # D/q for L=62, r_max=1.6 -> 0.2378804 m2
+        self.assertAlmostEqual(hs.sears_haack_wave_drag_area(62.0, 1.6),
+                               0.2378804128, delta=1e-6)
+        # parabolic rise above M_DD: k (M-M_DD)^2
+        self.assertAlmostEqual(hs.wave_drag_rise_coef(0.95, 0.853, k=20.0),
+                               0.18818, delta=1e-6)
+
+
+class TestBoundaryLayerAndHeating(unittest.TestCase):
+    """Anchors from the boundary-layer and heating leaf logic."""
+
+    def test_flat_plate_thicknesses_laminar(self):
+        # Blasius at Re 1e5, x=1: delta 5/sqrt(1e5) = 0.0158 m
+        bl = hs.flat_plate_thicknesses(1.0, 1e5)
+        self.assertEqual(bl["regime"], "laminar")
+        self.assertAlmostEqual(bl["delta"], 5.0 / math.sqrt(1e5))
+        self.assertAlmostEqual(bl["delta_star"],
+                               1.7208 / math.sqrt(1e5))
+        self.assertAlmostEqual(bl["cf_local"], 0.664 / math.sqrt(1e5))
+        self.assertAlmostEqual(bl["shape_factor"], 1.7208 / 0.664)
+
+    def test_flat_plate_thicknesses_turbulent_and_loglaw(self):
+        # 1/7-power turbulent at Re 2.866e7, x=6 m (cruise-state anchor)
+        bl = hs.flat_plate_thicknesses(6.0, 2.866e7)
+        self.assertEqual(bl["regime"], "turbulent")
+        self.assertAlmostEqual(bl["delta"], 0.37 * 6.0 / (2.866e7) ** 0.2,
+                               delta=1e-4)
+        self.assertAlmostEqual(bl["shape_factor"], 9.0 / 7.0)
+        self.assertAlmostEqual(hs.cf_turbulent_log_law(1e7),
+                               0.455 / (7.0 ** 2.58), delta=1e-9)
+
+    def test_transition_and_roughness(self):
+        # flat-plate natural transition at the cruise state ~0.349 m
+        x_tr = hs.flat_plate_transition(1.236e-4, 590.0, 6.0)
+        self.assertIsNotNone(x_tr)
+        self.assertAlmostEqual(x_tr, 0.3489, delta=1e-2)
+        # roughness: k+ 0.887 is smooth
+        self.assertEqual(hs.roughness_regime(0.887), "smooth")
+        self.assertEqual(hs.roughness_regime(20.0), "transitional")
+        self.assertEqual(hs.roughness_regime(100.0), "fully-rough")
+
+    def test_stagnation_flow_layer(self):
+        a = hs.stagnation_velocity_gradient("cylinder", 590.0, 0.05)
+        self.assertAlmostEqual(a, 2.0 * 590.0 / 0.05)
+        self.assertAlmostEqual(hs.stagnation_bl_thickness(1.236e-4, a),
+                               2.4 * math.sqrt(1.236e-4 / a), delta=1e-6)
+
+    def test_heating_and_standoff(self):
+        # Sutton-Graves: q at the cruise nose state ~5.7e4 W/m2 (leaf run)
+        q = hs.stagnation_heat_flux(0.115, 590.0, 0.05)
+        self.assertAlmostEqual(q, 56999.5, delta=1.0)
+        t = hs.radiation_equilibrium_temp(q)
+        self.assertAlmostEqual(t, 1042.82, delta=0.5)
+        # recovery factor turbulent Pr^(1/3), laminar sqrt(Pr)
+        self.assertAlmostEqual(hs.recovery_factor("turbulent"),
+                               0.71 ** (1.0 / 3.0))
+        self.assertAlmostEqual(hs.recovery_factor("laminar"),
+                               math.sqrt(0.71))
+        # adiabatic wall temp at M2, 216.65 K -> 371.27 K (leaf anchor)
+        self.assertAlmostEqual(hs.adiabatic_wall_temperature(2.0, 216.65,
+                                                             "turbulent"),
+                               371.2709, delta=1e-3)
+        # Billig sphere standoff at M2: Delta/R = 0.32145
+        self.assertAlmostEqual(hs.bow_shock_standoff_ratio(2.0, "sphere"),
+                               0.143 * math.exp(3.24 / 4.0), delta=1e-9)
+
+
+class TestMemoBuilderAndGates(unittest.TestCase):
+
+    def test_example_memo_numbers(self):
+        model = hs.build_memo(hs.example_item())
+        # isentropic anchor at M2.0: A/A* = 1.6875 exactly
+        self.assertAlmostEqual(model["area_ratio"], 1.6875, delta=1e-9)
+        # normal-shock anchor at the cruise Mach: recovery ~0.721
+        self.assertAlmostEqual(model["shocks"]["normal"]["p02_p01"],
+                               0.720874, delta=1e-4)
+        # two-shock intake recovery beats a single normal shock
+        self.assertGreater(model["shocks"]["recovery_total"],
+                           model["shocks"]["recovery_single"])
+        # supersonic cruise with a subsonic leading edge (sweep 66 deg)
+        self.assertLess(model["corrections"]["m_eff_cruise"], 1.0)
+        # drag-divergence margin positive at the cruise effective Mach
+        self.assertGreater(model["corrections"]["m_dd"],
+                           model["corrections"]["m_eff_cruise"])
+        # boundary layer real at the cruise station
+        self.assertGreater(model["bl"]["re"], 1e6)
+        self.assertGreater(model["bl"]["flat_plate"]["delta"], 0.0)
+
+    def test_core_gates_all_pass(self):
+        model = hs.build_memo(hs.example_item())
+        gates = hs.check_memo(model)
+        self.assertTrue(gates["all_pass"], gates)
+        self.assertGreaterEqual(len(model["margins"]), 4)
+        for m in model["margins"]:
+            self.assertIn("stage ", m["source"])
+            self.assertGreater(m["value"], 0.0)
+
+    def test_memo_markdown_complete_and_no_blanks(self):
+        md = hs.example_memo_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("HSX-1", md)
+        self.assertGreater(len(md), 3000)
+        gates = hs.check_memo_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_standalone_no_skills_repo(self):
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = hs.build_memo(hs.example_item())
+        md = hs.render_memo_markdown(model)
+        self.assertTrue(hs.check_memo(model)["all_pass"])
+        self.assertGreater(len(md), 3000)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/high-speed-aerodynamics-engineer/tests/test_role_high_speed_aerodynamics.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""Role test: high-speed-aerodynamics-engineer.
+
+Verifies (offline, no network):
+1. Every skill bound in ROLE.md frontmatter RESOLVES to a real leaf in
+   the AeroSkills repo (the pinned skills_release band).
+2. The workflow stage order is deterministic and complete.
+3. The role is a 100% executable worker: core engine + cli.py exist,
+   and the filled deliverable template (generated worked example) has
+   zero blanks and carries the gate-check vocabulary.
+4. Boundaries are present in ROLE.md.
+"""
+import os
+import re
+import unittest
+
+ROLES_REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))          # repo root (4 up from tests/)
+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", "high-speed-aerodynamics-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates", "high-speed-memo-template.md")
+
+EXPECTED_BOUND = [
+    "aerodynamics/high-speed/isentropic-flow-relations",
+    "aerodynamics/high-speed/normal-shock",
+    "aerodynamics/high-speed/oblique-shock",
+    "aerodynamics/high-speed/prandtl-meyer",
+    "aerodynamics/high-speed/regular-shock-reflection",
+    "aerodynamics/high-speed/shock-expansion-airfoil",
+    "aerodynamics/high-speed/transonic-similarity",
+    "aerodynamics/high-speed/swept-wing-aerodynamics",
+    "aerodynamics/high-speed/supercritical-airfoil",
+    "aerodynamics/high-speed/wave-drag-area-rule",
+    "aerodynamics/high-speed/bow-shock-standoff",
+    "aerodynamics/high-speed/aerodynamic-heating",
+    "aerodynamics/high-speed/flat-plate-skin-friction-heating",
+    "aerodynamics/high-speed/hypersonic-flow",
+    "aerodynamics/boundary-layer/boundary-layer-theory",
+    "aerodynamics/boundary-layer/boundary-layer-transition",
+    "aerodynamics/boundary-layer/boundary-layer-separation",
+    "aerodynamics/boundary-layer/rough-wall-skin-friction",
+    "aerodynamics/boundary-layer/stagnation-flow-boundary-layer",
+]
+
+STAGES = [
+    "1. Flow-state setup",
+    "2. Isentropic relations",
+    "3. Compressibility corrections",
+    "4. Shock system",
+    "5. Expansion",
+    "6. Supersonic section",
+    "7. Transonic limit",
+    "8. Boundary layer",
+    "9. BL separation screen",
+    "10. Surface state",
+    "11. Heating screen",
+    "12. Memo",
+]
+
+
+def role_text():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    return open(p).read() if os.path.exists(p) else None
+
+
+class TestHighSpeedAerodynamicsRole(unittest.TestCase):
+
+    def test_bound_skills_resolve(self):
+        if not HAS_SKILLS:
+            self.skipTest("skills checkout absent (cross-repo dev check)")
+        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)
+        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), "stage missing in workflow")
+        self.assertEqual(idx, sorted(idx), "stage order not deterministic")
+
+    def test_template_present(self):
+        self.assertTrue(os.path.exists(TEMPLATE), "deliverable template missing")
+
+    def test_filled_template_zero_blanks(self):
+        # ROLE-STANDARD 100% bar: templates hold ONE filled deliverable
+        # (the generated worked example). Zero ___ placeholders.
+        if not os.path.exists(TEMPLATE):
+            self.fail("template missing")
+        text = open(TEMPLATE).read()
+        self.assertNotIn("___", text, "template still has blanks")
+        low = text.lower()
+        for phrase in ["high-speed aerodynamic analysis memo", "draft",
+                       "not an approval", "margin summary"]:
+            self.assertIn(phrase, low, f"gate vocabulary missing: {phrase}")
+        # real compressible-flow numbers present (M 2.00, p0/p ~ 7.82)
+        self.assertRegex(text, r"cruise M 2\.00")
+        self.assertRegex(text, r"p0/p = 7\.8244")
+
+    def test_executable_core_and_cli(self):
+        # 100% worker anatomy: executable domain engine + runnable CLI.
+        for rel in ("core/high_speed_aero_core.py", "cli.py",
+                    "tests/test_high_speed_aero_core.py"):
+            self.assertTrue(os.path.exists(os.path.join(ROLE_DIR, rel)),
+                            f"missing executable part: {rel}")
+
+    def test_boundaries(self):
+        role = role_text()
+        self.assertIsNotNone(role)
+        role = role or ""
+        for phrase in ["sign_off_required: true", "forbidden",
+                       "never", "claim certification approval", "screening"]:
+            self.assertIn(phrase, role, f"missing boundary: {phrase}")
+
+    def test_sources(self):
+        self.assertTrue(os.path.exists(os.path.join(ROLE_DIR, "SOURCES.md")),
+                        "SOURCES.md missing")
+
+
+if __name__ == "__main__":
+    unittest.main()