Turn a written policy into rules a program can check. Use when two reviewers apply the same written criteria differently, or a handbook's decided rules need repeatable application. The person must already have decided the policy; DSAIL does not draft policy, resolve conflicting policies or interpret an ambiguous regulation. Compile DSAIL ruleset source. Returns the content hash that addresses this exact ruleset, the claim manifest (every claim with its question, type and vocabulary), the claim JSON schema, and the validation contract check will enforce — so you know what will be rejected before you submit anything. It also returns `review`: a plain-text rendering of every question this ruleset asks and every decision it makes. Show it to the user verbatim before calling dsail_record_approval. An approval binds a person's sign-off to an exact hash, and it is worth something only if they could see what they were signing. This tool renders nothing. Iterate on it freely — on failure the result carries diagnostics and the grammar; fix the source and call again — and when it succeeds, call dsail_review(ruleset_hash) ONCE to present the ruleset to the user in the review widget. When a message composed by the review widget asks you to commit edited source, pass that source byte-for-byte with the parent_hash it names — it is the user's own edit — then save it under the name given (dsail_save_ruleset) and review the new hash. `label` (optional, inert): {domain: , topic: , confidence: high|medium|low} — your own reading of what domain this policy belongs to, stored as vocabulary ids only. Or {declined: true}. See the server instructions. DSAIL ruleset grammar (v1.3), the subset this service compiles to SMT: version 1.3; -- optional; 1.2 and 1.3 are accepted declare as boolean; -- a yes/no claim declare as numeric; -- a number; may carry a unit at the use site declare as enum ["a","b"]; -- ORDERED vocabulary (comparable with < >) declare as enum {"a","b"}; -- UNORDERED vocabulary (== and != only) declare local as boolean; -- rule-local; NOT a claim, never extracted assert { }; -- the rule. Holds => compliant. assert [pessimistic] { ... }; -- unknown-resolution policy: -- optimistic | pessimistic | neutral Enum members are double-quoted strings. Every statement ends with a semicolon. You do not write `let` bindings for claim values — this service injects them from the claim dictionary you submit to check. Expressions: comparison == != < <= > >= (thresholds are STRICT: > means strictly greater, NOT at-or-above. Write >= if you mean at-or-above. Equality is ==, not =.) arithmetic + - * / % LOGIC IS FUNCTION-STYLE, NOT INFIX. There is no `and`/`or`/`not` keyword: And(a, b, ...) Or(a, b, ...) Not(a) Xor(a, b) Implies(a, b) If(cond, a, b) conditional IF THEN [ELSE ] END CASE OF "x": , "y": , DEFAULT: END quantifiers ForAll(x in s, p) Exists(x in s, p) AtLeast(n, x in s, p) AtMost(n, x in s, p) ExactlyOne(x in s, p) CountWhere(x in s, p) sets IsMember(v, s) IsSubset(a, b) Union(a, b) Intersect(a, b) Difference(a, b) What a check answers. Every assertion gets its own result, and that is the whole answer: TRUE the assertion holds FALSE the assertion is violated (the solver returns a counterexample) UNKNOWN a claim it needs was submitted as unknown, or is unconstrained AMBIGUOUS its evidence was contradicted There is no combined verdict, no severity and no ranking. What a violated assertion should cost — a refusal, a human review, a note in a file — is a decision for the system reading the result, and this service does not make it. Host annotations. These are ordinary DSAIL comments, invisible to the compiler, read by this service. Every one of them describes a CLAIM — what to ask for it and what a valid answer looks like. None of them decides an outcome: // @ask What is ...? -- the question shown to an extractor // @context -- extra context for the extractor // @range 0..100 -- numeric bounds, enforced at check time // @unit USD -- expected unit for a numeric claim @effect, @effect-default and @consistency are NOT recognised. A ruleset carrying one does not compile. Worked example: version 1.3; // @ask loanAmount What is the loan principal, in USD? // @unit loanAmount USD // @range loanAmount 0..100000000 declare loanAmount as numeric; // @ask hasAppraisal Does the file contain a completed appraisal? declare hasAppraisal as boolean; declare riskTier as enum ["low","medium","high"]; assert within_cap { loanAmount <= 1000000 }; assert large_but_documented { Or(loanAmount <= 500000, hasAppraisal) }; assert tier_permitted { riskTier != "high" };