audit: cycle 0107 tidy (drift resolved by ledger/glossary lift)

Architect verdict: drift_found — the code holds its contracts (C1
determinism incl. lowest-index fault attribution and doc-seeded
deflation; C16 seam: aura-campaign excludes ingest/std/composites,
MemberRunner isolates the condemned CLI scaffolding; the walk_forward
lockstep set moved together), the docs lagged the tree. All six drift
items resolved in this commit:

- C18: 'no executor exists' retired (0106 text now points forward);
  new cycle-0107 realization records the executor, the aura-campaign
  home, ListSpace, the campaign_runs.jsonl sibling store, zero-survivor
  exit-0 semantics, emit/persist_taps split, the #196 on-ramp, and the
  machinery-true std::walk_forward correction.
- C16: aura-campaign added to the non-node crate enumeration
  (cycle-0107 realization; explicitly not C21's World).
- Glossary: campaign document entry corrected (run verb, execution
  prose); new 'campaign run' entry; blueprint entry gains the on-ramp
  verbs.

Carry-on debt (self-noted in code, tracked): metric-roster
triplication #190, deflation-constant duplication #199; cross-cell
fault orphans + nested-parallelism oversubscription noted in the
tasks-6-7 commit body. Follow-ups filed on the milestone: #200
(mc/generalize stage execution), #201 (persist_taps wiring).

Regression: cargo test --workspace 987/0; clippy -D warnings clean;
cargo doc 0 warnings. Spec + plan removed at close per convention
(durable rationale lives in the ledger; the canonical record is the
git history).

closes #198

docs/design/INDEX.md

@@ -1219,6 +1219,15 @@ one-implementor abstraction. **Deferred to the World / C21 layer (explicitly *no
 making `RunReport` generic over a metric type and turning the orchestration/registry layer
 into a reusable domain-agnostic substrate — until then `RunReport` / `RunManifest` /
 `summarize` stay trace-coupled in the engine.
+**Realization (cycle 0107, #198 — the campaign-execution leaf).** The non-node engine
+workspace gains **`aura-campaign`**: campaign-execution *semantics* (cell enumeration,
+preflight, gate evaluation, winner selection, walk-forward rolling, realization assembly —
+see C18) as a leaf library crate whose deps deliberately exclude `aura-ingest` /
+`aura-std` / `aura-composites`; harness construction and data binding enter only through
+the one-method `MemberRunner` seam, so consumers (the `aura` CLI today; the playground and
+tests tomorrow) bind their own runners while the semantics live here once. It is
+explicitly NOT C21's World (a project-side program): it realizes one campaign document
+and owns no topology, no data sources, no UI.
 
 ### C17 — Authoring surface
 **Guarantee.** All *logic* — nodes, strategies, **and experiments/harnesses** —
@@ -1382,9 +1391,43 @@ canonical bytes; gets are `Ok(None)` treat-as-empty. The **referential tier**
 (`validate_campaign_refs`) resolves process/strategy refs against the stores (identity refs
 by store scan) and checks each campaign axis — name AND declared `ScalarKind`, the axis
 carries its kind once — against the referenced blueprint's `param_space`. Campaign P1
-control constructs (axes/gates/ladders per #188) carry intent only: **no executor exists**;
-executor need is re-tested against the intent-persistence diagnosis before one is scoped
-(#189 triage, decided item 6).
+control constructs (axes/gates/ladders per #188) carried intent only in this cycle: no
+executor existed yet — executor need was re-tested against the intent-persistence
+diagnosis (#189 triage, decided item 6; the cycle-0106 fieldtest F7 verdict was that
+evidence), and the v1 executor shipped the next cycle (below).
+**Realization (cycle 0107, #198/#196 — the campaign executor and its realization store).**
+`aura campaign run <file|content-id>` executes a campaign (a file is register-then-run
+sugar; the content id is canonical): zero-fault referential gate, then the process
+pipeline — v1 executable shape `std::sweep [std::gate]* [std::walk_forward]?`
+(`std::monte_carlo`/`std::generalize` refuse loudly at preflight, as does every other
+shape) — runs once per (strategy, instrument, window) cell in doc order. Execution
+*semantics* live in the **`aura-campaign` library crate** (#198 home decision: reachable
+beyond the CLI; NOT C21's project-side World): grid odometer over the campaign axes,
+members through the engine `sweep` over a **`ListSpace`** (explicit point set beside
+`GridSpace`/`RandomSpace` — a gate's survivor subset has no cartesian structure),
+per-member gates via the 14-name `member_metric` roster (an R-predicate over a missing R
+block fails conservatively), walk-forward re-rolled in the doc's epoch-ms unit
+(`WindowRoller`; IS windows search ONLY the survivor points; OOS winner reports carry
+`manifest.selection`), deflation nulls seeded from the doc's `seed` (C1: realization is a
+pure function of doc + stores + data). Harness/data binding stays consumer-side behind the
+one-method **`MemberRunner`** seam — the CLI binds the shipped loaded-blueprint reduce
+convention with unique suffix-join of raw axis names onto the wrapped `param_space`. The
+registry grew the **`campaign_runs.jsonl`** JSONL sibling (beside `runs.jsonl` /
+`families.jsonl`): one thin `CampaignRunRecord` per run — campaign/process ids, seed, and
+per-cell realized stage prefixes linking family ids, gate survivor ordinals, and sweep
+selections — over untouched family records, run-counted per campaign id. Zero survivors
+truncate a cell's realized prefix and exit 0 (a null result is a valid research result);
+`emit` is honored (`family_table`/`selection_report` lines), `persist_taps` is deferred
+LOUDLY on stderr (no name→tap wiring exists yet). The **blueprint on-ramp** (#196) closes
+the F5 authoring gap: `aura graph register` (store put keyed by content id == topology
+hash), `aura graph introspect --params` (the RAW `param_space` namespace campaign axes
+are validated against), and a blueprint-file mode on `--content-id`. The
+`std::walk_forward` vocabulary was corrected to machinery-true fields
+(`in_sample_ms`/`out_of_sample_ms`/`step_ms`/`mode` — `WindowRoller`'s three lengths and
+both `RollMode`s; the shipped `folds` slot mapped to nothing the machinery accepts), with
+a new `ZeroWalkForwardLength` intrinsic fault; wf-bearing process docs get new content ids
+by design (the 0106 fieldtest corpus stays as the historical record). Known debt:
+metric-roster triplication (#190), deflation-constant duplication (#199).
 **Guarantee.** Construction is a distinct phase, recursive at every level. Each
 node type has a **factory** `params → sized concrete node` (e.g. `SMA(length)`
 sizes its ring buffer). A **blueprint** is the param-generic, input-role-generic