Results and errors

Every answer says two things: whether it was computed at all, and what the computation supports. Your code must keep those axes apart — a computed answer can still support neither side — and must treat every unknown variant as failure, never as success.

evaluationStatus — was it computed

TypeScript

export type EvaluationDocumentEvaluationStatus = "COMPUTED" | "MISSING_INPUT" | "MISSING_POLICY" | "REQUIRES_JUDGMENT" | "NON_EXECUTABLE" | "EXTERNAL_UNAVAILABLE" | "INTERPRETATION_REQUIRED" | "SOURCE_RESOLUTION_FAILED" | "PRIORITY_CONFLICT" | "UNRESOLVED_NORMATIVE_CONFLICT" | "CONFLICTED_INPUTS" | "TYPE_ERROR" | "RUNTIME_ERROR" | "RESOURCE_LIMIT";

Status	Meaning for your code
COMPUTED	The engine evaluated the question; read truthStatus or value
MISSING_INPUT	Named inputs are absent; read missingInputs and ask for them
MISSING_POLICY	A counting policy was needed and none was supplied
REQUIRES_JUDGMENT	Only a court can decide; the engine stops
NON_EXECUTABLE	The question is outside the executable model
EXTERNAL_UNAVAILABLE	An external source the question needs did not answer
INTERPRETATION_REQUIRED	A reading must be chosen before evaluation
SOURCE_RESOLUTION_FAILED	A source the question refers to did not resolve
PRIORITY_CONFLICT	Competing rules could not be ordered
UNRESOLVED_NORMATIVE_CONFLICT	Competing norms stand unresolved
CONFLICTED_INPUTS	The supplied facts contradict each other
TYPE_ERROR	A value did not fit its declared type at evaluation
RUNTIME_ERROR	Evaluation itself failed
RESOURCE_LIMIT	Evaluation exceeded its budget

Only COMPUTED carries a verdict. Every other status is the engine telling you why there is no verdict — handle it as “not computed”, never as a negative answer.

truthStatus — what the computation supports

TypeScript

export type EvaluationDocumentTruthStatus = "TRUE_ONLY" | "FALSE_ONLY" | "BOTH" | "NEITHER";

Status	Exact meaning
TRUE_ONLY	The computation establishes the claim
FALSE_ONLY	The computation refutes the claim
BOTH	The computation supports the claim and its negation
NEITHER	The computation supports neither side

NEITHER is not “no”. On the frist scenario, the right candidate answers TRUE_ONLY, a wrong candidate answers NEITHER, and a case with the duration fact removed answers NEITHER too — the third says “one premise is absent”, which why_not then names. FALSE_ONLY needs a derivation of the negation, not merely the absence of a derivation of the claim.

Value shapes per kind

• truth and focused_truth: the verdict is truthStatus; value carries the result payload of the engine.
• why_not: value.value.blockers holds the blocker graph — one entry per candidate rule with its conjunct states — and whyNot projects the same list; whyNotTermErrors holds term errors beside it.
• collect: value holds the bindings; on the frist scenario value[0].value is '2026-03-20'.
• calendar_op (deadline): value holds the computed date.
• term (calc): value holds the evaluated term.
• positions: the duties and their statuses — positions on the Python answer, the value on the TypeScript answer.

missingInputs, sources, proof, issues

• missingInputs lists what a MISSING_INPUT answer lacks, as input requirements your code can turn into form fields.
• sources lists the source anchors of the applied rules when the canon attaches them; the periods canon build returns an empty list, and the rule identifier in proof remains the address.
• proof is the proof graph: the facts as assertions and the rules that fired, with rulesApplied read from it.
• issues carries the engine’s messages by code; on a clean call there are only defaulted context fields.
• hashes carries program (the canon that answered), semantic (the case as evaluated), and result (the outcome):

TypeScript

export type Hashes = {
  program: string; semantic?: string; result?: string; case?: string; code?: string;
  request?: string;
  focusedResult?: string; focusedProof?: string; answer?: string;
};

LocalAnswer versus RemoteAnswer

TypeScript

export type Answer = LocalAnswer | RemoteAnswer;

A local answer is the engine’s own document: document is a Uint8Array of canonical bytes and via is 'local'. A host answer is the host’s projection: document is null, via is 'mcp', and the raw payload stays in host. Both carry evaluationStatus, hashes, and — where the kind produces them — truthStatus, value, whyNot, and missingInputs. Archive the bytes of a local answer; you cannot archive what a host answer never attached.

Python’s Answer is always the local shape with document: bytes.

Error classes

Failures of the call are exceptions; “not established” is a value on the answer. The table lists every class with the condition that raises it.

Class	Raised when
FactError	A fact or the query does not match the declarations: unknown relation, wrong arity, a value that does not fit its type. Carries path and nearest
PackageNotFoundError	The spec is versionless, or no source — installed canon, checkout tree, cache, registry — has the package. Carries the name and version
LawClientError	Common ancestor of the transport family below
TransportError	The network, the HTTP code, a cap, or an unreadable body failed; also an explain on an offline package
ProtocolError	The envelope or handshake had the wrong shape
RpcError	The server answered with an error
ValidationError	An answer did not pass its schema; carries the field path
IntegrityError	A digest did not match its manifest hash, a path led outside, or a name had the wrong shape
ServeError (TS)	The serve connection refused or failed; carries status and code

JavaScript

// Sketch of the catch ladder — the helpers stand for your UI.
const checked = validateFormInput(raw);
if (!checked.ok) return askUserFor(checked.errors); // only these reach the form
try {
  await fristen.truth('frist_ende', ['frist', '2026-03-20'], toCaseInput(checked.value));
} catch (e) {
  // The form was already valid, so a FactError here is the
  // integration's bug — an unknown relation, a wrong arity, a value
  // the adapter mis-wrapped. Never bounce it to the user as a field
  // correction: log it and fix the adapter or the query.
  if (e instanceof FactError) throw e;
  if (e instanceof PackageNotFoundError) return install(e.packageName, e.version);
  throw e;
}

The unknown-variant rule

Statuses and error codes are open vocabularies: the engine and the host may return a value your code has never seen. The rule is fixed — an unknown evaluationStatus, an unknown truthStatus, or an unknown error code fails safe. Show “not computed”, ask for the missing input, or re-raise; never map the unknown onto success, onto FALSE_ONLY, or onto a default value. A switch over statuses ends in the failure branch, not in a guess.