Brummel/Aura
1
0
Fork 0
Code Issues 31 Pull Requests Actions Packages Projects Releases Wiki Activity

Ratify a five-layer model and dispatch aura run on blueprint shape #286

New Issue
Closed
opened 2026-07-19 13:48:53 +02:00 by claude · 6 comments
claude commented 2026-07-19 13:48:53 +02:00
Collaborator
Copy Link
Copy Source

All file references are at engine commit 592750b.

The layer model (proposed as a ledger contract)

The stack's de-facto layering, made explicit, inside out:

  1. engine — the domain-free deterministic streaming substrate: aura-core plus the graph/compile/harness half of aura-engine (the determinism/causality/composition contracts C1–C9, construction C19, compilation C23, blueprint-as-data C24 in docs/design/INDEX.md). Verified free of trading vocabulary in production code: trading identifiers in crates/aura-engine/src/builder.rs occur only inside its test module (#[cfg(test)] opens at line 341).
  2. trading — the market vocabulary carrying no analysis or strategy intent: instruments, session anchoring, bar resampling, pip/point geometry (contract C15), market-data ingestion (aura-ingest). This layer exists but is unnamed: the aura-std roster mixes it with layer-1 arithmetic (SMA, Sub, CumSum, …) and layer-3b strategy nodes in one vocabulary.
  3. a — trading-analysis — descriptive measurement over market data: session statistics, conditional rates, distributions. The missing layer; evidence below.
    b — trading-strategy — bias signals, stops, R-evaluation: Bias/stop rules/PositionManagement in aura-std, the R-metric roster in aura-analysis, the process/campaign machinery. 3a and 3b are siblings: both consume layer 2, neither needs the other.
  4. trading-execution — money, sizing, the real broker, deploy. Already rigorously exiled to the deploy edge by contracts C10/C13 ("account money lives only at the live deploy edge"): the in-house precedent that a boundary of exactly this kind can be ratified and enforced.

The rule worth ratifying: an inner layer never imports an outer one, and 3a/3b are siblings — neither routes through the other. It is the same cut C10/C13 already made at the 3b|4 boundary, applied to the inner boundaries.

Verified violations at HEAD

The only run verb mandates layer 3b. dispatch_run refuses any blueprint without a bias output ("aura run expects a strategy with a bias output", crates/aura-cli/src/main.rs:3589-3603) and routes every run through run_signal_r → wrap_r with the reduce flag hardcoded false (main.rs:1721, main.rs:1750). wrap_r (main.rs:1489-1667) welds on SimBroker, the risk executor, and four to five per-cycle Recorder sinks — equity, exposure, the dense 14-column PM record ("Emits ONE dense record per cycle", crates/aura-std/src/position_management.rs:3), plus the r_equity tap — whose mpsc channels are drained only after the run completes (main.rs:1783-1785).

Measured consequence (single aura run, UK100 M1, warm page cache, peak RSS via /bin/time -f %M): a measurement-shaped blueprint — 33 closed-roster std nodes computing a session-anchored conditional statistic (5-minute candles at the 09:00 Europe/Berlin open via SessionFrankfurt + Resample, cross-candle values held via When plus the engine's sample-and-hold, group-keyed rates via value-gated CumSum, read out through declared taps) — runs only by exposing its statistic under the name bias, and then pays the full strategy scaffold: peak RSS 172 MB over 1y, 911 MB over 5y, 2013 MB over 12y — linear in cycles. With all six declared taps removed the 12y run still peaks at 2011 MB, so the retention is the mandatory wrap, not the tap drain (#283 targets the declared-tap drain path; at one tap firing per day that component is negligible here). The statistic itself is fully expressible in the closed std vocabulary: the data-only graph matched a standalone Rust reference implementation of the same statistic (a direct aura-ingest consumer) to under 0.1 percentage points over 12 years (conditional continuation rates 51.19% vs 51.23% and 47.42% vs 47.35%). The layer-3a computation exists; only its run path does not.

Layer 3a has no first-class surface. The metric vocabulary is R-only (aura process introspect --metrics: every rankable/gate metric is a strategy-run reduction), in-graph order statistics are excluded by design (the declared-taps contract C27 forbids them in-graph — "they stay sink/analysis-side"), and the only extraction seam is declared taps on a single run followed by offline reduction of the trace.

Layer 1 imports layer 3b. crates/aura-engine/Cargo.toml depends on aura-analysis, self-described in that file's comment as holding "the pure trading-domain reductions (R-metrics, the position-event table, the multiple-comparison hurdle math)", re-exported via report:: (#136 lifted these out of the engine's report module into aura-analysis; the engine still consumes and re-exports them). R-shaped production types sit inside the engine crate: bias_sign_flips (crates/aura-engine/src/mc.rs:41, mc.rs:89), resampled E[R] statistics (mc.rs:182-183). The ledger's description of the engine as domain-free (C10's phrase "the domain-free aura-engine") is aspiration, not fact, at HEAD.

Direction

  • A ledger contract naming the five layers and the import rule, with the C10/C13 deploy-edge cut as the template.
  • First concrete step, purely additive: the bias gate in dispatch_run becomes a shape dispatch. A blueprint exposing bias takes the current strategy path unchanged (byte-identical). A blueprint declaring only taps runs bare: bootstrap, run, drain the declared taps — no wrap_r, no broker/executor compute, no O(cycles) recording. Nothing that runs today changes behaviour, since a taps-only blueprint is currently refused outright; the bare path is new surface only. This gives 3a its run verb and removes the measured 2 GB retention for measurement runs at the root.
  • Later, independently: relocate the report:: R re-exports out of aura-engine (completing the #136 direction), and stratify the aura-std roster into layer-1 arithmetic / layer-2 session-and-geometry / layer-3b strategy nodes when a consumer warrants it.
All file references are at engine commit 592750b. ## The layer model (proposed as a ledger contract) The stack's de-facto layering, made explicit, inside out: 1. **engine** — the domain-free deterministic streaming substrate: `aura-core` plus the graph/compile/harness half of `aura-engine` (the determinism/causality/composition contracts C1–C9, construction C19, compilation C23, blueprint-as-data C24 in `docs/design/INDEX.md`). Verified free of trading vocabulary in production code: trading identifiers in `crates/aura-engine/src/builder.rs` occur only inside its test module (`#[cfg(test)]` opens at line 341). 2. **trading** — the market vocabulary carrying no analysis or strategy intent: instruments, session anchoring, bar resampling, pip/point geometry (contract C15), market-data ingestion (`aura-ingest`). This layer exists but is unnamed: the `aura-std` roster mixes it with layer-1 arithmetic (`SMA`, `Sub`, `CumSum`, …) and layer-3b strategy nodes in one vocabulary. 3. **a — trading-analysis** — descriptive measurement over market data: session statistics, conditional rates, distributions. The missing layer; evidence below. **b — trading-strategy** — bias signals, stops, R-evaluation: `Bias`/stop rules/`PositionManagement` in `aura-std`, the R-metric roster in `aura-analysis`, the process/campaign machinery. 3a and 3b are siblings: both consume layer 2, neither needs the other. 4. **trading-execution** — money, sizing, the real broker, deploy. Already rigorously exiled to the deploy edge by contracts C10/C13 ("account money lives only at the live deploy edge"): the in-house precedent that a boundary of exactly this kind can be ratified and enforced. The rule worth ratifying: an inner layer never imports an outer one, and 3a/3b are siblings — neither routes through the other. It is the same cut C10/C13 already made at the 3b|4 boundary, applied to the inner boundaries. ## Verified violations at HEAD **The only run verb mandates layer 3b.** `dispatch_run` refuses any blueprint without a `bias` output ("aura run expects a strategy with a bias output", `crates/aura-cli/src/main.rs:3589-3603`) and routes every run through `run_signal_r` → `wrap_r` with the `reduce` flag hardcoded `false` (`main.rs:1721`, `main.rs:1750`). `wrap_r` (`main.rs:1489-1667`) welds on `SimBroker`, the risk executor, and four to five per-cycle `Recorder` sinks — equity, exposure, the dense 14-column PM record ("Emits ONE dense record per cycle", `crates/aura-std/src/position_management.rs:3`), plus the `r_equity` tap — whose mpsc channels are drained only after the run completes (`main.rs:1783-1785`). Measured consequence (single `aura run`, UK100 M1, warm page cache, peak RSS via `/bin/time -f %M`): a measurement-shaped blueprint — 33 closed-roster std nodes computing a session-anchored conditional statistic (5-minute candles at the 09:00 Europe/Berlin open via `SessionFrankfurt` + `Resample`, cross-candle values held via `When` plus the engine's sample-and-hold, group-keyed rates via value-gated `CumSum`, read out through declared taps) — runs only by exposing its statistic under the name `bias`, and then pays the full strategy scaffold: peak RSS 172 MB over 1y, 911 MB over 5y, 2013 MB over 12y — linear in cycles. With all six declared taps removed the 12y run still peaks at 2011 MB, so the retention is the mandatory wrap, not the tap drain (#283 targets the declared-tap drain path; at one tap firing per day that component is negligible here). The statistic itself is fully expressible in the closed std vocabulary: the data-only graph matched a standalone Rust reference implementation of the same statistic (a direct `aura-ingest` consumer) to under 0.1 percentage points over 12 years (conditional continuation rates 51.19% vs 51.23% and 47.42% vs 47.35%). The layer-3a computation exists; only its run path does not. **Layer 3a has no first-class surface.** The metric vocabulary is R-only (`aura process introspect --metrics`: every rankable/gate metric is a strategy-run reduction), in-graph order statistics are excluded by design (the declared-taps contract C27 forbids them in-graph — "they stay sink/analysis-side"), and the only extraction seam is declared taps on a single run followed by offline reduction of the trace. **Layer 1 imports layer 3b.** `crates/aura-engine/Cargo.toml` depends on `aura-analysis`, self-described in that file's comment as holding "the pure trading-domain reductions (R-metrics, the position-event table, the multiple-comparison hurdle math)", re-exported via `report::` (#136 lifted these out of the engine's `report` module into `aura-analysis`; the engine still consumes and re-exports them). R-shaped production types sit inside the engine crate: `bias_sign_flips` (`crates/aura-engine/src/mc.rs:41`, `mc.rs:89`), resampled `E[R]` statistics (`mc.rs:182-183`). The ledger's description of the engine as domain-free (C10's phrase "the domain-free `aura-engine`") is aspiration, not fact, at HEAD. ## Direction - A ledger contract naming the five layers and the import rule, with the C10/C13 deploy-edge cut as the template. - First concrete step, purely additive: the `bias` gate in `dispatch_run` becomes a shape dispatch. A blueprint exposing `bias` takes the current strategy path unchanged (byte-identical). A blueprint declaring only taps runs bare: bootstrap, run, drain the declared taps — no `wrap_r`, no broker/executor compute, no O(cycles) recording. Nothing that runs today changes behaviour, since a taps-only blueprint is currently refused outright; the bare path is new surface only. This gives 3a its run verb and removes the measured 2 GB retention for measurement runs at the root. - Later, independently: relocate the `report::` R re-exports out of `aura-engine` (completing the #136 direction), and stratify the `aura-std` roster into layer-1 arithmetic / layer-2 session-and-geometry / layer-3b strategy nodes when a consumer warrants it.
claude added the idea label 2026-07-19 13:48:53 +02:00
claude added this to the Stratification — ladder, process column, shell milestone 2026-07-19 14:49:57 +02:00
claude self-assigned this 2026-07-19 14:58:07 +02:00
claude commented 2026-07-19 15:17:28 +02:00
Author
Collaborator
Copy Link
Copy Source

Phase 1 landed — C28 ratified; the engine → analysis edge is coupled to the deferred #147.

The stratification layer model is now a ledger contract: C28 — Internal stratification: the trading ladder, the process column, the shell (docs/design/INDEX.md). It states the inner-to-outer ladder (engine → market → {measurement | strategy} → backtest → execution), the process column beside the ladder, the shell outside, the import rule, and the six seams (five already-ratified contracts — C8/C24/C27/C18/C10-C13 — only the process-column ↔ metric interface new). Committed on branch worktree-issue-286-stratify (the commit also restores the ### C19 ledger header, accidentally deleted as collateral of ebe8568; its body had survived orphaned under C18).

The one hard production violation, verified: aura-engine → aura-analysis. crates/aura-engine/src/report.rs:20 re-exports the R-metrics, the position-event table, the hurdle math and the selection-provenance types; the generic-statistics kernel carries R/bias-typed fields (McAggregate.bias_sign_flips at crates/aura-engine/src/mc.rs:41, RBootstrap.e_r at mc.rs:182). Every other production edge points inward or is column-internal (independently re-checked).

Cutting this edge needs #147 — making RunReport / RunManifest generic over a metric type and abstracting the registry's optimize_deflated null-model, so domain metrics leave the engine crate. #147 was ratified deferred twice (2026-06-27 in the #136 thread; 2026-07-02, "leave it deferred"), on the grounds that it is a one-implementor abstraction until a genuine second metric consumer or cross-domain need appears, and that building it in anticipation is a strategic bet no source in the tree settles.

Scope of the block (the load-bearing nuance): #147 blocks only the engine-domain-freedom capstone — the edge cut. It does not block the measured win: measurement's bare run verb plus the ~2 GB peak-RSS reduction is the additive shape dispatch (phase 3), which touches no metric genericity; nor does it block the aura-std roster split (phase 4). So the "second consumer" condition the deferral waited on is only partially met — measurement gains its run verb without #147; only the ideal of a truly domain-free innermost layer requires it. Un-deferring #147 therefore remains the same build-in-anticipation bet, now weighed against the stratification goal rather than a forced concrete need.

Open decision: the order in which #147 (and the coupled edge cut + aura-analysis split) is sequenced against the #147-free wins (phase 3, phase 4).

**Phase 1 landed — C28 ratified; the `engine → analysis` edge is coupled to the deferred #147.** The stratification layer model is now a ledger contract: **C28 — Internal stratification: the trading ladder, the process column, the shell** (`docs/design/INDEX.md`). It states the inner-to-outer ladder (engine → market → {measurement | strategy} → backtest → execution), the process column beside the ladder, the shell outside, the import rule, and the six seams (five already-ratified contracts — C8/C24/C27/C18/C10-C13 — only the process-column ↔ metric interface new). Committed on branch `worktree-issue-286-stratify` (the commit also restores the `### C19` ledger header, accidentally deleted as collateral of `ebe8568`; its body had survived orphaned under C18). **The one hard production violation, verified:** `aura-engine → aura-analysis`. `crates/aura-engine/src/report.rs:20` re-exports the R-metrics, the position-event table, the hurdle math and the selection-provenance types; the generic-statistics kernel carries R/bias-typed fields (`McAggregate.bias_sign_flips` at `crates/aura-engine/src/mc.rs:41`, `RBootstrap.e_r` at `mc.rs:182`). Every other production edge points inward or is column-internal (independently re-checked). **Cutting this edge needs #147** — making `RunReport` / `RunManifest` generic over a metric type and abstracting the registry's `optimize_deflated` null-model, so domain metrics leave the engine crate. #147 was ratified **deferred twice** (2026-06-27 in the #136 thread; 2026-07-02, "leave it deferred"), on the grounds that it is a one-implementor abstraction until a genuine second metric consumer or cross-domain need appears, and that building it in anticipation is a strategic bet no source in the tree settles. **Scope of the block (the load-bearing nuance):** #147 blocks only the engine-domain-freedom capstone — the edge cut. It does **not** block the measured win: measurement's bare run verb plus the ~2 GB peak-RSS reduction is the additive shape dispatch (phase 3), which touches no metric genericity; nor does it block the `aura-std` roster split (phase 4). So the "second consumer" condition the deferral waited on is only partially met — measurement gains its run verb without #147; only the ideal of a truly domain-free innermost layer requires it. Un-deferring #147 therefore remains the same build-in-anticipation bet, now weighed against the stratification goal rather than a forced concrete need. **Open decision:** the order in which #147 (and the coupled edge cut + `aura-analysis` split) is sequenced against the #147-free wins (phase 3, phase 4).
claude commented 2026-07-19 15:22:45 +02:00
Author
Collaborator
Copy Link
Copy Source

Sequencing decided (2026-07-19): the #147-free wins first.

Order: phase 3 (measurement's bare run verb + the ~2 GB peak-RSS reduction) and the aura-std roster split first — additive and #147-free — then #147 (the RunReport<M> genericity) together with the coupled engine → analysis edge cut and the aura-analysis split as one block.

#147 stays open as that block's prerequisite; its twice-ratified deferral is lifted for this milestone (it will be solved when the coupled block is reached, not kept indefinitely deferred). The alternative of leaving engine → analysis as a permanent documented violation was declined.

**Sequencing decided (2026-07-19): the #147-free wins first.** Order: phase 3 (measurement's bare run verb + the ~2 GB peak-RSS reduction) and the `aura-std` roster split first — additive and #147-free — then #147 (the `RunReport<M>` genericity) together with the coupled `engine → analysis` edge cut and the `aura-analysis` split as one block. #147 stays open as that block's prerequisite; its twice-ratified deferral is lifted for this milestone (it will be solved when the coupled block is reached, not kept indefinitely deferred). The alternative of leaving `engine → analysis` as a permanent documented violation was declined.
claude commented 2026-07-19 15:36:11 +02:00
Author
Collaborator
Copy Link
Copy Source

Phase-3 design decisions (specify) — the measurement run verb.

Recording the derived decisions for the shape-dispatch work — the third of the six phases enumerated in the Status block of ledger contract C28 (docs/design/INDEX.md; the tracker milestone carries the same list, but a comment cannot link a milestone, so the ledger Status is the reachable anchor). Spec: measurement-run-verb (git-ignored working file, not committed).

  • Dispatch (derived). aura run shape-dispatches on the loaded blueprint's output: a bias port → the current run_signal_r path, byte-identical; no bias + ≥1 declared tap → a new bare run_measurement; neither → refuse (inert). Basis: #286's proposal; the bias refusal at crates/aura-cli/src/main.rs:3595 becomes the branch point; the closed-blueprint guard stays on both paths.
  • Bare compute (derived). run_measurement = run_signal_r (crates/aura-cli/src/main.rs:1721) minus wrap_r and the eq/ex/r R-evaluation, keeping the C27 tap bind → drain → persist verbatim. No broker, no risk executor, no O(cycles) recorders — this is where the measured ~2 GB retention is removed.
  • Output contract (derived). A bare run has no broker → no equity/exposure rows → RunReport/summarize do not apply. A new MeasurementReport { manifest, taps: [names] } mirrors the persisted index.json shape; RunManifest.broker (a required String, report.rs:52) carries an interim "measurement" sentinel. Basis: consistency with the existing RunReport serde + trace_store persistence, weighed against risk — the honest broker: Option<String> model is deferred to the #147 metric-genericity block so this phase stays #147-free and the strategy-path C18 goldens byte-identical.

None of the three is a pure-preference fork — each is derivable from the sources, the existing serde, or relative risk — so decided here rather than bounced.

**Phase-3 design decisions (specify) — the measurement run verb.** Recording the derived decisions for the shape-dispatch work — the third of the six phases enumerated in the Status block of ledger contract **C28** (`docs/design/INDEX.md`; the tracker milestone carries the same list, but a comment cannot link a milestone, so the ledger Status is the reachable anchor). Spec: `measurement-run-verb` (git-ignored working file, not committed). - **Dispatch (derived).** `aura run` shape-dispatches on the loaded blueprint's output: a `bias` port → the current `run_signal_r` path, byte-identical; no `bias` + ≥1 declared tap → a new bare `run_measurement`; neither → refuse (inert). Basis: #286's proposal; the `bias` refusal at `crates/aura-cli/src/main.rs:3595` becomes the branch point; the closed-blueprint guard stays on both paths. - **Bare compute (derived).** `run_measurement` = `run_signal_r` (`crates/aura-cli/src/main.rs:1721`) minus `wrap_r` and the eq/ex/r R-evaluation, keeping the C27 tap bind → drain → persist verbatim. No broker, no risk executor, no O(cycles) recorders — this is where the measured ~2 GB retention is removed. - **Output contract (derived).** A bare run has no broker → no equity/exposure rows → `RunReport`/`summarize` do not apply. A new `MeasurementReport { manifest, taps: [names] }` mirrors the persisted `index.json` shape; `RunManifest.broker` (a required `String`, `report.rs:52`) carries an interim `"measurement"` sentinel. Basis: consistency with the existing `RunReport` serde + `trace_store` persistence, weighed against risk — the honest `broker: Option<String>` model is deferred to the #147 metric-genericity block so this phase stays #147-free and the strategy-path C18 goldens byte-identical. None of the three is a pure-preference fork — each is derivable from the sources, the existing serde, or relative risk — so decided here rather than bounced.
claude commented 2026-07-19 15:42:37 +02:00
Author
Collaborator
Copy Link
Copy Source

Spec auto-signed (specify Step 6, /boss) — the measurement run verb.

The measurement-run-verb spec — phase 3 of the plan in C28's Status block (measurement's bare run verb via aura run shape-dispatch) — was signed autonomously. Under /boss the signature is the Step-5 grounding-check PASS, an independent fresh-context agent's verdict against currently-green tests, not the orchestrator's own confidence; no human signed at this gate.

All load-bearing assumptions are ratified by named, currently-green tests: a tap-only / no-bias graph compiles + bootstraps + runs (crates/aura-engine/tests/bind_tap_e2e.rs, flat_taps_e2e.rs, and harness::tests::flat_graph_taps_are_inert_scaffolding_at_bootstrap); the pre-compile tap predicate; RunManifest.broker as a required String (report.rs:52); today's no-bias refusal (run_refuses_a_non_bias_output_blueprint); and the declared-tap persist round-trip (tap_recording.rs).

Two corrections the check surfaced — mechanism ratified, only names differ: the pre-compile predicate is Composite::taps() -> &[Tap] (crates/aura-engine/src/blueprint.rs:242), not the spec's provisional declared_taps() (!signal.taps().is_empty()); and declared taps persist under runs/traces/<name>/<tap>.json, not runs/<name>/….

The spec is a git-ignored working file (never committed); the design's durable record is contract C28 in the ledger.

**Spec auto-signed (specify Step 6, `/boss`) — the measurement run verb.** The `measurement-run-verb` spec — phase 3 of the plan in C28's Status block (measurement's bare run verb via `aura run` shape-dispatch) — was signed autonomously. Under `/boss` the signature is the Step-5 `grounding-check` **PASS**, an independent fresh-context agent's verdict against currently-green tests, not the orchestrator's own confidence; no human signed at this gate. All load-bearing assumptions are ratified by named, currently-green tests: a tap-only / no-`bias` graph compiles + bootstraps + runs (`crates/aura-engine/tests/bind_tap_e2e.rs`, `flat_taps_e2e.rs`, and `harness::tests::flat_graph_taps_are_inert_scaffolding_at_bootstrap`); the pre-compile tap predicate; `RunManifest.broker` as a required `String` (`report.rs:52`); today's no-`bias` refusal (`run_refuses_a_non_bias_output_blueprint`); and the declared-tap persist round-trip (`tap_recording.rs`). Two corrections the check surfaced — mechanism ratified, only names differ: the pre-compile predicate is `Composite::taps() -> &[Tap]` (`crates/aura-engine/src/blueprint.rs:242`), not the spec's provisional `declared_taps()` (`!signal.taps().is_empty()`); and declared taps persist under `runs/traces/<name>/<tap>.json`, not `runs/<name>/…`. The spec is a git-ignored working file (never committed); the design's durable record is contract C28 in the ledger.
claude commented 2026-07-19 16:10:46 +02:00
Author
Collaborator
Copy Link
Copy Source

Phase 3 landed on the branch (commit 34ff539, unmerged).

aura run now shape-dispatches on the loaded blueprint: a bias output → the existing strategy path (byte-identical); no bias + ≥1 declared tap → a bare run_measurement (bootstrap → run → drain taps, no wrap_r, no broker/executor/eq-ex-r recorders); neither → refuse. A new MeasurementReport { manifest, taps } is the stdout/record shape (no R metrics — a bare run has no broker); broker carries the interim "measurement" sentinel.

Verified (orchestrator-run, not agent-reported): cargo test --workspace green — the bias path byte-identical, C18 goldens untouched, the regression test run_refuses_a_non_bias_output_blueprint still green (its blueprint has a non-bias output but no tap → still refused, now via the three-way else); cargo clippy --workspace --all-targets -- -D warnings clean; the RED E2E measurement_blueprint_runs_bare_and_emits_its_tap green. run_signal_r is byte-identical (the tap machinery is duplicated into run_measurement, not extracted).

The measurement arm's closed-blueprint guard uses signal.param_space(), not blueprint_axis_probe — the latter welds wrap_r by the bias port and would panic on a no-bias signal (the exact reason the old bias-refusal existed).

**Phase 3 landed on the branch** (commit `34ff539`, unmerged). `aura run` now shape-dispatches on the loaded blueprint: a `bias` output → the existing strategy path (byte-identical); no `bias` + ≥1 declared tap → a bare `run_measurement` (bootstrap → run → drain taps, no `wrap_r`, no broker/executor/eq-ex-r recorders); neither → refuse. A new `MeasurementReport { manifest, taps }` is the stdout/record shape (no R metrics — a bare run has no broker); `broker` carries the interim `"measurement"` sentinel. Verified (orchestrator-run, not agent-reported): `cargo test --workspace` green — the `bias` path byte-identical, C18 goldens untouched, the regression test `run_refuses_a_non_bias_output_blueprint` still green (its blueprint has a non-`bias` output but no tap → still refused, now via the three-way `else`); `cargo clippy --workspace --all-targets -- -D warnings` clean; the RED E2E `measurement_blueprint_runs_bare_and_emits_its_tap` green. `run_signal_r` is byte-identical (the tap machinery is duplicated into `run_measurement`, not extracted). The measurement arm's closed-blueprint guard uses `signal.param_space()`, not `blueprint_axis_probe` — the latter welds `wrap_r` by the `bias` port and would panic on a no-`bias` signal (the exact reason the old `bias`-refusal existed).
claude commented 2026-07-20 11:19:30 +02:00
Author
Collaborator
Copy Link
Copy Source

Both of this issue's deliverables are shipped on main (origin/main at b39fd63):

  • Phase 1 — the trading-ladder layer model ratified as ledger contract C28
    (docs/design/INDEX.md), commit 1c49d5d.
  • Phase 3 — aura run shape-dispatch giving the measurement layer its bare run
    verb (no strategy scaffold on a taps-only blueprint), commit 34ff539.

Closing as complete. The rest of the Stratification milestone lives elsewhere: the
aura-std layer-crate split in #288 (done), the follow-up windowed-fold factoring
in #289, and the #147-coupled block (phases 2/5/6 — cut the aura-engine →
aura-analysis edge + generify the metric interface), which reverses a ratified
deferral and is reserved to the user.

Both of this issue's deliverables are shipped on `main` (`origin/main` at `b39fd63`): - **Phase 1** — the trading-ladder layer model ratified as ledger contract **C28** (`docs/design/INDEX.md`), commit `1c49d5d`. - **Phase 3** — `aura run` shape-dispatch giving the measurement layer its bare run verb (no strategy scaffold on a taps-only blueprint), commit `34ff539`. Closing as complete. The rest of the Stratification milestone lives elsewhere: the `aura-std` layer-crate split in #288 (done), the follow-up windowed-fold factoring in #289, and the #147-coupled block (phases 2/5/6 — cut the `aura-engine` → `aura-analysis` edge + generify the metric interface), which reverses a ratified deferral and is reserved to the user.
Sign in to join this conversation.
No Branch/Tag Specified
Branches Tags
Labels
Clear labels
BLOCKER
Core functionality blocked; preempts other selection
 bug
Observable misbehaviour
 feature
Substantial extension; no full spec required
 idea
Droppable; no commitment
No Label idea
Milestone
No items
No Milestone Stratification — ladder, process column, shell
Projects
Clear projects
No project
Assignees
Clear assignees
claude (Claude) Brummel
No Assignees claude
1 Participants
Notifications
Due Date
No due date set.
Dependencies

No dependencies set.

Reference: Brummel/Aura#286
Delete Branch "%!s()"

Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?