aero-agent-roles 1.0.0

package/roles/airworthiness-compliance-engineer/templates/compliance-matrix-template.md

@@ -0,0 +1,46 @@
+# Airworthiness Compliance Matrix
+
+**Item:** Autopilot flight guidance system retrofit (STC)
+**Aircraft type:** transport (jurisdiction FAA)
+**Certification basis:** FAR-25
+**Certification path:** STC
+**Applicable regulations (proposed):** 25.1301, 25.1309, 25.1329, 25.671, 25.683
+**Special conditions:** none identified
+**Equivalent level of safety (ELOS) findings:** none proposed
+**Status:** draft-for-review
+**Coverage:** 100% of applicable regulations have a proposed means of compliance and compliance document
+
+## Certification basis
+
+- Aircraft/system: Autopilot flight guidance system retrofit (STC)
+- Certification basis reference (TC/STC/amendment level): FAR-25, STC
+- Applicable regulations (list with amendment): 25.1301, 25.1309, 25.1329, 25.671, 25.683 (amendment level per the basis)
+- Special conditions: none identified
+- Equivalent level of safety findings: none proposed
+
+## Compliance matrix
+
+| Reg | Applicable? | Means of compliance | Compliance document | Status (proposed/open) | Owner |
+|---|---|---|---|---|---|
+| 25.1301 (Subpart F - Equipment) | YES | ground test + engineering/analysis | Equipment installation inspection records and qualification test report (installation conformity) | proposed (severity n/a / DAL n/a) | equipment engineer |
+| 25.1309 (Subpart F - Equipment) | YES | engineering/analysis + safety assessment (safety assessment required) | System safety assessment (SSA) per 25.1309 with failure condition classification | proposed (severity hazardous / DAL B) | systems safety engineer |
+| 25.1329 (Subpart F - Equipment) | YES | engineering/analysis + safety assessment + ground test + flight test (safety assessment required) | Autopilot ground/flight test report and SSA input for the flight guidance system | proposed (severity hazardous / DAL B) | systems safety engineer |
+| 25.671 (Subpart D - Design and Construction) | YES | engineering/analysis + safety assessment (safety assessment required) | Flight control integration analysis and test report (control system failure assessment) | proposed (severity hazardous / DAL B) | flight controls engineer |
+| 25.683 (Subpart D - Design and Construction) | YES | engineering/analysis + ground test | Control system operation test report | proposed (severity n/a / DAL n/a) | flight controls engineer |
+| 25.301 (Subpart C - Structure) | NO | n/a | not required (screened out: not applicable to this change: 25.301 covers the structure area but the change scope is limited to equipment, flight-controls, systems; screened out unless the change also touches the structure area - confirm with the certification authority) | proposed (n/a) | - |
+| 25.571 (Subpart C - Structure) | NO | n/a | not required (screened out: not applicable to this change: 25.571 covers the structure area but the change scope is limited to equipment, flight-controls, systems; screened out unless the change also touches the structure area - confirm with the certification authority) | proposed (n/a) | - |
+| 25.607 (Subpart D - Design and Construction) | NO | n/a | not required (screened out: not applicable to this change: 25.607 covers the design-and-construction area but the change scope is limited to equipment, flight-controls, systems; screened out unless the change also touches the design-and-construction area - confirm with the certification authority) | proposed (n/a) | - |
+
+## Notes
+
+- Status vocabulary: proposed | open | in-work | evidence-available.
+- Every row above is a PROPOSED determination by the compliance engineer (this role). The certification authority makes the binding applicability and compliance findings.
+- NEVER mark a row "compliant/found" without evidence - that is the authority's finding, not ours.
+- Severity and DAL context are proposed inputs to the 25.1309 safety assessment, subject to the system safety process.
+
+## Open items (gap report)
+
+- No open gaps in this draft; confirm every row with the certification authority before submission.
+
+---
+*Generated by Aero Agent Roles airworthiness-compliance-engineer core (2026-09-05). DRAFT - for human compliance engineer review. Not a compliance finding or an approval.*

package/roles/airworthiness-compliance-engineer/tests/test_airworthiness_core.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Test airworthiness_core: the executable engine of the
+airworthiness-compliance-engineer role.
+
+Proves the role can DO its job standalone (no AeroSkills needed):
+applicability determination, means-of-compliance selection, compliance
+matrix generation, and evidence-gate checks.
+
+Author: ashfordeOU
+"""
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "..", "core"))
+from airworthiness_core import (  # noqa: E402
+    MOC_IDS, MOC_NAMES, REGS, SEVERITY_TO_DAL,
+    build_matrix, check_matrix, check_matrix_markdown,
+    compliance_row, determine_applicability, example_item,
+    example_matrix_markdown, moc_is_valid, moc_suitability,
+    render_matrix_markdown, safety_assessment_required, select_moc,
+    severity_to_dal,
+)
+
+
+class TestCoreDomainRules(unittest.TestCase):
+
+    def test_severity_to_dal_mapping(self):
+        self.assertEqual(SEVERITY_TO_DAL["catastrophic"], "A")
+        self.assertEqual(SEVERITY_TO_DAL["hazardous"], "B")
+        self.assertEqual(SEVERITY_TO_DAL["major"], "C")
+        self.assertEqual(SEVERITY_TO_DAL["minor"], "D")
+        self.assertEqual(severity_to_dal("hazardous"), "B")
+
+    def test_safety_assessment_rule(self):
+        # 25.1309 practice: catastrophic/hazardous/major need the SSA.
+        self.assertTrue(safety_assessment_required("catastrophic"))
+        self.assertTrue(safety_assessment_required("hazardous"))
+        self.assertTrue(safety_assessment_required("major"))
+        self.assertFalse(safety_assessment_required("minor"))
+        self.assertFalse(safety_assessment_required("no-safety-effect"))
+        with self.assertRaises(ValueError):
+            safety_assessment_required("very-bad")
+
+    def test_moc_suitability_rules(self):
+        # Structure: analysis primary, static/ground test evidence.
+        self.assertEqual(moc_suitability("structure", "n/a", "n/a"), [1, 2])
+        # Novel structure adds flight test.
+        self.assertEqual(
+            moc_suitability("structure", "n/a", "n/a", novel=True), [1, 2, 3])
+        # Hazardous systems: analysis + MOC 6 safety assessment.
+        self.assertEqual(
+            moc_suitability("systems", "hazardous", "B"), [1, 6])
+        # Equipment: qualification ground test with analysis support.
+        self.assertEqual(moc_suitability("equipment"), [2, 1])
+        with self.assertRaises(ValueError):
+            moc_suitability("quantum", "n/a", "n/a")
+
+    def test_real_regs_are_real(self):
+        # Regs in the register must be real FAR-25 paragraphs (public
+        # domain; register verified against the public eCFR titles).
+        for number, rec in REGS.items():
+            self.assertRegex(number, r"^25\.\d{3,4}$")
+            self.assertTrue(rec["title"])
+            self.assertIn(rec["subpart"], "ABCDEFGH")
+        for num in ("25.1309", "25.1329", "25.301", "25.571",
+                    "25.607", "25.683", "25.671", "25.1301"):
+            self.assertIn(num, REGS)
+
+    def test_applicability_transport(self):
+        verdict = determine_applicability("25.1309", "transport")
+        self.assertTrue(verdict["applicable"])
+        verdict2 = determine_applicability("25.1329", "transport-category")
+        self.assertTrue(verdict2["applicable"])
+
+    def test_applicability_not_transport(self):
+        # Part 25 paragraphs do not apply to a normal-category airplane
+        # (that certifies under Part 23 / CS-23).
+        verdict = determine_applicability("25.1309", "normal")
+        self.assertFalse(verdict["applicable"])
+        self.assertIn("Part 23", verdict["reason"])
+        with self.assertRaises(ValueError):
+            determine_applicability("25.1309", "airship")
+        with self.assertRaises(ValueError):
+            determine_applicability("99.9999", "transport")
+        with self.assertRaises(ValueError):
+            determine_applicability("25.9999", "transport")
+
+    def test_applicability_change_scope(self):
+        # Structure paragraphs screen out when the STC touches only
+        # systems/flight-controls/equipment.
+        scope = ["systems", "flight-controls", "equipment"]
+        self.assertTrue(
+            determine_applicability("25.1309", "transport", scope)["applicable"])
+        self.assertFalse(
+            determine_applicability("25.571", "transport", scope)["applicable"])
+        self.assertFalse(
+            determine_applicability("25.301", "transport", scope)["applicable"])
+
+
+class TestMocSelection(unittest.TestCase):
+
+    def test_select_moc_far25_vocabulary(self):
+        moc = select_moc("25.1309", "FAR-25")
+        self.assertEqual(moc["reg"], "25.1309")
+        self.assertEqual(moc["item_kind"], "systems")
+        self.assertEqual(moc["dal"], "B")          # hazardous context
+        self.assertTrue(moc["safety_assessment"])
+        # Real vocabulary words only.
+        for m in moc["methods"]:
+            self.assertTrue(moc_is_valid(m))
+        self.assertIn("analysis", moc["moc_display"])
+        self.assertIn("safety assessment", moc["moc_display"])
+
+    def test_select_moc_cs25_scheme(self):
+        moc = select_moc("25.1309", "CS-25")
+        self.assertIn("MOC", moc["moc_display"])
+        self.assertIn("MOC 6 safety assessment", moc["moc_display"])
+        # ids must all be real MOC class ids
+        for i in moc["moc_ids"]:
+            self.assertIn(i, MOC_IDS)
+
+    def test_select_moc_extras_and_novelty(self):
+        # Autopilot flight guidance is novel on the type: ground test is
+        # added; the reg carries flight test from demonstration practice.
+        moc = select_moc("25.1329", "FAR-25", novel=True)
+        self.assertIn("flight test", moc["methods"])
+        self.assertIn(2, moc["moc_ids"])   # test MOC present for novel item
+        # 25.683 operation tests carries a ground test MOC.
+        moc683 = select_moc("25.683", "FAR-25")
+        self.assertIn("ground test", moc683["methods"])
+
+    def test_moc_names_real(self):
+        self.assertEqual(MOC_NAMES[1], "engineering/analysis")
+        self.assertEqual(MOC_NAMES[5], "certification by similarity")
+        self.assertEqual(MOC_NAMES[6], "safety assessment")
+        self.assertFalse(moc_is_valid("quantum compliance"))
+        with self.assertRaises(ValueError):
+            select_moc("25.9999", "FAR-25")
+
+
+class TestMatrixBuilder(unittest.TestCase):
+
+    def test_build_matrix_example(self):
+        model = build_matrix(example_item())
+        self.assertEqual(model["certification_basis"], "FAR-25")
+        self.assertEqual(model["status"], "draft-for-review")
+        # 8 candidate regs: 5 applicable, 3 screened out.
+        self.assertEqual(model["row_count"], 8)
+        self.assertEqual(model["applicable_count"], 5)
+        self.assertEqual(model["coverage"], 1.0)
+        self.assertEqual(model["issues"], [])
+        # The applicable autopilot regs are present.
+        regs_app = {r["reg"] for r in model["rows"] if r["applicable"]}
+        self.assertEqual(regs_app,
+                         {"25.1301", "25.1309", "25.1329", "25.671", "25.683"})
+
+    def test_compliance_row_fields(self):
+        row = compliance_row("25.1309", example_item())
+        self.assertTrue(row["applicable"])
+        self.assertEqual(row["status"], "proposed")
+        self.assertEqual(row["dal"], "B")
+        self.assertTrue(row["safety_assessment"])
+        self.assertIn("System safety assessment", row["compliance_document"])
+        self.assertTrue(row["owner"])
+        # No blank fields anywhere in the row.
+        for v in row.values():
+            self.assertNotIn("___", str(v))
+
+    def test_matrix_has_no_blanks(self):
+        md = example_matrix_markdown()
+        self.assertNotIn("___", md)
+        self.assertGreater(len(md), 1500)
+
+
+class TestGates(unittest.TestCase):
+
+    def test_core_gates_all_pass(self):
+        model = build_matrix(example_item())
+        gates = check_matrix(model)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_core_gates_fail_on_missing_doc(self):
+        model = build_matrix(example_item())
+        # Break a row: applicable reg without a compliance document.
+        row = next(r for r in model["rows"] if r["applicable"])
+        row["compliance_document"] = ""
+        gates = check_matrix(model)
+        self.assertFalse(gates["all_pass"])
+        self.assertFalse(gates["all_applicable_have_doc"])
+
+    def test_core_gates_fail_on_found_status(self):
+        model = build_matrix(example_item())
+        model["rows"][0]["status"] = "compliant"
+        gates = check_matrix(model)
+        self.assertFalse(gates["all_pass"])
+        self.assertFalse(gates["statuses_honest"])
+
+    def test_markdown_gates_all_pass(self):
+        md = example_matrix_markdown()
+        gates = check_matrix_markdown(md)
+        self.assertTrue(gates["all_pass"], gates)
+
+    def test_markdown_gates_fail_on_blank(self):
+        md = example_matrix_markdown().replace("## Compliance matrix",
+                                               "## Compliance ___ matrix")
+        gates = check_matrix_markdown(md)
+        self.assertFalse(gates["all_pass"])
+        self.assertFalse(gates["no_blank_fields"])
+
+    def test_standalone_no_skills_repo(self):
+        # Core must work with no AeroSkills present.
+        os.environ["AEROSKILLS_DEV"] = "/nonexistent"
+        model = build_matrix(example_item())
+        self.assertTrue(model["row_count"] >= 5)
+        self.assertTrue(model["coverage"] >= 0.5)
+        md = render_matrix_markdown(model)
+        self.assertGreater(len(md), 1500)
+        self.assertTrue(check_matrix_markdown(md)["all_pass"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/airworthiness-compliance-engineer/tests/test_role_airworthiness.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Role test: Airworthiness Compliance Engineer.
+
+Offline verification:
+1. Every bound skill resolves in aero-agent-skills.
+2. Workflow stage order deterministic + complete.
+3. Compliance matrix template has the required columns/rows.
+4. Boundaries + sign-off present.
+"""
+import os
+import re
+import unittest
+
+ROLES_REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))
+AEROSKILLS = os.environ.get("AEROSKILLS_DEV", os.path.expanduser("~/AeroSkills"))
+# Bound-skill resolution requires the Aero Agent Skills checkout (cross-repo
+# dev check); skip when absent so fresh public clones can still run make validate.
+HAS_SKILLS = os.path.isdir(os.path.join(AEROSKILLS, "skills"))
+ROLE_DIR = os.path.join(ROLES_REPO, "roles", "airworthiness-compliance-engineer")
+MATRIX = os.path.join(ROLE_DIR, "templates", "compliance-matrix-template.md")
+
+EXPECTED_BOUND = [
+    "avionics/far-cs25/airworthiness",
+    "avionics/far-cs25/special-conditions",
+    "systems-engineering-safety/certification/certification-basis",
+    "systems-engineering-safety/certification/equivalent-level-of-safety",
+    "systems-engineering-safety/certification/means-of-compliance",
+    "systems-engineering-safety/certification/mmel-development",
+    "systems-engineering-safety/continued-airworthiness/airworthiness-directive-compliance",
+    "systems-engineering-safety/continued-airworthiness/type-certificate-data-sheet",
+    "systems-engineering-safety/continued-airworthiness/in-service-safety-assessment",
+]
+
+STAGES = ["Certification basis", "Special conditions", "ELOS",
+          "Means of compliance", "Airworthiness mapping", "MMEL",
+          "Continued airworthiness", "Compliance matrix"]
+
+
+def role_text():
+    p = os.path.join(ROLE_DIR, "ROLE.md")
+    return open(p).read() if os.path.exists(p) else None
+
+
+class TestAirworthinessRole(unittest.TestCase):
+
+    def test_bound_skills_resolve(self):
+        if not HAS_SKILLS:
+            self.skipTest("Aero Agent Skills checkout not present (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)
+        idx = [role.find(s) for s in STAGES]
+        self.assertTrue(all(i >= 0 for i in idx))
+        self.assertEqual(idx, sorted(idx), "stage order not deterministic")
+
+    def test_matrix_columns_present(self):
+        if not os.path.exists(MATRIX):
+            self.fail("compliance-matrix-template.md missing")
+        text = open(MATRIX).read()
+        for col in ["Reg", "Applicable?", "Means of compliance",
+                    "Compliance document", "Status", "Owner"]:
+            self.assertIn(col, text, f"column missing: {col}")
+        self.assertIn("proposed", text.lower())
+
+    def test_boundaries(self):
+        role = role_text()
+        self.assertIsNotNone(role)
+        for phrase in ["declare a compliance finding", "claim certification approval",
+                       "sign_off_required: true"]:
+            self.assertIn(phrase, role)
+
+    def test_sources_register(self):
+        self.assertTrue(
+            os.path.exists(os.path.join(ROLE_DIR, "SOURCES.md")),
+            "SOURCES.md missing")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/roles/as9100-quality-auditor/ROLE.md

@@ -0,0 +1,128 @@
+---
+type: role
+name: as9100-quality-auditor
+title: "AS9100 Quality / Internal Auditor"
+status: draft
+domain: manufacturing-quality
+deliverable_type: "audit plan + findings report + corrective-action follow-up"
+standards_bound:
+  - id: as9100
+    tier: TIER-2
+    reference-only: true
+skills_bound:
+  - manufacturing-quality/as9100/internal-quality-audit
+  - manufacturing-quality/as9100/document-control
+  - manufacturing-quality/as9100/management-review
+  - manufacturing-quality/as9100/nonconformance-control
+  - manufacturing-quality/as9100/corrective-action
+  - manufacturing-quality/as9100/risk-management
+  - manufacturing-quality/as9100/supplier-control
+  - manufacturing-quality/as9100/order-requirements-review
+  - manufacturing-quality/as9100/calibration-control
+  - manufacturing-quality/as9100/counterfeit-prevention
+  - manufacturing-quality/as9100/fod-control
+  - manufacturing-quality/as9100/quality
+  - manufacturing-quality/as9102/first-article-inspection
+  - manufacturing-quality/as9102/delta-fai
+  - manufacturing-quality/as9102/fai-revalidation
+tools_allowed: [stdlib, offline-file-processing]
+forbidden:
+  - "issue certification"
+  - "claim audit closure"
+  - "recommend supplier approval"
+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+"
+---
+
+# AS9100 Quality / Internal Auditor
+
+## Role identity
+
+Plans and executes an AS9100 quality-management-system internal audit:
+scope, criteria, evidence collection against the standard's clauses,
+findings classification, and corrective-action follow-up. Use when a
+manufacturing/supplier site must demonstrate QMS conformity (internal
+audit, supplier audit prep, management-review input). Do NOT use for
+design/engineering work, or for external certification audits (that is a
+certification body's role).
+
+## Deliverable contract
+
+1. **Audit plan** — scope, criteria (AS9100 clauses + customer/supplier
+   requirements), schedule, auditee areas.
+2. **Findings report** — nonconformities classified (major/minor/
+   observation) with objective evidence + clause references.
+3. **Corrective-action follow-up** — root-cause verification, action
+   tracking, closure recommendation (for human QA sign-off).
+
+## Workflow (stages → bound skills)
+
+| Stage | Loads skill | Produces |
+|---|---|---|
+| 1. Audit planning | as9100/internal-quality-audit | audit plan, criteria, scope |
+| 2. Document control check | as9100/document-control | doc-control evidence review |
+| 3. Management review check | as9100/management-review | MR input/output evidence |
+| 4. Risk + ops review | as9100/risk-management + quality | operational risk evidence |
+| 5. Nonconformance + corrective action | as9100/nonconformance-control + corrective-action | NC handling evidence, CA effectiveness |
+| 6. Supplier + purchasing | as9100/supplier-control + order-requirements-review | supplier control evidence |
+| 7. Calibration + counterfeit + FOD | as9100/calibration-control + counterfeit-prevention + fod-control | special-process evidence |
+| 8. FAI (AS9102) | as9102/first-article-inspection + delta-fai + fai-revalidation | FAI evidence for product audit |
+| 9. Findings + report | (all above) | findings report + CA follow-up |
+
+## Evidence gates
+
+- Stage 1 done = audit plan states scope + criteria + schedule.
+- Stage 5 done = every NC has clause ref + objective evidence.
+- FINAL = findings classified; closure recommendation is PROPOSED (the
+  QA manager/auditor signs closure).
+
+## Boundary / forbidden
+
+- NEVER issue certification (external cert bodies do that).
+- NEVER claim audit closure without human sign-off.
+- NEVER recommend supplier approval/disapproval — report evidence only.
+- AS9100 is proprietary (IAQG) — TIER-2 reference-only, no verbatim.
+
+## Verification
+
+The role runs STANDALONE: `core/as9100_core.py` is an executable engine
+that classifies each nonconformity on the finding ladder (major/minor/
+observation with systemic and detection/containment escalation),
+scores corrective-action records on the closure chain (containment ->
+root cause -> corrective action -> effectiveness), sizes the record
+sample, computes the next audit due date from the process risk
+category, BUILDS the findings report, and gate-checks deliverables. No
+AeroSkills checkout required.
+
+Run the role:
+```bash
+python3 cli.py build --out findings.md              # example supplier audit
+python3 cli.py build --risk-category low --out f.md # low-risk variant
+python3 cli.py check --file findings.md             # gate-check a report
+```
+
+Tests:
+- tests/test_as9100_core.py (22 tests): classification ladder +
+  corrective-action chain + audit program numbers + findings builder +
+  gates + no-blanks render + standalone (no skills repo)
+- tests/test_role_as9100.py: bound-skill resolution (skips if the
+  skills repo is absent) + workflow + filled template fields +
+  boundaries
+
+`templates/findings-report-template.md` is the FILLED, generated
+deliverable for the example audit (2 major, 2 minor, 1 observation,
+zero blanks) — produced by `cli.py build --out`.
+
+Bound skills in Aero Agent Skills deepen individual stages when the
+library is present (audit scheduling, disposition, calibration,
+corrective action); the core engine does not depend on them.
+
+## Compliance
+
+- as9100 TIER-2 reference-only; as9102 same family.
+- SOURCES.md records acquisition/extraction/verification status.

package/roles/as9100-quality-auditor/SOURCES.md

@@ -0,0 +1,16 @@
+# SOURCES.md - AS9100 Quality / Internal Auditor
+
+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 |
+|---|---|---|
+| AS9100D | QMS requirements (the audit criteria) | true |
+| AS9102 | First Article Inspection (product audit) | true |
+| ISO 19011 | audit program and evidence discipline | true |
+| ISO 9001:2015 | QMS baseline that AS9100 extends | true |
+| IAQG public guides | supplier guidance and FAQs | false |
+
+The findings report template in `templates/` cites clause numbers, not
+standard text - the same practice real audit reports follow. Clause
+references are identifiers, not reproduction.

package/roles/as9100-quality-auditor/cli.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""cli.py - run the AS9100 Quality / Internal Auditor role.
+
+Usage:
+  python3 cli.py build --out <file.md>          # build the findings report for the example audit
+  python3 cli.py build --out <file.md> --bundle # + evidence/{model,gates,provenance}.json
+  python3 cli.py build --out <file.md> --bundle --profile <profile.json>
+                                                # + program profile (audited supplier context,
+                                                #   docs/PROFILE-SCHEMA.md)
+  python3 cli.py check --file <file.md>         # gate-check an existing findings report
+
+The role ENGINE (core/as9100_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 as9100_core as core
+import evidence  # noqa: E402
+
+ROLE_SLUG = "as9100-quality-auditor"
+
+
+def _provenance():
+    """Provenance for the evidence bundle: role core functions used."""
+    return {
+        "role": ROLE_SLUG,
+        "core": {
+            "file": "core/as9100_core.py",
+            "functions": ["classify_nc", "corrective_action_status",
+                          "audit_sample_size", "audit_due_date",
+                          "audit_findings", "check_findings"],
+            "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()
+    if args.risk_category:
+        item.process_risk = args.risk_category
+    if args.audit_date:
+        item.audit_date = args.audit_date
+    model = core.audit_findings(item)
+    md = core.render_findings_markdown(model)
+
+    # program profile (audited supplier context): 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_findings(model)
+    if args.out:
+        with open(args.out, "w") as f:
+            f.write(md)
+        print("built findings report for %s -> %s" % (model["supplier"],
+                                                      args.out))
+        if profile:
+            print("profile: %s / %s" % (profile.get("customer"),
+                                        profile.get("program")))
+        print("counts: %s" % model["counts"])
+        print("gates: all_pass=%s %s" % (gates["all_pass"], gates))
+        if args.bundle:
+            paths = evidence.write_bundle(
+                args.out, ROLE_SLUG,
+                "AS9100 internal audit findings report", model, gates,
+                _provenance())
+            print("bundle: model=%s" % paths["model"])
+            print("        gates=%s" % paths["gates"])
+            print("        provenance=%s" % 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("file not found: %s" % args.file)
+        return 1
+    md = open(args.file).read()
+    gates = core.check_findings_markdown(md)
+    for name, ok in gates.items():
+        if name != "all_pass":
+            print("%s  %s" % ("PASS" if ok else "FAIL", name))
+    print("RESULT: %s" % ("PASS" if gates["all_pass"] else "FAIL"))
+    return 0 if gates["all_pass"] else 1
+
+
+def main():
+    p = argparse.ArgumentParser(description="AS9100 Quality / Internal Auditor 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("--risk-category", default="",
+                   help="low/medium/high process risk")
+    b.add_argument("--audit-date", default="", help="audit date ISO YYYY-MM-DD")
+    b.add_argument("--bundle", action="store_true",
+                   help="emit evidence/{model,gates,provenance}.json")
+    b.add_argument("--profile", default="",
+                   help="program profile JSON (audited supplier context, "
+                        "docs/PROFILE-SCHEMA.md)")
+    b.set_defaults(fn=cmd_build)
+
+    c = sub.add_parser("check")
+    c.add_argument("--file", required=True,
+                   help="findings report markdown file to gate-check")
+    c.set_defaults(fn=cmd_check)
+
+    args = p.parse_args()
+    sys.exit(args.fn(args))
+
+
+if __name__ == "__main__":
+    main()