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.

---

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.

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).

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-std) 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). SessionFrankfurt bakes the Frankfurt 09:00 Europe/Berlin open with a single period_minutes knob; 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. aura sweep --axis takes the --list-axes-printed, root-composite-wrapped name (e.g. graph.fast.length) — not the raw param_space name (fast.length) that graph introspect --params and a campaign document's axes use; the CLI strips exactly one leading wrapper segment (#210). 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 ColumnarTraces 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 CLI verbs (aura run, aura measure) pass a record-all plan, so their semantics are unchanged.

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.

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.