calibrated_agent_evaluation.improve¶
calibrated_agent_evaluation.improve ¶
Check whether a proposed fix really worked.
The last stage of the loop. Four guards combine into one ImproveVerdict:
- a pre-registration ledger, which freezes the metric and threshold before the fix;
- a held-out confirmation slice, fresh and paired, that the fix was not tuned on;
- a paired McNemar test on before and after verdicts (with a mid-p variant, and an explicit
undefinedresult when no verdict changed); - a Holm-corrected panel of guard slices that catches a fix that only moves failures elsewhere, which for a crew means gating on the workflow outcome rate.
No trace-store or observability SDK and no backend writes; the only external library is
statsmodels, used in mcnemar.
CrewComparison
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
Both sides' crew failures, paired per trace for the guard slices.
agent_pairs and handoff_pairs hold, for each agent and handoff measured on both
sides, every paired trace's (failed before, failed after). not_measured_agents and
not_measured_handoffs were measured on neither side.
Config:
frozen:Trueextra:forbid
Fields:
CrewFile
pydantic-model
¶
Bases: _Strict
The crew file calibrated-agent-evaluation improve --crew-file reads.
agents and handoffs drive the guard panel. scenarios and rules are optional,
validated by build_crew_definition when present, and not read by the counting.
Fields:
CrewSide
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
One side's crew failures over the paired traces.
agent_failed and handoff_failed map every declared agent and handoff to the paired
traces that failed on it, each trace once. agents_measured and handoffs_measured are
the ones the source spoke to on this side. disputed are the traces with a FAIL whose
culprit is disputed.
Config:
frozen:Trueextra:forbid
Fields:
-
agent_failed(dict[str, tuple[str, ...]]) -
handoff_failed(dict[str, tuple[str, ...]]) -
agents_measured(tuple[str, ...]) -
handoffs_measured(tuple[str, ...]) -
disputed(tuple[str, ...])
AdjudicationRequiredError ¶
Bases: ImproveError
A judge-labeled discordant pair lacks a human-ratified adjudication.
McNemar assumes ground-truth labels; a judge's own run-to-run flip-flops land in exactly the
discordant cells it counts. So when an LLM judge produced the before/after labels, the improve
guard refuses to run the test until every discordant pair carries a kind="human"
adjudicating label -- the human-gold boundary (the "refuse to calibrate from gold"
analogue). The improve stage writes no label itself; it requires the human-provenance one the
review surface produces.
ConfirmationContaminationError ¶
Bases: ImproveError
The confirmation slice overlaps the development / tuning set.
Measuring a headline before/after on traces the fix was tuned against is regression-to-the-mean contamination -- the dev set scores better by construction. Raised (naming the overlapping trace_id) rather than measuring a contaminated headline.
ImproveError ¶
Bases: CalibratedAgentEvaluationDataError
Base class for every improve-stage refusal.
ImproveStoreError ¶
Bases: ImproveError
An ImproveRecord file read or write failed.
Wraps the underlying OSError / json.JSONDecodeError / csv failure so a
filesystem/parse error surfaces inside the typed family rather than as a raw stdlib exception
escaping the store's public surface ("wrap external errors at the boundary"). A stored
schema_version != the running IMPROVE_SCHEMA_VERSION also refuses here (no coercion).
LedgerIntegrityError ¶
Bases: ImproveError
The pre-registration ledger was edited, replaced or frozen after the run it gates.
Raised when a write would change or drop an entry already on disk, when the ledger no longer holds an entry an earlier evaluation recorded, and when a pre-registration was frozen after the earliest time recorded in the after run. Each is how a threshold chosen after seeing the result would get in, so the gate refuses rather than measure against it.
GuardPanelReport
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
The Holm-corrected guard-slice panel.
method is the literal "holm" only: one surviving slice rejects the fix, so the panel
controls the family-wise error rate, which Holm does under any dependence between the
overlapping slices (fdr_bh and fdr_by are not accepted).
m is the comparison count, stated per run. regressed names the slices whose regression
survived the correction. relocation carries the crew verdict for a crew improvement,
None for a single-agent one.
Config:
frozen:Trueextra:forbid
Fields:
-
slices(tuple[GuardSlice, ...]) -
method(Literal['holm']) -
m(int) -
regressed(tuple[str, ...]) -
relocation(RelocationResult | None)
GuardSlice
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
One non-targeted slice watched for regression, with its confidence-treated rates.
regression_p is the p-value that this slice regressed (worsened) between before and after;
the panel corrects these across all slices with Holm. rate_before /
rate_after are Interval\ s.
Config:
frozen:Trueextra:forbid
Fields:
-
name(str) -
kind(SliceKind) -
regression_p(float) -
rate_before(Interval) -
rate_after(Interval)
ImproveRecord
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
The persisted, version-pinned audit artifact for one improvement evaluation.
Carries the referenced pre-registration, the paired result, the guard panel (with its
multiplicity m and any crew relocation), the confirmation/development slice ids it was
proven disjoint against, the final verdict, and the inputs that produced it.
Round-trips losslessly through store.
Config:
frozen:Trueextra:forbid
Fields:
-
improve_id(str) -
verdict(Verdict) -
prereg(PreRegEntry) -
paired(McNemarResult) -
panel(GuardPanelReport) -
confirmation_slice_id(str) -
development_set_id(str) -
inputs(dict[str, str]) -
reasons(tuple[str, ...]) -
schema_version(str) -
provenance(ProvenanceStamp)
Validators:
-
_check_invariants
ImproveRequest
dataclass
¶
ImproveRequest(
ledger,
target_metric,
pairs,
confirmation_ids,
development_ids,
slices=(),
adjudications=dict(),
crew=None,
crew_before=None,
crew_after=None,
touched_agent=None,
success_threshold=None,
anchors=(),
after_run_started_at=None,
)
The full input to evaluate_improvement.
ledger + target_metric select the frozen pre-registration to gate on;
pairs are the paired before/after observations on the confirmation slice;
confirmation_ids / development_ids prove disjointness; slices are the
non-targeted guard panel. adjudications maps a discordant trace_id to the
kind="human" Label that adjudicates it -- the KEY presence + human provenance IS
the ratification record (there is no separate Adjudication type; the review surface records
it via Label.kind="human", not a label field). The crew / crew_before /
crew_after / touched_agent fields are populated only for a crew improvement.
success_threshold is optional and never used as the threshold: the gate reads the
pre-registered one, and a caller who states a threshold that differs from it is refused.
anchors are the pre-registration entries earlier evaluations recorded (each
ImproveRecord carries its own); the ledger must still hold every one unchanged.
after_run_started_at is the earliest time recorded in the after run, when known; the
pre-registration must have been frozen before it.
ImproveVerdict
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
The composed improve decision.
verdict is rejected if the paired test did not show an improvement, OR any guard slice
regressed, OR a crew improvement relocated its failure; accepted only when all guards pass.
reasons records why a rejection happened (named slices / relocation / not-significant).
Config:
frozen:Trueextra:forbid
Fields:
-
verdict(Verdict) -
prereg(PreRegEntry) -
paired(McNemarResult) -
panel(GuardPanelReport) -
reasons(tuple[str, ...])
McNemarResult
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
The paired before/after significance.
method records how it was computed -- asymptotic (>= 25 discordant), exact /
midp (< 25 discordant), or undefined (zero discordant pairs: the test has no info, so
p_value is None and undefined_reason is populated -- never a fabricated p-value).
effect is the change in fail-rate (after - before) as an Interval.
Config:
frozen:Trueextra:forbid
Fields:
-
method(PairedMethod) -
n_discordant(int) -
p_value(float | None) -
effect(Interval) -
undefined_reason(str | None)
Validators:
-
_check_invariants
PairedObs
dataclass
¶
One paired before/after observation on a single confirmation-slice input.
before_fail / after_fail are the old/new agent's binary FAIL verdict on the SAME input
(fresh-and-paired); together across the slice they populate the 2x2 McNemar table.
labels_are_judge_produced drives the adjudication gate.
PreRegEntry
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
One frozen pre-registration: a target metric + success threshold committed BEFORE a fix.
freeze (in prereg) stamps content_hash over
frozen_fields; require_prereg re-verifies it
on read, so a metric or threshold edited after the entry was frozen fails the check and is
refused. is_crew marks target_metric as the crew's workflow outcome rate.
success_threshold is the minimum absolute reduction in the target's fail rate the fix must
show, in (0, 1): 0.10 means the fail rate must fall by at least ten percentage points. The
improve gate accepts only when the upper bound of the paired effect interval (after minus
before) is at most -success_threshold, so the whole interval shows that reduction, not just
its point. freeze refuses a value
outside (0, 1).
The temporal anchor: frozen_at is the UTC time
freeze stamped, prev_hash the content_hash
of the ledger entry before this one (None for the first), and code_ref the commit of the
agent under test the entry was frozen against, supplied by the caller. All three are inside the
hash, so an entry edited and re-frozen gets a new frozen_at and breaks the chain to every
later entry.
Config:
frozen:Trueextra:forbid
Fields:
-
prereg_id(str) -
target_metric(str) -
success_threshold(float) -
is_crew(bool) -
content_hash(str) -
frozen_at(str) -
prev_hash(str | None) -
code_ref(str | None)
frozen_fields ¶
The tuple the content_hash is computed over (everything except the hash itself).
Source code in src/calibrated_agent_evaluation/improve/report.py
compute_hash ¶
Deterministic content hash over frozen_fields (JSON-canonical, sha256).
Source code in src/calibrated_agent_evaluation/improve/report.py
PreRegLedger
pydantic-model
¶
Bases: CalibratedAgentEvaluationModel
The append-only ledger of frozen pre-registrations.
register_prereg returns a NEW ledger with the frozen
entry appended; there is no update or delete path -- immutability is what makes "the metric was
chosen before the fix" a guarantee rather than a convention.
Config:
frozen:Trueextra:forbid
Fields:
-
entries(tuple[PreRegEntry, ...])
assert_held_out ¶
Refuse if the confirmation slice overlaps the development set.
Raises ConfirmationContaminationError naming the shared trace_id\ s. An empty
confirmation slice is refused too -- there is nothing to measure a headline on (a vacuous
"held out" is not held out).
Source code in src/calibrated_agent_evaluation/improve/confirm.py
pair_observations ¶
Pair before/after FAIL verdicts on the same inputs into PairedObs.
before / after map trace_id -> before/after FAIL (True = the agent failed on that
input). The two must cover exactly the same inputs -- an input present on only one side means
the slice was not run through both agents on the same inputs, breaking the paired assumption, so
it is refused (naming the offending ids) rather than silently dropped. judge_produced marks
every observation as judge-labeled (drives the adjudication gate downstream).
Source code in src/calibrated_agent_evaluation/improve/confirm.py
slice_id ¶
The id of a set of traces: prefix, then a digest of its sorted trace ids.
An improve record names its confirmation slice and development set this way, so another stage can tell whether a slice it holds is one a record already decided.
Source code in src/calibrated_agent_evaluation/improve/confirm.py
compare_crew_sides ¶
Pair before and after per trace over paired, for every agent and handoff.
Raises ImproveError naming each agent or handoff measured on one side only: its
other side has no evidence, and reading that as no failures would hide a regression.
source names the verdicts in that message.
Source code in src/calibrated_agent_evaluation/improve/crew.py
count_crew_side ¶
Count one side's agent and handoff failures over the paired traces.
is_verdict says which labels are the chosen source's verdicts; attribute names the
agent a verdict blames (None for none). A trace counts once for an agent when at least one
FAIL verdict on it is attributed to the agent, and once for a handoff when one names it in
handoff_implicated. A FAIL whose culprit_span is "disputed" blames no agent and
puts its trace on disputed.
An agent is measured when any verdict on a paired trace is attributed to it. ran (trace id
-> the agents with a span on it) is given when the source's verdicts speak for every agent that
ran, as a human's trace-level verdict does: an agent is then also measured when it ran on a
paired trace, and a handoff when both its agents ran on one. Otherwise a handoff is measured
only when a verdict names it.
Raises ImproveError when a verdict is attributed to an agent, or names a handoff, that
crew does not declare: the crew file and the store describe different crews.
Source code in src/calibrated_agent_evaluation/improve/crew.py
crew_definition_from_file ¶
Validate a parsed crew file and build its CrewDefinition.
Raises ImproveError for an unknown field, a value of the wrong type or a repeated
agent or handoff, and CrewDefinitionError for
whatever build_crew_definition refuses (no agents, a malformed or undeclared handoff, a
scenario or rule naming an undeclared agent).
Source code in src/calibrated_agent_evaluation/improve/crew.py
crew_outcomes ¶
The before and after CrewOutcomes for relocation_check.
The workflow failures are the FAILs in the (adjudicated) workflow pairs, over all of them; each agent's failures are its counted traces on that side.
Source code in src/calibrated_agent_evaluation/improve/crew.py
not_measured_rate ¶
The rate of a slice the source did not measure: no point, and the whole [0, 1] range.
Source code in src/calibrated_agent_evaluation/improve/crew.py
evaluate_improvement ¶
Evaluate one proposed improvement against all four causal guards.
Runs the guards in order (pre-registration -> held-out -> adjudication -> McNemar -> panel) and
returns the composed ImproveVerdict. Raises before returning a verdict when a guard
refuses: ImproveError (unregistered/mutated
prereg, a ledger that disagrees with the entries in anchors, a pre-registration frozen after
a time in after_run_at, a trace paired twice, a success_threshold outside (0, 1) or
differing from the caller's, empty input),
ConfirmationContaminationError,
AdjudicationRequiredError, or
StatisticsInputError (a forbidden
multiplicity method). For a crew request
(crew/crew_before/crew_after/touched_agent set), the panel is the crew panel
with the relocation fold-in.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
request
|
ImproveRequest
|
The pre-registration, the paired before/after observations and the guard slices. |
required |
Returns:
| Type | Description |
|---|---|
ImproveVerdict
|
Whether the improvement is accepted, with each guard's result. |
Source code in src/calibrated_agent_evaluation/improve/guard.py
record_of ¶
Assemble the persisted ImproveRecord from a verdict.
A thin constructor so the caller (or the CLI) can persist the audit artifact via
dump_improve_records. inputs must be non-empty
(the record refuses otherwise).
Source code in src/calibrated_agent_evaluation/improve/guard.py
adjudicate_pairs ¶
Return pairs with each judge-labeled discordant pair's after outcome set by its human.
The human's verdict replaces the judge's after-run verdict, so McNemar and the effect interval
count what the human saw: a flip the human says did not happen becomes a concordant pair. Call
require_adjudication first; a pair this cannot adjudicate raises
AdjudicationRequiredError. Concordant pairs and human-gold pairs are kept as given.
Source code in src/calibrated_agent_evaluation/improve/paired.py
adjudication_problem ¶
Why label cannot adjudicate trace_id for target_metric, or None if it can.
A usable adjudication is a human's trace-level label on that trace that speaks to the target:
a FAIL for target_metric, or a PASS for it or for no mode.
Source code in src/calibrated_agent_evaluation/improve/paired.py
discordant_pairs ¶
Return the discordant (flipped) pairs -- the b + c cells McNemar counts.
Source code in src/calibrated_agent_evaluation/improve/paired.py
discovery_enqueue ¶
Route the discordant pairs into the labeling queue tagged frame="discovery".
Reuses DiscoveryEnqueue: a discordant pair a judge
disagreed with itself on is non-random augmentation (it grows the discovery set) and must never
enter a production-frame rate (the assert_production_frame guard enforces that downstream).
Source code in src/calibrated_agent_evaluation/improve/paired.py
paired_mcnemar ¶
Run the paired McNemar test over pairs.
Auto-selects the exact/mid-p variant when the discordant count is < 25 and the asymptotic one
otherwise (via mcnemar_paired). A zero-discordant
slice is surfaced as McNemarResult(method="undefined", p_value=None, ...) with the effect
still reported (a genuine 0.0 change) -- never a fabricated p-value. Raises
ImproveError on empty input or a trace id that appears in more than one pair.
Source code in src/calibrated_agent_evaluation/improve/paired.py
require_adjudication ¶
Refuse McNemar until every judge-labeled discordant pair has a usable human verdict.
When labels_are_judge_produced is False the before/after labels are human gold and no
adjudication is required (returns immediately). When True, every discordant trace_id must
map to a Label that is a human's trace-level verdict on that trace's after-run output
for target_metric: a FAIL for target_metric, or a PASS for it or for no mode. Anything
else raises AdjudicationRequiredError, naming the traces: a missing entry, a non-human
(unratified) label, a span-level label, a label for another trace, or one about another failure
mode, which says nothing about whether the target was fixed.
Source code in src/calibrated_agent_evaluation/improve/paired.py
build_crew_slices ¶
build_crew_slices(
crew,
*,
touched_agent,
agent_regression_p,
agent_rates,
handoff_regression_p,
handoff_rates,
)
Derive the per-other-agent + per-declared-handoff guard slices for a crew.
Includes a slice for every crew agent EXCEPT touched_agent (the guard panel watches the
agents the fix did NOT target), and a slice for every declared handoff in crew.handoffs.
Each slice carries its before/after Interval rates and the p-value that it regressed. A
handoff_regression_p key naming a seam not in crew.handoffs, or an
agent_regression_p key naming an undeclared agent, is refused (the crew seam guard).
Source code in src/calibrated_agent_evaluation/improve/panel.py
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 | |
crew_panel ¶
Build the crew guard panel: agent+handoff slices + the relocation fold-in.
slices are the caller-derived per-agent and per-handoff guard slices (each kind="agent"
or "handoff", its name an agent in crew.agents or a handoff in crew.handoffs --
see build_crew_slices). This runs the Holm panel over them AND folds in
relocation_check over before/after at touched_agent so the
workflow-outcome-rate verdict + the failure-relocation flag are attached to the report. Refuses
a touched_agent absent from crew.agents.
Source code in src/calibrated_agent_evaluation/improve/panel.py
guard_panel ¶
Correct the guard-slice regression p-values with Holm and name any survivor.
slices each carry a regression_p (the p-value that the slice worsened). The panel
corrects them with holm at family-wise level alpha (via
apply_multiplicity -> multiplicity;
fdr_bh/unknown methods are refused by the primitive as StatisticsInputError),
states m = the slice count, and lists in
regressed the slices whose regression survived correction. Raises ImproveError on
an empty panel -- a declared-but-empty guard panel is a caller bug, not a vacuous "no
regression".
Source code in src/calibrated_agent_evaluation/improve/panel.py
freeze ¶
Return entry stamped with frozen_at, prev_hash and its content_hash.
frozen_at is the current UTC time (now exists for tests and must be timezone-aware);
prev_hash is the hash of the ledger entry this one follows, which register_prereg
supplies. code_ref is kept as given. The stamped entry is what register_prereg
stores; require_prereg recomputes the hash on read and refuses a mismatch. Refuses a
success_threshold outside (0, 1): it is a minimum absolute reduction in fail rate, so 0
would accept any significant drop and 1 or more can never be met.
Source code in src/calibrated_agent_evaluation/improve/prereg.py
ledger_head ¶
The ledger's head: its last entry's content_hash, or "empty" for no entries.
The hash chain makes the head name the whole ledger up to it, so a record stamped with the head when it was made can later tell whether the ledger it was made against still exists.
Source code in src/calibrated_agent_evaluation/improve/prereg.py
register_prereg ¶
Append entry (freezing it, chained to the last entry) to ledger; return a NEW ledger.
Refuses a duplicate target_metric -- a second pre-registration for the same metric would let
a later, result-fitted threshold shadow the one committed before the fix (the exact evasion the
ledger exists to stop). The returned ledger is a new object; the input is unchanged.
Source code in src/calibrated_agent_evaluation/improve/prereg.py
require_frozen_before ¶
Refuse entry if it was frozen at or after after_run_started_at.
A pre-registration exists to fix the bar before the result is known, so it must predate the
after run it gates. None means the after run recorded no time, and nothing is checked; the
caller says so in its output. Raises LedgerIntegrityError when the order is wrong and
ImproveError for a naive after_run_started_at.
Source code in src/calibrated_agent_evaluation/improve/prereg.py
require_prereg ¶
Return the frozen pre-registration for metric; refuse if absent, mutated, or unchained.
Verifies the whole ledger first (verify_ledger), so an entry whose metric, threshold,
or crew flag was edited after freeze, or a ledger whose chain was broken by a
re-freeze, is refused before any headline is measured. An unregistered metric is likewise
refused rather than silently measured.
Source code in src/calibrated_agent_evaluation/improve/prereg.py
verify_anchors ¶
Refuse a ledger that no longer holds, unchanged, every entry in anchors.
anchors are the pre-registrations earlier evaluations recorded (each improve record keeps
the entry it gated on). An anchor missing from the ledger, or present with a different hash,
means the ledger was edited, replaced or deleted after that evaluation, so a threshold it now
holds may have been chosen after a result was seen. Raises LedgerIntegrityError
naming the first such entry.
Source code in src/calibrated_agent_evaluation/improve/prereg.py
verify_heads ¶
Refuse a ledger that no longer holds a head a stored record was stamped with.
stamped pairs a description of each record ("run record 'run-1'") with the head it
carries. A head is held when it is "empty" or the content_hash of an entry still in
the ledger. Raises LedgerIntegrityError naming the first record whose head is gone.
Source code in src/calibrated_agent_evaluation/improve/prereg.py
verify_ledger ¶
Refuse a ledger whose hashes, chain, or freeze times do not hold.
Every entry must hash to its content_hash; the first must have no prev_hash and each
later one must name its predecessor's hash; frozen_at must be a UTC timestamp that never
goes backwards. Raises ImproveError naming the first broken entry.
Source code in src/calibrated_agent_evaluation/improve/prereg.py
dump_improve_records ¶
Write records to improve_record.{csv,json} under path.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
records
|
Sequence[ImproveRecord]
|
The improve records to persist. |
required |
path
|
str | Path
|
The directory to write into. |
required |
fmt
|
str
|
Which file a later |
'csv'
|
Raises:
| Type | Description |
|---|---|
ImproveStoreError
|
A bad |
Source code in src/calibrated_agent_evaluation/improve/store.py
dump_prereg_ledger ¶
Write ledger to prereg_ledger.json under path, entries in ledger order.
Every entry keeps its content_hash, frozen_at and prev_hash as stamped, so
load_prereg_ledger returns a ledger
verify_ledger accepts iff the original did. The
ledger is append-only on disk too: a ledger that changes or drops an entry already in the file
is refused, which is how an edited and re-frozen last entry would otherwise be saved.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
ledger
|
PreRegLedger
|
The ledger to persist. |
required |
path
|
str | Path
|
The directory to write into. |
required |
Raises:
| Type | Description |
|---|---|
LedgerIntegrityError
|
|
ImproveStoreError
|
Any filesystem failure, or a stored ledger that cannot be read. |
Source code in src/calibrated_agent_evaluation/improve/store.py
load_improve_records ¶
Read improve records back from path; a missing file is an empty store.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
path
|
str | Path
|
The directory |
required |
fmt
|
str
|
|
'csv'
|
Returns:
| Type | Description |
|---|---|
list[ImproveRecord]
|
The stored records. |
Raises:
| Type | Description |
|---|---|
ImproveStoreError
|
A schema-version mismatch, or any read, parse or validation failure. |
Source code in src/calibrated_agent_evaluation/improve/store.py
load_prereg_ledger ¶
Read the ledger written by dump_prereg_ledger; an absent file is an empty ledger.
Returns the entries exactly as stored and does not verify them: the improve gate's
require_prereg does, so an edited file is refused
there with the entry it broke.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
path
|
str | Path
|
The directory |
required |
Returns:
| Type | Description |
|---|---|
PreRegLedger
|
The stored ledger. |
Raises:
| Type | Description |
|---|---|
ImproveStoreError
|
Any read, parse or validation failure. |