aero-agent-roles 1.0.0

package/roles/engineering-analysis-engineer/templates/analysis-memo-template.md

@@ -0,0 +1,73 @@
+# Analysis Verification Memo
+
+**Chain:** Flight-test air-data chain at 3000 m
+**Status:** draft-for-review
+
+## 1. Scope and inputs
+
+Analysis question: verify the measurement/calculation chain Flight-test air-data chain at 3000 m - reduce the measured static pressure and temperature to air density and density altitude, check the repeated-measurement bias, verify the probe mounting tolerance stack and the atmosphere-model integrator, and state margins.
+- Analysis item: Flight-test air-data chain at 3000 m at geometric altitude 3000 m.
+- Inputs (measured, with 1-sigma standard uncertainties): static pressure p = 70050 Pa +/- 35 Pa; temperature T = 271 K +/- 1.2 K.
+- Inputs (geometry): 3-member probe mounting stack (see Section 5); position spec +/- 0.8 mm.
+- Inputs (acceptance): density accuracy spec +/- 1.5 %.
+- n=10 repeat readings of the static source error vs the reference pressure standard.
+
+## 2. Unit/atmosphere basis
+
+- Unit system: SI (Pa, K, kg/m3, m, mm). No unit conversions required in the chain; conversions applied for reporting: altitude 3000 m = 9842.5 ft; T 268.65 K = -4.5 degC.
+- Atmosphere basis: ISA (ISO 2533 / ICAO Doc 7488) reference model, sea level 288.15 K / 101325.0 Pa / 1.225 kg/m3, lapse rate 6.5 K/km to 11 km.
+- ISA reference values at 3000 m: T_ISA = 268.65 K, p_ISA = 70108 Pa, rho_ISA = 0.90913 kg/m3.
+
+## 3. Method and verification
+
+- Density from measured state: ideal gas EOS rho = p / (R T), R = 287.05 J/(kg K) (bound leaf: isa-atmosphere).
+- Uncertainty: GUM (JCGM 100) first-order law with analytic sensitivities, combined standard uncertainty u_c = sqrt(sum((df/dx_i * u_i)^2)) and expanded U = k * u_c with k = 2 (~95 %) (bound leaf: uncertainty-propagation).
+- Bias statistics: Student t interval for the mean of the repeat readings (bound leaf: confidence-interval-estimation).
+- Density altitude: Newton inversion of rho_ISA(h) = rho_measured, converged in 3 iterations to residual 4.16e-10 (bound leaf: root-finding; convergence evidence per leaf convergence-verification).
+- Numerical verification: three-grid trapezoid integration of the hydrostatic balance dp/dz = -rho g over 0..3000 m at 6, 12 and 24 steps (refinement ratio r = 2); Richardson extrapolation and grid convergence index (GCI) versus the closed-form ISA pressure.
+- Numerical accuracy statement: see grid study below; the integrator is grid-converged and agrees with the closed-form ISA pressure at the test point.
+
+## 4. Results
+
+- Air density (measured chain): rho = 0.90049 kg/m3.
+- Sensitivities: d rho/dp = 1.2855e-05 (kg/m3)/Pa, d rho/dT = -0.0033229 (kg/m3)/K.
+- Combined standard uncertainty: u_c = 0.0040127 kg/m3 (0.44561 % of rho).
+- Expanded uncertainty: U = 0.0080255 kg/m3 (k = 2). Result: rho = 0.90049 +/- 0.0080255 kg/m3.
+- Uncertainty budget: 98.7% from temperature (s = -3.323e-03, u = 1.2); 1.3% from static pressure (s = 1.286e-05, u = 35).
+- Versus ISA at 3000 m: delta = -0.94955 % (non-standard day).
+- Density altitude: h_rho = 3092.6 m (+92.551 m above the geometric test point).
+- Bias statistics (n=10 repeat readings of the static source error vs the reference pressure standard): mean bias 0.59 Pa, sample s = 1.907 Pa, 95 % t-interval [-0.77417, 1.9542] Pa (t = 2.2622, df = 9). Zero lies inside the interval: no statistically significant static-source bias at the 95 % level.
+
+## 5. Tolerances
+
+- GD&T basis: ASME Y14.5 (TIER-2 reference-only). The stack is a 1-D linear dimension chain with equal bilateral tolerances and independent, centered parts (bound leaf: tolerance-stackup).
+- Chain members (signed nominal direction, tolerance, RSS share):
+  - mounting bracket: 120 mm (dir +), +/- 0.5 mm, 52.9 % share
+  - adapter: 45 mm (dir +), +/- 0.25 mm, 13.2 % share
+  - probe inset: 60 mm (dir -), +/- 0.4 mm, 33.9 % share
+- Nominal total: 105 mm.
+- Worst case: +/- 1.15 mm -> limits [103.85, 106.15] mm.
+- RSS: +/- 0.68739 mm -> limits [104.31, 105.69] mm.
+- Dominant contributor: mounting bracket (52.9 % of RSS variance); tightening it reduces the stack most.
+
+## 6. Data sources
+
+- ISA model and constants: ISO 2533 / ICAO Doc 7488 standard atmosphere (public standard; summary-only use).
+- Uncertainty method: GUM, JCGM 100:2008 (public guide; summary-only use).
+- GD&T conventions: ASME Y14.5 (TIER-2 reference-only; summary-not-copy per SOURCES.md).
+- Export-control classification: uncontrolled technical data (example). No controlled data is included in this memo.
+
+## 7. Margins and conclusions
+
+- Margins per the engineering-margins convention MS = allowable / applied - 1 (same units both sides).
+- Density accuracy: applied (expanded) = 0.89123 %, allowable +/- 1.5 % -> MS = 0.68307 (PASS).
+- Probe position stack, RSS basis: applied +/- 0.68739 mm, allowable +/- 0.8 mm -> MS = 0.16383 (PASS).
+- Probe position stack, worst-case basis: applied +/- 1.15 mm, allowable +/- 0.8 mm -> MS = -0.30435 (FAIL).
+- Conclusions: the chain is unit-consistent with the stated ISA basis; the expanded density uncertainty is driven by the temperature input (99 % of variance); repeated-measurement bias is not significant; the atmosphere integrator is monotone-converged (order 2), GCI 0.0005462 % at the test point, and agrees with the closed-form ISA pressure. The stack meets the position spec on the RSS basis but not on the worst-case basis: the RSS basis is valid only while the parts remain independent and centered (process-capability evidence required).
+
+## 8. Open items
+
+- For the design owner / human approver: confirm the density accuracy spec and the position spec limits used as allowables; decide worst-case vs RSS basis for the probe stack (tighten the dominant contributor mounting bracket if worst case must be met); confirm export-control classification before external release.
+
+---
+*Generated by Aero Agent Roles engineering-analysis-engineer core. DRAFT for human engineering review. Not an approval document.*

package/roles/engineering-analysis-engineer/tests/test_engineering_analysis_engineer_core.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+"""Test engineering_analysis_engineer_core: the executable engine of the
+Engineering Analysis and Data Engineer role.
+
+Proves the role can DO its job standalone (no AeroSkills needed): ISA
+reference values, GUM uncertainty propagation, t confidence intervals,
+tolerance stack-up (worst case + RSS), Richardson/GCI convergence
+verification, engineering margins, memo generation, evidence gates, and
+the filled deliverable template.
+"""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "core"))
+from engineering_analysis_engineer_core import (  # noqa: E402
+    ISA_G, ISA_LAPSE, ISA_P0, ISA_R, ISA_T0, StackMember,
+    check_memo, check_memo_markdown, combined_standard_uncertainty,
+    confidence_interval_mean, convergence_verdict, density_altitude_m,
+    density_from_measured, example_chain, example_memo_markdown,
+    expanded_uncertainty, grid_convergence_index, isa_density_kgm3,
+    isa_pressure_pa, isa_reference_values, isa_temperature_k,
+    margin_of_safety, margin_verdict, nominal_total, observed_order,
+    render_memo_markdown, richardson_extrapolation, rss_shares, rss_total,
+    t_ppf_two_sided, uncertainty_contributions, worst_case_total,
+    build_memo, trapezoid_hydrostatic_pressure,
+)
+
+# 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")
+
+ROLE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+TEMPLATE = os.path.join(ROLE_DIR, "templates", "analysis-memo-template.md")
+
+
+class TestIsaAtmosphere(unittest.TestCase):
+
+    def test_sea_level_values(self):
+        self.assertAlmostEqual(isa_temperature_k(0), ISA_T0, places=9)
+        self.assertAlmostEqual(isa_pressure_pa(0), ISA_P0, places=6)
+        rho0 = ISA_P0 / (ISA_R * ISA_T0)
+        self.assertAlmostEqual(isa_density_kgm3(0), rho0, places=9)
+        self.assertAlmostEqual(rho0, 1.225, places=3)
+
+    def test_tropopause(self):
+        self.assertAlmostEqual(isa_temperature_k(11000), 216.65, places=9)
+        self.assertAlmostEqual(isa_temperature_k(15000), 216.65, places=9)
+
+    def test_known_troposphere_point(self):
+        # 3000 m: T = 288.15 - 0.0065*3000 = 268.65 K
+        self.assertAlmostEqual(isa_temperature_k(3000), 268.65, places=9)
+        p3 = isa_pressure_pa(3000)
+        t3 = isa_temperature_k(3000)
+        self.assertAlmostEqual(isa_density_kgm3(3000),
+                               p3 / (ISA_R * t3), places=12)
+        self.assertGreater(isa_pressure_pa(1000), isa_pressure_pa(3000))
+
+    def test_pressure_monotonic_and_reference_dict(self):
+        vals = [isa_reference_values(h) for h in (0, 3000, 11000)]
+        ps = [v["pressure_pa"] for v in vals]
+        self.assertEqual(ps, sorted(ps, reverse=True))
+        self.assertEqual(set(vals[0]), {"altitude_m", "temperature_k",
+                                        "pressure_pa", "density_kgm3"})
+
+    def test_out_of_range_raises(self):
+        for h in (-1, 21000):
+            with self.assertRaises(ValueError):
+                isa_temperature_k(h)
+            with self.assertRaises(ValueError):
+                isa_pressure_pa(h)
+
+    def test_density_from_measured(self):
+        # Ideal gas EOS rho = p / (R T)
+        self.assertAlmostEqual(density_from_measured(101325, 288.15),
+                               101325 / (ISA_R * 288.15), places=12)
+
+
+class TestUncertaintyPropagation(unittest.TestCase):
+
+    def test_combined_standard(self):
+        # u_c = sqrt((2*0.5)^2 + (3*1)^2) = sqrt(1 + 9) = sqrt(10)
+        self.assertAlmostEqual(combined_standard_uncertainty([2, 3],
+                                                             [0.5, 1.0]),
+                               (10.0) ** 0.5, places=12)
+        # single input: u_c = s*u
+        self.assertAlmostEqual(combined_standard_uncertainty([4], [0.25]),
+                               1.0, places=12)
+
+    def test_expanded(self):
+        self.assertAlmostEqual(expanded_uncertainty(2.0), 4.0, places=12)
+        self.assertAlmostEqual(expanded_uncertainty(2.0, k=3), 6.0, places=12)
+        with self.assertRaises(ValueError):
+            expanded_uncertainty(1.0, k=0)
+
+    def test_contributions_and_shares(self):
+        contribs = uncertainty_contributions([2, 3], [0.5, 1.0])
+        self.assertAlmostEqual(sum(c["percent"] for c in contribs), 100.0,
+                               places=9)
+        self.assertEqual(contribs[0]["index"], 1)  # dominant first
+        # invalid inputs
+        with self.assertRaises(ValueError):
+            combined_standard_uncertainty([1], [1, 2])
+        with self.assertRaises(ValueError):
+            combined_standard_uncertainty([1], [-1])
+
+    def test_example_density_chain_uncertainty(self):
+        # Example: p = 70050 +/- 35 Pa, T = 271 +/- 1.2 K, rho = p/(R T)
+        chain = example_chain()
+        t = chain.temperature_k
+        sens_p = 1.0 / (ISA_R * t)
+        sens_t = -chain.pressure_pa / (ISA_R * t * t)
+        uc = combined_standard_uncertainty([sens_p, sens_t],
+                                           [chain.pressure_unc_pa,
+                                            chain.temperature_unc_k])
+        U = expanded_uncertainty(uc, chain.coverage_factor)
+        rho = density_from_measured(chain.pressure_pa, t)
+        # temperature dominates the budget (~99%)
+        contribs = uncertainty_contributions([sens_p, sens_t],
+                                             [chain.pressure_unc_pa,
+                                              chain.temperature_unc_k])
+        self.assertAlmostEqual(uc, 0.0040127, places=6)
+        self.assertAlmostEqual(U, 2 * uc, places=12)
+        self.assertGreater(contribs[0]["percent"], 90.0)
+        self.assertAlmostEqual(rho, 0.900495, places=5)
+
+
+class TestConfidenceInterval(unittest.TestCase):
+
+    def test_t_quantile_known_values(self):
+        self.assertAlmostEqual(t_ppf_two_sided(0.95, 9), 2.262157, places=4)
+        self.assertAlmostEqual(t_ppf_two_sided(0.95, 4), 2.776445, places=4)
+        self.assertAlmostEqual(t_ppf_two_sided(0.99, 10), 3.169273, places=4)
+        with self.assertRaises(ValueError):
+            t_ppf_two_sided(0.0, 5)
+        with self.assertRaises(ValueError):
+            t_ppf_two_sided(0.95, 0.5)
+
+    def test_confidence_interval_mean(self):
+        x = [1.8, -2.2, 3.1, -0.7, 2.4, -1.5, 0.9, 2.8, -1.1, 0.4]
+        ci = confidence_interval_mean(x)
+        mean = sum(x) / len(x)
+        self.assertAlmostEqual(ci["mean"], mean, places=12)
+        self.assertEqual(ci["n"], 10)
+        self.assertEqual(ci["df"], 9.0)
+        self.assertLess(ci["lower"], mean)
+        self.assertGreater(ci["upper"], mean)
+        # 95% of the interval width comes from t * s / sqrt(n)
+        import math
+        s = math.sqrt(sum((v - mean) ** 2 for v in x) / 9.0)
+        self.assertAlmostEqual(ci["se"], s / math.sqrt(10), places=12)
+        self.assertAlmostEqual(ci["t_quantile"], 2.262157, places=4)
+
+    def test_degenerate_constant_sample(self):
+        ci = confidence_interval_mean([5.0, 5.0, 5.0])
+        self.assertEqual(ci["lower"], ci["upper"])
+
+    def test_short_sample_raises(self):
+        with self.assertRaises(ValueError):
+            confidence_interval_mean([1.0])
+
+
+class TestToleranceStackup(unittest.TestCase):
+
+    def _stack(self):
+        return [StackMember("bracket", 120.0, 0.50, +1),
+                StackMember("adapter", 45.0, 0.25, +1),
+                StackMember("probe inset", 60.0, 0.40, -1)]
+
+    def test_nominal_total(self):
+        self.assertAlmostEqual(nominal_total(self._stack()), 105.0, places=9)
+
+    def test_worst_case_total(self):
+        self.assertAlmostEqual(worst_case_total(self._stack()), 1.15,
+                               places=9)
+
+    def test_rss_total(self):
+        # sqrt(0.5^2 + 0.25^2 + 0.4^2)
+        self.assertAlmostEqual(rss_total(self._stack()),
+                               (0.25 + 0.0625 + 0.16) ** 0.5, places=9)
+        # RSS never exceeds worst case
+        self.assertLessEqual(rss_total(self._stack()),
+                             worst_case_total(self._stack()))
+
+    def test_rss_shares(self):
+        shares = rss_shares(self._stack())
+        self.assertAlmostEqual(sum(shares), 100.0, places=9)
+        self.assertGreater(shares[0], shares[1])  # bracket dominant
+        self.assertAlmostEqual(shares[0], 52.910, places=2)
+
+    def test_empty_raises(self):
+        with self.assertRaises(ValueError):
+            nominal_total([])
+        with self.assertRaises(ValueError):
+            worst_case_total([])
+        with self.assertRaises(ValueError):
+            rss_total([])
+
+
+class TestConvergenceVerification(unittest.TestCase):
+
+    def test_observed_order_monotone(self):
+        # r = 2, ratio (f3-f2)/(f2-f1) = 4 -> order exactly 2
+        self.assertAlmostEqual(observed_order(1.000, 1.010, 1.050, 2.0),
+                               2.0, places=9)
+
+    def test_richardson_and_gci(self):
+        f1, f2, r, p = 70107.96199725207, 70107.04297140652, 2.0, 2.0
+        fex = richardson_extrapolation(f1, f2, r, p)
+        gci = grid_convergence_index(f1, f2, r, p)
+        # extrapolated value recovers the closed-form ISA pressure at 3000 m
+        closed = isa_pressure_pa(3000)
+        self.assertAlmostEqual(fex, closed, delta=1e-4)
+        self.assertAlmostEqual(gci, 5.462e-6, places=8)
+
+    def test_verdict_monotone(self):
+        v = convergence_verdict(1.000, 1.010, 1.050, 2.0)
+        self.assertEqual(v["verdict"], "monotone converged")
+        self.assertAlmostEqual(v["order"], 2.0, places=9)
+        self.assertIsNotNone(v["extrapolated"])
+        self.assertIsNotNone(v["gci"])
+
+    def test_verdict_oscillatory_and_diverging(self):
+        # oscillatory: (f3-f2)/(f2-f1) in (-1, 0)
+        v = convergence_verdict(1.0, 1.1, 1.05, 2.0)
+        self.assertEqual(v["verdict"], "oscillatory")
+        self.assertIsNone(v["order"])
+        # diverging: |ratio| > 1 on the negative branch
+        v = convergence_verdict(1.0, 1.1, 0.6, 2.0)
+        self.assertEqual(v["verdict"], "diverging")
+
+    def test_trapezoid_hydrostatic_agrees_with_closed_form(self):
+        # fine-grid integration must approach the closed-form ISA pressure
+        exact = isa_pressure_pa(3000)
+        fine = trapezoid_hydrostatic_pressure(3000, 24)
+        coarse = trapezoid_hydrostatic_pressure(3000, 6)
+        self.assertLess(abs(fine - exact), abs(coarse - exact))
+        self.assertLess(abs(fine - exact) / exact, 1e-4)
+
+
+class TestDensityAltitudeRootFinding(unittest.TestCase):
+
+    def test_inversion_round_trip(self):
+        # rho_ISA at 3000 m must invert back to ~3000 m
+        rho3 = isa_density_kgm3(3000)
+        res = density_altitude_m(rho3, h0=2800)
+        self.assertTrue(res["converged"])
+        self.assertAlmostEqual(res["altitude_m"], 3000.0, delta=1e-3)
+
+    def test_warm_day_density_altitude(self):
+        # measured density below ISA at 3000 m -> density altitude above it
+        chain = example_chain()
+        rho_m = density_from_measured(chain.pressure_pa, chain.temperature_k)
+        res = density_altitude_m(rho_m, h0=3000)
+        self.assertGreater(res["altitude_m"], 3000.0)
+        self.assertAlmostEqual(res["altitude_m"], 3092.55, delta=0.5)
+
+
+class TestMargins(unittest.TestCase):
+
+    def test_margin_of_safety(self):
+        self.assertAlmostEqual(margin_of_safety(125000, 100000), 0.25,
+                               places=12)
+        self.assertAlmostEqual(margin_of_safety(90000, 100000), -0.1,
+                               places=12)
+
+    def test_margin_verdict(self):
+        self.assertEqual(margin_verdict(0.25), "PASS")
+        self.assertEqual(margin_verdict(-0.1), "FAIL")
+        self.assertEqual(margin_verdict(0.0), "PASS")
+
+
+class TestMemoBuilder(unittest.TestCase):
+
+    def test_example_model_numbers(self):
+        model = build_memo(example_chain())
+        self.assertEqual(model["document_type"], "Analysis Verification Memo")
+        self.assertEqual(model["status"], "draft-for-review")
+        self.assertAlmostEqual(model["density_kgm3"], 0.900495, places=5)
+        self.assertAlmostEqual(model["u_c"], 0.0040127, places=6)
+        self.assertAlmostEqual(model["expanded_U"], 0.0080255, places=6)
+        # ISA values at the test altitude
+        self.assertAlmostEqual(model["isa"]["temperature_k"], 268.65,
+                               places=9)
+        self.assertAlmostEqual(model["isa"]["pressure_pa"],
+                               isa_pressure_pa(3000), places=6)
+        # stack numbers
+        st = model["stack"]
+        self.assertAlmostEqual(st["nominal_mm"], 105.0, places=6)
+        self.assertAlmostEqual(st["worst_case_mm"], 1.15, places=6)
+        self.assertAlmostEqual(st["rss_mm"], 0.687386, places=5)
+        self.assertEqual(st["dominant"], "mounting bracket")
+        # margins
+        self.assertAlmostEqual(model["ms_density"], 0.68307, places=4)
+        self.assertAlmostEqual(st["ms_rss"], 0.16383, places=4)
+        self.assertAlmostEqual(st["ms_wc"], -0.30435, places=4)
+        # convergence
+        cv = model["convergence"]
+        self.assertEqual(cv["verdict"], "monotone converged")
+        self.assertAlmostEqual(cv["order"], 2.0, delta=0.01)
+        self.assertLess(cv["gci"], 0.001)
+        # bias CI contains the mean and zero
+        ci = model["bias_ci"]
+        self.assertAlmostEqual(ci["mean"], 0.59, places=9)
+        self.assertLess(ci["lower"], 0.0)
+        self.assertGreater(ci["upper"], 0.0)
+
+    def test_custom_altitude(self):
+        chain = example_chain()
+        chain.altitude_m = 6000.0
+        model = build_memo(chain)
+        self.assertAlmostEqual(model["isa"]["temperature_k"],
+                               isa_temperature_k(6000), places=9)
+        self.assertAlmostEqual(model["altitude_m"], 6000.0, places=9)
+
+    def test_model_gates_all_pass(self):
+        model = build_memo(example_chain())
+        gates = check_memo(model)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_markdown_gates_all_pass(self):
+        md = example_memo_markdown()
+        gates = check_memo_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_render_contains_required_sections(self):
+        md = example_memo_markdown()
+        for sec in ["## 1. Scope and inputs", "## 2. Unit/atmosphere basis",
+                    "## 3. Method and verification", "## 4. Results",
+                    "## 5. Tolerances", "## 6. Data sources",
+                    "## 7. Margins and conclusions", "## 8. Open items"]:
+            self.assertIn(sec, md)
+        self.assertIn("not an approval", md.lower())
+
+    def test_gate_failures_are_caught(self):
+        model = build_memo(example_chain())
+        model["status"] = "approved"          # dishonest sign-off
+        self.assertFalse(check_memo(model)["sign_off_honest"])
+        model2 = build_memo(example_chain())
+        model2["isa"]["pressure_pa"] = 1.0    # ISA values not real
+        self.assertFalse(check_memo(model2)["isa_values_real"])
+        model3 = build_memo(example_chain())
+        model3["u_c"] = 0.0                   # uncertainty not real
+        self.assertFalse(check_memo(model3)["uncertainty_valid"])
+        bad_md = "# nothing here"
+        self.assertFalse(check_memo_markdown(bad_md)["all_pass"])
+
+    def test_standalone_no_skills_repo(self):
+        # Core must work with no AeroSkills present.
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = build_memo(example_chain())
+        self.assertGreater(model["density_kgm3"], 0.1)
+        md = render_memo_markdown(model)
+        self.assertGreater(len(md), 3000)
+
+    def test_template_is_the_filled_example(self):
+        # ROLE-STANDARD: the template IS the example deliverable generated
+        # by the core - byte-identical, zero blanks.
+        self.assertTrue(os.path.exists(TEMPLATE))
+        template = open(TEMPLATE).read()
+        self.assertNotIn("___", template)
+        self.assertEqual(template, example_memo_markdown())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/engineering-analysis-engineer/tests/test_role_engineering_analysis_engineer.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""Role test: engineering-analysis-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", "engineering-analysis-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates", "analysis-memo-template.md")
+
+EXPECTED_BOUND = [
+    "cross-cutting/units-atmos/isa-atmosphere",
+    "cross-cutting/units-atmos/density-altitude",
+    "cross-cutting/units-atmos/airspeed-conversion",
+    "cross-cutting/units-atmos/unit-conversion",
+    "cross-cutting/units-atmos/dimensional-analysis",
+    "cross-cutting/units-atmos/temperature-conversion",
+    "cross-cutting/numerics/finite-difference-derivatives",
+    "cross-cutting/numerics/numerical-integration",
+    "cross-cutting/numerics/ode-solvers",
+    "cross-cutting/numerics/root-finding",
+    "cross-cutting/numerics/interpolation",
+    "cross-cutting/numerics/least-squares-regression",
+    "cross-cutting/numerics/optimization-algorithms",
+    "cross-cutting/numerics/eigenvalue-decomposition",
+    "cross-cutting/numerics/singular-value-decomposition",
+    "cross-cutting/numerics/matrix-operations",
+    "cross-cutting/numerics/complex-number-algebra",
+    "cross-cutting/numerics/quaternion-algebra",
+    "cross-cutting/numerics/fast-fourier-transform",
+    "cross-cutting/numerics/fir-filter-design",
+    "cross-cutting/numerics/digital-filter-design",
+    "cross-cutting/numerics/power-spectral-density",
+    "cross-cutting/numerics/uncertainty-propagation",
+    "cross-cutting/numerics/monte-carlo-sampling",
+    "cross-cutting/numerics/probability-distributions",
+    "cross-cutting/numerics/confidence-interval-estimation",
+    "cross-cutting/numerics/hypothesis-testing",
+    "cross-cutting/numerics/descriptive-statistics",
+    "cross-cutting/numerics/cross-correlation-analysis",
+    "cross-cutting/numerics/information-entropy",
+    "cross-cutting/numerics/convergence-verification",
+    "cross-cutting/numerics/grubbs-outlier-test",
+    "cross-cutting/numerics/runs-test",
+    "cross-cutting/numerics/rank-based-hypothesis-testing",
+    "cross-cutting/tolerancing/gdandt-basics",
+    "cross-cutting/tolerancing/datum-reference-frames",
+    "cross-cutting/tolerancing/position-tolerance-calc",
+    "cross-cutting/tolerancing/tolerance-stackup",
+    "cross-cutting/documentation/engineering-report",
+    "cross-cutting/documentation/engineering-margins",
+    "cross-cutting/data-sources/aeronautical-data-sources",
+    "cross-cutting/export-control/export-control-awareness"
+]
+
+STAGES = [
+    "1. Unit/atmosphere",
+          "2. Numerics",
+          "3. Regression/opt",
+          "4. Linear algebra",
+          "5. Signal",
+          "6. Uncertainty",
+          "7. Statistics",
+          "8. Convergence",
+          "9. Tolerancing",
+          "10. Data sourcing",
+          "11. Export control",
+          "12. Report"
+]
+
+
+def role_text():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    return open(p).read() if os.path.exists(p) else None
+
+
+class TestEngineeringAnalysisEngineerRole(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()