feat(std): meaning lines for all 27 shipped node schemas

C29 compile/unit seam, task 3 of the self-description plan: every
aura-std NodeSchema literal threads its one-line doc. Four texts were
corrected against the actual eval/finalize semantics rather than taken
from the plan table verbatim: Delay is a lag-N register (not one-step),
GatedRecorder flushes an ungated final row at finalize, Latch is a
level-sensitive set/reset register (captures no input), SeriesReducer
emits its single summary row at finalize (not per cycle).

Gate: cargo build -p aura-std --lib clean; full std test run follows at
the all-crates gate once strategy/backtest/engine thread their sites
(the earlier per-crate test gate was unsatisfiable in isolation --
std's dev-deps pull crates whose sites belong to later tasks).

refs #316

crates/aura-std/src/abs.rs

@@ -23,6 +23,7 @@ impl Abs {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "value".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "absolute value of the input series",
             },
             |_| Box::new(Abs::new()),
         )

crates/aura-std/src/add.rs

@@ -38,6 +38,7 @@ impl Add {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "elementwise sum of two input series",
             },
             |_| Box::new(Add::new()),
         )

crates/aura-std/src/and.rs

@@ -37,6 +37,7 @@ impl And {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::Bool }],
                 params: vec![],
+                doc: "logical AND of two boolean series",
             },
             |_| Box::new(And::new()),
         )

crates/aura-std/src/const_node.rs

@@ -33,6 +33,7 @@ impl Const {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "clock".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "value".into(), kind: ScalarKind::F64 }],
+                doc: "constant-valued stream from a single param",
             },
             |p| Box::new(Const::new(p[0].f64())),
         )

crates/aura-std/src/cumsum.rs

@@ -53,6 +53,7 @@ impl CumSum {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "series".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "running cumulative sum of the input series",
             },
             |_| Box::new(CumSum::new()),
         )

crates/aura-std/src/delay.rs

@@ -65,6 +65,7 @@ impl Delay {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "series".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "lag".into(), kind: ScalarKind::I64 }],
+                doc: "emits the input from `lag` cycles ago — the explicit delay register (C5)",
             },
             |p| Box::new(Delay::new(p[0].i64() as usize)),
         )

crates/aura-std/src/div.rs

@@ -30,6 +30,7 @@ impl Div {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "elementwise quotient of two input series",
             },
             |_| Box::new(Div::new()),
         )

crates/aura-std/src/ema.rs

@@ -63,6 +63,7 @@ impl Ema {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "series".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "length".into(), kind: ScalarKind::I64 }],
+                doc: "exponential moving average over the input series",
             },
             |p| Box::new(Ema::new(p[0].i64() as usize)),
         )

crates/aura-std/src/eqconst.rs

@@ -40,6 +40,7 @@ impl EqConst {
                 inputs: vec![PortSpec { kind: ScalarKind::I64, firing: Firing::Any, name: "value".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::Bool }],
                 params: vec![ParamSpec { name: "target".into(), kind: ScalarKind::I64 }],
+                doc: "true where the input equals a constant param",
             },
             |p| Box::new(EqConst::new(p[0].i64())),
         )

crates/aura-std/src/gated_recorder.rs

@@ -41,7 +41,12 @@ impl GatedRecorder {
         let build_kinds = kinds.clone();
         PrimitiveBuilder::new(
             "GatedRecorder",
-            NodeSchema { inputs, output: vec![], params: vec![] }, // sink: empty output (C8)
+            NodeSchema {
+                inputs,
+                output: vec![],
+                params: vec![],
+                doc: "recording sink that persists its input while the gate is true, plus a final row at finalize",
+            }, // sink: empty output (C8)
             move |_| Box::new(GatedRecorder::new(&build_kinds, gate_col, tx.clone())),
         )
     }

crates/aura-std/src/gt.rs

@@ -39,6 +39,7 @@ impl Gt {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::Bool }],
                 params: vec![],
+                doc: "true where the first input exceeds the second",
             },
             |_| Box::new(Gt::new()),
         )

crates/aura-std/src/latch.rs

@@ -46,6 +46,7 @@ impl Latch {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "level-sensitive set/reset register holding 1.0 when latched, 0.0 when reset",
             },
             |_| Box::new(Latch::new()),
         )

crates/aura-std/src/lincomb.rs

@@ -52,7 +52,12 @@ impl LinComb {
             .collect();
         PrimitiveBuilder::new(
             "LinComb",
-            NodeSchema { inputs, output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }], params },
+            NodeSchema {
+                inputs,
+                output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
+                params,
+                doc: "linear combination of its inputs with constant weights",
+            },
             |p| Box::new(LinComb::new(
                 p.iter().map(|c| c.f64()).collect(),
             )),

crates/aura-std/src/max.rs

@@ -26,6 +26,7 @@ impl Max {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "elementwise maximum of two input series",
             },
             |_| Box::new(Max::new()),
         )

crates/aura-std/src/min.rs

@@ -27,6 +27,7 @@ impl Min {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "elementwise minimum of two input series",
             },
             |_| Box::new(Min::new()),
         )

crates/aura-std/src/mul.rs

@@ -24,6 +24,7 @@ impl Mul {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "elementwise product of two input series",
             },
             |_| Box::new(Mul::new()),
         )

crates/aura-std/src/recorder.rs

@@ -53,7 +53,12 @@ impl Recorder {
         let build_kinds = kinds.clone();
         PrimitiveBuilder::new(
             "Recorder",
-            NodeSchema { inputs, output: vec![], params: vec![] }, // sink: empty output (C8)
+            NodeSchema {
+                inputs,
+                output: vec![],
+                params: vec![],
+                doc: "recording sink persisting its input series into the trace store",
+            }, // sink: empty output (C8)
             move |_| Box::new(Recorder::new(&build_kinds, firing, tx.clone())),
         )
     }

crates/aura-std/src/rolling_max.rs

@@ -54,6 +54,7 @@ impl RollingMax {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "series".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "length".into(), kind: ScalarKind::I64 }],
+                doc: "rolling maximum over a fixed lookback window",
             },
             |p| Box::new(RollingMax::new(p[0].i64() as usize)),
         )

crates/aura-std/src/rolling_min.rs

@@ -43,6 +43,7 @@ impl RollingMin {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "series".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "length".into(), kind: ScalarKind::I64 }],
+                doc: "rolling minimum over a fixed lookback window",
             },
             |p| Box::new(RollingMin::new(p[0].i64() as usize)),
         )

crates/aura-std/src/scale.rs

@@ -28,6 +28,7 @@ impl Scale {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "signal".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "factor".into(), kind: ScalarKind::F64 }],
+                doc: "input multiplied by a constant factor param",
             },
             |p| Box::new(Scale::new(p[0].f64())),
         )

crates/aura-std/src/select.rs

@@ -38,6 +38,7 @@ impl Select {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "chooses between two inputs by a boolean selector",
             },
             |_| Box::new(Select::new()),
         )

crates/aura-std/src/series_reducer.rs

@@ -26,6 +26,7 @@ impl SeriesReducer {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing, name: "col[0]".to_string() }],
                 output: vec![], // sink: empty output (C8)
                 params: vec![],
+                doc: "folds an input series into a single summary row emitted at finalize",
             },
             move |_| Box::new(SeriesReducer::new(tx.clone())),
         )

crates/aura-std/src/sign.rs

@@ -36,6 +36,7 @@ impl Sign {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "value".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "sign of the input: -1, 0 or +1",
             },
             |_| Box::new(Sign::new()),
         )

crates/aura-std/src/sma.rs

@@ -65,6 +65,7 @@ impl Sma {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "series".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "length".into(), kind: ScalarKind::I64 }],
+                doc: "simple moving average over the input series",
             },
             |p| Box::new(Sma::new(p[0].i64() as usize)),
         )

crates/aura-std/src/sqrt.rs

@@ -23,6 +23,7 @@ impl Sqrt {
                 inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "value".into() }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "square root of the input series",
             },
             |_| Box::new(Sqrt::new()),
         )

crates/aura-std/src/sub.rs

@@ -29,6 +29,7 @@ impl Sub {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "elementwise difference of two input series",
             },
             |_| Box::new(Sub::new()),
         )

crates/aura-std/src/when.rs

@@ -46,6 +46,7 @@ impl When {
                 ],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "emits the input only on cycles where the condition input is true",
             },
             |_| Box::new(When::new()),
         )