diff --git a/crates/aura-cli/tests/graph_construct.rs b/crates/aura-cli/tests/graph_construct.rs
index 7d6c175..7aba864 100644
--- a/crates/aura-cli/tests/graph_construct.rs
+++ b/crates/aura-cli/tests/graph_construct.rs
@@ -1279,7 +1279,7 @@ fn open_r_breakout_fixture_lists_its_axis_namespace() {
 #[test]
 fn open_r_breakout_fixture_gang_axis_matches_the_closed_example() {
     let closed_dir = temp_cwd("r-breakout-gang-axis-closed");
-    let (closed_stdout, closed_stderr, closed_code) = run_in(&closed_dir, &["run", &example("r_breakout.json")]);
+    let (closed_stdout, closed_stderr, closed_code) = run_in(&closed_dir, &["exec", &example("r_breakout.json")]);
     assert_eq!(closed_code, Some(0), "closed run stderr: {closed_stderr}");
     let closed: serde_json::Value =
         serde_json::from_str(closed_stdout.trim()).expect("closed run report parses as JSON");
@@ -1341,7 +1341,7 @@ fn open_r_meanrev_fixture_lists_its_axis_namespace() {
 #[test]
 fn open_r_meanrev_fixture_gang_plus_plain_axis_matches_the_closed_example() {
     let closed_dir = temp_cwd("r-meanrev-gang-axis-closed");
-    let (closed_stdout, closed_stderr, closed_code) = run_in(&closed_dir, &["run", &example("r_meanrev.json")]);
+    let (closed_stdout, closed_stderr, closed_code) = run_in(&closed_dir, &["exec", &example("r_meanrev.json")]);
     assert_eq!(closed_code, Some(0), "closed run stderr: {closed_stderr}");
     let closed: serde_json::Value =
         serde_json::from_str(closed_stdout.trim()).expect("closed run report parses as JSON");
@@ -1834,7 +1834,7 @@ fn tap_authored_via_op_script_runs_and_persists_the_series() {
     let bp_path = dir.join("tapped.json");
     std::fs::write(&bp_path, &blueprint_json).expect("write built blueprint");
 
-    let (_stdout, stderr2, code2) = run_in(&dir, &["run", bp_path.to_str().unwrap()]);
+    let (_stdout, stderr2, code2) = run_in(&dir, &["exec", bp_path.to_str().unwrap()]);
     assert_eq!(code2, Some(0), "aura run over the op-authored tap: {stderr2}");
 
     // `aura graph build` always names the root composite "graph" (`composite_from_str`),
@@ -2158,7 +2158,7 @@ fn running_an_open_blueprint_refuses_at_bootstrap() {
     assert!(built, "an open (Input) root role finishes without root-role boundness (#317)");
     let bp = dir.join("open.bp.json");
     std::fs::write(&bp, &build_out).expect("write built blueprint");
-    let (stdout, stderr, code) = run_in(&dir, &["run", bp.to_str().unwrap()]);
+    let (stdout, stderr, code) = run_in(&dir, &["exec", bp.to_str().unwrap()]);
     assert_eq!(code, Some(1), "an open blueprint refuses standalone at bootstrap, not finish: {stdout} {stderr}");
     assert!(stdout.is_empty(), "no report emitted on a bootstrap refusal: {stdout}");
     assert!(
diff --git a/crates/aura-cli/tests/measure_ic.rs b/crates/aura-cli/tests/measure_ic.rs
index a6c37f6..59e5bf3 100644
--- a/crates/aura-cli/tests/measure_ic.rs
+++ b/crates/aura-cli/tests/measure_ic.rs
@@ -35,7 +35,7 @@ fn run_measurement(cwd: &Path) {
     let bp = cwd.join("measurement.json");
     std::fs::write(&bp, two_tap_blueprint_json()).expect("write blueprint");
     let out = Command::new(BIN)
-        .args(["run", bp.to_str().unwrap()])
+        .args(["exec", bp.to_str().unwrap()])
         .current_dir(cwd)
         .output()
         .expect("spawn aura run");
diff --git a/crates/aura-cli/tests/project_load.rs b/crates/aura-cli/tests/project_load.rs
index 6e98d16..a3bf21d 100644
--- a/crates/aura-cli/tests/project_load.rs
+++ b/crates/aura-cli/tests/project_load.rs
@@ -38,13 +38,13 @@ fn aura(args: &[&str], cwd: &Path) -> Output {
 #[test]
 fn project_run_resolves_demo_node_and_is_bit_identical() {
     let dir = built_project();
-    let a = aura(&["run", "demo_signal.json"], dir);
+    let a = aura(&["exec", "demo_signal.json"], dir);
     assert!(
         a.status.success(),
         "run failed: {}",
         String::from_utf8_lossy(&a.stderr)
     );
-    let b = aura(&["run", "demo_signal.json"], dir);
+    let b = aura(&["exec", "demo_signal.json"], dir);
     assert!(b.status.success());
     assert_eq!(a.stdout, b.stdout, "two runs must be byte-identical (C1)");
 }
@@ -52,7 +52,7 @@ fn project_run_resolves_demo_node_and_is_bit_identical() {
 #[test]
 fn project_run_manifest_carries_provenance() {
     let dir = built_project();
-    let out = aura(&["run", "demo_signal.json"], dir);
+    let out = aura(&["exec", "demo_signal.json"], dir);
     assert!(out.status.success());
     let v: serde_json::Value =
         serde_json::from_slice(&out.stdout).expect("run report is JSON");
@@ -83,7 +83,7 @@ fn outside_a_project_the_demo_blueprint_is_unknown() {
     // cwd = the aura-cli crate dir: no Aura.toml anywhere up the tree.
     let cwd = Path::new(env!("CARGO_MANIFEST_DIR"));
     let bp = fixture_dir().join("demo_signal.json");
-    let out = aura(&["run", bp.to_str().unwrap()], cwd);
+    let out = aura(&["exec", bp.to_str().unwrap()], cwd);
     assert!(!out.status.success());
     let err = String::from_utf8_lossy(&out.stderr);
     assert!(
@@ -162,7 +162,7 @@ fn vocabulary_charter_violation_refuses_end_to_end() {
         "badcharter fixture build failed:\n{}",
         String::from_utf8_lossy(&build.stderr)
     );
-    let run = aura(&["run", "x.json"], &dir);
+    let run = aura(&["exec", "x.json"], &dir);
     assert_eq!(
         run.status.code(),
         Some(1),
@@ -191,7 +191,7 @@ fn undescribed_vocabulary_entry_refuses_end_to_end() {
         "undescribed fixture build failed:\n{}",
         String::from_utf8_lossy(&build.stderr)
     );
-    let run = aura(&["run", "x.json"], &dir);
+    let run = aura(&["exec", "x.json"], &dir);
     assert_eq!(
         run.status.code(),
         Some(1),
@@ -229,7 +229,7 @@ fn restated_name_vocabulary_entry_refuses_end_to_end() {
         "restated fixture build failed:\n{}",
         String::from_utf8_lossy(&build.stderr)
     );
-    let run = aura(&["run", "x.json"], &dir);
+    let run = aura(&["exec", "x.json"], &dir);
     assert_eq!(
         run.status.code(),
         Some(1),
@@ -287,7 +287,7 @@ fn stale_dylib_warns_naming_both_timestamps_but_still_runs() {
     set_mtime(&dylib, DYLIB_MTIME);
     set_mtime(&src, SOURCE_MTIME);
 
-    let out = aura(&["run", "demo_signal.json"], dir);
+    let out = aura(&["exec", "demo_signal.json"], dir);
 
     // Restore sane mtimes before asserting, so a failed assertion does not
     // leave the shared fixture wedged "stale" (or with a future mtime that
@@ -351,7 +351,7 @@ fn nested_nodes_dir() -> PathBuf {
 fn data_only_project_runs_and_stamps_commit_only_provenance() {
     let dir = dataonly_dir();
     let out = Command::new(env!("CARGO_BIN_EXE_aura"))
-        .args(["run", "signal.json"])
+        .args(["exec", "signal.json"])
         .current_dir(&dir)
         .output()
         .expect("spawn aura run");
@@ -387,7 +387,7 @@ fn data_only_project_runs_and_stamps_commit_only_provenance() {
 fn multi_crate_pointer_refuses_end_to_end() {
     let dir = multicrate_dir();
     let out = Command::new(env!("CARGO_BIN_EXE_aura"))
-        .args(["run", "x.json"])
+        .args(["exec", "x.json"])
         .current_dir(&dir)
         .output()
         .expect("spawn aura run");
@@ -427,7 +427,7 @@ fn nodes_pointer_crate_resolves_and_stamps_its_namespace() {
         String::from_utf8_lossy(&build.stderr)
     );
     let out = Command::new(env!("CARGO_BIN_EXE_aura"))
-        .args(["run", "pointer_signal.json"])
+        .args(["exec", "pointer_signal.json"])
         .current_dir(&dir)
         .output()
         .expect("spawn aura run");
@@ -455,7 +455,7 @@ fn data_only_project_hints_attach_for_namespaced_ids() {
     let bp = tmp.join("bp.json");
     std::fs::write(&bp, r#"{"format_version":1,"blueprint":{"name":"x","nodes":[{"primitive":{"type":"nosuch::Node"}}],"edges":[],"input_roles":[{"name":"price","targets":[{"node":0,"slot":0}],"source":"F64"}],"output":[{"node":0,"field":0,"name":"bias"}]}}"#).unwrap();
     let out = std::process::Command::new(env!("CARGO_BIN_EXE_aura"))
-        .args(["run", bp.to_str().unwrap()])
+        .args(["exec", bp.to_str().unwrap()])
         .current_dir(&tmp)
         .output()
         .expect("spawn aura");
@@ -479,7 +479,7 @@ fn missing_artifact_refuses_with_build_hint() {
         "[package]\nname = \"nobuild\"\nversion = \"0.1.0\"\nedition = \"2024\"\n\n[lib]\ncrate-type = [\"cdylib\"]\n\n[workspace]\n",
     )
     .unwrap();
-    let out = aura(&["run", "x.json"], &tmp);
+    let out = aura(&["exec", "x.json"], &tmp);
     assert_eq!(out.status.code(), Some(1), "runtime refusal");
     let err = String::from_utf8_lossy(&out.stderr);
     assert!(err.contains("cargo build"), "build hint present: {err}");
diff --git a/crates/aura-cli/tests/run_measurement.rs b/crates/aura-cli/tests/run_measurement.rs
index a11b8e6..a3e82e0 100644
--- a/crates/aura-cli/tests/run_measurement.rs
+++ b/crates/aura-cli/tests/run_measurement.rs
@@ -34,7 +34,7 @@ fn measurement_blueprint_runs_bare_and_emits_its_tap() {
     std::fs::write(&bp_path, measurement_blueprint_json()).expect("write measurement blueprint");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path")])
+        .args(["exec", bp_path.to_str().expect("utf-8 path")])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -65,7 +65,7 @@ fn measurement_run_honours_the_tap_selector() {
     let bp_path = cwd.join("measurement.json");
     std::fs::write(&bp_path, measurement_blueprint_json()).expect("write measurement blueprint");
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=last"])
+        .args(["exec", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=last"])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -104,7 +104,7 @@ fn run_refuses_a_hand_crafted_envelope_with_a_bad_root_name_before_any_trace_wri
     std::fs::write(&bp_path, &bad).expect("write bad-root-name blueprint");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=record"])
+        .args(["exec", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=record"])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
diff --git a/crates/aura-cli/tests/run_refuses_unrunnable_blueprint.rs b/crates/aura-cli/tests/run_refuses_unrunnable_blueprint.rs
index fc14a96..796db98 100644
--- a/crates/aura-cli/tests/run_refuses_unrunnable_blueprint.rs
+++ b/crates/aura-cli/tests/run_refuses_unrunnable_blueprint.rs
@@ -38,7 +38,7 @@ fn assert_clean_refusal(bp_json: &str, tag: &str, what: &str) {
     std::fs::write(&bp_path, bp_json).expect("write blueprint");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path")])
+        .args(["exec", bp_path.to_str().expect("utf-8 path")])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
diff --git a/crates/aura-cli/tests/tap_recording.rs b/crates/aura-cli/tests/tap_recording.rs
index c26d597..22fbdd1 100644
--- a/crates/aura-cli/tests/tap_recording.rs
+++ b/crates/aura-cli/tests/tap_recording.rs
@@ -53,7 +53,7 @@ fn single_run_persists_a_declared_tap_series() {
     std::fs::write(&bp_path, tap_blueprint_json()).expect("write tapped blueprint");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path")])
+        .args(["exec", bp_path.to_str().expect("utf-8 path")])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -100,7 +100,7 @@ fn tap_free_run_writes_no_trace_store() {
     let cwd = temp_cwd("tap-free-writes-nothing");
     let bp = format!("{}/examples/r_sma.json", env!("CARGO_MANIFEST_DIR"));
     let out = Command::new(BIN)
-        .args(["run", &bp])
+        .args(["exec", &bp])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -152,7 +152,7 @@ fn single_run_refuses_a_duplicate_tap_name_before_persisting_anything() {
     std::fs::write(&bp_path, duplicate_tap_blueprint_json()).expect("write dup-tap blueprint");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path")])
+        .args(["exec", bp_path.to_str().expect("utf-8 path")])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -178,7 +178,7 @@ fn an_unwritable_store_root_exits_through_the_tap_trace_register() {
     std::fs::write(cwd.join("runs"), b"not a directory").expect("occupy runs as a file");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path")])
+        .args(["exec", bp_path.to_str().expect("utf-8 path")])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -210,7 +210,7 @@ fn a_read_only_run_dir_surfaces_terminally_through_the_tap_trace_register() {
         .expect("make run dir read-only");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path")])
+        .args(["exec", bp_path.to_str().expect("utf-8 path")])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -239,7 +239,7 @@ fn run_tap_selector_persists_a_fold_summary_row() {
     std::fs::write(&bp_path, tap_blueprint_json()).expect("write tapped blueprint");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=mean"])
+        .args(["exec", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=mean"])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -276,7 +276,7 @@ fn run_explicit_record_plan_matches_the_record_all_default() {
             .expect("write two-tap blueprint");
     }
     let run = |cwd: &std::path::Path, extra: &[&str]| {
-        let mut args = vec!["run", "two_tap.json"];
+        let mut args = vec!["exec", "two_tap.json"];
         args.extend_from_slice(extra);
         let out = Command::new(BIN)
             .args(&args)
@@ -309,7 +309,7 @@ fn run_tap_selector_refuses_an_unknown_label_with_the_roster() {
     let bp_path = cwd.join("tapped_r_sma.json");
     std::fs::write(&bp_path, tap_blueprint_json()).expect("write tapped blueprint");
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=medain"])
+        .args(["exec", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=medain"])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -334,7 +334,7 @@ fn run_tap_selector_refuses_an_undeclared_tap() {
     let bp_path = cwd.join("two_tap.json");
     std::fs::write(&bp_path, two_tap_blueprint_json()).expect("write two-tap blueprint");
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path"), "--tap", "nope=mean"])
+        .args(["exec", bp_path.to_str().expect("utf-8 path"), "--tap", "nope=mean"])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -359,7 +359,7 @@ fn run_tap_selector_notes_unbound_declared_taps_on_stderr() {
     std::fs::write(&bp_path, two_tap_blueprint_json()).expect("write two-tap blueprint");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=mean"])
+        .args(["exec", bp_path.to_str().expect("utf-8 path"), "--tap", "fast_tap=mean"])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -384,7 +384,7 @@ fn run_with_no_tap_flag_emits_no_unbound_note() {
     std::fs::write(&bp_path, two_tap_blueprint_json()).expect("write two-tap blueprint");
 
     let out = Command::new(BIN)
-        .args(["run", bp_path.to_str().expect("utf-8 path")])
+        .args(["exec", bp_path.to_str().expect("utf-8 path")])
         .current_dir(&cwd)
         .output()
         .expect("spawn aura run");
@@ -407,7 +407,7 @@ fn run_tap_selector_refuses_malformed_and_duplicate_pairs() {
         vec!["--tap", "fast_tapmean"],
         vec!["--tap", "fast_tap=mean", "--tap", "fast_tap=last"],
     ] {
-        let mut full = vec!["run", bp_path.to_str().expect("utf-8 path")];
+        let mut full = vec!["exec", bp_path.to_str().expect("utf-8 path")];
         full.extend(args);
         let out = Command::new(BIN)
             .args(&full)