feat(aura-cli)!: retire the research-verb sugar — run/sweep/walkforward/mc/generalize removed

Slice 6 of the #319 retirement, the destructive half. The five flag verbs,
their five Args structs and dispatch arms, the whole argv->document
translator (verb_sugar.rs, 1257 lines) and 33 quintet-only helpers are
gone; retired verbs now refuse at the clap layer as unknown commands.
main.rs shrinks 4445 -> 2764 lines. The gated-intake route list narrows to
the canonical layer + exec's blueprint leg; exec's own refusal prose no
longer names dead verbs; test seeding recipes ride graph register.

cli_run.rs walked the full disposition table: 94 tests retired with their
dead flag surface (each with a named green twin where the property
survives), 75 ported — exec ports keep assertions byte-identical, campaign
ports inherit their golden grades unchanged (walkforward's 90/30/30 real
roller and the archive window clipping the sugar applied silently are now
explicit document fields — the equivalence held exactly, one reconstructed
walkforward pooled expectancy_r within 1e-12, cause documented inline).
Surface deltas recorded by the ports: per-cell refusals are #272 contained
faults (exit 3 + warning) rather than hard exit 1; the synthetic per-seed
mc family and generalize's merged cross-instrument family record were
sugar-only constructs and retire with it (the campaign record's
generalizations[] carries the data).

refs #319

crates/aura-cli/src/campaign_run.rs

@@ -108,17 +108,13 @@ struct CampaignRunLine<'a> {
     campaign_run: &'a CampaignRunRecord,
 }
 
-/// Stdout shape of a campaign run. `Full` is `aura campaign run` (emit-gated
-/// member/selection lines + the always-on final `campaign_run` record line).
-/// `MemberLinesOnly` is dissolved-verb sugar: the generated document's
-/// `emit: ["family_table"]` already limits emission to member lines; the mode
-/// additionally suppresses the final record line so the verb's stdout
-/// contract is reproduced byte-for-byte. The record append is identical in
-/// both modes — presentation changes, the record does not.
+/// Stdout shape of a campaign run: emit-gated member/selection lines + the
+/// always-on final `campaign_run` record line. `MemberLinesOnly` (the
+/// dissolved-verb sugar path's suppressed-record-line mode) retired with the
+/// quintet (#319 Task 8) — `Full` is the only surviving shape.
 #[derive(Clone, Copy, PartialEq)]
 pub(crate) enum RunPresentation {
     Full,
-    MemberLinesOnly,
 }
 
 /// `aura campaign run <target>`: resolve, gate, execute, emit. Every `Err`
@@ -184,12 +180,9 @@ pub(crate) struct CampaignRun {
 /// The one campaign executor path from a resolved content id onward: fetch
 /// the stored canonical bytes by id (so file addressing and id addressing
 /// produce the same realization by construction) and re-run the intrinsic
-/// tier on them, execute, and emit per `presentation`. Shared by
-/// `run_campaign` (`RunPresentation::Full`) and the dissolved-verb sugar path
-/// (`verb_sugar::run_sweep_sugar`, `RunPresentation::MemberLinesOnly`) — no
-/// project gate here: the sugar path must work project-less exactly as the
-/// inline verb it replaces did (store mechanics run against `env.registry()`
-/// in both cases).
+/// tier on them, execute, and emit per `presentation`. Called by
+/// `run_campaign` (`RunPresentation::Full`, the sole surviving shape since
+/// the quintet's dissolved-verb sugar path retired, #319 Task 8).
 pub(crate) fn run_campaign_by_id(
     campaign_id: &str,
     env: &Env,

crates/aura-cli/src/diag.rs

@@ -32,11 +32,11 @@ fn zero_trade_note_text(n_windows: usize) -> String {
     }
 }
 
-/// The #313 zero-trade note, shared by both walk-forward paths (the
-/// synthetic-blueprint path in `main.rs` and the `--real` sugar path in
-/// `verb_sugar.rs`) so the wording AND the condition live in exactly one
-/// place. Takes the per-window trade counts; a no-op unless there is at
-/// least one window and every one of them traded zero times.
+/// The #313 zero-trade note (#319 Task 5: migrated onto the campaign
+/// walk-forward leg in `campaign_run.rs`, the surviving executor path) so
+/// the wording AND the condition live in exactly one place. Takes the
+/// per-window trade counts; a no-op unless there is at least one window and
+/// every one of them traded zero times.
 pub(crate) fn note_zero_trade_windows(mut window_trades: impl ExactSizeIterator<Item = u64>) {
     let n_windows = window_trades.len();
     if n_windows > 0 && window_trades.all(|n| n == 0) {

crates/aura-cli/src/graph_construct.rs

@@ -805,41 +805,6 @@ pub(crate) fn unresolved_namespace_hint(e: &LoadError, env: &aura_runner::projec
     }
 }
 
-/// Validate a blueprint-slot document — the `sweep`/`walkforward`/`mc`
-/// loaded-blueprint branches' dispatch-boundary check (#210 c0110 fieldtest
-/// finding: the sweep slot used to print the raw `{e:?}` Debug leak). Single-
-/// sourced here so the three dual-grammar subcommands cannot diverge (#184's
-/// convention, extended). Two refusals, checked in order:
-///
-/// 1. The document parses as JSON but is an op-script ARRAY (#157), not a
-///    built blueprint envelope — refused with a targeted hint pointing at
-///    `aura graph build`, since `blueprint_from_json` would otherwise surface
-///    a confusing internal serde shape mismatch.
-/// 2. `blueprint_from_json` fails to load the envelope — phrased house-style
-///    via [`blueprint_load_prose`] (+ [`unresolved_namespace_hint`] where it
-///    applies), never the raw `LoadError` Debug form.
-///
-/// `Ok(())` means the document loaded cleanly; callers that only need the
-/// validation (not the `Composite`) re-parse `doc` themselves afterward
-/// (`blueprint_from_json` is cheap and infallible at that point).
-pub(crate) fn blueprint_slot_prose(doc: &str, env: &aura_runner::project::Env) -> Result<(), String> {
-    if matches!(serde_json::from_str::<serde_json::Value>(doc), Ok(serde_json::Value::Array(_))) {
-        return Err(
-            "this is an op-script (an op array), not a built blueprint — run \
-             'aura graph build' first"
-                .to_string(),
-        );
-    }
-    blueprint_from_json(doc, &|t| env.resolve(t)).map(|_| ()).map_err(|e| {
-        let mut msg = blueprint_load_prose(&e);
-        if let Some(hint) = unresolved_namespace_hint(&e, env) {
-            msg.push_str(" — ");
-            msg.push_str(&hint);
-        }
-        msg
-    })
-}
-
 /// #196: build a `Composite` from a document that is EITHER a #155 blueprint
 /// envelope (a JSON object: `format_version` + `blueprint`) OR a construction
 /// op-list (a JSON array) — shape-discriminated on the top-level JSON type,
@@ -893,34 +858,22 @@ pub(crate) fn composite_from_any(text: &str, env: &aura_runner::project::Env) ->
 /// function — C29's "registered artifacts are never retroactively
 /// invalidated" stays intact.
 ///
-/// **Deliberate exceptions — direct `gate_authored_root_name` callers
-/// (main.rs).** A handful of fresh-FILE intakes reach the same unsanitized
-/// `traces/<name>/` seam (or `put_blueprint` the loaded envelope straight
-/// into the registry) without going through this wrapper, because each
+/// **Deliberate exception — the one direct `gate_authored_root_name` caller
+/// (main.rs).** One fresh-FILE intake reaches the same unsanitized
+/// `traces/<name>/` seam without going through this wrapper, because it
 /// already parses the document its own way and only needs the shared root-
 /// name gate bolted on, not the shape-discrimination `composite_from_any`
 /// does:
-/// - `aura run <blueprint.json>` (`dispatch_run`): envelope-only grammar (no
-///   op-script fallback), feeds `signal.name()` into
+/// - `exec <blueprint.json>` (`exec_blueprint_leg`, #319): envelope-only
+///   grammar (no op-script fallback), feeds `signal.name()` into
 ///   `run_signal_r`/`run_measurement` -> `bind_tap_plan` ->
 ///   `TraceStore::begin_run`.
-/// - `validate_and_register_axes` (shared by `generalize`,
-///   `sweep --real`, `walkforward --real`, `mc --real`): `put_blueprint`s
-///   the loaded envelope by topology hash before any of those four verbs
-///   touches an archive.
-/// - `run_blueprint_sweep` / `run_blueprint_walkforward` / `run_blueprint_mc`
-///   (the synthetic, no-`--real` family builders): same `put_blueprint`
-///   reason, on the routes that bypass `validate_and_register_axes`
-///   entirely (#331 cycle-close — these used to plant an ungated envelope
-///   in the store; see each fn's own comment).
-/// - `list_blueprint_axes` (`aura sweep <FILE> --list-axes`, main.rs): no
-///   registry write and no trace directory here, but a shape-violating root
-///   name otherwise mangles through `wrapped_to_raw_axis` into a printed,
-///   non-bindable axis name instead of refusing (#331 fieldtest finding
-///   c331_2e) — the class rule is every CLI intake reading an authored
-///   envelope from a file gates the root name, not only the writing ones.
 ///
-/// All of these share the identical `name_gate` + `name_gate_fault_prose`
+/// (The quintet's other direct callers — `dispatch_run`,
+/// `validate_and_register_axes`, `run_blueprint_sweep`/`_walkforward`/`_mc`,
+/// `list_blueprint_axes` — retired with the quintet, #319 Task 8.)
+///
+/// This shares the identical `name_gate` + `name_gate_fault_prose`
 /// primitives this wrapper uses, so the refusal wording is byte-identical
 /// across every authored-file-intake route even though the shape-
 /// discrimination step is not shared by them.
@@ -934,10 +887,10 @@ pub(crate) fn composite_from_authored_text(
 }
 
 /// The root-name shape gate itself (#331 delta re-review), factored out of
-/// [`composite_from_authored_text`] so `dispatch_run`'s narrower-grammar file
-/// intake (see that fn's doc comment) can share the exact `name_gate` call and
-/// `name_gate_fault_prose` wording without going through the shape-discriminating
-/// wrapper.
+/// [`composite_from_authored_text`] so `exec_blueprint_leg`'s narrower-grammar
+/// file intake (see that fn's doc comment) can share the exact `name_gate`
+/// call and `name_gate_fault_prose` wording without going through the
+/// shape-discriminating wrapper.
 pub(crate) fn gate_authored_root_name(name: &str) -> Result<(), String> {
     name_gate(name).map_err(|fault| name_gate_fault_prose(name, &fault))
 }