Skip to content

solvi.core.system

System: catalog + questions → ask → answers with flow, trace and safeguards; fit / teach; storage.

System: catalog + questions → ask(init_state) → answers with confidence, flow, computed_state, trace; fit / teach; storage of responses and corrections (solvi.core.store).

Response dataclass

Response(results: dict, flow: object, trace: object, values: dict, ms: float, feasible: bool = True, violations: list | None = None, catalog: object = None, safeguards: list | None = None, model_outputs: int = 0)

Bases: Serial

The answers of one ask, with the flow, the trace, every fact's value and the safeguards. Stability: stable (final: use it, do not subclass; its record format is stable).

A response keeps a strong reference to the System that answered it (for report(): the questions, the answer heads, the replay). Deliberately not a weak one: System(cat, qs).ask(state).report() is common and the temporary System would be gone before the report runs. A response you keep for long keeps its System (and its models) alive; keep res.to_dict() or the stored record instead, or drop the reference with res.detach() (then pass system= to report).

checks property

checks

Every check of this decision's flow as data, in flow order → [CheckResult]: name, questions, status ("passed", "failed", "skipped", "error"), hard, reason (what Fail(...) said), and the answers a failed hard check's then set; then the hard checks that could not be planned for lack of data (guard "no_data"), "skipped" with the missing inputs. In to_dict() (and so in a stored decision) as "checks"; derived from the trace, never parsed from text.

confidence property

confidence

Overall confidence: the probability that every answered question is right — the product of the answers' confidences (errors taken as independent, so it is conservative when answers agree through constraints). Abstained questions are left out; see complete. 1.0 when nothing was answered by a model or a learned part.

complete property

complete

Did every question get an answer (none abstained)?

weakest property

weakest

(question, confidence) of the least confident answer, or None when every question abstained.

not_stated property

not_stated

Questions answered "not stated" (solvi.Unknown): answered — they count in confidence and complete — but the text does not state the value.

overall property

overall

The whole response in one line of data: confidence, weakest answer, answered / abstained, complete, feasible; the questions answered "not stated"; and per answer kind the answered count and the product of their confidences.

facts property

facts

The quoted facts of this response as data: every trace step that quoted its value out of a source text — name, value, the offsets (source[start:end]), the quoted text itself, confidence, provenance. Built from the trace (never parsed from text); empty when nothing was quoted. The whole computed state as data: res.values.

to_dict

to_dict()

model_dump(mode="json"): answers, flow, trace, values, safeguards as JSON-ready data (see Serial).

signature

signature(alg='syndrome')

The signature of this response's trace (solvi.core.store.signature.sign: the input, then every record) — a few numbers to keep next to the stored id; solvi.core.store.signature.locate(res, sig) later names the one record that changed.

state_text

state_text(lang=None)

The computed state for people: each computed fact with its value; a quote's offsets; for anything not computed by plain code, its provenance (quoted by a model, decided, learned) and the model; errors, including rejected (ungrounded) model outputs — in a language (solvi.core._i18n; default: the System's). The facts as data: res.values.

audit

audit(question=None, lang=None)

What each answer rests on and which safeguards fired: given inputs → computed facts → quotes (offsets and quoted text) → model decisions (model, probabilities) → learned parts → checks, rule, constraints → answer; plus the share of the support that is deterministic. print(res.audit()), or res.audit("q").to_dict() for data. lang: the language str() renders in (solvi.core._i18n; default: the System's, "en"); the data is the same in every one. → an Audit of every answer, or the AnswerAudit of one question when question is given.

detach

detach()

Drop this response's reference to the System that answered it (so a response kept for long does not keep the System and its models alive) → the response. Afterwards pass system= to report().

report

report(format='md', question=None, system=None, replay='trusted')

A human-readable report of this decision for an auditor or a customer: each answer, what it rests on, the quotes highlighted in the source text with their offsets, the safeguards that fired, the guarantee line, the models' fingerprints, the trace's hashes and the replay status. format: "md" (Markdown), "html" (one self-contained page, every value escaped) or "data" (a dict). replay: "trusted" (default: deterministic steps re-run, model outputs verified from the record — no model is called), "full" (models re-run too) or False. See solvi.core.store.report.

UnrecordedResponse dataclass

UnrecordedResponse(results: dict, values: dict, ms: float, feasible: bool = True, violations: list | None = None)

Answers from System.decide; deliberately has no audit trace or replay capability.

System

System(catalog: Catalog, questions, *, workers: int = 1, order: str = 'default', producers: str = 'declared', learn: bool | None = None, input_model=None, strategist=None, storage=None, timeout: float | None = None, cost_policy='declared', lang: str = 'en', early_exit: bool = True, cache: int | None = None, allow_unreachable_hard_checks: bool = False, check_models=None, check_intervals=None, check_policies=None)

A catalog and its questions: ask(state) plans the flow (the strategist), runs the parts, applies the checks, rules, heads, guarantees and constraints, and returns a Response with its hash-chained trace; fit, teach, guarantee, report, storage. See the constructor and the guide.

The concrete system every solution is built on — an extension point by what it takes (a Strategist, a TraceStorage, heads, deciders, monitors), not by subclassing. Stability: stable (final: use it, do not subclass).

order: "default" (hard checks and their inputs first, all together) or "learned" (hard checks one at a time, most expected saving first — see learn_order). producers: "declared" (alternative producers of a fact are tried in declaration order) or "learned" (a policy picks the order per input and learns from outcomes). learn: after every ask, update the order / producer models from what happened (which hard check failed on which input, which producer was accepted); default: on when order="learned" or producers="learned", else off (part costs are measured either way). learn_order() turns it on. input_model: a pydantic model of init_state (optional; inputs= in 0.7): a dict passed to ask is validated against it — its fields (with defaults) are the given facts, a field that fails is left out and reported (safeguard type_rejected). ask also takes a BaseModel instance directly, with or without input_model. A given fact cannot share a name with a part of the catalog (ask refuses such a key: the value would replace the part), so a model field named like a part is refused here. strategist: an object with plan(catalog, questions, init_keys, heads) → Flow used by ask instead of the deterministic strategist (solvi.core.plan.cost.CostStrategist; its plan is recorded in the trace, see docs/strategist.md). storage: a solvi.core.store.TraceStorage (or a path: .db / .sqlite → SQLite, else JSON lines) — every ask saves its response (answers, flow, whole trace) there, hash-chained across responses, and teach saves the correction; the response's stored_id is its id in the store (journal=path, its 0.7 name, was removed in 0.9). Every option after questions is keyword-only. timeout: seconds a part's call may take under aask when the part declares no timeout= (None: no limit). producers="equivalent": the producers of a fact are interchangeable — the cost-optimal planner (solvi.core.plan.cost.CostStrategist(producers="equivalent")) picks one per fact, the cheapest valid plan. cost_policy: what that planner's costs are — "declared" (cost=, 1 when undeclared; costs= in 0.7), the only one since 1.0 ("measured" was removed: it showed no measured benefit). early_exit: True (default) — when a hard check fails, the steps only the questions it settles needed are skipped (the expensive rest is not paid for); the decision's record then holds no values for them, and a part listed in requires may not have run — statistics over such records (the system report's "forced_split") cannot say whether the check changed the answer. False — every step of the flow runs anyway: the answers are the same (the failed hard check still decides), res.values and the trace hold every fact and rule value, and the trace says so (trace.early_exit is False). ask(..., early_exit=...) overrides it for one ask. lang: the language of what solvi renders for people — res.audit(), solvi.show, safeguard_summary() — "en" (default) or "ru" (solvi.core._i18n). Only the rendering changes: traces, stored responses, hashes and why stay in English. check_models: optional {question: fitted solvi.stat check combiner}. A detached snapshot applies conditional check likelihoods to the selected answer's confidence before calibration and abstention. Sources must be soft checks in requires, separate from the primary answer's inputs and declared shared calls. No model is fitted implicitly. Initially supports structured scalar choice/yes-no asks without joint constraints or answer facts; cache, decide and ask_text are refused. See docs/check_models.md for outcome mapping and limitations. check_intervals: optional per-question conditional uncertainty settings (level, n, seed, mode). mode="lower" uses the lower model-conditional quantile before confidence safeguards; it is not a certificate. check_policies: optional {question: CheckPolicy} enabling adaptive priced soft checks for one question per ask. Supply check_loss on each ask/aask. See docs/check_acquisition.md for budgets, replay and supported modes. cache: None (default) — every ask runs its flow. N — opt-in pure-decision cache for a catalog without models: ask serves a decision it made before from a cache of the last N, keyed by the catalog's and questions' fingerprints, the questions asked, early_exit and the given facts (their hash, as trace.init_hash). Only for parts that are pure functions of their inputs (no clock, no randomness, no I/O): a part's code is not re-run on a hit. A served response is a copy of the first one (same trace and hashes) with res.cached = {"of": the stored id of that first decision}; stored, it is a compact record with meta {"cache_of": that id} — replay / rederive re-run it from its input and compare every step's hash, as for any compact record. A model-backed part raises here; the cache is bypassed for an ask with another order, a system that learns (learn=True, order or producers "learned"), answer heads, a stateful guarantee or a strategist of your own. aask shares the cache with ask (a decision where a part timed out is not kept); ask_text / aask_text read the text each time and serve the flow when the read (entry point, fields with their quotes, dialogue changes) and the text are the same.

is_async property

is_async

Does the catalog have parts that aask awaits (async def, or marked blocking=True)? solvi serve then answers with aask.

participate

participate(*, after=None, when=None, max_iter=None, reads=(), writes=None, question=None, end=False)

Declare participation in an experimental Process; return self.

after names one predecessor (None declares an entry). when is the Process predicate on that predecessor's outcome. max_iter marks this incoming edge as a bounded loop, counting edge traversals per run. Process.participants snapshots the declaration. Redeclaring a bound System leaves that snapshot unchanged and makes subsequent process runs fail before node calls; assemble a new process to adopt the new declaration. This does not schedule standalone asks.

response_schema

response_schema()

The JSON schema of this system's responses, with each question's answer as its closed set of options.

with_params

with_params(params=None, **facts)

An immutable parameter view over this shared runtime, not an independent System.

Finite-JSON external fact defaults are privately copied; keyword facts override the mapping, and each ask's caller facts override the defaults. Catalog, guards/calibration, learning, stats, cache and storage stay shared. These are data defaults, not a security policy. See docs/api/parameters.md.

ask_many

ask_many(states, questions=None, *, max_items=1000, **options)

A bounded sequential batch of ordinary asks, each with its own trace/store record.

Materialize and check containers, fact keys and the item bound before any ask. Runtime errors propagate normally: earlier records and side effects remain, later inputs are not run. No concurrency or speedup is promised. Other options are the normal ask keyword options.

ask

ask(init_state, questions=None, *, workers=None, order=None, store=True, early_exit=None, check_loss=None)

init_state: a dict of given facts, or a pydantic BaseModel instance (its fields). questions: the questions to ask — a name or a list of names (None: all; an unknown name raises KeyError; names=, its 0.7 spelling, was removed in 0.9). Every other option is keyword-only. order: override the system's order for this ask — "default", "learned", or an object with p_fail(check, row) and row(vals, init_keys) (e.g. an oracle for experiments). store=False: do not save this response to the system's storage. early_exit: None — the system's (System(early_exit=), True by default: after a failed hard check the steps only the settled questions needed are skipped). False — compute the whole flow anyway: the answers are the same, and res.values and the trace hold every fact and rule value of a decision a hard check forced (and every part listed in requires); the trace records it (res.trace.early_exit), and replay checks no step is missing. An async def part is awaited in an event loop of its own, one call at a time: use aask for such catalogs.

probe

probe(question, facts, *, override=False)

Hypothetical evaluation of one question at explicit fact values.

override=True permits supplied values of computed facts; checks and answer rules cannot be replaced. Evaluation is serial so model canaries remain disabled in the diagnostic context. Uses this catalog's actual parts and the usual answer normalization/why, without storing, caching, learning, observing costs or applying calibrated guarantees. Input-model validation is bypassed so direct intermediate facts can be supplied; consumers still validate their inputs. The result is durably marked hypothetical.

decide

decide(init_state, questions=None, *, early_exit=None)

Evaluate a serial, unmodeled catalog without recording or observing it.

Returns UnrecordedResponse, never an audit/replay record. Every call rejects configured guards, storage, models, learning, watches, caches, custom strategies, confidence calibration, asynchronous parts and parallel workers BEFORE validating inputs or running callbacks. Use ask for any such configuration. Ordinary checks, types, contracts, constraints, aliases and accepted answer-fact stages are evaluated by the same execution path. Contract applicability must be an ordinary synchronous Python function (no partial or callable object). User functions retain their own effects.

depends

depends(question)

The initial fact names this question's declared flow reads (a new set).

Uses the same planner/declarations as input schemas, including hard checks, heads, aliases and explicitly declared applicability inputs. This is dependency analysis, not a causal explanation. An opaque applicability predicate needs applicable_inputs or Question.uses.

entry_points

entry_points(questions=None)

The questions as entry points: each question's name, text and the typed input state it reads — every given fact its flow reads, with its type, description and whether the question needs it (the schemas solvi serve publishes). → [solvi.core.textin.EntryPoint]; ep.tool() is the function-calling form.

ask_text

ask_text(text, decider=None, *, textin=None, question=None, store=True, workers=None, order=None, early_exit=None)

A free text → the answer of the question it asks, in one trace: a solvi.core.textin.TextIn (made from decider, or textin=) picks the entry point and reads its input fields with quotes, then the question is asked on that state. text may be a TextRead already (TextIn.read / update): each field is re-derived from its quote with the field's own parser arguments (those of textin=, else of the TextIn that read it) before it is used. question=: skip routing. The trace holds the text (init_state[read.source]), the entry-point decision and one record per field (kind "textin": quote, parser, the model that found it); the audit counts the fields as quoted by a model, not given. When the entry point escalates, nothing runs: the likely questions abstain (guard "escalated"). A required field the text does not state is not guessed: the question abstains for lack of it. res.read is the TextRead (res.read.missing, res.read.clarify(); res.read in 0.7). early_exit: as for ask.

aask_text async

aask_text(text, decider=None, *, textin=None, question=None, store=True, timeout=None, speculate=False, order=None, early_exit=None)

ask_text with aask (async parts awaited).

aask async

aask(init_state, questions=None, *, order=None, store=True, timeout=None, speculate=False, early_exit=None, check_loss=None)

ask on an event loop: async def parts (database lookups, HTTP APIs, model servers) are awaited, parts marked blocking=True run in worker threads (asyncio.to_thread), plain sync parts inline; steps whose inputs are ready run concurrently. The answers, records and hashes are those of ask on the same input: records are written in flow order after the run, whatever finished first. timeout: seconds per call of a part without its own timeout= (default: System(timeout=)); a call that does not finish in time fails with "timed out after ... s" (safeguard timeout), and the questions that need it abstain — a producer of a fact that times out is followed by the next one. A timeout cannot stop a plain sync part running inline: mark it blocking, or make it async. speculate=False: hard checks and the steps they read first, then what the open questions need (as ask: no call starts that ask would not make). speculate=True: every step starts once its inputs are ready, and a failed hard check cancels the pending calls that only the questions it settles needed (lower latency; some paid calls may start and be cancelled). Cancelling aask itself cancels every pending call. Under a learned order speculate=True is ignored, with a UserWarning (the hard checks run one at a time in that order). An async def part is awaited whatever blocking says. early_exit: as for ask (False: every step runs, whatever the hard checks say).

answers_of

answers_of(trace, names, flow=None)

The answers a recorded trace gives under this system: nothing is re-run — the facts are the trace's, the hard checks, rules, heads, constraints and the low-confidence safeguard are applied to them as ask does → {question: Result}. names: the questions to answer; flow: the response's flow (planned again when not given).

rename

rename(*, inputs=None, answers=None)

Return a new declarative system with old→external boundary names.

inputs maps external fact names to new names through Catalog.alias; answers maps question names to new names. Rules and hard-check explanations remain traceable. Storage and accumulated execution statistics start fresh. Existing heads/calibration/guards are reused. For an input_model system, declare external fields directly and use Catalog.alias for fact adaptation; inputs= renaming of model fields is refused to preserve its validators.

fingerprint

fingerprint()

What makes this system's decisions: {"catalog": the catalog's fingerprint (every part's code and declarations, see solvi.core.provenance.catalog_fingerprint), "questions": the questions' (answer types, thresholds, calibration), "parts": {part: fingerprint}, "models": {part or "answer:": model fingerprint} for model-backed parts and answer heads}. Every trace records the catalog and question fingerprints and those of the parts in its flow (trace.fingerprint); the models it used are recorded with the steps they produced.

report

report(since=None, until=None, *, store=None, **options)

What this System did over a stored period [since, until), for its owner → a solvi.core.store.sysreport.SystemReport (print it; .to_dict()): who answered and how often each abstained, what it cost, the promise in force against what the stored labels show, and drift. Read from the store alone (store, default: the System's storage); options: question=, price=, drift_window=, monitor= (see solvi.core.store.sysreport.system_report).

safeguard_summary

safeguard_summary(lang=None)

The lifetime stats as text: how many model outputs, and how many were caught by each safeguard. lang: solvi.core._i18n (default: the System's).

learn_order

learn_order(examples=None, features=None)

Learn which hard checks tend to fail on which inputs, and switch this system to the learned order. examples: [init_state] — each runs only its hard checks and what they read (no early exit), which also measures their costs. Without examples, the models learned from past asks are used as they are: asks feed them only while learning is on (System(order="learned"), producers="learned" or learn=True), so on a default System that never learned they are empty and every check counts as failing half the time. From this call on every ask feeds them (self.learn becomes True). features: computed facts to use besides init_state (cheap ones: they are computed before the hard checks).

facts_for

facts_for(init_state, *, features=None)

All computable facts (for head training): a "compute everything" flow without rules, planned by the system's strategist (so a fact ask computes around a dead-end producer is a feature candidate too).

fit

fit(question, examples, features=None, *, select=None, min_gain=0.0, lam=None, refit=2.0, refit_until=2000, head=None)

An answer head for a question without a rule, learned from examples — [(init_state, answer)]: a closed-form ridge head (solvi.core.deciders.heads.FastHead, milliseconds to seconds), which every teach for this question updates at once.

features: the facts it may read, by default every fact computable from the examples' init_state keys, the given keys included. select: keep only the facts that help — greedy forward selection by the exact leave-one-out squared error (solvi.core.deciders.heads.select_features); a fact is kept while it lowers that error by more than min_gain × the error of the answers' shares. The kept facts become the question's flow, so later requests compute only what the head reads. Default (None): select when features is not given, keep every fact listed when it is. lam, refit, refit_until: as FastHead (a refit keeps the selected facts; it does not choose again). head: a function options → an unfitted head of your own (the Head protocol, solvi.core.Head: fit(rows, answers, features), predict, contributions, teach, fingerprint) used instead of FastHead (lam, refit, refit_until then do not apply); a multi-label question gets one per option, with the options ["yes", "no"]. head.selection says what each kept fact did to the error. Before 0.8, fit was a logistic head chosen by cross-validated accuracy (+1 point), which kept nothing on imbalanced questions; fit_fast was this without the selection (now fit(..., select=False)).

learn_rule

learn_rule(question, examples, features, *, calibrated=False, calibration=None, confirm=None, **kw)

An answer rule learned from examples (solvi.core.deciders.rulelist.RuleList): a readable "if feature then answer" list, installed in the catalog as a regular rule (deterministic, replayable). examples: [(init_state, answer)], at least one; features: the facts the list reads (facts= in 0.7) — parts of the catalog or given facts of the examples (a name that is neither raises, and nothing is installed). calibrated=True explicitly returns a native Decision whose confidence/act is per-rule smoothed precision from calibration=[(state, answer)] supplied independently by the caller; a rule without such support abstains. Training never reads those labels. Use a separate independent set for guarantee().

calibrate

calibrate(question, examples, *removed, watch=None)

Calibrate answer confidence (Platt scaling) on held-out examples [(init_state, correct answer)], as fit takes them (the answer written as for fit and teach: True / False for a yes/no question, an Enum member, ...); the 0.7 form calibrate(question, states, truth) was removed in 0.9. → (a, b): confidence' = σ(a·logit(confidence) + b), applied to every later answer of the question. The held-out examples are run without the question's current calibration (so a second call fits the same thing again, not a correction of the first), are not saved to the storage and do not count in stats. Fewer than 10 answered examples, all of them right (or wrong), or confidences that do not vary (a rule's answers: 1.0): only the shift b is fitted (a = 1) — the calibrated confidence is then the share of right answers. watch= (experimental: solvi.experimental.ood.ShiftWatch): fitted on the same answers' raw confidences and options' probabilities, kept in shift_watch[question]; every later answer then carries "out of domain: ..." in why when it is unlike them (few answers of a new regime get it; test batches with shift_watch[question].shift), and the raw confidence in extra["out_of_domain"]. The Platt map is the same with or without it. watch=False removes a question's watch; without watch= a watch fitted before is kept.

guarantee

guarantee(question, examples=None, **kw)

A calibrated threshold with a stated promise on this question's answer, from labelled examples [(init_state, correct answer)] (corrections=store, sources=: plus the store's corrections of the question — the one place a "verified" System 2 answer is a label): max_risk= (P(answered alone and wrong) ≤ it, conformal risk control), max_error= (the error among the answers given alone ≤ it with probability ≥ 1 − delta, learn-then-test) or method="empirical"; on the answer's confidence, a computed fact or any signal (signal=), one-sided (answer=), per group (groups=). Below the threshold the question abstains with the reason; the promise is recorded with every answer. examples=False removes it. A failed call raises and keeps the guarantee in force before it (with a warning). Every attempt is logged in self.guard_history (installed, failed, removed). → the calibration report. See solvi.core.guarantees.guarantee.guard_question.

save_guarantee

save_guarantee(question, path)

Write the guarantee in force on a question (System.guarantee) to a JSON file — the promise, its thresholds (per group too) and report, how its signal is read, and what it was calibrated for (the catalog's fingerprint, the question's answer type, the guard's fingerprint) → path. A new process attaches it with load_guarantee instead of calibrating again, and its stored decisions replay against it (solvi.core.guarantees.guarantee.save_guarantee).

load_guarantee

load_guarantee(path, *, signal=None, groups=None, strict=True)

Attach a guarantee written by save_guarantee → its report. Refuses (ValueError) a file made for another catalog or answer type (strict=False: attaches it anyway) and one whose rebuilt guard is not the saved one; a signal or grouping that was a function is passed again (signal=, groups=). Logged in guard_history like System.guarantee (solvi.core.guarantees.guarantee.load_guarantee).

teach

teach(question, init_state, correct, *, label_source='human', by=None, of=None)

Human correction. A fast head (fit_fast) absorbs it at once; so does a model decision that answers the question (a solvi.core.deciders decision part as the question's rule, or a rule passing a decided fact on): its per-option shift is updated. Any correction goes to the storage for the next fit. Returns the update time in ms when something learned at once, else None. label_source ("human", "outcome", "rule"; source= in 0.7), by (who) and of (the stored id of the decision it corrects) are stored with it (TraceStorage.save_correction). label_source="verified" (with of= the stored System 2 decision that answered alone under a guarantee — save_correction checks it): the label is only stored, for System.guarantee(..., corrections=, sources=); no head or decision learns from it (a head fed such labels gained on one task of three), and a system without storage raises ValueError. With an update target attached (solvi.experimental.changes.LearningTarget(system, ..., gate_teach=True)) nothing learns at once: the correction is only stored, and the update's gates decide whether it is learned. With an adapter loop attached for the question (solvi.experimental.stream.AdapterLoop.attach) nothing learns at once either: on a System alone (label mode) the correction is the loop's label (a source its policy refuses raises UntrustedLabel before anything is stored), through a Dispatcher (stream mode) it is only stored — the loop's labels come with its decisions. An unknown question raises KeyError and an answer that is not one of the question's options ValueError, before anything is learned or stored; the answer is stored normalized (True → "yes"). When nothing learned at once and there is no storage, the correction is lost: a UserWarning says so.

outcome

outcome(decision, value, *, question=None, note=None, by=None)

Record what really happened after an earlier decision, as a label of it: system.outcome(res, "lost").

decision: the stored decision — its Response (saved by this system's storage) or its stored id. value: the correct answer the outcome shows (as for teach: True / False for a yes/no question, an option, an Enum member); question: which of the decision's questions (default: its only one); note: what happened, in words ("Link lost a heart two steps later"), kept with the label; by: who or what saw it (a process, an environment). The label is stored as a correction with source "outcome" (through the same source check as every label), of = the decision's stored id and its recorded input → the correction's stored id.

Nothing learns from it and no promise changes by itself: an outcome is a label for an explicit step — recalibrate a guarantee with it (System.guarantee(question, examples, corrections=True), on a schedule or after a drift flag), refit (fit on storage.corrections()), or keep it as knowledge. Recalibrating on every outcome as it arrives is not done here: measured, it broke the promises (the outcomes seen are not a random sample of the decisions, and a threshold moved after every label is no longer the calibrated one), and the experimental module that did it was removed in 1.1. A system without storage raises ValueError (the label has nowhere to go); an unknown question KeyError; an answer outside the options ValueError, before anything is stored.

MultiHead

MultiHead(options, make, train)

A multi-label answer as one yes/no head per option (each learned with fit or fit_fast).

fingerprint

fingerprint()

The options and every option's head (the Head protocol; the value 0.9 computed for it by type name).

governs

governs(part, question)

Does a failed hard check decide this question? Yes if the question is in its then, requires it, or the check has no then at all.