aero-agent-roles 1.0.0

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

@@ -0,0 +1,143 @@
+# Flight Test Plan and Envelope Expansion Report
+
+**Aircraft:** FT-1 Worked-Example Light Jet
+**Basis:** FAR/CS-25 context (worked example)
+**Status:** draft-for-review
+
+_Flight data below are SIMULATED for the worked example and must be replaced by recorded flight data._
+
+## 1. Objectives and configuration
+
+- Determine VS1g and the V-speed set (vref/v2/vr/VA) with warning-margin evidence in every configuration
+- Demonstrate freedom from flutter to V_D with damping >= 0.03 at the maximum test speed and an extrapolated margin >= 1.2*V_D
+- Expand the speed and load factor envelope in build-up blocks to V_D / n_max with a load factor check at every point
+- Verify stall recovery characteristics within the program limits
+- Measure climb performance and check the gradient requirement
+
+- Limit load factor: n_max = 2.5 g positive. Stall speeds (EAS): VS1g = 44.0 m/s (86 kt), VS1 = 40.0 m/s (78 kt), VS0 = 36.0 m/s (70 kt).
+- Placards (EAS): VFE = 62.0 m/s, VNO = 85.0 m/s, VNE = 94.0 m/s, V_D = 106.0 m/s, MMO = 0.78.
+- Derived: VA = 69.6 m/s (135 kt), vref = 46.8 m/s (91 kt), v2 = 48.0 m/s (93 kt), vr = 44.0 m/s (86 kt).
+- Crew: test pilot + flight test engineer console; airspace: restricted area; instrumentation: calibrated pitot-static, accelerometers, strain gauges on wing/elevator, flutter excitation vanes, telemetry with real-time damping.
+
+## 2. Safety
+
+| Hazard | Sev | Lik | Risk | High (>=15) | Mitigation |
+|---|---|---|---|---|---|
+| Flutter onset at high speed | 5 | 2 | 10 | no | GVT + build-up blocks, damping gate 0.03, excitation vanes, real-time monitoring |
+| Stall departure at aft CG | 4 | 3 | 12 | no | entry technique, altitude floor, recovery demonstration, spin chute installed |
+| Overspeed control upset | 4 | 2 | 8 | no | abort criteria at every block, test pilot briefing, VMO/VNE marking |
+| Engine failure during climb segment | 3 | 2 | 6 | no | single-engine drills, field/landing options, engine instruments monitored |
+| Telemetry data loss | 2 | 3 | 6 | no | onboard recording backup, link checked pre-flight |
+
+Every high-risk item is mitigated before the flight: true.
+
+| Go/no-go criterion | Value |
+|---|---|
+| weather | GO |
+| aircraft_ready | GO |
+| instrumentation_ok | GO |
+| safety_review_ok | GO |
+| airspace_ok | GO |
+
+Flight release: GO.
+
+## 3. Build-up plan
+
+Build-up order: GVT -> flutter build-up (blocks S1..S4) -> stall matrix -> load factor envelope -> climb performance. Each block clears before the next is flown; every block states its limit, abort criteria, and PASS/FAIL criteria.
+
+### 3.1 Flutter build-up (speed blocks as fractions of V_D)
+
+| Block | V_D fraction | Target (EAS) | Category | Abort | PASS/FAIL criteria |
+|---|---|---|---|---|---|
+| S1 | 0.85 | 90.1 m/s (175 kt) | vno-to-vne | immediate pull-up + throttle reduction if buffet, LCO, or control anomaly | PASS: damping >= 0.03 at point, no LCO, load factor within 2.5 g; FAIL otherwise |
+| S2 | 0.90 | 95.4 m/s (185 kt) | at-or-above-vne | immediate pull-up + throttle reduction if buffet, LCO, or control anomaly | PASS: damping >= 0.03 at point, no LCO, load factor within 2.5 g; FAIL otherwise |
+| S3 | 0.95 | 100.7 m/s (196 kt) | at-or-above-vne | immediate pull-up + throttle reduction if buffet, LCO, or control anomaly | PASS: damping >= 0.03 at point, no LCO, load factor within 2.5 g; FAIL otherwise |
+| S4 | 1.00 | 106.0 m/s (206 kt) | at-or-above-vne | immediate pull-up + throttle reduction if buffet, LCO, or control anomaly | PASS: damping >= 0.03 at point, no LCO, load factor within 2.5 g; FAIL otherwise |
+
+Required flutter demonstration speed: V_F = 127.2 m/s (1.2 x V_D). Damping >= 0.03 required at the maximum test speed; structural mode frequency separation >= 0.10 at every point.
+
+### 3.2 Altitude / Mach grid (V_D tested per altitude, ISA)
+
+| Altitude | Density ratio | Speed of sound | TAS at V_D | Mach at V_D | MMO | Limit |
+|---|---|---|---|---|---|---|
+| 0 ft | 1.000 | 340.3 m/s | 106.0 m/s | 0.311 | 0.78 | eas-limited |
+| 25000 ft | 0.448 | 309.7 m/s | 158.3 m/s | 0.511 | 0.78 | eas-limited |
+| 35000 ft | 0.310 | 296.5 m/s | 190.4 m/s | 0.642 | 0.78 | eas-limited |
+
+### 3.3 Stall matrix (VS1g and warning onset per configuration)
+
+| Config | Measured VS1g (EAS) | Warning required | Warning onset | Recovery limits |
+|---|---|---|---|---|
+| clean | 44.1 m/s | 46.3 m/s | 46.8 m/s | alt <= 30 m, pitch <= 8 deg, roll <= 20 deg |
+| takeoff (flaps) | 40.4 m/s | 42.4 m/s | 42.5 m/s | alt <= 30 m, pitch <= 8 deg, roll <= 20 deg |
+| landing (flaps/gear) | 36.3 m/s | 38.1 m/s | 38.2 m/s | alt <= 30 m, pitch <= 8 deg, roll <= 20 deg |
+
+### 3.4 Load factor envelope (pull blocks at VA or above)
+
+| Block | n_max fraction | Target n | PASS/FAIL |
+|---|---|---|---|
+| L1 | 0.50 | 1.25 g | PASS if n <= 2.5 g at point, with no buffet/LCO |
+| L2 | 0.75 | 1.88 g | PASS if n <= 2.5 g at point, with no buffet/LCO |
+| L3 | 1.00 | 2.50 g | PASS if n <= 2.5 g at point, with no buffet/LCO |
+
+### 3.5 Climb performance
+
+Sawtooth climb segments at constant indicated airspeed; gradient check against 2.4 % (two-engine context).
+
+## 4. Results
+
+### 4.1 Flutter build-up points
+
+| Block | Speed (EAS) | Damping | Min damping | Verdict |
+|---|---|---|---|---|
+| S1 | 90.1 m/s | 0.120 | 0.030 | PASS |
+| S2 | 95.4 m/s | 0.115 | 0.030 | PASS |
+| S3 | 100.7 m/s | 0.108 | 0.030 | PASS |
+| S4 | 106.0 m/s | 0.100 | 0.030 | PASS |
+
+Extrapolated flutter speed from the damping trend: 185.7 m/s; margin ratio 1.75 vs required 1.2 -> PASS.
+
+Structural mode frequency separation (GVT pairs):
+- mode pair 4.2 Hz / 11.6 Hz: separation 0.94 >= 0.10 -> PASS
+- mode pair 9.1 Hz / 14.8 Hz: separation 0.48 >= 0.10 -> PASS
+- mode pair 11.6 Hz / 14.8 Hz: separation 0.24 >= 0.10 -> PASS
+- mode pair 4.2 Hz / 9.1 Hz: separation 0.74 >= 0.10 -> PASS
+
+### 4.2 Stall results
+
+| Config | VS1g (EAS) | Warning onset | Warning margin | Recovery | Verdict |
+|---|---|---|---|---|---|
+| clean | 44.1 m/s | 46.8 m/s | +2.70 m/s | alt 18 m / pitch 3 deg / roll 6 deg | PASS |
+| takeoff (flaps) | 40.4 m/s | 42.5 m/s | +2.10 m/s | alt 21 m / pitch 4 deg / roll 8 deg | PASS |
+| landing (flaps/gear) | 36.3 m/s | 38.2 m/s | +1.90 m/s | alt 24 m / pitch 5 deg / roll 9 deg | PASS |
+
+### 4.3 Load factor envelope results
+
+| Block | Target n | Achieved n | Limit | Verdict |
+|---|---|---|---|---|
+| L1 | 1.25 g | 1.26 g | 2.5 g | PASS |
+| L2 | 1.88 g | 1.88 g | 2.5 g | PASS |
+| L3 | 2.50 g | 2.48 g | 2.5 g | PASS |
+
+### 4.4 Climb performance results
+
+- Rate of climb: 1450 ft/min (segment reduction, corrected to reference weight).
+- Gradient: 2.70 % vs 2.4 % required -> margin +0.30 % (PASS).
+
+## 5. Findings, limit changes, and recommendations
+
+| Envelope limit change | Traced to data point | Verdict |
+|---|---|---|
+| Speed envelope to 0.85 V_D | S1 | PASS |
+| Speed envelope to 0.90 V_D | S2 | PASS |
+| Speed envelope to 0.95 V_D | S3 | PASS |
+| Speed envelope to 1.00 V_D | S4 | PASS |
+
+Recommendations: (1) expand to the top block only after the damping and separation verdicts above; (2) repeat the configuration whose stall warning onset is marginal before envelope use; (3) confirm flutter clearance per point with the flight test conductor.
+
+## 6. Sign-off
+
+This plan/report states that the recorded data support expanding to the listed limits PENDING human flight test conductor review. It is a draft deliverable, not a clearance.
+
+---
+*Generated by Aero Agent Roles flight-test-engineer core (2026-09-05). DRAFT for human flight test conductor review. Not a clearance and not an approval of the envelope or of flight.*

package/roles/flight-test-engineer/tests/test_flight_test_engineer_core.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""Test flight_test_core: the executable engine of the flight-test-engineer role.
+
+Proves the role can DO its job standalone (no AeroSkills needed):
+V-speed margins, corner speed, stall warning/recovery rules, flutter
+build-up with the damping requirement and margin ratio, altitude/Mach
+grid, safety/go-no-go, deliverable generation, and evidence-gate checks.
+"""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "core"))
+from flight_test_core import (
+    MIN_DAMPING, MIN_FREQ_SEPARATION, accelerated_stall_speed,
+    build_flight_test_deliverable, check_flight_test_deliverable,
+    check_flight_test_markdown, classify_airspeed, corner_speed,
+    damping_margin, example_aircraft, example_deliverable_markdown,
+    example_flight_data, flutter_margin_ratio, flutter_required_speed,
+    flutter_speed_from_damping, frequency_separation, isa_density_ratio,
+    level_turn_load_factor, mach_grid_row, render_flight_test_markdown,
+    risk_index, speed_block_targets, stall_recovery_verdict,
+    stall_warning_required, stall_warning_verdict, v_speeds,
+)
+
+
+class TestDomainRules(unittest.TestCase):
+
+    def test_v_speed_factors(self):
+        ac = example_aircraft()
+        s = v_speeds(ac)
+        # vref = 1.3*vs0 = 46.8, v2 = 1.2*vs1 = 48.0, vr = 1.1*vs1 = 44.0
+        self.assertAlmostEqual(s["vref"], 46.8, places=3)
+        self.assertAlmostEqual(s["v2"], 48.0, places=3)
+        self.assertAlmostEqual(s["vr"], 44.0, places=3)
+
+    def test_corner_speed(self):
+        # VA = VS * sqrt(n_max): 44 * sqrt(2.5)
+        self.assertAlmostEqual(corner_speed(44.0, 2.5),
+                               44.0 * 2.5 ** 0.5, places=3)
+        with self.assertRaises(ValueError):
+            corner_speed(0, 2.5)
+        with self.assertRaises(ValueError):
+            corner_speed(44.0, 1.0)
+
+    def test_placard_ordering_validation(self):
+        ac = example_aircraft()
+        self.assertAlmostEqual(v_speeds(ac)["va"], corner_speed(44.0, 2.5))
+        ac.vne_eas_ms = 50.0  # breaks vfe < va < vno < vne < vd
+        with self.assertRaises(ValueError):
+            build_flight_test_deliverable(ac)
+
+    def test_airspeed_classification(self):
+        ac = example_aircraft()
+        va = v_speeds(ac)["va"]
+        self.assertEqual(classify_airspeed(60, ac.vfe_eas_ms, va,
+                                           ac.vno_eas_ms, ac.vne_eas_ms),
+                         "below-vfe")
+        self.assertEqual(classify_airspeed(90.1, ac.vfe_eas_ms, va,
+                                           ac.vno_eas_ms, ac.vne_eas_ms),
+                         "vno-to-vne")
+        self.assertEqual(classify_airspeed(95.4, ac.vfe_eas_ms, va,
+                                           ac.vno_eas_ms, ac.vne_eas_ms),
+                         "at-or-above-vne")
+
+    def test_stall_warning_margin(self):
+        # 1.05 * VS1g or VS1g + 3 kt, whichever is greater
+        req = stall_warning_required(44.0)
+        self.assertAlmostEqual(req, max(44.0 * 1.05, 44.0 + 3 * 0.514444),
+                               places=3)
+        self.assertTrue(stall_warning_verdict(44.0, req + 0.1)["ok"])
+        self.assertFalse(stall_warning_verdict(44.0, req - 0.1)["ok"])
+
+    def test_accelerated_stall_and_bank(self):
+        # 60 deg bank doubles load factor: stall rises ~41%
+        n60 = level_turn_load_factor(60.0)
+        self.assertAlmostEqual(n60, 2.0, places=4)
+        v = accelerated_stall_speed(44.0, n60)
+        self.assertAlmostEqual(v, 44.0 * 2.0 ** 0.5, places=3)
+        with self.assertRaises(ValueError):
+            accelerated_stall_speed(44.0, 0.9)
+
+    def test_stall_recovery_verdict(self):
+        ac = example_aircraft()
+        good = stall_recovery_verdict(ac, 18.0, 3.0, 6.0)
+        self.assertTrue(good["ok"])
+        bad = stall_recovery_verdict(ac, 18.0, 12.0, 6.0)  # pitch-up excess
+        self.assertFalse(bad["ok"])
+        self.assertFalse(bad["pitch_up_ok"])
+
+    def test_flutter_required_speed(self):
+        ac = example_aircraft()
+        self.assertAlmostEqual(flutter_required_speed(ac.vd_eas_ms),
+                               1.2 * 106.0, places=3)
+
+    def test_damping_margin_rule(self):
+        self.assertTrue(damping_margin(0.100)["pass"])
+        self.assertTrue(damping_margin(0.03)["pass"])  # boundary passes
+        self.assertFalse(damping_margin(0.02)["pass"])
+        self.assertEqual(MIN_DAMPING, 0.03)
+
+    def test_frequency_separation(self):
+        r = frequency_separation(11.6, 14.8)
+        self.assertAlmostEqual(r["separation"], 3.2 / 13.2, places=3)
+        self.assertTrue(r["pass"])
+        self.assertEqual(MIN_FREQ_SEPARATION, 0.10)
+
+    def test_flutter_extrapolation_and_margin(self):
+        # simulated damping trend over the block speeds
+        vf = flutter_speed_from_damping([90.1, 95.4, 100.7, 106.0],
+                                        [0.120, 0.115, 0.108, 0.100])
+        self.assertGreater(vf, 106.0 * 1.2)  # clears the 1.2 margin
+        m = flutter_margin_ratio(vf, 106.0)
+        self.assertTrue(m["pass"])
+        with self.assertRaises(ValueError):
+            flutter_speed_from_damping([90.1, 95.4], [0.1, 0.12])  # rising
+
+    def test_risk_index_high_threshold(self):
+        self.assertEqual(risk_index(5, 3), 15)     # high risk boundary
+        self.assertEqual(risk_index(5, 2), 10)     # mitigated in example
+        with self.assertRaises(ValueError):
+            risk_index(6, 1)
+        with self.assertRaises(ValueError):
+            risk_index(0, 1)
+
+    def test_mach_grid(self):
+        g0 = mach_grid_row(example_aircraft(), 0.0, 106.0)
+        self.assertAlmostEqual(g0["sigma"], 1.0, places=3)
+        self.assertLess(g0["mach"], g0["mmo"])     # EAS-limited at SL
+        # density ratio at 11000 m is the standard ~0.297 troposphere top
+        self.assertAlmostEqual(isa_density_ratio(11000.0), 0.29707,
+                               places=3)
+
+    def test_speed_blocks_equal_steps_to_limit(self):
+        blocks = speed_block_targets(106.0)
+        fracs = [b["fraction"] for b in blocks]
+        self.assertEqual(fracs, [0.85, 0.90, 0.95, 1.00])
+        self.assertAlmostEqual(blocks[-1]["target_eas_ms"], 106.0)
+        with self.assertRaises(ValueError):
+            speed_block_targets(106.0, (0.85, 0.95, 1.00))  # uneven steps
+
+
+class TestDeliverableBuilder(unittest.TestCase):
+
+    def test_example_model_complete(self):
+        model = build_flight_test_deliverable(example_aircraft())
+        self.assertEqual(model["document_type"],
+                         "Flight Test Plan and Envelope Expansion Report")
+        self.assertEqual(model["status"], "draft-for-review")
+        self.assertEqual(len(model["speed_blocks"]), 4)
+        self.assertEqual(len(model["flutter"]["points"]), 4)
+        self.assertEqual(len(model["stall_rows"]), 3)
+        self.assertEqual(len(model["n_blocks"]), 3)
+        self.assertTrue(model["flutter"]["pass"])
+        self.assertTrue(model["stall_all_ok"])
+        self.assertTrue(model["go_no_go"]["go"])
+        self.assertTrue(model["safety_no_unmitigated"])
+
+    def test_every_limit_change_traces_to_data_point(self):
+        model = build_flight_test_deliverable(example_aircraft())
+        for ch in model["limit_changes"]:
+            self.assertTrue(ch["data_point"])
+            self.assertTrue(ch["ok"])
+        # each change maps to a real block id
+        ids = {b["id"] for b in model["speed_blocks"]}
+        for ch in model["limit_changes"]:
+            self.assertIn(ch["data_point"], ids)
+
+    def test_markdown_has_all_sections(self):
+        md = example_deliverable_markdown()
+        for sec in ["## 1. Objectives", "## 2. Safety", "## 3. Build-up",
+                    "## 4. Results", "## 5. Findings", "## 6. Sign-off",
+                    "### 3.2 Altitude / Mach grid", "### 4.1 Flutter"]:
+            self.assertIn(sec, md)
+        self.assertIn("not a clearance", md.lower())
+        self.assertIn("draft", md.lower())
+
+    def test_core_gates_all_pass(self):
+        model = build_flight_test_deliverable(example_aircraft())
+        gates = check_flight_test_deliverable(model)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_markdown_gates_all_pass(self):
+        md = example_deliverable_markdown()
+        gates = check_flight_test_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_sign_off_gate_fails_when_status_changed(self):
+        model = build_flight_test_deliverable(example_aircraft())
+        model["status"] = "cleared"
+        gates = check_flight_test_deliverable(model)
+        self.assertFalse(gates["all_pass"])
+        self.assertFalse(gates["sign_off_honest"])
+
+    def test_markdown_gate_fails_without_clearance_marker(self):
+        md = example_deliverable_markdown()
+        import re
+        stripped = re.sub(r"(?i)not a clearance", "noted", md)
+        self.assertNotIn("not a clearance", stripped.lower())
+        gates = check_flight_test_markdown(stripped)
+        self.assertFalse(gates["all_pass"])
+        self.assertFalse(gates["has_not_clearance"])
+
+    def test_markdown_gate_fails_with_blank_placeholders(self):
+        md = example_deliverable_markdown().replace("clean", "___clean___")
+        gates = check_flight_test_markdown(md)
+        self.assertFalse(gates["no_blank_blanks"])
+
+    def test_standalone_no_skills_repo(self):
+        # Core must work with no AeroSkills present: set env to a bad path.
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = build_flight_test_deliverable(example_aircraft())
+        self.assertEqual(len(model["speed_blocks"]), 4)
+        md = render_flight_test_markdown(model)
+        self.assertGreater(len(md), 4000)
+        self.assertTrue(check_flight_test_markdown(md)["all_pass"])
+
+    def test_example_data_must_cover_blocks(self):
+        data = example_flight_data()
+        data["flutter_points"]["dampings"] = [0.1, 0.1, 0.1]
+        with self.assertRaises(ValueError):
+            build_flight_test_deliverable(example_aircraft(), data)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/flight-test-engineer/tests/test_role_flight_test_engineer.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""Role test: flight-test-engineer.
+
+Verifies (offline, no network):
+1. Every skill bound in ROLE.md frontmatter RESOLVES to a real leaf in
+   the aero-agent-skills repo (the pinned skills_release band).
+2. The workflow stage order is deterministic and complete.
+3. The deliverable template is a FILLED worked example: complete
+   sections, real numbers, no ___ blanks, DRAFT + not-a-clearance.
+4. The executable core + cli exist and pass their own gates standalone
+   (no AeroSkills checkout required).
+"""
+import os
+import re
+import sys
+import unittest
+
+ROLES_REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))
+AEROSKILLS = os.environ.get("AEROSKILLS_DEV", os.path.expanduser("~/AeroSkills"))
+HAS_SKILLS = os.path.isdir(os.path.join(AEROSKILLS, "skills"))
+ROLE_DIR = os.path.join(ROLES_REPO, "roles", "flight-test-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates", "flight-test-template.md")
+CORE = os.path.join(ROLE_DIR, "core", "flight_test_core.py")
+CLI = os.path.join(ROLE_DIR, "cli.py")
+
+EXPECTED_BOUND = [
+    "flight-test-operations/planning/flight-test-safety",
+    "flight-test-operations/envelope/envelope-expansion",
+    "flight-test-operations/envelope/v-speeds",
+    "flight-test-operations/envelope/load-factor-envelope",
+    "flight-test-operations/envelope/stall-characteristics-testing",
+    "flight-test-operations/envelope/high-angle-of-attack-testing",
+    "flight-test-operations/envelope/buffet-boundary-testing",
+    "flight-test-operations/envelope/spin-testing",
+    "flight-test-operations/envelope/icing-flight-test",
+    "flight-test-operations/envelope/vmc-determination",
+    "flight-test-operations/envelope/flight-loads-survey",
+    "flight-test-operations/envelope/structural-coupling-test",
+    "flight-test-operations/flutter/ground-vibration-testing",
+    "flight-test-operations/flutter/flight-vibration-survey",
+    "flight-test-operations/flutter/flutter-testing",
+    "flight-test-operations/flutter/limit-cycle-oscillation",
+    "flight-test-operations/performance/accelerate-stop-distance",
+    "flight-test-operations/performance/climb-performance-flight-test",
+    "flight-test-operations/performance/cruise-performance-flight-test",
+    "flight-test-operations/performance/engine-failure-takeoff-flight-test",
+    "flight-test-operations/performance/engine-flight-test"
+]
+
+STAGES = [
+    "1. Safety planning",
+    "2. Ground vibration",
+    "3. Flutter build-up",
+    "4. V-speeds",
+    "5. Envelope expansion",
+    "6. Stall/alpha",
+    "7. Buffet/loads",
+    "8. Spin/icing",
+    "9. Structural coupling",
+    "10. Performance",
+    "11. Report"
+]
+
+
+def role_text():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    return open(p).read() if os.path.exists(p) else None
+
+
+class TestFlightTestEngineerRole(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_how_to_run_present(self):
+        role = role_text()
+        self.assertIsNotNone(role)
+        for phrase in ["cli.py build", "cli.py check", "flight_test_core"]:
+            self.assertIn(phrase, role, f"missing run instruction: {phrase}")
+
+    def test_executable_core_and_cli_present(self):
+        self.assertTrue(os.path.exists(CORE), "core/flight_test_core.py missing")
+        self.assertTrue(os.path.exists(CLI), "cli.py missing")
+        # cli references the core engine
+        cli = open(CLI).read()
+        self.assertIn("flight_test_core", cli)
+
+    def test_core_runs_standalone(self):
+        # core must import and produce a passing model with no skills repo
+        old = os.environ.get("AEROSKILLS_DEV")
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        try:
+            sys.path.insert(0, os.path.join(ROLE_DIR, "core"))
+            import flight_test_core as core
+            model = core.build_flight_test_deliverable(core.example_aircraft())
+            self.assertTrue(core.check_flight_test_deliverable(model)["all_pass"])
+            md = core.render_flight_test_markdown(model)
+            self.assertTrue(core.check_flight_test_markdown(md)["all_pass"])
+        finally:
+            if old is None:
+                os.environ.pop("AEROSKILLS_DEV", None)
+            else:
+                os.environ["AEROSKILLS_DEV"] = old
+
+    def test_template_complete_no_blanks(self):
+        self.assertTrue(os.path.exists(TEMPLATE), "deliverable template missing")
+        text = open(TEMPLATE).read()
+        self.assertNotIn("___", text, "template still has blank placeholders")
+        # filled deliverable sections 1..6
+        for n in range(1, 7):
+            self.assertTrue(re.search(rf"^## {n}\. ", text, re.M),
+                            f"section {n} missing from template")
+        low = text.lower()
+        self.assertIn("not a clearance", low)
+        self.assertIn("draft", low)
+        self.assertIn("pass", low)
+        self.assertIn("fail", low)
+        # real numbers present (V-speeds, flutter margin, V_D)
+        self.assertIn("v_d", low)
+        self.assertTrue(re.search(r"\d+\.\d+", text))
+
+    def test_boundaries(self):
+        role = role_text()
+        self.assertIsNotNone(role)
+        low = role.lower()
+        for phrase in ["sign_off_required: true", "forbidden",
+                       "never clear an envelope", "not a clearance"]:
+            self.assertIn(phrase, low, 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()