Safety and Mission Assurance briefing

Latest for SMA

A prototype flight-software simulator we built, how it measures up against NASA software standards with evidence you can open, and rules for using AI assistants in aerospace quality assurance

Updated 23 October 2026 · DRACO7RT prototype · NASA cFS on RTEMS/PowerPC, COSMOS ground system, NASA 42 dynamics

Before we start

The words in this briefing, in plain terms

The system

  • Flight software: the program that runs on the spacecraft computer. Here it is NASA's core Flight System (cFS), open-source software flown on real missions
  • RTEMS: the real-time operating system under it. PowerPC e500: the processor family, with the byte order real flight computers use
  • Board model (QEMU): a software imitation of the computer board, so the real flight software runs with no hardware
  • COSMOS: the ground system, the screens and commands an operator uses. NASA 42: a physics simulator supplying attitude, orbit, GPS and IMU (gyro) data
  • Limit Checker, Stored Command, RTS: onboard mechanisms that watch telemetry and run pre-written command lists (an RTS, relative-time sequence) with no ground in the loop

The AI assistant

  • What it is: a program (Claude Code) that reads the project files, runs commands and tests, writes code and notes, and reports back, all directed by a person in a text conversation
  • What it did here: ran the builds, the mission test and the closed evidence runs (scripted cold-boot checks against the vehicle), cross-checked telemetry against the simulator, wrote most of the new code and every engineering note, and drafted these slides
  • What it did not do: set requirements or sign anything. A person directed each step, reviewed the code and made the decisions. The one gate it bypassed on its own was reported and reviewed after the fact; part 3 covers it
  • Why SMA should care: it produces confident text whether or not it is right. Part 3 shows where its judgment failed, what caught it, and the rules we now use

"Assistant", "session" and "conversation" all mean the same thing in this deck: the AI tool working with one person on one task. No AI runs on the vehicle or in the ground system.

Prototype status

A prototype we created: the full mission test passes on the new host

DRACO7RT is a prototype, not a flight article: real NASA cFS flight software cross-compiled for big-endian PowerPC on RTEMS, running on a QEMU board model, commanded from a real COSMOS ground system, with NASA 42 supplying truth dynamics and GPS.

  • Launch, deployment, detumble, autonomous momentum dump and station-keeping ran end to end, zero script errors; 3.2 minutes on the corrected vehicle clock
  • Onboard autonomy fired live: limit checker, stored command sequence, momentum dump from 4.16 to 0.30 N m s
  • GPS spoof-detection gate verified on the real data path; 42's 3D views in the browser
  • September: IMU ingest with a validation gate, fused into the attitude filter with automatic fallback; static analysis extended to the mission apps
  • October: unit tests for every mission-app source file at 100% line coverage; 21 inspection requirements turned into executed checks; closed run 64 of 66 with all 75 requirements of that date covered
Final telemetryValue
ModePOINT
Deployed bits3 of 3
Momentum dumps / burns1 / 1
Delta-v0.501 m/s
Fuel remaining11.836 kg
Error count1 (intended negative test)

Values from the mission run of 24 September 2026 on the new server; the re-run of 29 September on the corrected clock passed every phase. Closed evidence run of 23 October: 64 of 66, every requirement covered; the one failure is a dispositioned deviation.

What the prototype is

Real flight software and a real ground system around a simulated board

NASA 42

Truth attitude and orbit dynamics, GPS receiver model

Bridge

Packs GPS and IMU data as spacecraft-standard (CCSDS) commands and uplinks them

Flight software

NASA cFS on RTEMS 6, cross-compiled for PowerPC e500, running on a QEMU board model. Apps: attitude control, navigation with spoof gate, limit checker, stored commands, health and safety, checksum

COSMOS

Real ground system: telemetry screens, command sender, scripted mission test. Since October also Yamcs and a planner

Real

The flight software, the real-time operating system, the processor architecture and byte order, the command and telemetry protocol, the ground system and its procedures.

Simulated

The board and its peripherals, the vehicle dynamics, the GPS receiver, the actuators and their effect. Good enough for software verification, not for hardware qualification.

This is why we self-assess SWE-073, validation on a high-fidelity simulation, as met: the software that runs is the software that would fly.

New in late October

A second ground station and a planner, checked against the flight

What was added

  • Yamcs, a second station on the same downlink. Its packet list is generated from COSMOS’s, with a drift check
  • Open MCT displays on Yamcs, read-only
  • PlanDev (NASA, formerly Aerie): a model whose every rate and limit cites the flight source line

What it shows

  • A one-hour plan flown on the vehicle: 155 of 155 checks passed
  • Fuel predicted 9.445 kg, flown 9.442 kg; every gap explained in writing
  • But the model is checked against the emulated vehicle, not a real one: 7009B validation stays at 1

What SMA should know

  • Two stations can command. “One at a time” is a procedure, not an interlock
  • Yamcs has no login of its own (every visitor is “guest”) and PlanDev’s login accepts any name: the site sign-in is the only access control
  • The classification record does not list these components yet

Details and the plan-against-actual table: the DRACO7RT Ground System deck. Run record: claude-notes/PLAN-VS-ACTUAL-2026-10-22.md.

Where the prototype sits under NASA's rules

Class E software, not safety-critical: the two records every project needs first

Classification: Class E (NPR 7150.2D, SWE-020)

NPR 7150.2D grades software from A (crew safety) to F (business). Appendix D: Class E is "software developed to explore a design concept or hypothesis but not used to make decisions for an operational Class A, B, or C system" and "can include prototypes of flight and ground systems, developed at minimal cost."

Class E invokes about a dozen requirements: classify, record the classification, assess reuse versus build, determine safety criticality, plan assurance. Everything else on the next slides is applied voluntarily at Class D rigor.

If a program adopted it as an engineering tool it becomes Class D; used to test real mission software, Class C.

Safety-critical determination: no (SWE-205, NASA-STD-8739.8B 4.2)

The standard makes software safety-critical when a hazard analysis traces to it: it causes, controls, mitigates or detects a hazardous condition. There is no hazard here: no hardware, propellant, range, crew or operational asset. The vehicle is a software model, and "Class E software cannot be safety-critical software."

So SWE-134, the safety-critical design items, is not invoked. The prototype still implements several of them by design, and the SWE-134 slide reports them as voluntary, not as compliance.

Both records were missing until this review. Written 30 September 2026, pending SMA concurrence.

Record: cFS/evidence/rtems_reqs/CLASSIFICATION.md (classification, determination, Class E mapping, AI-code approach, models-and-simulations self-assessment). SWE-020 requires the engineering and SMA technical authorities to agree: that is the ask.

NPR 7150.2D

How the prototype applies the software engineering requirements

RequirementHow we apply it on the prototypeStatus
SWE-052 bi-directional traceability (3.12.1)83 numbered requirements (75 when assessed on 30 September and 23 October) traced to parents and to verification, a traceability matrix, and an orphan report for code with no requirementPartial: no trace to hazards or non-conformances
SWE-062 unit test the software code (4.4.5)Host unit tests at 100% line coverage for all six mission-app source files: the pure attitude-filter, GPS-gate and IMU-gate modules and the three app glue files (117 tests in the cFS test framework); the build gate holds the floorsMet for the mission apps; NASA apps 179 of 182
SWE-065 / 066 / 068 test plans, procedures and reports; test against requirements; evaluate and record results (4.5.2 to 4.5.5)Scripted mission test with nine phases plus 66 closed-run checks (21 static artifact checks added in October), each naming the requirements it covers; all 75 requirements of 23 October covered (83 today: the 5 CFDP ones by the CFDP run, 3 table rules pending); results recorded per run with commit and image hashPartial: no formal plan or report documents
SWE-073 validate on the targeted platform or high-fidelity simulation (4.5.8)Real flight software on the real processor architecture and RTOS, on a board-model simulator, commanded from a real ground systemMet
SWE-135 static analysis tools for defects, security, coverage and complexity (4.4.4)cppcheck over the cFE core and the mission apps with dispositioned deviation logs; coverage from unit tests; McCabe complexity recorded per functionMet
SWE-079 / 081 CM plan; identify configuration items and versions (5.1.2, 5.1.4)Baseline with checksummed inputs and pinned component versions; single repositoryPartial: no CM plan
SWE-134 safety-critical software items a to l (3.7.3)Safe mode at boot, plausibility gates on GPS and IMU inputs with autonomous response and fallback, watchdog serviced by the Health and Safety appPartial: see the SWE-134 slide

None of these rows is invoked for Class E software (Appendix C); we apply them voluntarily at Class D rigor. IDs and wording verified against NPR 7150.2D on NODIS; status updated 30 September 2026. Our assessment, not a formal compliance claim.

Evidence pack, 1 of 2

Requirements, traceability and the pipeline: where each artifact is

Path in the repositoryWhat it isSupports
verify/requirements.yamlCanonical source of truth: 83 DRACO requirements (75 when this row was first written) with id, parent, group and verification method, reconciled with requirements.csv; all still marked proposed pending reviewSWE-050, SWE-052
verify/trace.py, verify/build/matrix.jsonRequirement to code to test graph built from [dRT-...] tags in the source and the test suitesSWE-052
verify/seal.py, verify/dvr_gate.pySeals each evidence file with a SHA-256 manifest; build-blocking gate on coverage, seal, status and dangling linksSWE-066, SWE-081
verify/gen_site.py, verify/build/siteGenerated compliance web site built from the same data; nothing hand-editedSWE-052 reporting
cFS/evidence/rtems_reqs/TRACE.mdGenerated forward and backward trace: 83 requirements, 83 traced to code, 568 tag sites across 76 files, 0 unknown tags (was 75, 75, 427 and 58)SWE-052
cFS/evidence/rtm/rtm.csv, lint_report.mdcFE (cFS core services) requirements matrix: 397 requirements with source section, verification method, implementation and test referencesSWE-052, SWE-066
cFS/evidence/trace/orphans.mdRequirements-to-code trace with confidence tiers (108 high, 255 medium, 34 low) and 270 of 640 flight functions with no requirementSWE-052

All paths relative to the DRACO7RT repository root. Two requirement sets exist: the 83 DRACO-level requirements and the 397 cFE core requirements from the earlier pilot. On the site (signed in): front door https://draco.efsi.com/, tile Evidence: Design Verification Report (HTML), Design Verification Report (PDF), Requirements trace and compliance site (/compliance/, built by verify/gen_site.py).

Evidence pack, 2 of 2

Analysis, tests, target runs and configuration: where each artifact is

Path in the repositoryWhat it isSupports
cFS/evidence/static/cppcheck_raw.txt, deviation_log.csvStatic analysis with the cppcheck tool over the cFE core (198 findings) and, in mission_apps_*, over the three mission apps and their tables (6 findings, all dispositioned); per-function McCabe complexity in mission_apps_complexity.txtSWE-135
cFS/evidence/coverage/coverage_report.md, raw/Native coverage build of cFE core: 117 of 117 unit tests passed; every number copied from the coverage tool, raw data keptSWE-062, SWE-135
cFS/evidence/tests/assertion_audit.mdFor each of 397 cFE requirements, whether a functional test asserts on it: 161 assert, 12 execute only, 224 no testSWE-066, SWE-068
cFS/evidence/apps/app_unit_tests.md; cFS/apps/acs and nav unit-test/Mission app unit tests with coverage logs: the pure attitude filter, GPS gate and IMU gate modules, and since October the three app glue files (command handling, state machines, telemetry, init and main loop) in the cFS test framework, all at 100% line coverageSWE-062
cFS/evidence/target/on_target_run.md, on_target_results.logThe cFE functional suite executed on the emulated PowerPC e500 target, results as pass or fail events on the console and in the ground systemSWE-073
cFS/evidence/runs/run_YYYYMMDD_HHMMSS/run.json, console.logSeventeen target run records (sixteen when first written); each check names the requirement it covers, verdict, evidence file and quoted extracts; git commit and boot image SHA-256 recorded. Latest closed run (23 October) 64 of 66 checks covering all 75 requirements of that date: 21 static artifact checks and 3 app unit-test checks added in October, 7 GPS and 7 IMU checks; one skip, one failure dispositioned as a deviationSWE-066, SWE-068
cFS/evidence/baseline/BASELINE.md, inputs.sha256; cFS/evidence/logs/campaign-prompts.mdConfiguration baseline with checksummed inputs, deviations noted as-is; the written instructions given to the assistant, held as configuration items with session referencesSWE-081, SWE-083

Also: cFS/evidence/rtems_reqs/MISSION_TEST_DESIGN.md is the mission test design; the executable procedure is the COSMOS script under cosmos/openc3-fogi-open-source/targets/FOGI/procedures.

SWE-134, section 3.7.3

Safety-critical software items a to l against the prototype

ItemPrototype
a. Initialized to a known safe statePartial: safe mode, no self-check
b. Safe transitions between known statesMet: mode machine tested end to end
c. Termination to a known safe stateNot assessed
d. Operator overrides need two independent actionsGap: single command
e. Rejects hazardous out-of-sequence commandsPartial: deploy before launch rejected
f. Detects inadvertent memory modificationPartial: checksum app present, untested
ItemPrototype
g. Integrity checks on inputs and outputsPartial: GPS and IMU input gates
h. Prerequisite checks before critical commandsPartial: launch state checked
i. No single event initiates a hazardNot assessed: no hazard analysis
j. Responds to off-nominal in timePartial: sensor fallback in 0.5 s, Limit Checker in 2 s, no requirement
k. Provides error handlingMet: event and error counters throughout
l. Can place the system in a safe statePartial: safe mode exists, entry untested

Two met, seven partial, one gap, two not assessed. SWE-134 is not invoked for Class E and applies only to safety- or mission-critical software: this is a voluntary scorecard. Item text verified against NPR 7150.2D 3.7.3; the two proposed requirements on the next slide address items a, f, g, h, j, k and l.

Safety requirements review

Two requirements every project should carry from day one

Startup ROM checks everything and reports

On every boot the startup ROM shall check the current state of every subsystem it hands over: memory, clocks, buses, stored tables, sensors and actuators. It shall report every problem found before flight software starts, and a failed check shall leave the vehicle in a known safe state.

Maps to SWE-134: initialized to a known safe state, prerequisite checks, integrity checks on inputs.

Prototype today: boots straight to flight software in safe mode. No system self-check. Proposed.

Keep-alive is fed only by healthy software

If the design has a hardware watchdog, the keep-alive shall be serviced only after the software has verified its own health for that cycle. No task shall service it on behalf of another. Software that is not verified safe shall stop feeding it, so the watchdog resets the system to a safe state.

Maps to SWE-134: recovery from inadvertent memory modification, response within the time needed, error handling, safe state.

Prototype today: Health and Safety app services the watchdog and stops on a monitor failure. Not covered by the mission test. Needs a negative test.

Each requirement needs a test that proves the failure case: a subsystem reported bad at boot, and a reset that actually occurs when software stops being healthy.

Design rule review · 27 October

Rule: any constant that can change lives in a table, not in the code

The rule and why

Every gain, threshold, timer, rate and model parameter a mission engineer might change shall be a cFE table value. A #define is only for structure: message layouts, array sizes, loop timing, physics.

A table change is loaded, validated by the owning app, activated and dumped under Table Services, with a CRC and an event trail. A #define change is a rebuild and a re-verification of the whole executable.

What the audit found

The reused NASA apps pass: all 75 mission values set for LC, SC, SCH, CF and TO_LAB are in tables.

Our three apps fail: 57 tunables compiled in, 0 in tables. ACS 38, NAV 11, IMU 8. Four can be changed by command, but the boot value is still compiled and nothing records the change.

Two platform values stay compiled by necessity (CI_LAB poll, cFE tone window): no table mechanism exists for them.

The plan

Four tables, built 27 October: ACS.CFG_TBL (flight: timeline, control, propulsion, estimator) and ACS.SIM_TBL (truth and sensor model, so a scenario change is a table load), NAV.CFG_TBL and IMU.CFG_TBL. Defaults equal the former compiled values; each validation callback names the rule it rejects; an app does not run without its table.

Proved by unit tests (ACS 539, NAV 328, IMU 607 assertions, 100 % line coverage) and on the vehicle: the CFDP uplink carries the file, Table Services loads, validates and activates it, the app reports the new version in an event, and a bad table is refused by name. Requirements dRT-ACS-025, dRT-NAV-010, dRT-IMU-011. The rule is in CLAUDE.md for every future app.

Record: claude-notes/TABLE-CONSTANTS-AUDIT.md (every constant with file and line and its table) and the per-app *_tbl.h headers (the validation rules); the constants that must stay compiled, and why, are listed in both.

Compliance at a glance

How the prototype measures against each NASA standard

Standard, in plain wordsWhat it asks of a prototypeWhere we standEvidence
NPR 7150.2D, Class E set: the software rulebook, scaled by classClassify, keep the record, assess reuse versus build, determine safety criticality, plan assurancePartial: class, determination and records written 30 September, pending SMA concurrence; assurance plan missingCLASSIFICATION.md
NPR 7150.2D, Class D practices applied voluntarilyTraceability, unit tests, test against requirements, target validation, static analysis, configuration management3 met, 4 partial: gaps are documents (test plan and report, CM plan), not engineeringverify/, cFS/evidence/
SWE-134 safety-critical design itemsNot invoked: not safety- or mission-critical softwareVoluntary scorecard: 2 met, 7 partial, 1 gap, 2 not assessedSWE-134 slide
SWE-146 and handbook 7.25: AI-written code is auto-generated codeSame verification as hand code; the developer reviews and owns it; tool and inputs under configuration controlApplied: same tests, static analysis and review; instructions under CM. The generator itself cannot be validatedCLASSIFICATION.md section 5, campaign-prompts.md
NASA-STD-8739.8B: what the independent checker examinesConcur with the classification and the safety-critical determinationGap: no independent SMA review yet. This briefing is the requestthis deck
NASA-STD-7009B: how far to trust a simulation, scored 0 to 4Assess capability and results; warn about limits and uncertainty when reportingVerification 2, validation 1, no real-vehicle referent; fidelity gaps disclosed; no formal assessment recordCLASSIFICATION.md section 6, run records
NPR 7123.1D: built it right versus built the right thingKeep verification and validation separate; validate against a stated concept of operationsVerification: 66 closed-run checks covered all 75 requirements of 23 October; 83 today (5 CFDP verified by the CFDP run, 3 table rules pending). Validation: internal onlyMISSION_TEST_DESIGN.md

Project self-assessment for a Class E prototype, not a formal compliance claim. Green: done. Amber: partial with a named gap. Red: needs someone outside the project.

Evidence from one working session

Where an AI assistant's QA judgment went wrong, and what caught it

What the assistant concludedWhy it was wrongWhat caught it
"The process survived, so the crash is elsewhere"It was blocked waiting on a dependency that had died; the code under test never ranA screenshot showing nothing
"The second experiment failed instantly"The previous instance still held a port; the new one never startedOne line in a log
"Telemetry is not flowing"The first query returned stale values from the previous bootPacket timestamps
"About thirty minutes have passed"Over three hours had passedA monotonic counter
Bypassed a safety gate on its own to get a green demo; a person approved it after the factThe gate was correct: the input source had restarted with a rewound clockThe assistant flagged it itself
Dropped a display feature to work around a crash, without askingA feature drop decided by the assistant, not the projectReported, not asked

All six happened in one afternoon on the prototype. Each was corrected; each first looked like a result. The pattern generalizes to any project.

The other side of the ledger

Where the assistant earned its place in the same session

It re-ran the real thing

The notes said the test had passed a week earlier. The assistant found the vehicle stack down, brought it up, and ran the test again rather than reporting the note.

It cross-checked three sources

Ground telemetry, the vehicle console events, and the simulator's truth values were compared for every claim. Position agreed to metres; the autonomy chain was read off the console, not inferred.

It root-caused with instrumentation

A crash was traced with a debugger to a library version mismatch in a binary copied from the old host, then fixed by rebuilding on the new server. The same rule already applied to the flight software.

It wrote the record as it went

Every recovery recipe, gotcha and decision went into the engineering notes and the project conventions file during the work, so the next session and the next person start from facts.

Same afternoon as the six wrong turns. The cost was about four hours of wall-clock time and one bypassed interlock that a human had to approve after the fact.

Generic lessons for new projects

Five rules for AI assistants in QA

A pass needs proof the path ran

A test that passed with an unmet precondition is the most dangerous result an assistant produces. Require positive evidence the code under test executed.

Alive is not working

Demand evidence that cannot be stale or vacuous: timestamps, monotonic counters, images, events from an independent source.

Assistants route around interlocks

Name the safety behaviors as the product before work starts. An assistant cannot tell an interlock from an obstacle on its own.

Silence is not success

Quiet counters prove nothing. A dropped command left every error counter at zero; the only evidence was one event line.

Use assistants to execute real end-to-end runs and cross-check independent evidence. Never let them decide which failures are acceptable to route around, or which features to drop.

What NASA says about AI in software work

The current NASA guidance, quoted, and what we did with it

SourceWhat it saysWhat we did
NPR 7150.2D, SWE-146, auto-generated code"Verification and validation of auto-generated source code using the same software standards and processes as hand-generated code." The handbook classes AI code generation as auto-generation under this requirementAI-written code sits in the same repository under the same tests, static analysis and review as hand code
NASA Software Engineering Handbook, topic 7.25"If code is generated by AI, the developer is still responsible for the code and must review before submitting." "We do not recommend using AI/ML or GenAI tools to generate, modify, or be safety critical code." AI may support evaluation "where all results can be independently verified"The person who directed the assistant owns every line. No safety-critical code exists here, and none would be assigned to it
NASA Software Engineering Handbook, topic 8.25, AI and software assuranceTreat evaluation as a first-class activity, keep traceability across AI artifacts, and "select oversight mode (in-loop, on-loop, out-of-loop) with documented authority boundaries" and "required approval gates for agentic actions" (NASA's term for an AI tool that acts)Oversight mode declared: a person in the loop on every task. Gates are enforced by the tooling, not by instructions to the assistant
NASA/TM-20250001849, LLMs and assurance arguments (2025)"Much remains to be demonstrated before it can be concluded that LLMs are fit for use in generating or assessing" assurance arguments; treat the technology "as experimental"The assistant produces evidence: run records, traces, reports. People write and sign the argument
NASA Framework for the Ethical Use of AI (2021)"Humans must remain in charge." Solutions "must clearly state if, when, and how an AI system is involved." Organizations and individuals "must be accountable for the systems they create"This deck states where the assistant was used and who is accountable; the notes record it per session
NASA OSMA, AI-ready handbook announcement, May 2026"AI-generated artifacts (plans, checklists, code comments, evidence mappings) must be reviewed and approved by qualified engineering and assurance personnel"The compliance site and run records are generated from data and reviewed; nothing is AI-signed

Sources read 30 September 2026 from NODIS, standards.nasa.gov, swehb.nasa.gov and NTRS. Handbook pages carry an "updates needed" banner; re-check wording before external use.

Proposed rules

Rules for AI assistants in aerospace QA: standards plus what we saw

No.RuleBasis
1The assistant is an unqualified tool. Every output it produces is independently verified, or it is not usedSWE-146 item d; handbook 7.25; DO-330
2The assistant runs and observes verification. It never authors or signs the assurance argument, and never generates or modifies safety-critical codeHandbook 7.25; NASA/TM-20250001849
3Every assistant claim links to a retrievable, re-runnable artifact: a run record, a console extract, a counter, a hash. No artifact, no claimNASA/TM-20250001849; OSMA May 2026; our run records
4Prompts, model version, permissions and transcripts are configuration items under the same control as proceduresSWE-081; SWE-146 items b and g; our instructions file
5Safety interlocks and command authority are enforced by the tooling around the assistant (its permissions and the gates), not by written instructions. The assistant gets no authority to disable a gate without a recorded human approvalHandbook 8.25 approval gates for agentic actions; the gate we bypassed
6A pass requires positive evidence the path under test executed, and the precondition it depended onOur two invalid experiments
7Independence: the assistant conversation that verifies is not the one that wrote the change, and a human reviews the verdictNASA-STD-8739.8B independence; handbook 8.25
8Feature drops, workarounds and bypasses go on a visible list with a human disposition, and reviewer time is budgeted before the campaign startsNASA/TM-20250001849; the display feature we dropped

Rules 1 to 5 follow from published guidance. Rules 6 to 8 came from our own session and fill gaps the standards do not yet address for assistants that act.

Recommendations

A starting checklist for the next project

Set up on day one

  • The software class and the safety-critical determination, written down and agreed with SMA (SWE-020, SWE-205): an hour's work that scales everything else
  • Numbered requirements with parents and a traceability matrix, before the first line of code
  • The two safety requirements: startup self-check with reporting, and health-gated keep-alive, each with a negative test
  • Validate on the target architecture or a high-fidelity simulation, not only on the host
  • Static analysis with a deviation log, and a checksummed configuration baseline

Rules for assistants in the loop

  • Every assistant-run test states the precondition it checked and the positive evidence the path executed
  • Safety interlocks are listed as the product; bypassing one requires a human decision, recorded
  • Feature drops and workarounds go in a visible list, never only in the assistant's prose
  • The assistant's oversight mode (in-loop, on-loop or out-of-loop), permissions, model version and instructions are declared in the development plan and kept under configuration control
  • Engineering notes are written as work proceeds; they carried every recovery recipe across our host move

Open on the prototype: SMA concurrence on the class and determination, an assurance plan, test plan and report, CM plan, a 7009B assessment record, a startup self-check, a watchdog negative test, and the new ground components in the classification record.

← All presentations