aero-agent-roles 1.0.0

package/roles/propulsion-engineer/templates/propulsion-report-template.md

@@ -0,0 +1,92 @@
+# Propulsion Design Report
+
+**Item:** High-bypass turbofan for a 200-seat twin (design study)
+**Vehicle / mission:** 200-seat twin-aisle-class transport, 2 wing-mounted engines - Subsonic transport cruise design point (M0.78, FL350)
+**Engine class:** high-bypass turbofan (BPR 8, FPR 1.60, OPR 30, TIT 1650 K)
+**Status:** draft-for-review
+**Certification basis:** Design study in a FAR 33 engine-type context; no certification approval claimed
+
+## 1. Requirement and selected cycle
+
+- Thrust requirement (per engine, design point): 30.0 kN net at M0.78, 11 km ISA.
+- Selected cycle: separate-stream turbofan with the fan on the low-pressure spool and the core compressor/turbine on the high-pressure spool. Rationale: high bypass ratio (8) lowers mean jet velocity and raises propulsive efficiency at a transonic cruise Mach; the OPR 30 / TIT 1650 K core delivers the cruise SFC of 0.541 lb/(lbf.h) computed below.
+- Design airflow (total, matched to the requirement): 141.0 kg/s.
+
+## 2. Cycle analysis (airbreathing)
+
+On-design station state table (total temperature / total pressure, per kg/s inlet airflow basis; component efficiencies are stated inputs below):
+
+| Station | Name | Tt (K) | Pt (kPa) |
+|---|---|---|---|
+| 2 | fan face | 245.4 | 35.5 |
+| 13 | fan exit | 284.6 | 56.7 |
+| 3 | compressor exit | 699.1 | 1063.7 |
+| 4 | turbine inlet (TIT) | 1650.0 | 1010.5 |
+| 5 | turbine exit | 996.2 | 97.5 |
+
+Core nozzle (station 9): exit static 855 K / 52.7 kPa, jet velocity 565.6 m/s, Mach 1.000, choked, exit area 0.2936 m^2 (per engine).
+Fan nozzle (station 19): exit static 237 K / 29.7 kPa, jet velocity 305.6 m/s, Mach 1.000, choked, exit area 1.1711 m^2 (per engine).
+
+- Net thrust (per engine, design point): 30.0 kN = sum of m_dot*(V9 - V0) + (P9 - P0)*A9 over both streams.
+- TSFC: 15.3 g/(kN.s)  (0.541 lb/(lbf.h)).
+- Fuel/air ratio (core): 0.02937 (total basis 0.00326); fuel flow 0.460 kg/s per engine.
+- Efficiencies: overall 0.349, thermal 0.412, propulsive 0.848 (kinetic-energy method over both streams); ideal Brayton at OPR 30: 0.622.
+
+Input assumptions (stated): fan efficiency 0.90, core compressor efficiency 0.90, turbine 0.90, combustor 0.995 (pressure ratio 0.95), inlet recovery 0.995, fan-duct ratio 0.99, mechanical 0.99, nozzle velocity coefficient 0.99; fuel LHV 43.2 MJ/kg (kerosene class). Component maps and stage counts are representative input.
+
+## 3. Off-design
+
+Quick off-design model (turbofan-off-design leaf): corrected mass flow and turbine inlet temperature held at the design value; physical airflow scales by delta/sqrt(theta); net thrust is recomputed through the on-design cycle at each flight point.
+
+| Point | Alt (km) | Mach | Throttle | Verdict | m_dot (kg/s) | F_net (kN) | TSFC g/(kN.s) | Surge clearance | Map verdict |
+|---|---|---|---|---|---|---|---|---|---|
+| SLS static | 0 | 0.00 | 1.00 | max-continuous | 370.1 | 111.5 | 9.7 | 15% | on-map |
+| FL250 climb | 8 | 0.78 | 1.00 | max-continuous | 213.0 | 39.4 | 16.7 | 15% | on-map |
+| FL350 design cruise | 11 | 0.78 | 1.00 | max-continuous | 141.0 | 30.0 | 15.3 | 15% | on-map |
+| FL350 part power | 11 | 0.78 | 0.60 | cruise | 141.0 | 18.0 | 15.3 | 15% | on-map |
+| FL390 top of cruise | 12 | 0.80 | 1.00 | max-continuous | 119.0 | 25.7 | 15.1 | 15% | on-map |
+
+Surge clearance: representative core-compressor surge line set 115% above the operating line pressure ratio (34 vs OPR 30); the operating line clears surge at every envelope point (representative map input, not vendor data).
+
+## 4. Component selection
+
+| Component | Choice | Basis |
+|---|---|---|
+| Inlet | subsonic pitot, recovery 0.995 | cruise M0.78 |
+| Fan | single stage, PR 1.60, eta 0.90 | Tt 285 K at design |
+| Core compressor | multi-stage axial, PR 18.8 (OPR 30/fan 1.60) | Tt 699 K, representative map margin |
+| Combustor | annular, eta 0.995, pressure ratio 0.95 | f/a 0.02937 |
+| HP turbine | cooled (turbine-blade-cooling stage), eta 0.90 | Tt in 1650 K, Tt out 996 K |
+| Core nozzle | convergent, choked at design | area 0.2936 m^2 |
+| Fan nozzle | convergent, choked at design | area 1.1711 m^2 |
+
+## 5. Integration
+
+- Ram-drag bookkeeping (engine-airframe integration): net thrust above already subtracts the inlet momentum drag m_dot_0*V0 (= 32.6 kN at the design point).
+- Installed performance: nacelle, pylon and bleed/accessory losses are NOT yet deducted; the uninstalled net thrust is 30.0 kN per engine.  Installation bookkeeping is a follow-on engine-airframe integration pass.
+
+## 6. Rocket / space option (if applicable)
+
+Not applicable to this airbreathing transport item - the engine selection is turbofan.  For a space item the rocket-engine-cycle and nozzle-design stages apply (see the rocket reference example in the core / cli build --engine rocket).
+
+## 7. Electric option (if applicable)
+
+Not applicable: no electric-propulsion role for a 30 kN cruise thrust requirement at M0.78.  Electric thrusters cover the low-thrust space regime (hall/gridded-ion), not airbreathing main propulsion.
+
+## 8. Bypass-ratio trade and recommendation
+
+First-order trade at fixed core conditions, fixed total mass flow and jet velocities held at the design-point values (bypass-ratio-trade leaf method):
+
+| BPR | F/m_dot (N per kg/s) | TSFC g/(kN.s) | eta_o |
+|---|---|---|---|
+| 2 | 273.3 | 35.8 | 0.149 |
+| 4 | 211.0 | 27.8 | 0.192 |
+| 6 | 184.3 | 22.8 | 0.235 |
+| 8 | 169.5 | 19.3 | 0.278 |
+| 10 | 160.1 | 16.7 | 0.321 |
+| 12 | 153.5 | 14.7 | 0.364 |
+
+Raising BPR lowers specific thrust and TSFC by shifting flow to the fan stream (bypass-ratio-trade trend), at the cost of fan diameter and nacelle drag.  BPR 8 balances specific thrust with nacelle integration for a 200-seat twin; the design point above is the recommendation.  Open items: nacelle drag, turbine cooling flow, and the component map verification.
+
+---
+*Generated by Aero Agent Roles propulsion-engineer core (2026-09-05). DRAFT for human propulsion lead review. Not an approval document.*

package/roles/propulsion-engineer/tests/test_propulsion_engineer_core.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""Test propulsion_core: the executable engine of the Propulsion Engineer.
+
+Proves the role can DO its job standalone (no AeroSkills needed): ISA,
+Brayton/real-cycle relations, turbofan on-design thrust/TSFC/efficiency,
+nozzle choked/unchoked logic, compressor-map surge verdicts, off-design
+envelope, bypass-ratio trade, rocket Isp/mass-split/cycle feasibility,
+report builder + evidence gates, and standalone mode.
+"""
+import os
+import re
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "core"))
+from propulsion_core import (  # noqa: E402
+    PROPELLANTS, bpr_trend, build_report, build_rocket_report,
+    build_turbofan_report, brayton_thermal_efficiency, check_report,
+    check_report_markdown, compressor_exit_temperature,
+    cycle_feasibility, example_rocket_item, example_rocket_markdown,
+    example_turbofan_item, example_turbofan_markdown, exit_mach_from_area_ratio,
+    isa, map_verdict, mass_flow_split, off_design_envelope, operating_line_clearance,
+    real_thermal_efficiency, render_report_markdown, rocket_mass_flow,
+    rocket_nozzle_sizing, thrust_split, turbofan_design_point,
+    turbine_exit_temperature, turbine_power,
+)
+
+# 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")
+
+
+class TestCoreDomainRules(unittest.TestCase):
+    """Public-standard anchors mirrored from the bound AeroSkills leaves."""
+
+    def test_isa_at_sea_level(self):
+        s = isa(0.0)
+        self.assertAlmostEqual(s["t"], 288.15, places=2)
+        self.assertAlmostEqual(s["p"], 101325.0, places=1)
+
+    def test_brayton_anchor_pr8(self):
+        # Ideal Brayton at PR 8, gamma 1.4: 0.44795 (leaf anchor).
+        self.assertAlmostEqual(brayton_thermal_efficiency(8.0), 0.44795,
+                               delta=1e-3)
+
+    def test_compressor_anchor(self):
+        # T2 = T1*PR^((g-1)/g), 288 K / PR 8: 521.70 K (leaf anchor).
+        self.assertAlmostEqual(compressor_exit_temperature(288.0, 8.0),
+                               521.70, delta=0.1)
+        # real-cycle with efficiency raises the exit temperature
+        self.assertGreater(
+            compressor_exit_temperature(288.0, 8.0, eta_c=0.85),
+            compressor_exit_temperature(288.0, 8.0, eta_c=1.0))
+
+    def test_turbine_anchor(self):
+        # T4 = T3/PR^((g-1)/g), 1400 K / PR 8: 772.86 K (leaf anchor).
+        self.assertAlmostEqual(turbine_exit_temperature(1400.0, 8.0, 1.4),
+                               772.86, delta=0.1)
+
+    def test_real_thermal_efficiency_order(self):
+        # Requires physically ordered stations; net/heat < 1.
+        eta = real_thermal_efficiency(288.0, 600.0, 1500.0, 900.0)
+        self.assertGreater(eta, 0.0)
+        self.assertLess(eta, 1.0)
+        with self.assertRaises(ValueError):
+            real_thermal_efficiency(600.0, 288.0, 1500.0, 900.0)
+
+    def test_area_mach_supersonic(self):
+        # area ratio 2 -> Mach ~1.5-2 on the supersonic branch (gamma 1.2)
+        m = exit_mach_from_area_ratio(2.0, 1.2)
+        self.assertGreater(m, 1.0)
+        with self.assertRaises(ValueError):
+            exit_mach_from_area_ratio(1.0, 1.2)  # sonic is not supersonic
+
+
+class TestTurbofanDesignPoint(unittest.TestCase):
+    """On-design cycle: real numbers, physical ordering, gates."""
+
+    def test_cruise_design_point_realistic(self):
+        # Reference item: BPR 8 / OPR 30 / TIT 1650 at M0.78 FL350.
+        d = turbofan_design_point(0.78, 10668.0, 8.0, 1.6, 30.0, 1650.0)
+        # station temperature ordering
+        st = d["stations"]
+        self.assertLess(st["2"]["tt"], st["13"]["tt"])
+        self.assertLess(st["13"]["tt"], st["3"]["tt"])
+        self.assertLess(st["3"]["tt"], st["4"]["tt"])
+        self.assertLess(st["5"]["tt"], st["4"]["tt"])
+        # realistic compressor exit for OPR 30 at cruise (700 K ballpark)
+        self.assertTrue(600 < st["3"]["tt"] < 850, st["3"]["tt"])
+        # net thrust per kg/s air positive and in a physical band (N)
+        self.assertTrue(150 < d["f_net_per_kg"] < 250, d["f_net_per_kg"])
+        # cruise TSFC in the modern high-bypass band: 12-20 g/(kN s)
+        tsfc = d["tsfc_kg_Ns"] * 1e6
+        self.assertTrue(12.0 < tsfc < 20.0, tsfc)
+        # efficiencies bounded and consistent: eta_o = eta_th * eta_p
+        self.assertLess(d["eta_o"], 1.0)
+        self.assertLess(d["eta_p"], 1.0)
+        self.assertAlmostEqual(d["eta_o"], d["eta_th"] * d["eta_p"], delta=1e-6)
+
+    def test_scaled_to_thrust_requirement(self):
+        item = example_turbofan_item()
+        model = build_turbofan_report(item)
+        d = model["design"]
+        # sizing hits the requirement
+        self.assertAlmostEqual(d["f_net"], 30000.0, delta=100.0)
+        self.assertGreater(d["mdot0"], 50.0)          # 100+ kg/s class airflow
+        self.assertGreater(d["mdot_fuel"], 0.3)       # kg/s fuel flow
+
+    def test_sls_static_nozzles_unchoked(self):
+        # at SLS (M0, sea level) the nozzle pressure ratios are below the
+        # critical ratio (fan NPR ~1.6 < 1.89), so both are unchoked and
+        # fully expanded to ambient.
+        d = turbofan_design_point(0.0, 0.0, 8.0, 1.6, 30.0, 1650.0)
+        self.assertFalse(d["nozzle_core"]["choked"])
+        self.assertFalse(d["nozzle_fan"]["choked"])
+        self.assertEqual(d["v0"], 0.0)
+        # at the M0.78 / FL350 design point both nozzles are choked
+        c = turbofan_design_point(0.78, 10668.0, 8.0, 1.6, 30.0, 1650.0)
+        self.assertTrue(c["nozzle_core"]["choked"])
+        self.assertTrue(c["nozzle_fan"]["choked"])
+
+    def test_bad_inputs_raise(self):
+        with self.assertRaises(ValueError):
+            turbofan_design_point(1.2, 0.0, 8.0, 1.6, 30.0, 1650.0)
+        with self.assertRaises(ValueError):
+            turbofan_design_point(0.78, 10668.0, 0.0, 1.6, 30.0, 1650.0)
+        with self.assertRaises(ValueError):
+            turbofan_design_point(0.78, 10668.0, 8.0, 1.0, 30.0, 1650.0)
+        with self.assertRaises(ValueError):
+            turbofan_design_point(0.78, 10668.0, 8.0, 1.6, 30.0, 1400.0)
+
+    def test_thrust_identity(self):
+        # momentum+pressure form reproduces thrust: F = mdot(V9-V0)+(P9-P0)A9
+        d = turbofan_design_point(0.78, 10668.0, 8.0, 1.6, 30.0, 1650.0)
+        nc, nf = d["nozzle_core"], d["nozzle_fan"]
+        f = (d["mdot_core_frac"] * (1 + d["f_air_core"]) * (nc["ve"] - d["v0"])
+             + (nc["pe"] - d["p0"]) * nc["a_exit"]
+             + d["mdot_fan_frac"] * (nf["ve"] - d["v0"])
+             + (nf["pe"] - d["p0"]) * nf["a_exit"])
+        self.assertAlmostEqual(f, d["f_net_per_kg"], delta=1e-6)
+
+
+class TestOffDesignAndTrade(unittest.TestCase):
+    def test_off_design_envelope_covers_points(self):
+        d = turbofan_design_point(0.78, 10668.0, 8.0, 1.6, 30.0, 1650.0)
+        d["mdot0"] = 100.0
+        pts = [("SLS", 0.0, 0.0, 1.0), ("FL250", 7620.0, 0.78, 1.0),
+               ("part power", 10668.0, 0.78, 0.6)]
+        rows = off_design_envelope(d, pts)
+        self.assertEqual(len(rows), 3)
+        for r in rows:
+            self.assertGreater(r["mdot_phys"], 0.0)
+            self.assertGreater(r["f_net"], 0.0)
+            self.assertIn(r["map_verdict"], ("on-map", "approaching-surge"))
+            self.assertTrue(r["surge_clearance_pct"] > 0.0)
+        # named point carried through, part-power below the max row
+        self.assertEqual(rows[0]["name"], "SLS")
+        self.assertLess(rows[2]["f_throttled"], rows[2]["f_net"])
+
+    def test_surge_clearance_and_verdict(self):
+        # clearance positive below surge; verdict on-map until within 5%
+        self.assertAlmostEqual(operating_line_clearance(20.0, 23.0), 15.0)
+        self.assertEqual(map_verdict(20.0, 23.0), "on-map")
+        self.assertEqual(map_verdict(22.4, 23.0), "approaching-surge")
+        with self.assertRaises(ValueError):
+            map_verdict(23.0, 23.0)  # on/above the surge line is rejected
+
+    def test_thrust_split_and_bpr_trend(self):
+        s = thrust_split(8.0, 90.0, 500.0, 300.0, 231.0)
+        self.assertGreater(s["f_total"], 0.0)
+        # trend signature: bpr_trend(mdot_total, vj_core, vj_fan, v0, f_core)
+        trend = bpr_trend(90.0, 500.0, 300.0, 231.0, 0.02)
+        self.assertEqual(len(trend), 6)
+        # fixed core/fan jet velocities, fixed total flow (leaf model):
+        # higher BPR shifts flow to the slower fan stream -> specific
+        # thrust and TSFC both fall monotonically.
+        specs = [r["specific_thrust"] for r in trend]
+        tsfcs = [r["tsfc_g_kN_s"] for r in trend]
+        self.assertEqual(specs, sorted(specs, reverse=True))
+        self.assertEqual(tsfcs, sorted(tsfcs, reverse=True))
+
+
+class TestRocketDomain(unittest.TestCase):
+    def test_propellant_table(self):
+        # reference-typical values from the rocket-engine-cycle leaf
+        self.assertEqual(PROPELLANTS["LOX/LH2"], (1140.0, 71.0, 5.5, 430.0))
+        self.assertEqual(PROPELLANTS["LOX/RP-1"], (1140.0, 820.0, 2.56, 300.0))
+
+    def test_mass_flow_from_isp(self):
+        # mdot = F/(Isp*g0): 110 kN at Isp 430 -> ~26.1 kg/s
+        m = rocket_mass_flow(110000.0, 430.0)
+        self.assertAlmostEqual(m, 26.1, delta=0.2)
+        mdot, mox, mf = mass_flow_split(110000.0, 430.0, 5.5)
+        self.assertAlmostEqual(mdot, mox + mf, delta=1e-9)
+        self.assertAlmostEqual(mox / mf, 5.5, delta=1e-9)
+
+    def test_cycle_feasibility_bounds(self):
+        # pressure-fed bound at 3 MPa; expander LOX/LH2 <= 10 MPa
+        ok, _ = cycle_feasibility("pressure-fed", "LOX/LH2", 2.0e6)
+        self.assertTrue(ok)
+        ok, _ = cycle_feasibility("pressure-fed", "LOX/LH2", 4.0e6)
+        self.assertFalse(ok)
+        ok, _ = cycle_feasibility("expander", "LOX/LH2", 8.0e6)
+        self.assertTrue(ok)
+        ok, _ = cycle_feasibility("expander", "LOX/RP-1", 4.0e6)
+        self.assertFalse(ok)   # expander needs the LH2 fuel
+        ok, _ = cycle_feasibility("staged-combustion", "LOX/RP-1", 20.0e6)
+        self.assertTrue(ok)
+
+    def test_turbine_power_positive(self):
+        p = turbine_power(4.0, 2000.0, 1200.0, 0.6, 1.2, 3.2e6, 0.2e6)
+        self.assertGreater(p, 0.0)
+
+    def test_nozzle_sizing(self):
+        n = rocket_nozzle_sizing(26.1, 4.0e6, 3500.0, 1.2, 84.0, r_gas=693.0)
+        self.assertGreater(n["a_star"], 0.0)
+        self.assertGreater(n["me"], 3.0)       # supersonic, high area ratio
+        self.assertLess(n["pe"], 4.0e6)
+        self.assertGreater(n["cf_ideal"], 1.5)  # vacuum Cf of a good nozzle
+        # ideal exit velocity implies ideal vacuum Isp > real typical
+        self.assertGreater(n["ve"] / 9.80665, 430.0)
+
+    def test_rocket_report_builder(self):
+        model = build_rocket_report(example_rocket_item())
+        self.assertEqual(model["engine_kind"], "rocket")
+        self.assertEqual(model["cycle"]["propellant"], "LOX/LH2")
+        self.assertTrue(model["cycle"]["feasible"])
+        gates = check_report(model)
+        self.assertTrue(gates["all_pass"], gates)
+        md = render_report_markdown(model)
+        self.assertIn("not an approval", md.lower())
+
+
+class TestReportBuilderAndGates(unittest.TestCase):
+    def test_turbofan_report_gates(self):
+        model = build_report(example_turbofan_item())
+        self.assertEqual(model["document_type"], "Propulsion Design Report")
+        self.assertEqual(model["status"], "draft-for-review")
+        gates = check_report(model)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_markdown_gates(self):
+        md = example_turbofan_markdown()
+        gates = check_report_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+        for section in ("## 1. Requirement", "## 2. Cycle analysis",
+                        "## 3. Off-design", "## 4. Component selection",
+                        "## 8. Bypass-ratio trade"):
+            self.assertIn(section, md)
+        self.assertIn("not an approval", md.lower())
+
+    def test_report_has_computed_numbers(self):
+        # evidence gate: every headline performance claim is a number
+        md = example_turbofan_markdown()
+        self.assertRegex(md, r"kN")
+        self.assertRegex(md, r"g/\(kN\.s\)|lb/\(lbf\.h\)")
+        self.assertRegex(md, r"\d+\.\d+ kg/s")
+        self.assertRegex(md, r"K")
+
+    def test_rocket_markdown_no_blank_template(self):
+        md = example_rocket_markdown()
+        self.assertNotIn("___", md)
+        self.assertIn("not an approval", md.lower())
+
+    def test_deliverable_template_filled(self):
+        # templates/propulsion-report-template.md is the FILLED example
+        # deliverable (the reference turbofan item): zero blanks, and it
+        # matches what the core renders today (modulo the date footer).
+        here = os.path.dirname(os.path.abspath(__file__))
+        tmpl = os.path.join(here, "..", "templates",
+                            "propulsion-report-template.md")
+        with open(tmpl) as f:
+            text = f.read()
+        self.assertNotIn("___", text)
+        low = text.lower()
+        self.assertIn("not an approval", low)
+        self.assertIn("draft", low)
+        fresh = example_turbofan_markdown()
+        norm = lambda s: re.sub(r"\(20\d\d-\d\d-\d\d\)", "(DATE)", s)
+        self.assertEqual(norm(text), norm(fresh))
+
+    def test_standalone_no_skills_repo(self):
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        for item, render in ((example_turbofan_item(), example_turbofan_markdown),
+                             (example_rocket_item(), example_rocket_markdown)):
+            model = build_report(item)
+            self.assertTrue(check_report(model)["all_pass"])
+            md = render()
+            self.assertGreater(len(md), 1000)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/roles/propulsion-engineer/tests/test_role_propulsion_engineer.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""Role test: propulsion-engineer."""
+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", "propulsion-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates", "propulsion-report-template.md")
+
+EXPECTED_BOUND = [
+    "propulsion/gas-turbine-cycle/gas-turbine-cycle",
+    "propulsion/gas-turbine-cycle/real-cycle-effects",
+    "propulsion/gas-turbine-cycle/afterburner-cycle",
+    "propulsion/gas-turbine-cycle/regenerative-cycle",
+    "propulsion/gas-turbine-cycle/propelling-nozzle",
+    "propulsion/gas-turbine-cycle/subsonic-inlet-recovery",
+    "propulsion/gas-turbine-cycle/combustor-design",
+    "propulsion/turbofan/turbofan-cycle",
+    "propulsion/turbofan/bypass-ratio-trade",
+    "propulsion/turbofan/turbofan-off-design",
+    "propulsion/turboprop/turboprop-cycle",
+    "propulsion/turboprop/free-turbine",
+    "propulsion/axial-compressor/axial-compressor-stage",
+    "propulsion/axial-compressor/compressor-map",
+    "propulsion/axial-compressor/multi-stage-compressor",
+    "propulsion/axial-compressor/turbine-stage",
+    "propulsion/axial-compressor/turbine-blade-cooling",
+    "propulsion/engine-airframe/engine-airframe-integration",
+    "propulsion/rocket/rocket-engine-cycle",
+    "propulsion/rocket/nozzle-design",
+    "propulsion/rocket/combustion-chamber-design",
+    "propulsion/rocket/injector-design",
+    "propulsion/rocket/propellant-selection",
+    "propulsion/rocket/solid-rocket-motor",
+    "propulsion/rocket/hybrid-rocket-motor",
+    "propulsion/rocket/thrust-chamber-cooling",
+    "propulsion/rocket/thrust-vector-control",
+    "propulsion/rocket/cold-gas-thruster",
+    "propulsion/combustion/cea-rocket-combustion",
+    "propulsion/electric/hall-thruster",
+    "propulsion/electric/gridded-ion-thruster",
+    "propulsion/electric/electrothermal-thruster",
+    "propulsion/ramjet/ramjet-cycle",
+    "propulsion/ramjet/ramjet-inlet"
+]
+
+STAGES = [
+    "1. Airbreathing cycle",
+          "2. Bypass/regenerative/AB trades",
+          "3. Off-design",
+          "4. Components",
+          "5. Turbine cooling",
+          "6. Integration",
+          "7. Rocket cycle",
+          "8. Solid/hybrid",
+          "9. Cooling/TVC",
+          "10. Combustion",
+          "11. Electric",
+          "12. Ramjet",
+          "13. Report"
+]
+
+
+def role_text():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    return open(p).read() if os.path.exists(p) else None
+
+
+class TestPropulsionEngineerRole(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_boundaries(self):
+        role = role_text()
+        self.assertIsNotNone(role)
+        for phrase in ["sign_off_required: true", "forbidden"]:
+            self.assertIn(phrase, role)
+
+    def test_sources(self):
+        self.assertTrue(os.path.exists(os.path.join(ROLE_DIR, "SOURCES.md")),
+                        "SOURCES.md missing")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/space-systems-engineer/ROLE.md

@@ -0,0 +1,161 @@
+---
+type: role
+name: space-systems-engineer
+title: "Space Systems Engineer"
+status: draft
+domain: space-systems
+deliverable_type: "spacecraft mission + subsystem design report"
+standards_bound:
+  - id: ecss
+    tier: TIER-2
+    reference-only: true
+skills_bound:
+  - space-systems/mission-design/mission-delta-v-budget
+  - space-systems/mission-design/launch-window-analysis
+  - space-systems/mission-design/c3-departure-energy
+  - space-systems/mission-design/entry-descent-landing
+  - space-systems/mission-design/radiation-debris
+  - space-systems/orbit-mechanics/keplerian-elements
+  - space-systems/orbit-mechanics/kepler-orbit-propagation
+  - space-systems/orbit-mechanics/hohmann-transfer
+  - space-systems/orbit-mechanics/bi-elliptic-transfer
+  - space-systems/orbit-mechanics/plane-change-maneuver
+  - space-systems/orbit-mechanics/lambert-transfer
+  - space-systems/orbit-mechanics/gravity-assist-swingby
+  - space-systems/orbit-mechanics/low-thrust-spiral
+  - space-systems/orbit-mechanics/orbital-perturbations
+  - space-systems/orbit-mechanics/sun-synchronous-inclination
+  - space-systems/orbit-mechanics/ground-track-repeat
+  - space-systems/orbit-mechanics/eclipse-time
+  - space-systems/orbit-mechanics/satellite-coverage
+  - space-systems/orbit-mechanics/walker-delta-constellation
+  - space-systems/orbit-mechanics/geostationary-station-keeping
+  - space-systems/orbit-mechanics/conjunction-assessment
+  - space-systems/orbit-mechanics/three-body-libration
+  - space-systems/orbit-mechanics/orbital-decay
+  - space-systems/orbit-mechanics/clohessy-wiltshire
+  - space-systems/adcs/attitude-determination-triad
+  - space-systems/adcs/attitude-determination-quest
+  - space-systems/adcs/star-tracker
+  - space-systems/adcs/sun-pointing
+  - space-systems/adcs/reaction-wheel-control
+  - space-systems/adcs/control-moment-gyro
+  - space-systems/adcs/magnetorquer-control
+  - space-systems/adcs/attitude-control-sizing
+  - space-systems/adcs/pointing-error-budget
+  - space-systems/adcs/gyro-allan-variance
+  - space-systems/subsystems/communication-link-budget
+  - space-systems/subsystems/antenna-aperture-sizing
+  - space-systems/subsystems/power-thermal-budget
+  - space-systems/subsystems/solar-array-sizing
+  - space-systems/subsystems/spacecraft-battery-sizing
+  - space-systems/subsystems/thermal-design
+  - space-systems/subsystems/propellant-tank-sizing
+  - space-systems/subsystems/command-data-handling
+  - space-systems/ecss/systems-engineering
+  - space-systems/ecss/software-engineering
+  - space-systems/ecss/software-verification
+tools_allowed: [stdlib, offline-file-processing]
+forbidden:
+  - "claim certification approval"
+  - "declare launch readiness"
+  - "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+"
+---
+
+# Space Systems Engineer
+
+## Role identity
+
+Owns spacecraft mission and subsystem design: delta-v budget, transfer
+and maneuver design, constellation/coverage analysis, ADCS selection,
+and the subsystem sizing loop (power, thermal, comms, propulsion,
+C&DH) that closes a satellite design against its mission. Use when a
+space mission needs a defensible spacecraft with a delta-v budget,
+orbit, attitude control solution, and subsystem power/thermal/comm
+budgets. Do NOT use for aircraft certification or airframe roles.
+
+## Deliverable contract
+
+1. **Mission design report** - orbit + maneuver plan, delta-v budget,
+   launch window, coverage/constellation result, radiation/debris notes.
+2. **Subsystem design report** - ADCS selection + pointing budget,
+   power/thermal/comm budgets, solar array/battery/tank sizing, C&DH.
+3. **System budget summary** - mass, power, delta-v, pointing.
+
+## Workflow (stages -> bound skills)
+
+| Stage | Loads skill | Produces |
+|---|---|---|
+| 1. Mission delta-v | mission-delta-v-budget + keplerian-elements + kepler-orbit-propagation | orbit elements, total delta-v |
+| 2. Transfers | hohmann-transfer + bi-elliptic-transfer + plane-change-maneuver + lambert-transfer + gravity-assist-swingby + low-thrust-spiral | transfer solution |
+| 3. Launch window | launch-window-analysis + c3-departure-energy | window/C3 |
+| 4. Constellation/coverage | satellite-coverage + walker-delta-constellation + ground-track-repeat + sun-synchronous-inclination + geostationary-station-keeping | coverage result |
+| 5. Environment | eclipse-time + orbital-perturbations + conjunction-assessment + radiation-debris + orbital-decay + three-body-libration | environment inputs |
+| 6. Rendezvous | clohessy-wiltshire | proximity solution |
+| 7. ADCS determination | attitude-determination-triad + attitude-determination-quest + star-tracker + sun-pointing + gyro-allan-variance | attitude knowledge |
+| 8. ADCS control | reaction-wheel-control + control-moment-gyro + magnetorquer-control + attitude-control-sizing + pointing-error-budget | ADCS solution + pointing |
+| 9. Power/thermal | power-thermal-budget + solar-array-sizing + spacecraft-battery-sizing + thermal-design | power/thermal budgets |
+| 10. Comms | communication-link-budget + antenna-aperture-sizing | link budget |
+| 11. Propulsion/C&DH | propellant-tank-sizing + command-data-handling | propulsion sizing, C&DH |
+| 12. ECSS context | ecss/systems-engineering + ecss/software-engineering + ecss/software-verification | process + software context |
+| 13. Report | (all above) | mission + subsystem reports |
+
+## Evidence gates
+
+- Stage 1 done = delta-v budget sums with margins; elements consistent
+  with the mission.
+- Stage 8 done = pointing error budget meets the requirement.
+- Stage 9 done = power budget closes with eclipse sizing; thermal
+  balance stated.
+- FINAL = every budget closes with a stated margin policy.
+
+## Boundary / forbidden
+
+- NEVER claim certification approval or declare launch readiness.
+- ECSS is referenced (TIER-2), never reproduced.
+- Subsystem performance assumes the stated models and margins.
+
+## Verification
+
+The role runs STANDALONE: `core/space_systems_core.py` is an executable
+engine that computes the orbit elements, delta-v budget (Hohmann and
+disposal legs), propellant mass (rocket equation), reaction wheel sizing
+(h = J*omega), pointing error budget, battery and solar array sizing,
+radiator area, and the comms link budget, then BUILDS the mission +
+subsystem design report and gate-checks deliverables. No AeroSkills
+checkout required.
+
+Run the role:
+```bash
+python3 cli.py build --out report.md                     # example mission
+python3 cli.py build --out leo550.md --altitude 550      # variant orbit
+python3 cli.py build --out heavy.md --dry-mass 400 --isp 250
+python3 cli.py check --file report.md                    # gate-check a report
+```
+
+Tests:
+- tests/test_space_systems_engineer_core.py (28 tests): domain rules
+  with AeroSkills leaf anchor values + report builder + gates +
+  standalone (no skills repo).
+- tests/test_role_space_systems_engineer.py: bound-skill resolution
+  (skips if the skills repo is absent) + workflow + template present +
+  boundaries.
+
+Bound skills in Aero Skills deepen individual stages when the library
+is present (kepler propagation, transfer trade-offs, pointing error
+refinement, detailed tank design); the core engine does not depend on
+them. The worked example in `templates/space-systems-template.md` is the
+generated output of the core for the example mission - REAL numbers, no
+blanks.
+
+## Compliance
+
+- ecss TIER-2 reference-only. References summary-not-copy.
+- SOURCES.md records standards referenced.