DSAIL

by ai.jaxon

Overview Discussions Admin

Server Details

Turn a written policy into rules a program can check, and get the same answer every time.

Ownership verified

Status: Healthy
Uptime: 96.0% over 23 days
OAuth: Works in Glama
Last Tested: 2026-10-12 16:38
Transport: Streamable HTTP · MCP 2025-11-25
URL
Repository: JaxonAI/dsail
GitHub Stars: 0

TDQS

A4.1/5.0

Scored 2026-10-02 00:00 across 20 tools

Disambiguation4/5

Most tools target clearly distinct operations: compile, check, save, load, review, approve, team management, workspace selection, and unit handling are largely separable. Some overlap exists around compile/get_prompt_pack/review/load because they all expose ruleset contracts, but the descriptions give enough detail to choose correctly.

Naming Consistency4/5

Names are consistently snake_case and almost all follow a dsail_verb_noun pattern, e.g. dsail_compile, dsail_save_ruleset, dsail_record_approval. Minor deviations like dsail_team_members and dsail_unit_library are noun phrases rather than verb-led names, but the overall convention remains predictable.

Tool Count3/5

At 20 tools, the surface is on the heavy side for an MCP server, spanning ruleset compilation, checking, approvals, teams, workspaces, account status, and units. The breadth is defensible for the platform, but 20 tools is borderline and could likely be consolidated or grouped.

Completeness3/5

Core policy ruleset lifecycle is well covered: compile, save, load, list, copy, review, approve, check, and prompt extraction. However, notable operations are missing or absent by design, including ruleset deletion, team deletion/leaving, API key revocation/listing, and unit converter removal, which leaves some lifecycle dead ends.

Available Tools

20 tools

dsail_add_unit_converterAdd a unit converterA

DestructiveIdempotent

Inspect

Give a policy check the conversion it needs between two units, with a factor a person supplied.

Use when a rule and its claim values use different units and a person has supplied the conversion factor needed to compare them.

Adds a unit converter to this project so rules mixing the two units resolve instead of answering UNKNOWN. to = from * factor + offset.

The factor is a policy decision with legal weight — an exchange rate fixed by a contract, a density fixed by a spec — and attribution records the person or document it came from, because a figure recalled from training would enter results as though a person had decided it.

This changes results. A check is reproducible from the PAIR (ruleset_hash, unit_library_hash); this edit changes the second half, so an approval recorded against the previous library no longer describes what the ruleset does. The result says so.

ParametersJSON Schema

Name	Required	Description
`factor`	Yes	The multiplier a person supplied: one `from_unit` equals `factor` `to_unit`. Never a value recalled from training — a rate is a policy decision.
`offset`	No	Added after multiplying, for affine conversions such as temperatures. Default 0.
`to_unit`	Yes	The unit converted to (`USD`).
`from_unit`	Yes	The unit converted from (`EUR`).
`attribution`	No	Who supplied the factor, or the document it comes from. Recorded beside the converter, outside the hashed library.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations, the description discloses that this tool changes results, that reproducibility depends on the (ruleset_hash, unit_library_hash) pair, and that a prior approval no longer describes the ruleset after the edit. It also explains the legal/policy weight of the factor and attribution, adding meaningful behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is longer than average, but every sentence earns its place: purpose, usage condition, mechanism, policy semantics, and behavioral consequences. It is front-loaded with the core action and use case, with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema, full parameter coverage, and annotations covering destructiveness and idempotency, the description provides everything an agent needs: when to use it, the conversion formula, the attribution requirement, and the downstream effect on approvals. Nothing essential is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although schema coverage is 100%, the description adds the crucial formula 'to = from * factor + offset' and explains the semantic significance of attribution as recording the person or document behind a policy decision. This goes well beyond the schema's individual parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: it adds a unit converter so rules using different units resolve instead of answering UNKNOWN. It also gives the conversion formula, making the tool's role unmistakable and distinguishable from read-only siblings like dsail_unit_library.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says to use this tool when a rule and its claim values use different units and a person has supplied the conversion factor. It does not name alternative tools or state when not to use it, but the context is clear enough for an agent to select it appropriately.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_checkCheck claim values against a rulesetInspect

Check extracted values against a written policy and get the same answer every time, with the rule that decided.

Use when reviewers disagree about applying decided rules to the same facts, or repeated reviews give inconsistent answers. Takes the ruleset and claim values extracted by the caller's own model.

Validates a claim dictionary and solves it against a ruleset, in one call.

Takes ruleset_hash (a compiled ruleset's content hash) or source. claims maps every declared claim name to a value; a claim that could not be determined is the string "unknown", which the rules treat as a first-class answer rather than a guess.

Returns every rule with the assertions it states, each carrying the engine's own result — TRUE (it holds), FALSE (it is violated), UNKNOWN (a claim it needs was not determined) or AMBIGUOUS (its evidence was contradicted), with the assertion's name and source text, and which claims had no value. AMBIGUOUS is reserved: it needs several answers for one claim, and a claim dictionary holds one, so no check sent here returns it. A rejected dictionary names every failing field at once as {field, expected, received}.

There is no overall verdict, by design: the four per-assertion words are the whole answer, and what a FALSE costs is a decision for whoever reads it.

This is the one metered call. It counts against the account's allowance of Jaxon Verified Units: one rule checked against up to 1,000 characters is one JVU, so a call carrying more rules or more text counts as more than one. When the allowance is used it answers ENTITLEMENT_EXCEEDED, and everything except checking keeps working.

ParametersJSON Schema

Name	Required	Description
`label`	No	Optional application-domain label: `{"topic": "<a few words on what the policy governs>"}`, or `{"declined": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal.
`claims`	Yes	The claim dictionary to evaluate: one entry per declared claim, keyed by claim name, values as the prompt pack specifies (`"120 USD"`, `true`, `"unknown"` for a value the extractor could not determine). A JSON object, or the same object as a JSON string.
`source`	No	DSAIL source text, byte for byte as compiled. Give this OR `ruleset_hash`; prefer the hash for anything already compiled.
`ruleset_hash`	No	The content hash of an already compiled ruleset (from `dsail_compile` or a saved name). Give this OR `source`, not both.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

dsail_compileCompile a policy into a rulesetA

Idempotent

Inspect

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 has already decided the policy; DSAIL formalises decisions, it does not draft policy, resolve conflicting policies or interpret an ambiguous regulation.

Compiles 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 a check will enforce — so what will be rejected is known before anything is submitted.

Also returns review: a plain-text rendering of every question this ruleset asks and every decision it makes. It is what a person signs when they approve the hash, so it is worth showing them before an approval is recorded.

Renders nothing on its own, so iterating on it costs nothing. On failure the result carries diagnostics naming the offending line, plus the grammar below as hint. On success the hash is what the review widget, a check and an approval all address.

parent_hash (optional) links this revision to the one it edits, so the review can show a diff; source relayed from the widget's own edit control arrives with the parent it names. label (optional, inert): {domain: , topic: , confidence: high|medium|low}, the caller's reading of what domain the policy belongs to, stored as vocabulary ids only; or {declined: true}.

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; units go on literals (below) 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.

Literals: numbers 42 3.5 0.05 with a unit 3000 "mi" 25000 "USD" 0 "USD" -- a number followed by the unit as a QUOTED string. A bare -- unit word is a syntax error: 3000 mi fails to parse. booleans True False -- capitalised. Lowercase true and false are read as -- identifiers and fail as undefined variables. enum members "low" "high" -- double-quoted strings

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 UNKNOWN a claim it needs was submitted as unknown, or is unconstrained AMBIGUOUS reserved. It means an assertion's evidence contradicted itself, which needs several answers for one claim. A claim dictionary holds exactly one value per claim, so no check submitted to this service produces it. Handle the word if you switch on results; there is no input that triggers it.

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.

Rule descriptions. Directly above every assert, with no blank line between, write what the rule requires in plain words as an ordinary comment block (no @ tag). The review widget shows it as the rule's description and a person edits it there, so it must say what the assert beneath it actually checks. dsail_compile over MCP refuses an assert that has none, naming its line.

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"];

// No loan may exceed one million dollars. assert within_cap { loanAmount <= 1000000 "USD" }; // A loan over 500,000 USD needs an appraisal on file. assert large_but_documented { Or(loanAmount <= 500000 "USD", hasAppraisal) }; // A loan over 250,000 USD needs an appraisal on file. assert appraisal_when_large { IF loanAmount > 250000 "USD" THEN hasAppraisal ELSE True END }; // High-risk applicants are not permitted. assert tier_permitted { riskTier != "high" };

ParametersJSON Schema

Name	Required	Description
`label`	No	Optional application-domain label: `{"topic": "<a few words on what the policy governs>"}`, or `{"declined": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal.
`source`	Yes	The DSAIL source text to compile: `declare` lines for each claim with their `// @ask`, `// @unit` and `// @range` annotations, then `assert` rules. Written only after the user has confirmed the English summary.
`parent_hash`	No	The hash of the revision this one supersedes, when editing a saved ruleset. Links the two so the review can show a diff; omit for a new ruleset.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations only supply the safety profile (non-destructive, idempotent, non-read-only). The description adds substantive behavior the annotations cannot: it renders nothing on its own so iteration is free, failures return line-naming diagnostics plus the grammar as `hint`, success returns a hash that the review widget, a check and an approval all address, and it refuses any assert lacking a plain-word description. That is strong, non-redundant behavioral disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose and usage are front-loaded correctly, and most of the grammar reference genuinely earns its place because the agent must author valid DSAIL source that the compiler will accept. However, the section on check results (TRUE/FALSE/UNKNOWN/AMBIGUOUS) belongs to dsail_check, and the AMBIGUOUS paragraph explicitly concedes 'there is no input that triggers it' — dead weight that inflates an already very long definition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so return values need no explanation, yet the description still explains the hash/manifest/review contract and the failure mode. Combined with the full grammar, literal/expression rules, host-annotation list, worked example and the rule-description requirement, an agent has everything needed to produce source this service will compile.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it explains that `parent_hash` links a revision so the review can show a diff and that source relayed from the edit widget arrives pre-populated with its parent, and it describes `label` as inert and stored only as vocabulary ids (including the `confidence` field the schema does not mention). Minor mismatch in how `label` is described versus the open object in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence gives a concrete verb and resource ('Turn a written policy into rules a program can check') and immediately delimits the tool against its siblings by stating it formalises decisions rather than drafting, resolving or interpreting policy. Its scope — compile DSAIL source into a hash-addressed ruleset plus review text — is unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It names the trigger conditions ('two reviewers apply the same written criteria differently', 'a handbook's decided rules need repeatable application') and explicit exclusions ('does not draft policy, resolve conflicting policies or interpret an ambiguous regulation'). It also places the tool in the surrounding workflow (dsail_check, dsail_review, approval) so the agent knows where it sits.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_copy_rulesetCopy a ruleset into another workspaceAInspect

Put a copy of one of your saved policy rulesets into a team.

Use when a ruleset the user already has should also be available to a team — the usual way a new team gets its first library.

Copies a saved ruleset from one of this user's workspaces into another. It is a copy: the original stays exactly where it was. destination and the optional source name a team or personal; source defaults to the workspace in use. The revisions it cites travel with it so a diff still works, but recorded approvals stay behind — an approval is one workspace's sign-off, so the copy arrives unapproved and must be approved there if the team needs that. A name already in use in the destination is refused rather than overwritten; new_name copies it under another.

ParametersJSON Schema

Name	Required	Description
`name`	Yes	The saved ruleset to copy, by name.
`source`	No	The workspace to copy from; defaults to the workspace in use.
`new_name`	No	A different name for the copy, when the destination already uses `name`.
`destination`	Yes	The workspace to copy into: a team's name or id, or `personal`.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds substantial behavioral detail beyond the annotations: it clarifies that the operation is a copy, not a move, that the original stays, that revisions travel while approvals do not, that the copy arrives unapproved, and that name collisions are refused unless new_name is supplied. This fully compensates for the sparse annotation set.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well structured and efficient, with the primary action front-loaded. Each sentence adds value: usage context, copy semantics, revision/approval behavior, and collision handling. No filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with four parameters, the description covers all key operational concerns: copy semantics, workspace targeting, source defaulting, approval behavior, and name conflict handling. With an output schema also present, an agent has sufficient information to invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema coverage is 100%, and the description adds extra meaning to the parameters: it explains that source defaults to the workspace in use, destination can be a team or 'personal', and new_name resolves name conflicts. This goes beyond the schema's field-level descriptions without redundancy.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource: "Put a copy of one of your saved policy rulesets into a team." It clearly differentiates from siblings like save_ruleset, load_ruleset, and list_rulesets by focusing on copying an existing saved ruleset into another workspace.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use it: "Use when a ruleset the user already has should also be available to a team — the usual way a new team gets its first library." It provides strong contextual guidance, though it does not explicitly call out when not to use it or name alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_create_teamCreate a teamInspect

Start a team so colleagues share one set of policy rules.

Use when the user says a colleague cannot see their rulesets, or wants work shared with named people rather than kept to themselves.

Creates a team with a ruleset library of its own and makes this user its administrator. The team starts EMPTY: their existing rulesets stay in their own workspace and are not moved or copied; copying a ruleset is how work gets into it. A team has no allowance of its own: each member's checks in it count against that member's own account. name is a label shown to members, not an identifier, and does not have to be unique.

ParametersJSON Schema

Name	Required	Description	Default
`name`	Yes	A label for the team, shown to its members. Not an identifier; need not be unique.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

dsail_get_account_statusAccount status and allowance

Read-onlyIdempotent

Inspect

Know how much of this credential's allowance is used before a limit interrupts a check.

Use when an upcoming check could be interrupted by the account's allowance limit and the caller needs to see usage first.

This account's entitlement and usage position. usage is the meter that refuses the next check — used, limit and remaining — and stub: false means it is enforced. Only checks are metered; compiling, editing, saving, loading and approving rulesets are free and stay free at any limit. When the tier is gated the payload carries plans_url, the address of a page describing the available plans. Also reports the current application-domain vocabulary version, whether this account may label rulesets, how many API keys it may still issue, and terms — the terms-of-service version that governs this tier with the URLs of the terms, privacy and data-handling pages. account.project is an internal identifier that names nothing a user would recognise. account.organizations lists the owner of the workspace currently in use (a team id while working in a team), not the teams the user belongs to; the workspace listing is where those are.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

dsail_get_prompt_packGet the extraction prompt packA

Idempotent

Inspect

Get the exact questions to ask a document so the answers can be checked against a written policy.

Use when reviewers pull different facts from the same kind of document, or the caller needs a consistent set of questions before applying decided rules.

Returns the extraction contract for a compiled ruleset: one prompt per claim (question, answer format, vocabulary, unit), the claim JSON schema, and the exact validation rules a check enforces. The prompts are for the caller's own model to run; this service calls no model. The assembled claim dictionary is what a check takes.

ParametersJSON Schema

Name	Required	Description	Default
`source`	No	DSAIL source text, byte for byte as compiled. Give this OR `ruleset_hash`; prefer the hash for anything already compiled.
`ruleset_hash`	No	The content hash of an already compiled ruleset (from `dsail_compile` or a saved name). Give this OR `source`, not both.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With annotations already declaring idempotency and non-destructiveness, the description adds valuable behavioral context beyond the structured data: 'The prompts are for the caller's own model to run; this service calls no model.' This clarifies side-effect-free behavior and the division of labor between caller and service.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Every sentence earns its place: purpose, usage, return value, behavioral note, and relation to check. The description is front-loaded with the core action and remains structured without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the rich schema descriptions, annotations, and an output schema, the description provides sufficient context for an agent to decide when to use the tool and what to expect. It covers the what, why, and how the result is used, with no critical missing information.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the schema already explains the 'source' and 'ruleset_hash' parameters, including the OR relationship and preference for hash. The tool description itself does not add further parameter-level meaning, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description immediately states a specific verb and resource: 'Get the exact questions to ask a document so the answers can be checked against a written policy.' It goes on to describe the return payload (prompt per claim, JSON schema, validation rules), which clearly distinguishes this from siblings like dsail_check or dsail_compile.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit use cases: 'Use when reviewers pull different facts from the same kind of document, or the caller needs a consistent set of questions before applying decided rules.' It also positions the tool relative to dsail_check by noting 'the assembled claim dictionary is what a check takes.' It does not explicitly name alternative tools or say when not to use it, so it falls just short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_invite_to_teamInvite a colleague to a teamAInspect

Invite a colleague into a team by email address.

Use when an administrator wants a specific colleague to reach the team's rulesets.

Issues a single-use invitation to one email address. This service sends no mail, so what comes back is a link the administrator passes on themselves. Only the invited address can accept it, by signing in as that address, and only once, so a forwarded link is useless to anyone else. Restricted to the team's administrators.

ParametersJSON Schema

Name	Required	Description	Default
`email`	Yes	The colleague's email address. Only that address can accept the invitation, and only once.
`team_id`	Yes	The team's id (`team-…`), as returned by `dsail_create_team` or `dsail_list_workspaces`.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations provide only basic safety hints (not read-only, not idempotent, not destructive), so the description carries the burden of disclosing key behaviors. It does this thoroughly: no email is sent, a single-use link is returned, only the invited address can accept it, and only once, rendering forwarded links useless. It also highlights the admin-only restriction. This goes well beyond what annotations imply, fully justifying the description's additional context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is composed of four sentences, each adding a distinct piece of information: the core action, the trigger scenario, the no-mail and single-use behavior, and the admin restriction. It is front-loaded with the main verb and remains efficient, though it could be tightened. Minor redundancy with the schema's email description prevents a 5.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with two required parameters, full schema coverage, and an output schema, the description covers all critical aspects: when to invoke it, the security constraints, the mechanics of delivery, and the limitations. It does not explain return values, but the output schema presumably does. There are no gaps that would leave an agent unsure how to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and each parameter already has a descriptive explanation (e.g., email's single-use acceptance, team_id's origin). The description reinforces these points but does not add meaningful new semantics beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting; the description's extra details are about tool behavior, not parameter meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action: inviting a colleague into a team via email. It specifies the method (by email address), the target (specific colleague), and the goal (reach the team's rulesets). This distinguishes it from sibling team management tools like remove_from_team or set_team_role, and the single-use, admin-only detail further clarifies its unique role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use it: 'Use when an administrator wants a specific colleague to reach the team's rulesets.' It also notes the restriction to administrators, giving clear context. However, it does not name alternatives or explicitly state when not to use it, so it falls just short of a 5, which would require naming a sibling and the condition that selects it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_issue_api_keyIssue an API keyAInspect

Issues a REST API key for this account.

The key authenticates calls to the DSAIL REST API, sent as the x-jaxon-credential header, and reaches the rulesets this account holds. Optional label records what the key is for. The token is returned once and cannot be recovered; the service keeps only a hash. An account has a limited number of keys.

ParametersJSON Schema

Name	Required	Description	Default
`label`	No	Optional label naming what the key is for (a service, a repository), shown in listings.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations confirm a non-read-only, non-idempotent, non-destructive creation, and the description adds substantive behavioral facts beyond them: the token is returned once and cannot be recovered, only a hash is retained, and the account has a limited number of keys. These are exactly the operational constraints an agent needs before calling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The core action is front-loaded, then supporting facts (header name, scope, one-time token, quota) follow in short sentences. Each sentence earns its place, though the header/scope detail is slightly more than the caller strictly needs to invoke it.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so return shape need not be described; the description instead covers the things the schema and annotations cannot — one-time token retrieval, hash-only storage, quota limits, and how the key is presented to the API. Nothing needed to call this correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single optional `label`, and the schema already documents it as a listing-visible name. The description's 'Optional `label` records what the key is for' largely restates that, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Issues a REST API key for this account') and immediately scopes it: the key authenticates the DSAIL REST API via the `x-jaxon-credential` header and reaches the account's rulesets. No sibling touches key issuance, so it is unambiguously distinguishable from the ruleset/team/workspace tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The context for use is clear — issuing a credential for programmatic access to the REST API — and the `label` is explained as recording what the key is for. There are no alternative key-management siblings to route against and no explicit when-not guidance, so it stops short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_list_rulesetsList saved rulesetsA

Read-onlyIdempotent

Inspect

See which written policies already have rules a program can check.

Use when a team may already have formalised the handbook or written criteria, and the caller needs to find existing rules before starting again.

The rulesets saved in the workspace in use. On a client that renders MCP Apps this opens the ruleset library: one row per ruleset with its name, what it decides, how many questions it asks, how many rules it applies, whether anyone has approved it and when it last changed. A row opens that ruleset in the review widget, so the rows are already in front of the user. The namespace field is a service-internal identifier, not a name a person would recognise.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already establish the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description's burden is low. It still adds value by disclosing the MCP Apps rendering behavior (opening the ruleset library with per-row details) and clarifying that the namespace field is an internal identifier, not a recognizable name. No contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose is front-loaded in the first sentence, followed by usage context and then rendering detail. Each sentence earns its place with no filler, though the rendering paragraph runs slightly longer than strictly necessary for a list tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, read-only list tool with a rich annotations block and an output schema present, the description is complete. It covers why to use it, what happens when it renders, and the meaning of a potentially confusing output field.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With zero parameters there is nothing to document; per the rubric the baseline is 4 for a no-parameter tool. The only parameter-adjacent mention is the namespace field clarification, which concerns output, not input.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific purpose: seeing which written policies already have rules a program can check. The framing 'already have rules' and 'before starting again' implicitly contrasts with the creation tools in the sibling set (dsail_save_ruleset, dsail_copy_ruleset), though no sibling is named explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives a concrete trigger condition: when the team may already have formalized the handbook/written criteria and the caller needs to find existing rules before recreating them. This is clear context, but it doesn't state when NOT to use the tool or explicitly name the alternative creation/load tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_list_workspacesList workspacesA

Read-onlyIdempotent

Inspect

See which teams you work in and which one you are working in now.

Use when a ruleset the user expects is missing from a listing, before saving something that belongs to a particular team, and whenever the user mentions a colleague, a team or sharing.

Every workspace this user may work in — their own, plus one per team — and which one is currently in use. The current workspace decides what a listing shows and where a save writes. It does NOT decide who pays: every check is billed to the user's own account, in any workspace.

signed_in says whether a person is behind this connection. When it is false the caller holds an API key, which names a workspace and not a person, so creating a team, inviting, removing and switching workspace are all refused; remedy is the command that signs the person in, and their key keeps working for everything else.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Adds substantial context beyond annotations: billing is always to the user's own account regardless of workspace, and the `signed_in` flag reveals whether a person or API key is behind the connection, with consequences for restricted actions and a remedy. This enriches the readOnly/idempotent hints with actionable details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is multi-paragraph but well organized: purpose first, then triggers, then workspace/billing semantics, then signed_in behavior. Each section earns its place; however, it could be tightened without losing meaning. Still well-structured and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with an output schema and safety annotations, the description covers all essential behavior: what it lists, how current workspace affects results, billing independence, and authentication implications. Nothing critical is missing for an agent to use it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so the schema is trivially 100% covered. The description adds no parameter-specific details, but that is unnecessary. Baseline of 4 is appropriate since the description doesn't need to compensate for any gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('see') and resource ('workspaces'/'teams'), and clarifies the current workspace distinction. The description is precise and tells the agent exactly what information is returned (own workspace plus one per team). It stands apart from siblings by describing its scope without naming them, but the clarity is high.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly lists when to use: when a ruleset is missing from a listing, before saving to a team, or when the user mentions a colleague/team/sharing. This gives concrete triggers and leaves no ambiguity about the tool's role in the workflow.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_load_rulesetLoad a saved rulesetA

Read-onlyIdempotent

Inspect

Read a saved policy ruleset exactly as it was stored.

Use when someone asks which saved rules were used, or needs to inspect an existing revision rather than author a new one.

Loads a named ruleset: its source, its hash, its claim manifest and claim schema, its diagnostics, its revision chain and any approvals bound to it — the same contract a compile returns, for bytes already stored.

An approval follows the stored bytes, so source re-compiled from memory is a different object the moment the two texts drift; the source this returns, with the hash it came with as parent_hash, is the starting point for an edit. Loading shows nothing on screen.

ParametersJSON Schema

Name	Required	Description	Default
`name`	Yes	The saved ruleset's name, exactly as `dsail_list_rulesets` reports it.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, non-destructive, closed-world, so the safety profile is covered. The description still adds real context beyond them: the returned payload mirrors a compile's contract, approvals are bound to stored bytes (so drifted re-compiled source is a different object), and 'Loading shows nothing on screen' foreshadows the absence of a UI side effect. No error/not-found behavior is described, hence 4 rather than 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose is front-loaded in the first sentence and every following sentence carries information (usage conditions, payload contents, byte-binding caveat, no-visual-effect note). The middle sentence is dense and clause-heavy, which costs a point on structure but not on waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With annotations covering safety and an output schema covering the return shape, the description need only say what is fetched and when; it does both. It stops short of describing failure modes (unknown name) or revision-selection behavior, a minor gap for an otherwise complete definition.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the single parameter 'name' is already documented as 'exactly as dsail_list_rulesets reports it.' The description adds no further naming/format guidance, so the schema carries the parameter semantics and baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Read a saved policy ruleset exactly as it was stored') and immediately enumerates what is loaded (source, hash, claim manifest, claim schema, diagnostics, revision chain, approvals). It draws a clear line against authoring/compiling, so an agent can distinguish this from dsail_compile or dsail_save_ruleset without opening a schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit when-to-use conditions: 'when someone asks which saved rules were used, or needs to inspect an existing revision rather than author a new one.' The alternative (authoring/compiling a new revision) is named and the condition that selects this over that is stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_record_approvalRecord a person's approval of a rulesetAInspect

Bind a person's sign-off to the exact rules a program will check.

Use when a reviewer has seen the formal rules and is ready to sign off, or revised rules need a fresh human approval.

Binds a human approval to one exact ruleset hash. An approval follows the bytes, not the name: a later revision is not covered by it.

name saves the ruleset under that name as part of approving it. The name is bound BEFORE the approval is recorded, so what a person approves is in their library afterwards instead of being reachable only by a hash they would have to have kept; it is optional only for a hash already saved under a name. approver and note are recorded with the approval. The review widget's approve control composes the exact arguments for this call, because a chat client cannot call tools from inside a widget.

ParametersJSON Schema

Name	Required	Description
`name`	No	The name to save the ruleset under before approving, when it is not saved yet. Approving saves first, so an approved hash is always reachable afterwards.
`note`	No	Optional free-text note recorded beside the approval.
`label`	No	Optional application-domain label: `{"topic": "<a few words on what the policy governs>"}`, or `{"declined": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal.
`approver`	Yes	Who approved, as they wish to be recorded (a name or an email address).
`ruleset_hash`	Yes	The exact content hash the person approved. Approval binds to this hash only; a later revision needs its own.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnly=false and destructiveHint=false, but the description adds significant behavioral context beyond that. It explains that the tool performs a write operation (recording approval) and also has a side effect of saving the ruleset under a name if provided. It clarifies the naming side effect happens BEFORE approval is recorded, and that label is 'discarded; never stored'. This goes beyond basic annotation info and addresses likely side effects and data handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized for a tool with this complexity; it's thorough without being overly verbose. The key point about binding to the hash is front-loaded. Some sentences are long and dense, but they pack useful information. It could be slightly streamlined, but it's well-structured and every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers all essential aspects: when to use, side effects, binding semantics, and parameter handling. The output schema exists, so return values are not needed. It even mentions how the review widget composes arguments, providing practical context. Given the tool's complexity (side effects, naming, label), the description is complete and leaves no obvious gaps for an agent to correctly invoke it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so each parameter is documented in the schema. The description adds extra context for the 'name' parameter, explaining that it saves the ruleset and is bound before approval. However, for 'label', the description clarifies its transient nature and matching against a published vocabulary, which is not fully captured in the schema. Overall, it adds meaning beyond the schema, but some parameters like 'note' and 'approver' are straightforward and don't need much extra.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: binding a person's sign-off to a specific ruleset hash. It uses specific verbs ('Bind', 'saves', 'recorded') and describes the exact resource (ruleset hash). It distinguishes from siblings like dsail_review and dsail_save_ruleset by emphasizing the one-to-one binding to a hash and the 'approves the bytes, not the name' semantics.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit when-to-use guidance: 'Use when a reviewer has seen the formal rules and is ready to sign off, or revised rules need a fresh human approval.' It also explains the critical caveat that a later revision is not covered by an earlier approval, preventing misuse. It does not explicitly name alternative tools, but the context is clear enough for an agent to select this tool over similar ones.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_remove_from_teamRemove a team memberA

DestructiveIdempotent

Inspect

Take somebody out of a team and cut off the keys they issued for it.

Use when somebody has left the team or should no longer reach its rulesets.

Removes a member. Their access ends on their next call, including through any API key they issued for this team, which is revoked. What they saved stays with the team — removing a person does not remove their work. A team is not left without an administrator: removing the last one is refused until somebody else has been promoted. member is their email address as the team's member list reports it, or the subject listed beside it. Restricted to the team's administrators.

ParametersJSON Schema

Name	Required	Description	Default
`member`	Yes	The member: the `email` `dsail_team_members` reports for them (case does not matter), or the `subject` it reports beside it.
`team_id`	Yes	The team's id (`team-…`), as returned by `dsail_create_team` or `dsail_list_workspaces`.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description richly supplements the annotations: access ends on the next call, API keys are revoked, saved work remains with the team, and removing the last administrator is refused. This goes well beyond the destructiveHint and idempotentHint flags.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact, front-loaded with the core effect, and each sentence adds useful context. 'Removes a member' is a slightly redundant restatement after the opening line, but the overall structure is clean.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's destructive nature, the description covers side effects, data persistence, the last-admin edge case, administrative permission restriction, and member identification. Combined with the output schema and annotations, nothing critical is missing for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and the schema already explains that member can be an email or subject and team_id is a team-… id. The description mostly restates these facts rather than adding new parameter-level meaning, so the schema carries the weight.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a concrete verb and resource: 'Take somebody out of a team and cut off the keys they issued for it.' This clearly distinguishes removal from sibling operations like invite, set_team_role, or team_members by including the key-revocation consequence.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives an explicit trigger: 'Use when somebody has left the team or should no longer reach its rulesets.' However, it does not name alternatives or state when not to use it, so it stops short of the strongest routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_reviewReview a ruleset (widget)A

Read-onlyIdempotent

Inspect

Show a person the rules a program will check, so they can approve exactly those bytes.

Use when the policy owner needs to inspect how decided criteria were formalised before signing off, or a later revision needs its own review.

Presents a compiled ruleset to the user in the inline review widget: each rule with what it says, the claims it reads and a Yes / No / Unknown answer for each, a check that shows every rule's own result, the source (editable), the approve control, and the project's unit-conversion library when the ruleset uses units.

Takes the ruleset_hash of a ruleset that compiled clean, or the name a stored ruleset is saved under; a hash that failed to compile has nothing to show. One rendering per revision is what the user sees, and a later revision gets its own.

Returns the same payload a compile returns for that hash, plus the name it is saved under (null when nothing names it yet) and every approval bound to it.

ParametersJSON Schema

Name	Required	Description	Default
`name`	No	The name a stored ruleset is saved under, instead of a hash: its current revision is shown.
`ruleset_hash`	No	The content hash of the compiled ruleset to show, from `dsail_compile`.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds real context beyond that: it is a UI-facing render (shows claims, per-rule Yes/No/Unknown, editable source, approve control, unit library) and it discloses the return payload plus saved name and bound approvals. Only the finer rendering/refresh behavior is left implicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded and each paragraph carries information about usage, rendering, inputs, and returns. It is on the long side for two optional parameters, and the point that a later revision gets its own review is stated twice, which costs a little.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present the description need not restate returns, yet it usefully summarizes them, and annotations already carry the safety profile. When-to-use, the compile-clean precondition, both input routes, and the rendering behavior are all covered, leaving nothing an agent needs to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline would be 3, but the description adds meaning: a failed-compile hash has nothing to show, and passing a name shows that stored ruleset's current revision. It also clarifies the hash comes from dsail_compile, which is not stated in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence states a specific verb and resource — show a person the rules a program will check so they can approve exactly those bytes — and the body clarifies it renders a compiled ruleset in an inline review widget. That distinguishes it from dsail_compile (which produces the hash) and dsail_check (which presumably evaluates). An agent can route correctly without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives a clear when-to-use: the policy owner inspecting how decided criteria were formalised before signing off, or a revision needing its own review, plus a negative constraint (a hash that failed to compile has nothing to show). It does not explicitly name alternative tools such as dsail_record_approval for recording the decision, so it stops short of full alternative routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_save_rulesetSave a ruleset under a nameAInspect

Keep a written policy's rules as a named, immutable revision, so a later check answers exactly as this one did.

Use when a handbook changes but earlier reviews must remain tied to the rules used then, or a team needs a name for a decided policy's formal rules.

Stores a named, immutable revision of a ruleset. Saving over an existing name links the previous hash as this revision's parent — nothing is ever edited in place. Scoped to the workspace in use: a ruleset saved here is reachable from any later conversation through the same connection, and from no other.

created is true when these exact bytes were stored for the first time, and false when an identical source had already been stored, by a compile or an earlier save. It says nothing about the name: the first save under a new name returns false if the same source was compiled before.

label (optional, inert): {domain: , topic: , confidence: high|medium|low}, or {declined: true}. Stored as vocabulary ids only.

ParametersJSON Schema

Name	Required	Description
`name`	Yes	The name to save under, in the current workspace. Saving over an existing name creates a new revision with the previous one as its parent; nothing is edited in place.
`label`	No	Optional application-domain label: `{"topic": "<a few words on what the policy governs>"}`, or `{"declined": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal.
`source`	Yes	The DSAIL source text to save, byte for byte as it compiled.
`parent_hash`	No	The hash of the revision this one supersedes, when editing a saved ruleset. Links the two so the review can show a diff; omit for a new ruleset.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses key behavioral traits beyond annotations: it explains that the operation creates an immutable revision, links parent hashes, never edits in place, is scoped to the workspace, and explains the exact semantics of the `created` flag. This is far more than the annotations (which only indicate readOnly=false, destructive=false) and gives the agent a precise model of the tool's side effects and return value.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is organized into clear paragraphs, starting with purpose and usage, then behavioral details, then `created` semantics, then label details. It is longer than a one-liner but every paragraph serves a distinct function and contains necessary information. The structure is logical and front-loaded with the most important information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (immutability, revision chaining, workspace scoping, label semantics) and the presence of a detailed output schema (visible via the `created` flag explanation), the description is complete. It covers the core behavior, the meaning of the `created` return value, scoping rules, and edge cases like saving over an existing name, which an agent needs to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with each parameter already well-explained (e.g., `name` details revision chaining, `label` explains matching and discarding). The description adds context about the `created` flag but does not add meaning for the parameters beyond what the schema already provides. Since the schema does the heavy lifting, a baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action (saving a ruleset as a named, immutable revision) and clarifies that it does not edit in place, distinguishing it from other operations like copying or loading. The purpose is further explained with the 'keep a written policy's rules as a named revision' phrase, making it clear what the tool is for and how it relates to sibling tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly provides a 'Use when' clause, giving clear conditions for when to invoke the tool: when a handbook changes but earlier reviews must remain tied to the rules used then, or when a team needs a name for a decided policy's formal rules. It does not mention alternatives or exclusions, so it stops short of a full 5, but the guidance is clear and practical.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_set_team_roleSet a member's team roleA

DestructiveIdempotent

Inspect

Let another member administer a team, or stop them administering it.

Use when the user wants somebody else able to invite and remove, or no longer able to.

Makes a member an administrator, or returns an administrator to an ordinary member. role is admin or member. It does not change what they can read or write — every member already sees the whole library — only whether they can change who is in the team. member is their email address as the team's member list reports it, or the subject listed beside it. Demoting the last administrator is refused. Restricted to the team's administrators.

ParametersJSON Schema

Name	Required	Description
`role`	Yes	`admin` (may invite, remove and promote) or `member` (reads and writes the library).
`member`	Yes	The member: the `email` `dsail_team_members` reports for them (case does not matter), or the `subject` it reports beside it.
`team_id`	Yes	The team's id (`team-…`), as returned by `dsail_create_team` or `dsail_list_workspaces`.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations indicate a destructive, non-read-only, idempotent operation. The description adds critical behavioral detail beyond that: it clarifies exactly what changes (role only), what does not change (read/write access), the refusal to demote the last admin, and the admin-only restriction. This is substantial context that the annotations do not convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a tight paragraph with no filler. The core purpose is front-loaded, and every subsequent sentence adds a necessary constraint or clarification. It is long enough to be complete but short enough to be scanned quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with an output schema and comprehensive annotations, the description covers all essential aspects: the exact operation, when to use it, the parameter semantics, edge-case behavior (last-admin refusal), and access restriction. There is no missing information an agent would need to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already provides thorough descriptions for all three parameters (100% coverage). The description reinforces the meaning of 'role' (admin vs member), clarifies that 'member' is the email or subject from dsail_team_members, and notes the team_id source. It adds examples and context, elevating it above the schema baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a precise statement of the tool's effect — 'Let another member administer a team, or stop them administering it' — and then clarifies it changes only role, not read/write access. This clearly distinguishes it from invite/remove tools like dsail_invite_to_team and dsail_remove_from_team. The verb and resource are specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly says 'Use when the user wants somebody else able to invite and remove, or no longer able to,' giving a direct usage trigger. It also states important constraints: it does not change read/write access, demoting the last admin is refused, and only team admins can call it. These exclusions and conditions are stated unambiguously.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_team_membersList a team's membersA

Read-onlyIdempotent

Inspect

See who is in a team and who administers it.

Use before removing somebody, changing who administers a team, or when the user asks who can see the team's rulesets.

Who is in this team and what each one may do. Every member reads and writes the whole of the team's library; an administrator can additionally invite, remove and promote. Only a member of the team may ask.

ParametersJSON Schema

Name	Required	Description	Default
`team_id`	Yes	The team's id (`team-…`), as returned by `dsail_create_team` or `dsail_list_workspaces`.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already mark this as read-only and idempotent, so the description's extra value lies in explaining the team permission model: every member can read/write the whole library, administrators can invite/remove/promote, and only team members may call this tool. That is useful behavioral context beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with a clear purpose, followed by usage guidance and role behavior. It is slightly repetitive between 'See who is in a team and who administers it' and 'Who is in this team and what each one may do', but each paragraph earns its place overall.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given a single well-documented parameter, an output schema to cover return values, and annotations declaring the operation safe and idempotent, the description fully supplements the structured data with usage context, permission semantics, and authorization requirements. Nothing critical is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter team_id is fully documented in the schema with format and provenance ('team-…' as returned by dsail_create_team or dsail_list_workspaces). The description itself does not add further detail about the parameter, but with 100% schema coverage the baseline expectation is met.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'See who is in a team and who administers it.' This clearly identifies the tool as a read-only listing operation and distinguishes it from sibling tools like invite_to_team, remove_from_team, and set_team_role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says when to use it: before removing somebody, before changing an administrator, or when the user asks who can see a team's rulesets. This gives an agent concrete trigger conditions and makes the tool's role in a workflow obvious.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_unit_libraryUnit library and conversionsA

Read-onlyIdempotent

Inspect

Find out whether two units convert before a rule compares them, so the check does not answer UNKNOWN forever.

Use when a document supplies a quantity in one unit while the written rule uses another, or a unit mismatch is leaving a comparison unresolved.

What this project can convert between. DSAIL numerics are dimensional: a rule comparing a value in one unit against a literal in another resolves only if a converter bridges them, and if none does, that rule answers UNKNOWN for every claim dictionary, forever — which makes this worth knowing before rules that mix units are written. With from_unit and to_unit it answers for one pair with one of: same, convertible (with the factor), ambiguous (an interval-valued conversion such as months to days, which makes the comparison honestly UNKNOWN), unknown_unit (in no loaded library, so probably a typo), or no_path (both known, nothing bridges them). Currencies ship as alias groups with NO exchange rates: a rate is not a constant.

ParametersJSON Schema

Name	Required	Description	Default
`to_unit`	No	The unit to convert into; paired with `from_unit`.
`from_unit`	No	A unit symbol (`EUR`, `km`, `mo`). Give both `from_unit` and `to_unit` to ask whether that pair converts; give neither to list the whole library.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description goes beyond these by detailing the possible return outcomes (same, convertible, ambiguous, unknown_unit, no_path), explaining that ambiguous conversions (e.g., months to days) lead to an honest UNKNOWN, and warning that currencies ship with no exchange rates. This is exactly the kind of behavioral context an agent needs to interpret results correctly.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is longer than average but well-structured: purpose first, then usage, then behavioral details, then a caveat about currencies. It is front-loaded with the most critical information. Each section earns its place; no filler or redundancy. It could be slightly tightened, but it remains readable and informative.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with two optional parameters and no required inputs, the description is remarkably complete. It covers when to use it, what results to expect (enumerated outcomes), the meaning of ambiguous conversions, the currency limitation, and the critical consequence of missing converters (permanent UNKNOWN). The output schema exists but the description already covers the return value semantics, so nothing essential is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema fully documents both parameters (to_unit, from_unit) with clear descriptions, including that giving neither lists the whole library. Schema coverage is 100%, so the baseline is 3. The description reiterates this pattern and adds context about outcomes, but it does not add new parameter-level semantics beyond what the schema already provides. It is adequate but not enhancing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific, actionable purpose: 'Find out whether two units convert before a rule compares them.' It clearly distinguishes this from the sibling tool dsail_add_unit_converter (which presumably adds converters) by focusing on checking convertibility, and it explains the consequence of not using it. The verb-resource pairing is explicit and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit use cases: 'when a document supplies a quantity in one unit while the written rule uses another' and 'before rules that mix units are written.' It advises using this tool to avoid permanent UNKNOWN answers. It does not explicitly name alternatives (e.g., dsail_add_unit_converter) or state when not to use it, but the context is clear enough for an agent to decide. A mention of when to use the add-converter sibling would push this to 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

dsail_use_workspaceSwitch workspaceA

Idempotent

Inspect

Work in a different team, or in your own workspace.

Use when the user wants to work on a different team's rulesets, or to go back to their own.

Chooses which workspace this user's saving and listing happen in. workspace names a team by its name or its id, or is personal for their own workspace. The choice persists across sessions. If two of their teams share a name the call is refused and names the ids, rather than guessing.

ParametersJSON Schema

Name	Required	Description	Default
`workspace`	Yes	A team's name or id, or `personal` for the user's own workspace.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Adds meaningful behavior beyond annotations: the workspace choice persists across sessions, and ambiguous team names cause the call to be refused with IDs named rather than guessing. These are non-obvious behavioral details that the annotations do not convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact, front-loaded with the core purpose, and every sentence adds useful information: usage trigger, effect, parameter format, persistence, and edge-case behavior. No filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-parameter tool with an output schema and rich annotations, the description covers purpose, when to use it, parameter semantics, persistence, and ambiguity handling. Nothing essential is missing for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already documents the parameter fully ('A team's name or id, or `personal`'). The description reinforces this and adds extra semantic context about how ambiguous names are handled, which helps the agent provide correct values.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific action ('Work in a different team, or in your own workspace') and resource ('workspace'), and clarifies that it determines where saving and listing happen. This distinguishes it from sibling tools like list_workspaces, which only list workspaces.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit use context: 'when the user wants to work on a different team's rulesets, or to go back to their own.' It does not explicitly name alternative tools or state when not to use it, but the context is clear enough to route an agent correctly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

1 tool updateOct 1, 2026

Changeddsail_review5 fields changed

addedInput schema / properties / name

Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "description": "The name a stored ruleset is saved under, instead of a hash: its current revision is shown.",
+  "title": "Name"
+}

addedInput schema / properties / ruleset_hash / anyOf

Added value: +[
+  {
+    "type": "string"
+  },
+  {
+    "type": "null"
+  }
+]

addedInput schema / properties / ruleset_hash / default
```
Added value: +null
```
removedInput schema / properties / ruleset_hash / type
```
Removed value: -"string"
```
removedInput schema / required
```
Removed value: -[
-  "ruleset_hash"
-]
```

4 tool updatesSep 26, 2026

Changeddsail_get_account_status1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "This account's tier, usage against its allowance, and the terms version that governs it.",
-    "properties": {
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "terms": {
-        "type": "object"
-      },
-      "tier": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "ENGINE_BUSY",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          },
-          "retry_after_ms": {
-            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
-            "type": "integer"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "This account's tier, usage against its allowance, and the terms version that governs it.",
+    "properties": {
+      "account": {
+        "properties": {
+          "organizations": {
+            "description": "The owner of the workspace currently in use (a team id while working in a team). Not the teams the user belongs to: `dsail_list_workspaces` lists those.",
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          }
+        },
+        "type": "object"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "terms": {
+        "type": "object"
+      },
+      "tier": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_remove_from_team1 field changed

changedInput schema / properties / member / description

Previous value: -"The member, by the email address they signed in with."New value: +"The member: the `email` `dsail_team_members` reports for them (case does not matter), or the `subject` it reports beside it."

Changeddsail_save_ruleset1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The saved revision: its name, hash and parent.",
-    "properties": {
-      "name": {
-        "type": "string"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "parent_hash": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "ruleset_hash": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "ENGINE_BUSY",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          },
-          "retry_after_ms": {
-            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
-            "type": "integer"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The saved revision: its name, hash and parent.",
+    "properties": {
+      "created": {
+        "description": "True when these exact source bytes were stored for the first time; false when an identical source was already stored by a compile or an earlier save. Independent of whether the name is new.",
+        "type": "boolean"
+      },
+      "name": {
+        "type": "string"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "parent_hash": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "ruleset_hash": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_set_team_role1 field changed

changedInput schema / properties / member / description

Previous value: -"The member, by the email address they signed in with."New value: +"The member: the `email` `dsail_team_members` reports for them (case does not matter), or the `subject` it reports beside it."

20 tool updatesSep 25, 2026

Changeddsail_add_unit_converter1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The unit library after the change, with its new hash and a warning about approvals recorded against the previous one.",
-    "properties": {
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "unit_library_hash": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      },
-      "warning": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The unit library after the change, with its new hash and a warning about approvals recorded against the previous one.",
+    "properties": {
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "unit_library_hash": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      },
+      "warning": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_check2 fields changed

changedOutput schema / description

Previous value: -"Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — with a counterexample where an assertion is violated. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it."New value: +"Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — each naming the assertion that decided it. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it."

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
-    "properties": {
-      "claims": {
-        "properties": {
-          "bound": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "quantities": {
-            "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
-            "items": {
-              "properties": {
-                "bound": {
-                  "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
-                  "type": "string"
-                },
-                "claim": {
-                  "type": "string"
-                },
-                "conversion": {
-                  "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
-                  "properties": {
-                    "by": {
-                      "const": "engine",
-                      "type": "string"
-                    },
-                    "factor": {
-                      "type": "number"
-                    },
-                    "from": {
-                      "type": "string"
-                    },
-                    "status": {
-                      "type": "string"
-                    },
-                    "to": {
-                      "type": "string"
-                    }
-                  },
-                  "required": [
-                    "from",
-                    "to",
-                    "by",
-                    "status"
-                  ],
-                  "type": "object"
-                },
-                "measured_in": {
-                  "description": "The claim's declared @unit, if any.",
-                  "type": [
-                    "string",
-                    "null"
-                  ]
-                },
-                "submitted": {
-                  "description": "The value as the caller sent it.",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "claim",
-                "submitted",
-                "bound",
-                "measured_in"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "unbound": {
-            "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          }
-        },
-        "required": [
-          "bound",
-          "unbound"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "rules": {
-        "items": {
-          "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
-          "properties": {
-            "assertions": {
-              "items": {
-                "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
-                "properties": {
-                  "check": {
-                    "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
-                    "enum": [
-                      "TRUE",
-                      "FALSE",
-                      "UNKNOWN",
-                      "AMBIGUOUS"
-                    ],
-                    "type": "string"
-                  },
-                  "counterexample": {
-                    "description": "The assignment that violates this assertion, from the solver. Present only on FALSE: for an UNKNOWN the solver's witness is merely a model in which the assertion could fail, and publishing it would state a determination this service did not make.",
-                    "type": "string"
-                  },
-                  "name": {
-                    "type": "string"
-                  },
-                  "reason_unknown": {
-                    "type": "string"
-                  },
-                  "source": {
-                    "type": [
-                      "string",
-                      "null"
-                    ]
-                  },
-                  "unbridged_units": {
-                    "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
-                    "items": {
-                      "properties": {
-                        "from": {
-                          "type": "string"
-                        },
-                        "to": {
-                          "type": "string"
-                        }
-                      },
-                      "required": [
-                        "from",
-                        "to"
-                      ],
-                      "type": "object"
-                    },
-                    "type": "array"
-                  },
-                  "unknown_policy": {
-                    "type": "string"
-                  }
-                },
-                "required": [
-                  "name",
-                  "check"
-                ],
-                "type": "object"
-              },
-              "type": "array"
-            },
-            "rule": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "rule",
-            "assertions"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "ruleset_hash": {
-        "type": "string"
-      },
-      "unit_library_hash": {
-        "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "ruleset_hash",
-      "unit_library_hash",
-      "rules",
-      "claims",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
+    "properties": {
+      "claims": {
+        "properties": {
+          "bound": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "quantities": {
+            "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
+            "items": {
+              "properties": {
+                "bound": {
+                  "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
+                  "type": "string"
+                },
+                "claim": {
+                  "type": "string"
+                },
+                "conversion": {
+                  "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
+                  "properties": {
+                    "by": {
+                      "const": "engine",
+                      "type": "string"
+                    },
+                    "factor": {
+                      "type": "number"
+                    },
+                    "from": {
+                      "type": "string"
+                    },
+                    "status": {
+                      "type": "string"
+                    },
+                    "to": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "from",
+                    "to",
+                    "by",
+                    "status"
+                  ],
+                  "type": "object"
+                },
+                "measured_in": {
+                  "description": "The claim's declared @unit, if any.",
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "submitted": {
+                  "description": "The value as the caller sent it.",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "claim",
+                "submitted",
+                "bound",
+                "measured_in"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "unbound": {
+            "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "bound",
+          "unbound"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "rules": {
+        "items": {
+          "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
+          "properties": {
+            "assertions": {
+              "items": {
+                "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
+                "properties": {
+                  "check": {
+                    "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
+                    "enum": [
+                      "TRUE",
+                      "FALSE",
+                      "UNKNOWN",
+                      "AMBIGUOUS"
+                    ],
+                    "type": "string"
+                  },
+                  "name": {
+                    "type": "string"
+                  },
+                  "reason_unknown": {
+                    "type": "string"
+                  },
+                  "source": {
+                    "type": [
+                      "string",
+                      "null"
+                    ]
+                  },
+                  "unbridged_units": {
+                    "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
+                    "items": {
+                      "properties": {
+                        "from": {
+                          "type": "string"
+                        },
+                        "to": {
+                          "type": "string"
+                        }
+                      },
+                      "required": [
+                        "from",
+                        "to"
+                      ],
+                      "type": "object"
+                    },
+                    "type": "array"
+                  },
+                  "unknown_policy": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "name",
+                  "check"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "rule": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "rule",
+            "assertions"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "ruleset_hash": {
+        "type": "string"
+      },
+      "unit_library_hash": {
+        "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "ruleset_hash",
+      "unit_library_hash",
+      "rules",
+      "claims",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_compile1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "properties": {
-      "claim_schema": {
-        "description": "JSON Schema for the claim dictionary.",
-        "type": "object"
-      },
-      "diagnostics": {
-        "items": {
-          "properties": {
-            "line": {
-              "type": [
-                "integer",
-                "null"
-              ]
-            },
-            "message": {
-              "type": "string"
-            },
-            "severity": {
-              "enum": [
-                "error",
-                "warning"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "severity",
-            "message"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "label": {
-        "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
-        "properties": {
-          "confidence": {
-            "enum": [
-              "high",
-              "medium",
-              "low",
-              null
-            ],
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "declined": {
-            "type": "boolean"
-          },
-          "level_one": {
-            "description": "Level-one domain id. Null only when declined.",
-            "enum": [
-              "finance",
-              "consumer_finance",
-              "capital_markets",
-              "insurance",
-              "regulatory_compliance",
-              "hr_workforce",
-              "security_access",
-              "security_classification",
-              "healthcare",
-              "legal_contracts",
-              "procurement",
-              "engineering_release",
-              "content_safety",
-              "other",
-              null
-            ],
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "level_two": {
-            "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
-            "pattern": "^l2-[0-9]{4,}$",
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "updated_at": {
-            "description": "UTC, ISO 8601.",
-            "type": "string"
-          },
-          "vocabulary_version": {
-            "example": "v1",
-            "type": "string"
-          }
-        },
-        "required": [
-          "vocabulary_version",
-          "level_one",
-          "level_two",
-          "confidence",
-          "declined",
-          "updated_at"
-        ],
-        "type": [
-          "object",
-          "null"
-        ]
-      },
-      "manifest": {
-        "properties": {
-          "claims": {
-            "items": {
-              "properties": {
-                "boolean_subtype": {
-                  "type": "string"
-                },
-                "claim": {
-                  "type": "string"
-                },
-                "context": {
-                  "type": "string"
-                },
-                "data_type": {
-                  "enum": [
-                    "boolean",
-                    "numeric",
-                    "enum"
-                  ],
-                  "type": "string"
-                },
-                "ordered": {
-                  "type": "boolean"
-                },
-                "question": {
-                  "description": "Shown to the extracting model.",
-                  "type": "string"
-                },
-                "range": {
-                  "properties": {
-                    "max": {
-                      "type": "number"
-                    },
-                    "min": {
-                      "type": "number"
-                    }
-                  },
-                  "type": "object"
-                },
-                "required": {
-                  "type": "boolean"
-                },
-                "unit": {
-                  "type": [
-                    "string",
-                    "null"
-                  ]
-                },
-                "unknown_allowed": {
-                  "const": true,
-                  "type": "boolean"
-                },
-                "unknown_sentinel": {
-                  "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
-                  "type": "string"
-                },
-                "vocabulary": {
-                  "items": {
-                    "type": "string"
-                  },
-                  "type": "array"
-                }
-              },
-              "required": [
-                "claim",
-                "data_type",
-                "question",
-                "required",
-                "unknown_allowed"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "rules": {
-            "items": {
-              "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
-              "properties": {
-                "assertions": {
-                  "items": {
-                    "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
-                    "properties": {
-                      "line": {
-                        "type": [
-                          "integer",
-                          "null"
-                        ]
-                      },
-                      "name": {
-                        "type": "string"
-                      },
-                      "source": {
-                        "type": [
-                          "string",
-                          "null"
-                        ]
-                      },
-                      "unknown_policy": {
-                        "enum": [
-                          "optimistic",
-                          "pessimistic",
-                          "neutral"
-                        ],
-                        "type": "string"
-                      }
-                    },
-                    "required": [
-                      "name",
-                      "unknown_policy"
-                    ],
-                    "type": "object"
-                  },
-                  "type": "array"
-                },
-                "rule": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "rule",
-                "assertions"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "ruleset_hash": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "ruleset_hash",
-          "claims",
-          "rules"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "review": {
-        "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
-        "type": "string"
-      },
-      "ruleset_hash": {
-        "description": "sha256 of the normalised source. This is the object key.",
-        "type": "string"
-      },
-      "source": {
-        "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
-        "type": "string"
-      },
-      "stored": {
-        "properties": {
-          "parent_hash": {
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "revision_depth": {
-            "type": "integer"
-          }
-        },
-        "type": "object"
-      },
-      "summary": {
-        "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
-        "type": "string"
-      },
-      "unbridged_units": {
-        "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
-        "items": {
-          "properties": {
-            "cause": {
-              "enum": [
-                "missing",
-                "ambiguous"
-              ],
-              "type": "string"
-            },
-            "from": {
-              "type": "string"
-            },
-            "rule": {
-              "type": "string"
-            },
-            "to": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "rule",
-            "from",
-            "to",
-            "cause"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "unit_library_hash": {
-        "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "validation_contract": {
-        "description": "Exactly what check will reject, known before submitting.",
-        "type": "object"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "ruleset_hash",
-      "source",
-      "manifest",
-      "review",
-      "summary",
-      "claim_schema",
-      "validation_contract",
-      "diagnostics",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "properties": {
+      "claim_schema": {
+        "description": "JSON Schema for the claim dictionary.",
+        "type": "object"
+      },
+      "diagnostics": {
+        "items": {
+          "properties": {
+            "line": {
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "message": {
+              "type": "string"
+            },
+            "severity": {
+              "enum": [
+                "error",
+                "warning"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "severity",
+            "message"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "label": {
+        "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
+        "properties": {
+          "confidence": {
+            "enum": [
+              "high",
+              "medium",
+              "low",
+              null
+            ],
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "declined": {
+            "type": "boolean"
+          },
+          "level_one": {
+            "description": "Level-one domain id. Null only when declined.",
+            "enum": [
+              "finance",
+              "consumer_finance",
+              "capital_markets",
+              "insurance",
+              "regulatory_compliance",
+              "hr_workforce",
+              "security_access",
+              "security_classification",
+              "healthcare",
+              "legal_contracts",
+              "procurement",
+              "engineering_release",
+              "content_safety",
+              "other",
+              null
+            ],
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "level_two": {
+            "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
+            "pattern": "^l2-[0-9]{4,}$",
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "updated_at": {
+            "description": "UTC, ISO 8601.",
+            "type": "string"
+          },
+          "vocabulary_version": {
+            "example": "v1",
+            "type": "string"
+          }
+        },
+        "required": [
+          "vocabulary_version",
+          "level_one",
+          "level_two",
+          "confidence",
+          "declined",
+          "updated_at"
+        ],
+        "type": [
+          "object",
+          "null"
+        ]
+      },
+      "manifest": {
+        "properties": {
+          "claims": {
+            "items": {
+              "properties": {
+                "boolean_subtype": {
+                  "type": "string"
+                },
+                "claim": {
+                  "type": "string"
+                },
+                "context": {
+                  "type": "string"
+                },
+                "data_type": {
+                  "enum": [
+                    "boolean",
+                    "numeric",
+                    "enum"
+                  ],
+                  "type": "string"
+                },
+                "ordered": {
+                  "type": "boolean"
+                },
+                "question": {
+                  "description": "Shown to the extracting model.",
+                  "type": "string"
+                },
+                "range": {
+                  "properties": {
+                    "max": {
+                      "type": "number"
+                    },
+                    "min": {
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                },
+                "required": {
+                  "type": "boolean"
+                },
+                "unit": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "unknown_allowed": {
+                  "const": true,
+                  "type": "boolean"
+                },
+                "unknown_sentinel": {
+                  "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
+                  "type": "string"
+                },
+                "vocabulary": {
+                  "items": {
+                    "type": "string"
+                  },
+                  "type": "array"
+                }
+              },
+              "required": [
+                "claim",
+                "data_type",
+                "question",
+                "required",
+                "unknown_allowed"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "rules": {
+            "items": {
+              "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
+              "properties": {
+                "assertions": {
+                  "items": {
+                    "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
+                    "properties": {
+                      "line": {
+                        "type": [
+                          "integer",
+                          "null"
+                        ]
+                      },
+                      "name": {
+                        "type": "string"
+                      },
+                      "source": {
+                        "type": [
+                          "string",
+                          "null"
+                        ]
+                      },
+                      "unknown_policy": {
+                        "enum": [
+                          "optimistic",
+                          "pessimistic",
+                          "neutral"
+                        ],
+                        "type": "string"
+                      }
+                    },
+                    "required": [
+                      "name",
+                      "unknown_policy"
+                    ],
+                    "type": "object"
+                  },
+                  "type": "array"
+                },
+                "rule": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "rule",
+                "assertions"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "ruleset_hash": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "ruleset_hash",
+          "claims",
+          "rules"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "review": {
+        "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
+        "type": "string"
+      },
+      "ruleset_hash": {
+        "description": "sha256 of the normalised source. This is the object key.",
+        "type": "string"
+      },
+      "source": {
+        "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
+        "type": "string"
+      },
+      "stored": {
+        "properties": {
+          "parent_hash": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "revision_depth": {
+            "type": "integer"
+          }
+        },
+        "type": "object"
+      },
+      "summary": {
+        "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
+        "type": "string"
+      },
+      "unbridged_units": {
+        "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
+        "items": {
+          "properties": {
+            "cause": {
+              "enum": [
+                "missing",
+                "ambiguous"
+              ],
+              "type": "string"
+            },
+            "from": {
+              "type": "string"
+            },
+            "rule": {
+              "type": "string"
+            },
+            "to": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "rule",
+            "from",
+            "to",
+            "cause"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "unit_library_hash": {
+        "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "validation_contract": {
+        "description": "Exactly what check will reject, known before submitting.",
+        "type": "object"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "ruleset_hash",
+      "source",
+      "manifest",
+      "review",
+      "summary",
+      "claim_schema",
+      "validation_contract",
+      "diagnostics",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_copy_ruleset1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The copy as saved in the destination workspace.",
-    "properties": {
-      "name": {
-        "type": "string"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "ruleset_hash": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The copy as saved in the destination workspace.",
+    "properties": {
+      "name": {
+        "type": "string"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "ruleset_hash": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_create_team1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The new team's id and the administrator's first invitation link.",
-    "properties": {
-      "invitation": {
-        "type": [
-          "string",
-          "object",
-          "null"
-        ]
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "team_id": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The new team's id and the administrator's first invitation link.",
+    "properties": {
+      "invitation": {
+        "type": [
+          "string",
+          "object",
+          "null"
+        ]
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "team_id": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_get_account_status1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "This account's tier, usage against its allowance, and the terms version that governs it.",
-    "properties": {
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "terms": {
-        "type": "object"
-      },
-      "tier": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "This account's tier, usage against its allowance, and the terms version that governs it.",
+    "properties": {
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "terms": {
+        "type": "object"
+      },
+      "tier": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_get_prompt_pack1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "properties": {
-      "assembly_notes": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "claim_schema": {
-        "type": "object"
-      },
-      "integrity_rule": {
-        "type": "string"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "prompts": {
-        "items": {
-          "properties": {
-            "answer_format": {
-              "type": "string"
-            },
-            "claim": {
-              "type": "string"
-            },
-            "context": {
-              "type": "string"
-            },
-            "data_type": {
-              "type": "string"
-            },
-            "ordered_vocabulary": {
-              "description": "True when the enum was declared ordered, so its members compare with < and >.",
-              "type": "boolean"
-            },
-            "question": {
-              "type": "string"
-            },
-            "range": {
-              "type": "object"
-            },
-            "undetermined_value": {
-              "description": "The literal to send when this claim could not be determined: \"unknown\", or null where the vocabulary itself contains \"unknown\".",
-              "type": "string"
-            },
-            "unit": {
-              "type": "string"
-            },
-            "unknown_rule": {
-              "type": "string"
-            },
-            "vocabulary": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            }
-          },
-          "required": [
-            "claim",
-            "data_type",
-            "question",
-            "answer_format",
-            "unknown_rule"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "ruleset_hash": {
-        "type": "string"
-      },
-      "validation_contract": {
-        "type": "object"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "ruleset_hash",
-      "integrity_rule",
-      "prompts",
-      "claim_schema",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "properties": {
+      "assembly_notes": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "claim_schema": {
+        "type": "object"
+      },
+      "integrity_rule": {
+        "type": "string"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "prompts": {
+        "items": {
+          "properties": {
+            "answer_format": {
+              "type": "string"
+            },
+            "claim": {
+              "type": "string"
+            },
+            "context": {
+              "type": "string"
+            },
+            "data_type": {
+              "type": "string"
+            },
+            "ordered_vocabulary": {
+              "description": "True when the enum was declared ordered, so its members compare with < and >.",
+              "type": "boolean"
+            },
+            "question": {
+              "type": "string"
+            },
+            "range": {
+              "type": "object"
+            },
+            "undetermined_value": {
+              "description": "The literal to send when this claim could not be determined: \"unknown\", or null where the vocabulary itself contains \"unknown\".",
+              "type": "string"
+            },
+            "unit": {
+              "type": "string"
+            },
+            "unknown_rule": {
+              "type": "string"
+            },
+            "vocabulary": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "claim",
+            "data_type",
+            "question",
+            "answer_format",
+            "unknown_rule"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "ruleset_hash": {
+        "type": "string"
+      },
+      "validation_contract": {
+        "type": "object"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "ruleset_hash",
+      "integrity_rule",
+      "prompts",
+      "claim_schema",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_invite_to_team1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "A single-use invitation link for the administrator to pass on.",
-    "properties": {
-      "invitation": {
-        "type": [
-          "string",
-          "object"
-        ]
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "A single-use invitation link for the administrator to pass on.",
+    "properties": {
+      "invitation": {
+        "type": [
+          "string",
+          "object"
+        ]
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_issue_api_key1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "An evaluation credential, minted on request with no human gate (TJP-621). The token is shown here and nowhere else — the service stores only its hash. Send it as the x-jaxon-credential header. It is scoped to compile, check and the prompt pack, capped per day and over its lifetime, and expires; every response it produces carries x-jaxon-credential-grade: evaluation.",
-    "properties": {
-      "credential": {
-        "description": "The bearer token. Store it; it is not retrievable again.",
-        "type": "string"
-      },
-      "credential_id": {
-        "description": "Names the credential without unlocking anything; safe to log.",
-        "type": "string"
-      },
-      "expires_at": {
-        "description": "ISO 8601, UTC.",
-        "type": "string"
-      },
-      "grade": {
-        "enum": [
-          "evaluation"
-        ],
-        "type": "string"
-      },
-      "header": {
-        "const": "x-jaxon-credential",
-        "type": "string"
-      },
-      "limits": {
-        "properties": {
-          "calls_per_day": {
-            "type": "integer"
-          },
-          "calls_total": {
-            "type": "integer"
-          },
-          "ttl_days": {
-            "type": "integer"
-          }
-        },
-        "required": [
-          "ttl_days",
-          "calls_per_day",
-          "calls_total"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "scope": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "upgrade": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "credential",
-      "credential_id",
-      "grade",
-      "expires_at",
-      "limits",
-      "header",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "An evaluation credential, minted on request with no human gate (TJP-621). The token is shown here and nowhere else — the service stores only its hash. Send it as the x-jaxon-credential header. It is scoped to compile, check and the prompt pack, capped per day and over its lifetime, and expires; every response it produces carries x-jaxon-credential-grade: evaluation.",
+    "properties": {
+      "credential": {
+        "description": "The bearer token. Store it; it is not retrievable again.",
+        "type": "string"
+      },
+      "credential_id": {
+        "description": "Names the credential without unlocking anything; safe to log.",
+        "type": "string"
+      },
+      "expires_at": {
+        "description": "ISO 8601, UTC.",
+        "type": "string"
+      },
+      "grade": {
+        "enum": [
+          "evaluation"
+        ],
+        "type": "string"
+      },
+      "header": {
+        "const": "x-jaxon-credential",
+        "type": "string"
+      },
+      "limits": {
+        "properties": {
+          "calls_per_day": {
+            "type": "integer"
+          },
+          "calls_total": {
+            "type": "integer"
+          },
+          "ttl_days": {
+            "type": "integer"
+          }
+        },
+        "required": [
+          "ttl_days",
+          "calls_per_day",
+          "calls_total"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "scope": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "upgrade": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "credential",
+      "credential_id",
+      "grade",
+      "expires_at",
+      "limits",
+      "header",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_list_rulesets1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "Every named ruleset saved for this connection, with enough per row to render a library without a second call.",
-    "properties": {
-      "namespace": {
-        "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
-        "type": "string"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "rulesets": {
-        "items": {
-          "properties": {
-            "approval_count": {
-              "type": "integer"
-            },
-            "bound_at": {
-              "description": "When this name last started pointing at these bytes — the ruleset's last-changed time.",
-              "type": "string"
-            },
-            "claim_count": {
-              "type": [
-                "integer",
-                "null"
-              ]
-            },
-            "compiles": {
-              "description": "False when the stored source no longer compiles under this engine, or its bytes are gone. The row is still returned — a listing a single unreadable entry could hide is worse than one that says so — and the counts are null.",
-              "type": "boolean"
-            },
-            "name": {
-              "description": "The primary handle.",
-              "type": "string"
-            },
-            "revision_depth": {
-              "type": "integer"
-            },
-            "rule_count": {
-              "type": [
-                "integer",
-                "null"
-              ]
-            },
-            "ruleset_hash": {
-              "type": "string"
-            },
-            "summary": {
-              "description": "One sentence: what this ruleset asks and what it can decide. Derived per row from the manifest, never stored beside it.",
-              "type": "string"
-            }
-          },
-          "required": [
-            "name",
-            "ruleset_hash",
-            "bound_at",
-            "revision_depth",
-            "approval_count",
-            "compiles",
-            "summary",
-            "claim_count",
-            "rule_count"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "namespace",
-      "rulesets",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "Every named ruleset saved for this connection, with enough per row to render a library without a second call.",
+    "properties": {
+      "namespace": {
+        "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
+        "type": "string"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "rulesets": {
+        "items": {
+          "properties": {
+            "approval_count": {
+              "type": "integer"
+            },
+            "bound_at": {
+              "description": "When this name last started pointing at these bytes — the ruleset's last-changed time.",
+              "type": "string"
+            },
+            "claim_count": {
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "compiles": {
+              "description": "False when the stored source no longer compiles under this engine, or its bytes are gone. The row is still returned — a listing a single unreadable entry could hide is worse than one that says so — and the counts are null.",
+              "type": "boolean"
+            },
+            "name": {
+              "description": "The primary handle.",
+              "type": "string"
+            },
+            "revision_depth": {
+              "type": "integer"
+            },
+            "rule_count": {
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "ruleset_hash": {
+              "type": "string"
+            },
+            "summary": {
+              "description": "One sentence: what this ruleset asks and what it can decide. Derived per row from the manifest, never stored beside it.",
+              "type": "string"
+            }
+          },
+          "required": [
+            "name",
+            "ruleset_hash",
+            "bound_at",
+            "revision_depth",
+            "approval_count",
+            "compiles",
+            "summary",
+            "claim_count",
+            "rule_count"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "namespace",
+      "rulesets",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_list_workspaces1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "Every workspace this user may work in, which one is current, and whether a signed-in person is behind the call.",
-    "properties": {
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "remedy": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "signed_in": {
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      },
-      "workspaces": {
-        "type": "array"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "Every workspace this user may work in, which one is current, and whether a signed-in person is behind the call.",
+    "properties": {
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "remedy": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "signed_in": {
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      },
+      "workspaces": {
+        "type": "array"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_load_ruleset1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "A stored ruleset, in the shape a compile of it would return plus what the store knows about it. This is how a saved ruleset is SHOWN — re-compiling remembered source produces a different object the moment the two disagree, and an approval follows the stored bytes.",
-    "properties": {
-      "approvals": {
-        "items": {
-          "properties": {
-            "approved_at": {
-              "description": "UTC, ISO 8601.",
-              "type": "string"
-            },
-            "approver": {
-              "type": "string"
-            },
-            "hash": {
-              "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
-              "type": "string"
-            },
-            "note": {
-              "type": [
-                "string",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "hash",
-            "approver",
-            "approved_at"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "claim_schema": {
-        "description": "JSON Schema for the claim dictionary.",
-        "type": "object"
-      },
-      "diagnostics": {
-        "items": {
-          "properties": {
-            "line": {
-              "type": [
-                "integer",
-                "null"
-              ]
-            },
-            "message": {
-              "type": "string"
-            },
-            "severity": {
-              "enum": [
-                "error",
-                "warning"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "severity",
-            "message"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "label": {
-        "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
-        "properties": {
-          "confidence": {
-            "enum": [
-              "high",
-              "medium",
-              "low",
-              null
-            ],
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "declined": {
-            "type": "boolean"
-          },
-          "level_one": {
-            "description": "Level-one domain id. Null only when declined.",
-            "enum": [
-              "finance",
-              "consumer_finance",
-              "capital_markets",
-              "insurance",
-              "regulatory_compliance",
-              "hr_workforce",
-              "security_access",
-              "security_classification",
-              "healthcare",
-              "legal_contracts",
-              "procurement",
-              "engineering_release",
-              "content_safety",
-              "other",
-              null
-            ],
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "level_two": {
-            "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
-            "pattern": "^l2-[0-9]{4,}$",
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "updated_at": {
-            "description": "UTC, ISO 8601.",
-            "type": "string"
-          },
-          "vocabulary_version": {
-            "example": "v1",
-            "type": "string"
-          }
-        },
-        "required": [
-          "vocabulary_version",
-          "level_one",
-          "level_two",
-          "confidence",
-          "declined",
-          "updated_at"
-        ],
-        "type": [
-          "object",
-          "null"
-        ]
-      },
-      "manifest": {
-        "properties": {
-          "claims": {
-            "items": {
-              "properties": {
-                "boolean_subtype": {
-                  "type": "string"
-                },
-                "claim": {
-                  "type": "string"
-                },
-                "context": {
-                  "type": "string"
-                },
-                "data_type": {
-                  "enum": [
-                    "boolean",
-                    "numeric",
-                    "enum"
-                  ],
-                  "type": "string"
-                },
-                "ordered": {
-                  "type": "boolean"
-                },
-                "question": {
-                  "description": "Shown to the extracting model.",
-                  "type": "string"
-                },
-                "range": {
-                  "properties": {
-                    "max": {
-                      "type": "number"
-                    },
-                    "min": {
-                      "type": "number"
-                    }
-                  },
-                  "type": "object"
-                },
-                "required": {
-                  "type": "boolean"
-                },
-                "unit": {
-                  "type": [
-                    "string",
-                    "null"
-                  ]
-                },
-                "unknown_allowed": {
-                  "const": true,
-                  "type": "boolean"
-                },
-                "unknown_sentinel": {
-                  "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
-                  "type": "string"
-                },
-                "vocabulary": {
-                  "items": {
-                    "type": "string"
-                  },
-                  "type": "array"
-                }
-              },
-              "required": [
-                "claim",
-                "data_type",
-                "question",
-                "required",
-                "unknown_allowed"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "rules": {
-            "items": {
-              "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
-              "properties": {
-                "assertions": {
-                  "items": {
-                    "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
-                    "properties": {
-                      "line": {
-                        "type": [
-                          "integer",
-                          "null"
-                        ]
-                      },
-                      "name": {
-                        "type": "string"
-                      },
-                      "source": {
-                        "type": [
-                          "string",
-                          "null"
-                        ]
-                      },
-                      "unknown_policy": {
-                        "enum": [
-                          "optimistic",
-                          "pessimistic",
-                          "neutral"
-                        ],
-                        "type": "string"
-                      }
-                    },
-                    "required": [
-                      "name",
-                      "unknown_policy"
-                    ],
-                    "type": "object"
-                  },
-                  "type": "array"
-                },
-                "rule": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "rule",
-                "assertions"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "ruleset_hash": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "ruleset_hash",
-          "claims",
-          "rules"
-        ],
-        "type": "object"
-      },
-      "name": {
-        "description": "The name that was asked for.",
-        "type": "string"
-      },
-      "namespace": {
-        "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
-        "type": "string"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "review": {
-        "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
-        "type": "string"
-      },
-      "revision_chain": {
-        "description": "This hash, then its parent, back to the root.",
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "ruleset_hash": {
-        "description": "sha256 of the normalised source. This is the object key.",
-        "type": "string"
-      },
-      "source": {
-        "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
-        "type": "string"
-      },
-      "stored": {
-        "properties": {
-          "parent_hash": {
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "revision_depth": {
-            "type": "integer"
-          }
-        },
-        "type": "object"
-      },
-      "summary": {
-        "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
-        "type": "string"
-      },
-      "unbridged_units": {
-        "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
-        "items": {
-          "properties": {
-            "cause": {
-              "enum": [
-                "missing",
-                "ambiguous"
-              ],
-              "type": "string"
-            },
-            "from": {
-              "type": "string"
-            },
-            "rule": {
-              "type": "string"
-            },
-            "to": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "rule",
-            "from",
-            "to",
-            "cause"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "unit_library_hash": {
-        "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "validation_contract": {
-        "description": "Exactly what check will reject, known before submitting.",
-        "type": "object"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "namespace",
-      "name",
-      "ruleset_hash",
-      "source",
-      "manifest",
-      "revision_chain",
-      "approvals",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "A stored ruleset, in the shape a compile of it would return plus what the store knows about it. This is how a saved ruleset is SHOWN — re-compiling remembered source produces a different object the moment the two disagree, and an approval follows the stored bytes.",
+    "properties": {
+      "approvals": {
+        "items": {
+          "properties": {
+            "approved_at": {
+              "description": "UTC, ISO 8601.",
+              "type": "string"
+            },
+            "approver": {
+              "type": "string"
+            },
+            "hash": {
+              "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
+              "type": "string"
+            },
+            "note": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "hash",
+            "approver",
+            "approved_at"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "claim_schema": {
+        "description": "JSON Schema for the claim dictionary.",
+        "type": "object"
+      },
+      "diagnostics": {
+        "items": {
+          "properties": {
+            "line": {
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "message": {
+              "type": "string"
+            },
+            "severity": {
+              "enum": [
+                "error",
+                "warning"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "severity",
+            "message"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "label": {
+        "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
+        "properties": {
+          "confidence": {
+            "enum": [
+              "high",
+              "medium",
+              "low",
+              null
+            ],
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "declined": {
+            "type": "boolean"
+          },
+          "level_one": {
+            "description": "Level-one domain id. Null only when declined.",
+            "enum": [
+              "finance",
+              "consumer_finance",
+              "capital_markets",
+              "insurance",
+              "regulatory_compliance",
+              "hr_workforce",
+              "security_access",
+              "security_classification",
+              "healthcare",
+              "legal_contracts",
+              "procurement",
+              "engineering_release",
+              "content_safety",
+              "other",
+              null
+            ],
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "level_two": {
+            "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
+            "pattern": "^l2-[0-9]{4,}$",
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "updated_at": {
+            "description": "UTC, ISO 8601.",
+            "type": "string"
+          },
+          "vocabulary_version": {
+            "example": "v1",
+            "type": "string"
+          }
+        },
+        "required": [
+          "vocabulary_version",
+          "level_one",
+          "level_two",
+          "confidence",
+          "declined",
+          "updated_at"
+        ],
+        "type": [
+          "object",
+          "null"
+        ]
+      },
+      "manifest": {
+        "properties": {
+          "claims": {
+            "items": {
+              "properties": {
+                "boolean_subtype": {
+                  "type": "string"
+                },
+                "claim": {
+                  "type": "string"
+                },
+                "context": {
+                  "type": "string"
+                },
+                "data_type": {
+                  "enum": [
+                    "boolean",
+                    "numeric",
+                    "enum"
+                  ],
+                  "type": "string"
+                },
+                "ordered": {
+                  "type": "boolean"
+                },
+                "question": {
+                  "description": "Shown to the extracting model.",
+                  "type": "string"
+                },
+                "range": {
+                  "properties": {
+                    "max": {
+                      "type": "number"
+                    },
+                    "min": {
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                },
+                "required": {
+                  "type": "boolean"
+                },
+                "unit": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "unknown_allowed": {
+                  "const": true,
+                  "type": "boolean"
+                },
+                "unknown_sentinel": {
+                  "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
+                  "type": "string"
+                },
+                "vocabulary": {
+                  "items": {
+                    "type": "string"
+                  },
+                  "type": "array"
+                }
+              },
+              "required": [
+                "claim",
+                "data_type",
+                "question",
+                "required",
+                "unknown_allowed"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "rules": {
+            "items": {
+              "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
+              "properties": {
+                "assertions": {
+                  "items": {
+                    "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
+                    "properties": {
+                      "line": {
+                        "type": [
+                          "integer",
+                          "null"
+                        ]
+                      },
+                      "name": {
+                        "type": "string"
+                      },
+                      "source": {
+                        "type": [
+                          "string",
+                          "null"
+                        ]
+                      },
+                      "unknown_policy": {
+                        "enum": [
+                          "optimistic",
+                          "pessimistic",
+                          "neutral"
+                        ],
+                        "type": "string"
+                      }
+                    },
+                    "required": [
+                      "name",
+                      "unknown_policy"
+                    ],
+                    "type": "object"
+                  },
+                  "type": "array"
+                },
+                "rule": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "rule",
+                "assertions"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "ruleset_hash": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "ruleset_hash",
+          "claims",
+          "rules"
+        ],
+        "type": "object"
+      },
+      "name": {
+        "description": "The name that was asked for.",
+        "type": "string"
+      },
+      "namespace": {
+        "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
+        "type": "string"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "review": {
+        "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
+        "type": "string"
+      },
+      "revision_chain": {
+        "description": "This hash, then its parent, back to the root.",
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "ruleset_hash": {
+        "description": "sha256 of the normalised source. This is the object key.",
+        "type": "string"
+      },
+      "source": {
+        "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
+        "type": "string"
+      },
+      "stored": {
+        "properties": {
+          "parent_hash": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "revision_depth": {
+            "type": "integer"
+          }
+        },
+        "type": "object"
+      },
+      "summary": {
+        "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
+        "type": "string"
+      },
+      "unbridged_units": {
+        "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
+        "items": {
+          "properties": {
+            "cause": {
+              "enum": [
+                "missing",
+                "ambiguous"
+              ],
+              "type": "string"
+            },
+            "from": {
+              "type": "string"
+            },
+            "rule": {
+              "type": "string"
+            },
+            "to": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "rule",
+            "from",
+            "to",
+            "cause"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "unit_library_hash": {
+        "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "validation_contract": {
+        "description": "Exactly what check will reject, known before submitting.",
+        "type": "object"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "namespace",
+      "name",
+      "ruleset_hash",
+      "source",
+      "manifest",
+      "revision_chain",
+      "approvals",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_record_approval1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "properties": {
-      "approval": {
-        "properties": {
-          "approved_at": {
-            "description": "UTC, ISO 8601.",
-            "type": "string"
-          },
-          "approver": {
-            "type": "string"
-          },
-          "hash": {
-            "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
-            "type": "string"
-          },
-          "note": {
-            "type": [
-              "string",
-              "null"
-            ]
-          }
-        },
-        "required": [
-          "hash",
-          "approver",
-          "approved_at"
-        ],
-        "type": "object"
-      },
-      "approvals": {
-        "description": "Every approval on this hash, including the new one.",
-        "items": {
-          "properties": {
-            "approved_at": {
-              "description": "UTC, ISO 8601.",
-              "type": "string"
-            },
-            "approver": {
-              "type": "string"
-            },
-            "hash": {
-              "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
-              "type": "string"
-            },
-            "note": {
-              "type": [
-                "string",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "hash",
-            "approver",
-            "approved_at"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "label": {
-        "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
-        "properties": {
-          "confidence": {
-            "enum": [
-              "high",
-              "medium",
-              "low",
-              null
-            ],
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "declined": {
-            "type": "boolean"
-          },
-          "level_one": {
-            "description": "Level-one domain id. Null only when declined.",
-            "enum": [
-              "finance",
-              "consumer_finance",
-              "capital_markets",
-              "insurance",
-              "regulatory_compliance",
-              "hr_workforce",
-              "security_access",
-              "security_classification",
-              "healthcare",
-              "legal_contracts",
-              "procurement",
-              "engineering_release",
-              "content_safety",
-              "other",
-              null
-            ],
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "level_two": {
-            "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
-            "pattern": "^l2-[0-9]{4,}$",
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "updated_at": {
-            "description": "UTC, ISO 8601.",
-            "type": "string"
-          },
-          "vocabulary_version": {
-            "example": "v1",
-            "type": "string"
-          }
-        },
-        "required": [
-          "vocabulary_version",
-          "level_one",
-          "level_two",
-          "confidence",
-          "declined",
-          "updated_at"
-        ],
-        "type": [
-          "object",
-          "null"
-        ]
-      },
-      "name": {
-        "description": "The name these bytes are saved under after this call. Null only when none was supplied and none was already bound.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "namespace": {
-        "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
-        "type": "string"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "ruleset_hash": {
-        "type": "string"
-      },
-      "saved": {
-        "description": "Whether this call bound a name. The binding happens BEFORE the approval is recorded, so a refused name records no approval at all.",
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "ruleset_hash",
-      "namespace",
-      "name",
-      "saved",
-      "approval",
-      "approvals",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "properties": {
+      "approval": {
+        "properties": {
+          "approved_at": {
+            "description": "UTC, ISO 8601.",
+            "type": "string"
+          },
+          "approver": {
+            "type": "string"
+          },
+          "hash": {
+            "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
+            "type": "string"
+          },
+          "note": {
+            "type": [
+              "string",
+              "null"
+            ]
+          }
+        },
+        "required": [
+          "hash",
+          "approver",
+          "approved_at"
+        ],
+        "type": "object"
+      },
+      "approvals": {
+        "description": "Every approval on this hash, including the new one.",
+        "items": {
+          "properties": {
+            "approved_at": {
+              "description": "UTC, ISO 8601.",
+              "type": "string"
+            },
+            "approver": {
+              "type": "string"
+            },
+            "hash": {
+              "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
+              "type": "string"
+            },
+            "note": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "hash",
+            "approver",
+            "approved_at"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "label": {
+        "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
+        "properties": {
+          "confidence": {
+            "enum": [
+              "high",
+              "medium",
+              "low",
+              null
+            ],
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "declined": {
+            "type": "boolean"
+          },
+          "level_one": {
+            "description": "Level-one domain id. Null only when declined.",
+            "enum": [
+              "finance",
+              "consumer_finance",
+              "capital_markets",
+              "insurance",
+              "regulatory_compliance",
+              "hr_workforce",
+              "security_access",
+              "security_classification",
+              "healthcare",
+              "legal_contracts",
+              "procurement",
+              "engineering_release",
+              "content_safety",
+              "other",
+              null
+            ],
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "level_two": {
+            "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
+            "pattern": "^l2-[0-9]{4,}$",
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "updated_at": {
+            "description": "UTC, ISO 8601.",
+            "type": "string"
+          },
+          "vocabulary_version": {
+            "example": "v1",
+            "type": "string"
+          }
+        },
+        "required": [
+          "vocabulary_version",
+          "level_one",
+          "level_two",
+          "confidence",
+          "declined",
+          "updated_at"
+        ],
+        "type": [
+          "object",
+          "null"
+        ]
+      },
+      "name": {
+        "description": "The name these bytes are saved under after this call. Null only when none was supplied and none was already bound.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "namespace": {
+        "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
+        "type": "string"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "ruleset_hash": {
+        "type": "string"
+      },
+      "saved": {
+        "description": "Whether this call bound a name. The binding happens BEFORE the approval is recorded, so a refused name records no approval at all.",
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "ruleset_hash",
+      "namespace",
+      "name",
+      "saved",
+      "approval",
+      "approvals",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_remove_from_team1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "Confirmation of the removal.",
-    "properties": {
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "Confirmation of the removal.",
+    "properties": {
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_review1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "properties": {
-      "claim_schema": {
-        "description": "JSON Schema for the claim dictionary.",
-        "type": "object"
-      },
-      "diagnostics": {
-        "items": {
-          "properties": {
-            "line": {
-              "type": [
-                "integer",
-                "null"
-              ]
-            },
-            "message": {
-              "type": "string"
-            },
-            "severity": {
-              "enum": [
-                "error",
-                "warning"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "severity",
-            "message"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "label": {
-        "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
-        "properties": {
-          "confidence": {
-            "enum": [
-              "high",
-              "medium",
-              "low",
-              null
-            ],
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "declined": {
-            "type": "boolean"
-          },
-          "level_one": {
-            "description": "Level-one domain id. Null only when declined.",
-            "enum": [
-              "finance",
-              "consumer_finance",
-              "capital_markets",
-              "insurance",
-              "regulatory_compliance",
-              "hr_workforce",
-              "security_access",
-              "security_classification",
-              "healthcare",
-              "legal_contracts",
-              "procurement",
-              "engineering_release",
-              "content_safety",
-              "other",
-              null
-            ],
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "level_two": {
-            "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
-            "pattern": "^l2-[0-9]{4,}$",
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "updated_at": {
-            "description": "UTC, ISO 8601.",
-            "type": "string"
-          },
-          "vocabulary_version": {
-            "example": "v1",
-            "type": "string"
-          }
-        },
-        "required": [
-          "vocabulary_version",
-          "level_one",
-          "level_two",
-          "confidence",
-          "declined",
-          "updated_at"
-        ],
-        "type": [
-          "object",
-          "null"
-        ]
-      },
-      "manifest": {
-        "properties": {
-          "claims": {
-            "items": {
-              "properties": {
-                "boolean_subtype": {
-                  "type": "string"
-                },
-                "claim": {
-                  "type": "string"
-                },
-                "context": {
-                  "type": "string"
-                },
-                "data_type": {
-                  "enum": [
-                    "boolean",
-                    "numeric",
-                    "enum"
-                  ],
-                  "type": "string"
-                },
-                "ordered": {
-                  "type": "boolean"
-                },
-                "question": {
-                  "description": "Shown to the extracting model.",
-                  "type": "string"
-                },
-                "range": {
-                  "properties": {
-                    "max": {
-                      "type": "number"
-                    },
-                    "min": {
-                      "type": "number"
-                    }
-                  },
-                  "type": "object"
-                },
-                "required": {
-                  "type": "boolean"
-                },
-                "unit": {
-                  "type": [
-                    "string",
-                    "null"
-                  ]
-                },
-                "unknown_allowed": {
-                  "const": true,
-                  "type": "boolean"
-                },
-                "unknown_sentinel": {
-                  "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
-                  "type": "string"
-                },
-                "vocabulary": {
-                  "items": {
-                    "type": "string"
-                  },
-                  "type": "array"
-                }
-              },
-              "required": [
-                "claim",
-                "data_type",
-                "question",
-                "required",
-                "unknown_allowed"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "rules": {
-            "items": {
-              "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
-              "properties": {
-                "assertions": {
-                  "items": {
-                    "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
-                    "properties": {
-                      "line": {
-                        "type": [
-                          "integer",
-                          "null"
-                        ]
-                      },
-                      "name": {
-                        "type": "string"
-                      },
-                      "source": {
-                        "type": [
-                          "string",
-                          "null"
-                        ]
-                      },
-                      "unknown_policy": {
-                        "enum": [
-                          "optimistic",
-                          "pessimistic",
-                          "neutral"
-                        ],
-                        "type": "string"
-                      }
-                    },
-                    "required": [
-                      "name",
-                      "unknown_policy"
-                    ],
-                    "type": "object"
-                  },
-                  "type": "array"
-                },
-                "rule": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "rule",
-                "assertions"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "ruleset_hash": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "ruleset_hash",
-          "claims",
-          "rules"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "review": {
-        "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
-        "type": "string"
-      },
-      "ruleset_hash": {
-        "description": "sha256 of the normalised source. This is the object key.",
-        "type": "string"
-      },
-      "source": {
-        "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
-        "type": "string"
-      },
-      "stored": {
-        "properties": {
-          "parent_hash": {
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "revision_depth": {
-            "type": "integer"
-          }
-        },
-        "type": "object"
-      },
-      "summary": {
-        "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
-        "type": "string"
-      },
-      "unbridged_units": {
-        "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
-        "items": {
-          "properties": {
-            "cause": {
-              "enum": [
-                "missing",
-                "ambiguous"
-              ],
-              "type": "string"
-            },
-            "from": {
-              "type": "string"
-            },
-            "rule": {
-              "type": "string"
-            },
-            "to": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "rule",
-            "from",
-            "to",
-            "cause"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "unit_library_hash": {
-        "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "validation_contract": {
-        "description": "Exactly what check will reject, known before submitting.",
-        "type": "object"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "ruleset_hash",
-      "source",
-      "manifest",
-      "review",
-      "summary",
-      "claim_schema",
-      "validation_contract",
-      "diagnostics",
-      "versions"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "properties": {
+      "claim_schema": {
+        "description": "JSON Schema for the claim dictionary.",
+        "type": "object"
+      },
+      "diagnostics": {
+        "items": {
+          "properties": {
+            "line": {
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "message": {
+              "type": "string"
+            },
+            "severity": {
+              "enum": [
+                "error",
+                "warning"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "severity",
+            "message"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "label": {
+        "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
+        "properties": {
+          "confidence": {
+            "enum": [
+              "high",
+              "medium",
+              "low",
+              null
+            ],
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "declined": {
+            "type": "boolean"
+          },
+          "level_one": {
+            "description": "Level-one domain id. Null only when declined.",
+            "enum": [
+              "finance",
+              "consumer_finance",
+              "capital_markets",
+              "insurance",
+              "regulatory_compliance",
+              "hr_workforce",
+              "security_access",
+              "security_classification",
+              "healthcare",
+              "legal_contracts",
+              "procurement",
+              "engineering_release",
+              "content_safety",
+              "other",
+              null
+            ],
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "level_two": {
+            "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
+            "pattern": "^l2-[0-9]{4,}$",
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "updated_at": {
+            "description": "UTC, ISO 8601.",
+            "type": "string"
+          },
+          "vocabulary_version": {
+            "example": "v1",
+            "type": "string"
+          }
+        },
+        "required": [
+          "vocabulary_version",
+          "level_one",
+          "level_two",
+          "confidence",
+          "declined",
+          "updated_at"
+        ],
+        "type": [
+          "object",
+          "null"
+        ]
+      },
+      "manifest": {
+        "properties": {
+          "claims": {
+            "items": {
+              "properties": {
+                "boolean_subtype": {
+                  "type": "string"
+                },
+                "claim": {
+                  "type": "string"
+                },
+                "context": {
+                  "type": "string"
+                },
+                "data_type": {
+                  "enum": [
+                    "boolean",
+                    "numeric",
+                    "enum"
+                  ],
+                  "type": "string"
+                },
+                "ordered": {
+                  "type": "boolean"
+                },
+                "question": {
+                  "description": "Shown to the extracting model.",
+                  "type": "string"
+                },
+                "range": {
+                  "properties": {
+                    "max": {
+                      "type": "number"
+                    },
+                    "min": {
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                },
+                "required": {
+                  "type": "boolean"
+                },
+                "unit": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "unknown_allowed": {
+                  "const": true,
+                  "type": "boolean"
+                },
+                "unknown_sentinel": {
+                  "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
+                  "type": "string"
+                },
+                "vocabulary": {
+                  "items": {
+                    "type": "string"
+                  },
+                  "type": "array"
+                }
+              },
+              "required": [
+                "claim",
+                "data_type",
+                "question",
+                "required",
+                "unknown_allowed"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "rules": {
+            "items": {
+              "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
+              "properties": {
+                "assertions": {
+                  "items": {
+                    "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
+                    "properties": {
+                      "line": {
+                        "type": [
+                          "integer",
+                          "null"
+                        ]
+                      },
+                      "name": {
+                        "type": "string"
+                      },
+                      "source": {
+                        "type": [
+                          "string",
+                          "null"
+                        ]
+                      },
+                      "unknown_policy": {
+                        "enum": [
+                          "optimistic",
+                          "pessimistic",
+                          "neutral"
+                        ],
+                        "type": "string"
+                      }
+                    },
+                    "required": [
+                      "name",
+                      "unknown_policy"
+                    ],
+                    "type": "object"
+                  },
+                  "type": "array"
+                },
+                "rule": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "rule",
+                "assertions"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "ruleset_hash": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "ruleset_hash",
+          "claims",
+          "rules"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "review": {
+        "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
+        "type": "string"
+      },
+      "ruleset_hash": {
+        "description": "sha256 of the normalised source. This is the object key.",
+        "type": "string"
+      },
+      "source": {
+        "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
+        "type": "string"
+      },
+      "stored": {
+        "properties": {
+          "parent_hash": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "revision_depth": {
+            "type": "integer"
+          }
+        },
+        "type": "object"
+      },
+      "summary": {
+        "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
+        "type": "string"
+      },
+      "unbridged_units": {
+        "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
+        "items": {
+          "properties": {
+            "cause": {
+              "enum": [
+                "missing",
+                "ambiguous"
+              ],
+              "type": "string"
+            },
+            "from": {
+              "type": "string"
+            },
+            "rule": {
+              "type": "string"
+            },
+            "to": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "rule",
+            "from",
+            "to",
+            "cause"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "unit_library_hash": {
+        "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "validation_contract": {
+        "description": "Exactly what check will reject, known before submitting.",
+        "type": "object"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "ruleset_hash",
+      "source",
+      "manifest",
+      "review",
+      "summary",
+      "claim_schema",
+      "validation_contract",
+      "diagnostics",
+      "versions"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_save_ruleset1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The saved revision: its name, hash and parent.",
-    "properties": {
-      "name": {
-        "type": "string"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "parent_hash": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "ruleset_hash": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The saved revision: its name, hash and parent.",
+    "properties": {
+      "name": {
+        "type": "string"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "parent_hash": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "ruleset_hash": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_set_team_role1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The member's role after the change.",
-    "properties": {
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "role": {
-        "type": "string"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The member's role after the change.",
+    "properties": {
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "role": {
+        "type": "string"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_team_members1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The team's members and each one's role.",
-    "properties": {
-      "members": {
-        "type": "array"
-      },
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The team's members and each one's role.",
+    "properties": {
+      "members": {
+        "type": "array"
+      },
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_unit_library1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The unit library in force, or whether one pair converts and by what factor.",
-    "properties": {
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The unit library in force, or whether one pair converts and by what factor.",
+    "properties": {
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

Changeddsail_use_workspace1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "description": "The workspace now in use.",
-    "properties": {
-      "ok": {
-        "const": true,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      },
-      "workspace": {
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "error": {
-        "properties": {
-          "actual": {
-            "type": "integer"
-          },
-          "budget": {
-            "type": "string"
-          },
-          "code": {
-            "enum": [
-              "VALIDATION_REJECTED",
-              "COMPILE_FAILED",
-              "BUDGET_EXCEEDED",
-              "RULESET_NOT_FOUND",
-              "ENGINE_ERROR",
-              "BAD_REQUEST",
-              "CREDENTIAL_REQUIRED",
-              "CREDENTIAL_INVALID",
-              "CREDENTIAL_SCOPE",
-              "EVALUATION_LIMIT",
-              "ENTITLEMENT_EXCEEDED",
-              "TIER_UNAVAILABLE"
-            ],
-            "type": "string"
-          },
-          "diagnostics": {
-            "items": {
-              "properties": {
-                "line": {
-                  "type": [
-                    "integer",
-                    "null"
-                  ]
-                },
-                "message": {
-                  "type": "string"
-                },
-                "severity": {
-                  "enum": [
-                    "error",
-                    "warning"
-                  ],
-                  "type": "string"
-                }
-              },
-              "required": [
-                "severity",
-                "message"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "docs": {
-            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
-            "format": "uri",
-            "type": "string"
-          },
-          "failure_count": {
-            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
-            "type": "integer"
-          },
-          "failures": {
-            "description": "EVERY failing field, not the first one.",
-            "items": {
-              "properties": {
-                "expected": {
-                  "type": "string"
-                },
-                "field": {
-                  "type": "string"
-                },
-                "received": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "field",
-                "expected",
-                "received"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "hint": {
-            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
-            "type": "string"
-          },
-          "limit": {
-            "type": "integer"
-          },
-          "message": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "code",
-          "message"
-        ],
-        "type": "object"
-      },
-      "ok": {
-        "const": false,
-        "type": "boolean"
-      },
-      "versions": {
-        "description": "Which engine and which wire contract produced this response.",
-        "properties": {
-          "engine": {
-            "example": "dsail-core",
-            "type": "string"
-          },
-          "engine_version": {
-            "type": "string"
-          },
-          "language_version": {
-            "description": "DSAIL language version.",
-            "type": "string"
-          },
-          "service_version": {
-            "type": "string"
-          },
-          "supported_language_versions": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "wire_version": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "engine",
-          "engine_version",
-          "language_version",
-          "service_version",
-          "wire_version"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "ok",
-      "error",
-      "versions"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "description": "The workspace now in use.",
+    "properties": {
+      "ok": {
+        "const": true,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      },
+      "workspace": {
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "error": {
+        "properties": {
+          "actual": {
+            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
+            "type": "integer"
+          },
+          "budget": {
+            "type": "string"
+          },
+          "code": {
+            "enum": [
+              "VALIDATION_REJECTED",
+              "COMPILE_FAILED",
+              "BUDGET_EXCEEDED",
+              "RULESET_NOT_FOUND",
+              "ENGINE_ERROR",
+              "ENGINE_BUSY",
+              "BAD_REQUEST",
+              "CREDENTIAL_REQUIRED",
+              "CREDENTIAL_INVALID",
+              "CREDENTIAL_SCOPE",
+              "EVALUATION_LIMIT",
+              "ENTITLEMENT_EXCEEDED",
+              "TIER_UNAVAILABLE"
+            ],
+            "type": "string"
+          },
+          "diagnostics": {
+            "items": {
+              "properties": {
+                "line": {
+                  "type": [
+                    "integer",
+                    "null"
+                  ]
+                },
+                "message": {
+                  "type": "string"
+                },
+                "severity": {
+                  "enum": [
+                    "error",
+                    "warning"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "severity",
+                "message"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "docs": {
+            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+            "format": "uri",
+            "type": "string"
+          },
+          "failure_count": {
+            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+            "type": "integer"
+          },
+          "failures": {
+            "description": "EVERY failing field, not the first one.",
+            "items": {
+              "properties": {
+                "expected": {
+                  "type": "string"
+                },
+                "field": {
+                  "type": "string"
+                },
+                "received": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "field",
+                "expected",
+                "received"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "hint": {
+            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer"
+          },
+          "message": {
+            "type": "string"
+          },
+          "retry_after_ms": {
+            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "code",
+          "message"
+        ],
+        "type": "object"
+      },
+      "ok": {
+        "const": false,
+        "type": "boolean"
+      },
+      "versions": {
+        "description": "Which engine and which wire contract produced this response.",
+        "properties": {
+          "engine": {
+            "example": "dsail-core",
+            "type": "string"
+          },
+          "engine_version": {
+            "type": "string"
+          },
+          "language_version": {
+            "description": "DSAIL language version.",
+            "type": "string"
+          },
+          "service_version": {
+            "type": "string"
+          },
+          "supported_language_versions": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "wire_version": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "engine",
+          "engine_version",
+          "language_version",
+          "service_version",
+          "wire_version"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "ok",
+      "error",
+      "versions"
+    ],
+    "type": "object"
+  }
+]

20 tool updatesSep 21, 2026

Changeddsail_add_unit_converter6 fields changed

addedInput schema / properties / attribution / description

Added value: +"Who supplied the factor, or the document it comes from. Recorded beside the converter, outside the hashed library."

addedInput schema / properties / factor / description

Added value: +"The multiplier a person supplied: one `from_unit` equals `factor` `to_unit`. Never a value recalled from training — a rate is a policy decision."

addedInput schema / properties / from_unit / description
```
Added value: +"The unit converted from (`EUR`)."
```

addedInput schema / properties / offset / description

Added value: +"Added after multiplying, for affine conversions such as temperatures. Default 0."

addedInput schema / properties / to_unit / description
```
Added value: +"The unit converted to (`USD`)."
```

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The updated unit library. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "The unit library after the change, with its new hash and a warning about approvals recorded against the previous one.",
+      "properties": {
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "unit_library_hash": {
+          "type": "string"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        },
+        "warning": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_check5 fields changed

addedInput schema / properties / claims / description

Added value: +"The claim dictionary to evaluate: one entry per declared claim, keyed by claim name, values as the prompt pack specifies (`\"120 USD\"`, `true`, `\"unknown\"` for a value the extractor could not determine). A JSON object, or the same object as a JSON string."

addedInput schema / properties / label / description

Added value: +"Optional application-domain label: `{\"topic\": \"<a few words on what the policy governs>\"}`, or `{\"declined\": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal."

addedInput schema / properties / ruleset_hash / description

Added value: +"The content hash of an already compiled ruleset (from `dsail_compile` or a saved name). Give this OR `source`, not both."

addedInput schema / properties / source / description

Added value: +"DSAIL source text, byte for byte as compiled. Give this OR `ruleset_hash`; prefer the hash for anything already compiled."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — with a counterexample where an assertion is violated. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
+      "properties": {
+        "claims": {
+          "properties": {
+            "bound": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "quantities": {
+              "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
+              "items": {
+                "properties": {
+                  "bound": {
+                    "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
+                    "type": "string"
+                  },
+                  "claim": {
+                    "type": "string"
+                  },
+                  "conversion": {
+                    "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
+                    "properties": {
+                      "by": {
+                        "const": "engine",
+                        "type": "string"
+                      },
+                      "factor": {
+                        "type": "number"
+                      },
+                      "from": {
+                        "type": "string"
+                      },
+                      "status": {
+                        "type": "string"
+                      },
+                      "to": {
+                        "type": "string"
+                      }
+                    },
+                    "required": [
+                      "from",
+                      "to",
+                      "by",
+                      "status"
+                    ],
+                    "type": "object"
+                  },
+                  "measured_in": {
+                    "description": "The claim's declared @unit, if any.",
+                    "type": [
+                      "string",
+                      "null"
+                    ]
+                  },
+                  "submitted": {
+                    "description": "The value as the caller sent it.",
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "claim",
+                  "submitted",
+                  "bound",
+                  "measured_in"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "unbound": {
+              "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "bound",
+            "unbound"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "rules": {
+          "items": {
+            "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
+            "properties": {
+              "assertions": {
+                "items": {
+                  "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
+                  "properties": {
+                    "check": {
+                      "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
+                      "enum": [
+                        "TRUE",
+                        "FALSE",
+                        "UNKNOWN",
+                        "AMBIGUOUS"
+                      ],
+                      "type": "string"
+                    },
+                    "counterexample": {
+                      "description": "The assignment that violates this assertion, from the solver. Present only on FALSE: for an UNKNOWN the solver's witness is merely a model in which the assertion could fail, and publishing it would state a determination this service did not make.",
+                      "type": "string"
+                    },
+                    "name": {
+                      "type": "string"
+                    },
+                    "reason_unknown": {
+                      "type": "string"
+                    },
+                    "source": {
+                      "type": [
+                        "string",
+                        "null"
+                      ]
+                    },
+                    "unbridged_units": {
+                      "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
+                      "items": {
+                        "properties": {
+                          "from": {
+                            "type": "string"
+                          },
+                          "to": {
+                            "type": "string"
+                          }
+                        },
+                        "required": [
+                          "from",
+                          "to"
+                        ],
+                        "type": "object"
+                      },
+                      "type": "array"
+                    },
+                    "unknown_policy": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "name",
+                    "check"
+                  ],
+                  "type": "object"
+                },
+                "type": "array"
+              },
+              "rule": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "rule",
+              "assertions"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "ruleset_hash": {
+          "type": "string"
+        },
+        "unit_library_hash": {
+          "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "ruleset_hash",
+        "unit_library_hash",
+        "rules",
+        "claims",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_compile4 fields changed

addedInput schema / properties / label / description

Added value: +"Optional application-domain label: `{\"topic\": \"<a few words on what the policy governs>\"}`, or `{\"declined\": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal."

addedInput schema / properties / parent_hash / description

Added value: +"The hash of the revision this one supersedes, when editing a saved ruleset. Links the two so the review can show a diff; omit for a new ruleset."

addedInput schema / properties / source / description

Added value: +"The DSAIL source text to compile: `declare` lines for each claim with their `// @ask`, `// @unit` and `// @range` annotations, then `assert` rules. Written only after the user has confirmed the English summary."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The compiled ruleset: its content hash, the claim manifest, review text and diagnostics. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "properties": {
+        "claim_schema": {
+          "description": "JSON Schema for the claim dictionary.",
+          "type": "object"
+        },
+        "diagnostics": {
+          "items": {
+            "properties": {
+              "line": {
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "message": {
+                "type": "string"
+              },
+              "severity": {
+                "enum": [
+                  "error",
+                  "warning"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "severity",
+              "message"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "label": {
+          "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
+          "properties": {
+            "confidence": {
+              "enum": [
+                "high",
+                "medium",
+                "low",
+                null
+              ],
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "declined": {
+              "type": "boolean"
+            },
+            "level_one": {
+              "description": "Level-one domain id. Null only when declined.",
+              "enum": [
+                "finance",
+                "consumer_finance",
+                "capital_markets",
+                "insurance",
+                "regulatory_compliance",
+                "hr_workforce",
+                "security_access",
+                "security_classification",
+                "healthcare",
+                "legal_contracts",
+                "procurement",
+                "engineering_release",
+                "content_safety",
+                "other",
+                null
+              ],
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "level_two": {
+              "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
+              "pattern": "^l2-[0-9]{4,}$",
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "updated_at": {
+              "description": "UTC, ISO 8601.",
+              "type": "string"
+            },
+            "vocabulary_version": {
+              "example": "v1",
+              "type": "string"
+            }
+          },
+          "required": [
+            "vocabulary_version",
+            "level_one",
+            "level_two",
+            "confidence",
+            "declined",
+            "updated_at"
+          ],
+          "type": [
+            "object",
+            "null"
+          ]
+        },
+        "manifest": {
+          "properties": {
+            "claims": {
+              "items": {
+                "properties": {
+                  "boolean_subtype": {
+                    "type": "string"
+                  },
+                  "claim": {
+                    "type": "string"
+                  },
+                  "context": {
+                    "type": "string"
+                  },
+                  "data_type": {
+                    "enum": [
+                      "boolean",
+                      "numeric",
+                      "enum"
+                    ],
+                    "type": "string"
+                  },
+                  "ordered": {
+                    "type": "boolean"
+                  },
+                  "question": {
+                    "description": "Shown to the extracting model.",
+                    "type": "string"
+                  },
+                  "range": {
+                    "properties": {
+                      "max": {
+                        "type": "number"
+                      },
+                      "min": {
+                        "type": "number"
+                      }
+                    },
+                    "type": "object"
+                  },
+                  "required": {
+                    "type": "boolean"
+                  },
+                  "unit": {
+                    "type": [
+                      "string",
+                      "null"
+                    ]
+                  },
+                  "unknown_allowed": {
+                    "const": true,
+                    "type": "boolean"
+                  },
+                  "unknown_sentinel": {
+                    "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
+                    "type": "string"
+                  },
+                  "vocabulary": {
+                    "items": {
+                      "type": "string"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "claim",
+                  "data_type",
+                  "question",
+                  "required",
+                  "unknown_allowed"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "rules": {
+              "items": {
+                "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
+                "properties": {
+                  "assertions": {
+                    "items": {
+                      "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
+                      "properties": {
+                        "line": {
+                          "type": [
+                            "integer",
+                            "null"
+                          ]
+                        },
+                        "name": {
+                          "type": "string"
+                        },
+                        "source": {
+                          "type": [
+                            "string",
+                            "null"
+                          ]
+                        },
+                        "unknown_policy": {
+                          "enum": [
+                            "optimistic",
+                            "pessimistic",
+                            "neutral"
+                          ],
+                          "type": "string"
+                        }
+                      },
+                      "required": [
+                        "name",
+                        "unknown_policy"
+                      ],
+                      "type": "object"
+                    },
+                    "type": "array"
+                  },
+                  "rule": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "rule",
+                  "assertions"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "ruleset_hash": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "ruleset_hash",
+            "claims",
+            "rules"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "review": {
+          "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
+          "type": "string"
+        },
+        "ruleset_hash": {
+          "description": "sha256 of the normalised source. This is the object key.",
+          "type": "string"
+        },
+        "source": {
+          "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
+          "type": "string"
+        },
+        "stored": {
+          "properties": {
+            "parent_hash": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "revision_depth": {
+              "type": "integer"
+            }
+          },
+          "type": "object"
+        },
+        "summary": {
+          "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
+          "type": "string"
+        },
+        "unbridged_units": {
+          "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
+          "items": {
+            "properties": {
+              "cause": {
+                "enum": [
+                  "missing",
+                  "ambiguous"
+                ],
+                "type": "string"
+              },
+              "from": {
+                "type": "string"
+              },
+              "rule": {
+                "type": "string"
+              },
+              "to": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "rule",
+              "from",
+              "to",
+              "cause"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "unit_library_hash": {
+          "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "validation_contract": {
+          "description": "Exactly what check will reject, known before submitting.",
+          "type": "object"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "ruleset_hash",
+        "source",
+        "manifest",
+        "review",
+        "summary",
+        "claim_schema",
+        "validation_contract",
+        "diagnostics",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_copy_ruleset5 fields changed

addedInput schema / properties / destination / description

Added value: +"The workspace to copy into: a team's name or id, or `personal`."

addedInput schema / properties / name / description

Added value: +"The saved ruleset to copy, by name."

addedInput schema / properties / new_name / description

Added value: +"A different name for the copy, when the destination already uses `name`."

addedInput schema / properties / source / description

Added value: +"The workspace to copy from; defaults to the workspace in use."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The copy. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "The copy as saved in the destination workspace.",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "ruleset_hash": {
+          "type": "string"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_create_team2 fields changed

addedInput schema / properties / name / description

Added value: +"A label for the team, shown to its members. Not an identifier; need not be unique."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The new team. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "The new team's id and the administrator's first invitation link.",
+      "properties": {
+        "invitation": {
+          "type": [
+            "string",
+            "object",
+            "null"
+          ]
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "team_id": {
+          "type": "string"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_get_account_status1 field changed

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The account's status. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "This account's tier, usage against its allowance, and the terms version that governs it.",
+      "properties": {
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "terms": {
+          "type": "object"
+        },
+        "tier": {
+          "type": "string"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_get_prompt_pack3 fields changed

addedInput schema / properties / ruleset_hash / description

Added value: +"The content hash of an already compiled ruleset (from `dsail_compile` or a saved name). Give this OR `source`, not both."

addedInput schema / properties / source / description

Added value: +"DSAIL source text, byte for byte as compiled. Give this OR `ruleset_hash`; prefer the hash for anything already compiled."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "One extraction prompt per claim, the claim JSON schema and the validation rules. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "properties": {
+        "assembly_notes": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "claim_schema": {
+          "type": "object"
+        },
+        "integrity_rule": {
+          "type": "string"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "prompts": {
+          "items": {
+            "properties": {
+              "answer_format": {
+                "type": "string"
+              },
+              "claim": {
+                "type": "string"
+              },
+              "context": {
+                "type": "string"
+              },
+              "data_type": {
+                "type": "string"
+              },
+              "ordered_vocabulary": {
+                "description": "True when the enum was declared ordered, so its members compare with < and >.",
+                "type": "boolean"
+              },
+              "question": {
+                "type": "string"
+              },
+              "range": {
+                "type": "object"
+              },
+              "undetermined_value": {
+                "description": "The literal to send when this claim could not be determined: \"unknown\", or null where the vocabulary itself contains \"unknown\".",
+                "type": "string"
+              },
+              "unit": {
+                "type": "string"
+              },
+              "unknown_rule": {
+                "type": "string"
+              },
+              "vocabulary": {
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              }
+            },
+            "required": [
+              "claim",
+              "data_type",
+              "question",
+              "answer_format",
+              "unknown_rule"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "ruleset_hash": {
+          "type": "string"
+        },
+        "validation_contract": {
+          "type": "object"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "ruleset_hash",
+        "integrity_rule",
+        "prompts",
+        "claim_schema",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_invite_to_team3 fields changed

addedInput schema / properties / email / description

Added value: +"The colleague's email address. Only that address can accept the invitation, and only once."

addedInput schema / properties / team_id / description

Added value: +"The team's id (`team-…`), as returned by `dsail_create_team` or `dsail_list_workspaces`."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The invitation. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "A single-use invitation link for the administrator to pass on.",
+      "properties": {
+        "invitation": {
+          "type": [
+            "string",
+            "object"
+          ]
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_issue_api_key2 fields changed

addedInput schema / properties / label / description

Added value: +"Optional label naming what the key is for (a service, a repository), shown in listings."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The new credential, shown once. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "An evaluation credential, minted on request with no human gate (TJP-621). The token is shown here and nowhere else — the service stores only its hash. Send it as the x-jaxon-credential header. It is scoped to compile, check and the prompt pack, capped per day and over its lifetime, and expires; every response it produces carries x-jaxon-credential-grade: evaluation.",
+      "properties": {
+        "credential": {
+          "description": "The bearer token. Store it; it is not retrievable again.",
+          "type": "string"
+        },
+        "credential_id": {
+          "description": "Names the credential without unlocking anything; safe to log.",
+          "type": "string"
+        },
+        "expires_at": {
+          "description": "ISO 8601, UTC.",
+          "type": "string"
+        },
+        "grade": {
+          "enum": [
+            "evaluation"
+          ],
+          "type": "string"
+        },
+        "header": {
+          "const": "x-jaxon-credential",
+          "type": "string"
+        },
+        "limits": {
+          "properties": {
+            "calls_per_day": {
+              "type": "integer"
+            },
+            "calls_total": {
+              "type": "integer"
+            },
+            "ttl_days": {
+              "type": "integer"
+            }
+          },
+          "required": [
+            "ttl_days",
+            "calls_per_day",
+            "calls_total"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "scope": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "upgrade": {
+          "type": "string"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "credential",
+        "credential_id",
+        "grade",
+        "expires_at",
+        "limits",
+        "header",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_list_rulesets1 field changed

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "Every named ruleset in the current workspace, with counts and approval state. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "Every named ruleset saved for this connection, with enough per row to render a library without a second call.",
+      "properties": {
+        "namespace": {
+          "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
+          "type": "string"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "rulesets": {
+          "items": {
+            "properties": {
+              "approval_count": {
+                "type": "integer"
+              },
+              "bound_at": {
+                "description": "When this name last started pointing at these bytes — the ruleset's last-changed time.",
+                "type": "string"
+              },
+              "claim_count": {
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "compiles": {
+                "description": "False when the stored source no longer compiles under this engine, or its bytes are gone. The row is still returned — a listing a single unreadable entry could hide is worse than one that says so — and the counts are null.",
+                "type": "boolean"
+              },
+              "name": {
+                "description": "The primary handle.",
+                "type": "string"
+              },
+              "revision_depth": {
+                "type": "integer"
+              },
+              "rule_count": {
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "ruleset_hash": {
+                "type": "string"
+              },
+              "summary": {
+                "description": "One sentence: what this ruleset asks and what it can decide. Derived per row from the manifest, never stored beside it.",
+                "type": "string"
+              }
+            },
+            "required": [
+              "name",
+              "ruleset_hash",
+              "bound_at",
+              "revision_depth",
+              "approval_count",
+              "compiles",
+              "summary",
+              "claim_count",
+              "rule_count"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "namespace",
+        "rulesets",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_list_workspaces1 field changed

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The workspaces. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "Every workspace this user may work in, which one is current, and whether a signed-in person is behind the call.",
+      "properties": {
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "remedy": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "signed_in": {
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        },
+        "workspaces": {
+          "type": "array"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_load_ruleset2 fields changed

addedInput schema / properties / name / description

Added value: +"The saved ruleset's name, exactly as `dsail_list_rulesets` reports it."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The stored ruleset exactly as saved: source, manifest, approvals. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "A stored ruleset, in the shape a compile of it would return plus what the store knows about it. This is how a saved ruleset is SHOWN — re-compiling remembered source produces a different object the moment the two disagree, and an approval follows the stored bytes.",
+      "properties": {
+        "approvals": {
+          "items": {
+            "properties": {
+              "approved_at": {
+                "description": "UTC, ISO 8601.",
+                "type": "string"
+              },
+              "approver": {
+                "type": "string"
+              },
+              "hash": {
+                "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
+                "type": "string"
+              },
+              "note": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              }
+            },
+            "required": [
+              "hash",
+              "approver",
+              "approved_at"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "claim_schema": {
+          "description": "JSON Schema for the claim dictionary.",
+          "type": "object"
+        },
+        "diagnostics": {
+          "items": {
+            "properties": {
+              "line": {
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "message": {
+                "type": "string"
+              },
+              "severity": {
+                "enum": [
+                  "error",
+                  "warning"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "severity",
+              "message"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "label": {
+          "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
+          "properties": {
+            "confidence": {
+              "enum": [
+                "high",
+                "medium",
+                "low",
+                null
+              ],
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "declined": {
+              "type": "boolean"
+            },
+            "level_one": {
+              "description": "Level-one domain id. Null only when declined.",
+              "enum": [
+                "finance",
+                "consumer_finance",
+                "capital_markets",
+                "insurance",
+                "regulatory_compliance",
+                "hr_workforce",
+                "security_access",
+                "security_classification",
+                "healthcare",
+                "legal_contracts",
+                "procurement",
+                "engineering_release",
+                "content_safety",
+                "other",
+                null
+              ],
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "level_two": {
+              "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
+              "pattern": "^l2-[0-9]{4,}$",
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "updated_at": {
+              "description": "UTC, ISO 8601.",
+              "type": "string"
+            },
+            "vocabulary_version": {
+              "example": "v1",
+              "type": "string"
+            }
+          },
+          "required": [
+            "vocabulary_version",
+            "level_one",
+            "level_two",
+            "confidence",
+            "declined",
+            "updated_at"
+          ],
+          "type": [
+            "object",
+            "null"
+          ]
+        },
+        "manifest": {
+          "properties": {
+            "claims": {
+              "items": {
+                "properties": {
+                  "boolean_subtype": {
+                    "type": "string"
+                  },
+                  "claim": {
+                    "type": "string"
+                  },
+                  "context": {
+                    "type": "string"
+                  },
+                  "data_type": {
+                    "enum": [
+                      "boolean",
+                      "numeric",
+                      "enum"
+                    ],
+                    "type": "string"
+                  },
+                  "ordered": {
+                    "type": "boolean"
+                  },
+                  "question": {
+                    "description": "Shown to the extracting model.",
+                    "type": "string"
+                  },
+                  "range": {
+                    "properties": {
+                      "max": {
+                        "type": "number"
+                      },
+                      "min": {
+                        "type": "number"
+                      }
+                    },
+                    "type": "object"
+                  },
+                  "required": {
+                    "type": "boolean"
+                  },
+                  "unit": {
+                    "type": [
+                      "string",
+                      "null"
+                    ]
+                  },
+                  "unknown_allowed": {
+                    "const": true,
+                    "type": "boolean"
+                  },
+                  "unknown_sentinel": {
+                    "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
+                    "type": "string"
+                  },
+                  "vocabulary": {
+                    "items": {
+                      "type": "string"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "claim",
+                  "data_type",
+                  "question",
+                  "required",
+                  "unknown_allowed"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "rules": {
+              "items": {
+                "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
+                "properties": {
+                  "assertions": {
+                    "items": {
+                      "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
+                      "properties": {
+                        "line": {
+                          "type": [
+                            "integer",
+                            "null"
+                          ]
+                        },
+                        "name": {
+                          "type": "string"
+                        },
+                        "source": {
+                          "type": [
+                            "string",
+                            "null"
+                          ]
+                        },
+                        "unknown_policy": {
+                          "enum": [
+                            "optimistic",
+                            "pessimistic",
+                            "neutral"
+                          ],
+                          "type": "string"
+                        }
+                      },
+                      "required": [
+                        "name",
+                        "unknown_policy"
+                      ],
+                      "type": "object"
+                    },
+                    "type": "array"
+                  },
+                  "rule": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "rule",
+                  "assertions"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "ruleset_hash": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "ruleset_hash",
+            "claims",
+            "rules"
+          ],
+          "type": "object"
+        },
+        "name": {
+          "description": "The name that was asked for.",
+          "type": "string"
+        },
+        "namespace": {
+          "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
+          "type": "string"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "review": {
+          "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
+          "type": "string"
+        },
+        "revision_chain": {
+          "description": "This hash, then its parent, back to the root.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "ruleset_hash": {
+          "description": "sha256 of the normalised source. This is the object key.",
+          "type": "string"
+        },
+        "source": {
+          "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
+          "type": "string"
+        },
+        "stored": {
+          "properties": {
+            "parent_hash": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "revision_depth": {
+              "type": "integer"
+            }
+          },
+          "type": "object"
+        },
+        "summary": {
+          "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
+          "type": "string"
+        },
+        "unbridged_units": {
+          "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
+          "items": {
+            "properties": {
+              "cause": {
+                "enum": [
+                  "missing",
+                  "ambiguous"
+                ],
+                "type": "string"
+              },
+              "from": {
+                "type": "string"
+              },
+              "rule": {
+                "type": "string"
+              },
+              "to": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "rule",
+              "from",
+              "to",
+              "cause"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "unit_library_hash": {
+          "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "validation_contract": {
+          "description": "Exactly what check will reject, known before submitting.",
+          "type": "object"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "namespace",
+        "name",
+        "ruleset_hash",
+        "source",
+        "manifest",
+        "revision_chain",
+        "approvals",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_record_approval6 fields changed

addedInput schema / properties / approver / description

Added value: +"Who approved, as they wish to be recorded (a name or an email address)."

addedInput schema / properties / label / description

Added value: +"Optional application-domain label: `{\"topic\": \"<a few words on what the policy governs>\"}`, or `{\"declined\": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal."

addedInput schema / properties / name / description

Added value: +"The name to save the ruleset under before approving, when it is not saved yet. Approving saves first, so an approved hash is always reachable afterwards."

addedInput schema / properties / note / description

Added value: +"Optional free-text note recorded beside the approval."

addedInput schema / properties / ruleset_hash / description

Added value: +"The exact content hash the person approved. Approval binds to this hash only; a later revision needs its own."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The approval as recorded, bound to the exact hash. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "properties": {
+        "approval": {
+          "properties": {
+            "approved_at": {
+              "description": "UTC, ISO 8601.",
+              "type": "string"
+            },
+            "approver": {
+              "type": "string"
+            },
+            "hash": {
+              "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
+              "type": "string"
+            },
+            "note": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "hash",
+            "approver",
+            "approved_at"
+          ],
+          "type": "object"
+        },
+        "approvals": {
+          "description": "Every approval on this hash, including the new one.",
+          "items": {
+            "properties": {
+              "approved_at": {
+                "description": "UTC, ISO 8601.",
+                "type": "string"
+              },
+              "approver": {
+                "type": "string"
+              },
+              "hash": {
+                "description": "The exact bytes signed for. An approval follows the hash, never a name: a later revision is not covered by it.",
+                "type": "string"
+              },
+              "note": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              }
+            },
+            "required": [
+              "hash",
+              "approver",
+              "approved_at"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "label": {
+          "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
+          "properties": {
+            "confidence": {
+              "enum": [
+                "high",
+                "medium",
+                "low",
+                null
+              ],
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "declined": {
+              "type": "boolean"
+            },
+            "level_one": {
+              "description": "Level-one domain id. Null only when declined.",
+              "enum": [
+                "finance",
+                "consumer_finance",
+                "capital_markets",
+                "insurance",
+                "regulatory_compliance",
+                "hr_workforce",
+                "security_access",
+                "security_classification",
+                "healthcare",
+                "legal_contracts",
+                "procurement",
+                "engineering_release",
+                "content_safety",
+                "other",
+                null
+              ],
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "level_two": {
+              "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
+              "pattern": "^l2-[0-9]{4,}$",
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "updated_at": {
+              "description": "UTC, ISO 8601.",
+              "type": "string"
+            },
+            "vocabulary_version": {
+              "example": "v1",
+              "type": "string"
+            }
+          },
+          "required": [
+            "vocabulary_version",
+            "level_one",
+            "level_two",
+            "confidence",
+            "declined",
+            "updated_at"
+          ],
+          "type": [
+            "object",
+            "null"
+          ]
+        },
+        "name": {
+          "description": "The name these bytes are saved under after this call. Null only when none was supplied and none was already bound.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "namespace": {
+          "description": "Service-internal scope identifier. For clients, not for display: never show this to a person, who identifies a ruleset by name.",
+          "type": "string"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "ruleset_hash": {
+          "type": "string"
+        },
+        "saved": {
+          "description": "Whether this call bound a name. The binding happens BEFORE the approval is recorded, so a refused name records no approval at all.",
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "ruleset_hash",
+        "namespace",
+        "name",
+        "saved",
+        "approval",
+        "approvals",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_remove_from_team3 fields changed

addedInput schema / properties / member / description

Added value: +"The member, by the email address they signed in with."

addedInput schema / properties / team_id / description

Added value: +"The team's id (`team-…`), as returned by `dsail_create_team` or `dsail_list_workspaces`."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The removal. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "Confirmation of the removal.",
+      "properties": {
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_review2 fields changed

addedInput schema / properties / ruleset_hash / description

Added value: +"The content hash of the compiled ruleset to show, from `dsail_compile`."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The compiled ruleset for review, rendered as a widget where the client supports one. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "properties": {
+        "claim_schema": {
+          "description": "JSON Schema for the claim dictionary.",
+          "type": "object"
+        },
+        "diagnostics": {
+          "items": {
+            "properties": {
+              "line": {
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "message": {
+                "type": "string"
+              },
+              "severity": {
+                "enum": [
+                  "error",
+                  "warning"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "severity",
+              "message"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "label": {
+          "description": "The ruleset's stored application-domain label (TJP-642), as ids under `vocabulary_version`. Null when the ruleset carries none, or when this account has labeling disabled. A label never alters a result; the level-two proposal text a caller sent is matched and dropped, never stored or returned.",
+          "properties": {
+            "confidence": {
+              "enum": [
+                "high",
+                "medium",
+                "low",
+                null
+              ],
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "declined": {
+              "type": "boolean"
+            },
+            "level_one": {
+              "description": "Level-one domain id. Null only when declined.",
+              "enum": [
+                "finance",
+                "consumer_finance",
+                "capital_markets",
+                "insurance",
+                "regulatory_compliance",
+                "hr_workforce",
+                "security_access",
+                "security_classification",
+                "healthcare",
+                "legal_contracts",
+                "procurement",
+                "engineering_release",
+                "content_safety",
+                "other",
+                null
+              ],
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "level_two": {
+              "description": "Level-two term id, from GET /v1/vocabulary. Null when the proposal matched no published term (the proposal was counted toward promotion instead) or none was offered.",
+              "pattern": "^l2-[0-9]{4,}$",
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "updated_at": {
+              "description": "UTC, ISO 8601.",
+              "type": "string"
+            },
+            "vocabulary_version": {
+              "example": "v1",
+              "type": "string"
+            }
+          },
+          "required": [
+            "vocabulary_version",
+            "level_one",
+            "level_two",
+            "confidence",
+            "declined",
+            "updated_at"
+          ],
+          "type": [
+            "object",
+            "null"
+          ]
+        },
+        "manifest": {
+          "properties": {
+            "claims": {
+              "items": {
+                "properties": {
+                  "boolean_subtype": {
+                    "type": "string"
+                  },
+                  "claim": {
+                    "type": "string"
+                  },
+                  "context": {
+                    "type": "string"
+                  },
+                  "data_type": {
+                    "enum": [
+                      "boolean",
+                      "numeric",
+                      "enum"
+                    ],
+                    "type": "string"
+                  },
+                  "ordered": {
+                    "type": "boolean"
+                  },
+                  "question": {
+                    "description": "Shown to the extracting model.",
+                    "type": "string"
+                  },
+                  "range": {
+                    "properties": {
+                      "max": {
+                        "type": "number"
+                      },
+                      "min": {
+                        "type": "number"
+                      }
+                    },
+                    "type": "object"
+                  },
+                  "required": {
+                    "type": "boolean"
+                  },
+                  "unit": {
+                    "type": [
+                      "string",
+                      "null"
+                    ]
+                  },
+                  "unknown_allowed": {
+                    "const": true,
+                    "type": "boolean"
+                  },
+                  "unknown_sentinel": {
+                    "description": "Present only when this claim's own vocabulary contains a member spelled like the sentinel. Then the string means that member and this names the value that means undetermined (null).",
+                    "type": "string"
+                  },
+                  "vocabulary": {
+                    "items": {
+                      "type": "string"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "claim",
+                  "data_type",
+                  "question",
+                  "required",
+                  "unknown_allowed"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "rules": {
+              "items": {
+                "description": "One rule, with the assertions it states. A rule is the unit a policy is written in; an assertion is the unit the engine answers, and one rule may state several. A ruleset compiled here is a single DSAIL source and the grammar has no grouping construct, so today every rule holds exactly one assertion and carries its name — read results through this level anyway and a rule that states more costs you nothing.",
+                "properties": {
+                  "assertions": {
+                    "items": {
+                      "description": "One assertion a rule states. The engine answers per assertion, so this is the unit a check reports on.",
+                      "properties": {
+                        "line": {
+                          "type": [
+                            "integer",
+                            "null"
+                          ]
+                        },
+                        "name": {
+                          "type": "string"
+                        },
+                        "source": {
+                          "type": [
+                            "string",
+                            "null"
+                          ]
+                        },
+                        "unknown_policy": {
+                          "enum": [
+                            "optimistic",
+                            "pessimistic",
+                            "neutral"
+                          ],
+                          "type": "string"
+                        }
+                      },
+                      "required": [
+                        "name",
+                        "unknown_policy"
+                      ],
+                      "type": "object"
+                    },
+                    "type": "array"
+                  },
+                  "rule": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "rule",
+                  "assertions"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "ruleset_hash": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "ruleset_hash",
+            "claims",
+            "rules"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "review": {
+          "description": "A plain-text rendering of what this ruleset asks and decides, for a person about to approve it. Derived from the manifest on every compile, never stored, so it cannot drift from the contract a caller was handed.",
+          "type": "string"
+        },
+        "ruleset_hash": {
+          "description": "sha256 of the normalised source. This is the object key.",
+          "type": "string"
+        },
+        "source": {
+          "description": "The normalised DSAIL source that hashed to `ruleset_hash`, so a caller that only ever compiles has something to show or diff without a separate load-by-name call.",
+          "type": "string"
+        },
+        "stored": {
+          "properties": {
+            "parent_hash": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "revision_depth": {
+              "type": "integer"
+            }
+          },
+          "type": "object"
+        },
+        "summary": {
+          "description": "The same thing in one sentence, for a row in a list rather than a page a person reads.",
+          "type": "string"
+        },
+        "unbridged_units": {
+          "description": "Unit pairs this ruleset compares that no loaded converter bridges, attributed by the engine to the rule that cannot be lowered. Each one answers UNKNOWN for every claim dictionary until a converter is added.",
+          "items": {
+            "properties": {
+              "cause": {
+                "enum": [
+                  "missing",
+                  "ambiguous"
+                ],
+                "type": "string"
+              },
+              "from": {
+                "type": "string"
+              },
+              "rule": {
+                "type": "string"
+              },
+              "to": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "rule",
+              "from",
+              "to",
+              "cause"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "unit_library_hash": {
+          "description": "The project unit library this compile read. Half of a result's provenance; null selects the six built-in standards.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "validation_contract": {
+          "description": "Exactly what check will reject, known before submitting.",
+          "type": "object"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "ruleset_hash",
+        "source",
+        "manifest",
+        "review",
+        "summary",
+        "claim_schema",
+        "validation_contract",
+        "diagnostics",
+        "versions"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_save_ruleset5 fields changed

addedInput schema / properties / label / description

Added value: +"Optional application-domain label: `{\"topic\": \"<a few words on what the policy governs>\"}`, or `{\"declined\": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal."

addedInput schema / properties / name / description

Added value: +"The name to save under, in the current workspace. Saving over an existing name creates a new revision with the previous one as its parent; nothing is edited in place."

addedInput schema / properties / parent_hash / description

Added value: +"The hash of the revision this one supersedes, when editing a saved ruleset. Links the two so the review can show a diff; omit for a new ruleset."

addedInput schema / properties / source / description

Added value: +"The DSAIL source text to save, byte for byte as it compiled."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The saved revision. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "The saved revision: its name, hash and parent.",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "parent_hash": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "ruleset_hash": {
+          "type": "string"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_set_team_role4 fields changed

addedInput schema / properties / member / description

Added value: +"The member, by the email address they signed in with."

addedInput schema / properties / role / description

Added value: +"`admin` (may invite, remove and promote) or `member` (reads and writes the library)."

addedInput schema / properties / team_id / description

Added value: +"The team's id (`team-…`), as returned by `dsail_create_team` or `dsail_list_workspaces`."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The role change. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "The member's role after the change.",
+      "properties": {
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "role": {
+          "type": "string"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_team_members2 fields changed

addedInput schema / properties / team_id / description

Added value: +"The team's id (`team-…`), as returned by `dsail_create_team` or `dsail_list_workspaces`."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The membership. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "The team's members and each one's role.",
+      "properties": {
+        "members": {
+          "type": "array"
+        },
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_unit_library3 fields changed

addedInput schema / properties / from_unit / description

Added value: +"A unit symbol (`EUR`, `km`, `mo`). Give both `from_unit` and `to_unit` to ask whether that pair converts; give neither to list the whole library."

addedInput schema / properties / to_unit / description

Added value: +"The unit to convert into; paired with `from_unit`."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The unit library, or one conversion. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "The unit library in force, or whether one pair converts and by what factor.",
+      "properties": {
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

Changeddsail_use_workspace2 fields changed

addedInput schema / properties / workspace / description

Added value: +"A team's name or id, or `personal` for the user's own workspace."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "description": "The current workspace. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
+  "oneOf": [
+    {
+      "description": "The workspace now in use.",
+      "properties": {
+        "ok": {
+          "const": true,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        },
+        "workspace": {
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "error": {
+          "properties": {
+            "actual": {
+              "type": "integer"
+            },
+            "budget": {
+              "type": "string"
+            },
+            "code": {
+              "enum": [
+                "VALIDATION_REJECTED",
+                "COMPILE_FAILED",
+                "BUDGET_EXCEEDED",
+                "RULESET_NOT_FOUND",
+                "ENGINE_ERROR",
+                "BAD_REQUEST",
+                "CREDENTIAL_REQUIRED",
+                "CREDENTIAL_INVALID",
+                "CREDENTIAL_SCOPE",
+                "EVALUATION_LIMIT",
+                "ENTITLEMENT_EXCEEDED",
+                "TIER_UNAVAILABLE"
+              ],
+              "type": "string"
+            },
+            "diagnostics": {
+              "items": {
+                "properties": {
+                  "line": {
+                    "type": [
+                      "integer",
+                      "null"
+                    ]
+                  },
+                  "message": {
+                    "type": "string"
+                  },
+                  "severity": {
+                    "enum": [
+                      "error",
+                      "warning"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "severity",
+                  "message"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "docs": {
+              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
+              "format": "uri",
+              "type": "string"
+            },
+            "failure_count": {
+              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
+              "type": "integer"
+            },
+            "failures": {
+              "description": "EVERY failing field, not the first one.",
+              "items": {
+                "properties": {
+                  "expected": {
+                    "type": "string"
+                  },
+                  "field": {
+                    "type": "string"
+                  },
+                  "received": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "field",
+                  "expected",
+                  "received"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "hint": {
+              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
+              "type": "string"
+            },
+            "limit": {
+              "type": "integer"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        "ok": {
+          "const": false,
+          "type": "boolean"
+        },
+        "versions": {
+          "description": "Which engine and which wire contract produced this response.",
+          "properties": {
+            "engine": {
+              "example": "dsail-core",
+              "type": "string"
+            },
+            "engine_version": {
+              "type": "string"
+            },
+            "language_version": {
+              "description": "DSAIL language version.",
+              "type": "string"
+            },
+            "service_version": {
+              "type": "string"
+            },
+            "supported_language_versions": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "wire_version": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "engine",
+            "engine_version",
+            "language_version",
+            "service_version",
+            "wire_version"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "ok",
+        "error",
+        "versions"
+      ],
+      "type": "object"
+    }
+  ],
+  "type": "object"
+}

20 tool updatesSep 20, 2026
- First observeddsail_add_unit_converter
- First observeddsail_check
- First observeddsail_compile
- First observeddsail_copy_ruleset
- First observeddsail_create_team
- First observeddsail_get_account_status
- First observeddsail_get_prompt_pack
- First observeddsail_invite_to_team
- First observeddsail_issue_api_key
- First observeddsail_list_rulesets
- First observeddsail_list_workspaces
- First observeddsail_load_ruleset
- First observeddsail_record_approval
- First observeddsail_remove_from_team
- First observeddsail_review
- First observeddsail_save_ruleset
- First observeddsail_set_team_role
- First observeddsail_team_members
- First observeddsail_unit_library
- First observeddsail_use_workspace

Publisher details

Operator: Jaxon AI · Publisher source
Operator website: https://jaxon.ai · Publisher source
Vendor relationship: Not applicable
Documentation: https://docs.agents.jaxon.ai · Publisher source
Trust center: Not applicable
Restrictions: Ruleset create is free. Inference uses a free tier and switches to a metered tier for production scale; the service will communicate current pricing and tiers.

Related MCP Connectors

ai·rete·rag AOAuth
com.ai-rete-rag
Author rules from policy docs, then decide: a Rete engine gives the verdict, an LLM explains why.
RAG Systems AI & Machine Learning Knowledge & Memory
1
PolicyLayer
com.policylayer
The system of record for AI agent authority: playbooks, routed policy questions, reusable rules.
Autonomous Agents
2
Norma by Quality CloudsOAuth
ai.qualityclouds
Checks AI-written code against your rules as it is written, and keeps a record of what it found.
Code Analysis Developer Tools
15
policy-gate A
dev.workers.3labsio.policy-gate
Deterministic allow/require_approval/deny verdicts for agent actions, before they happen.
Security Autonomous Agents
41

Related MCP Servers

ai-rete-rag
RAG Systems Knowledge & Memory
zaharajabeen13-create
A
license
A
quality
A
maintenance
Author rules from policy docs, then decide: a Rete engine gives the verdict, an LLM explains why.
Updated 2 days ago (2026-10-10 10:45 UTC)
9
MIT
GlassTape Policy Builderofficial
Security Legal & Compliance Autonomous Agents
GlassTape
A
license
A
quality
D
maintenance
Converts natural language security requirements into validated Cerbos YAML policies with automated testing and red-team analysis, enabling AI governance with zero-trust guardrails for tool calls, data access, and compliance frameworks.
Updated a year ago (2025-11-02 19:43 UTC)
5
3
Apache 2.0
signet-eval
Security Developer Tools
wandercom
A
license
Not graded
quality
B
maintenance
Deterministic policy enforcement for AI agent tool calls. It evaluates every tool call against user-defined rules before execution, with no LLM in the authorization path.
Updated 8 days ago (2026-10-04 17:46 UTC)
3
MIT
mcp-vaaraofficial
Security Observability Autonomous Agents
vaaraio
A
license
Not graded
quality
A
maintenance
Gates every AI agent tool call against your policy before it runs, then writes a hash-chained, tamper-evident record of what was decided and what happened. Anyone can verify that record offline, without your software, your systems or any key you hold.
Updated 2 days ago (2026-10-10 23:14 UTC)
1,766 PyPI
15
AGPL 3.0

Try in Browser

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

Glama MCP Gateway

Add one secure layer between your agents and this server.

Server Details

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Publisher details

Related MCP Connectors

Related MCP Servers

GlassTape Policy Builderofficial

mcp-vaaraofficial

Glama MCP Gateway

Resources