aero-agent-roles 1.0.0

package/roles/data-bus-avionics-engineer/templates/bus-assessment-template.md

@@ -0,0 +1,134 @@
+# Avionics Data Bus Loading and Protocol Assessment
+
+**Aircraft / program:** EX-100 Reference Example Transport
+**Status:** draft-for-review
+**Protocol basis:** MIL-STD-1553B / ARINC 429 Mark 33 DITS / ARINC 664 Part 7 protocol practice
+
+## 1. Scope
+
+This assessment budgets every ARINC 429 transmit line, the MIL-STD-1553 bus-controller minor-frame schedule, and the ARINC 664 AFDX virtual-link set of the aircraft bus architecture, and checks received-word conformance (parity, label, word fields) against the interface control documents. Flight deck avionics data bus architecture: ADC, IRS and legacy utility concentrator ARINC 429 transmit lines, a dual-redundant MIL-STD-1553 bus under one bus controller, and a growth AFDX core network.
+
+Loading gates: ARINC 429 and MIL-STD-1553 utilization against the 80% design guideline (the leaf practice; ARINC 429 capacity is the link itself), AFDX VL set against the 100 Mbps link.
+
+## 2. ARINC 429 bus loading
+
+### A429-1 ADC/FMS data  (ADC-1 -> FMS-1, EFIS-1, 100 kbps)
+
+| Label | Rate (words/s) |
+|---|---|
+| 010 | 25 |
+| 011 | 25 |
+| 036 | 50 |
+| 100 | 50 |
+| 203 | 12.5 |
+| 210 | 25 |
+| 231 | 25 |
+| 320 | 12.5 |
+| 365 | 12.5 |
+| 370 | 12.5 |
+
+- Total word rate: **250.00 words/s**
+- Bus load: **9000 bps** (36 bit-times per word)
+- Bus utilization: **9.00%** of 100 kbps (capacity 2777.8 words/s)
+- Capacity verdict: **FITS**; design guideline (80%): **FITS**
+- Headroom to guideline: **71.00%**
+
+### A429-2 IRS/FCC data  (IRS-1 -> FCC-1, EFIS-1, 100 kbps)
+
+| Label | Rate (words/s) |
+|---|---|
+| 320 | 25 |
+| 365 | 25 |
+| 366 | 25 |
+| 367 | 25 |
+| 370 | 25 |
+| 371 | 25 |
+| 372 | 25 |
+| 375 | 12.5 |
+| 376 | 12.5 |
+
+- Total word rate: **200.00 words/s**
+- Bus load: **7200 bps** (36 bit-times per word)
+- Bus utilization: **7.20%** of 100 kbps (capacity 2777.8 words/s)
+- Capacity verdict: **FITS**; design guideline (80%): **FITS**
+- Headroom to guideline: **72.80%**
+
+### A429-3 fuel/utility (low speed)  (UTA-1 -> EICAS-1, 12.5 kbps)
+
+| Label | Rate (words/s) |
+|---|---|
+| 250 | 20 |
+| 251 | 20 |
+| 252 | 20 |
+| 253 | 20 |
+| 254 | 20 |
+| 255 | 20 |
+| 256 | 20 |
+| 257 | 20 |
+| 260 | 20 |
+| 261 | 20 |
+| 262 | 20 |
+| 263 | 20 |
+| 264 | 20 |
+
+- Total word rate: **260.00 words/s**
+- Bus load: **9360 bps** (36 bit-times per word)
+- Bus utilization: **74.88%** of 12.5 kbps (capacity 347.2 words/s)
+- Capacity verdict: **FITS**; design guideline (80%): **FITS**
+- Headroom to guideline: **5.12%**
+
+## 3. MIL-STD-1553 bus loading
+
+### 1553-B1 mission bus  (BC Mission Computer (MC-1); RTs RT 1 (FMS-1), RT 2 (NAV-1), RT 3 (FCC-1); minor frame 5000 us)
+
+| Message | Data words | Wire words | Bus time (us) |
+|---|---|---|---|
+| BCRT | 32 | 34 | 816 |
+| RTBC | 16 | 18 | 432 |
+| BCRT | 16 | 18 | 432 |
+| RTRT | 8 | 11 | 264 |
+| RTBC | 8 | 10 | 240 |
+| BCRT | 8 | 10 | 240 |
+| BCRT | 4 | 6 | 144 |
+| RTRT | 4 | 7 | 168 |
+
+- Schedule time: **2736 us** over 5000 us (114 wire words x 24 us)
+- Bus utilization: **54.72%**
+- Budget (80% of frame): 4000 us; headroom 1264 us (25.28%)
+- Verdict: **FITS**
+
+## 4. ARINC 664 AFDX network
+
+### AFDX core network (growth)  (dual independent networks A and B, same VL set)
+
+- Virtual links: 14; total bandwidth **10.816 Mbps**
+- Link utilization: **10.82%** of 100 Mbps
+- Link budget verdict: **FITS**
+
+| VLs | BAG (ms) | Frame (bytes) | Bandwidth (Mbps) |
+|---|---|---|---|
+| 1 | 4 | 1518 | 3.036 |
+| 1 | 8 | 1518 | 1.518 |
+| 6 | 16 | 1518 | 0.759 |
+| 4 | 32 | 1518 | 0.380 |
+| 2 | 128 | 1518 | 0.095 |
+
+- Worst-case latency (1518-byte frame, 2 switch(es) at 150 us): **542.88 us**
+- Jitter: measured 420 us vs budget 500 us -> slack **80.0 us**
+## 5. Protocol conformance checks
+
+- ARINC 429 received word 0x60134908: label 010 (8), SDI 1, data field 1234 (BNR 123.4 at LSB 0.1), SSM 3, parity OK
+  - Expected label 010 (8): MATCH
+- MIL-STD-1553 command word 16 data words, RT 5 subaddress 12, RT-to-BC: classified **rt-to-bc**, parity OK
+- MIL-STD-1553 status word RT 5: busy=1, terminal_flag=0, parity OK
+
+## 6. Findings and observations
+
+- **O-1** A429-3 fuel/utility (low speed) sits at 74.88% utilization with only 5.12% headroom to the 80% guideline: growth requires a re-rate or a new line.
+
+## 7. Conclusion
+
+The bus architecture loading and received-word conformance results above are computed by the data-bus-avionics-engineer core from the bound ARINC 429, MIL-STD-1553 and ARINC 664 AFDX leaf rules (36 bit-times per ARINC 429 word; 24 us per MIL-STD-1553 wire word; frame x 8 / BAG for AFDX VL bandwidth). Numbers are cross-checked against the AeroSkills leaf logic when the skills library is present and recorded in the evidence bundle.
+
+---
+*Generated by Aero Agent Roles data-bus-avionics-engineer core (2026-09-05). DRAFT for human avionics/data-bus engineer review. Not an approval document.*

package/roles/data-bus-avionics-engineer/tests/test_bundle_protocol.py

@@ -0,0 +1,137 @@
+#!/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 bus loading numbers,
+  gates all_pass
+- the five bound avionics/data-bus leaf logic modules dispatch and
+  cross-check their numbers against the core (agree within 1e-6) when
+  AeroSkills is present
+- standalone (no AeroSkills) emits the bundle honestly with
+  cross_checked=false
+- build --profile prepends a program context header
+- check gate-checks a built assessment
+"""
+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")
+PROFILE = os.path.normpath(os.path.join(ROLE_DIR, "..", "..", "profiles",
+                                        "example-airframer.json"))
+
+AEROSKILLS = os.environ.get("AEROSKILLS_DEV", os.path.expanduser("~/AeroSkills"))
+HAS_SKILLS = os.path.isdir(os.path.join(AEROSKILLS, "skills"))
+
+EXPECTED_LEAVES = [
+    "arinc429-protocol", "arinc429-bus-loading", "arinc664-afdx",
+    "mil-std-1553", "mil-std-1553-bus-loading",
+]
+
+
+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, "assessment.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("arinc429", m)
+        self.assertIn("m1553", m)
+        self.assertIn("afdx", m)
+        self.assertEqual(m.get("status"), "draft-for-review")
+        self.assertIn("role", m)
+        self.assertEqual(m["role"], "data-bus-avionics-engineer")
+        # the model must carry the numbers that appear in the markdown
+        self.assertAlmostEqual(
+            m["m1553"]["schedule"]["utilization_pct"], 54.72, places=4)
+        self.assertAlmostEqual(m["afdx"]["utilization_pct"], 10.81575,
+                               places=4)
+
+    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)
+        self.assertEqual(r.returncode, 0, r.stderr[-500:])
+        p = json.load(open(os.path.join(self.tmp, "evidence",
+                                        "provenance.json")))
+        self.assertTrue(p["cross_checked"])
+        self.assertEqual(len(p["skills"]), 5)
+        leafs = {row["leaf"].rsplit("/", 1)[-1] for row in p["skills"]}
+        self.assertEqual(leafs, set(EXPECTED_LEAVES))
+        for row in p["skills"]:
+            self.assertTrue(row["dispatched"])
+            self.assertTrue(row["agrees"],
+                            "core/skill disagree for %s: %s"
+                            % (row["function"], row))
+            self.assertLessEqual(row["delta"], 1e-6)
+        funcs = {row["function"] for row in p["skills"]}
+        self.assertIn("vl_bandwidth", funcs)
+        self.assertIn("schedule_utilization", funcs)
+
+    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_profile_header_applied(self):
+        if not os.path.exists(PROFILE):
+            self.skipTest("profiles/example-airframer.json not present")
+        r = run_build(self.tmp, extra_args=["--profile", PROFILE])
+        self.assertEqual(r.returncode, 0, r.stderr[-500:])
+        md = open(os.path.join(self.tmp, "assessment.md")).read()
+        self.assertIn("Example Airframers Ltd", md)
+        self.assertIn("Program context (profile)", md)
+        m = json.load(open(os.path.join(self.tmp, "evidence", "model.json")))
+        self.assertEqual(m["profile"]["customer"], "Example Airframers Ltd")
+
+    def test_check_still_works(self):
+        run_build(self.tmp)
+        md = os.path.join(self.tmp, "assessment.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/data-bus-avionics-engineer/tests/test_data_bus_avionics_core.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+"""Test data_bus_avionics_core: the executable engine of the Data Bus role.
+
+Proves the role can DO its job standalone (no AeroSkills needed):
+ARINC 429 word decode/build with odd parity, ARINC 429 bus loading %,
+MIL-STD-1553 word encode/decode and message classification, MIL-STD-1553
+BC minor-frame bus loading, AFDX VL bandwidth and link budget, the
+assessment builder + evidence gates, and standalone operation.
+
+Real computed anchors (from the bound AeroSkills leaf logic tests):
+- ARINC 429 build_word(8, 1, 1234, 3) == 1611876616 (0x60134908)
+- MIL-STD-1553 encode_command_word(5, 12, 16, 1) == 93316
+- MIL-STD-1553 encode_data_word(0x7FFF) == 262139
+- MIL-STD-1553 encode_status_word(5, busy=1) == 606276
+- AFDX vl_bandwidth(4 ms, 1518) == 3036000.0 bps
+- AFDX 30 x (4 ms, 1518) VLs == 91.08% of the 100 Mbps link
+"""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "core"))
+from data_bus_avionics_core import (  # noqa: E402
+    a429_bnr_decode, a429_bnr_encode, a429_build_word, a429_decode_word,
+    a429_loading_summary, a429_parity_ok, a429_total_word_rate,
+    a429_utilization_pct, a429_word_capacity,
+    afdx_end_to_end_latency_us, afdx_jitter_slack,
+    afdx_largest_bag_for_bandwidth, afdx_link_utilization_pct,
+    afdx_transmission_time_us, afdx_vl_bandwidth,
+    analyze_architecture, build_assessment, check_assessment,
+    check_assessment_markdown, example_assessment_markdown, example_item,
+    m1553_classify_message, m1553_decode_command_word,
+    m1553_decode_status_word, m1553_encode_command_word,
+    m1553_encode_data_word, m1553_encode_status_word, m1553_message_time_us,
+    m1553_schedule_utilization, m1553_wire_words, render_assessment_markdown,
+)
+
+A429_WORD = 1611876616          # 0x60134908: label 010, SDI 1, data 1234
+M1553_CMD = 93316               # RT 5, SA 12, WC 16, T/R 1
+M1553_STATUS = 606276           # RT 5, busy=1
+
+
+class TestArinc429Protocol(unittest.TestCase):
+
+    def test_word_build_anchor(self):
+        self.assertEqual(a429_build_word(8, 1, 1234, 3), A429_WORD)
+        self.assertEqual(a429_build_word("010", 1, 1234, 3), A429_WORD)
+
+    def test_word_decode_fields(self):
+        d = a429_decode_word(A429_WORD)
+        self.assertEqual(d["label"], 8)          # octal 010
+        self.assertEqual(d["sdi"], 1)
+        self.assertEqual(d["data"], 1234)
+        self.assertEqual(d["ssm"], 3)
+        self.assertTrue(d["parity_ok"])
+        self.assertTrue(a429_parity_ok(A429_WORD))
+
+    def test_word_round_trip(self):
+        w = a429_build_word(0o365, 2, 777, 1)
+        d = a429_decode_word(w)
+        self.assertEqual((d["label"], d["sdi"], d["data"], d["ssm"]),
+                         (0o365, 2, 777, 1))
+
+    def test_bnr_encode_decode(self):
+        self.assertEqual(a429_bnr_encode(123.4, 0.1), 1234)
+        self.assertAlmostEqual(a429_bnr_decode(1234, 0.1), 123.4, places=6)
+        neg = a429_bnr_encode(-12.3, 0.1)
+        self.assertEqual(neg, 524165)
+        self.assertAlmostEqual(a429_bnr_decode(neg, 0.1), -12.3, places=6)
+
+
+class TestArinc429Loading(unittest.TestCase):
+
+    def test_total_word_rate_and_load(self):
+        rates = {"010": 100.0, "011": 100.0}
+        self.assertEqual(a429_total_word_rate(rates), 200.0)
+        self.assertAlmostEqual(a429_utilization_pct(200.0), 7.2, places=6)
+        self.assertAlmostEqual(a429_utilization_pct(200.0, 12500.0),
+                               57.6, places=6)
+
+    def test_capacity(self):
+        # ~2777.8 words/s at 100 kbps, ~347.2 at 12.5 kbps (36 bit-times)
+        self.assertAlmostEqual(a429_word_capacity(100000.0), 2777.7778,
+                               places=3)
+        self.assertAlmostEqual(a429_word_capacity(12500.0), 347.2222,
+                               places=3)
+
+    def test_fits_with_headroom(self):
+        s = a429_loading_summary({"010": 250.0}, 100000.0)
+        self.assertEqual(s["capacity_verdict"], "FITS")
+        self.assertEqual(s["guideline_verdict"], "FITS")
+        self.assertAlmostEqual(s["utilization_pct"], 9.0, places=6)
+        self.assertAlmostEqual(s["headroom_pct"], 71.0, places=6)
+
+    def test_guideline_violation_not_capacity_over(self):
+        # 2500 words/s -> 90% of the 100 kbps link: fits capacity,
+        # violates the 80% design guideline.
+        s = a429_loading_summary({"010": 2500.0}, 100000.0)
+        self.assertAlmostEqual(s["utilization_pct"], 90.0, places=6)
+        self.assertEqual(s["capacity_verdict"], "FITS")
+        self.assertEqual(s["guideline_verdict"], "VIOLATION")
+        self.assertEqual(s["headroom_pct"], 0.0)
+
+    def test_capacity_over(self):
+        # 3100 words/s -> 111.6%: beyond the link itself.
+        s = a429_loading_summary({"010": 3100.0}, 100000.0)
+        self.assertAlmostEqual(s["utilization_pct"], 111.6, places=6)
+        self.assertEqual(s["capacity_verdict"], "OVER")
+
+    def test_low_speed_line_near_guideline(self):
+        # 13 labels x 20 wps = 260 wps -> 74.88% of the 12.5 kbps link
+        rates = {oct(0o250 + i)[2:]: 20.0 for i in range(13)}
+        s = a429_loading_summary(rates, 12500.0)
+        self.assertAlmostEqual(s["total_words_per_s"], 260.0, places=6)
+        self.assertAlmostEqual(s["utilization_pct"], 74.88, places=4)
+        self.assertEqual(s["guideline_verdict"], "FITS")
+
+
+class TestM1553Protocol(unittest.TestCase):
+
+    def test_command_word_anchor(self):
+        self.assertEqual(m1553_encode_command_word(5, 12, 16, 1), M1553_CMD)
+        d = m1553_decode_command_word(M1553_CMD)
+        self.assertEqual(d["rt_address"], 5)
+        self.assertEqual(d["subaddress"], 12)
+        self.assertEqual(d["word_count"], 16)
+        self.assertEqual(d["transmit_receive"], 1)
+        self.assertTrue(d["parity_ok"])
+
+    def test_data_word_anchor(self):
+        self.assertEqual(m1553_encode_data_word(0x7FFF), 262139)
+
+    def test_status_word_anchor(self):
+        self.assertEqual(m1553_encode_status_word(5, busy=1), M1553_STATUS)
+        d = m1553_decode_status_word(M1553_STATUS)
+        self.assertEqual(d["rt_address"], 5)
+        self.assertEqual(d["busy"], 1)
+        self.assertTrue(d["parity_ok"])
+
+    def test_message_classification(self):
+        self.assertEqual(m1553_classify_message(5, 12, 16, 1), "rt-to-bc")
+        self.assertEqual(m1553_classify_message(5, 12, 16, 0), "bc-to-rt")
+        self.assertEqual(m1553_classify_message(31, 8, 8, 0), "broadcast")
+        self.assertEqual(m1553_classify_message(3, 0, 17, 0), "mode-code")
+
+
+class TestM1553Loading(unittest.TestCase):
+
+    MESSAGES = [("BCRT", 32), ("RTBC", 16), ("BCRT", 16), ("RTRT", 8),
+                ("RTBC", 8), ("BCRT", 8), ("BCRT", 4), ("RTRT", 4)]
+
+    def test_wire_words(self):
+        self.assertEqual(m1553_wire_words("BCRT", 16), 18)
+        self.assertEqual(m1553_wire_words("RTBC", 32), 34)
+        self.assertEqual(m1553_wire_words("RTRT", 8), 11)
+        self.assertEqual(m1553_message_time_us("RTRT", 8), 264.0)
+
+    def test_schedule_utilization_anchor(self):
+        s = m1553_schedule_utilization(self.MESSAGES, 5000.0)
+        # 114 wire words x 24 us = 2736 us of a 5000 us minor frame
+        self.assertEqual(s["total_wire_words"], 114)
+        self.assertEqual(s["total_us"], 2736.0)
+        self.assertAlmostEqual(s["utilization_pct"], 54.72, places=6)
+        self.assertEqual(s["budget_us"], 4000.0)
+        self.assertEqual(s["headroom_us"], 1264.0)
+        self.assertEqual(s["verdict"], "FITS")
+
+    def test_schedule_over_budget(self):
+        heavy = [("BCRT", 32)] * 6 + [("RTRT", 32)] * 6
+        s = m1553_schedule_utilization(heavy, 5000.0)
+        self.assertEqual(s["verdict"], "OVER")
+
+
+class TestAfdx(unittest.TestCase):
+
+    def test_vl_bandwidth_anchors(self):
+        self.assertEqual(afdx_vl_bandwidth(4, 1518), 3036000.0)
+        self.assertEqual(afdx_vl_bandwidth(128, 1518), 94875.0)
+
+    def test_link_utilization(self):
+        self.assertAlmostEqual(afdx_link_utilization_pct([(4, 1518)] * 30),
+                               91.08, places=4)
+        with self.assertRaises(ValueError):
+            afdx_link_utilization_pct([(4, 1518)] * 33)
+
+    def test_timing_anchors(self):
+        self.assertAlmostEqual(afdx_transmission_time_us(1518), 121.44,
+                               places=6)
+        self.assertAlmostEqual(afdx_end_to_end_latency_us(1518, 2, 150.0),
+                               542.88, places=4)
+        self.assertEqual(afdx_jitter_slack(420.0, 500.0), 80.0)
+        self.assertEqual(afdx_jitter_slack(620.0, 500.0), -120.0)
+
+    def test_largest_bag_for_bandwidth(self):
+        self.assertEqual(afdx_largest_bag_for_bandwidth(1e6, 1518), 8)
+        with self.assertRaises(ValueError):
+            afdx_largest_bag_for_bandwidth(13e6, 1518)
+
+
+class TestAssessmentBuilder(unittest.TestCase):
+
+    def test_example_architecture_loads(self):
+        item = example_item()
+        results = analyze_architecture(item)
+        model = build_assessment(item, results)
+        self.assertEqual(len(model["arinc429"]), 3)
+        # worked example numbers: 1553 54.72%, AFDX 10.81575%
+        self.assertAlmostEqual(
+            model["m1553"]["schedule"]["utilization_pct"], 54.72, places=4)
+        self.assertAlmostEqual(model["afdx"]["utilization_pct"], 10.81575,
+                               places=4)
+        self.assertFalse(model["afdx"]["oversubscribed"])
+        # low-speed line is the loaded one (74.88%) -> observation raised
+        self.assertTrue(model["observations"])
+        self.assertEqual(model["status"], "draft-for-review")
+
+    def test_conformance_samples_decode(self):
+        item = example_item()
+        conf = analyze_architecture(item)["conformance"]
+        self.assertEqual(conf["a429_word"]["label"], 8)
+        self.assertTrue(conf["a429_word"]["parity_ok"])
+        self.assertAlmostEqual(conf["a429_bnr"]["engineering_value"], 123.4,
+                               places=6)
+        self.assertEqual(conf["m1553_command"]["rt_address"], 5)
+        self.assertTrue(conf["m1553_command"]["parity_ok"])
+        self.assertEqual(conf["m1553_status"]["busy"], 1)
+
+    def test_deliverable_sections(self):
+        md = example_assessment_markdown()
+        for sec in ["## 1. Scope", "## 2. ARINC 429 bus loading",
+                    "## 3. MIL-STD-1553 bus loading",
+                    "## 4. ARINC 664 AFDX network",
+                    "## 5. Protocol conformance checks",
+                    "## 6. Findings and observations"]:
+            self.assertIn(sec, md)
+        self.assertIn("not an approval", md.lower())
+        self.assertGreater(len(md), 3000)
+
+    def test_core_gates_all_pass(self):
+        item = example_item()
+        model = build_assessment(item, analyze_architecture(item))
+        gates = check_assessment(model)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_markdown_gates_all_pass(self):
+        md = example_assessment_markdown()
+        gates = check_assessment_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_standalone_no_skills_repo(self):
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = build_assessment(example_item(),
+                                 analyze_architecture(example_item()))
+        md = render_assessment_markdown(model)
+        self.assertGreater(len(md), 3000)
+        self.assertTrue(check_assessment(model)["all_pass"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/data-bus-avionics-engineer/tests/test_role_data_bus_avionics_engineer.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Role test: Data Bus / Avionics Network 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. Evidence-gate smoke: the filled template deliverable carries the
+   loading numbers, conformance checks, DRAFT and not-an-approval
+   markers with zero blank fields.
+"""
+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", "data-bus-avionics-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates", "bus-assessment-template.md")
+
+EXPECTED_BOUND = [
+    "avionics/data-bus/arinc429-protocol",
+    "avionics/data-bus/arinc429-bus-loading",
+    "avionics/data-bus/arinc664-afdx",
+    "avionics/data-bus/mil-std-1553",
+    "avionics/data-bus/mil-std-1553-bus-loading",
+]
+
+EXPECTED_STAGES = [
+    "Architecture inventory",
+    "ARINC 429 decode review",
+    "ARINC 429 bus loading",
+    "MIL-STD-1553 word review",
+    "MIL-STD-1553 bus loading",
+    "AFDX bandwidth check",
+    "Conformance gate",
+    "Assessment package",
+]
+
+
+def read_role_md():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    if not os.path.exists(p):
+        return None
+    return open(p).read()
+
+
+class TestDataBusRole(unittest.TestCase):
+
+    def test_bound_skills_resolve_in_aeroskills(self):
+        if not HAS_SKILLS:
+            self.skipTest("Aero Agent Skills checkout not present "
+                          "(cross-repo dev check)")
+        for leaf in EXPECTED_BOUND:
+            sk = os.path.join(AEROSKILLS, "skills", leaf, "SKILL.md")
+            self.assertTrue(
+                os.path.exists(sk),
+                f"bound skill not found in aero-agent-skills: {leaf}")
+            logic_dir = os.path.join(AEROSKILLS, "skills", leaf, "scripts")
+            self.assertTrue(
+                any(f.endswith("_logic.py")
+                    for f in os.listdir(logic_dir)),
+                f"bound skill has no logic file: {leaf}")
+
+    def test_bound_skills_listed_in_frontmatter(self):
+        role = read_role_md()
+        self.assertIsNotNone(role)
+        for leaf in EXPECTED_BOUND:
+            self.assertIn(leaf, role, f"missing in ROLE.md skills_bound: {leaf}")
+
+    def test_workflow_stages_deterministic(self):
+        role = read_role_md()
+        # every expected stage appears in order (indexes ascending)
+        idx = [role.find(stage) for stage in EXPECTED_STAGES]
+        self.assertTrue(all(i >= 0 for i in idx), "a stage is missing")
+        self.assertEqual(idx, sorted(idx), "stage order not deterministic")
+
+    def test_deliverable_template_complete(self):
+        if not os.path.exists(TEMPLATE):
+            self.fail("bus-assessment-template.md missing")
+        text = open(TEMPLATE).read()
+        # all 7 numbered sections present, zero blanks
+        for n in range(1, 8):
+            self.assertTrue(
+                re.search(rf"^## {n}\. ", text, re.M),
+                f"section {n} missing")
+        self.assertNotIn("___", text)
+        low = text.lower()
+        for marker in ["arinc 429", "mil-std-1553", "afdx", "utilization",
+                       "parity", "draft", "not an approval", "document"]:
+            self.assertIn(marker, low, f"template missing marker: {marker}")
+
+    def test_forbidden_lines_present(self):
+        role = read_role_md()
+        for phrase in ["issue bus architecture sign-off",
+                       "network qualification approval",
+                       "sign_off_required: true"]:
+            self.assertIn(phrase, role, f"missing boundary: {phrase}")
+
+    def test_sources_register_exists(self):
+        p = os.path.join(ROLE_DIR, "SOURCES.md")
+        self.assertTrue(os.path.exists(p), "SOURCES.md missing for role")
+
+    def test_core_engine_exists(self):
+        """100% standard: every role ships an executable core + cli."""
+        for f in ["core", "cli.py"]:
+            self.assertTrue(os.path.exists(os.path.join(ROLE_DIR, f)),
+                            f"{f} missing - role is not executable")
+
+    def test_author_ashfordeou(self):
+        role = read_role_md()
+        self.assertIn("ashfordeOU", role, "author not set")
+
+
+if __name__ == "__main__":
+    unittest.main()