Cycle 0107, anchored on #198 (campaign executor; #196 blueprint on-ramp
rides along). Encodes the twelve decisions recorded on #198: eleven from
the fork triage (2026-07-03) plus the user-decided executor home (a new
library crate, 2026-07-03). Scope: aura-campaign library crate
(MemberRunner seam, execute, gate evaluation, preflight, realization
assembly), std::walk_forward vocabulary correction to machinery-true
fields, engine ListSpace, registry CampaignRunRecord + campaign_runs
store, CLI campaign-run verb + driver, #196 on-ramp verbs.
Boss-signed via grounding-check PASS (17/17 load-bearing assumptions
ratified against currently-green tests). One construction note carried
to the plan: a private Registry::blueprint_path already exists and is
promoted to public rather than duplicated.
refs #198, refs #196
Architect drift review (holds: C14 headless authoring, C16/C17 no-DSL with
aura-research a true leaf, content-id move behaviour-preserving per the
untouched id goldens). Resolution per item:
- fix (docs): C18 gains the cycle-0106 realization note (processes/ +
campaigns/ stores, document canonical form, the content-id primitive's
library home, the referential tier, no-executor status); the #109
analysis-meta-level open thread records the artifact half shipped v1 and
what stays open (executor question, verb dissolution 'once it carries',
the remaining #188 amendment package). Glossary: new campaign document +
process document entries; content id generalized to all three artifact
classes; experiment marked superseded by the campaign document (#188
re-cut of the builder-API thread).
- fix (code): the --unwired guide advertised an identity_id process ref
that validate_campaign refuses — the process.ref open-slot hint now says
content-id-only (strategy refs keep both); lib + seam pins updated.
- filed forward: #190 (metric-vocabulary single-sourcing, the 0105 roster
drift class), #191 (identity-ref store scan is O(store), performance
only).
- carry-on: regression gates green by hand — cargo test --workspace 916/0,
clippy -D warnings clean, cargo doc --no-deps 0 warnings; no baseline to
ratify (project has no metric baseline scripts).
Cycle 0106 spec and plan retired per convention (git rm); durable record
is the ledger notes above plus #188/#189.
refs #189
User veto (2026-07-03) of the per-cell tagged Scalar draft: the kind is a
property of the parameter, not of each value. An axis is now
{"kind": "I64", "values": [8, 12, 16]} — mixed-kind axes are
unrepresentable, canonical form normalizes value spelling, and the
referential kind check is one comparison per axis. Op-script binds keep
their tagged form (single-value slots). Decision log: #189.
refs #189
The campaign example wrote bare JSON numbers in the axes while the spec's
own typed-cell clause (op-script bind parity) requires the tagged Scalar
wire form. Example now matches the clause; no assumption changed.
refs #189
Architect drift review (range 7b429f9..57f401f): drift_found (low/medium
only), resolved inline as close-fixes:
- crates/aura-std/src/vocabulary.rs — the roster-site doc now names BOTH
count pins a node addition trips (the in-crate shape test and aura-cli's
cross-boundary --vocabulary count e2e); the singular phrasing understated
the cross-crate lockstep the extra e2e introduced.
- docs/design/INDEX.md — the C24 enforcement-shift passage gains the 0105
delivery note: resolver-vs-list drift closed by construction via the
roster macro; the un-rostered-node residual stays fail-safe.
Noted, no action: spec/plan predicted 884 (no new test) but delivery added
one e2e (885) — consciously superseded, disclosed in the iter commit body;
the artifacts are ephemeral and removed below.
What holds (architect): byte-preserving refactor confirmed against the
diff (22 keys/order exact, signatures and module doc untouched, every
consumer unchanged); invariant 9 / C24 preserved (compile-time expansion,
no registry); the new e2e count pin is genuinely roster-tied.
Regression gates (all green): cargo build clean; cargo test --workspace
885 passed / 0 failed (884 baseline + 1 new e2e); clippy --all-targets
-D warnings clean; cargo doc --no-deps 0 warnings.
Ephemeral cycle artifacts removed per project convention (git rm):
docs/specs/0105-std-vocabulary-roster-macro.md,
docs/plans/0105-std-vocabulary-roster-macro.md.
refs #180
Boss-signed via grounding-check PASS (fresh-context agent): all seven
load-bearing current-behaviour assumptions ratified by named green tests —
the two vocabulary unit tests (label round-trip + negatives; count==22 +
non-members), the PrimitiveBuilder::label() oracle, and the four consumer
pins (graph introspect --vocabulary e2e, engine loader UnknownNodeType,
the 0102 merged-vocabulary charter suite, the canonical golden).
Design basis: the mechanism recorded on #160 (declarative macro as single
source for resolver match + enumerable list) plus the cycle-0105
reconciliation comment there (single pair-generating invocation; the
test's inline roster copy replaced by iterating the generated list with
label() as independent oracle; the un-rostered-node residual accepted as
fail-safe and documented; public surface byte-identical).
refs #180, refs #160
Boss-signed via grounding-check PASS (fresh-context agent): all five
load-bearing assumptions about current behaviour are ratified by named
currently-green tests — the byte-canonical golden
(signal_serializes_to_canonical_golden), the --content-id CLI contract
(graph_introspect_content_id_is_deterministic_and_distinguishes and the
bad-document refusal), the three topology_hash roles (introspect
content id, blueprint-store round-trip key, reproduce fetch anchor —
each with its own green test), the I64:4-vs-5 distinguishing property,
and the bound-array openness encoding (bound slot textually present,
open slot absent).
Design carried from the #171 reconciliation (adversarially reviewed):
the identity hash is an additive SIBLING of topology_hash —
introspection-only this cycle, no manifest field, no store key; the
byte-canonical form and every consumer of it stay byte-for-byte
untouched. Reviewer note carried to planning: allowing --content-id
and --identity-id together relaxes the current exactly-one flag
dispatch in graph_construct.rs — the usage tests must be adjusted
deliberately, not incidentally.
refs #180, refs #171
Architect review of b672a37..HEAD. What holds: emitted templates match
the settled contracts (Aura.toml paths-only per C17, cdylib + empty
[workspace] per C16, ::-namespaced ids per the charter, the C14 exit
partition in dispatch_new); the load-bypass guard is narrow and sound
(only the new-project verb exempted, the load arm byte-unchanged for
every other verb); e2e coverage is real (scaffold -> build -> run twice
byte-identical, namespace stamped, introspection, four refusals, the
unbuilt-tree bypass, plus the additive namespace-override test).
Regression: cargo build --workspace rc=0; cargo test --workspace 873
passed / 0 failed (project_new 6/6); clippy --workspace --all-targets
-D warnings rc=0; cargo doc --workspace --no-deps 0 warnings. No
baselines exist to move, so nothing to ratify.
Drift resolved in this commit: three doc mirrors still framing the
scaffolder as future — project-layout.md's 'the future aura new
scaffolder will emit this line; until then, add it by hand', the C24
status paragraph's 'what remains open is the aura new scaffolder (the
milestone's next cycle)', and the #109 open-thread bullet's 'the aura
new scaffolder and the experiment-builder API remain open' — all
rewritten to the landed reading (only the experiment-builder API stays
open in that layer).
Carried debt, filed forward: the scaffold templates and the
demo-project fixture encode one project shape twice with no lockstep
guard and deliberate cosmetic divergences (#181, idea — needs a design
pass, not a mechanical edit).
Process note: one mid-cycle plan-fix commit (derive(Debug) on a
plan-prescribed struct whose own test code required it) — the
implement loop's spec gate correctly blocked the necessary deviation;
resolution followed the fix-plan/commit-subset/re-run path.
Ephemeral cycle artifacts removed per convention: spec 0103, plan 0103.
refs #180
Grounding-check PASS as the autonomous signature: 8 load-bearing
current-behaviour assumptions each ratified by a named green test
(the templates are the cycle-0102 fixture verbatim, itself e2e-green);
greenfield scaffolder surfaces excluded per contract. Fork decisions:
the cycle-0103 reconciliation comment on the milestone reference issue.
refs #180
Architect review of d7c935d..HEAD. What holds: C13/C16 separation
verified by diff (descriptor in aura-core::project, loader entirely in
aura-cli::project, aura-engine gains only the additive provenance
field); the C-tier-before-Rust-tier discipline is enforced in load()
(magic -> version -> stamps, fn pointers touched only after Ok);
C17/C24/invariant-9 hold (paths-only Aura.toml, injected merged
resolver, charter at the one seam); outside-a-project byte-identity
confirmed by the full green suite incl. every golden-bearing test.
Regression: cargo build --workspace rc=0; cargo test --workspace 862
passed / 0 failed (cli_run 133, project_load 7 e2e); clippy
--workspace --all-targets -D warnings rc=0; cargo doc --workspace
--no-deps 0 warnings. No baselines exist to move, so nothing to
ratify.
Drift resolved in this commit: two stale project-as-crate ledger
mirrors — the C24 status paragraph still calling the layer
sequencing-coupled/unbuilt, and the #109 open-thread bullet naming it
an unbuilt half — rewritten to record the landed load boundary (the
aura new scaffolder and the experiment-builder API stay open).
Carried holds (plan-prescribed bytes, cosmetic): the unreachable
rsplit fallback in node_name, the unreachable! build closure in one
aura-core test.
Ephemeral cycle artifacts removed per convention: spec 0102, plan 0102.
refs #180
Grounding-check PASS as the autonomous signature: 7 load-bearing
current-behaviour assumptions each ratified by a named green test;
greenfield surfaces (descriptor, loader, Aura.toml) excluded per
contract. Design decisions and provenance: the decision-log on the
milestone reference issue.
refs #180
Architect review of 8814e295..HEAD. What holds: the cosmetic-only claim is
verified (every -/+ pair in the code diff is a string literal; no exit(),
channel, or control-flow byte moved; the C14 usage=2/runtime=1 partition
preserved at every touched site); grep gates exact (zero lowercase usage:
literals, 11 'Usage: aura' source lines = 10 edited + the pre-conforming
run_args_from); fieldtests corpus and refusal diagnostics byte-identical.
The recorded spec deviation (3 additive house-style pins) strengthens
coverage over a real pin gap and is decision-logged on the issue.
Regression: cargo build rc=0, cargo test --workspace rc=0 (cli_run 133
passed / 0 failed), clippy -D warnings rc=0, doc build rc=0. No baselines
exist to move, so nothing to ratify.
Drift resolved in this commit: the C14 ledger note still described the
casing normalization as deferred after #179 landed - rewritten to record
the landed house style (usage lines 'Usage: aura <verb> ...', refusal
diagnostics deliberately unprefixed).
Ephemeral cycle artifacts removed per convention: spec 0101, plan 0101.
refs #179
Single house style for every hand-rolled usage line: 'Usage: aura <verb> ...'
(clap's capital prefix + program name), 10 literal edits + the one
casing-sensitive test pin in lockstep. Refusal diagnostics, the conforming
run_args_from site, clap output, and the fieldtests corpus stay byte-identical.
Grounding-check PASS is the autonomous signature; scope-fork decisions are
recorded on the issue.
refs #179
Architect review of 88e9c9a..HEAD. What holds: token purity of the rename
(removed + mapping == added, 33 sanctioned prose rewordings, numeric golden
bytes untouched); CLAUDE.md invariant 7 now matches the ledger C10 section
clause-by-clause; no silent alias for the old selectors (unknown-selector
exit-2 path is tested).
Regression: cargo build / clippy -D warnings / doc build clean; cargo test
--workspace rc=0, 51 targets, 0 failures. No baselines exist to move, so
nothing to ratify.
Drift resolved in this commit: the C10 terminology note (INDEX.md) still
called Stage-1 a surviving identifier name after the glossary recorded the
rename - aligned to name the r-family rename (#174). Remaining low items:
the spec's own survivor-list contradiction was ratified and recorded on the
issue; the RGrid const-seeding debt is recorded on the harness-retirement
issue (refs #159).
Ephemeral cycle artifacts removed per convention: spec 0100, plan 0100, and
the spent prior-milestone fieldtest spec.
refs #174
The stage1 ordinal is dead vocabulary since the C10 reframe; the spec
renames the selector/identifier family to r-sma / r-breakout / r-meanrev
(signal-named members under the R-yardstick marker), reworders dead
Stage-1/Stage-2 doc prose, and pins the survivors (history, fieldtests).
Signed autonomously under /boss on the grounding-check PASS; fork
decisions recorded on the reference issue.
refs #174
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
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
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 4710fcc.
The milestone's FUNCTIONAL PROMISE HOLDS (3 working findings): a consumer-authored
blueprint round-trips the whole verb family (graph build → list-axes → sweep →
rank → reproduce; walkforward → reproduce; mc → reproduce); all three FamilyKinds
(Sweep 4/4, MonteCarlo 5/5, WalkForward 3/3) reproduce bit-identically through the
one shared content-addressed store (the C18 core promise); list-axes→sweep→rank
composes and self-corrects.
Findings surfaced for follow-on (NOT fixed here — filed to the tracker): 2 bugs
(aura run on an open blueprint PANICS exit 101 instead of a clean exit-2 like mc;
closed→walkforward --axis prints the rejection twice), 2 friction (sweep-side
closed error terser than mc's exemplary message; mc reproduce lines omit the
seed), 2 spec-gaps (every open knob is mandatory on sweep but the docs frame
list-axes as a menu; the whole blueprint-data verb family is invisible from
`--help` / no README — empirically confirms #159). Detail per finding in the spec.
fieldtests/world-c21-milestone/ carries the op-scripts, authored blueprints,
captured outputs, and run_all.sh (regenerates the gitignored runs/ telemetry).
refs #170
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
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
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
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
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
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
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
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
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
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
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
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
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).
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
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.
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).
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
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
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-*.
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
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.
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
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
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
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
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
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
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
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
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