docs(readme, guides, glossary, ledger), bench: the surviving surface everywhere

Slice 8, closing the #319 retirement's prose and bench debt. Bench argv
rides exec (fixed_cost single-run probe, campaign surfaces, and the seed
helper that still called the retired sweep at runtime — caught by the
bench run itself); all five fingerprints unchanged against the committed
baselines, confirming record-line parity through the retirement. Live
docs (README, authoring guide, project layout, glossary) describe only
exec + campaign documents + graph introspect --params; three glossary
entries explicitly mark their verb retired. Ledger amendments per the C29
discipline — C25's executor-verb-set re-settled (exec + the --override
residue), C14's dual grammar reduced to the one dispatch, C24's
document-built runs/families + gated-intake route list (lockstep with the
code comment), C12's override clause and identity anchor repointed to the
runner-layer hash computation, C18/C22/C27/C01 mention rewrites —
superseded sentences moved verbatim to the history sidecars (c25's
created). Stale dual-grammar doc comment on is_blueprint_file rewritten.

refs #319

crates/aura-bench/src/surfaces/campaign.rs

@@ -95,31 +95,18 @@ fn blueprint_stems(dir: &Path) -> Vec<String> {
         .unwrap_or_default()
 }
 
-/// Seed one blueprint into the scratch store via a tiny synthetic sweep (the
-/// E2E `seed_blueprint` pattern) and return its content id.
+/// Seed one blueprint into the scratch store via `graph register` (#319: the
+/// surviving registration surface) and return its content id.
 fn seed_blueprint(bin: &Path, dir: &Path, file: &str, name: &str) -> Result<String, String> {
     let before = blueprint_stems(dir);
-    let (out, code) = run_in(
-        bin,
-        dir,
-        &[
-            "sweep",
-            file,
-            "--axis",
-            "fast.length=2,4",
-            "--axis",
-            "slow.length=8,16",
-            "--name",
-            name,
-        ],
-    )?;
+    let (out, code) = run_in(bin, dir, &["graph", "register", file, "--name", name])?;
     if code != Some(0) {
-        return Err(format!("seed sweep failed ({code:?}): {out}"));
+        return Err(format!("seed register failed ({code:?}): {out}"));
     }
     blueprint_stems(dir)
         .into_iter()
         .find(|s| !before.contains(s))
-        .ok_or_else(|| "seed sweep must store a new blueprint".to_string())
+        .ok_or_else(|| "seed register must store a new blueprint".to_string())
 }
 
 fn register_process(bin: &Path, dir: &Path, file: &str, doc: &str) -> Result<String, String> {
@@ -261,7 +248,7 @@ pub fn winner_fingerprint(stdout: &str) -> Result<String, String> {
 
 fn campaign_rep(bin: &Path, sizing: Sizing, process_doc: &str) -> Result<RepOutcome, String> {
     let (scratch, doc) = build_scratch(bin, sizing, process_doc)?;
-    let timed: TimedChild = run_timed(bin, &["campaign", "run", &doc], &scratch.0)?;
+    let timed: TimedChild = run_timed(bin, &["exec", &doc], &scratch.0)?;
     if timed.exit != Some(0) {
         return Err(format!(
             "campaign run exited {:?}\nstdout: {}\nstderr: {}",

crates/aura-bench/src/surfaces/fixed_cost.rs

@@ -1,6 +1,6 @@
 //! CLI fixed cost: the spawn floor (`aura --help`, no fingerprint — nothing is
-//! computed) and a minimal data-only project run whose fingerprint is the
-//! FNV-1a hash of the run's single stdout JSON line. Fresh scratch project per
+//! computed) and a minimal data-only project exec whose fingerprint is the
+//! FNV-1a hash of the exec's single stdout JSON line. Fresh scratch project per
 //! repetition, so store counters start identical.
 
 use super::{median, RepOutcome};
@@ -11,7 +11,7 @@ use std::collections::BTreeMap;
 use std::path::Path;
 use std::time::Instant;
 
-/// Fingerprint of an `aura run` record line, invariant across rebuilds: the
+/// Fingerprint of an `aura exec` record line, invariant across rebuilds: the
 /// line's `manifest.commit` is the aura binary's compile-time build sha
 /// (crates/aura-cli/build.rs — the invariant-8 audit trail), so hashing the
 /// raw line would flip the fingerprint on EVERY new commit and report a
@@ -59,7 +59,7 @@ pub fn rep(bin: &Path) -> Result<RepOutcome, String> {
     let mut run_walls = Vec::new();
     let mut first_line = None;
     for _ in 0..RUN_SAMPLES {
-        let timed = run_timed(bin, &["run", "bench_sma_a.json"], &scratch.0)?;
+        let timed = run_timed(bin, &["exec", "bench_sma_a.json"], &scratch.0)?;
         if timed.exit != Some(0) {
             return Err(format!("aura run exited {:?}: {}", timed.exit, timed.stdout));
         }

crates/aura-cli/src/main.rs

@@ -953,9 +953,9 @@ struct ExecCmd {
     tap: Vec<String>,
 }
 
-/// The dual-grammar discriminator: a first-positional that names an existing
-/// `.json` file selects the loaded-blueprint branch. Single-sourced so the
-/// four dual-grammar subcommands stay in lockstep.
+/// The file-target discriminator: a first-positional that names an existing
+/// `.json` file is a document on disk. Shared by `exec`'s target routing
+/// (layered with `is_campaign_document_file`) and `dispatch_graph`.
 fn is_blueprint_file(arg: &Option<String>) -> Option<&str> {
     arg.as_deref()
         .filter(|a| a.ends_with(".json") && std::path::Path::new(a).is_file())

crates/aura-cli/src/scaffold.rs

@@ -247,9 +247,9 @@ std vocabulary, anchored by `Aura.toml`. There is no crate and no build step.
   unit R, and quality metrics are R-based. Entry signals become held state
   via the signal-side latch/edge-pulse idiom (see
   `aura graph introspect --vocabulary`).
-- Data plane: the research verbs are sugar over registered process/campaign
-  documents — author them directly with `aura process` / `aura campaign`,
-  growing one from a bare `{}` via `aura campaign introspect --unwired`.
+- Data plane: process/campaign documents are authored directly with
+  `aura process` / `aura campaign`, growing one from a bare `{}` via
+  `aura campaign introspect --unwired`.
 "#;
 
 /// Render a data-only project template: only `__NAME__`/`__NAME_SNAKE__`