Aura/docs/glossary.md

# aura glossary

Canonical nomenclature for aura's domain. This file is the source of truth for
naming: where another document names a concept differently, the canonical entry
and its **Avoid** list win. Rules (format, reading obligation, write discipline)
live in the skills glossary convention; this file is an instance of it.

Each block has three fields: a canonical-term heading, an `**Avoid:**` line
(synonyms that must not be used; `—` when none), and a ≤2-sentence definition.
Entries are alphabetical.

---

### arg kind
**Avoid:** ArgKind, construction-arg type
The closed vocabulary of construction-arg value shapes (`Tz`/`TimeOfDay`/`Count`, #271) — deliberately NOT a `scalar base type`: args are bootstrap metadata, never streamed, so the two closedness axes stay separate. Each kind's accepted strict form IS its canonical form (an exact IANA name; zero-padded `HH:MM`; a plain positive decimal count, no sign or leading zeros) — there is no normalization layer, so a near-miss string refuses rather than being rewritten. The per-kind forms are deliberately asymmetric (`"03"` refuses as a count while `"09:30"` requires the pad): canonical is each domain's conventional notation — fixed-width for wall-clock times, minimal for numbers.

### atomic sim unit
**Avoid:** atomic unit, sim unit
The primitive `(frozen topology + param-set + data-window + RNG-seed) → deterministic run → metrics` over which the four orchestration axes operate. One frozen-topology unit equals one harness instance.

### Aura.toml
**Avoid:** —
The per-project declarative config holding only static context — paths only: `[paths] data` (the archive root; defaults to the built-in path when unset) and `[paths] runs` (the runs dir) — never logic, and never instrument geometry (that is the recorded sidecar, C15). Its presence marks the project root, the way `Cargo.toml` marks a cargo crate. An optional `[nodes]` section (a `crates` pointer list, one entry honored) tier-selects a `node crate` in; absent, the project stays `data-only project`.

### backtest
**Avoid:** —
A single deterministic, synchronous run of one harness over historical input — the historical-replay framing of an execution. The commodity substrate the World builds families of; distinct from `sim` (the executable unit) and `run` (its registry record).

### bias
**Avoid:** exposure, exposure stream, intent stream
A strategy's primary, backtestable DAG output: one signed, bounded `f64 ∈ [-1,+1]` per cycle whose **sign is direction and magnitude is conviction** (conviction optional) — a *directional* bias, not the statistical look-ahead/survivorship sense. Bias is **unsized** — the protective stop lives downstream in the `RiskExecutor` (stop-rule → position-management, in R), never in the strategy, and sizing/fill are deploy concerns outside the research loop; it reframes the pre-reframe `exposure stream` (a signed fractional *position*).

### blueprint
**Avoid:** —
The param-generic, input-role-generic graph-as-data produced by running a Rust builder; it carries free numeric params and free input roles before bootstrap. Bootstrapped into a frozen instance by binding params + data + seed. Registered and inspected headless (`aura graph register`, `aura graph introspect --params` — the raw `param_space` namespace campaign axes bind against; cycle 0107/#196); a *bound* param is an overridable **default** — a sweep axis naming it re-opens it per family (#246), while `run` uses it as-is.

### blueprint label
**Avoid:** —
A registry-level name pointing at a registered blueprint's content id (`graph register --name <label>`, #317) — a mutable, latest-wins pointer over the immutable content-addressed store, not a second identity: re-registering under an existing label *repoints* it (the earlier content id stays reachable by its own id, never invalidated). `graph introspect --registered` lists every label with its content-id prefix and root `doc` line — the discovery surface a `use (op)` reference by name resolves against.

### bootstrap
**Avoid:** —
The distinct, recursive construction phase that binds `(blueprint + param-set + data bindings + seed)` into a frozen instance — buffers sized, topology fixed. The explicit name for the "wiring / graph build" that C7/C12 reference — the construction/compilation sense. Disambiguation: the *statistical* moving-block bootstrap of a trade-R series (`r_bootstrap`, `RBootstrap`) is a different thing that keeps its statistics name — it appears as the deflation null, the `aura mc` R path, and since 0108 the `std::monte_carlo` stage's `stage bootstrap` annotation; context (construction vs annotation) disambiguates.

### bot
**Avoid:** —
A frozen artifact that is a deployed strategy + broker: the live trading program (audit trail: this bot = this commit). Every bot is a frozen artifact, but not every frozen artifact is a bot.

### broker
**Avoid:** —
A downstream consumer node, never part of the strategy: the signal-quality side is the **R-evaluator** (per-trade R-outcomes from the in-R `RiskExecutor` → R-expectancy), read as **gross R** (signal) and **net R** (after the `cost model`). The historical in-graph **realistic broker** — the in-loop fill/commission/slippage account simulator that backtrader (`BackBroker`) and LEAN call a "broker" — is retired (real friction is not historically knowable) — cost is approximated by the `cost model` (a C9 cost-graph, in R), and the only real broker is the **live deploy-edge I/O adapter** against an actual venue (e.g. cTrader Open API), the sole reliable ground truth (measured never modelled, C11/C13); account money lives only at that deploy edge.

### campaign document
**Avoid:** experiment doc, campaign file
The role-6b research artifact (#188/#189): persisted experiment intent as closed-vocabulary canonical JSON — instruments × windows × strategy refs (by `content id` or `identity id`) × per-strategy param axes (each axis declares its `ScalarKind` once over bare values) × a process reference (content-id-only) × data-level presentation (taps to persist — the closed `tap` vocabulary — and tables to emit). Authored, validated, and executed headless (`aura campaign validate|introspect|register|show|run|runs` — `show` prints a registered document's canonical bytes back, #300), content-addressed beside blueprints in the registry store; carries P1 control constructs (bounded axes, gates, ladders) as intent, executed by `aura campaign run` (v2 pipeline shape `std::sweep [std::gate]* [std::walk_forward]? [std::monte_carlo]? [std::generalize]?` — the two annotators terminal, cycles 0107/0108, #198/#200) into a `campaign run` realization. `std::sweep`'s own selection group (`metric`+`select`) is optional, all-or-nothing, and permitted only as the pipeline's terminal stage when omitted (a selection-free sweep, #210).

### campaign run
**Avoid:** campaign execution record, realized campaign
One execution of a `campaign document` (`aura campaign run <file|content id>`; a file is register-then-run sugar — the content id is the canonical address). Realized once per (strategy, instrument, window) cell in doc order and recorded as a thin `CampaignRunRecord` line in the registry's `campaign_runs.jsonl` — linking the per-stage family ids, gate survivor ordinals, `stage bootstrap` annotations, and (campaign-scope, per strategy × window) `generalizations` entries (`generalization` with `worst_case`/`sign_agreement`/`per_instrument`, plus `winners` params and `missing` instruments on shortfall) over untouched family records, run-counted per campaign id. A cell whose gate leaves no survivors records its realized prefix and the run exits 0: a null result is a valid research result. Deterministic from doc + stores + data (C1): deflation and bootstrap nulls seed from the doc's `seed`. When the document requests `persist_taps`, the record's sparse `trace_name` (`"{campaign8}-{run}"`) points at the TraceStore family holding each nominee cell's persisted taps (0109/#201). NB the stdout emit wraps each record as `{"campaign_run": …}`; the stored `campaign_runs.jsonl` line is the bare record.

### cdylib
**Avoid:** —
The dynamically-loadable Rust library form of a project and its nodes, hot-reloaded during authoring; the hot-reload unit is always the project-side cdylib. Frozen to a static artifact for deploy.

### cell
**Avoid:** —
The type-erased 64-bit word holding one scalar-base-type value with its kind stripped off (`crates/aura-core/src/cell.rs`): the type lives at the schema/column/port, so a cell is read only by naming it via a branch-free accessor (`i64()`/`f64()`/`bool()`/`ts()`). A bare cell is what the SoA hot path reads without a per-value branch, whereas a `Scalar` — the self-describing tagged union of the four base types, used at the dynamic boundaries — is its disjoint counterpart, bridged by `Scalar::cell` (encode) / `Scalar::from_cell` (decode).

### composite
**Avoid:** —
A node that wires a sub-graph and exposes one output (a combined signal, or a strategy) — composition is fractal and acyclic. May carry an optional authored rationale (`doc`, #125) — a non-load-bearing debug symbol shown in the graph tooltip, identity-blind like the name. Also names the multi-column stream a node emits: the **record** a producer's `eval` returns, bundling 1..K base scalar columns (e.g. OHLCV), each bound field-wise by a consumer (C7/C8).

### construction arg
**Avoid:** construction-time param, arg
A typed, closed, non-scalar construction input (`args`, #271) that configures an **arg-bearing** vocabulary type's structural shape — `Session`'s IANA timezone/open, `LinComb`/`CostSum`'s arity — through a second channel beside `bind`, consumed once at construction (`PrimitiveBuilder::try_args`) before any param binds, never streamed, never swept, never bound. Values are closed, load-time-validated strings (see `arg kind`); the accepted pairs are id-bearing (they enter the blueprint's content id, like `bind` values) and survive the identity projection.

### content id
**Avoid:** —
The SHA-256 (hex) of an artifact's byte-canonical form — for a blueprint, `blueprint_to_json` (the byte-exact identity that keys the reproduction store and anchors `aura reproduce`, stamped into a run manifest as the `topology hash`); for a `process document` / `campaign document`, its canonical JSON (keying the sibling registry stores). One primitive, library-hosted in `aura-research` (`content_id_of`; the CLI delegates). Surfaced as `aura graph|process|campaign introspect --content-id`; two artifacts share a content id only when their canonical bytes agree, debug names included — contrast `identity id`.

### conviction-based risk allocation
**Avoid:** risk budgeting, risk parity, risk contribution
A feed-forward, order-independent research axis for scaling risk by bias strength — **flat** (sum of `realized_r`, sign only) vs **conviction-weighted** (sum of `|bias| · realized_r`) R-aggregation. Distinct from the deploy-only money-`Sizer`: because per-trade R is size-invariant, conviction is an **R-aggregation weight**, never a position-size scale (tested via `conviction_at_entry` / `conviction_terciles_r`).

### cost model
**Avoid:** realistic broker
A composable downstream **C9 graph of cost nodes**, in **R**, that **approximates** (never claims) a broker's cost: each cost node reads the state it depends on (price, realized-volatility, a C11-recorded rate source, the executor's per-trade R-records) and emits a **cost-in-R** stream subtracted from gross R to yield **net R** (per-trade factors deduct at close, per-cycle-held factors accrue over the hold). It generalizes / subsumes the scalar `round_trip_cost` (its degenerate constant-per-trade case — `cost_per_trade` is a **price-unit** numerator, R-normalized per trade as `cost/|entry−stop|`, not a cost in R), lives in `aura-std` / `aura-composites`, is optional (zero-cost baseline), and demands every factor be a labelled stress-parameter **or** data-grounded (over-modelling is the anti-pattern).

### cross-instrument generalization
**Avoid:** cross-symbol pooling, pooled generalization
The validation read that grades how consistently one *brought* candidate holds across a set of instruments, scored on its weakest one — the across-instrument axis of the anti-false-discovery discipline. Realised by `aura generalize` and, since 0108 (#200), by the `std::generalize` process stage at campaign scope (per (strategy, window) over the cells' nominees across instruments, recorded in the `campaign run`'s `generalizations`); an aggregator (a recomputable family score), never a selector that picks a winner.

### cycle
**Avoid:** —
One data-driven clock step: one input record = one cycle, advanced in global timestamp order with a monotonic `cycle_id` — the time-axis clock step (mainstream backtesters call it a tick/event/bar), **not** the topology-axis directed loop that C5's DAG forbids. (In the pipeline-process sense "cycle" also names one milestone round; the engine sense is this clock step.)

### data-only project
**Avoid:** —
The default project tier (#241): a directory anchored by `Aura.toml` with blueprints and research documents over the std vocabulary — no crate, no build step. Runs, sweeps, and campaigns work immediately after `aura new`.

### deflated score
**Avoid:** trials-adjusted score
A sweep winner's metric penalised for the number of configurations tried (trials-deflation — generalising the **Deflated Sharpe Ratio** deflation *concept*, Bailey & López de Prado 2014, not the analytic DSR formula), recorded additively on the winning member's `selection` without changing which member won. Paired with an **overfit probability**; the across-trials defence against a winner that is luck at sweep scale.

### edge
**Avoid:** —
A directed wiring link in a harness that forwards **one field** (`from_field`) of a producer node's `eval` output record into a consumer node's input slot (the engine's `Edge`); the source-side variant binding the source value into an input slot is a **source target** (`Target`). Edges define the DAG the bootstrap topologically orders (this is the **wiring edge** — not the quant *trading edge* = positive expectancy, nor the *deploy edge* = system boundary); a per-field scalar-kind mismatch across an edge is rejected at bootstrap.

### equity stream
**Avoid:** —
A downstream node's output over time — the headline form is the **net-R equity curve** (gross R minus the `cost model`'s cost-in-R, via the `net_r_equity` tap); currency equity is not a research artifact (it lives only at the live deploy edge). An equity *curve* is explicitly not a strategy's output (the `bias` stream is).

### experiment
**Avoid:** experiment-builder API
**Superseded by `campaign document` (2026-07-03, #188/#189).** The pre-role-model reading — a Rust builder-API definition of anything beyond a single backtest, living in a project's `experiments/` — was role-6b work mis-typed in role-2 technique: experiment intent is now closed-vocabulary *data* (the campaign document), not Rust source, so a tiny campaign change never costs a compile cycle. What stays Rust is node/block *logic* (role 2). The run registry / family remains the passive run-container counterpart.

### experiment matrix
**Avoid:** structural matrix
The set of harness instances produced by varying the structural axes (strategy × instrument × broker × window), expressed as plain Rust loops. The outer orchestration over the structural dimension; the tuning sweep is the inner loop.

### exposure stream
**Avoid:** — (superseded)
**Superseded by `bias` (2026-06 R-reframe).** The pre-reframe primary output: a signed, bounded `f64 ∈ [-1,+1]` per cycle read as the desired fractional *position* (conflating direction + conviction + size). Reframed to `bias` (unsized direction + conviction), sizing moved downstream to the `Sizer`/`RiskExecutor`; the term and the `Exposure` node persisted in pre-reframe code until the r-family rename (#174).

### firing policy
**Avoid:** —
A per-input-group declaration of one of two firing modes: A = fire-on-any-fresh + hold (as-of join), B = all-fresh barrier (synchronizing join). A single node may mix an A input and a B group.

### freshness-gated recompute
**Avoid:** freshness-gating
A node re-evaluates only when ≥1 of its own inputs is fresh this cycle; otherwise it holds its last output (sample-and-hold). Stale inputs contribute their last held value, not a missing one.

### frozen artifact
**Avoid:** deploy artifact, standalone binary
A statically-linked, versioned, frozen build, never hot-swapped (audit trail: this artifact = this commit). The general category; a `bot` is the specific case of a deployed strategy + broker.

### gang
**Avoid:** —
A blueprint-level declaration that two or more sibling nodes' open params are
semantically one knob. The member addresses leave the blueprint's parameter
space; one gang address (a single path segment at the composite's level)
replaces them, and its value fans out to every member at bootstrap. Binding is
structural, not advisory — no consumer can bind a member independently. The
gang's name is a debug/axis symbol (identity-blind); its member coordinates
are identity-bearing. Declared by the `gang` op / `GraphBuilder::gang`.

### gross R
**Avoid:** —
The R-multiple outcome of the **signal alone** — per-trade R integrated by the R-evaluator with **no `cost model`** attached (the zero-cost baseline). `net R = gross R − cost-in-R` once a cost model is composed on.

### harness
**Avoid:** root sim graph, root graph, root scope
The closed root sim graph that actually runs — sources bound to a strategy's roles + the strategy + broker node(s) + sinks under a clock; C1's disjoint unit. It is not a node (no free inputs, no output); "root scope" is RustAst's name for it.

### hot-reload
**Avoid:** —
The authoring-loop mechanism in which the project-side cdylib is rebuilt and reloaded live during research; authoring-only, never applied to a live bot. A sweep pays no hot-reload tax — params are runtime data, so the cdylib loads once.

### identity id
**Avoid:** identity hash, topology-identity hash
The SHA-256 of a blueprint's identity-canonical form (`blueprint_identity_json`: the canonical document with every non-load-bearing debug symbol blanked — composite, instance, bound-param, role, and output names, and the composite `doc`), surfaced as `aura graph introspect --identity-id`. Same topology → same id across authoring paths (op-script vs Rust builder, renamed twins) while openness, bound values, wiring, and order stay identity-bearing; an introspection-only comparison id — the byte-exact `content id` keeps the store/reproduce roles.

### ingestion boundary
**Avoid:** —
The single point where heterogeneous timestamped sources are k-way-merged into one chronological cycle stream and source-native time is normalized to canonical epoch-ns. The only place a merge happens — there is no merge or as-of join inside the graph.

### instance
**Avoid:** —
A concrete, frozen graph produced by binding a blueprint to params + data + seed — buffers sized, topology fixed. A sweep builds many disjoint instances from one blueprint.

### manifest
**Avoid:** —
The reproducible metadata record of a run (node-commit + params + data-window + seed + broker profile + `topology hash`, plus — for a project-hosted run — the `project` provenance block `{namespace, dylib_sha256, commit}`, with `namespace`/`dylib_sha256` present only when a `node crate` is attached — a `data-only project` run stamps `commit` alone), paired with metrics in the run registry — the run-output record, *not* the Cargo.toml/`Aura.toml`-style static *config* manifest. Determinism lets the full result be re-derived from this tiny record on demand.

### Monte-Carlo
**Avoid:** MC
An orchestration axis running N seeded realizations that perturb the input (the input stream, not the trade sequence); each realization is itself deterministic given its seed (Monte-Carlo = sweep over seeds). Distinct from the `std::monte_carlo` *process stage* (0108/#200): that block is the moving-block bootstrap of a per-trade R series (`r_bootstrap` — it perturbs the trade sequence, exactly what this axis does not), named for its fields (`resamples`, `block_len`) being that primitive's arguments; the seed-axis sense stays this entry's.

### neighbourhood score
**Avoid:** smoothed score
The metric of a sweep cell averaged (or worst-cased) over its closed grid neighbourhood — the surface a **plateau selection** argmaxes instead of the bare peak. Recorded on a plateau winner's `selection` alongside its neighbour count.

### net R
**Avoid:** —
**Gross R** after the `cost model`: `net R = gross R − cost-in-R`. The honest, cost-charged reading of signal quality, folded into `net_expectancy_r` (one home for cost, no double-count).

### net-R equity curve
**Avoid:** —
The headline research artifact: the R-equity curve with the `cost model`'s cost-drag drawn onto it (gross R minus cost-in-R), recorded through the named **`net_r_equity`** tap/sink (sibling of `r_equity`). A research / ranking **hypothesis**, never a claim of realism — the forward / live run against a real broker is the ground truth.

### node
**Avoid:** block
The universal composable dataflow unit, implementing `lookbacks()` + `eval(ctx)` — a producer, a pure consumer (sink), or both — with at most one output port; a producer's output is a **record of 1..K base-scalar columns** (a scalar is the degenerate K=1 case). Everything that plugs into the engine is fractally a node.

### node crate
**Avoid:** —
A separate cdylib crate holding a project's native node logic, attached via `Aura.toml [nodes]` (scaffolded by `aura nodes new`). Depends only on aura-core (no data-plane coupling); its namespace prefixes every type id it contributes; the manifest stamps its dylib sha alongside the project commit.

### overfit probability
**Avoid:** P(overfit), luck probability, Probability of Backtest Overfitting / PBO, CSCV
The recorded chance that a deflated sweep winner is noise rather than edge — a rank of the winner's metric against a centred no-edge null over the family (a moving-block reality-check bootstrap; **not** CSCV-PBO — there is no in-sample/out-of-sample split). Paired with the **deflated score** on the winner's `selection`.

### plateau selection
**Avoid:** plateau-over-peak (as a noun)
A selection objective that argmaxes the neighbourhood-smoothed metric surface (mean or worst-case) rather than the bare in-sample peak, preferring a robust parameter plateau to a lucky spike. Opt-in via `--select plateau:mean|plateau:worst`; the default selection stays a bare argmax.

### playground
**Avoid:** —
The visual face that plays any harness — program structure before a run, live sink streams during, recorded traces and meta-views after. A trace explorer / execution viewer, never a scene editor; per C25 a *stateless projection* of disk-persisted canonical data. The shipped form is the web-from-disk front (self-contained HTML chart pages over persisted taps, revised 2026-06/#101 — not the earlier egui-native plan).

### position table
**Avoid:** transactions, trade blotter
A broker-independent, time-ordered table of position events (scalar columns: `event_ts, action, position_id, instrument_id, volume`) — the **derived** first difference of the executed **book** (book-tracking `deal = target − book − in_flight`; a close sizes the actual book). A **deploy / reconciliation** artifact (real volume), not a research artifact and not "fed to a broker" in research; computed, not emitted per `eval` (one decision instant may yield >1 event), and **not** the strategy's direct DAG output (that is the `bias` stream).

### process document
**Avoid:** process doc, methodology file
The role-5 research artifact (#188/#189): a named, versionable validation/eval methodology as closed-vocabulary canonical JSON — an ordered pipeline of std stage blocks (`std::sweep`, `std::gate`, `std::walk_forward`, `std::monte_carlo`, `std::generalize`) wrapping shipped analysis/selection primitives, with typed gate predicates over the declared metric vocabulary. Authored and validated headless (`aura process validate|introspect|register|show`), content-addressed in the registry store; campaigns reference it by `content id` only — a one-off methodology is a process document with a disposable name, never an inline body.

### R
**Avoid:** —
The native unit of strategy performance: 1R = the loss if the protective stop is hit, so a trade's outcome is a multiple of R (−1R stopped out, +2R, …) and the primary question is *"how much R out per 1R risked?"*. Risk-normalized and account-/instrument-agnostic — the research yardstick replacing pips, defined by the stop (Van Tharp R-multiples), read as **gross R** (signal only) and **net R** (after the `cost model`).

### R metrics
**Avoid:** —
The R-multiple summary metrics `summarize_r` folds into `RunMetrics.r`, which double as the higher-is-better rank vocabulary for `aura runs family <id> rank <metric>` (cycle 0066): **`sqn`** (the System Quality Number — see SQN), **`sqn_normalized`** (the n-normalized SQN100 — see SQN; cycle 0067), **`expectancy_r`** (mean realized R per trade, the headline E[R]), and **`net_expectancy_r`** (expectancy net of the `cost model`'s cost-in-R per trade — churn-honest; the scalar `round_trip_cost` is its degenerate constant-per-trade case, and it equals `expectancy_r` when no cost model is attached). A family member with no `r` block ranks last under any of them, so a pip-only family ranked by an R metric falls back to ordinal order.

### R-evaluator
**Avoid:** —
The signal-quality node: integrates the per-trade R-outcomes of the in-R `RiskExecutor` into an R-expectancy / R-curve — the deterministic, account-/instrument-agnostic yardstick — read as **gross R** (signal only) and **net R** once the `cost model` is composed on. The R-reframe successor of the `sim-optimal broker` (pip integral); unlike it the R-evaluator requires a stop, so it consumes a RiskExecutor, not raw bias.

### RiskExecutor
**Avoid:** risk-manager
The per-symbol composite turning a bias into a managed position, **in R**: `stop-rule → position-management`, with the **Veto** an optional documented pre-trade-gate seam (a pass-through DCE'd away when absent). The research loop is **pure feed-forward** — **no Sizer**, no equity → size edge, no `z⁻¹` register (sizing/fill and any compounding feedback live at the live deploy edge, not here).

### realistic broker
**Avoid:** — (retired)
**Retired (2026-06-28 C10 reframe), replaced by the `cost model`.** The pre-reframe plan: an in-graph broker node applying authored historical friction (spread / commission / slippage / lot / margin) to emit a currency equity stream. Rejected as "horseshoe-throwing" — real friction is not historically knowable; cost is now approximated by the `cost model` (a C9 cost-graph, in R), and the only real broker is the **live deploy-edge I/O adapter** (measured, never modelled).

### resampler
**Avoid:** —
A node that converts a finer stream to a coarser bar stream, emitting a completed bar only at the boundary so no partial bar ever leaks (enforcing no look-ahead). Clock-sensitive.

### risk regime
**Avoid:** risk section
One entry of a campaign document's structural risk axis (`risk`): a
serializable protective-stop regime (variants `vol{length,k}` — per-cycle —
and `vol_tf{period_minutes,length,k}` — per completed time bucket) the matrix
runs every cell under, so cells differ by execution discipline, never by
signal. Absent or empty = one implicit default regime; the regime's stop
defines the risk unit R — in `vol{length,k}` (stop = k·√EMA(Δ², length) over
m1 cycles) `length` only smooths the vol estimator while `k` scales the stop
distance, so the stop's timescale stays one cycle (`vol_tf` sets the stop's
timescale via `period_minutes`).

### run
**Avoid:** —
One execution recorded in the run registry as a manifest + metrics — the registry-record framing of an execution. Distinct from `sim` (the executable unit) and `backtest` (the replay framing).

### run registry
**Avoid:** registry, runs dir, model registry
The aura-native, per-project store of one record per run — a manifest + metrics, queryable, with lineage (composite ← signals; run ← inputs). It lives under `runs/` and is the World's memory.

### run-count
**Avoid:** total_count
The per-series push counter on every `Column` — bumped on each push, never moved by a read; the node-visible freshness primitive (the reactive-systems **version counter** / stream **sequence number** pattern). The engine's per-cycle firing gate (C5/C6) reads a per-wiring-slot cycle epoch (`fresh_at == cycle_id`, the freshness epoch C4's cycle_id materializes as) rather than this counter, which remains the column-level count a node may read for its own logic. ("total_count" is RustAst's name for the same counter.)

### scalar base types
**Avoid:** —
The four streamed scalar kinds — `i64`, `f64`, `bool`, `timestamp` (a newtype over i64, epoch-ns UTC) — the only payloads on the hot path. Non-scalars (String, records, tables, calendars) live as metadata beside it, never in it.

### session node
**Avoid:** session window
A node that exposes session context as a scalar stream so session logic stays inside the stream model. The shipped `Session` / `SessionFrankfurt` node (`aura-market`) emits ONE `i64` field, `bars_since_open` — the count of completed bar-periods since the local (tz-aware, DST-correct) session open, indexed off the just-closed bar's close instant (in-session closes read exact positive multiples: 09:15→1, 09:45→3; pre-open ≤0). `Session` is roster-reachable for ANY IANA timezone/open through the typed **construction arg** channel (#271: `args: {"tz": <IANA name>, "open": "HH:MM"}`, applied before its one scalar param, `period_minutes`); `SessionFrankfurt` stays as baked sugar over the Frankfurt 09:00 `Europe/Berlin` open. Its `trigger` input only clocks it once per completed bar (the value is ignored). Calendars and instrument specs remain metadata beside the hot path.

### sign-agreement
**Avoid:** sign consistency, market breadth
In a cross-instrument generalization, the count of instruments on which the candidate's R-metric is net positive. Reported beside the **worst-case floor** to express consistency of direction across instruments.

### signal
**Avoid:** entry/exit signal, trade signal
A node whose output is a score, feeding the `signals (scores) → decision node → bias stream` chain — an upstream score *input* to the decision node, never an entry/exit trigger (the VectorBT/backtrader sense) nor the final directional output (that is the `bias`). A specific node role — distinct from a general node and from a strategy.

### sim
**Avoid:** —
The disjoint, executable unit of one deterministic harness run; the unit of parallelism (parallelism is *across* sims, never within one). Distinct from `backtest` (the replay framing) and `run` (the registry record).

### sim-optimal broker
**Avoid:** —
**Pre-reframe term, succeeded by the `R-evaluator`.** The deterministic, frictionless, perfect-fill broker (`SimBroker`) that consumes the **exposure stream** + prices and integrates `exposure·return` into synthetic pip equity to measure signal quality. The R-reframe replaces pips with R (the R-evaluator integrates per-trade R-outcomes from a flat-1R RiskExecutor); post-2026-06-28 reframe `SimBroker` is retained only as a legacy / optional pip yardstick (redundant for quality, not to be expanded).

### sink
**Avoid:** —
A node in its **recording role**: in `eval` it reads its inputs (and `ctx.now()`) and pushes the record to an out-of-graph destination it holds as a field (a channel, a chart handle, the run registry) — a role, not a type, so a node may be a pure consumer (no output) or record *and* forward an output in the same `eval` (the C8 "both" case). The sole recording and observability mechanism: displayable = exactly what a sink recorded.

### stage bootstrap
**Avoid:** mc annotation, bootstrap record
The `std::monte_carlo` stage's realization payload (0108/#200): a moving-block `r_bootstrap` of the stage's incoming R-evidence, recorded on the stage's `StageRealization` in one of two shapes — `pooled_oos` (ONE bootstrap over the preceding walk-forward's per-window OOS trade-R series, pooled in roll order) or `per_survivor` (`[ordinal, bootstrap]` per surviving member over its full in-sample series; ordinals index the population family). Each bootstrap carries `e_r` (quantiles of the resampled E[R] distribution), `prob_le_zero` = P[bootstrap E[R] ≤ 0], `n_trades`, `block_len`, `n_resamples`; seeded from the campaign doc's `seed` (C1). A zero-trade input records the defined all-zero degenerate — a null result is a valid research result.

### Sizer
**Avoid:** risk-manager
A **deploy** concept — sizing a trade in currency / lots from account equity — **not a research node**: per-trade R is **size-invariant** (size carries no information in R), so the Sizer and currency `size` / `volume` are removed from the research loop (the research executor is stop-rule → position-management in R). It owns size, not direction (bias) or the gate (Veto); "risk-manager" is avoided (in LEAN/nautilus that names the Veto layer, not the sizer).

### SoA
**Avoid:** Structure-of-Arrays
The columnar Structure-of-Arrays layout in which the four scalar base types are streamed on the hot path. Composite streams are bundles of base columns; the layout is what makes streaming cache- and SIMD-friendly.

### source
**Avoid:** —
Anything that produces timestamped scalar streams — market data and non-financial feeds (e.g. a news-bias node) are treated identically; a pure producer node. `data-server` is aura's first source.

### SQN
**Avoid:** system-quality-number (spell out once, then SQN)
System Quality Number — `√n · mean_R / stdev_R`: the dispersion- and trade-count-aware single-number objective for ranking a sweep family by R signal quality (cycle 0066; van Tharp). Higher is better; `n < 2` or zero-variance → 0. One of the R metrics. Its n-normalized variant **`sqn_normalized`** (SQN100 = `(mean_R / stdev_R) · √(min(n, 100))`, van Tharp's trade-count cap at 100) is turnover-robust across members with different trade counts and equals `sqn` below the cap (cycle 0067, #130).

### Stage 1 / Stage 2
**Avoid:** — (superseded)
**Superseded (2026-06-28 C10 reframe): there is no Stage-2 currency/compounding gate.** Research is one pure feed-forward R loop — gross R → net R via the `cost model` — with money, compounding, and a real broker living only at a separate later **live / deploy edge** (compounding is a post-hoc money-management transform of the net-R sequence, not an in-loop axis). The pre-reframe cleave gated a Stage-2 currency / fixed-fractional / realistic-broker layer behind `E[R] > 0`; **"Stage-1"** now survives only as a historical cycle name — the shipped feed-forward R chain's identifier family was renamed to the r-family (`r-sma` / `r-breakout` / `r-meanrev`, #174) — not one half of a two-stage gate.

### stderr class marker
**Avoid:** log level, severity tag
The stable prefix pair separating diagnostics on a continuing run: `aura: note: ` marks a benign, expected outcome (exit code unaffected), `aura: warning: ` a recorded fault or suspect condition the run survives. Error lines that accompany a non-zero exit and plain info lines keep the bare `aura: ` prefix — for errors, the exit-code partition (C14) is the machine contract.

### strategy
**Avoid:** —
A reusable composite-node blueprint — broker-, data-, and viz-independent, inputs declared as named roles — whose output is the **bias** stream (unsized direction + conviction; not an equity curve, not a size; sizing and the position table are derived downstream layers). Frozen with a broker into a bot for deploy.

### structural axes
**Avoid:** —
The harness's structural parameterization — which strategy, instrument(s), broker(s), window — whose variation selects *different* instances; together they form the experiment matrix. Contrasted with tuning params (numeric params swept within a fixed structure).

### sweep
**Avoid:** param-sweep, parameter sweep
An orchestration axis varying tuning params (grid or random) within a fixed structure. The inner, param-tuning loop, distinct from the structural experiment matrix. On a loaded blueprint every open knob (`--list-axes`) is **required** — a subset is refused with the missing knob named; pin an unwanted knob with a single-value axis (`--axis name=<one-value>`), there is no default. One raw namespace, `<node>.<param>` (a splice path keeps its interior path), is the only axis name (#328): `graph introspect --params` and `aura sweep --list-axes` are line-identical (open params bare, bound params with `default=`), and `--axis` accepts exactly that raw form on both sweep routes — the older `<blueprint>.<node>.<param>` wrapped form (e.g. `graph.fast.length`) is retired from the surface; naming it on `--axis` refuses (`axis names are raw node.param paths — use "fast.length" …`), and quoting it in a campaign document gets a did-you-mean toward the raw candidate. The `aura sweep` CLI verb is now thin sugar over the `campaign document` path — its blueprint form (`<bp.json> --real`) translates to a generated, content-addressed campaign run through the one executor (#210); the built-in `--strategy` sweep surface was retired by #159 (its hard-wired harnesses removed) — sweep now runs from a blueprint + `--axis`, and a retired `--strategy` token falls to the generic usage error. A ganged pair contributes ONE axis.

### tap
**Avoid:** probe, monitor, scope (for the observation slot — "probe" is taken by the sweep-terminal `blueprint_axis_probe` sense; the #77 `Recorder`→`Probe` rename was retired, 2026-07-21)
A named recorded stream produced by a recording `sink` — the addressable label (e.g. `equity`, `net_r_equity`) under which one sink's per-cycle output is persisted as a columnar (SoA) `ColumnarTrace` and selected for charting via `--tap`. Distinct from the `sink` node that emits it (a tap is the stream, the sink is the role) and from a whole recorded run (a bundle of taps); taps fire at their own cadences and are fused only by joining on the recorded timestamp, never by positional index. In a `campaign document`, `persist_taps` names taps from the CLOSED vocabulary `equity | exposure | r_equity | net_r_equity` (`tap_vocabulary`, 0109/#201) — a new observable is a new vocabulary entry or an authored blueprint sink, never an open node-path namespace. Persisted taps are charted by the printed handle: a campaign run's via the record's `trace_name`, a `sweep`/`walkforward --trace` family's via the family handle the run prints (`aura chart <handle>`; its members are keyed `<cell>/<member>` in the chart) — or, equivalently, by the `--trace <NAME>` the user chose, when `NAME` uniquely resolves against the recorded campaign documents (#238; a name reused across runs refuses rather than guessing).

Since C27 (#282) the word also names a second, author-facing sense: a **declared tap** — a `Composite.taps` entry `Tap { name, from: {node, field} }` a hand-authored blueprint declares on an interior output wire, the output-side twin of an `input_role`. It is a pure declaration (no channel endpoint); the harness binds it run-mode-aware (a single `aura run` constructs a recorder at each and persists the series through the trace store; a sweep leaves it unbound and inert). This is an OPEN, per-blueprint author-declared name — distinct from the CLOSED campaign `persist_taps` vocabulary above, which selects among fixed observables of the standard R-harness. Both senses land as `ColumnarTrace`s in the same trace store; the closed vocabulary is what a `campaign document` selects, the declared tap is what a blueprint author names.

Since #283 what CONSUMES a declared tap is itself declared per run by a **tap plan**: a subscription is either `Named { label, params }` — resolved against a layered **fold registry** whose core vocabulary is `record | count | sum | mean | min | max | first | last`, each entry carrying a doc line (the help surface and the roster-enumerating refusal) and a scalar-typed param schema (all core entries param-less; growth is a new Rust entry per C25, and higher layers register entries without touching the core) — or `Live(closure)`, the single non-data variant (an in-process consumer with consumer-owned loss policy). `record` streams the full series to the trace store at constant memory (no buffer-then-drain); folds keep an O(1) accumulator and land one summary row at finalize. Both declared-tap entry points are arms of the single verb `aura run` (`aura measure` is the post-hoc IC analysis over already-persisted traces and constructs no tap plan); `aura run` subscribes every declared tap to `record` by default, and its repeatable `--tap TAP=FOLD` selector (#310) replaces that default with an explicit plan — only listed taps are bound, unlisted taps stay unbound/inert. A fold's one summary row is emitted at finalize and stamped with the instant of the last contributing (warm) value — `first` alone pins the first contributing instant, and `min`/`max` deliberately do not carry the extremum's instant (ratified #335).

### topology hash
**Avoid:** —
The `content id` of a run's signal blueprint in its run-record role: stamped into the manifest as `topology_hash`, keying the reproduction store and anchoring `aura reproduce` — the same SHA-256 over the same canonical bytes. Distinct from the debug-name-blind `identity id`.

### use (op)
**Avoid:** —
The construction op that splices a **registered** blueprint into the building graph as a nested `composite` under a chosen instance name (`{"op":"use","ref":{"content_id"|"name":…},"name":…,"bind":{…}}`, #317): the reference — a content id, a unique content-id prefix, or a `blueprint label` — resolves CLI-side, before the engine ever sees it; the fetched composite is C29-gated, spliced, and its resolution echoed on stderr (`aura: note:`, the existing benign marker). The emitted blueprint carries the splice inline as an ordinary nested composite — no reference or registry dependency survives into the artifact. An instance's open input roles become its `<instance>.<role>` in-ports, its output boundary fields its `<instance>.<field>` out-fields — the existing nested-composite param-prefix discipline extends unchanged (`<instance>.<node>.<param>`, the raw axis form since #328). Pairs with the `input` op: a pattern meant to be `use`d declares its formal parameters as open `input` roles, left unbound at `finish()` (#317's open-pattern amendment) — only running it standalone requires them bound.

### veto
**Avoid:** risk-manager
The **optional** documented pre-trade-gate seam in the execution chain (`stop-rule → [Veto] → position-management`): position / exposure / notional caps that may reject or scale a trade. A pass-through identity DCE'd away when absent (C19/C23); kept as a named seam — it is what LEAN calls "Risk Management" and nautilus the RiskEngine.

### walk-forward
**Avoid:** —
An orchestration axis: rolling in-sample optimize + out-of-sample test across moving windows, stitched into one out-of-sample verdict plus parameter stability. As with `sweep`, every open knob named by `--list-axes` is **required** on a loaded blueprint — a subset is refused with the missing knob named; pin one with a single-value axis, there is no default. The `aura walkforward <blueprint.json> --real <sym> --axis <name>=<csv> …` CLI verb is thin sugar over the `campaign document` path — translated to a generated campaign (`std::sweep → std::walk_forward`) run through the one executor (#210; blueprint-generic over arbitrary blueprints and axes since #220).

### World
**Avoid:** —
The project's meta-level program that dynamically constructs and orchestrates *families* of harnesses (walk-forward / sweep / optimize / Monte-Carlo / comparison) — the research-orchestration World, not a game-engine scene world (Unreal's `UWorld`). aura's differentiator and product, as opposed to the single-backtest substrate.

### worst-case floor
**Avoid:** min-over-instruments
The headline cross-instrument generalization score: the minimum of a candidate's R-metric across the instruments, so a single strong market cannot flatter it (non-dominable by construction). The cross-instrument sibling of a worst-case **plateau selection**.