aero-agent-roles 1.0.0

package/roles/do160-environmental-engineer/tests/test_role_do160_environmental_engineer.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+"""Role test: DO-160G Environmental Qualification 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 example LRU produces a complete
+   qualification report with no blank sections.
+4. When the skills checkout is present, the core's numeric anchors are
+   CROSS-CHECKED against the bound leaves' own *_logic.py files.
+5. cli.py build --bundle works (evidence JSON written, gates pass).
+"""
+import importlib.util
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+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/)
+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", "do160-environmental-engineer")
+TEMPLATE = os.path.join(ROLE_DIR, "templates",
+                        "environmental-qualification-plan-template.md")
+
+EXPECTED_BOUND = [
+    "avionics/do160/environmental-qualification",
+    "avionics/do160/lightning-protection",
+    "avionics/do160/electrostatic-discharge",
+    "avionics/do160/power-input",
+    "avionics/do160/radio-frequency-susceptibility",
+    "avionics/do160/radio-frequency-emissions",
+]
+
+EXPECTED_STAGES = [
+    "Environmental scope", "Lightning plan", "ESD levels",
+    "Power input quality", "RF immunity", "RF emissions",
+]
+
+
+def read_role_md():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    if not os.path.exists(p):
+        return None
+    return open(p).read()
+
+
+def load_leaf_logic(leaf):
+    """Import a bound leaf's *_logic.py (first one found). Returns module
+    or None when the leaf or its logic file is unavailable."""
+    logic_dir = os.path.join(AEROSKILLS, "skills", leaf, "scripts")
+    if not os.path.isdir(logic_dir):
+        return None
+    for f in sorted(os.listdir(logic_dir)):
+        if f.endswith("_logic.py"):
+            path = os.path.join(logic_dir, f)
+            spec = importlib.util.spec_from_file_location(
+                leaf.replace("/", "_"), path)
+            mod = importlib.util.module_from_spec(spec)
+            try:
+                spec.loader.exec_module(mod)
+            except Exception:
+                continue
+            return mod
+    return None
+
+
+class TestDo160Role(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: "
+                            f"{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: "
+                                      f"{leaf}")
+
+    def test_workflow_stages_deterministic(self):
+        role = read_role_md()
+        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):
+        self.assertTrue(os.path.exists(TEMPLATE),
+                        "environmental-qualification-plan-template.md missing")
+        text = open(TEMPLATE, encoding="utf-8").read()
+        # all 9 numbered sections present
+        for n in range(1, 10):
+            self.assertTrue(re.search(rf"^## {n}\. ", text, re.M),
+                            f"section {n} missing")
+        # zero blank fillers
+        self.assertNotIn("___", text)
+        low = text.lower()
+        self.assertIn("draft", low)
+        self.assertIn("not an approval", low)
+        self.assertIn("15 kv air discharge", low)
+
+    def test_forbidden_lines_present(self):
+        role = read_role_md()
+        for phrase in ["issue qualification approval", "regulatory sign-off",
+                       "reproduce proprietary", "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):
+        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_cli_build_bundle_exits_zero(self):
+        """cli build --bundle -> exit 0, evidence JSON valid, gates pass."""
+        with tempfile.TemporaryDirectory() as td:
+            out = os.path.join(td, "eqpr.md")
+            r = subprocess.run([sys.executable, os.path.join(ROLE_DIR, "cli.py"),
+                                "build", "--out", out, "--bundle"],
+                               capture_output=True, text=True)
+            self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+            self.assertTrue(os.path.exists(out))
+            ev = os.path.join(td, "evidence")
+            for f in ["model.json", "gates.json", "provenance.json"]:
+                self.assertTrue(os.path.exists(os.path.join(ev, f)),
+                                f"evidence/{f} missing")
+            gates = json.load(open(os.path.join(ev, "gates.json")))
+            self.assertTrue(gates["all_pass"])
+            self.assertEqual(gates["exit_code"], 0)
+            model = json.load(open(os.path.join(ev, "model.json")))
+            self.assertIn("temperature_category", model)
+            prov = json.load(open(os.path.join(ev, "provenance.json")))
+            self.assertEqual(prov["role"], "do160-environmental-engineer")
+            # no local paths in the bundle
+            blob = json.dumps(model) + json.dumps(prov)
+            self.assertNotIn("/Users/", blob)
+            self.assertNotIn(AEROSKILLS if not AEROSKILLS.startswith("~")
+                             else "/nonexistent", blob)
+
+    def test_cli_build_standalone_bad_skills_env(self):
+        """AEROSKILLS_DEV=/nonexistent -> core still builds correctly."""
+        env = dict(os.environ)
+        env["AEROSKILLS_DEV"] = "/nonexistent"
+        with tempfile.TemporaryDirectory() as td:
+            out = os.path.join(td, "eqpr.md")
+            r = subprocess.run([sys.executable, os.path.join(ROLE_DIR, "cli.py"),
+                                "build", "--out", out],
+                               capture_output=True, text=True, env=env)
+            self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+            text = open(out).read()
+            self.assertIn("draft", text.lower())
+            self.assertIn("not an approval", text.lower())
+
+    def test_cli_check_gate(self):
+        with tempfile.TemporaryDirectory() as td:
+            out = os.path.join(td, "eqpr.md")
+            subprocess.run([sys.executable, os.path.join(ROLE_DIR, "cli.py"),
+                            "build", "--out", out],
+                           capture_output=True, text=True, check=True)
+            r = subprocess.run([sys.executable,
+                                os.path.join(ROLE_DIR, "cli.py"),
+                                "check", "--file", out, "--category", "B1"],
+                               capture_output=True, text=True)
+            self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+            self.assertIn("RESULT: PASS", r.stdout)
+
+
+class TestDo160LeafCrossCheck(unittest.TestCase):
+    """Core numeric anchors vs the bound leaves' logic files (dev check,
+    skipped when the skills checkout is absent)."""
+
+    @classmethod
+    def setUpClass(cls):
+        if not HAS_SKILLS:
+            raise unittest.SkipTest("Aero Skills checkout not present")
+
+    def _core(self):
+        sys.path.insert(0, os.path.join(ROLE_DIR, "core"))
+        import do160_environmental_core as core
+        return core
+
+    def test_esd_leaf_agrees(self):
+        mod = load_leaf_logic("avionics/do160/electrostatic-discharge")
+        core = self._core()
+        self.assertIsNotNone(mod)
+        self.assertAlmostEqual(
+            mod.category_test_level_kv("A"),
+            core.esd_category_test_level_kv("A"), places=6)
+        self.assertAlmostEqual(
+            mod.stored_energy_joules(150.0, 15.0),
+            core.esd_stored_energy_joules(150.0, 15.0), places=9)
+        self.assertAlmostEqual(mod.peak_current_amps(15.0),
+                               core.esd_peak_current_amps(15.0), places=6)
+        self.assertAlmostEqual(
+            mod.rc_time_constant_ns(330.0, 150.0),
+            core.esd_rc_time_constant_ns(330.0, 150.0), places=6)
+        self.assertEqual(mod.pass_verdict(True, True),
+                         core.esd_pass_verdict(True, True))
+
+    def test_lightning_leaf_agrees(self):
+        mod = load_leaf_logic("avionics/do160/lightning-protection")
+        core = self._core()
+        self.assertIsNotNone(mod)
+        self.assertEqual(mod.test_level_in_range(3),
+                         core.lightning_level_valid(3))
+        self.assertEqual(mod.waveform_supported("C"),
+                         core.lightning_waveform_valid("C"))
+        self.assertEqual(mod.pass_verdict(False, False, False),
+                         core.lightning_pass_verdict(False, False, False))
+
+    def test_power_input_leaf_agrees(self):
+        mod = load_leaf_logic("avionics/do160/power-input")
+        core = self._core()
+        self.assertIsNotNone(mod)
+        self.assertAlmostEqual(mod.sag_depth_percent(28.0, 21.0),
+                               core.sag_depth_percent(28.0, 21.0), places=6)
+        self.assertAlmostEqual(mod.surge_height_percent(28.0, 32.2),
+                               core.surge_height_percent(28.0, 32.2),
+                               places=6)
+        ok1, d1, p1 = mod.transient_check(80.0, 20.0, 100.0, 25.0)
+        ok2, d2, p2 = core.transient_check(80.0, 20.0, 100.0, 25.0)
+        self.assertEqual((ok1, d1, p1), (ok2, d2, p2))
+        self.assertAlmostEqual(mod.ripple_percent(29.0, 27.0, 28.0),
+                               core.ripple_percent(29.0, 27.0, 28.0),
+                               places=6)
+
+    def test_rf_susceptibility_leaf_agrees(self):
+        mod = load_leaf_logic("avionics/do160/radio-frequency-susceptibility")
+        core = self._core()
+        self.assertIsNotNone(mod)
+        self.assertAlmostEqual(
+            mod.required_amp_power_for_test(100.0, 3.0, 3.0, 3.0, 6.0),
+            core.required_amp_power_for_test(100.0, 3.0, 3.0, 3.0, 6.0),
+            delta=1.0)
+        self.assertAlmostEqual(mod.cs114_limit_dbu_a("B"),
+                               core.cs114_limit_dbu_a("B"), places=6)
+        m1, o1 = mod.margin_check_dbu(60.0, 65.7)
+        m2, o2 = core.margin_check_dbu(60.0, 65.7)
+        self.assertAlmostEqual(m1, m2, places=6)
+        self.assertEqual(o1, o2)
+
+    def test_rf_emissions_leaf_agrees(self):
+        mod = load_leaf_logic("avionics/do160/radio-frequency-emissions")
+        core = self._core()
+        self.assertIsNotNone(mod)
+        self.assertAlmostEqual(mod.ce102_limit_db(150e3, "A"),
+                               core.ce102_limit_db(150e3, "A"), places=6)
+        self.assertAlmostEqual(mod.re102_limit_db(100e6, "A"),
+                               core.re102_limit_db(100e6, "A"), places=6)
+        self.assertEqual(mod.worst_case_frequency([50e3, 150e3], [8.0, 5.0])[0],
+                         core.worst_case_frequency([50e3, 150e3],
+                                                   [8.0, 5.0])[0])
+
+    def test_environmental_leaf_agrees(self):
+        mod = load_leaf_logic("avionics/do160/environmental-qualification")
+        core = self._core()
+        self.assertIsNotNone(mod)
+        self.assertEqual(mod.section_name(25), core.section_name(25))
+        self.assertEqual(mod.temperature_category_range("B1"),
+                         core.temperature_category_range("B1"))
+        self.assertEqual(mod.matrix_complete(sorted(core.SECTIONS), "B1"),
+                         core.matrix_complete(sorted(core.SECTIONS), "B1"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/do178c-cert-engineer/ROLE.md

@@ -0,0 +1,120 @@
+---
+type: role
+name: do178c-cert-engineer
+title: "DO-178C Software Certification Engineer"
+status: draft
+domain: avionics
+deliverable_type: "certification plan + verification evidence set"
+standards_bound:
+  - id: do-178c
+    tier: TIER-2
+    reference-only: true
+skills_bound:
+  - avionics/do178c/planning
+  - avionics/do178c/development
+  - avionics/do178c/verification
+  - avionics/do178c/software-testing
+  - avionics/do178c/configuration-management
+  - avionics/do178c/tool-qualification
+  - avionics/do178c/previously-developed-software
+  - avionics/do178c/data-control-coupling-analysis
+  - avionics/do178c/airworthiness-liaison
+tools_allowed: [stdlib, offline-file-processing]
+forbidden:
+  - "issue certification approval"
+  - "claim regulatory sign-off"
+  - "reproduce proprietary RTCA/EUROCAE text"
+  - "assert DAL without evidence"
+sign_off_required: true
+license: Apache-2.0
+compatibility: "agentskills.io ROLE.md; any SKILL.md host"
+metadata:
+  version: 0.1.0
+  author: Aero Agent Roles
+  skills_release: "v1.3.0+"
+---
+
+# DO-178C Software Certification Engineer
+
+## Role identity
+
+This role drives the DO-178C software certification workflow for an
+airborne software item: from planning through development, verification,
+configuration management, and the artifacts that support the Plan for
+Software Aspects of Certification (PSAC). Use when a project must produce
+DO-178C-compliant software evidence. Do NOT use for general software
+engineering (non-airborne), hardware-only items (see DO-254 role), or
+when no cert basis exists.
+
+## Deliverable contract
+
+The role produces:
+1. **PSAC (Plan for Software Aspects of Certification)** — original
+   skeleton per templates/psac-template.md: software level (DAL), life
+   cycle data, standards, tool qualification approach, verification
+   strategy, liaison with airworthiness.
+2. **Verification evidence set** — requirements-based test coverage
+   summary, data/control coupling analysis results, configuration
+   index, accomplishment summary input.
+3. **Gap report** — what is missing before the human cert engineer
+   signs.
+
+## Workflow (stages → bound skills)
+
+| Stage | Loads skill | Produces |
+|---|---|---|
+| 1. Planning | do178c/planning | PSAC draft, DAL determination input, life cycle data list |
+| 2. Dev framework | do178c/development | development standards mapping, code/data standards inputs |
+| 3. Verification strategy | do178c/verification | verification methods, coverage targets per level |
+| 4. Test evidence | do178c/software-testing | requirements-based test coverage summary |
+| 5. CM | do178c/configuration-management | configuration index input, change control notes |
+| 6. Tool qualification | do178c/tool-qualification | tool qualification level + approach |
+| 7. PDS check | do178c/previously-developed-software | PDS assessment input |
+| 8. Coupling analysis | do178c/data-control-coupling-analysis | data/control coupling results |
+| 9. Airworthiness liaison | do178c/airworthiness-liaison | liaison summary, open items for the cert authority |
+
+## Evidence gates
+
+- Stage 1 done = DAL identified WITH evidence (system safety output),
+  PSAC skeleton filled.
+- Stage 4 done = every requirement mapped to a test with pass criteria.
+- Stage 8 done = coupling analysis executed with results recorded.
+- FINAL = every section of the deliverable has a source (skill + standard
+  reference); nothing asserted without a checkable basis.
+
+## Boundary / forbidden
+
+- NEVER issue certification approval — the DER/regulator signs.
+- NEVER reproduce DO-178C text (proprietary, RTCA/EUROCAE). Summaries and
+  original structure only.
+- NEVER assert a DAL without the system-safety evidence trail.
+- Output is a DRAFT for human review — mark it draft.
+
+## Verification
+
+The role runs STANDALONE: `core/do178c_core.py` is an executable engine
+that determines DAL from failure severity, computes coverage targets,
+structural coverage, independence, life cycle data, BUILDS the PSAC, and
+gate-checks deliverables. No AeroSkills checkout required.
+
+Run the role:
+```bash
+python3 cli.py build --out psac.md                     # example item (DAL B)
+python3 cli.py build --failure-condition catastrophic  # DAL A variant
+python3 cli.py check --file psac.md --dal B            # gate-check a PSAC
+```
+
+Tests:
+- tests/test_do178c_core.py (11 tests): domain rules + PSAC builder +
+  gates + standalone (no skills repo)
+- tests/test_role_do178c.py: bound-skill resolution (skips if the skills
+  repo is absent) + workflow + template present + boundaries
+
+Bound skills in Aero Agent Skills deepen individual stages when the
+library is present (verification logic, CM, tool qualification); the
+core engine does not depend on them.
+
+## Compliance
+
+- do-178c TIER-2 reference-only per standards-map; no verbatim.
+- SOURCES.md records acquisition/extraction/verification status.

package/roles/do178c-cert-engineer/SOURCES.md

@@ -0,0 +1,16 @@
+# SOURCES.md - DO-178C Certification Engineer
+
+Standards and documents this role references. Summary-not-copy: see
+[STANDARDS.md](../../STANDARDS.md) for the full rule and purchase links.
+
+| Source | Role use | Gated |
+|---|---|---|
+| RTCA DO-178C / ED-12C | software life cycle, objectives, DAL-specific evidence | true |
+| RTCA DO-330 | tool qualification approach | true |
+| SAE ARP4754A | development assurance context (shared with systems safety) | true |
+| FAA AC 20-115D | FAA acceptance of DO-178C methods | false |
+| EASA AMC 20-115C | EASA acceptance of ED-12C methods | false |
+
+The PSAC and verification templates in `templates/` are original
+structures informed by public-domain guidance (AC 20-115D, AMC 20-115C)
+and summary process knowledge. No proprietary text is reproduced.

package/roles/do178c-cert-engineer/cli.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""cli.py - run the DO-178C Certification Engineer role.
+
+Usage:
+  python3 cli.py build --out <file.md>          # build PSAC for the example item
+  python3 cli.py check --file <file.md>         # gate-check an existing PSAC
+
+The role ENGINE (core/do178c_core.py) does the work standalone; bound
+skills in Aero Agent Skills deepen individual stages when present.
+"""
+import argparse
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "core"))
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "..", "scripts"))
+import do178c_core as core  # noqa: E402
+import evidence  # noqa: E402
+
+ROLE_SLUG = "do178c-cert-engineer"
+
+
+def _provenance() -> dict:
+    """Provenance for the PSAC bundle: role core, no skill dispatch."""
+    return {
+        "role": ROLE_SLUG,
+        "core": {
+            "file": "core/do178c_core.py",
+            "functions": ["build_psac", "check_psac", "render_psac_markdown"],
+            "version": "0.1.0",
+        },
+        "skills": [],
+        "cross_checked": False,
+        "disclaimer": "DRAFT for human review. Not an approval document.",
+    }
+
+
+def cmd_build(args):
+    item = core.example_item()
+    # allow overriding the failure condition from CLI for different DALs
+    if args.failure_condition:
+        item.failure_condition = args.failure_condition
+        item.system_safety_ref = args.safety_ref or item.system_safety_ref
+    model = core.build_psac(item)
+    md = core.render_psac_markdown(model)
+
+    # program profile (customer tailoring): load + apply context header
+    profile = None
+    try:
+        profile = evidence.load_profile(args.profile)
+    except ValueError as e:
+        print(f"error: bad profile: {e}")
+        return 1
+    if profile:
+        model["profile"] = {
+            "customer": profile.get("customer"),
+            "program": profile.get("program"),
+            "basis": profile.get("basis"),
+            "authority": profile.get("authority"),
+            "der": profile.get("der"),
+            "document_prefix": profile.get("document_prefix"),
+            "revision": profile.get("revision"),
+        }
+        md = evidence.profile_header_block(profile) + md
+
+    gates = core.check_psac(model)
+    if args.out:
+        with open(args.out, "w") as f:
+            f.write(md)
+        print(f"built PSAC (level {model['software_level']}) -> {args.out}")
+        if profile:
+            print(f"profile: {profile.get('customer')} / "
+                  f"{profile.get('program')}")
+        print(f"gates: all_pass={gates['all_pass']} {gates}")
+        if args.bundle:
+            paths = evidence.write_bundle(
+                args.out, ROLE_SLUG,
+                "Plan for Software Aspects of Certification",
+                model, gates, _provenance())
+            print(f"bundle: model={paths['model']}")
+            print(f"        gates={paths['gates']}")
+            print(f"        provenance={paths['provenance']}")
+    else:
+        print(md)
+    return 0 if gates["all_pass"] else 1
+
+
+def cmd_check(args):
+    if not os.path.exists(args.file):
+        print(f"file not found: {args.file}")
+        return 1
+    md = open(args.file).read()
+    # determine level from the doc if not given
+    dal = (args.dal or "B").upper()
+    gates = core.check_psac_markdown(md, dal)
+    for name, ok in gates.items():
+        if name != "all_pass":
+            print(f"{'PASS' if ok else 'FAIL'}  {name}")
+    print(f"RESULT: {'PASS' if gates['all_pass'] else 'FAIL'}")
+    return 0 if gates["all_pass"] else 1
+
+
+def main():
+    p = argparse.ArgumentParser(description="DO-178C Certification Engineer role")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    b = sub.add_parser("build")
+    b.add_argument("--out", default="", help="output file (default: stdout)")
+    b.add_argument("--failure-condition", default="", help="hazardous/major/minor/...")
+    b.add_argument("--safety-ref", default="", help="system safety reference")
+    b.add_argument("--bundle", action="store_true",
+                   help="emit evidence/{model,gates,provenance}.json")
+    b.add_argument("--profile", default="",
+                   help="program profile JSON (customer tailoring, "
+                        "docs/PROFILE-SCHEMA.md)")
+    b.set_defaults(fn=cmd_build)
+
+    c = sub.add_parser("check")
+    c.add_argument("--file", required=True, help="PSAC markdown file to gate-check")
+    c.add_argument("--dal", default="", help="expected software level")
+    c.set_defaults(fn=cmd_check)
+
+    args = p.parse_args()
+    sys.exit(args.fn(args))
+
+
+if __name__ == "__main__":
+    main()