Changelog

Source: NEWS.md

ledgr 0.2.0.0

• Made ledgr-owned DuckDB drivers use session-local extension and secret storage, removing repeated DuckDB home notices from tests and rendered articles without suppressing ledgr diagnostics. Release checks now verify GFM freshness and local image targets, and the non-CRAN quantstrat DSR oracle is a documented manual check while CRAN pbo is declared in Suggests.
• Corrected reversal-fill projections so derived CLOSE and OPEN fees are allocated pro rata and sum to the source event fee without changing cash, lot state, realized PnL, or trade metrics.
• Simplified ledgr_run_fills() to one eager bt argument with a stable tibble result; the cursor, lazy-read, and threshold-switching modes were removed.
• Restored source and risk lineage on ranked sweep-review results so explicit candidate extraction and promotion work after review and reopen. The compact review$top table remains presentation-only and carries no sweep lineage.
• Added the committed risk_chain_hash to ledgr_run_info(). Historical runs without recorded risk identity report NA rather than an inferred no-op plan; inspection remains read-only and does not expose the full risk plan.
• Locked durable run handles as resource-owning locators: close(bt) releases resources without deleting evidence, and completed runs remain readable from the closed handle or through ledgr_run_open() in a later session. Public examples now use ordinary target indexing and an explicit review-to-promotion workflow.
• Split the backtest implementation into its accepted config, handle, fills, and result ownership files, and extracted all four run-coordinator stages as explicit preparation, snapshot, finalization, registration, and resume records. Runtime effect order, snapshot guards, cleanup ownership, public exports, and execution behavior remain unchanged.
• Corrected post-fold failure handling so committed ledger, strategy-state, and feature evidence survives a failed finalization and the same run can resume finalization without duplicate rows. Added detecting feature causality, caller-RNG preservation, and resource-cleanup regression gates.
• Protected the structural ts_utc column in retained wide sweep projections with a reversible reserved-name encoding. Original candidate IDs remain unchanged in long, matrix, panel, and candidate-extraction surfaces; no persisted mapping or identity input was added.
• Corrected the availability run window so declared session-calendar bounds keep their time of day. The bounds are ISO8601 strings, and parsing them without an explicit format truncated both to midnight, which silently dropped the final open session from the decision axis and left a target decided on the last remaining pulse unfilled even though its next open was present in the snapshot. Runs over declared session calendars now cover one more session, so equity curves, pulse counts, and run identity hashes change for affected configurations. The same truncation is corrected for the walk-forward created_at_utc record.
• Added classed point-in-time fact constructors and a read-only pre-seal validation report for membership, trading status, lifetime, and complete venue-session calendars. Daily vendor dates map explicitly to declared session closes; observed bars never define the expected-session clock.
• Added read-only fact history and cutoff resolution over in-memory facts or sealed snapshots. Resolution preserves explicit true, false, and unknown membership states without exposing future-known evidence or widening the strategy context.
• Added constituent-list membership input and an optional qlcal session preparation adapter. Equivalent row/list membership evidence hashes identically; generated schedules retain provider, calendar, hours, override, and assumption provenance without persisting a calendar object.
• Session construction now rejects ambiguous fall-back and nonexistent spring-forward local wall times consistently while preserving explicit POSIXct instants.
• Added experiment-store schema 113, saved-sweep schema 4, and snapshot hash rule 2 for normalized fact families and explicitly acknowledged observation quarantine. Fact-free snapshots retain hash rule 1 unchanged, legacy sealed snapshots are never rehashed, and quarantined rows remain hashed audit evidence rather than runtime bars.
• Added explicit availability activation with public membership-universe and stale-valuation policies plus effective-plan inspection. Availability-aware experiments require a complete declared session calendar and valuation policy; canonical omission keeps the dense path unchanged.
• Added the internal point-in-time availability provider, dynamic public pulse axes, decision-time context planes, and stable-ID asset state. Facts are resolved only after both effective and knowledge time, while provider code remains free of valuation, affordability, risk, and fill policy.
• Corrected availability-aware execution so a close-time decision resolves execution facts and records an accepted fill at the next declared session opening. Decision-frozen membership and the terminal no-opportunity rule are preserved, while dense execution remains unchanged.
• Added read-side fill alignment and explicit timing provenance. Public fill timestamps remain economic execution times, while recording_pulse_ts_utc derives the associated execution-session close for grouped equity alignment without adding a persisted column. New active runs record timing version 2 in identity; retained version-1 runs reopen read-only, and mixed or unknown timing conventions are marked ineligible for fill-level equivalence without hiding their summary metrics.
• Added strict expected-session feature semantics for the built-in SMA and returns indicators. Whole-feed outages remain visible, missing required observations invalidate affected windows, and unsupported gap behavior fails before strategy use. Availability-aware compiled spot-FIFO requests also fail before execution; dense compiled behavior is unchanged.
• Added availability-aware target restrictions and helper-safe sizing. Held nonmembers are preserved and reserved by default, unavailable sizing data fails closed, post-risk targets cannot enlarge strategy exposure, and new or enlarged shorts are rejected before any fill can finance another purchase. The pre-release restriction vocabulary is finalized by renaming status_halted to trading_halted and status_quotation_only to quotation_only.
• Added separate fresh/stale valuation and risk marks plus bounded affordability. Accepted reductions fund purchases through a deterministic virtual cash ledger, rejected sales fund nothing, stale marks never price execution, and final cash is reconciled without imposing an intrapulse floor.
• Added experiment-store schema 114 with direct-run completion and diagnostic evidence. Expected valuation, risk-mark, settlement, and reconciliation stops preserve accepted prefixes as INCOMPLETE; unexpected fold errors remain FAILED and retain only post-rollback error diagnostics.
• Added terminal recovery for availability-aware DONE and INCOMPLETE runs. Achieved incomplete run IDs return idempotently, while failed finalization resumes from committed terminal evidence without rerunning strategy code or duplicating fold rows. ledgr_run_open() now opens either terminal status; malformed evidence fails with ledgr_run_terminal_evidence_invalid.
• Curated fact-history and resolution printing now keeps effective and knowledge times, completeness, and resolution reasons visible while naming omitted stored columns and preserving the full evidence objects unchanged.
• ledgr_run_list() now appends recorded completion evidence and puts achieved horizons beside raw metrics in its default print. Incomplete metrics are explicitly labelled as prefix-only; dense and historical runs retain typed unknown completion fields.
• Backtest summaries now follow recorded completion evidence: when performance is incomplete they retain prefix total return and maximum drawdown, name the achieved window, and withhold annualized return, annualized volatility, and Sharpe ratio with an explanation. Run-info printing presents completion before identity and telemetry fields.
• Backtest summaries now label n_trades as Closed Trades, matching its closed-trade-row computation without changing the value.
• Bound the completed-run comparison rule: explicitly named non-DONE runs fail with ledgr_run_not_complete, while inventory-style comparison without IDs excludes them. The Survivorship Bias article now uses the public fact prints and completion-aware inventory rather than article-defined reporting helpers.
• Added experiment-store schema 115 completion evidence for sweep candidates and walk-forward scores. Incomplete prefixes stay visibly labelled but are excluded from complete panels, selection, candidate extraction, and promotion; an incomplete test fold ends a carry-state walk-forward session as PARTIAL without inventing a later opening state. Extraction and promotion reject incomplete candidates with ledgr_incomplete_sweep_candidate and ledgr_promote_incomplete_candidate, respectively.
• Added diagnostics and availability result tables plus ledgr_run_explain(). These read durable traces and reconstruct availability from sealed facts without executing strategy code; missing traces fail with ledgr_run_explanation_unavailable rather than producing an inferred decision.
• Added the executed Survivorship Bias article. Its public workflow builds dated membership and session facts, seals and runs an ordinary strategy, explains a blocked exit and retained holding, reopens the same evidence, and contrasts strict invalid-observation rejection with explicit quarantine and an honestly incomplete valuation horizon.
• Rebuilt that workflow around public fact-history and cutoff-resolution queries, an explicit whole-feed outage, opening-time fill evidence, and a result-derived common comparison window. ledgr_run_info() and summary() now expose recorded completion bounds, stop evidence, and affected instruments without reconstructing historical evidence.
• Development continues under the accepted v0.2.0.0 packet. The ordered scope next hardens representation, provenance, and run-coordinator boundaries, then implements the first point-in-time asset-availability path on the shared fold. The packet is at inst/design/ledgr_v0_2_0_0_spec_packet/; Batches 0-12 are complete after review and Batch 13 is awaiting review.

ledgr 0.1.9.7

• Added ledgr_return_panel() as the public return-panel entry point for selection-integrity diagnostics. The diagnostics now accept either a source-neutral return panel or a retained sweep, carry a uniform evidence-only panel_hash, and are renamed to ledgr_pbo(), ledgr_min_track_record(), ledgr_dsr(), and ledgr_effective_trials() with no deprecated aliases.
• Extended opt-in sweep retention with closed-trade evidence and added ledgr_sweep_trades(). The compact retained table records deterministic trade order, close time, realized P&L, and win/loss outcome; it is captured during the sweep and is never reconstructed from fills.
• Added ledgr_business_objective() and seven classed, serializable, hashable eligibility criteria covering trade distribution, profit distribution, strict-lattice stable regions, drawdown, run stability, minimum trade count, and positive equity trajectory. Named DSR and MinTRL diagnostic outputs can also be thresholded as evidence without being recomputed. Objective hashes are provenance only and do not enter run, sweep, candidate, promotion, session, or walk-forward identity.
• Added ledgr_sweep_filter() as an evidence-only, all-candidates objective evaluation. Its default table retains every completed candidate and every criterion outcome, including failures. It does not rank, choose, or promote a candidate, and candidate extraction, promotion, and walk-forward selection reject the result explicitly.
• Added native ledgr_k_ratio() using the pinned Kestner (2013) compounded- return definition. Like the other Selection Integrity diagnostics, it is evidence only and makes no future-profitability claim.
• Closed the v0.1.9.6 intraday-audit M-1 honesty gap with a warning-only, classed metric-context cadence guardrail. It detects intraday observations paired with daily annualization assumptions without changing metric values, execution behavior, or identity. This is not first-class intraday runtime support.
• Rebuilt the Selection Integrity article around visible return-panel inputs, concept-first explanations, and executed cautionary contrasts for PBO/CSCV, MinTRL, K-Ratio, DSR, and effective trials.
• Deferred objective-filtered walk-forward identity, broader non-lattice robustness criteria, scored/weighted objective composition, and a public third-party criterion contract to a later business-objective RFC. Triple Penance remains paper-verification gated; cadence-aware walk-forward window warnings and the bounded intraday example remain with the later intraday cycle. Purging/embargo/CPCV, portfolio optimization, point-in-time data, benchmark-relative metrics, OMS, broker reconciliation, paper/live trading, and liquidity/capacity remain separate future work.

ledgr 0.1.9.6

• Added canonical single-run returns as ledgr_results(bt, what = "returns") and as_tibble(bt, what = "returns"), using the same adjacent-equity return formula as ledgr-owned metrics and retained sweep returns.
• Added retained-sweep return panels and adapter-shaped projections for validation consumers. ledgr_sweep_returns_panel() fails closed on ragged completed-candidate grids, while matrix, data-frame, and optional xts projections keep candidate ordering deterministic.
• Ran the PBO/CSCV spike and accepted a native implementation path. ledgr now ships native evidence-only selection-integrity diagnostics: ledgr_sweep_pbo(), ledgr_sweep_min_track_record(), ledgr_sweep_dsr(), and ledgr_sweep_cluster(). The CRAN pbo, PerformanceAnalytics, and quantstrat packages remain optional reference checks, not runtime dependencies.
• Added the Selection Integrity article. It teaches PBO/CSCV, minimum track record length, Deflated Sharpe Ratio, and deterministic effective-trial clustering as one method family: what evidence they consume, how to interpret them, what they cannot prove, and why they do not select or promote candidates.
• Completed the intraday-readiness audit and recorded the future guardrails it found. v0.1.9.6 makes no intraday runtime change.
• Redid the internal peer-benchmark preflight on the current cost/risk surface and recorded the current-surface row boundary. This is internal measurement evidence only; the release adds no public benchmark ranking claim and does not flip the compiled spot-FIFO default.
• Deferred out of v0.1.9.6: business-objective filtering, objective-filtered walk-forward identity, K-Ratio, Triple Penance, purging, embargo, CPCV, benchmark-relative diagnostics, portfolio optimization, intraday runtime support, and a compiled spot-FIFO default decision.

ledgr 0.1.9.5

• Consolidated the post-v0.1.9.x public surface after the cost, sweep persistence, target-risk, and walk-forward feature arc. This release is a naming, teaching, contract, and audit-hardening release before the validation-toolkit packet.
• Renamed and unexported pre-CRAN API names for naming consistency. No compatibility aliases are shipped.
• Fixed scheduled v0.1.9.4 deep-review findings in runner/results behavior, accounting hardening, compiled spot-FIFO validation, timestamp hashing, lot-close dust handling, and contracts.
• Refreshed the article set: quickstart, risk-and-cost, walk-forward, strategy-authoring, TTR/adapter indicators, metric-context conventions, experiment-store, and execution-semantics now reflect the renamed API and the v0.1.9.x feature arc.
• Added maintainer-manual articles for the cost resolver, target-risk layer, and walk-forward machinery, plus an internal performance-arc follow-up for cost/risk/walk-forward measurement questions.
• Made walk-forward inspection easier to read: wf$degradation now prints a curated train-versus-test view (the full table is one as_tibble() away), and fold lists print their per-fold train and test windows.
• Added ledgr_sweep_review() for explicit sweep review tables and ledgr_temp_store() for disposable .duckdb paths used in examples and teaching workflows.
• Deferred out of v0.1.9.5: validation-toolkit statistics, the standalone debugging article, the Split E vignette split, additional sweep/metric-context splits, lower-value vignette-audit helpers, paired entry/exit trade views, and the promotion-recovery summary helper.

Old name	New name / disposition
iso_utc()	ledgr_iso_utc()
passed_warmup()	ledgr_passed_warmup()
select_top_n()	ledgr_select_top_n()
signal_return()	ledgr_signal_return()
target_rebalance()	ledgr_target_rebalance()
weight_equal()	ledgr_weight_equal()
ledgr_clear_feature_cache()	ledgr_feature_cache_clear()
ledgr_compare_runs()	ledgr_run_compare()
ledgr_deregister_indicator()	ledgr_indicator_remove()
ledgr_extract_strategy()	ledgr_run_strategy()
ledgr_extract_fills()	ledgr_run_fills()
ledgr_get_indicator()	ledgr_indicator_get()
ledgr_list_indicators()	ledgr_indicator_list()
ledgr_register_indicator()	ledgr_indicator_register()
ledgr_snapshot_load()	ledgr_snapshot_open()
ledgr_ttr_warmup_rules()	ledgr_ind_ttr_warmup_rules()
ledgr_walk_forward_results()	ledgr_walk_forward_open()
ledgr_backtest_run()	no longer exported
ledgr_compute_equity_curve()	no longer exported; use ledgr_results(bt, "equity")
ledgr_create_schema()	no longer exported
ledgr_metric_context_resolve()	no longer exported

ledgr 0.1.9.4

• Added the first walk-forward evaluation surface. ledgr_walk_forward() runs fold-local train sweeps, applies scalar selection rules, executes the selected candidate on each test window through ledgr_run(), and persists compact session, fold, and score evidence.
• Walk-forward results now lead with a train-vs-test degradation table. The table records selected train and test metric values, absolute and percentage differences, and warning flags such as short_test_window and cold_start_distorted.
• Added read-only walk-forward inspection helpers and explicit candidate extraction. ledgr_walk_forward_results(), ledgr_walk_forward_scores(), and ledgr_walk_forward_folds() reopen stored evidence without recomputing or rerunning. ledgr_walk_forward_extract_candidate() returns a normal ledgr_sweep_candidate for deliberate ledgr_promote() use.
• This release does not add PBO, CSCV, CPCV, DSR, benchmark diagnostics, selection-integrity correction, cross-snapshot walk-forward, OMS behavior, paper/live behavior, gross-vs-net attribution, signal decay, or implementation/cost decay.

ledgr 0.1.9.3

• Added the first public target-risk API: classed ledgr_risk_chain(), ledgr_risk_none(), ledgr_risk_long_only(), and ledgr_risk_max_weight() objects. Risk chains transform full validated strategy target vectors before fill timing and cost resolution; they do not construct targets, rank candidates, estimate costs, model liquidity, or own order lifecycle behavior.
• Added target-risk execution identity. Modern configs, runs, sweep candidates, promotion context, and saved sweeps carry risk_chain_hash plus risk_plan_json alongside existing strategy, feature, metric, and cost identity. Omitted risk, risk_chain = NULL, and ledgr_risk_none() normalize to the same no-op risk plan.
• Target-risk transforms apply uniformly across canonical R, parallel, and compiled spot-FIFO sweep paths with the same risk identity and parity requirements.
• Saved sweeps now use schema v2 for risk identity. The first ledgr_sweep_save() against a v0.1.9.2 store performs an additive migration for risk_chain_hash and risk_plan_json; older saved sweeps with no risk fields reopen as the no-op risk plan when unambiguous.
• Refactored the fold pulse into plan, risk, timing/cost, emit, and apply phases so risk transforms happen once per pulse before fills are proposed. This preserves the canonical fold path and changes internal telemetry attribution by moving proposal-build work into pulse planning / t_fill; it is not a behavior change apart from the requested risk transforms.
• This release does not add arbitrary risk callbacks, affordability enforcement, cash-floor checks, portfolio optimization, margin, shorting or borrow policy, liquidity/capacity modeling, OMS behavior, broker-grade risk controls, failure_type schema columns, walk-forward, or automatic candidate selection.

ledgr 0.1.9.2

• ledgr_sweep() can now retain and persist compact sweep artifacts. The new retain = ledgr_sweep_retention() argument defaults to today’s scalar-only sweep behavior; opting into returns = "completed" keeps net portfolio equity and pulse-aligned returns for completed candidates. Saved sweeps can be eagerly reopened from the experiment store as sweep-like result objects and queried through ledgr_sweep_returns() or ledgr_sweep_returns_wide(). Failed candidates keep scalar summary rows but no retained return rows.
• Pre-CRAN sweep candidate rows now expose candidate_id plus one-indexed candidate_row instead of overloading run_id. Committed runs still use run_id; sweep promotion context records the source candidate_id / candidate_row separately from the promoted run ID.
• This release does not add ranking helpers, automatic selection, benchmark-relative alpha/beta diagnostics, signal-decay tooling, or gross-vs-net cost attribution; those remain routed to later benchmark-context, feature-analysis, and execution-attribution RFCs.

ledgr 0.1.9.1

• Added the public transaction-cost API: classed ledgr_cost_*() model constructors, ordered ledgr_cost_chain() composition, ledgr_cost_steps() / ledgr_cost_describe() inspection helpers, explicit ledgr_timing_next_open() timing, and deterministic cost identity through cost_model_hash plus cost_plan_json.
• Breaking pre-CRAN changes: legacy fill_model inputs are replaced by timing_model plus required cost_model; zero-cost execution must be explicit with ledgr_cost_zero(); new fill rows use fee instead of the legacy commission_fixed field; and legacy stored configs with fill_model are rejected with classed errors rather than translated.
• Fixed the v0.1.8.11 auditr THEME-004 identity findings: config_hash is now independent of DuckDB store path and alias declaration order, and alias_map_hash is independent of concrete feature parameter values. Concrete feature identity is captured by feature_set_hash, which is exposed alongside cost_model_hash and cost_plan_json on documented run and promotion surfaces. These identity fixes intentionally change stored-run hashes for affected experiments.
• Refreshed bounded documentation surfaces for the cost API and related auditr findings: installed disclaimer resolution, stable cost/timing/legacy condition-class help, LEDGR_LAST_BAR_NO_FILL help, quoted-spread cost teaching, runnable cost examples, and sweep documentation that cost models are fixed experiment inputs in v1. At the time of v0.1.9.1, sweep artifact persistence, target risk, and walk-forward were still future v0.1.9.x packets.

ledgr 0.1.8.11

• Added the maintainer manual under inst/design/manual/, with two-layer Synthesis and Implementation Trace articles for execution fold core, observability/determinism, snapshots/data, sweep, features, the v0.1.8.x performance arc, and benchmark methodology.
• Audited and reorganized the design surface: contracts.md, the design index, RFC index, roadmap, horizon, generated documentation, inst/ contents, and release-gate context were refreshed for the post-v0.1.8.10 architecture.
• Wound down legacy adr/, architecture/, and maintainer_review/ source-note directories to README-only ledgers after migrating their load-bearing content into the maintainer manual.
• Refreshed user-facing documentation for the scoped B2 spot-FIFO sweep opt-in, strategy accessor substrate, and research-software disclaimer posture. This release adds no execution semantics, public API, or benchmark speed claims.

ledgr 0.1.8.10

• Added the matrix-canonical strategy context substrate: ctx$idx(), universe-aligned ctx$vec OHLCV/positions views, and ctx$vec$feature(feature_id) for bulk feature reads. Existing scalar helpers remain supported.
• ctx$positions remains a named pulse-start snapshot, but its name order is now canonicalized to ctx$universe even when the internal fold state was initialized from a differently ordered named position vector.
• Moved FIFO lot accounting ownership into the fold state transition for fresh sweep execution while preserving event rows and durable reconstruction / readback as verifier and fallback paths. Fresh memory-backed sweeps now use the handler’s inline summary facts when available instead of replaying the event stream for equity/fills/metrics.
• Hoisted fixed yyjsonr read/write option objects out of canonical JSON helper bodies, preserving canonical byte-format v2 while removing avoidable per-call options construction overhead.
• Added a scoped public opt-in for the memory-backed sweep spot-FIFO accelerator with ledgr_sweep(..., compiled_accounting_model = "spot_fifo"). The default remains canonical R (compiled_accounting_model = NULL); committed durable runs still fail closed for "spot_fifo" until a separate durable-integration gate lands. ledgr_run() validates the same enum and reports that durable deferral explicitly.

ledgr 0.1.8.9

• Switched canonical JSON serialization and parsing from jsonlite to yyjsonr and intentionally bumped the canonical JSON byte format to v2. Config, snapshot, strategy, reproduction, and ledger metadata hashes that include canonical JSON bytes are not byte-comparable with pre-v0.1.8.9 values.
• Updated strategy provenance package fingerprints to track yyjsonr instead of jsonlite. This is an expected identity-surface change for the v0.1.8.9 dependency migration, not a strategy-semantics change.
• Continued the single-core optimization round with measured per-lane attribution for fills reconstruction, durable and memory output handlers, position valuation, and target-delta handling.
• Recorded the local v0.1.8.8-to-v0.1.8.9 benchmark closeout. On the high-density xlarge workload-grid cell, durable wall time moved from 445.02s to 232.03s, per-fill engine cost fell 51.9%, and per-fill extraction cost fell 88.2%; these numbers are local-host/current-source evidence, not a public speed ranking.

ledgr 0.1.8.8

• Added optional parallel sweep dispatch over the existing fold core, keeping workers = 1 on the sequential reference path and making worker setup, package loading, deterministic row ordering, warning/error association, and discard-all interrupt behavior explicit.
• Added deterministic per-pulse seed plumbing through ctx$pulse_seed and rejected ambient-RNG strategy behavior for resume/parallel equivalence surfaces while preserving deterministic strategies.
• Introduced an internal typed execution-spec payload and validation boundary so run, sweep, fold, and worker dispatch share one structured execution contract without adding public API surface.
• Refreshed fold-core diagnostics and maintainer evidence, including bucketed fold-loop profiling and current-source closeout artifacts for future optimization work.
• Reorganized dev/bench/, added a repo-local peer benchmark with boundary-equivalent ingestion/engine/results timing, real engine invocation gates, divergence attribution artifacts, and explicit caveats that the report is an internal sanity check rather than a public ranking.
• Added a ledgr-only self-profiling workload grid across SMA density, universe size, history length, and persistence mode. The baseline confirms that high-fill-density workloads are dominated by fold-loop fill/event throughput and fills reconstruction, and that the memory-backed path is not currently a universal fast path at large scale.
• Deferred the maintainer-manual skeleton and stale-document cleanup ticket to a future maintainer-manual / architecture-documentation release.

ledgr 0.1.8.7

• Removed legacy execution gunk from modern runs: execution now reaches the fold only through sealed snapshots, R6 strategies are gone, and run-time data_hash identity no longer participates in sealed-run resume or replay.
• Dropped cli and R6, added collapse behind a deterministic wrapper, and kept the modern strategy contract as plain functions returning full named numeric target vectors.
• Reworked the durable and sweep event buffers from worst-case preallocation to grow-by-doubling, preserving event IDs, event order, POSIXct UTC timestamps, per-row meta_json, and durable/memory event surfaces.
• Rejected sub-second snapshot input, carried trusted whole-second POSIXct values through hot fill paths, and replaced session-local feature cache JSON+hash keys with deterministic length-prefixed lookup keys while keeping durable identity hashes fenced.
• Rewrote fills reconstruction/read-back around primitive column buffers instead of per-row data.frames plus do.call(rbind, ...), preserving FIFO semantics and DB-backed/memory-backed parity.
• Formalized the sweep fast path versus promotion/materialization slow path and added ledgr_candidate_reproduction_key() so compact sweep candidates expose the data needed for later explicit promotion.
• Recorded the post-lane local benchmark closeout. On this host and one TTR-backed SMA workload, the canonical ledgr peer row is now faster than the local Backtrader and quantstrat rows, but the result is scoped to that workload, timing boundary, and machine; it is not a public peer-superiority claim.
• Deferred parallel dispatch, compiled fold-core work, matrix-canonical public strategy surfaces, target risk, walk-forward, cost/liquidity, OMS, and public benchmark dashboards.

ledgr 0.1.8.6

• Reduced feature setup/materialization cost by deduplicating feature cache-key inputs, making ctx$feature_table schema-only by default, and preserving long-row inspection through explicit/on-demand paths.
• Kept ctx$features_wide contract-compatible while making wide-view data.frame manifestation cheaper and removing an intermediate all-pulse wide matrix allocation.
• Added a structured local benchmark suite with current-source guards, warmup/repeat metadata, machine-readable outputs, LEAN side-by-side caveats, two-mode width sweeps, and matched local peer benchmark support.
• Recorded post-fix attribution and peer-comparison evidence: the matched Backtrader SMA crossover row is faster than ledgr on this host, and profiling names the event-buffering/emission path as the dominant remaining hot lane.
• Deferred DuckDB feature storage, typed persistent event columns, snapshot administration, research-loop helper APIs, auditr-report intake, target risk, parallel dispatch, walk-forward, public cost/liquidity APIs, OMS, and public benchmark dashboards.
• Added the v0.1.8.7 Optimization Round 2 handoff: RFC-first fold-core primitive contract, run-artifact materialization policy, event-emission lane, cache-key/setup lane, reconstruction lane, and ADR 0004 dependency decisions.

ledgr 0.1.8.5

• Rebuilt the documentation set around the research workflow: sealed snapshots, declared experiments, executable runs, exploratory sweeps, candidate promotion, reopenable artifacts, and provenance review.
• Migrated installed and pkgdown article sources to Quarto, removed the retired Getting Started middle layer, and aligned README and pkgdown navigation with the new reading flow.
• Added or refreshed canonical articles for experiment storage, reproducibility tiers, execution semantics, sweeps, strategy development, indicators, custom indicators, metrics and accounting, leakage, and research-to-production boundaries.
• Tightened documentation contracts around active aliases, feature-vs-strategy parameter namespaces, sweep inspection, promotion caveats, metric context, snapshot lifecycle, source provenance, warmup behavior, and target-holding execution semantics.
• Kept runtime semantics stable. Walk-forward evaluation, target-risk and capital-affordability constraints, public cost-model factories, parallel dispatch, out-of-core feature storage, benchmark context, external point-in-time regressors, and paper/live adapters remain planned roadmap layers rather than v0.1.8.5 features.

ledgr 0.1.8.4

• Added active parameterized feature aliases so feature declarations can use ledgr_param() placeholders and resolve them per run or sweep candidate while strategies read stable alias names such as fast and slow.
• Added separate feature-grid and strategy-grid helpers plus executable grid composition so feature-resolution parameters and strategy-runtime parameters stay conceptually distinct.
• Stored alias-map provenance with run and sweep artifacts, including deterministic alias-map hashes, while keeping concrete feature identity separate from user-facing alias names.
• Updated pulse-debug and feature-inspection surfaces so parameterized feature maps, active aliases, and resolved concrete feature IDs can be inspected before and after execution.
• Added ledgr_demo_sma_crossover_strategy() as a small Tier-1 teaching fixture for README, getting-started, sweep, and strategy-development examples.
• Routed the v0.1.8.3 auditr report into bounded fixes for sweep print copy, preflight global-assignment diagnostics, warmup-guard examples, real-data troubleshooting notes, and active-alias documentation.
• Kept automatic ranking, objective selection, walk-forward, target risk, cost/liquidity policy, OMS, parallel dispatch, split stores, live data logs, point-in-time regressors, and scaffold helpers out of this release.

ledgr 0.1.8.3

• Made ledgr_sweep() substantially faster on single-core workloads by adding a shared runtime feature projection, fast pulse-context helper reuse, prebuilt static pulse views, typed memory events, and single-pass sweep summary reconstruction while preserving the shared ledgr_run() / ledgr_sweep() fold-core contract.
• Final v0.1.8.3 measurements show the reference sweep workload improving from 45.585s to 13.220s (3.45x faster) and the wider feature-payload workload improving from 65.360s to 12.130s (5.39x faster). The repeated committed-run comparison is also faster than baseline after the persistent buffered-write path was preserved under the unified output-handler contract.
• Preserved public context field semantics for ctx$bars, ctx$feature_table, and ctx$features_wide while moving their expensive per-pulse construction out of the fold hot loop.
• Hardened strategy preflight against indirection bypasses and clarified Tier 3 forbidden-call diagnostics without adding a public force-override path.
• Polished metric-context, sweep failure inspection, snapshot sealing, indicator, strategy-development, and troubleshooting documentation based on routed maintainer-review findings.
• Recorded the accepted primitive-internals and collapse-acceleration synthesis for future v0.1.9 planning, while keeping collapse out of v0.1.8.3 runtime dependencies.

ledgr 0.1.8.2

• Added ledgr_metric_context(), ledgr_risk_free_rate(), ledgr_calendar(), US-equity and crypto calendar templates, metric-context hashing, and inspection accessors so risk-free-rate and annualization assumptions are explicit, stored, and auditable.
• Threaded metric context through experiments, committed runs, summaries, single-run metrics, comparisons, sweeps, candidates, and promotion context without adding metric context to execution config identity.
• Added a plain serializable metric kernel that precomputes annualization and period risk-free-rate inputs before metric computation, including comparison and sweep paths.
• Fixed strategy preflight so forbidden nondeterministic calls such as Sys.time() and global assignment with <<- fail early as Tier 3 before run or sweep artifacts are written, while resolved immutable external scalars remain Tier 2.
• Improved metric, sweep, promotion, indicator, CSV, timestamp, TTR bundle, feature-inspection, and strategy-development documentation based on auditr intake, including clearer current-workflow guidance for parameterized indicator sweeps before the future active-alias API.
• Polished selected diagnostics without changing error classes, including timestamp format guidance, CSV snapshot failure next actions, duplicate bundle alias remediation, unsupported feature-result table routing, and TTR output-naming guidance.
• Completed the indicator codebase Phase 2 file-shape cleanup by renaming the built-in and adapter indicator files and splitting indicator development helpers from pulse snapshot helpers while preserving public APIs, exports, feature IDs, fingerprints, and behavior.
• Recorded pre-CRAN compatibility policy and accepted the active parameterized feature aliases synthesis for the future v0.1.8.4 sweep-authoring ergonomics cycle.

ledgr 0.1.8.1

• Added ledgr_ind_ttr_outputs() for multi-output TTR authoring. The helper returns a ledgr_indicator_bundle that flattens into ordinary single-output indicators before runtime, preserving the existing feature and sweep provenance contracts.
• Added derived default bundle names such as bbands_dn, explicit prefix support, outputs filtering, prefix = NULL raw-name opt-in, and a named-vector naming escape hatch for custom bundle IDs.
• Extracted package-level determinism and fingerprint helpers from R/indicator.R into a dedicated determinism module without changing public APIs, existing indicator IDs, or fingerprint pins.
• Expanded installed documentation around the feature lifecycle, feature IDs, feature-map aliases, warmup feasibility, result inspection surfaces, sweep provenance, failed-candidate inspection, snapshot metadata, CSV validation locality, and strategy-helper troubleshooting.
• Completed runnable example and discoverability polish across the main vignettes, including a complete custom-indicator run/inspect workflow and clearer installed article links from package and function help.
• Polished selected diagnostics: final-bar no-fill warnings now state origin, consequence, and next action; duplicate indicator registration errors now name both safe actions; Tier 3 preflight errors now state that no public force override exists on ledgr_run() or ledgr_sweep().
• Documented current metric assumptions without introducing metric-context storage: the current public metric path uses a default risk-free rate of zero and cadence-inferred annualization.
• Refreshed stale version wording in user-facing documentation so current tutorials describe the current research workflow instead of old patch-release labels.

ledgr 0.1.8.0

• Added sequential ledgr_sweep() for lightweight parameter-grid exploration over the same private fold core used by ledgr_run(), with in-memory sweep output rather than per-candidate DuckDB writes.
• Added ledgr_param_grid(), ledgr_precompute_features(), ledgr_candidate(), and ledgr_promote() support for explicit sweep construction, candidate extraction, and committed run promotion.
• Added row-level execution_seed, compact row-level provenance, and durable run_promotion_context records so promoted runs remain traceable to their source sweep candidate and selection view.
• Added explicit execution seed support for ledgr_run() and deterministic sweep candidate seed derivation from the master seed, candidate label, and candidate parameters.
• Refactored fold execution internals around a shared execution core, memory and persistent output handlers, a reserved future target-risk slot, and a private fill-timing/cost-resolution boundary.
• Added parity coverage proving sweep, promotion, and direct run behavior agree for deterministic strategies, seeded stochastic strategies, feature-factory sweeps, fill timing, standard metrics, and config identity.
• Added the sweeps vignette and README workflow section documenting train/sweep/evaluate discipline, caller-owned ranking, failure rows, seeds, provenance, promotion context, and deferred non-goals.

ledgr 0.1.7.9

• Added ledgr_feature_contract_check() so users can inspect feature warmup feasibility before running a strategy, including explicit handling for deferred feature factories.
• Improved strategy-author ergonomics around empty selections, feature maps, strategy context helpers, custom indicators, and zero-trade/warmup diagnosis.
• Polished public documentation flow, article ordering, snapshot/store examples, result-inspection guidance, and release-site hygiene.
• Fixed opening-position lot accounting so cost basis is honored consistently across fills, trades, metrics, equity reconstruction, derived state, and run comparison output.
• Documented current per-leg spread_bps semantics without changing fill-model behavior.
• Removed dead live equity-array bookkeeping and routed remaining execution engine audit findings to explicit release or roadmap decisions.

ledgr 0.1.7.8

• Added strategy reproducibility preflight with ledgr_strategy_preflight(), classifying functional strategies as tier_1, tier_2, or tier_3 before ordinary ledgr_run() execution.
• Integrated Tier 3 enforcement into the existing run path so unresolved unqualified helper dependencies stop execution with a classed error before run artifacts are written.
• Recorded strategy preflight results in run provenance and exposed the reproducibility tier through existing run-info, comparison, and strategy extraction surfaces.
• Added public design articles for reproducibility, leakage, and custom indicator authoring, including the trust = FALSE strategy-extraction boundary and the residual risk of custom vectorized series_fn code.
• Routed the v0.1.7.7 auditr follow-up findings so reproducibility, leakage, provenance, and custom-indicator boundary work shipped in v0.1.7.8 while broader strategy-author ergonomics remained deferred to v0.1.7.9.
• Documented the fold-core/output-handler contract that future sweep mode must inherit so ledgr_sweep() can remove persistence overhead without becoming a second execution engine.

ledgr 0.1.7.7

• Added the first ledgr-owned risk-adjusted standard metric, sharpe_ratio, computed from adjacent public equity-row excess returns with a scalar annual risk-free rate converted geometrically to a per-period return.
• Tightened standard metric return-series handling so invalid adjacent equity returns make annualized volatility and Sharpe-style metrics NA instead of silently dropping structurally invalid return rows.

ledgr 0.1.7.6

• Completed a DuckDB persistence architecture review covering connection ownership, checkpoint placement, transaction boundaries, shutdown behavior, and DuckDB metadata assumptions.
• Hardened schema validation boundaries so runtime validators remain read-only with respect to ledgr data rows while constraint enforcement is tested in isolated disposable databases.
• Added explicit live DML coverage for runs.status and snapshots.status constraints, including valid status values and safe cleanup after expected DuckDB constraint failures.
• Added fresh-connection persistence tests proving completed runs, public run metadata mutations, and low-level CSV snapshot create/import/seal/load workflows are readable after reopen.
• Documented a narrow local WSL/Ubuntu DuckDB gate and preserved branch, main, and tag-triggered CI as separate release evidence.
• Routed the v0.1.7.5 auditr retrospective into later roadmap milestones so v0.1.7.6 stays focused on persistence architecture.

ledgr 0.1.7.5

• Hardened the TTR adapter with parity tests across every supported ledgr_ttr_warmup_rules() entry and resolved the MACD warmup boundary with direct TTR evidence.
• Added a user-facing warmup diagnostic for zero-trade runs where a registered feature never becomes finite because an instrument has too few bars.
• Fixed: schema validation probes now issue an explicit rollback after expected constraint violations, preventing DuckDB connection-state contamination on Ubuntu under coverage instrumentation.
• Improved result-inspection documentation with a compact closed-trade example that distinguishes equity, fills, trades, ledger rows, and summary metrics.
• Added a complete low-level CSV snapshot bridge from create/import/seal through verified load, metadata inspection, experiment construction, and ledgr_run().
• Strengthened indicator, helper, feature-map, and ctx$features() discoverability while keeping feature-map aliases distinct from engine feature IDs.
• Documented ledgr’s adapter posture as a deterministic backtesting core that connects to R finance ecosystem packages through explicit adapter boundaries.

ledgr 0.1.7.4

• Breaking: the raw long feature table on pulse contexts moved from ctx$features to ctx$feature_table; ctx$features is now the feature-map bundle accessor. This keeps raw inspection data and strategy authoring accessors separate.
• Added feature-map authoring UX with ledgr_feature_map(), ctx$features(), and passed_warmup() while preserving the existing target-vector execution contract and features = list(...) registration.
• Added feature-inspection views with ledgr_feature_contracts(), ledgr_pulse_features(), and ledgr_pulse_wide() so users can inspect contracts, long pulse rows, and stable wide pulse rows.
• Resolved auditr documentation findings around hidden vignette helpers, helper-page discovery, feature IDs, warmup diagnosis, TTR-backed indicators, leakage examples, and first-path navigation.
• Fixed the low-level CSV snapshot create/import/seal workflow so sealing derives missing runnable metadata from imported bars and instruments without changing snapshot hash identity.
• Cleaned installed-documentation hygiene, including stale retired ttr-indicators artifacts, package/help-page article links, pkgdown reference entries, and documentation-contract tests.

ledgr 0.1.7.3

• Correctness hardening: aligned equity-curve state, final positions, and summary/comparison metrics against ledger fills, with focused regressions for the v0.1.7.2 auditr accounting finding.
• Metric explainability: documented every metric shown by summary(), ledgr_compare_runs(), and related result surfaces, and added independent oracle tests that recompute expected values from public result tables.
• Documentation discoverability: made installed articles discoverable from package-level and function-level help pages for headless and agent workflows.
• Concept documentation: added installed accounting/metrics and indicators articles, consolidated TTR-backed and built-in indicator teaching, and tighten helper, feature-ID, warmup, and no-trade guidance.

ledgr 0.1.7.2

• Stabilised comparison metrics and zero-row result schemas: n_trades now counts closed trade rows consistently across summary(), ledgr_compare_runs(), ledgr_run_list(), and ledgr_results(bt, what = "trades"), while what = "fills" continues to expose execution fill rows.
• Improved result-access connection lifecycle: ordinary durable result inspection now opens and closes read connections per operation, and close() is documented as long-session resource management rather than data-safety ceremony.
• Added the strategy-helper value type foundation: ledgr_signal, ledgr_selection, ledgr_weights, and ledgr_target, with ledgr_target unwrapping through the existing target-vector validator.
• Added the minimal strategy-helper reference layer: signal_return(), select_top_n(), weight_equal(), and target_rebalance() for long-only helper pipelines that still terminate in normal target quantities.
• Improved strategy diagnostics and feature-ID documentation: strategy errors now include pulse timestamp, run, instrument, and available-feature context while preserving the original error as the parent condition.
• Overhauled the strategy-development article around the ledgr pulse mental model, helper functions, feature IDs, warmup behavior, interactive pulse debugging, and run comparison.
• Improved documentation discovery and pkgdown positioning: README now shows noninteractive installed-vignette lookup paths, background positioning articles remain pkgdown-only, and experiment-store docs clarify durable paths, persistent snapshot IDs, labels, tags, CSV snapshot creation, and handle lifecycle framing.

ledgr 0.1.7.1

• Stabilised the installed-package UX after the v0.1.7 experiment-first reset, with clearer start-here documentation, modern base-pipe examples, and a runnable offline workflow built around ledgr_demo_bars.
• Added ledgr_utc() as a small UTC timestamp helper for examples and user workflows, avoiding repeated as.POSIXct(..., tz = "UTC") boilerplate.
• Made ledgr_demo_bars and ledgr_sim_bars() tibble-friendly for modern R examples.
• Added display-only result timestamp printing controls through options(ledgr.print_ts_utc = "auto"), so all-midnight EOD result tables can print compact dates while underlying ts_utc values remain POSIXct UTC.
• Verified MACD TTR warmup against direct TTR output for macd, signal, and histogram outputs with both percent = TRUE and percent = FALSE; under the tested TTR version, macd is first valid at nSlow, while signal and histogram are first valid at nSlow + nSig - 1.
• Expanded strategy and TTR indicator articles with clearer ctx, params, feature ID, warmup NA, and quantity-target sizing guidance.
• Clarified the experiment-store mental model: sealed snapshots freeze market data, while indicators, features, runs, labels, tags, comparisons, and telemetry are derived artifacts that can be added later.
• Included package vignettes in source builds and declared the vignette build dependencies so GitHub installs with build_vignettes = TRUE expose vignette(package = "ledgr").

ledgr 0.1.7

Breaking changes

• Began the v0.1.7 experiment-first API reset. The public research workflow now centers on ledgr_experiment() and ledgr_run() rather than db_path-first calls and direct ledgr_backtest() usage.
• The v0.1.7 strategy contract is function(ctx, params). Strategies without tunable parameters receive params = list().
• The v0.1.7 context target constructors are ctx$flat() and ctx$hold(); the older ctx$targets() and ctx$current_targets() helpers now fail with migration guidance.

New features

• Added ledgr_opening() for explicit opening cash, positions, and optional cost basis.
• Added ledgr_experiment() as the central object for the experiment-first workflow.
• Added ledgr_run() as the public single-run API for ledgr_experiment objects, including run-time features = function(params) evaluation and an explicit seed = NULL identity field.
• Converted experiment-store APIs to snapshot-first signatures and extended ledgr_snapshot_load() so a durable file with exactly one sealed snapshot can be resumed without retyping the snapshot id.
• Added ledgr_param_grid() as a typed, non-executing parameter-grid object with stable canonical-JSON labels for future sweep/tune workflows.
• Added curated print methods for ledgr_run_list() and ledgr_compare_runs() while keeping the underlying objects tibble-compatible.
• Added ledgr_demo_bars and ledgr_sim_bars() as deterministic offline demo data for examples and documentation.
• Made durable ledgr_backtest handles safer to clean up: explicit close(bt) checkpoints before disconnecting, and a finalizer safety net attempts one auto-checkpoint if a durable handle is garbage-collected without close.
• Rewrote README and vignettes around the v0.1.7 experiment-first workflow and added a v0.1.6 to v0.1.7 migration guide.
• Added ledgr_opening_from_broker() as a reserved adapter hook. v0.1.7 does not ship built-in broker integrations.

ledgr 0.1.6

• Added ledgr_compare_runs() for comparing completed stored runs from a durable experiment store without rerunning strategies.
• Added ledgr_extract_strategy() for safe strategy-source inspection and optional hash-verified recovery from the experiment store.
• Added ledgr_run_tag(), ledgr_run_untag(), and ledgr_run_tags() for mutable run grouping metadata that does not change experiment identity.
• Added dedicated experiment-store and strategy-development articles covering run management, ctx, feature IDs, comparison, and safe source inspection.
• Added ledgr_feature_id() and print.ledgr_indicator() so strategy authors can discover exact built-in and TTR feature IDs before writing ctx$feature() calls.
• Expanded the TTR indicator article with feature ID examples for built-in indicators, RSI, ATR, BBands, and MACD.

ledgr 0.1.5

• Added the v0.1.5 experiment-store schema foundation, including schema-version metadata, additive migration hooks, run provenance and telemetry tables, and defensive future-schema checks.
• Added strategy_params support for function(ctx, params) strategies and durable run provenance capture for strategy source hashes, parameter hashes, dependency versions, R version, and reproducibility tier.
• Added experiment-store discovery APIs: ledgr_run_list(), ledgr_run_info(), and ledgr_run_open() for listing, inspecting, and reopening completed runs without recomputation.
• Added ledgr_run_label() and ledgr_run_archive() for metadata-only run management without changing experiment identity or deleting artifacts.
• Added ledgr_results() as a package-prefixed wrapper for result tables.
• Made mistyped ctx$feature() lookups fail loudly with available feature IDs instead of silently returning NA, while preserving warmup NA behavior for known features.
• Persisted compact run telemetry summaries, including execution mode, elapsed time, pulse count, feature-cache hit/miss counts, and persist_features; print.ledgr_backtest() and ledgr_run_info() now surface execution mode.
• Relaxed snapshot ID diagnostics so explicit durable custom IDs do not warn unless they use the generated snapshot_ prefix in a malformed way.

ledgr 0.1.4

• Stabilised the research workflow ahead of the experiment-store APIs, with durable snapshot reuse, safer strategy helpers, faster indicator precomputation, and broader TTR indicator support.
• Added ledgr_snapshot_load() for reopening existing sealed snapshots from a durable DuckDB file, with optional hash verification.
• Updated ledgr_snapshot_list() so it accepts either a DBI connection or a DuckDB file path.
• Added ctx$current_targets() to runtime and interactive pulse contexts for hold-unless-signal strategy patterns.
• Made internal backtest configs an S3 ledgr_config object with validation and diagnostic printing, while keeping public workflows centered on ledgr_backtest().
• Marked ledgr_data_hash() as a legacy v0.1.0 helper and moved internal run/snapshot-adapter hash call sites to explicitly named internal helpers.
• Added optional vectorized indicator series_fn support for full-series feature precomputation, including vectorized built-in indicators.
• Added a session-scoped feature cache keyed by snapshot hash, instrument, indicator fingerprint, feature-engine version, and date range, with ledgr_clear_feature_cache() for explicit cleanup.
• Added ledgr_ind_ttr() and ledgr_ttr_warmup_rules() for low-code TTR indicator construction with explicit warmup and fingerprint metadata.
• Expanded low-code TTR support to common close, high/low, HLC, and HLCV indicators including WMA, ROC, momentum, CCI, BBands, aroon, DonchianChannel, MFI, CMF, and rolling statistic functions.
• Added ledgr_deregister_indicator() for cleaning up session-scoped indicator registry entries during interactive work and tests.
• Changed fn-only custom indicator fallback from expanding full-history windows to bounded stable windows to avoid accidental O(n^2) feature work.
• Clarified v0.x compatibility policy, strategy reproducibility tiers, next-open fill semantics, and low-level API lifecycle notes in design and reference documentation.

ledgr 0.1.3

• Reworked the README into a 5-minute installed-package path with runnable synthetic data, rendered output, target-vector strategy examples, and an explicit determinism trust check.
• Added a getting-started vignette that walks through the research loop: in-memory bars, strategy authoring, result inspection, pulse debugging, indicators, Yahoo convenience data, CSV snapshots, and durable DuckDB artifacts.
• Added human-readable pulse context helpers for strategy code, including ctx$close(), ctx$position(), ctx$targets(), and related OHLCV accessors.
• Improved target-vector validation errors so unnamed, non-numeric, missing, and extra instrument targets point users to the required contract: a named numeric target vector with names matching ctx$universe.
• Audited exported reference documentation and examples so public examples run offline, use temporary files/databases, guard optional dependencies, and avoid network access.
• Added metric definitions to the reference documentation, including the closed-trade meaning of win rate and average trade.
• Added local and CI release gates for the README cold-start example, acceptance tests, rcmdcheck, coverage, and pkgdown site builds.
• Added a GitHub Pages pkgdown deployment workflow for publishing the package site after the repository is made public.
• Hardened DuckDB run persistence by checkpointing runner-owned write connections before disconnect/shutdown, fixing cross-connection visibility on Ubuntu CI.
• Documented the longer-term experiment-store model: DuckDB files as durable research artifacts, immutable run IDs, strategy identity, reproducibility tiers, and future run discovery/comparison APIs.

ledgr 0.1.2

• Added a data-first ledgr_backtest(data = bars, ...) convenience path that creates a sealed snapshot and then runs the canonical engine.
• Added indicator registry, built-in indicators, adapters, pulse development tools, basic metrics, fill extraction, equity curves, and plotting.
• Strengthened strategy and indicator fingerprints so mutable registry state cannot silently change deterministic replays.
• Exported and documented the v0.1.2 public API surface.

ledgr 0.1.1

• Added snapshot provenance workflow: create, import (CSV), list/info, hash, and seal snapshots.
• Runner can source data from a SEALED snapshot and fails loud on tampering (hash mismatch).

ledgr 0.1.0

• Initial deterministic backtest core spine (schema, config/data hashing, features, strategy contract, fill model, ledger writer, derived state reconstruction, runner, acceptance tests).
• Strategy state persistence/restore for resume-safe strategy state.
• Equity curve reconstruction emits one row per pulse timestamp.
• Added public API functions ledgr_db_init() and ledgr_state_reconstruct().