8b2defa6538925719a375ebdc30d0f0ba6fc201b
163 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Brummel
|
27f0f8ea11 |
audit(0099): cycle close — CLI clap adoption; ledger refreshed (C14); rm ephemeral spec/plan
Architect drift review (scope 780d823..HEAD, the sole gate — no regression script) returned one medium ledger-gap, now resolved; otherwise drift-clean with a positive What-holds: - invariant 8 / C16 engine-domain separation preserved: clap is confined to crates/aura-cli/Cargo.toml; the whole diff touches only aura-cli/ + Cargo.lock + ephemeral docs; no engine/std/composites/analysis/registry/core/ingest crate mentions clap, so the frozen deploy artifact structurally cannot pick it up (aura-cli is a leaf binary). The 16 new lock entries are exactly clap's tree. - C16 per-case admission honest: clap admitted with a documented rationale at the Cargo.toml site (replaces the hand-rolled parser + ten help surfaces; dev-loop tax, not frozen-artifact tax), the same admission form as sha2/libc. - C14 automation-face served, execution layer intact: the usage=2/runtime=1 partition, scoped --help, --version, and GNU flags match the spec; the domain fns keep their signatures (arg-plumbing via thin *_from adapters); new behaviour is pinned (partition property test, version, scoped-help, dual-grammar stray-positional guard). Ledger refreshed: the C14 realization block now records the clap adoption + the exit-code partition (usage=2/runtime=1) as a durable automation contract, before the ephemeral spec that first stated it is removed (the drift item the architect raised). Deferred/forward: error-message casing normalization (#179, idea); the machine-first help surface stays on the #157/C21 track (Fork B settled this cycle as human/GNU convention compliance). Verified green (orchestrator, this session): cargo build --workspace clean; cargo clippy --workspace --all-targets -- -D warnings clean; cargo test --workspace green. Cycle drift-clean. closes #175 |
||
|
Brummel
|
e2e3a51c6c |
spec: 0098 CLI GNU/clig.dev compliance via clap adoption (boss-signed)
Replace the hand-rolled aura-cli argv parser with a clap derive parser: scoped `aura <sub> --help`, `--version`/`-V`, a per-flag Options section, and `--flag=value`/`--`/long-opt abbreviation for free. Two iterations — (1) clap migration, behaviour-preserving on exit codes; (2) exit-code split (usage=2, runtime=1). clap is admitted under the C16 per-case review (research-side CLI, invariant 8 untouched). Forks ratified by the user (clap over hand-rolled; GNU-compliance over the machine-first reframe; exit-code Option A) and the three spec-time derived decisions (dual-grammar clap mapping, parse-vs-runtime exit classification, two-iteration split) are recorded on #175. Boss-signed on grounding-check PASS (independent, fresh-context; 13 current-behaviour assumptions all ratified by named green tests). refs #175 |
||
|
Brummel
|
780d823067 |
fieldtest: World/C21 milestone — 4 examples, 9 findings (functional promise holds)
Milestone-close validation of the World/C21 blueprint-data family surface, run
from the PUBLIC interface only (design ledger + op-script grammar; blueprints
authored as a consumer via `aura graph build`, no crates/ source read). Binary
built from
|
||
|
Brummel
|
4710fccf32 |
audit(0097): cycle close — IS-refit walk-forward over a loaded blueprint; ledger refreshed (C24/C18); rm ephemeral spec/plan
cycle 0097 tidy (clean). Architect drift review over 485f3c8..HEAD: no code drift, no debt. Regression: no dedicated script (architect is the sole gate); its "What holds" is non-empty (design commitments confirmed against the diff): - Inv. 8 / 9: the cycle touches only crates/aura-cli (main.rs + cli_run.rs + the ephemeral spec/plan); walk_forward/WindowRoller/FamilyKind::WalkForward/ append_family/put_blueprint are read-only reuse, no engine/registry change. - Inv. 1 / 2: blueprint_walkforward_family reuses the generic walk_forward roller (windows disjoint-parallel, across-sim); each IS-sweep/OOS-run sees only its window's windowed_sources; IS precedes OOS per window — no look-ahead. - Reproduce lockstep: the reproduce_family_in WalkForward arm rebuilds each OOS slice from stored.manifest.window (before the _ => run_sources fallthrough that would rebuild the wrong full-window source); winner params via the shared manifest->cells recovery; pinned by the reproduces_bit_identically E2E. - Structural mirror + panic-safety: one-substitution-deep twin of the hard-wired Stage1R arm (select_winner + walk_forward reused, metric sqn_normalized); run_blueprint_walkforward follows the content-addressed sibling pattern (no ensure_name_free); blueprint_sweep_over returns Result<_,BindError>, a bad axis is in-closure exit 2 (never a panic); run_oos_blueprint derives pip internally (7 args, no #[allow]). Ledger: refreshed the C24 realization block (docs/design/INDEX.md) — replaced the now-false "Walk-forward is deferred (#173, dep #169)" sentence with the "IS-refit walk-forward shipped (cycle 0097)" note; and extended the C18 reproduction note — reproduce now spans the third family kind (WalkForward), so all three FamilyKind variants persist AND reproduce through the one shared topology_hash+put_blueprint hook. Milestone: the World/C21 blueprint-data family surface (run/sweep/mc/walkforward/ list-axes/reproduce) is coherent and complete per the architect review — no structural gap. This audit proves drift-clean; a green end-to-end MILESTONE FIELDTEST remains the deliberate gate to formally close the World/C21 milestone. Ephemeral spec/plan git-rm'd per the lifecycle convention. refs #173 |
||
|
Brummel
|
1e2ac82473 |
spec: 0097 IS-refit walk-forward over a loaded blueprint (boss-signed)
Add `aura walkforward <blueprint.json> --axis <name>=<csv> [--axis …]`: a true in-sample-refit walk-forward over a loaded blueprint (Arm A, #173). Per IS window it re-optimizes the blueprint's params over the user's --axis grid, selects the winner by sqn_normalized, runs it out-of-sample, and aggregates the per-window OOS reports into a FamilyKind::WalkForward family that is content-addressed (put_blueprint) and aura-reproduce-aware. Closes the World/C21 milestone's last piece (the walk-forward half of #170). Design (Arm A settled by the user; sub-forks derived and recorded on #173): the loaded-blueprint WF mirrors the hard-wired stage1-r walk-forward arm one substitution deep — the generic engine walk_forward driver + select_winner + the 24/12/12 synthetic schedule are reused verbatim; only the per-window IS-sweep and OOS-run source the loaded blueprint (wrap_stage1r via cycle-0096's blueprint_axis_probe) over the user --axis grid. Persist + reproduce ship together (coupled — a persisted family with no store hook is unreproducible, the #170 hazard); the reproduce WalkForward branch reconstructs each OOS window's windowed source + winner params from the member manifest, mirroring the 0095 MonteCarlo branch. Loaded members are reduce-mode (R-metrics, no raw pip curve), so the WF is measured in R (oos_r), stitched pip-equity empty — consistent with the C10 R-first yardstick. Boss-signed on grounding-check PASS (independent, fresh-context; all 8 load-bearing current-behaviour assumptions ratified by named green tests — incl. an empirically-confirmed one: a loaded-blueprint member carries and ranks by sqn_normalized. One spec-internal tension flagged + fixed before sign). Engine/registry untouched (invariants 1/2/8/9). refs #173 |
||
|
Brummel
|
485f3c8c89 |
audit(0096): cycle close — axis discovery over a loaded blueprint; ledger refreshed (C24); rm ephemeral spec/plan
cycle 0096 tidy (clean). Architect drift review over ebebc24..HEAD: no drift, no debt. Regression: no dedicated script (architect is the sole gate); its "What holds" is non-empty (design commitments confirmed against the diff + a green test run, not the commit body): - Inv. 8 / 9: the cycle touches only crates/aura-cli (main.rs + cli_run.rs + the ephemeral spec/plan) — no engine/registry/blueprint.rs change; those are read-only callees. - Inv. 1: --list-axes is a pure read-only probe (short-circuits before run_blueprint_sweep; builds the wrapped composite, reads param_space, prints — no run, no seed, no engine execution). - Behaviour-preserving single-source: blueprint_axis_probe is token-identical to the two former inline probes; three copies (sweep/mc/list) collapse to one; the reload closures survive (topology_hash + per-member run); clippy -D warnings clean, no dead code; the subsumed tests (blueprint_sweep_member_equals_single_run_and_shares_topology_hash, blueprint_mc_family_rejects_an_open_blueprint) stayed green. - The blueprint_axis_probe .expect is not a latent panic: the ["sweep",..] arm validates blueprint_from_json first (exit 2), pinned by the shipped aura_sweep_list_axes_rejects_malformed_blueprint E2E (no panic). Ledger: refreshed the C24 realization block (docs/design/INDEX.md) — reclassified the "axis-name discovery surface" from tracked debt to shipped (cycle 0096), recording the single-sourced blueprint_axis_probe and the listed==swept-by- construction property. Per-member trace-writing (#168) remains the one tracked debt in that block. Milestone World/C21 stays OPEN — the walk-forward half (#173, IS-refit, now unblocked by this #169) remains. Ephemeral spec/plan git-rm'd per the lifecycle convention. refs #169 |
||
|
Brummel
|
a78a0557f4 |
spec: 0096 discover a loaded blueprint's sweepable axes (boss-signed)
Add `aura sweep <blueprint.json> --list-axes`: a read-only query sub-mode that lists a loaded blueprint's open sweepable knobs (one `<name>:<kind>` per line, param_space() order), then exits. Closes the discovery gap #169 surfaced — today the only way to learn the axis names is to guess one and read a MissingKnob/UnknownKnob error, and that error names only the rejected knob, never the valid set. Prerequisite for #173 (IS-refit walk-forward must know which axes to re-fit per in-sample window). Derived surface decision (recorded on #169): the query lands on the SWEEP verb, not `graph introspect`. The axis names `--axis` accepts are produced by the sweep's own harness-wrapping — the loaded signal (name "stage1_signal") is nested via wrap_stage1r as a BlueprintNode::Composite, so collect_params prefixes the names (stage1_signal.fast.length), NOT the raw param_space (fast.length; empirically: the bare name → UnknownKnob). Only the sweep verb, which owns the wrapping, can print the names the user will actually pass; a shared blueprint_axis_probe single-sources the probe for both the sweep terminal and --list-axes, so listed == swept by construction (and stays correct across #159's harness retirement). Boss-signed on grounding-check PASS (independent, fresh-context; one BLOCK raised + fixed: the malformed-sweep .expect panic-path is now pinned by a this-cycle E2E over unknown_node.json, not an untested current-behaviour claim). Engine/registry untouched (invariants 1/8/9). refs #169 |
||
|
Brummel
|
ebebc2401b |
audit(0095): cycle close — MC over a loaded blueprint; ledger refreshed (C18/C21); rm ephemeral spec/plan
Architect drift review (scope cec7811..HEAD, the sole gate — no regression script) returned drift-clean with positive What-holds: - invariants 8/9: the whole cycle is aura-cli (main.rs + cli_run.rs + ephemeral docs); nothing entered aura-engine/aura-registry; FamilyKind::MonteCarlo, monte_carlo, append_family, mc_member_reports are pre-existing seams reused. - invariant 1 / C1: draws run disjoint-parallel via the engine monte_carlo seam (seed-input order, no within-sim concurrency); bit-identity proven by the reproduce round-trip (unit + E2E). - the C1 lockstep is a single shared fn: synthetic_walk_sources (one fixed SyntheticSpec) is called by BOTH the persist path and the reproduce MonteCarlo branch; pip is lockstepped too (both pass DataSource::Synthetic). - the sweep-sibling pattern matches: Result<McFamily,String> + boundary render. - scope honesty: WF deferral (#173, dep #169) and synthetic-walk-DGP (#172) are named in the spec + feat body, not silent. Carry-on debt (does NOT block close, filed forward, NOT new-this-cycle drift): synthetic_walk_sources' len:60 is hand-calibrated to the shallow stage1 warm-up; a deep-lookback closed blueprint warms poorly -> silent-vacuous draws with no error, and the anti-degenerate test only exercises the shallow fixture. Folded into #172 (real-data DGP retires the length calibration) per the architect's recommendation, rather than a new thread. Ledger refreshed: the C21 realization block now records the MC verb shipped (cycle 0095) with WF deferred; the C18 reproduction block notes aura reproduce now spans FamilyKind::MonteCarlo. Verified green (orchestrator, this session): cargo build --workspace clean; cargo clippy --workspace --all-targets -- -D warnings clean; cargo test --workspace green. Cycle is drift-clean (not a milestone close — #170's WF half remains, milestone stays open). refs #170 |
||
|
Brummel
|
7116660fe8 |
spec: 0095 monte-carlo over a loaded blueprint (boss-signed)
The MC half of #170 (World/C21): aura mc <closed blueprint.json> --seeds N builds a FamilyKind::MonteCarlo family from a loaded closed blueprint, each seed drawing a distinct synthetic price walk (the mc_family pattern), sharing one topology_hash, written once to the content-addressed store (the 0094 hook) so aura reproduce re-derives it bit-identically. Scope narrowed from #170's two verbs by two read-only review gates: - spec-skeptic: a loaded-blueprint 'walkforward' with no in-sample refit under the verb name that hard-wired walkforward uses for real IS-optimization is a guarantee collision -> walk-forward deferred to #173 (deps #169 axis-discovery). - grounding-check: there is no per-knob declared-default mechanism and the raw bind path panics on arity mismatch -> MC runs a CLOSED blueprint over the empty point (as aura run does), rejecting an open blueprint with a named error + exit 2. Grounding-check PASS on the revised spec; decisions logged on #170. refs #170 |
||
|
Brummel
|
cec7811c32 |
audit(0094): cycle close — content-addressed reproduction; ledger refreshed, coverage closed; rm ephemeral spec/plan
Architect drift review (4751d4b..HEAD): drift_found — ledger-currency only; the
code is clean.
What holds (architect, confirmed by diff + green tests):
- Inv 8 / C9: aura-engine byte-untouched; content_id + sha2 in aura-cli, the
store in aura-registry.
- Inv 9: Registry::{put,get}_blueprint is a dumb bytes-by-key store (opaque
String keyed by String hash; no sha2, no parse, no sha256==hash verify — the
caller owns the hash). No domain knowledge crept into the engine or registry.
- C1: the run_blueprint_member extraction is behaviour-preserving (keystone
blueprint_sweep_member_equals_single_run_and_shares_topology_hash unchanged +
green); serde_json/float_roundtrip serves determinism (disk==recomputed), not a
mask (1-ULP canary green).
- C11/C12: one blueprint stored per family, keyed by the shared topology_hash.
Resolutions:
- [ledger] Refreshed C18 + C24: added the cycle-0094 Realization (the
content-addressed store runs/blueprints/<hash>.json + aura reproduce), and
retired the now-false "content-addressed identity / full reproduction deferred"
claims (INDEX.md:1261, C24 deferred block). Only the structural-axis /
whole-harness content-id (and the debug-name-in-id question) genuinely remains,
filed forward (#171, #170).
- [debt->closed] Added the two untested refuse-don't-guess E2E arms
(aura_reproduce_rejects_a_non_generated_family — a hard-wired sweep member has
no topology_hash; aura_reproduce_rejects_a_missing_stored_blueprint — the store
was deleted), and a cross-surface unit pin
(topology_hash_is_the_content_id_of_the_canonical_form) so the two acc-1 paths
cannot silently drift.
- [scaling] MC/walk-forward-from-blueprint (#170) will need the same put_blueprint
hook or reproduce won't cover them — noted on #170.
No regression scripts in this project (Test is the gate): full workspace suite
green (51 suites), clippy -D warnings clean, binary verified end-to-end.
Ephemeral spec/plan git-rm'd per the lifecycle convention; durable rationale is in
the ledger. The World/C21 milestone stays open (#170 remains).
closes #158
|
||
|
Brummel
|
4b6bc52794 |
spec: 0094 content-addressed reproduction (boss-signed)
Restore C18 reproducibility for generated (blueprint-sweep) runs. Since cycle 0093 a sweep member's topology is a generated data value, so commit alone no longer identifies the graph and the manifest is not a complete re-derivation recipe (#158). Design: content-address the topology. The canonical blueprint JSON is stored once, keyed by the topology_hash the manifest already carries (cycle 0092), under runs/blueprints/<hash>.json (a dumb bytes-by-key store in aura-registry, no sha2 dep — the reproduce path's bit-identical compare is the integrity check). `aura reproduce <family-id>` loads each member's blueprint by hash, re-bootstraps with the member's params/window/seed, re-runs, and asserts the metrics are bit-identical (C1). acc-1 (two paths -> same content id) via a minimal `graph introspect --content-id`; acc-3 (Tier-1-stable id) composes the #156 omit-defaults pin. Derived forks (logged on #158): content-address (not carry-inline) — keeps the manifest tiny (C18) and dedups one topology across a family (C11/C12); hash domain = signal-only this cycle (the scaffolding is not yet blueprint-data, C24), boundary documented, whole-harness id deferred (#156/#159). Engine untouched (C9); store + hash off the frozen engine (invariant 8). boss-signed on a grounding-check PASS (9/9 current-behaviour assumptions ratified by green tests). refs #158 |
||
|
Brummel
|
4751d4b590 |
audit(0093): cycle close — sweep-from-blueprint; ledger refreshed, debt filed; rm ephemeral spec/plan
Cycle-close drift review (architect) for cycle 0093 / #166 (aura sweep <blueprint.json>). Drift-found on debt only; no contract violation. What holds (architect, evidence of review): invariant 9 fail-clean (resolve_axes runs before the sweep closure → named BindError UnknownKnob/MissingKnob/KindMismatch, exit 2; UnknownNodeType on load; no registry); C1/C12/C18 shape verbatim from stage1_r_sweep_family (members disjoint + enumeration-ordered; shared topology_hash correct, consistent with the cycle-1 #158 signal-only scope; append_family/ sweep_member_reports reused); reload-per-member is sound (Composite !Clone, #164); stdout uses family_member_line with family_id, run_sweep-consistent. Resolved: ledger refreshed (C24 Status — the cycle-0093 realization: the World now orchestrates FAMILIES from blueprint-data; the open-vs-bound fixture fact + the reload-per-member rationale recorded). Drift filed forward: #168 (--trace writes no per-member traces — silently like --name, debt-med), #169 (no axis-name discovery for loaded sweeps, debt-low), #170 (MC/walk-forward over a loaded blueprint — the next family-verb cycle, assigned to the milestone). Ephemeral 0093 spec + plan git-rm'd per the lifecycle convention. closes #166 |
||
|
Brummel
|
132dee2437 |
spec: 0093 sweep-from-blueprint (boss-signed)
Cycle 2 of the World/C21 milestone (#166): `aura sweep <blueprint.json> --axis <name>=<csv>` sweeps a loaded signal over its named param-space axes, reusing the existing stage1-r sweep machinery with the signal source swapped to cycle-1's wrap_stage1r seam, aggregating to a FamilyKind::Sweep family; each member manifest carries the shared topology_hash. Derivable extension, not a fork (recon + grounding confirm): the sweep is by-name param-space-driven (SweepBinder.axis / resolve_axes / bootstrap_with_cells), so a loaded blueprint's param_space slots in; wrap_stage1r nests an arbitrary signal; append_family is blueprint-agnostic. Scoped to sweep (the keystone family); MC / walk-forward over a loaded blueprint are the same machinery per verb and follow as a fast follow-on. Decisions recorded on #166. Boss-signed on a grounding-check PASS: all six load-bearing current-behaviour assumptions ratified by named green tests (wrap_stage1r arbitrary-signal nesting, the by-name param-space sweep, stage1_r_sweep_family, append_family/FamilyKind::Sweep, topology_hash, the .json-discriminator dispatch precedent). refs #166 |
||
|
Brummel
|
327d71b1d4 |
audit(0092): cycle close — run-from-blueprint; ledger refreshed, drift filed; rm ephemeral spec/plan
Cycle-close drift review (architect) for cycle 0092 / #165 (aura run <blueprint.json>). Drift-found on ledger currency only; the code is clean and correct. What holds (architect, evidence of review): the stage1_signal/wrap_stage1r split is behaviour-preserving (golden metrics byte-unchanged; loaded_signal bit-identical green; the STAGE1_R_SMA_* constants keep the hashed signal == the executed signal); sha2 + the topology_hash helper live in aura-cli only, aura-engine stays sha2-free (invariant 8 / C16); the resolver resolves the closed std_vocabulary set, unknown type -> UnknownNodeType, no registry (invariant 9); topology_hash is a correct Tier-1 optional and the RunManifest <-> RunManifestRead read-mirror both carry it. Resolved: ledger refreshed (C24 Status — the cycle-0092 run-from-blueprint realization + the topology_hash #158 anchor landing; #158 reframed from "premature" to "field landed, full reproduction remains"). Drift filed forward: #167 (single-source the stage1-r suffix-remapping lockstep — debt-med), and a scope note on #158 (the hash currently covers the signal only; a structural-variant content-id is the #158/#166 concern). The spec's illustrative instrument:"GER40" example (note-low) is moot — the ephemeral spec is removed here. Ephemeral 0092 spec + 0092/0092b plans git-rm'd per the lifecycle convention. closes #165 |
||
|
Brummel
|
29a519dbf6 |
spec: 0092 run-from-blueprint (boss-signed)
Cycle 1 of the World/C21 milestone (#165): `aura run <blueprint.json>` loads a serialized C24 signal blueprint, wraps it in the existing Stage-1-R run scaffolding via a shared seam extracted from run_stage1_r, compiles + bootstraps + runs, and emits a RunReport whose RunManifest carries a new Tier-1-optional topology_hash (SHA256 of the canonical blueprint form, #158 anchor). A serialized blueprint is a SIGNAL (sinks/brokers/data/clock out of the round-trippable set, C24), so aura run WRAPS the loaded signal in a runnable harness — the same wrap the Rust path does, shared as one function so "bit-identical to the Rust path" is the same seam over the same signal. The round-trip bit-identity is already proven (blueprint_serde_e2e.rs); cycle 1 lifts it to the CLI + adds topology_hash. Boss-signed on a grounding-check PASS: all six load-bearing current-behaviour assumptions ratified by named green tests (blueprint_from_json, the bit-identical round-trip, the run_stage1_r compile/bootstrap/run path, RunManifest's Tier-1 optional-field pattern, canonical blueprint_to_json, window_of). Derived wrapping decision recorded on #165. sha2 enters under the C16 per-case dependency review (SHA256 user-settled). refs #165 |
||
|
Brummel
|
3f75d59598 |
audit(0090): cycle + C24 milestone close — fieldtest green; ledger + rm ephemeral spec/plan
Closes the cycle-0090 (#156) work and delivers the "Topology-as-data: blueprint serialization & loader (C24)" milestone. Cycle-0090 audit (architect drift review, range 7ad7f58..HEAD): drift-clean on substance. Tier-1 forward-tolerance is genuinely serde-default (deny_unknown_fields = 0 in every production struct), pinned at envelope + primitive across both the in-crate and public-seam tests; Tier-2 refusals real and green; no struct/signature/runtime change; the invariant-5 acyclicity lockstep (construction gate <-> bootstrap Kahn sort) undisturbed; invariant-9 resolver stays injected, no registry. The one medium item the architect flagged — the C24 Remaining block carried no deferral signal for #158/#159 — is fixed in this commit's ledger update. Milestone fieldtest (fieldtests/milestone-topology-as-data/, the close-gate evidence): GREEN, 0 behavioural bugs. A downstream consumer ran the full author -> serialize -> load -> construct -> introspect -> reproduce story from the public surface alone — round-trip bit-exact on both authoring surfaces (Rust builder + op-script CLI), build-free introspection, Tier-1/Tier-2 forward-compat by name, fail-fast diagnostics by identifier. Verified the headline claims myself (the two Rust binaries + the CLI build/diff + the fail-fast exits), not just the agent's report. Findings triaged to the forward queue (none blocking): op-script grammar undocumented + a stale cycle-0088 example (#163); canonical trailing-newline divergence + Composite Debug/PartialEq ergonomics (#164); CLI discoverability of build/introspect + no `graph run` (commented on #159); the newline as a content-addressing prerequisite (commented on #158). #158 (content-address topology in the manifest) and #159 (retire the hard-wired harnesses) were moved OUT of this milestone: both are premature until the World generates runs from blueprint-data (commit still fully identifies every hard-wired topology), so they belong to the project-as-crate / World cycle. The C24 ledger Status records the delivery and the deferral. Ephemeral cycle-0090 spec + plan removed per the lifecycle convention. The Gitea milestone container is closed on user ratification (this run tees up the close, does not click it). |
||
|
Brummel
|
cb558519b0 |
spec: 0090 blueprint forward-compat two-tier discipline (boss-signed)
Iteration within the C24 topology-as-data milestone (#156). Codifies the blueprint format's additive forward-compatibility under one discipline: Tier-1 (additive-optional) = serde-default silent-ignore, no version bump, C1 default-equals-prior-behaviour; Tier-2 (must-understand: new node type, edge semantics, structural-axis kind) = bump format_version so an old reader refuses cleanly rather than building a different graph. Most of #156 already shipped with #155 (cycle 0087): the format_version envelope, omit-defaults canonical form, and both Tier-2 load-path refusals (LoadError::UnsupportedVersion / UnknownNodeType) are present and green. The genuine remainder is one unproven property — forward-tolerance of an unknown optional field on the current loader — plus codifying the discipline in the LoadError doc and the C24 ledger entry. Not a new mechanism. Derived fork recorded on #156: the per-section required-flag mechanism (PNG critical-vs-ancillary) is NOT built — the version envelope already gives the must-understand refusal at version granularity, there is no current Tier-2 section to validate a finer scheme against, and C1 holds either way. Boss-signed on a grounding-check PASS (all current-behaviour claims ratified by named green tests; the new Tier-1 pin correctly absent — this cycle's deliverable). refs #156 |
||
|
Brummel
|
7ad7f58798 |
audit(0089): cycle close — record acyclicity lockstep + C24 ledger refresh; rm ephemeral spec/plan
Cycle-close audit for the /boss run that followed up the cycle-0088 construction fieldtest (#161 cycle-reject + #162 diagnostics-by-identifier). Regression gate: full workspace suite green (0 failed). Architect drift review (range 86841b0..HEAD): drift_found, two items, both documentation-side — the code is correct and green. - What holds: invariant 5 / C9 acyclicity (closes_cycle is a correct eager reachability gate, no false positive on a valid DAG); C24 no-second-validator (blueprint.rs untouched, finish() only translates the gates' returned CompileError); fieldtest corpus handled per convention. - Resolved (fix path, ledger): the C24 Status now enumerates the #161 eager acyclicity gate and captures the LOCKSTEP the architect flagged — closes_cycle (construction-time) and the bootstrap Kahn sort (harness.rs, BootstrapError::Cycle) are now two homes of invariant-5 that must co-evolve when the explicit delay/register node lands; plus a note that the holistic finalize faults now read by-identifier (#162) while still calling the unchanged gates. Ephemeral 0089 spec + plan git-rm'd per the active-cycle artefact lifecycle; the durable rationale is lifted to the ledger above. No code change in this commit. |
||
|
Brummel
|
365f112451 |
spec: 0089 construction diagnostics polish (boss-signed) (refs #162)
Three presentation-only defects the cycle-0088 fieldtest found on the
construction op-script surface: the holistic finalize fault leaks raw machine
indices (UnconnectedPort { node: 2, slot: 1 }) where the by-identifier mapping
demonstrably exists; the bind-kind mismatch leaks a Debug struct; the typed-Scalar
bind form is invisible from introspect --node. Boss-signed on a grounding-check
PASS (every load-bearing assumption ratified by a currently-green test or the
defining code).
|
||
|
Brummel
|
86841b0740 |
audit(0088): cycle close — drift fixes + C24 ledger refresh; close construction service
Architect drift review of cycle 0088 (#157, the introspectable fail-fast construction service: §A shared gate predicates, §B the GraphSession/Op/replay per-op surface + introspection, §C the aura graph build/introspect CLI). What holds (confirmed against the diff): no-second-validator (C24) — edge_kind_check is the single kind-check site called by both validate_wiring and GraphSession::connect, and validate_wiring / check_param_namespace_injective are reused verbatim in finish(); engine domain-free (invariant 9) — construction takes an injected Fn(&str)->Option<PrimitiveBuilder>, no registry, the closed match + std_vocabulary_types live in aura-std; topology-as-data / no DSL (C24/C17/inv 10) — the engine Op is serde-free, the OpDoc wire DTO is CLI-side, ops are static and non-Turing-complete; replay-equals-builder byte-identity (construction_e2e.rs) protects C9/C19/C23. Resolution: - fix (drift-med): the root-role-boundness gate was the one holistic check finish() re-implemented instead of sharing — extracted check_root_roles_bound (blueprint.rs) and called from BOTH compile_with_cells and finish(), so finish() now reuses ALL the holistic gates and the no-second-validator claim is literally true. Behaviour- preserving (same UnboundRootRole variant; unbound_root_role_is_rejected stays green). - fix (drift-med): removed the #![allow(dead_code)] on construction.rs — empirically unnecessary (the pub re-exported surface is reachable; clippy -D warnings green without it) — and its now-inaccurate comment (it claimed removal "when the consumer lands", but the consumer is a separate crate). Also tidied a stale graph_construct.rs module-doc line. - fix (ledger): C24 Status refreshed — #157 moved out of "Remaining" with a cycle-0088 realization note (the construction service: eager/holistic gate split, build-free introspection, emits the #155 blueprint); #159 reframed as paired with #157. - carry-on (debt-med, forward-noted): the std_vocabulary roster is now a third hand-kept copy (match + test list + std_vocabulary_types) and introspect --vocabulary escalates #160's gap to user-facing — noted on #160; still fails safe. - carry-on (scaling-low, forward-noted): the engine Op -> wire OpDoc direction is unguarded for future Op variants — noted on #156 (the format-extension track). No architect-sweep / regression script is declared in the project facts, so the suite is the gate: cargo test --workspace 51 suites green; clippy --all-targets -D warnings clean. Cycle drift-clean. Ephemeral cycle artifacts removed (lifecycle convention): docs/specs/0088-*, docs/plans/0088-*. closes #157 |
||
|
Brummel
|
114fa3d718 |
spec: 0088 construction op-script (boss-signed)
The introspectable, fail-fast construction service (#157): a declarative, replayable by-identifier op-script that builds a runnable blueprint through validated ops and emits the #155 value, reusing the engine's existing gates (no second validator, C24). Surface-agnostic core = an eager/holistic gate split: the per-op-decidable checks (name resolution, edge kind-match, the >1-cover DoubleWiredPort arm, param bind) fire eagerly at the offending op; the only-at-end-decidable checks (0-cover UnconnectedPort totality, DuplicateParamPath injectivity, root-role boundness) stay holistic at finalize. Both cadences call the SAME extracted predicates. Plus build-free introspection over the closed std_vocabulary (enumerable companion) and a partial document's unwired slots. The JSON op-list + `aura graph build`/`introspect` CLI is a thin shell (iteration 2). Spec auto-signed under /boss on a grounding-check PASS (11/11 load-bearing current-behaviour assumptions ratified by named green tests). Derived sub-forks logged on the issue. refs #157 |
||
|
Brummel
|
468fbae62b |
audit(0087): cycle close — drift-clean after C24/C9 realization note; rm ephemeral spec/plan
Architect drift review of cycle 0087 (#155, the C24 blueprint-serialization-and- loader first cut). What holds (confirmed against the diff): C17 / no-RustAst (the format carries only type identity + name + bound params + topology; the build closure is dropped and re-derived, no node logic in the data); invariant 9 / domain-free engine (injected resolver, the closed match in aura-std, engine lib deps aura-core + aura-analysis only — a compiled-in closed set, not a dynamic registry); C9 round-trip / C23 bootstrap untouched (loader's terminal step is the unchanged Composite::new -> bootstrap_with_params; validation deferred to the existing gate, not bypassed). Resolution: - fix (ledger): C24 Status refreshed from "unbuilt" to "first cut shipped" with a cycle-0087 realization note; C9's round-trips-both-ways refinement marked realised. The ledger no longer contradicts the code. - backlog (debt-med): the hand-written std_vocabulary match has no guard test that fails when a new zero-arg aura-std node lacks an arm — fails safe today (clean UnknownNodeType, never silent-wrong). Filed as #160. - carry-on (scaling): construction-arg builders + sinks excluded, so no real harness round-trips yet; harness retirement blocks on the construction + project-as-crate layers — already tracked #156/#157/#159. No architect-sweep / regression script is declared in the project facts, so the suite is the gate: cargo test --workspace 748 passed (737 -> 748 = the 11 new tests); clippy --all-targets -D warnings clean. Ephemeral cycle artifacts removed (lifecycle convention): docs/specs/0087-*, docs/plans/0087-*. |
||
|
Brummel
|
ce86b4ec30 |
spec: 0087 blueprint serialization & loader (boss-signed)
The C24 first cut (#155): a stable, versioned, canonical serialization of a param-generic Composite blueprint plus the data -> blueprint -> FlatGraph loader, closing the graph-as-data loop. Format references nodes by compiled-in type identity over a closed vocabulary (no logic, non-Turing); the loader is generic over an injected resolver with the concrete aura-std vocabulary match living outside the engine (engine stays domain-free). Acceptance: a serialized blueprint runs bit-identical (C1) to its Rust-built twin. Signed under /boss on the Step-5 grounding-check PASS (all load-bearing assumptions ratified by currently-green tests). refs #155 |
||
|
Brummel
|
893698a1e6 |
audit(0086): cycle close — drift-clean; rm ephemeral spec/plan
Architect drift review (8d04a84..HEAD): clean, no drift/debt. What holds (verified against code, not asserted): - C10 cost contract preserved: the non-R-harness guard reads the *resolved* harness, so a `run` cost flag on sma/macd (incl. the implicit default) is exit-2 fail-loud, never a silent no-op; parse_nonneg_rate names the flag; the eight stage1-r cost goldens are byte-unchanged. - The three edited realization notes are grounded: C12 Arc-sharing → aura-ingest/src/lib.rs:316; aura-std "~30 modules" → 30 node files; C15 Session emits only bars_since_open, matching the quoted source wording. - project-layout.md rewrite complete: no residual exposure/realistic-broker. Non-actionable scaling note (architect): the guard hardcodes Stage1R as the sole R-harness, coupled to the "stage1-r only" note text — three sites move together if a second R-harness ever lands; not in plausible next scope. Regression gate: cargo test --workspace exit 0 (48 binaries, 737 passed, 0 failed); cargo clippy --workspace --all-targets -- -D warnings exit 0. No baseline moved → no ratify needed. cycle 0086 tidy (clean). Ephemeral spec/plan (docs/specs/0086, docs/plans/0086) removed per the ephemeral-artifact convention. |
||
|
Brummel
|
f26b33f345 |
spec: 0086 cost-flag CLI ergonomics (boss-signed)
Settled design from #153 (fieldtest friction of milestone #148): make the `aura run` cost-flag surface honest — a units/constraints note in the usage, a named non-negativity diagnostic, and a refuse-don't-guess rejection of cost flags on a non-R harness (the spec_gap; decided reject/exit-2, recorded on #153). CLI-ergonomics + one C10 ledger note only; no cost-model/R-math change. Boss-signed: grounding-check PASS (independent fresh-context agent; 6/6 load-bearing assumptions ratified by currently-green tests). refs #153 |
||
|
Brummel
|
84ec2ab5d1 |
audit(0085): cycle close — drift-clean; C10 cycle-0085 realization note
Cycle 5 of milestone #148 (per-cycle-held accrual + CarryCost). Architect drift review over 39f9387..f5e00a9: status clean, no code drift. What holds (architect, evidence-of-review): - C11 byte-identity: the AtClose eval arm is the pre-cycle-5 tokens verbatim (if closed { per } / if open { per }, the per + cum lines unchanged), so the cycle-0083/0084 net_expectancy_r goldens (-614.3134020253314, -615.0304388396047) stay byte-identical and the AtClose unit regressions are untouched. - Accrual sound, no double-count: aura-analysis (summarize_r) is genuinely unchanged. During a hold the carry lives only in open_cost_in_r (cum=0); at close it moves to cum while open_cost->0 (open/closed mutually exclusive per cycle), so net_r_equity subtracts cum+open singly. summarize_r reads the close-row dumped total + the window-end accrued-so-far — one charge per trade, acc reset proven. The 3-field cost record's semantics generalize cleanly to accrual. - C9/C16/C23: the diff touches only aura-std + aura-cli; aura-engine stays domain-free. CarryCost is a CostNode factor, CostRunner a plain Node, composed via cost_graph/CostSum. label() carries its param. All three run_stage1_r call sites threaded; the negative-rate guard is symmetric with the sibling cost flags. Resolved this commit (the cycle-close ledger sync): - C10 realization note (cycle 0085) added under docs/design/INDEX.md — C10's "per-cycle-held factors accrue over the hold" clause is now first realized (the prior 0084 note covered the cost-graph composite-builder). Regression gate: cargo test --workspace (0 failures), cargo build --workspace, cargo clippy --workspace --all-targets -- -D warnings clean — the architect is the primary gate (no dedicated regression script). Ephemera (spec 0085 + plan 0085) git rm'd. Milestone "Cost-model graph (in R)" remains OPEN. refs #148 |
||
|
Brummel
|
19ba1ec978 |
spec: 0085 per-cycle-held accrual + CarryCost (boss-signed)
Cycle 5 of milestone #148 (cost-model graph in R): the per-cycle-held accrual mechanism — C10's "per-cycle-held factors accrue over the hold" — exercised by a constant per-held-cycle CarryCost node and a --carry-per-cycle CLI flag. Approach B (user-decided, "ja, mach B"): the headline net_r_equity curve bleeds continuously over each hold, not stepping at close. Mechanism (derived, logged on #148): the bleed lives in open_cost_in_r (grown each held cycle = accrued-so-far mark-to-market); cost_in_r dumps the accrued total into cum at close. The net_r_equity tap already subtracts both cum_cost_in_r and open_cost_in_r, so the curve bleeds with NO change to summarize_r or the CLI net_eq wiring — and the AtClose runner branch is kept verbatim, so every cycle-0083/0084 net_expectancy_r golden stays byte-identical. ChargeMode is a property of the factor read by the one shared CostRunner (no second runner type); CarryCost is a ConstantCost twin differing only in charge_mode() -> PerHeldCycle. Auto-signed under /boss on a grounding-check PASS (all 6 current-behaviour assumptions ratified against named green tests). Reference issue #148 carries the A/B fork (user decision), the minimal-scope decision (derived), and the mechanism refinement (derived). refs #148 |
||
|
Brummel
|
face1879a6 |
audit(0084): cycle close — drift-clean (code); C10 cycle-0084 note + doc fixes
Cycle 4 of milestone #148 (cost-graph composite-builder). Architect drift review over fc52b4f..d5c44dd: drift_found, every item dispositioned. What holds (architect, evidence-of-review): C16/C9 — cost_graph lives in aura-composites, the factors in aura-std, aura-engine stays domain-free; the composite is ordinary downstream nodes. C11 behaviour-preservation is structural, not just asserted — the composite inlines to the same flat fan-in as the deleted CLI block (identical node set/order, cost[k].field slot map, geometry fan, net_eq terms/signs, cost_rec cols), so the cycle-0083 net_expectancy_r goldens stay byte-identical. C23 — role/port names non-load-bearing; 4 fixtures pin the role-set + output triple. Resolved this commit: - [high] ledger C10: the cycle-0083 note's "Still deferred (decision E)" is removed (E shipped this cycle) and a cycle-0084 realization note added. - [medium] cost_graph .leak() provenance (aura-composites/src/lib.rs): the "risk_executor precedent" was imprecise — that .leak() lives in risk_executor's TEST (one-shot, leak-safe), not its production builder. Doc corrected: the leak is fine for one-shot run-path construction but must be interned (the COL_PORTS production pattern) before cost reaches the sweep path. - [low] cli_run.rs golden docstring cited the deleted `slot * COST_WIDTH + f` CLI wiring; updated to the cost_graph composite's per-node cost[k].<port> wiring. Deferred (tracked, not pending) -> #152: - [medium] the cost[k].<port> index-namespacing restated across CostSum / cost_graph / the CLI (a build-validated lockstep — a divergent name fails loudly at g.build(), NOT the silent positional kind 0083 collapsed), AND the per-build .leak() that becomes an allocation regression on the per-member sweep path. Both are harmless on the current run-only cost path; the proper fix is one sweep-safe single-source cost-port-name contract (interned), best built with the deferred sweep-cost cycle. Regression gate: cargo test --workspace (0 failures), clippy --workspace --all-targets -- -D warnings clean, cargo doc clean — the architect is the primary gate (no dedicated regression script). Ephemera (spec 0084 + plan 0084) git rm'd. Milestone "Cost-model graph (in R)" remains OPEN. refs #148 |
||
|
Brummel
|
9fb3d8b8ee |
spec: 0084 cost-graph composite-builder (boss-signed)
Cycle 4 of milestone #148 (Cost-model graph in R), decision E — the cost-graph composite-builder, recorded across cycles 2-3 as the natural next. Adds a `cost_graph(Vec<PrimitiveBuilder>) -> Composite` builder in aura-composites that fans the 4 PM-geometry inputs to N cost nodes, surfaces each node's extra inputs as `cost[k].<port>` roles (schema introspection past GEOMETRY_WIDTH), sums them via CostSum, and exposes the 3-field aggregate. Replaces the CLI's manual slot-indexed cost-wiring + the hardcoded MAX_RUN_COST_NODES=2 cap with one principled composite of arbitrary arity. Re-exports GEOMETRY_WIDTH from aura-std (first cross-crate consumer). Behaviour-preserving at the value level: the composite inlines at bootstrap (C11) to the same flat computation, so the two cycle-3 net_expectancy_r goldens, the C18 no-cost golden, and the full suite stay green verbatim. Routed spec-driven (specify direct-entry): settled in #148's scope + the mature aura-composites idiom + the CostNode contract. All four forks (composite API shape, extra-input namespacing, GEOMETRY_WIDTH visibility, CLI consumption) are derived decisions logged on #148; none hangs on pure user preference. Auto-signed under /boss on the Step-5 grounding-check PASS (every load-bearing current-behaviour assumption tied to a named green test or current source; no with-cost graph label/shape pin contradicts the C23-permitted label drift). refs #148 |
||
|
Brummel
|
fc52b4fced |
audit(0083): cycle close — drift-clean (code); C10 cycle-0083 note + lib.rs doc
Architect drift review over 6c7f5dd..HEAD. No regression scripts in this project → the architect is the sole gate; verdict: shipped code byte-clean. What holds (verified against the diff): - C9 — a CostRunner<F> is a plain downstream Node; the two cost nodes are thin factors wired through the same cost_node_builder. No runtime sub-object. - C18 / byte-identity — the numerator/latched token form is preserved verbatim; the two new CLI goldens pin exact net_expectancy_r and pass; the no-cost golden is untouched. - C10 co-temporality + C23 + invariant-4 — the gate-on-PM-geometry-only rule (cold factor input → 0 cost, row still emits) is now centralized once in the runner; name() dropped cleanly (label() remains the non-load-bearing symbol); the 3-field triple is a single source (COST_FIELD_NAMES) read by both producers + CostSum + the CLI — the cycle-0082 by-convention lockstep is structurally gone. Resolution: - [fix] docs/design/INDEX.md C10 — added the cycle-0083 realization note (each prior cost cycle got one; the deferred general CostNode trait is now shipped and the lockstep eliminated). Ledger deferred-work tracking re-synced. - [fix] crates/aura-std/src/lib.rs:5 — module doc now names the CostNode/CostRunner authoring surface. - [carry-on, low debt] vol_slippage_cost.rs still declares its extra-input port twice (the cost_node_builder arg and the trait extra_inputs()); a clean unifier needs design thought (builder() is static, no factor instance) and is not worth forcing at cycle close. Documented here; agreement rests on the helper + a test + the harness debug-assert. Cycle 0083 ephemera removed (docs/specs/0083 + docs/plans/0083). Verified: cargo build/test --workspace clean (0 failures), clippy -D warnings clean, cargo doc -p aura-std clean (CostNode/CostRunner intra-doc links resolve). refs #148 |
||
|
Brummel
|
16f4cbb548 |
spec: 0083 cost-node trait + shared cost-record contract (boss-signed)
Cycle 3 of the cost-model-graph milestone: lift the duplicated cost-node skeleton (shared verbatim by ConstantCost/VolSlippageCost, locked by convention against CostSum) into a CostNode factor trait + a generic CostRunner<F> adapter, with one source of truth for the 3-field cost record. Behaviour-preserving: same schemas, same wiring, byte-identical output; the existing suite is the regression net. Cost-graph composite-builder deferred (decision E). Grounding-check PASS (7/7 assumption groups against named green tests). Fork decisions logged on the reference issue. refs #148 |
||
|
Brummel
|
6c7f5dd147 |
audit(0082): cycle close — drift-clean; C10 cycle-0082 note + cost-flag validation symmetry
Cycle 0082 (cost-graph composition, cycle 2) closes drift-clean against C10. The
architect review confirms the cycle is fundamentally sound:
What holds: VolSlippageCost + CostSum are ordinary aura-std downstream nodes
(C9/C8), cost stays out of aura-engine; the vol proxy is a trailing realized range
(C2, no look-ahead); feed-forward, no equity feedback (C1); the co-temporality
contract (gate cost nodes on PM geometry only, 0-cost on a cold state input) is
consistent with C1/C2/C9 and the cycle-1 positional join, and charging 0 during
warm-up is honest (no estimate yet, not a fabricated guess). The no-cost C18 golden
is byte-identical.
Drift resolved at close:
- [medium -> fixed] docs/design/INDEX.md (C10): added the cycle-0082 realization
note. The load-bearing co-temporality contract (generalizes to all future cost
factors) lived only in code comments + spec 0082; the ledger is now its durable
home once the spec is removed.
- [low -> fixed] crates/aura-cli/src/main.rs: --cost-per-trade now rejects negatives
at parse, symmetric with --slip-vol-mult (it previously deferred to the node
assert's panic). Run-path tests + the no-cost golden stay green.
Carry-on (documented deferrals, not this cycle's debt to fix):
- The 3-field cost triple {cost_in_r, cum_cost_in_r, open_cost_in_r} is restated
by-convention across ConstantCost, VolSlippageCost, and CostSum (compiler-unlinked
lockstep) — to be unified by the general CostNode trait, now justified by two
concrete nodes (#148).
- SLIP_VOL_LENGTH=5 is sized to warm within the synthetic smoke fixture; documented
in the const doc (on real M1 data any reasonable window warms).
- A future per-cycle-held accrual (carry/funding) accrues over holding duration,
which will force a summarize_r fold change and stress the positional seam — flagged
for that deferred cycle.
Regression gate green and unchanged: full workspace suite 0-fail, clippy --workspace
--all-targets -D warnings clean. No baseline moved -> no ratify.
Spec + plan ephemera removed (git rm docs/specs/0082, docs/plans/0082).
refs #148
|
||
|
Brummel
|
7f3756a395 |
feat(0082): cost-graph composition — VolSlippageCost + CostSum net-R aggregate
Cycle 2 of the "Cost-model graph (in R)" milestone (#148): the milestone's real architectural claim — the cost graph composes. Two cost nodes now sum into one net-R curve while summarize_r and the net_r_equity tap stay structurally unchanged. - VolSlippageCost (aura-std): a second, STATE-DEPENDENT cost node; per-trade charge = slip_vol_mult * volatility / |entry-stop|, in R. The vol is an independent short-horizon realized range (SLIP_VOL_LENGTH=5, distinct from the stop's EWMA-3) — scaling slippage by the stop's own vol would collapse cost-in-R to a constant (indistinguishable from ConstantCost). - CostSum (aura-std): the cost-graph OUTPUT node — sums N cost nodes' 3-field cost-in-R records per-field into one aggregate. summarize_r and net_r_equity read the aggregate (one home for cost; n=1 is the identity, so the cost path is uniform). A future CostNode trait (deferred) will unify the cost-triple the two producer nodes currently restate by-convention. - Run path: --cost-per-trade and --slip-vol-mult combine, their costs summing into the net-R curve; a hoisted vol proxy (RollingMax-RollingMin) keeps the single feed. Run-path-scoped; sweep/walkforward/mc pass None. Co-temporality contract (the load-bearing design decision; corrected from the signed spec after the implement-loop correctly BLOCKED Task 3 on it). summarize_r positional-joins cost[i] <-> record[i], so the cost stream must be co-temporal 1:1 with the PM record. A cost node is therefore gated ONLY by the PM geometry (closed/open/entry/stop); a not-yet-warm state input (the vol proxy warms later than PM) contributes 0 cost that cycle rather than withholding and desyncing the stream. This makes co-temporality structural + warmup-independent, preserves the C18 golden, and generalizes to any future cost factor. The rejected alternative (a key-join in summarize_r) would have moved the golden and pushed cost-graph logic into the post-run fold. Recorded on #148. Tests: VolSlippageCost + CostSum unit sets (incl. the co-temporal-zero-during- warmup case); the CLI composition run (both flags -> net_both < net_flat, net_r_equity persisted); node-level EXACT additive composition (net_both == net_flat + net_vol - gross over the real nodes), the aggregate net_r_equity == post-run net total, and CostSum(1) identity. Full workspace suite green; clippy -D warnings clean; the no-cost C18 golden byte-identical (the regression floor). Deferred (later cycles of this milestone): the general CostNode trait + cost-graph composite-builder (now justified by two concrete nodes), the conviction-weighting R-aggregation axis, and cost on the reduce-mode sweep path. Spec + plan amended to the corrected contract; both are cycle ephemera (git rm at cycle close). refs #148 |
||
|
Brummel
|
372eae9cac |
spec: 0082 vol-slippage cost + cost-graph composition (boss-signed)
Cycle 2 of the "Cost-model graph (in R)" milestone (#148): the milestone's real architectural claim — the cost graph composes. Two pieces: - VolSlippageCost (aura-std): a second, state-dependent cost node whose per-trade charge scales with a measured volatility input (k * vol / |entry - stop|), distinct from ConstantCost's flat charge. The vol is an independent short-horizon realized range, deliberately NOT the stop's own vol — scaling slippage by the vol the stop already normalizes would collapse cost-in-R to a constant (indistinguishable from ConstantCost). - CostSum (aura-std): the cost-graph output node — sums N cost nodes' 3-field cost-in-R records per-field into one aggregate record. So summarize_r and the net_r_equity LinComb(4) read the AGGREGATE and stay structurally unchanged (one home for cost; n=1 is the identity, keeping the cost path uniform). Run-path wiring: --cost-per-trade and --slip-vol-mult combine, their costs summing into the net-R curve; a hoisted vol proxy keeps the single-feed pattern. A no-cost run stays byte-identical (C18 golden floor). Scope is the run path; sweep/walkforward/mc still pass None (sweep-path cost remains deferred), and the general CostNode trait stays deferred (designed against two shipped nodes later). Auto-signed under /boss on the grounding-check PASS: all 8 load-bearing existing-behaviour assumptions tie to named green tests. Fork decisions recorded on #148. refs #148 |
||
|
Brummel
|
e82725f2d7 |
audit(0081): cycle close — drift-clean (code); ledger C10 realization note + stale-broker doc sync (refs #148)
Cycle 0081 (cost-model graph, cycle 1) closes drift-clean against C10: the architect review confirmed ConstantCost + the net-R seam realize the contract at its floor (C9 cost node; net_r_equity a C8/C18 sink; R-pure; one home for cost, subsuming the retired scalar round_trip_cost; pure feed-forward C1), and the no-cost baseline is byte-identical (C18 golden held). Regression gate green and unchanged: full workspace suite 0-fail, clippy --workspace --all-targets -D warnings clean. No baseline moved -> no ratify. Ledger sync (docs/design/INDEX.md): added the C10 cycle-0081 realization note (ConstantCost node + net_r_equity seam shipped; scalar round_trip_cost retired; run-path-scoped; later-cycle deferrals named). Drift swept (cycle-adjacent + cheap one-liners): - crates/aura-analysis/src/lib.rs net_expectancy_r doc: the removed in-fold mechanic (mean(R - round_trip_cost/latched_dist)) -> the cost-stream fold. - crates/aura-std/src/lib.rs module doc: "realistic broker profiles" (retired by #116) -> the legacy SimBroker pip yardstick + cost-model nodes. Backlogged (pre-existing, broader, predates this cycle): the docs/project-layout.md backtest worked example is stale on #117 (exposure->bias) and #116 (realistic broker); a proper rewrite is filed as #151, not folded here. Architect-accepted: the #[allow(dead_code)] on r_col::ENTRY_PRICE/STOP_PRICE (their production reader legitimately removed when summarize_r stopped recovering latched_dist; still the layout contract + exercised by test fixtures). Spec + plan ephemera removed (git rm docs/specs/0081, docs/plans/0081). refs #148 |
||
|
Brummel
|
2e63ed9e26 |
spec: 0081 cost-model constant-cost (boss-signed)
Cycle 1 of the "Cost-model graph (in R)" milestone (#148): a single ConstantCost node (flat round-trip cost per trade) plus the net-R seam — an in-graph cost_in_r stream, a net_r_equity sink (sibling of r_equity), and summarize_r folding that one stream into net_expectancy_r (replacing the scalar round_trip_cost). A run with no cost stays a byte-identical gross-R baseline. Defers the general CostNode trait, the cost-graph composite-builder, data-grounded factors, and the conviction axis. Auto-signed under /boss on the grounding-check PASS: all load-bearing existing-behaviour assumptions are ratified by green tests. Fork decisions recorded on #148. refs #148 |
||
|
Brummel
|
3e8fd73f68 |
tidy: clear the milestone fieldtest findings (refusal reasons, --help, ledger + glossary)
Resolves the four non-bug findings from the inferential-validation milestone
fieldtest (the bug — the broken-pipe panic — is fixed in
|
||
|
Brummel
|
ab04ed01c3 |
fieldtest: milestone inferential-validation — 4 scenarios, 6 findings (1 bug, 2 friction, 2 spec_gap, 1 working)
Milestone-close gate for "Inferential validation (defend against false discovery at sweep scale)". Downstream-consumer exercise from the public interface only (CLI --help, ledger, glossary, examples — never the source). All four end-to-end scenarios PASS — the milestone delivers its promise: trials-deflation (#144), plateau-over-peak (#145), and cross-instrument generalization (#146) all reach the output and read sensibly, and the composed "is this edge real or overfit?" verdict is honest (scenario 4: a GER40 in-sample winner sqn 0.994 does NOT generalize — worst_case -0.149 on EURUSD, sign_agreement 2/3 → instrument-specific / likely overfit). Milestone status roll-up: bugs_found — NOT green, so the milestone is NOT yet closeable (the green roll-up is the functional leg of the close gate). Findings: - [bug] a family-emitting command piped into an early-closing reader (`aura sweep|walkforward|mc|runs family … | head`) panics "Broken pipe (os error 32)" on stdout (exit 101 under pipefail) instead of exiting cleanly on EPIPE. Pre-existing (not a #146 regression — reproduced on `aura sweep | head -1`); surfaced by the milestone commands. -> debug (RED-first). - [friction] two generalize refusals (single --real symbol; multi-value candidate flag) dump bare usage with no reason. -> tidy iteration. - [friction] the --select plateau objective is absent from `aura --help`. -> tidy. - [spec_gap] sweep vs generalize recompute the same member's sqn with a stable 1-ULP difference; the ledger's C1 / "recomputable" is silent on cross-command metric agreement. -> ratify (ledger note). - [spec_gap] the milestone vocabulary (deflated_score / overfit_probability / worst_case / sign_agreement) is absent from docs/glossary.md. -> docwriter. Artefacts: docs/specs/fieldtest-milestone-inferential-validation.md + fieldtests/milestone-inferential-validation/ (README + 4 scenario scripts). The existing fieldtests/ tree was untouched. refs #146 |
||
|
Brummel
|
15f5c0bc99 |
audit(0078): cycle close — drift addressed; ledger inferential-thread synced (milestone complete) + C12/C18 realization; drop ephemera
Architect drift review (d50a482..feat): drift_found — documentation only, NO contract violation. C1/C9/C10/C23 verified preserved against the diff: `generalization` is a pure deterministic fold (registry-side, C9; R-only, C10); the sole `instrument = Some` production site is `run_generalize`, every other manifest constructor threads `None` + `skip_serializing_if`, so sweep/mc/walkforward/standalone manifest bytes are byte-identical (C23); the compat read-mirror was threaded in lockstep. Drift fixed in this commit (ledger sync, docs/design/INDEX.md): - The inferential-honesty thread read "now two of three pieces built" / "#146 remains the last open piece" — false now that #146 landed. Updated to record the inferential half as structurally complete (all three built, cycle 0078) + the #146 realization, including the aggregator/validator-vs-selector distinction (#146 is a recomputable aggregate, not a FamilySelection annotation). - C18 realization block: added the cycle-0078 note — the comparison axis (C12) realized as FamilyKind::CrossInstrument + the first-class RunManifest.instrument lineage field. Regression: no regression scripts configured (project facts name only Build/Test/Lint/Doc); architect is the gate. cargo test --workspace green (0 failed) and cargo clippy --workspace --all-targets -D warnings clean, orchestrator-verified. Ephemera removed per the project lifecycle convention: docs/specs/0078-* and docs/plans/0078-* (git rm). Durable rationale lifted to the ledger above. refs #146 |
||
|
Brummel
|
428d092298 |
spec: 0078 cross-instrument generalization (boss-signed)
Last piece of the Inferential-validation milestone (#146): grade how consistently a brought candidate holds across a set of instruments. Aggregator/validator, not a third selector (user-ratified "mach es so", decision + derivations minuted on #146): a new `aura generalize` subcommand runs a single candidate (single-cell stage1-r grid) across an instrument list, collects per-instrument R-metrics, and reduces them to a worst-case floor (min over instruments) + a sign-agreement count + the per-instrument breakdown. R-only (C10 — R is the only cross-instrument-comparable unit); the worst-case min is the cross-instrument sibling of PlateauMode::Worst and satisfies the non-domination constraint by construction. New FamilyKind::CrossInstrument (C12) + a first-class RunManifest.instrument lineage field (serde-widened, C14/C18); the reduction lives registry-side beside optimize_deflated/optimize_plateau (C9). Additive — existing sweep/walkforward/mc paths stay byte-identical (C23). grounding-check PASS: all 9 current-behaviour assumptions ratified by green tests. refs #146 |
||
|
Brummel
|
d50a4828ad |
audit(0077): cycle close — drift addressed; legacy-load fixture + ledger sync; drop ephemera
Architect drift review over 9c6b9c7..cb32658 returned drift_found (3 items); all resolved here. What holds (architect): C23 default-argmax byte-identical, C9 separation (selector in aura-registry, walk_forward selection-agnostic), C1/C2 (plateau pure/deterministic/in-sample), one higher_is_better direction source. Resolutions: - [medium] Backfilled the pre-0077 FamilySelection legacy-load fixture (report.rs family_selection_loads_a_pre_0077_legacy_line). The feat commit and the struct doc-comment claimed "a legacy line still loads (C14/C18)" as landed, but no test pinned the field-level mapping: bare deflation scalars -> Some(...), absent plateau keys -> None. families.jsonl/runs.jsonl are append-only, so a winner stamped pre-0077 must read back; now pinned. - [low] Synced the ledger's inferential-validation open thread (docs/design/INDEX.md): #145 plateau-over-peak landed (cycle 0077), selection is now a pluggable objective (bare argmax -> trials-deflated -> plateau) on the manifest carrier; only #146 (cross-instrument generalization) remains of the milestone's three pieces. - [medium-high] Removed the cycle ephemera (git rm docs/specs/0077-*, docs/plans/0077-*) per the cycle-close convention. Regression: full workspace suite green and clippy --all-targets -D warnings clean (verified at feat-review time). No baseline scripts configured; the test + clippy gates are the regression gate. Cycle 0077 tidy (clean) — drift-clean, not a milestone close (the milestone fieldtest is a separate deliberate gate). |
||
|
Brummel
|
45b8e2b28b |
spec: 0077 plateau over peak selection (boss-signed)
Second cycle of the inferential-validation milestone. Adds an opt-in plateau selection objective: optimize_plateau beside optimize/optimize_deflated scores each grid member by the mean/worst of its grid-neighbourhood metric and argmaxes the smoothed surface (mixed-radix neighbours over GridSpace axis_lens, passed as an argument not a SweepFamily field). Strictly opt-in via --select <argmax|plateau:mean|plateau:worst>, default argmax (C23 byte-preserving). Reconciles the shared RunManifest.selection carrier with #144's landed reality: the selection RULE (argmax vs plateau) and the deflation ANNOTATION are orthogonal, so FamilySelection is extended — deflation fields become Option, SelectionMode gains PlateauMean/PlateauWorst (the reserved slot), and neighbourhood_score/n_neighbours are added. A small wire change to the one-cycle-old type; legacy lines still load. RandomSpace plateau refused (exit 2 — no lattice); kNN deferred. Grounding-check PASS (12 assumptions ratified). refs #145 |
||
|
Brummel
|
9c6b9c7ea9 |
audit(0076): cycle close — drift addressed; ledger inferential-thread synced; drop ephemera
Architect drift review (c192dfd..a295905): drift_found, medium/low only — no
ledger or hot-path contract crossed. C23-additive, C1-deterministic, C14/C18
back-compat all verified green (full workspace suite + clippy). No regression
scripts configured (test+clippy are the gate).
Resolution:
- [medium] three spec-promised optimize_deflated tests were missing (the
centring control, the all-noise high-p companion, the C2 IS-only read) — the
centring was unprotected ("removing it would pass every test"). Plus an
unguarded dispersion-floor sign assumption. FIXED in 0076.tidy (
|
||
|
Brummel
|
a1908bd15e |
spec: 0076 deflate sweep winner for trials (boss-signed)
First cycle of the inferential-validation milestone. Adds optimize_deflated beside optimize: an additive selection-provenance record (deflated score + overfit probability) stamped on the OOS winner's manifest, never re-ranking (C23). R arm = centred moving-block reality-check reusing the r_bootstrap kernel; total_pips arm = expected-max-of-K dispersion floor. Shared RunManifest.selection carrier with a SelectionMode::Plateau slot reserved for #145. refs #144 |
||
|
Brummel
|
c192dfd344 |
audit(0075): cycle close — drift-clean; doc-link + trade_rs tripwire tidy; drop ephemera
Architect drift review (c99e7b8..2e77ab1) against the design ledger +
CLAUDE.md invariants: drift-clean, debt only — no contract or spec
violation. Verified intact: C18 wire shape (trade_rs is #[serde(skip)] +
excluded from the hand-written PartialEq; runs.jsonl/families.jsonl bytes
and digests unmoved; mc_r_bootstrap is a printed line, never a record),
C1 determinism (seeded r_bootstrap + disjoint walkforward windows, both
pinned by byte-identical-rerun e2e tests), C7 frictionless Stage-1
(round_trip_cost stays 0.0), C8/C12 streaming reduction (IS sweep folds
O(trades)/member, OOS run non-reduce). The verbatim summarize_r /
r_metrics_from_rs float duplication is guarded by the cross-reducer
equality test — sound.
Tidy applied this close:
- doc-link drift: the new E[R] notation in r_bootstrap / RBootstrap /
run_mc_r_bootstrap doc-comments was parsed by rustdoc as an intra-doc
link `[R]` (4 warnings). Wrapped in backticks; doc build now clean.
- coverage micro-gap [low, architect]: added a tripwire asserting a
populated trade_rs is absent from the serialized JSON (the serde(skip)
C18-preservation property had no direct test — only Vec::new() was
serialized before).
Carry-on (benign debt, not fixed): the mc usage literal carries a `usage:`
prefix the sibling sweep/walkforward usages omit — required because the
new `["mc", rest @ ..]` arm now handles the `--real` rejection and the
preserved golden asserts stderr.contains("usage"); churning the golden to
drop the prefix is not worth it.
Removed the cycle's ephemeral spec + plans (docs/specs/0075,
docs/plans/0075, docs/plans/0076) per the lifecycle rule.
Verified: cargo test --workspace 610 passed / 0 failed, clippy -D warnings
clean, cargo doc --no-deps clean.
closes #139
|
||
|
Brummel
|
3a1de05ef3 |
spec: 0075 walk-forward + Monte-Carlo OOS validation for R candidates (boss-signed)
Make the World layer's two OOS validation verbs candidate-aware and R-reporting instead of locked to the SMA sample blueprint: - aura walkforward --strategy stage1-r --real <SYM>: roll IS->OOS, sweep the stage1-r grid in-sample, pick by an R metric, run OOS, report per-window + across-window-pooled OOS R-metrics. - aura mc --strategy stage1-r --real <SYM>: moving-block bootstrap of the pooled OOS per-trade R series -> E[R] distribution / CI. Frictionless Stage-1 R (costs are Stage-2). Bare walkforward/mc paths and their goldens preserved byte-for-byte. Grounding-check PASS; signed under /boss (design forks recorded on the reference issue). refs #139 |
||
|
Brummel
|
c99e7b8f7f |
audit(0074): cycle close — provider-sourced pip; authored floor removed; drift-clean
Architect audit: drift-clean. The ledger and source now point at the recorded geometry sidecar; no live reference to the removed authored floor survives in code or any live contract. Refuse-don't-guess preserved. Recorded debt (non-blocking, accepted): - fieldtests/milestone-runway references the removed instrument_spec; a frozen non-workspace snapshot, left untouched per the tracked-fieldtests convention. - cli_run.rs test fn names retain unspecced/vetted vocabulary (plan prescribed substring-only edits); cosmetic. #124 stays open for the deferred override/floor tiers the Stage-2 broker needs. Drops the ephemeral cycle spec + plan (rationale lifted to the ledger). |
||
|
Brummel
|
eb1097d7ca |
spec: 0074 provider-sourced pip, drop authored instrument floor (boss-signed)
Resolve the real-path pip from the data-server geometry sidecar (instrument_geometry) and remove the redundant authored floor (InstrumentSpec / instrument_spec / VETTED_SYMBOLS) plus its table-only tests. Consumption grep: only pip_size is read in production; InstrumentSpec.instrument_id has no consumer (the position-event table's id is a decoupled caller parameter). Speculative geometry fields are deferred to the Stage-2 broker, read from the sidecar when needed. Signed via grounding-check PASS (all assumptions tied to currently-green tests, executed with the archive present). Decisions recorded on #124; #140 closed as obsolete. refs #124 |
||
|
Brummel
|
dda20abc28 |
audit(0073): cycle close — lift tier-2 geometry to ledger, finish VETTED_SYMBOLS, drop ephemera
Cycle-close audit: drift-clean on all load-bearing invariants (C7/C8/C15 hold; geometry stays non-scalar metadata, the Source seam still carries only (Timestamp, Scalar); scope boundary held — no resolver, quote_currency still &'static str, both #124's). Tidy: completed the VETTED_SYMBOLS consolidation the feat commit over-claimed — migrated the two remaining inline vetted-symbol arrays in the crate-internal unit tests (instrument_spec_pip_value_matches_contract_times_pip, instrument_spec_ids_are_distinct) to the const, so #140 now extends one list. Ledger: lifted this cycle's durable rationale into the C15 realization note (docs/design/INDEX.md) — the floor now carries tick_size/digits, and the recorded-metadata tier-2 source (instrument_geometry over symbol_meta -> neutral InstrumentGeometry, cross-checked against the authored floor) now exists at the ingestion edge; the tier-composing resolver remains #124. Drop the ephemeral cycle spec + plan (docs/specs, docs/plans) per the lifecycle convention; durable rationale now in the ledger + the #143 thread. refs #143 |
||
|
Brummel
|
8d9939733d |
spec: 0073 instrument-geometry cross-check + deploy fields (boss-signed)
Consume data-server's neutral InstrumentGeometry at the aura-ingest edge to cross-check the hand-authored vetted InstrumentSpec floor (#113) against provider truth, and add the two deferred deploy-grade fields (tick_size, digits) the sidecars now supply. Scope fork derived and recorded on #143: this cycle does NOT build #124's runtime resolver and does NOT change quote_currency's &'static str type (the geometry tier carries non-FX currency as String). Auto-signed autonomously under /boss on a grounding-check PASS (6/6 assumptions ratified); reply to the run to veto. refs #143 |