aero-agent-roles 1.0.0

package/roles/structures-loads-engineer/templates/loads-strength-report-template.md

@@ -0,0 +1,96 @@
+# Loads and Strength Report
+
+**Item:** Example regional transport wing
+**Aircraft:** Example 100,000 lb regional transport (FAR 25)
+**Category / basis:** transport category, FAR 25 (Subpart C loads, Subpart D structure)
+**Status:** draft-for-review
+
+## 1. Loads
+
+- Wing loading W/S = 100.000 psf, mean geometric chord cbar = 11.180 ft (cbar = S/b), lift-curve slope a = 5.700/rad.
+- Design speeds (EAS): VS = 230.000 ft/s, VA = 363.662 ft/s, VB = 414.000 ft/s, VC = 460.000 ft/s, VD = 621.000 ft/s.
+- Gust alleviation (FAR 25.341(b)(2)): mass ratio mu_g = 41.020, alleviation factor K_g = 0.779.
+- Limit maneuvering load factor at VA = 2.500 (transport category, FAR 25.337); negative limit -1.000 at speeds up to VC.
+- Discrete-gust limit load factors (design gust velocities U_de of FAR 25.341(a) at sea level, fps EAS):
+
+  - VB (414.000 ft/s, U_de = 66.000 fps): n = 2.443 (positive), -0.443 (negative).
+  - VC (460.000 ft/s, U_de = 50.000 fps): n = 2.215 (positive), -0.215 (negative).
+  - VD (621.000 ft/s, U_de = 25.000 fps): n = 1.820 (positive), 0.180 (negative).
+
+- Gust line vs maneuver envelope at VB/VC/VD: VB margin -0.215 (gust-critical); VC margin -0.416 (gust-critical); VD margin +1.000 (maneuver envelope governs).
+
+- **Design limit condition: maneuver at VA, n_limit = +2.500** (negative envelope limit -1.000).
+- **Ultimate loads: n_ult = 1.5 x 2.500 = 3.750 (factor of safety, FAR 25.303).**
+
+- Root loads per wing at the design condition (elliptic span-load idealization: root shear = nW/2 and root bending M = nWb/(3 pi), the semi-ellipse lift resultant standing at 4/(3 pi) of the semi-span from the root):
+  - Limit root bending moment = 28.47 M in-lb; ultimate root bending M_ult = 42.70 M in-lb (3.56 M ft-lb).
+  - Ultimate root shear V_ult = 188 klb per wing.
+
+- Ground loads - level landing at the limit vertical inertia factor 2.500 (bound landing-ground-loads leaf):
+  - Nose gear reaction 62 klb; main gear reaction 188 klb (total 250 klb).
+  - Braked-roll deceleration 0.60 g (braking friction 0.8 on the main gear).
+- Spectra: fatigue and dynamic load spectra feed the fatigue screening (Section 6); random-vibration / shock-response-spectrum conditions for equipment-mounted structure are derived with the bound random-vibration-analysis / shock-response-spectrum leaves when that structure is in scope.
+
+## 2. Global model
+
+- Idealization: each wing is a cantilever box beam from the root to the tip carrying the elliptic spanwise lift distribution l(y) = l0 sqrt(1 - (2y/b)^2); root shear and bending then follow in closed form (above), which is sufficient for the screening margins of this report. A refined beam-frame/truss/CalculiX model (bound FEM leaves) confirms station-by-station internal loads and deflections in the detailed phase.
+- Boundary conditions: wing root fixed at the fuselage side of body; box depth h = 40.000 in between spar cap centroids at the root section (example geometry).
+- Internal loads at the root: M_ult = 42.70 M in-lb, V_ult = 188 klb - used for every margin below.
+
+## 3. Strength/stability margins (ultimate load)
+
+| Component | Load | Allowable | MS | Basis |
+|---|---|---|---|---|
+| Lower spar cap (tension, root) | P = M_ult/h = 1067611 lb | Ftu = 83.0 ksi | **+0.360** | boom couple at box depth 40 in; 7075-T6 Ftu per bound materials/lug leaf anchors (MMPDS B-basis to confirm) |
+| Upper spar cap (compression, root) | P = M_ult/h = 1067611 lb | Fcy = 73.0 ksi | **+0.196** | compression material limit (yield); local stability of the stiffened panel carried by the skin/stringer rows |
+| Spar web (shear, two webs) | V_ult = 187500 lb | Fsu = 48.0 ksi | **+0.557** | V_ult/(2 t h_web); 7075-T6 Fsu per bound lug leaf anchor (MMPDS to confirm) |
+| Upper skin panel (compression buckling, between stringers) | sigma_app = 61.0 ksi | sigma_cr = 66.7 ksi (k=4, ssss long plate) | **+0.093** | plate buckling sigma_cr = k pi^2 E/(12(1-nu^2)) (t/b)^2 with b = stringer pitch 6.0 in, t = 0.25 in (bound plate-buckling leaf) |
+| Upper stringer (column over rib pitch) | P_app = 73208 lb | Fcy*A = 87545 lb (yield-governed column) | **+0.196** | short column: lambda = 31.1 < lambda_1 = 37.5, yield governs (bound buckling leaf) |
+| Wing root lug (vertical shear, one lug of pair) | P = V_ult/2 = 93750 lb | min over bearing Fbru, net-tension Ftu, tearout Fsu; governing mode tearout | **+2.259** | round-end lug: bearing, net section, tearout margins per bound lug-joint leaf (e/D = 1.50, D/t = 4.00) |
+
+## 4. Dynamics
+
+- First wing bending frequency f1 = 2.135 Hz (uniform cantilever idealization over the semi-span with the root box stiffness EI, wing weight fraction applied; beta1*L = 1.875, bound beam-vibration leaf).
+- Frequency placement vs rotor/propeller 1P and control-surface excitation bands is confirmed against the bound modal-analysis / beam-vibration leaves in the detailed phase.
+
+## 5. Materials
+
+- Allowables used: 7075-T6 screening values from the bound AeroSkills anchors (material-selection leaf E/Fty/UTS, lug-joint worked example Fsu/Fbru, strain-life 7075-T6 class fatigue constants). MMPDS (licensed) is referenced, never reproduced; B-basis design allowables are confirmed by the materials group before release:
+  - E = 10400 ksi; Ftu = 83.0 ksi; Fty = 73.0 ksi; Fsu = 48.0 ksi; Fbru = 152.3 ksi.
+- Ramberg-Osgood / creep / fracture data: not required for the 7075-T6 screening at room temperature; the bound ramberg-osgood / creep-rupture / fracture-toughness leaves apply where those regimes are in scope.
+
+## 6. Fatigue
+
+- Critical location: lower spar cap at the root; 1g bending stress sigma_1g = 16.3 ksi.
+- S-N basis: Basquin S = A N^b with A = 100.1 ksi, b = -0.10 (7075-T6 class fatigue strength constants, bound stress-life / strain-life leaves, reference-only). Mean stress is corrected with the modified Goodman rule Sa_eq = Sa / (1 - Sm/Ftu).
+- Spectrum (per-flight cycle blocks at the lower spar cap, amplitude dn about the 1g mean):
+
+  - 1.00 cycle(s)/flight at dn = 0.80: Sa = 6.5 ksi, Sa_eq = 8.1 ksi, N = 8.34e+10 cycles, damage per flight = 1.20e-11
+  - 0.05 cycle(s)/flight at dn = 1.40: Sa = 11.4 ksi, Sa_eq = 14.2 ksi, N = 3.10e+08 cycles, damage per flight = 1.61e-10
+
+- GAG cycle (0g to 1g, once per flight): Sa = 8.1 ksi, Sm = 8.1 ksi, Sa_eq = 9.0 ksi, N = 2.83e+10 cycles, damage per flight = 3.53e-11.
+- **Palmgren-Miner cumulative damage sum per flight D = 2.09e-10** (limit 1.0): safe-life screening passes with equivalent life far beyond the design life; production fatigue refines with the counted load spectrum and detail notch factors from the bound load-spectrum-counting / notch-sensitivity / goodman-diagram leaves.
+
+## 7. Damage tolerance
+
+- Safe-life screening (Section 6) is the scope of this example report; the damage tolerance evaluation per FAR 25.571 (crack growth, residual strength, inspection intervals) is executed with the bound crack-growth / residual-strength / widespread-fatigue-damage leaves once the production spectrum and crack-growth data are baselined.
+- Bird strike (FAR 25.631) is a design load case for the leading edge and windshield supports; the bound bird-strike leaf applies when that structure is in scope.
+
+## 8. Composites / thermal
+
+- The example item is metallic (7075-T6); laminate first-ply-failure and sandwich margins from the bound laminate-stiffness / laminate-first-ply-failure / failure-criteria / sandwich-panels leaves apply when composite structure enters the design.
+- Thermal stress and thermal buckling margins are computed with the bound thermal-stress-analysis / thermal-buckling leaves for thermal-critical structure; no thermal-critical metallic margin is driven in this room-temperature screening.
+
+## 9. Margin summary
+
+| Component | MS | Status |
+|---|---|---|
+| Lower spar cap (tension, root) | +0.360 | PASS |
+| Upper spar cap (compression, root) | +0.196 | PASS |
+| Spar web (shear, two webs) | +0.557 | PASS |
+| Upper skin panel (compression buckling, between stringers) | +0.093 | PASS |
+| Upper stringer (column over rib pitch) | +0.196 | PASS |
+| Wing root lug (vertical shear, one lug of pair) | +2.259 | PASS |
+
+---
+*Generated by Aero Agent Roles structures-loads-engineer core (2026-09-05). DRAFT for human stress lead review. Not an approval document - no certification approval is claimed, no compliance finding is declared. FEM results are as good as the model idealizations stated above.*

package/roles/structures-loads-engineer/tests/test_bundle_protocol.py

@@ -0,0 +1,101 @@
+#!/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 gust load factor against the core
+  (agrees within tolerance) 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, "report.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("n_ult", m)
+        self.assertIn("vn", m)
+        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"]), 3)
+
+    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.assertEqual(len(p["skills"]), 1)
+        row = p["skills"][0]
+        self.assertTrue(row["dispatched"])
+        self.assertTrue(row["agrees"], "core/skill gust disagree: %s" % row)
+        self.assertLessEqual(row["delta"], 1e-6)
+        self.assertIn("gust_load_factor", row["function"])
+
+    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, "report.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/structures-loads-engineer/tests/test_role_structures_loads_engineer.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Role test: structures-loads-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/)
+# Bound-skill resolution requires the Aero Agent Skills checkout. It is a
+# cross-repo dev check: when the skills repo is absent (fresh public clone),
+# skip resolution rather than fail - the role's bound list is verified in CI.
+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", "structures-loads-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates",
+                        "loads-strength-report-template.md")
+
+EXPECTED_BOUND = [
+    "structures/loads/gust-maneuver-loads",
+    "structures/loads/landing-ground-loads",
+    "structures/loads/random-vibration-analysis",
+    "structures/loads/shock-response-spectrum",
+    "structures/fem/beam-frame-analysis",
+    "structures/fem/truss-analysis",
+    "structures/fem/calculix-linear",
+    "structures/fem/calculix-nonlinear",
+    "structures/fem/buckling-analysis",
+    "structures/fem/plate-buckling",
+    "structures/fem/cylindrical-shell-buckling",
+    "structures/fem/modal-analysis",
+    "structures/fem/beam-vibration",
+    "structures/fem/lug-joint-analysis",
+    "structures/fem/contact-analysis",
+    "structures/fem/pressure-bulkhead",
+    "structures/materials/material-selection",
+    "structures/materials/mmpsd-allowables",
+    "structures/materials/ramberg-osgood",
+    "structures/materials/creep-rupture",
+    "structures/materials/fracture-toughness",
+    "structures/fatigue/goodman-diagram",
+    "structures/fatigue/stress-life-curve",
+    "structures/fatigue/strain-life-fatigue",
+    "structures/fatigue/miner-damage",
+    "structures/fatigue/notch-sensitivity",
+    "structures/fatigue/load-spectrum-counting",
+    "structures/damage-tolerance/crack-growth",
+    "structures/damage-tolerance/residual-strength",
+    "structures/damage-tolerance/bird-strike",
+    "structures/damage-tolerance/widespread-fatigue-damage",
+    "structures/composites/laminate-stiffness",
+    "structures/composites/laminate-first-ply-failure",
+    "structures/composites/failure-criteria",
+    "structures/composites/sandwich-panels",
+    "structures/composites/composite-repair",
+    "structures/thermal-structures/thermal-stress-analysis",
+    "structures/thermal-structures/thermal-buckling"
+]
+
+STAGES = [
+    "1. Design loads",
+    "2. Global FEM",
+    "3. Nonlinear/buckling",
+    "4. Detail joints",
+    "5. Dynamics",
+    "6. Materials",
+    "7. Fatigue",
+    "8. Damage tolerance",
+    "9. Composites",
+    "10. Thermal",
+    "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 TestStructuresLoadsEngineerRole(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()
+        # gate-check vocabulary must exist in the filled deliverable
+        for phrase in ["loads and strength report", "margins", "draft",
+                       "not an approval"]:
+            self.assertIn(phrase, low, f"gate vocabulary missing: {phrase}")
+        # a real margin-of-safety number is present (MS like +0.xxx)
+        self.assertRegex(text, r"\*\*[+-]\d\.\d{3}\*\*")
+
+    def test_executable_core_and_cli(self):
+        # 100% worker anatomy: executable domain engine + runnable CLI.
+        for rel in ("core/structures_loads_core.py", "cli.py",
+                    "tests/test_structures_loads_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 invent allowables", "not an approval"]:
+            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()

package/roles/structures-loads-engineer/tests/test_structures_loads_core.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+"""Test structures_loads_core: the executable engine of the Structures
+and Loads Engineer role.
+
+Proves the role can DO its job standalone (no AeroSkills needed): FAR 25
+gust + maneuver envelope, limit/ultimate loads, root internal loads,
+margins of safety per component, fatigue screening (S-N basis + Miner),
+dynamics, evidence gates, and the worked-example report. Anchor values
+are taken from the bound AeroSkills leaves' own behavior contracts
+(gust load factor ~2.3-2.4 band at VB, lug margins +1.800/+1.135/+0.926
+governing tearout, Basquin life 1.69e5 cycles at S=300/A=1000/b=-0.1).
+"""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "core"))
+from structures_loads_core import (
+    CANTILEVER_BETA1_L, MATERIALS, NEGATIVE_MANEUVER_LIMIT,
+    basquin_life, build_report, cantilever_frequency_hz, check_report,
+    check_report_markdown, column_check, cumulative_damage,
+    design_limit_load_factor, effective_length_factor, envelope_margins,
+    euler_buckling_load, example_item, example_report_markdown,
+    far25_gust_velocity, goodman_effective_amplitude, gust_alleviation_factor,
+    gust_load_factor, gust_mass_ratio, level_landing_reactions,
+    lug_analysis, maneuver_limit_load_factor, margin_of_safety,
+    plate_buckling_stress, render_report_markdown, shear_buckling_stress,
+    vn_diagram,
+)
+
+KSI_MPA = 6.894757
+
+
+class TestGustManeuverDomain(unittest.TestCase):
+    """Domain rules mirroring the bound gust-maneuver-loads leaf."""
+
+    def test_far25_gust_velocities(self):
+        self.assertAlmostEqual(far25_gust_velocity("vb-vc", 0.0), 66.0)
+        self.assertAlmostEqual(far25_gust_velocity("vc", 0.0), 50.0)
+        self.assertAlmostEqual(far25_gust_velocity("vd", 0.0), 25.0)
+        self.assertAlmostEqual(far25_gust_velocity("vc", 15000.0), 25.0)
+        self.assertAlmostEqual(far25_gust_velocity("vd", 50000.0), 12.5)
+
+    def test_alleviation_anchor(self):
+        # Transport anchor: W/S=100 psf, cbar=11.18 ft, a=5.7 -> mu_g ~41,
+        # K_g ~0.78 (same band as the leaf's cbar=12.5 anchor of 36.7/0.769).
+        mu = gust_mass_ratio(100.0, 11.18, 5.7)
+        kg = gust_alleviation_factor(100.0, 11.18, 5.7)
+        self.assertAlmostEqual(mu, 41.02, delta=0.5)
+        self.assertAlmostEqual(kg, 0.779, delta=0.02)
+        self.assertLess(kg, 0.88)
+
+    def test_gust_load_factor_band(self):
+        # 66 fps design gust at VB on the example wing: n in the 2.3-2.5 band.
+        n = gust_load_factor(414.0, 100.0, 5.7, 66.0, cbar=11.18)
+        self.assertGreater(n, 2.3)
+        self.assertLess(n, 2.6)
+        vn = vn_diagram(100.0, 230.0, 621.0, 5.7, 11.18,
+                        weight_lb=100_000.0)
+        n_vb = [p["n_pos"] for p in vn["gust_points"] if p["speed"] == "VB"][0]
+        self.assertAlmostEqual(n_vb, n, delta=0.01)
+
+    def test_maneuver_factor_far337(self):
+        # FAR 25.337(b): n = max(2.5, min(3.8, 2.1+24000/(W+10000))).
+        self.assertAlmostEqual(maneuver_limit_load_factor(100_000.0,
+                                                          "transport"), 2.5)
+        self.assertAlmostEqual(maneuver_limit_load_factor(3_000.0,
+                                                          "transport"), 3.8)
+        self.assertEqual(maneuver_limit_load_factor(50_000.0, "normal"), 2.5)
+        self.assertEqual(maneuver_limit_load_factor(50_000.0, "commuter"), 3.8)
+        self.assertEqual(maneuver_limit_load_factor(50_000.0, "transport",
+                                                    negative=True),
+                         NEGATIVE_MANEUVER_LIMIT)
+
+    def test_vn_speed_ordering_and_corner(self):
+        vn = vn_diagram(100.0, 230.0, 621.0, 5.7, 11.18,
+                        weight_lb=100_000.0)
+        self.assertTrue(vn["vs"] < vn["va"] < vn["vb"] < vn["vc"] < vn["vd"])
+        import math
+        self.assertAlmostEqual(vn["va"], 230.0 * math.sqrt(2.5), places=3)
+        self.assertEqual(len(vn["gust_points"]), 3)
+
+    def test_design_limit_and_gust_critical(self):
+        vn = vn_diagram(100.0, 230.0, 621.0, 5.7, 11.18,
+                        weight_lb=100_000.0)
+        design = design_limit_load_factor(vn)
+        self.assertAlmostEqual(design["n_limit_pos"], 2.5)
+        em = envelope_margins(vn)
+        # gust-criticality is checked at least somewhere on the envelope
+        self.assertTrue(any(v["gust_critical_pos"] or v["gust_critical_neg"]
+                            for v in em.values())
+                        or all(v["margin_pos"] >= 0 for v in em.values()))
+
+
+class TestStrengthDomain(unittest.TestCase):
+    """Strength rules mirroring the bound buckling / plate-buckling /
+    lug-joint leaves."""
+
+    def test_margin_of_safety(self):
+        self.assertEqual(margin_of_safety(100.0, 80.0), 0.25)
+        self.assertEqual(margin_of_safety(100.0, 100.0), 0.0)
+        self.assertEqual(margin_of_safety(100.0, 200.0), -0.5)
+        with self.assertRaises(ValueError):
+            margin_of_safety(0.0, 1.0)
+
+    def test_euler_anchor(self):
+        # Euler scaling anchor: doubling K quarters Pcr (leaf behavior).
+        pcr2 = euler_buckling_load(29_000.0, 0.6, 22.0)
+        pcr_half = euler_buckling_load(29_000.0, 0.6, 22.0, "fixed-free")
+        self.assertAlmostEqual(pcr_half / pcr2, 0.25, places=4)
+
+    def test_end_conditions(self):
+        self.assertEqual(effective_length_factor("pinned-pinned"), 1.0)
+        self.assertEqual(effective_length_factor("fixed-fixed"), 0.5)
+        self.assertEqual(effective_length_factor("fixed-pinned"), 0.7)
+        self.assertEqual(effective_length_factor("cantilever"), 2.0)
+
+    def test_column_check_transition(self):
+        # Stocky column: yield-governed; slender column: Euler-governed.
+        stocky = column_check(10_400.0, 0.60, 1.2, 8.0, "pinned-pinned",
+                              40_000.0, 73.0)
+        self.assertFalse(stocky["euler_governs"])
+        slender = column_check(10_400.0, 0.60, 1.2, 60.0, "pinned-pinned",
+                              40_000.0, 73.0)
+        self.assertTrue(slender["euler_governs"])
+
+    def test_plate_buckling(self):
+        # k=4 long plate anchor: E=10,400 ksi, nu=0.33, t=0.25, b=6
+        # -> sigma_cr ~ 66.7 ksi (matches the worked example wing panel).
+        sig = plate_buckling_stress(10_400.0, 0.33, 0.25, 6.0, k=4.0)
+        self.assertAlmostEqual(sig, 66.7, delta=1.0)
+        # clamped long plate k=6.97 is stiffer than ssss k=4
+        sig_c = plate_buckling_stress(10_400.0, 0.33, 0.25, 6.0, k=6.97)
+        self.assertGreater(sig_c, sig)
+
+    def test_lug_worked_example_anchor(self):
+        # Bound lug leaf worked example, converted to US customary:
+        # 7075-T6 D=20mm,t=12mm,e=24mm,w=48mm,P=90kN with Ftu=572,
+        # Fsu=331, Fbru=1050 MPa -> margins +1.800/+1.135/+0.926, tearout
+        # governs, passes.
+        d_in = 20.0 / 25.4
+        t_in = 12.0 / 25.4
+        e_in = 24.0 / 25.4
+        w_in = 48.0 / 25.4
+        p_lb = 90_000.0 / 4.448222
+        lug = lug_analysis(p_lb, d_in, t_in, w_in, e_in,
+                           572.0 / KSI_MPA, 331.0 / KSI_MPA,
+                           1050.0 / KSI_MPA)
+        self.assertAlmostEqual(lug["bearing_margin"], 1.800, delta=0.02)
+        self.assertAlmostEqual(lug["net_tension_margin"], 1.135, delta=0.02)
+        self.assertAlmostEqual(lug["tearout_margin"], 0.926, delta=0.02)
+        self.assertEqual(lug["governing_mode"], "tearout")
+        self.assertTrue(lug["passes"])
+
+
+class TestFatigueDomain(unittest.TestCase):
+    """Fatigue rules mirroring the bound stress-life / goodman / miner
+    leaves."""
+
+    def test_basquin_anchor(self):
+        # stress-life leaf anchor: A=1000, b=-0.1, S=300 -> N ~1.69e5.
+        n = basquin_life(300.0, 1000.0, -0.1)
+        self.assertAlmostEqual(n, 1.6935e5, delta=0.05e5)
+
+    def test_goodman_effective_amplitude(self):
+        self.assertAlmostEqual(goodman_effective_amplitude(10.0, 0.0, 83.0),
+                               10.0)
+        # A tensile mean stress raises the equivalent fully-reversed
+        # amplitude (same damage at zero mean needs a bigger amplitude).
+        self.assertLess(goodman_effective_amplitude(10.0, 0.0, 83.0),
+                        goodman_effective_amplitude(10.0, 30.0, 83.0))
+        self.assertAlmostEqual(goodman_effective_amplitude(10.0, 30.0, 83.0),
+                               10.0 / (1.0 - 30.0 / 83.0), places=6)
+        with self.assertRaises(ValueError):
+            goodman_effective_amplitude(10.0, 90.0, 83.0)
+
+    def test_miner_sum(self):
+        self.assertEqual(cumulative_damage([(100, 200)]), 0.5)
+        d = cumulative_damage([(500, 1000), (300, 600)])
+        self.assertEqual(d, 1.0)
+        with self.assertRaises(ValueError):
+            cumulative_damage([])
+        with self.assertRaises(ValueError):
+            cumulative_damage([(10, 0)])
+
+    def test_fatigue_report_fields(self):
+        model = build_report(example_item())
+        f = model["fatigue"]
+        self.assertIn("damage_per_flight", f)
+        self.assertGreater(f["damage_per_flight"], 0.0)
+        self.assertLess(f["damage_per_flight"], 1.0)
+        self.assertTrue(f["gust_blocks"])
+
+
+class TestBuilderAndGates(unittest.TestCase):
+
+    def test_example_report_model(self):
+        model = build_report(example_item())
+        self.assertEqual(model["document_type"], "Loads and Strength Report")
+        self.assertEqual(model["status"], "draft-for-review")
+        self.assertGreaterEqual(len(model["margins"]), 5)
+        # the example wing must pass: every margin of safety >= 0
+        for m in model["margins"]:
+            self.assertGreaterEqual(m["MS"], 0.0,
+                                    "example margin negative: %s" % m)
+            for key in ("component", "load", "allowable", "basis"):
+                self.assertTrue(m[key], "missing %s in margin row" % key)
+
+    def test_ground_loads(self):
+        g = level_landing_reactions(100_000.0, 18.0, 6.0, 2.5)
+        self.assertAlmostEqual(g["total_lb"], 250_000.0, places=1)
+
+    def test_dynamics_frequency_sane(self):
+        model = build_report(example_item())
+        # regional transport wing first bending: ~1-4 Hz
+        self.assertGreater(model["dynamics_f1_hz"], 1.0)
+        self.assertLess(model["dynamics_f1_hz"], 4.0)
+        self.assertAlmostEqual(CANTILEVER_BETA1_L, 1.87510407, places=5)
+
+    def test_core_gates_all_pass(self):
+        model = build_report(example_item())
+        gates = check_report(model)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_markdown_gates_all_pass(self):
+        md = example_report_markdown()
+        gates = check_report_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_rendered_report_structure(self):
+        md = example_report_markdown()
+        for sec in ["## 1. Loads", "## 3. Strength/stability margins",
+                    "## 6. Fatigue", "## 9. Margin summary"]:
+            self.assertIn(sec, md)
+        self.assertIn("not an approval", md.lower())
+        # no template blanks left in the worked example
+        self.assertNotIn("___", md)
+
+    def test_standalone_no_skills_repo(self):
+        # Core must work with no AeroSkills present.
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = build_report(example_item())
+        self.assertGreaterEqual(len(model["margins"]), 5)
+        md = render_report_markdown(model)
+        self.assertGreater(len(md), 2000)
+        self.assertTrue(check_report(model)["all_pass"])
+        self.assertTrue(check_report_markdown(md)["all_pass"])
+
+    def test_material_allowables_grounded(self):
+        # The allowables used in the example report must be the leaf
+        # anchors (572/503/331/1050 MPa -> 83.0/73.0/48.0/152.3 ksi).
+        mat = MATERIALS["al-7075-t6"]
+        self.assertAlmostEqual(mat["Ftu_ksi"], 572.0 / KSI_MPA, places=2)
+        self.assertAlmostEqual(mat["Fty_ksi"], 503.0 / KSI_MPA, places=2)
+        self.assertAlmostEqual(mat["Fsu_ksi"], 331.0 / KSI_MPA, places=2)
+        self.assertAlmostEqual(mat["Fbru_ksi"], 1050.0 / KSI_MPA, places=2)
+
+
+if __name__ == "__main__":
+    unittest.main()