Release History
2026-09-19 · current
Axiom API 0.2.83
Adds the governed POST /v1/assertions contract so GapCare and other Axiom-native demos can create first-class event/assertion records through the public API contract surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events/assertions
contract-visible: Added POST /v1/assertions as a governed, tenant-scoped, idempotent assertion creation operation with canonical Axiom contract metadata and generated public contract projections.
Migration: Clients that need first-class assertion writes may adopt POST /v1/assertions with tenant context and Idempotency-Key; existing read-only assertion consumers are unchanged.
2026-09-17 · previous
Axiom API 0.2.82
Distinguish events from assertions, align reserve response contracts with runtime, and emit SDK telemetry identities at package version 0.1.100.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Events/Assertions contract and SDK telemetry
contract-visible: Correct event-report descriptions to model an event as the occurrence half of Events/Assertions and stamp TypeScript and Python requests with their published 0.1.100 SDK identity.
- Fixed - Claim reserve responses
contract-visible: Remove the repository-only tenant_id storage key from the source/internal ClaimReserve response schema and declare 200 OK for synchronous getReserve and listClaimReserves reads, matching runtime and public SDK behavior.
- Clarified - Generated query contracts
sdk-visible: Generated TypeScript and Python clients now require every contract-required query parameter, expose only declared optional query keys, and project governed enum values consistently in both languages.
Migration: Wire request fields are unchanged. Consumers should treat ClaimReserve.tenant_id as non-public and expect 200 OK, not 202 Accepted, from reserve read operations. Calls that omitted an API-required query parameter, supplied an undeclared query key, or passed a broad string where the contract declares an enum must be corrected before upgrading the generated client.
2026-09-17 · previous
Axiom API 0.2.81
Reserve responses expose explicit currency and as-was cover-capacity authority; reserve admission, release, cancellation, and re-establishment are serialized and fail closed when their authority is unavailable.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - claims
contract-visible: Added currency, cover type, balance period, and cover limit fields to claim reserves. Concurrent reserve admission now returns 409 when capacity is exhausted; missing transaction, audit, balance, limit, or currency authority fails closed with 422 or 503 according to the published error contract.
Migration: Apply t01M2Q3B9KW76GTM7TSBWGF6BSM-claim-reserve-currency-capacity.sql before serving the new contract. Existing rows remain unaltered where currency or cover authority cannot be inferred safely and fail closed until tenant-authorised correction supplies those facts.
2026-09-17 · previous
Axiom API 0.2.80
Makes event reporting retry-safe and contract-accurate: Idempotency-Key exact replays are explicit, tenant schema and money validation return typed 422 responses, and estimated loss requires an explicit lowercase ISO-4217 currency.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Events and assertions
contract-visible: Require Idempotency-Key for event reporting, publish 409 replay-conflict and 422 validation outcomes, and enforce paired estimated_loss/currency semantics without a silent USD default.
Migration: Apply the tenant event currency conditional migration before serving the new contract. Existing non-monetary event currencies are cleared; monetary currencies are canonicalized to lowercase; no denomination is invented.
2026-09-17 · previous
Axiom API 0.2.79
Makes explicit lowercase ISO-4217 currency authoritative across claim submission, aggregate persistence, settlement, payment, ledger posting, and tenant-facing projection.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Events/assertions retained claim-family compatibility contract
contract-visible: Claim and payment schemas now expose authoritative lowercase currency; missing, invalid, heterogeneous, and settlement-mismatched currency is rejected through the typed validation contract.
Migration: Upgrade generated SDKs to 0.1.97. Supply one lowercase ISO-4217 currency consistently across claim lines and payments; uppercase, mixed, missing, or settlement-mismatched currency is rejected.
2026-09-17 · previous
Axiom API 0.2.78
POST /v1/ledger/integrity/verify published a request body of account_codes/date_from/date_to that the service never read, while the handler required entry_ids. A request following the published contract was rejected with 400. The published body is now the one the service accepts, the six failure codes are published as an enum, and the description no longer states that the operation detects unbalanced transactions, orphaned entries or sequence gaps - it verifies per-entry content hashes and reversal lineage for the entries you name.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Ledger
contract-visible: POST /v1/ledger/integrity/verify now publishes entry_ids (required, 1..1000), include_chain (default true) and as_of_time as its request body, and requestBody is required. The previously published account_codes, date_from and date_to were never read by the service and are removed. failure_code is now a published enum of NONE, HASH_MISMATCH, MISSING_LINK, CHAIN_BREAK, NOT_FOUND and OUT_OF_WINDOW. The operation description no longer states that it detects unbalanced transactions, orphaned entries or sequence gaps; it verifies the content hash and reversal lineage of the entries named in the request.
Migration: No working integration can break: a request built from the previously published body was rejected with 400 INVALID_REQUEST because entry_ids was absent, so no caller following the old contract could reach the operation. Send entry_ids with 1 to 1000 ledger entry ids. Regenerate SDK types to pick up the corrected request model and the failure_code enum. If you relied on the description's promise of unbalanced-transaction detection, note that balance is enforced when an entry is written, by a deferred database constraint that refuses an unbalanced transaction at commit, not by this operation.
2026-09-17 · previous
Axiom API 0.2.77
Aligns retained claim lifecycle contracts and generated clients with the implemented request, response, idempotency, error, and cursor-pagination surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - claims
contract-visible: Publishes authoritative submit, assess, reserve mutation, and cursor-paginated claim-list contracts with generated TypeScript and Python client parity.
Migration: Upgrade the TypeScript package family and Python SDK to 0.1.95, replace legacy listClaims limit/offset pagination with page[size] and page[after], and supply required lifecycle request bodies and Idempotency-Key values for mutations.
2026-09-17 · previous
Axiom API 0.2.76
Makes cover pricing-rule binding retries safe and publishes the required idempotency and conflict contract.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - covers
contract-visible: POST /v1/covers/{id}/pricing-rules now requires Idempotency-Key; exact semantic repeats return the canonical binding, while conflicting same-boundary assignments return HTTP 409.
Migration: Provide a stable Idempotency-Key for each logical pricing-rule binding assignment and handle HTTP 409 as a temporal binding conflict. Regenerate clients against this contract release.
2026-09-16 · previous
Axiom API 0.2.75
Classifies append-only realtime subscription state rows with a stable typed identity while preserving the existing subscription identifier contract.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Realtime
contract-visible: Realtime subscription lifecycle state rows now carry the rss_ typed identifier classification; tenant-facing realtime subscription identifiers remain rts_.
Migration: No consumer action is required. Realtime subscription state row identifiers are not emitted by current endpoints, and existing rts_ subscription identifiers are unchanged.
2026-09-15 · previous
Axiom API 0.2.74
Records refreshed public contract projections produced while enforcing standards-reference coherence; runtime operation semantics are unchanged.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - public contract evidence
contract-visible: Public contract projections and their developer-reference copies now match the current governed source corpus used by the standards coherence gate.
Migration: Update the TypeScript package family or Python package to 0.1.93 before generating against API contract 0.2.74. Runtime request and response semantics are unchanged.
2026-09-15 · previous
Axiom API 0.2.73
Refresh the generated API reference after the Redocly tooling update.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-reference
contract-visible: Regenerated the public API reference with the current documentation toolchain; the API operation contract is unchanged.
Migration: No consumer migration is required.
2026-09-14 · previous
Axiom API 0.2.72
Records the internal Calendar manifest route and Knowledge and Calendar CLI vocabulary alignment without changing a public Axiom API operation.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - internal substrate operations
contract-visible: The internal Calendar metadata route is now named /calendar/manifest, and the Knowledge and Calendar operator CLIs use the canonical domain-operation vocabulary. Existing compatibility commands and the retired Calendar route remain bounded compatibility surfaces with explicit replacement guidance. No public /v1 request or response shape changes.
Migration: No public API consumer action. Internal substrate operators should use the manifest route and canonical CLI operation names; compatibility aliases remain available for the declared transition window.
2026-09-14 · previous
Axiom API 0.2.71
POST /v1/ai/query now refuses every data-returning request, and the party-scope refusal on POST /v1/ai/chat is documented.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - AI
contract-visible: POST /v1/ai/query returns 501 PARTY_CONTEXT_UNAVAILABLE instead of records. It applied no party scope, so any authenticated caller in a tenant received every party's records. Returning records requires binding them to the caller's party, and that resolution is not exposed by this service. Its previously documented 200 response and 503 inference-service response are removed: neither was reachable. POST /v1/ai/chat already refused its includeDatabase path; that 501 is now documented on the operation.
Migration: Consumers of POST /v1/ai/query must stop expecting records and read them through the operations that carry their own scoping — /v1/policies, /v1/premiums, /v1/parties, /v1/covers. There is no scoped replacement for the aggregate natural-language query. Both operations are sdk-eligible, so the SDK surface is affected; both are future-public, so no released client depends on the removed response. Chat without includeDatabase is unaffected.
2026-09-13 · previous
Axiom API 0.2.70
The five payment-schedule operations are withdrawn. Billing cadence is a field of the premium, not a separate resource, so /v1/premiums is the canonical replacement.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Removed - premiums-payments
contract-visible: listPaymentSchedules, createPaymentSchedule, getPaymentSchedule, pausePaymentSchedule and resumePaymentSchedule are withdrawn, and the /v1/payment-schedules paths no longer appear in the contract. Four of the five had returned 501 since the retire decision recorded in MR !1915; they were never implemented. The fifth, listPaymentSchedules, read the aggregate premium rows and re-rendered them under schedule field names, substituting defaults when a premium field was empty, so it could report a cadence the premium did not carry. Every field it returned is available directly on the premium: frequency as payment_frequency, amount as installment_amount_minor, next due as due_date, plus status, policy_id and the timestamps.
Migration: Read the cadence from /v1/premiums. frequency becomes payment_frequency, the per-period amount becomes installment_amount_minor, and next_due_date becomes due_date; status, policy_id, created_at and updated_at keep their names. A premium whose cadence fields are empty now reports them as empty rather than as a substituted default, so a consumer that relied on always receiving a frequency must handle its absence. Per-instalment paid/overdue state is not on this surface and remains the payment noun (ADR-0179 3.9).
2026-09-13 · previous
Axiom API 0.2.69
A party handling classification now carries the phc typed-prefix identity, so its uuid can never reach a surface as a bare UUID. No published operation changes.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity
contract-visible: PartyHandlingClassification is registered as a typed-prefix entity with the phc prefix. It has no published route today; the registration exists so that if its identity ever reaches a wire surface it arrives in typed-prefix form rather than as a bare UUID, per ADR-0145 §3.2. No request or response shape changes, and no existing identifier changes form.
Migration: No action. No published operation, request field, response field or identifier format changes in this release.
2026-09-13 · previous
Axiom API 0.2.68
Requires every carrier dispatch and delivery attempt to carry the canonical locale used for rendering, and requires the exact rendered payload to be archived.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Clarified - communications
contract-visible: POST /v1/communications now requires rendered_payload and a canonical BCP 47 locale on every carrier dispatch. Delivery callbacks likewise require the locale so delivery-attempt evidence records which language version was sent. Missing or malformed provenance fails loudly before persistence or dispatch.
Migration: Send the exact rendered bytes in rendered_payload and add locale to every carrier dispatch and delivery callback. Use the canonical language-region form such as en-ZA; language-only tags such as en are also accepted.
2026-09-13 · previous
Axiom API 0.2.67
/v1/payments now serves the tenant payment record rather than the platform usage-billing store, and reference_type becomes required so a payment is never given a classification its caller did not assert.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Clarified - payments
contract-visible: reference_type is now required on POST /v1/payments. The server previously substituted "premium" when it was absent, which wrote a business classification the caller never stated onto a financial record. Supplying it explicitly is the only change a caller needs to make. The CreatePaymentRequest.party_id example is also corrected: it showed a pay_ payment identifier on a party field and now shows a pty_ one.
Migration: Send reference_type on every POST /v1/payments call. Any value you would previously have relied on the server to infer must now be stated: send "premium" to preserve the previous implicit behaviour. A request without reference_type is refused with 422 REFERENCE_TYPE_REQUIRED rather than being classified for you.
2026-09-13 · previous
Axiom API 0.2.66
Assertion.event_id is rendered and filtered as a canonical evt_ identifier, and the reference is enforced by a composite (tenant_id, event_id) foreign key.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Clarified - assertions
contract-visible: Assertion.event_id publishes format typed-prefix-id and pattern ^evt_[0-9a-hjkmnp-tv-z]{26}$, and the GET /v1/assertions event_id filter requires the same form; a malformed filter returns 400 rather than an empty page. The database now enforces the reference as a composite foreign key on (tenant_id, event_id), so an assertion can only name an event in its own tenant.
Migration: Read event_id from the assertion response and use it verbatim when filtering. If you stored a bare UUID, it is the storage identity of the same event; re-read the assertion or encode it into its evt_ form.
2026-09-12 · previous
Axiom API 0.2.65
Publishes the Axiom public API projections with the canonical OpenAPI Specification 3.2.1 declaration.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - OpenAPI metadata
contract-visible: Public OpenAPI documents now declare OpenAPI Specification 3.2.1 while preserving the existing API operation semantics.
Migration: No consumer request or response migration is required. API clients may refresh generated SDKs or schema tooling to consume the updated OpenAPI metadata.
2026-09-12 · previous
Axiom API 0.2.64
GET /v1/events/{id}, POST /v1/events/{event_id}/documents and POST /v1/events/{id}/proration-adjustments now publish the evt_ typed-prefix pattern on their path parameter.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Clarified - events
contract-visible: The event path parameter on the three event operations declares format typed-prefix-id and pattern ^evt_[0-9a-hjkmnp-tv-z]{26}$. This publishes the shape 0.2.63 already enforced at runtime; no behaviour changes.
Migration: No action. Callers already sending an evt_ identifier are unaffected; a bare UUID was already rejected before this release documented it.
2026-09-12 · previous
Axiom API 0.2.63
Event identity is rendered as a canonical typed-prefix evt_ id on every surface, and is the only accepted form when addressing an event. Storage identity is a native uuid column.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Changed - events
contract-visible: Event.id and the report response's event_id are rendered as a canonical typed-prefix identifier matching ^evt_[0-9a-hjkmnp-tv-z]{26}$, replacing the opaque server-assigned string. Both now declare format typed-prefix-id and the pattern.
- Changed - events
contract-visible: GET /v1/events/{id} and POST /v1/events/{event_id}/documents accept only the typed-prefix form. A bare UUID is rejected with 400 rather than resolved, so an event has exactly one wire identifier.
- Changed - events
contract-visible: POST /v1/events/{id}/proration-adjustments rejects an event id that is not a valid evt_ identifier with 422 PRORATION_EVENT_INVALID.
Migration: Read event identity from the response and use it verbatim; it is now an evt_ identifier rather than an opaque string. Replace any stored bare UUID with the evt_ form before addressing an event, because a bare UUID is refused rather than resolved. Values obtained from a 0.2.62 response are the storage UUID of the same row, so the identity itself is unchanged: only its rendered form differs.
2026-09-11 · previous
Axiom API 0.2.62
POST /v1/events/report no longer accepts a caller-supplied event_id. Event identity is assigned by the server and returned on the response.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Clarified - events
contract-visible: Supplying event_id in event_data is now rejected with 422 EVENT_ID_NOT_ACCEPTED rather than ignored. The server assigns event identity and returns it as data.event_id. The Event schema already declared id as readOnly; the implementation now matches it.
Migration: Stop sending event_id when reporting an event, and read the assigned identity from data.event_id on the response for any follow-up call. To carry your own reference, use external_reference with source_system to name its origin. Retry safety is unchanged: Idempotency-Key is required on this operation and is body-aware, so a retried request with a changed body is detected rather than silently accepted.
2026-09-10 · previous
Axiom API 0.2.61
Tenant extension schemas may now declare the party_handling_classification carrier, admitting party handling classification as a governed tenant-defined schema kind.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Tenant extension schemas
contract-visible: The tenant extension schema surface admits a new carrier kind, party_handling_classification. Generated clients gain the corresponding enum value. No existing request or response shape changes and no endpoint behaviour changes.
Migration: No action is required. Existing tenant schemas and clients are unaffected. Clients regenerated against this contract will see the additional carrier kind in the schema-kind union and may begin declaring it.
2026-09-10 · previous
Axiom API 0.2.60
All 21 /v1/claims operations now carry deprecated: true, matching the RFC-8594 Deprecation header the runtime has always sent.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Claims compatibility API
contract-visible: Every /v1/claims operation is now marked deprecated in the OpenAPI specification. The runtime already answered these routes with Deprecation: true and a Link rel="deprecation"; the specification previously said deprecated: false, so generated clients did not warn. No request or response shape changes.
Migration: No action is required today and no behaviour changes. Regenerated clients will begin emitting deprecation warnings for these operations. The canonical successors are the events and assertions surfaces; plan migration before the compatibility routes are retired.
2026-09-09 · previous
Axiom API 0.2.59
Support-visible API identifiers now render as typed-prefix or classified opaque values across evidence, ingress, extensions, allocation, documentation, SDK, and generated public contract surfaces.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity-boundary
contract-visible: Removes the remaining support-visible bare UUID identifier exposure by enforcing typed-prefix rendering/rejection at the affected runtime and contract boundaries.
Migration: Regenerate public API, SDK projections, identity exposure manifest, remediation ledger, header telemetry proof, public contract truth, and bare UUID wire-surface evidence for API 0.2.59.
2026-09-09 · previous
Axiom API 0.2.58
The benefit balance and availability routes are renamed to their canonical form and nested under the policy they belong to. Sector vernacular leaves the canonical slot-2 position on the wire.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Changed - Policy cover balances
contract-visible: GET /v1/benefits/balance is now GET /v1/policies/{id}/cover-balances; GET /v1/benefits/available is now GET /v1/policies/{id}/cover-balances/available; GET /v1/benefits/{id}/claims-ratio is now GET /v1/policies/{id}/cover-balances/claims-ratio. The policy identifier moves from a required policy_id query parameter to the path, the benefit_type query parameter is renamed cover_type, operationIds become getPolicyCoverBalance, getPolicyCoverBalanceAvailable and getPolicyCoverClaimsRatio, and the Benefit tag is retired in favour of Policy.
Migration: Replace the retired paths with their canonical equivalents, move policy_id from the query string into the path, and rename the benefit_type query parameter to cover_type. Response bodies are unchanged. Axiom is in alpha with no external consumers, so the retired names are removed rather than dual-mounted.
2026-09-09 · previous
Axiom API 0.2.57
Async job polling and catalogue bulk-write receipts now publish typed work-item job identifiers instead of bare storage UUIDs.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - operational-health
contract-visible: The async job status path parameter, job status DTO id, and catalogue bulk-write job_id response are now documented as job_ typed-prefix identifiers backed by the WorkItem registry mapping.
Migration: Clients must poll GET /v1/jobs/{job_id} with the job_ identifier returned by catalogue bulk-write; bare UUID job identifiers are rejected at the wire boundary.
2026-09-09 · previous
Axiom API 0.2.56
Authorisation explanation-node references and recent audit entry identifiers now use typed-prefix IDs on public API surfaces.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity
contract-visible: Authorisation explanation-node references use een_ typed-prefix identifiers and recent audit entry identifiers use aud_ typed-prefix identifiers in public contracts, examples, SDK projections, and generated reference artefacts.
Migration: Clients should send explanation_node_id as an een_ typed-prefix ID and should treat recent audit entry IDs as aud_ typed-prefix IDs. Raw UUID explanation_node_id values are rejected.
2026-09-09 · previous
Axiom API 0.2.55
Authorisation wire identifiers now use typed-prefix forms for transition, assertion entity, and party-role actor references.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Authorisation identity
contract-visible: POST /v1/claims/{id}/authorisations now documents and generates typed-prefix identifiers for the authorisation transition id, assertion entity id, and authorising party-role actor. Raw UUID authorising_actor input is rejected by the runtime boundary.
Migration: Send authorising_actor as the party-role typed-prefix identifier using the rol_ prefix. Continue treating logical_authorisation_id and explanation_node_id as alpha exceptions until their owning identity contracts are assigned.
2026-09-09 · previous
Axiom API 0.2.54
Clarifies party and related support-visible identifier contracts so stale UUID-shaped examples are replaced with typed-prefix or opaque identifier classifications.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity-contracts
contract-visible: Party membership, party role, actor, payment, and external identifier examples and schemas now publish supportable typed-prefix or opaque identifier classifications instead of alpha exception evidence.
Migration: No consumer migration required. Existing typed-prefix identifiers remain stable; this release corrects public contract metadata and generated examples.
2026-09-09 · previous
Axiom API 0.2.53
Narrows support-visible identifier exceptions by projecting registry-backed public API fields as typed-prefix identifiers and repairing the typed-prefix codec registry.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity
contract-visible: Registry-backed public identifier fields now use typed-prefix string patterns in the published API contract instead of alpha exception identifier shapes.
Migration: Consumers should continue to treat Axiom identifiers as opaque strings; support-visible entity identifiers render with their typed prefix.
2026-09-08 · previous
Axiom API 0.2.52
Identifier telemetry fields now declare opaque-string wire shape metadata while entity references remain governed by typed-prefix identifiers.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Identity contracts
contract-visible: Request, correlation and trace identifier telemetry fields now use explicit opaque-string identifier metadata in public API contracts, keeping raw UUID syntax out of support-visible entity identity surfaces.
Migration: Consumers should continue treating request, correlation and trace references as opaque support tokens; entity identifiers remain typed-prefix values and raw UUID syntax is not a support-visible contract shape.
2026-09-08 · previous
Axiom API 0.2.51
Policy-family identifier fields now declare typed-prefix wire shapes and examples use canonical policy, party, product, premium-schedule and policy-version prefixes.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Identity contracts
contract-visible: Policy-family identifier fields now use typed-prefix wire metadata and examples no longer use opaque reference surrogates or wrong entity prefixes for policy, party, product, premium-schedule and policy-version identifiers.
Migration: Consumers that previously treated policy-family identifier fields as arbitrary strings should accept the documented typed-prefix identifier shape; raw UUID syntax is not a support-visible contract shape for these identifiers.
2026-09-08 · previous
Axiom API 0.2.50
Rule and ruleset identifier fields in public contract surfaces now declare typed-prefix wire shapes.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Identity contracts
contract-visible: Rule identifiers now use the rul_ typed-prefix shape and ruleset identifiers now use the rst_ typed-prefix shape across the affected public API contract surfaces, examples, SDK projections, and generated reference artefacts.
Migration: Consumers that previously treated these rule or ruleset fields as arbitrary strings should accept the documented typed-prefix identifier shape; raw UUID syntax is not a support-visible contract shape for these identifiers.
2026-09-08 · previous
Axiom API 0.2.49
Classifies observability trace identifiers as opaque non-entity support references in the identity exception remediation ledger.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity-governance
contract-visible: The identity exception remediation ledger now treats response telemetry trace identifiers as opaque support references rather than typed-prefix entity identifiers. Public wire shapes are unchanged.
Migration: No consumer migration required; this is generated governance evidence only.
2026-09-08 · previous
Axiom API 0.2.48
Public API contract evidence now includes a classified identity exception remediation ledger for alpha identifier surfaces and removes the remaining mixed typed-prefix/raw UUID contract shape.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity/contract-governance
contract-visible: Add the identity exception remediation ledger to public contract evidence, require classified ownership for alpha identifier exceptions, and publish typed-prefix catalogue and party erasure contract corrections.
Migration: No consumer migration required for already-compliant typed-prefix clients. Clients must continue using typed-prefix identifiers on support-visible API surfaces; raw UUID identifier syntax is not part of the public contract.
2026-09-08 · previous
Axiom API 0.2.47
Events/assertions runtime proof now records assessment resolution trace honesty and refreshes generated public contract evidence without changing public request or response wire semantics.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events/assertions
contract-visible: Refresh events/assertions contract evidence and generated public API publication artifacts after adding runtime proof that contract responses are recorded only from passing assessment resolution stages.
Migration: No consumer migration required. Public routes and wire schemas are unchanged; this release records stronger runtime and publication evidence for events/assertions lifecycle execution.
2026-09-08 · previous
Axiom API 0.2.46
Canonical events/assertions contract metadata now declares operation-level lifecycle boundaries for every event portfolio contract.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events/assertions
contract-visible: Events/assertions contract authority now records each operation's primary lifecycle boundary, touched lifecycle boundaries, money/ledger boundary, and runtime posture. This is contract metadata only; public routes and wire shapes are unchanged.
Migration: No consumer migration required. Existing routes and wire schemas are unchanged; the release records stronger contract authority metadata.
2026-09-08 · previous
Axiom API 0.2.45
Cover-item trigger references are now expressed as governed trigger_ids rather than free-text trigger labels.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - covers
contract-visible: Cover-item contract schemas now expose trigger_ids for governed event-trigger-kind references instead of free-text triggers.
Migration: Consumers sending cover-item triggers should send governed trigger_ids; free-text trigger labels are no longer the canonical cover-item contract field.
2026-09-07 · previous
Axiom API 0.2.44
Adds explicit seeded currency-code references for cover and cover-item money fields.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - products
contract-visible: Product cover schemas now expose exact integer minor-unit cover-item money fields with paired seeded lowercase currency-code references for response amounts, per-assertion limits, annual limits, and cover-level sum insured/deductible currency.
Migration: Consumers may send the new optional currency fields when sending the paired money amount. Currency fields must be omitted when the paired amount is absent.
2026-09-07 · previous
Axiom API 0.2.43
Product decision evaluation now has governed runtime execution where tenant binding, pipeline, audit, and explanation substrate are configured.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Product decision evaluation
contract-visible: POST /v1/covers/{id}/decision-evaluations now resolves product binding, loads the admitted tenant pipeline template, executes the governed pipeline, persists explanation and audit evidence, and returns stable routeable outputs only after evidence persistence succeeds.
Migration: No request schema migration is required. Workflow callers must treat missing binding, missing active pipeline template, execution failure, audit failure, or explanation failure as typed technical failures, not routeable business decisions.
2026-09-07 · previous
Axiom API 0.2.42
Classify retained events/assertions compatibility operations by canonical operation boundary without changing public route names.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events-assertions
contract-visible: Retained events/assertions compatibility contract sources now declare operation_boundaries metadata so consumers and reviewers can distinguish assertion reads, assessment execution, evidence capture, contract response reads, and payment/ledger operations.
Migration: No consumer migration required. Public routes, operationIds, response schemas, and SDK-facing compatibility identifiers are unchanged; the added metadata is contract governance evidence.
2026-09-07 · previous
Axiom API 0.2.41
Product decision evaluation examples now use Axiom assertion vocabulary instead of legacy decision intent and stage names.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Product decision evaluation
contract-visible: Contract-owned product decision intent examples now use assertion.required_evidence, assertion.coverage_response, assertion.contract_response, and assertion_intake.
Migration: Consumers using the non-enum example values should send the assertion.* decision intents and assertion_intake stage. The route and request schema shape are unchanged.
2026-09-07 · previous
Axiom API 0.2.40
Publishes refreshed API publication closure evidence so public contract truth, header telemetry proof, SDK-derived artifacts, and contract learning packs reconcile on current main.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api/publication
contract-visible: Adds refreshed public contract truth and header telemetry proof evidence, with generated publication artifacts reconciled to the current API surface.
Migration: No consumer migration required. Public routes and payload fields are unchanged; this release publishes refreshed contract evidence only.
2026-09-07 · previous
Axiom API 0.2.39
Clarifies that retained claims compatibility recovery and correction operations may carry conditional payment/ledger authority while the canonical lifecycle remains event, assertion, assessment, evidence, evaluation, and contract response.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events/assertions
contract-visible: Clarifies payment and ledger boundary metadata for retained claims compatibility recovery and correction event contracts.
Migration: No consumer migration required. Public routes and payload fields are unchanged; this release clarifies operation authority metadata only.
2026-09-07 · previous
Axiom API 0.2.38
Clarifies retained claims-family compatibility contracts as event/assertion lifecycle surfaces and adds compatibility posture plus lifecycle semantics metadata.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events-assertions
contract-visible: Retained claims-family event contracts now declare compatibility posture and canonical lifecycle semantics for event, assertion, assessment/evaluation, evidence, ruleset/pipeline execution, contract response, payment, and ledger boundaries.
Migration: No runtime migration. Public /v1/claims routes are retained as compatibility surfaces; consumers should treat them as events/assertions lifecycle contracts rather than Axiom canonical claim nouns.
2026-09-07 · previous
Axiom API 0.2.37
Corrected 18 stale file:line evidence anchors in api/contracts/internal-routes.yaml after unrelated server.go changes shifted line numbers. No route classification, exposure_decision, method, or path changed.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - internal-routes-registry
contract-visible: No public-facing change. Internal (non-public) route evidence anchors realigned to their correct current source line.
Migration: None -- internal-only routes, no consumer-visible behavior or contract change.
2026-09-07 · previous
Axiom API 0.2.36
Admit the product decision evaluation runtime skeleton behind the existing cover decision-evaluations route.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - covers
contract-visible: POST /v1/covers/{id}/decision-evaluations now has a runtime skeleton that validates decision intent, product stage, requested outputs, forbidden caller-supplied authority fields, canonical request hash, idempotency posture, and binding-resolution failure semantics while deliberately returning controlled typed failures until governed evaluation execution is wired.
Migration: No consumer migration required. The route remains alpha and does not yet produce successful governed evaluation results; consumers should treat RUNTIME_UNIMPLEMENTED and EVALUATION_FAILED as controlled Slice 2 outcomes until Slice 3 runtime execution lands.
2026-09-07 · previous
Axiom API 0.2.35
Expose the canonical claim payment request and successful response contract, including durable payment ledger reversal handles.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - claims
contract-visible: The payClaim operation now publishes the request body and 200 PayClaimResponse shape with ledger_entries so SDK consumers can retain durable reversal handles from successful claim payments.
Migration: Regenerate SDK clients and read ledger_entries from successful payClaim responses before attempting payment reversals.
2026-09-07 · previous
Axiom API 0.2.34
example_for_schema()'s recursion-depth guard cut off before expanding actor_authority[0].actor_role/authority_kind in the lifecycle-definitions validate request example. Corrected the generator; regenerated the affected Postman/Insomnia example bodies. No API contract, schema, or behavior change.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - developer-reference-examples
contract-visible: No public-facing contract change. Corrected example request bodies for the lifecycle-definitions validate endpoint in the published Postman/Insomnia collections.
Migration: None -- documentation/example correction only, no consumer-visible behavior or contract change.
2026-09-07 · previous
Axiom API 0.2.33
Fixed 14 stale file:line evidence anchors in api/contracts/internal-routes.yaml that pointed at the wrong line after an unrelated line insertion in internal/api/rest/server.go. Evidence pointer correction only; no route method, path, or exposure_decision changed.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - internal-routes-registry
contract-visible: No public-facing change. Internal (non-public) route evidence anchors realigned to their correct current source line.
Migration: None -- internal-only routes, no consumer-visible behavior or contract change.
2026-09-07 · previous
Axiom API 0.2.32
Adds publisher-owned broad bare-UUID wire-surface scanning across support-visible API contracts, docs, SDK projections, examples, and generated public artifacts.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity wire governance
contract-visible: Broadens bare-UUID leak detection beyond source OpenAPI and records existing generated/public findings in a publisher-owned baseline with deterministic CI enforcement.
Migration: No consumer migration; this is a contract-governance and publication-evidence hardening release.
2026-09-06 · previous
Axiom API 0.2.31
Admits the product decision evaluation contract for governed cover decision points while runtime evaluation remains unavailable in this slice.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - covers
contract-visible: Adds POST /v1/covers/{id}/decision-evaluations as a contract-admitted endpoint that returns typed runtime-unimplemented semantics until the governed evaluation runtime is implemented.
Migration: No consumer migration is required. Early consumers may generate SDKs for the new operation, but runtime calls receive RUNTIME_UNIMPLEMENTED until Slice 2 lands.
2026-09-06 · previous
Axiom API 0.2.30
Adds the contract-admitted product decision evaluation operation used by external process tooling to request governed Axiom decisions.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Product
contract-visible: Added POST /v1/covers/{id}/decision-evaluations as a contract-admitted, runtime-unimplemented product decision evaluation surface with typed failure semantics.
Migration: No runtime migration required. The operation is admitted for contract visibility and currently documents runtime-unimplemented behaviour until the service slice lands.
2026-09-06 · previous
Axiom API 0.2.29
Blocks raw UUID wire declarations in source OpenAPI and regenerated public API contract projections.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity
contract-visible: Source OpenAPI and public contract projections no longer declare raw UUID wire formats or raw UUID regex patterns for support-visible identifiers; identity exposure checks now fail those declarations before publication.
Migration: No consumer migration is required for typed-prefix identifiers; consumers should continue sending and storing typed identifiers such as tnt_... rather than bare UUIDs.
2026-09-05 · previous
Axiom API 0.2.28
Align retained /v1/claims workflow and pipeline substrate annotations with the events/assertions compatibility contracts while preserving the public route shape.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - workflow substrate metadata
contract-visible: Retained /v1/claims operations now point at the events/assertions compatibility lifecycle and assessment pipeline contract records instead of the retired claims-workflow contract names.
Migration: No consumer code migration is required; request and response shapes are unchanged.
2026-09-05 · previous
Axiom API 0.2.27
Adds a support-visible identity exposure manifest and CI gates for unclassified identifier fields and bare UUID examples.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identity
contract-visible: Support-visible API contracts now publish an identity exposure manifest and block bare UUID-shaped identifier values in current public contract surfaces.
Migration: No consumer migration required; examples and generated projections use typed-prefix or opaque non-UUID identifiers.
2026-09-05 · previous
Axiom API 0.2.26
Axiom's canonical OpenAPI contract projection now declares OpenAPI Specification 3.2.0 while preserving the existing public JSON wire shapes.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - openapi-specification-dialect
contract-visible: Canonical authored OpenAPI source, generated OpenAPI fragments, runtime bundles, developer reference bundles, SDK inputs, and public contract truth move from OpenAPI 3.0.3 to OpenAPI 3.2.0.
Migration: No endpoint, authentication, identifier, envelope, or JSON field migration is required. Consumers whose tooling cannot parse OpenAPI 3.2.0 must pin to the previous 0.2.25 contract until their tooling is upgraded or a generated compatibility projection is deliberately introduced. SDK consumers should refresh generated clients because OpenAPI 3.2.0 and JSON Schema null unions change generated type metadata, including nullable object model names, even where the public JSON wire shape is unchanged.
2026-09-05 · previous
Axiom API 0.2.25
Public API contract artifacts now enforce typed-prefix wire identifiers and remove raw UUID-looking examples from the current external contract surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - identifier-wire-contract
contract-visible: Current public OpenAPI, generated developer reference, SDK-facing manifests, and public proof artifacts no longer expose bare UUID examples or public format: uuid fields for typed-prefix entities.
Migration: No SDK migration required. Existing typed-prefix identifiers remain the public wire form; internal UUID storage and historical evidence are unchanged.
2026-09-04 · previous
Axiom API 0.2.24
Correct product update contract metadata and classify retained claims and benefits developer-facing bundles as compatibility vocabulary while keeping public API routes stable.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - developer-docs
contract-visible: Developer API projections now identify the claims and benefits scoped bundles as compatibility surfaces over canonical events/assertions and cover/entitlement semantics.
- Fixed - products
sdk-visible: Product update contracts now publish the typed `prd_...` product identifier shape and optional actor metadata used by the runtime.
Migration: No consumer migration required for conforming clients; route names, operationIds, and SDK method names remain unchanged.
2026-09-04 · previous
Axiom API 0.2.23
Clarify retained public API terminology so legacy claim-family and benefit-family identifiers are described as compatibility surfaces over Axiom canonical event, assertion, cover, entitlement, payment, and ledger nouns.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-vocabulary
contract-visible: Public API descriptions and examples now classify retained claim-family and benefit-family names as compatibility vocabulary while preserving existing route names, operationIds, schema names, enum values, and SDK-facing identifiers.
Migration: No consumer action required. Public identifiers are unchanged; generated docs and SDK surfaces carry clarified descriptions only.
2026-09-04 · previous
Axiom API 0.2.22
Expose party_group and party_group_membership as tenant schema registry entity types for tenant party/group/role schema enforcement.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - extensions
contract-visible: Tenant extension schema registration now accepts party_group and party_group_membership entity types, with subtype discriminators for group_type and role_in_group.
Migration: Consumers registering tenant extension schemas may now use party_group.<group_type> and party_group_membership.<role_in_group> names; existing schema registrations are unchanged.
2026-09-04 · previous
Axiom API 0.2.21
Classifies retained claim-family API contracts and generated public API documentation as compatibility surfaces over Axiom events/assertions canon.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events-assertions
contract-visible: Retained /v1/claims contract and documentation prose now states that claim-family names are compatibility identifiers while Axiom canon remains events and assertions. No route, schema, operationId, permission, or SDK identifier is renamed in this patch.
Migration: No consumer migration required. Existing /v1/claims routes, operationIds, schemas, permissions, and SDK-facing identifiers are unchanged.
2026-09-04 · previous
Axiom API 0.2.20
Clarifies that support request intake creates a collaboration_request support lifecycle record, not a workflow or pipeline authoring surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - support-requests
contract-visible: Support request OpenAPI wording now classifies collaboration_request as a support lifecycle instead of a pipeline, preserving the no workflow/pipeline authoring boundary.
Migration: No consumer migration required; route shape and payload schema are unchanged.
2026-09-03 · previous
Axiom API 0.2.19
Clarify that GET /v1/jobs/{job_id} reports workqueue execution status only and does not expose workflow execution identifiers.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Operational health
contract-visible: The async job status endpoint now explicitly states that it is a workqueue execution-status surface, not a workflow execution registry, and does not expose workflow_execution_id.
Migration: No client migration required unless a consumer incorrectly treated job status as workflow execution tracking; use a future admitted workflow execution contract for that need.
2026-09-03 · previous
Axiom API 0.2.18
Clarifies the alpha payment schedule route-accountability boundary.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - payments
contract-visible: Payment schedule create, detail, pause, and resume routes are explicitly unavailable lifecycle surfaces returning 501 until implemented; list remains the supported schedule projection.
Migration: No consumer migration is required. Existing list consumers are unchanged; create/detail/pause/resume consumers should continue treating these routes as unavailable.
2026-09-03 · previous
Axiom API 0.2.17
Publish the ingress transport execution contract and link async ingress transport surfaces to the durable receipt and status semantics.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - transport
contract-visible: Async ingress remains an alpha tenant transport execution surface: 202 means durable receipt only, status polling is authoritative, and event promotion remains gated.
Migration: No consumer migration required; no request or response schema changes are introduced.
2026-09-03 · previous
Axiom API 0.2.16
Publishes the premium quotation pipeline contract link for premium calculation and refreshes generated API/SDK projections.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Premiums
contract-visible: POST /v1/premiums/calculate now advertises the admitted premium quotation pipeline contract in OpenAPI metadata.
Migration: No request or response shape migration is required; consumers may use the new contract metadata for documentation and tooling.
2026-09-03 · previous
Axiom API 0.2.15
Clarifies that onboarding tenant_id route values are compatibility anchors while X-Tenant-Context remains the server-minted tenant-scope authority.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - onboarding
contract-visible: Onboarding route documentation now states that tenant_id path values are verified against, and subordinate to, the server-minted X-Tenant-Context operating tenant. Runtime handlers reject missing or mismatched tenant context before service execution.
Migration: No current public SDK migration; onboarding remains full-bundle/future-public and the current route shape is preserved while tenant authority semantics are clarified.
2026-09-03 · previous
Axiom API 0.2.14
Converge future-public onboarding workflow rules and step vocabulary with runtime contract authority.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - onboarding
contract-visible: Clarifies onboarding workflow_rules as structured CEL-backed lifecycle guards, aligns onboarding steps to the ADR-0043 runtime sequence, and records onboarding operations as future-public domain-specific workflow contract surfaces.
Migration: No current public SDK migration; onboarding remains full-bundle/future-public and this release records contract convergence for future consumers.
2026-09-03 · previous
Axiom API 0.2.13
Adds public contract metadata for claim assessment pipeline semantics.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - workflow-substrate
contract-visible: assessClaim now links to the claims adjudication pipeline contract, making deterministic stage, ruleset binding, halt, explanation, and as-was semantics visible to API consumers and agents.
Migration: No request or response shape migration is required. Consumers may use the new contract metadata to understand assessClaim pipeline semantics.
2026-09-03 · previous
Axiom API 0.2.12
Clarifies ProductRulesetBinding ruleset_type as the ruleset entity-type catalogue and publishes the ruleset binding contract for public SDK and OpenAPI consumers.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - workflow-substrate
contract-visible: ProductRulesetBinding ruleset_type now exposes the same allowed catalogue as Ruleset.entity_type, and the product ruleset binding contract documents stage binding and as-was resolution semantics.
Migration: No request shape migration is required for valid consumers. Unknown ruleset_type values remain rejected fail-closed; SDK consumers should regenerate against API contract 0.2.12 for the explicit enum.
2026-09-03 · previous
Axiom API 0.2.11
Adds workflow substrate classification metadata to public workflow-adjacent API operations.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - workflow-substrate
contract-visible: Public OpenAPI operations that participate in workflow, pipeline, ruleset, binding, lifecycle, or execution substrates now publish x-axiom substrate metadata for agent and developer inspection.
Migration: No request or response payload migration is required. Consumers may optionally read the new x-axiom substrate metadata from the public OpenAPI profile.
2026-09-02 · previous
Axiom API 0.2.10
Clarifies the claims audit public contract evidence so the generated API surface consistently publishes the server-minted X-Tenant-Context requirement enforced by runtime.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - claims audit
contract-visible: The claims audit route now publishes the server-minted X-Tenant-Context contract consistently across OpenAPI, generated public contracts, and developer reference projections.
Migration: No consumer request shape changes are required. Existing callers must continue using bearer authentication and server-minted X-Tenant-Context where required by the published contract.
2026-09-01 · previous
Axiom API 0.2.9
Refreshes generated API contract evidence after post-merge validation exposed stale internal route source anchors, and clarifies the claim audit route's server-minted tenant-context contract.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - internal route evidence
contract-visible: No public API behavior change; internal route authority anchors and generated audit evidence were refreshed.
- Clarified - claims audit
contract-visible: The claim audit route now publishes the same server-minted X-Tenant-Context contract that its runtime already enforces.
Migration: No consumer migration required.
2026-09-01 · previous
Axiom API 0.2.8
Catalogue bulk-write now follows the published staged-upload contract: a tenant-owned upload_id from /v1/uploads is sufficient for enqueue when the staging store and workqueue are wired.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - catalogues
contract-visible: Catalogue bulk-write no longer requires an unpublished object-upload custody verifier before schema validation or enqueue; readiness is limited to the published staging-store and workqueue dependencies.
Migration: No client migration required. Operators should deploy this patch to restore scheduled catalogue feed loads that already use /v1/uploads followed by catalogue bulk-write.
2026-08-31 · previous
Axiom API 0.2.7
Refresh generated contract scaffold evidence after the 0.2.6 remediation merge and correct internal route evidence anchors.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - contract-scaffold
contract-visible: Generated API estate, sanitized runtime evidence, and contract learning pack evidence were refreshed; internal-only route evidence anchors now point at concrete route registrations.
Migration: No consumer migration required; no public request or response semantics changed.
2026-08-31 · previous
Axiom API 0.2.6
Product lifecycle audit feeds now include product-scoped application audit rows, pricing-rule assignment audit is keyed by product, tenant extension schema failures return structured client errors, and product type values are published.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Covers/products
contract-visible: Expose the accepted product type enum, return structured tenant-schema validation errors for product extension attributes, and make product audit feeds include create/update/section-add/binding/activation evidence.
Migration: Clients should use /v1/covers as the canonical product root, choose one of the published product type values, publish tenant extension schemas before sending non-empty extension attributes, and expect product audit feeds to include product-scoped lifecycle operations.
2026-08-31 · previous
Axiom API 0.2.5
Premium calculation now rejects malformed typed-prefix policy identifiers before service lookup so policy-context validation follows the public API contract.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Premiums
contract-visible: Reject malformed premium calculation policy identifiers with a canonical INVALID_REQUEST response before service lookup.
Migration: Clients must send canonical typed-prefix insurance policy identifiers in premium calculation requests.
2026-08-31 · previous
Axiom API 0.2.4
Adds the tenant-facing Support Requests API for governed collaboration and support intake.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - support
contract-visible: Adds /v1/support/requests create, list, read, transition, and comment operations with tenant-visible mutation authority and generated SDK surfaces.
Migration: Consumers can adopt /v1/support/requests for tenant support intake; no existing endpoint migration is required.
2026-08-31 · previous
Axiom API 0.2.3
Clarifies create-from-base ruleset semantics, lineage metadata, copied rule codes, and structured create error responses for API consumers.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Rulesets
contract-visible: Ruleset create-from-base now requires base_ruleset to be an existing ruleset UUID, derives the next numeric version, records lineage metadata, preserves copied business rule codes, and reports validation/not-found/persistence failures with structured non-500 responses.
Migration: Send a ruleset UUID in base_ruleset when creating from an existing ruleset. Code-form base references are rejected with BASE_RULESET_INVALID; consumers should read lineage metadata and treat copied rule codes as stable business identifiers within each derived ruleset.
2026-08-31 · previous
Axiom API 0.2.2
Adds the tenant-facing schema lifecycle contract for governed tenant extension schemas.
- API family
v1
- Version impact
minor
- Contract authority
api/contracts
- Added - tenant-schema
contract-visible: Adds /v1/extensions/schemas tenant schema lifecycle operations for tenant-scoped schema registration, listing, resolution, retrieval, publication, and deprecation.
Migration: API consumers may use /v1/extensions/schemas for tenant-scoped schema lifecycle operations. Platform/operator schema custody remains on /v1/admin/extensions/schemas.
2026-08-31 · previous
Axiom API 0.2.1
Admission and gateway error envelopes now expose the same top-level telemetry block as wrapped success responses.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - errors
contract-visible: Error responses from API admission and gateway denial paths now include top-level telemetry with request_id, server_time, api_version, timing, idempotency_replayed, and optional trace_id.
Migration: No consumer migration is required. Clients that parse JSON:API errors can ignore the additional telemetry member or use it for diagnostics.
2026-08-31 · previous
Axiom API 0.2.0
Opens the 0.2 alpha contract line to make the canonical covers/products public resource boundary explicit after retiring product-rooted transport vocabulary.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Changed - covers/products
contract-visible: Opens the 0.2 alpha contract line to mark the canonical /v1/covers resource boundary after retiring the product-rooted public transport root.
Migration: Consumers should treat 0.2.0 as the covers/products alpha contract baseline. Integrations still relying on product-rooted resource vocabulary must migrate to /v1/covers and the covers/products primitive wording.
2026-08-30 · previous
Axiom API 0.1.93
Adds explanation reference metadata to compliance report findings while preserving disclosure minimisation for external consumers.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - compliance reports
contract-visible: Compliance report findings now expose explanation_refs alongside evidence_references so external consumers can reconstruct why a finding matters without receiving source payloads or tenant-internal data.
Migration: Consumers may read the new optional explanation_refs array on compliance report findings; existing evidence_references remain unchanged.
2026-08-30 · previous
Axiom API 0.1.92
Clarifies the public compliance report endpoint as contract-authoritative and publishes generated consumer-facing projection evidence.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - compliance reports
contract-visible: Published contract authority for the compliance report endpoint and aligned OpenAPI/developer projections with the compliance report contract.
Migration: No consumer migration required; this patch clarifies contract authority and projection metadata for the existing compliance report endpoint.
2026-08-29 · previous
Axiom API 0.1.91
Record bounded internal-route authority for Calendar tenant runtime routes so API Estate no longer reports Calendar runtime orphans.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - calendar-substrate
contract-visible: Calendar tenant runtime routes are now recorded in the internal-route registry as bounded tenant-runtime surfaces. This is an authority/projection correction for internal runtime coverage, not a new public API publication.
Migration: No consumer migration required; the routes remain bounded internal tenant-runtime surfaces.
2026-08-29 · previous
Axiom API 0.1.90
Classifies the API Estate follow-on audit state for Calendar and Compliance without adding public API operations.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-estate-audit
contract-visible: Classify Calendar and Compliance audit follow-on evidence and the Calendar runtime route reference while remediation work remains open.
Migration: No consumer migration required; no public API operation or SDK method changes in this release.
2026-08-29 · previous
Axiom API 0.1.89
Classifies internal operational and support-session API estate surfaces so coverage remediation can close without changing public API behavior.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - operational-runtime
contract-visible: Classified Swagger UI, Prometheus metrics, and support-session disclosure routing in the API estate coverage model; no public API behavior or SDK surface changes.
Migration: No consumer migration required; this is an internal route classification and audit coverage update.
2026-08-29 · previous
Axiom API 0.1.88
Refresh generated public API contract artifacts after the Ruff 0.16.4 CI gate exposed stale checked-in projections.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - public-api-contracts
contract-visible: Generated public API contract artifacts and developer reference bundle metadata are refreshed without changing runtime API behavior.
Migration: No consumer migration required.
2026-08-29 · previous
Axiom API 0.1.87
Refreshes the generated sanitized runtime evidence corpus after runtime implementation files changed, without changing the public API shape.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - contract evidence
contract-visible: The sanitized runtime evidence corpus was regenerated so public contract evidence hashes match the current runtime implementation.
Migration: No consumer migration required; this is generated evidence freshness only.
2026-08-29 · previous
Axiom API 0.1.86
Clarifies that support-session operator read/write operations are internal-operational and SDK-exempt while support-session disclosure reads remain the public SDK-supported consumer surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - support sessions
contract-visible: Support-session open/list/end operations are classified as internal-operational and SDK-exempt; support-session disclosure reads remain SDK-visible for API consumers.
Migration: No consumer migration is required. Public SDK consumers continue to use support-session disclosure reads; internal operator support-session operations are not public SDK surface.
2026-08-29 · previous
Axiom API 0.1.85
Adds a tenant-scoped support-session disclosure history read so tenants can inspect bounded support-access evidence.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - support-sessions
contract-visible: Adds GET /v1/support-session-disclosures to return bounded support-session disclosure history for the authenticated tenant.
Migration: Consumers may call GET /v1/support-session-disclosures with a valid tenant context to inspect support-session disclosure history; no existing request shape changes.
2026-08-29 · previous
Axiom API 0.1.84
Records that tenant schema registry operation authority remains admin-internal and does not introduce a public SDK surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - tenant-extensible-schema-registry
contract-visible: Clarified operation authority and publication disposition for tenant schema registry admin operations.
Migration: No consumer migration required; this is an internal administrative posture clarification with no SDK-visible API change.
2026-08-29 · previous
Axiom API 0.1.83
Runtime evidence updated for registered outbound integration enforcement and internal route evidence anchor correction.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - tenant-facing integrations
contract-visible: Outbound vendor webhook dispatch now fails closed unless an active registered egress or bidirectional integration authorizes the dispatch; internal route evidence anchors were corrected for generated audit verification.
Migration: No consumer migration required; this is an alpha runtime enforcement and evidence correction with no SDK-visible surface change.
2026-08-28 · previous
Axiom API 0.1.82
Adds actor-scoped vendor security review and subprocessor approval decision operations while making direct attestation mutation read-only/forbidden.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Vendor
contract-visible: Added decideVendorSecurityReview and decideSubprocessorApproval so vendor attestation state is changed through authorized decision workflows with actor and basis evidence instead of ordinary update payloads.
Migration: Stop writing vendor security_review_status or subprocessor approval metadata through ordinary update requests. Use the new decision operations with an authorized actor context.
2026-08-28 · previous
Axiom API 0.1.81
Clarifies report export as unavailable until the tenant-owned report-runner substrate is admitted.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - reports
contract-visible: Report export now returns typed JSON:API unavailable metadata and advertises only the canonical report-export type enum.
Migration: Consumers should treat /v1/reports/export as unavailable and use the returned metadata for accepted report types, evidence, explanation, freshness, redaction, and runtime authority.
2026-08-28 · previous
Axiom API 0.1.80
Surface missing object-upload custody verifier readiness before catalogue bulk-write schema validation and preserve the server 503 machine code in the catalogue loader.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - catalogues
contract-visible: Catalogue bulk-write readiness now reports UPLOAD_CUSTODY_VERIFIER_REQUIRED when the upload custody verifier is not wired, allowing feed preflight to fail before a doomed upload is submitted.
Migration: No request or success-response migration required. Operators should treat UPLOAD_CUSTODY_VERIFIER_REQUIRED as a server deployment readiness failure until the custody verifier substrate is wired.
2026-08-28 · previous
Axiom API 0.1.79
Clarify that vendor classification is computed from tenant-governed rules rather than supplied as independent client authority.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - vendors
contract-visible: Vendor classification is documented as ruleset-computed from accessed data classes. Create and update requests may include classification only as a compatibility assertion; mismatches fail with CLASSIFICATION_MISMATCH.
Migration: Clients should omit vendor classification on create/update unless using it as an assertion that the server-derived classification matches their expectation.
2026-08-28 · previous
Axiom API 0.1.78
Clarifies the published policy-version creation side effects to match the implemented runtime path.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - policies
contract-visible: The create policy version route now describes the implemented version-service side effects instead of stale 501 placeholder prose.
Migration: No consumer migration is required; this is a documentation and projection clarification with no route, schema, or SDK call-shape change.
2026-08-28 · previous
Axiom API 0.1.77
Documents the typed halted-state response returned when advisor search derived-data deletion or purge is unavailable during append-only vector-store canonicalisation.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - advisor-search
contract-visible: Advisor search delete and purge operations now publish the 503 CANONICALISATION_IN_FLIGHT response for derived-data canonicalisation halt conditions, while legal hold remains a 409 LEGAL_HOLD response.
Migration: Consumers should treat CANONICALISATION_IN_FLIGHT as a non-retryable halted-state response and contact Kelevra/operator support instead of retrying destructive derived-data mutation.
2026-08-28 · previous
Axiom API 0.1.76
Clarifies that report export is not runtime-backed in the current developer preview.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - reporting
contract-visible: The public report export route now publishes unavailable runtime metadata and a typed 501 response until the tenant-owned report-runner substrate is implemented.
Migration: Consumers must not call report export as a working binary export route until a later release publishes runtime availability.
2026-08-28 · previous
Axiom API 0.1.75
Internal Advisor search and search read-model access now bind tenant scope from verified operating tenant context.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - search-reporting-analytics-read-models
contract-visible: Internal Advisor search routes require verified X-Tenant-Context and shared search operations reject missing or mismatched operating tenant context before read-model access.
Migration: No public SDK migration is required; this is an internal route and runtime-boundary hardening change.
2026-08-28 · previous
Axiom API 0.1.74
Refreshes sanitized runtime evidence for communications webhook tenant-context enforcement.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - communications
contract-visible: Communications webhook operations now include sanitized runtime evidence for fail-closed operating-tenant enforcement and tenant-context mismatch denial.
Migration: No consumer migration required; this records evidence for runtime boundary enforcement without changing the public webhook request contract.
2026-08-28 · previous
Axiom API 0.1.73
Carrier callback transport evidence now records fail-closed signed-envelope verification and carrier effective-time persistence.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - communications delivery state
contract-visible: Carrier callback transport metadata now documents signed callback envelope verification, replay denial, tenant-scoped mutation ordering, and carrier effective_at persistence for delivery-state evidence.
Migration: No SDK migration. This is an inbound carrier callback transport-surface hardening record; generated tenant SDK consumers are not expected to call the carrier callback surface.
2026-08-28 · previous
Axiom API 0.1.72
POST /v1/communications now resolves template_ref to an immutable communication template revision before entering the Two-Touch transaction.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - communications
contract-visible: Clarifies that the communications endpoint is live when archive, outbox, repository, and template resolver dependencies are wired, and records template_ref resolution before the transaction begins.
Migration: Consumers should continue sending template_ref as <template_code> or <template_code>:<version>; no request-shape migration is required.
2026-08-28 · previous
Axiom API 0.1.71
Adds a canonical communications delivery-state taxonomy and binds webhook delivery semantics to the mapped delivery states.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - communications-delivery-state
contract-visible: Published canonical delivery-state mappings across notification outcomes, notification intent status, delivery-attempt storage status, and webhook delivery status.
Migration: Consumers can continue reading existing webhook pending/dispatched/delivered/failed values; pending now maps explicitly to the canonical queued delivery state for contract interpretation.
2026-08-28 · previous
Axiom API 0.1.70
Publish scan/security custody evidence for object upload and Advisor conversion remediation.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - object-upload-conversion-custody
contract-visible: The public sanitized runtime evidence corpus now records the updated catalogue bulk-write custody proof test hash for AUD-OBJECT-UPLOAD-CONVERSION-CUSTODY-0004.
Migration: No consumer migration required; this is a proof/evidence metadata update only.
2026-08-28 · previous
Axiom API 0.1.69
The public contract evidence now records that upload custody checks require archive identity, owner, retention, legal-hold, redaction, and tenant-isolated retrieval proof before downstream object consumption.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - object upload custody
contract-visible: Recorded the archive custody evidence requirement for uploaded-object downstream consumption without changing the public route shape.
Migration: No client route migration is required. Producers should continue supplying upload custody evidence; downstream catalogue and conversion work now requires archive custody metadata before consumption.
2026-08-27 · previous
Axiom API 0.1.68
Require admitted object-upload custody proof before catalogue bulk-write enqueue and refresh internal API projection evidence.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - object-upload-custody
contract-visible: Catalogue bulk-write now fails closed unless staged upload custody proof is present, tenant-matched, cleanly scanned, archived, and provenance-stamped before enqueue.
Migration: No public SDK migration is required; this is server-side custody enforcement for existing upload consumption.
2026-08-27 · previous
Axiom API 0.1.67
Converge edge function API responses on the shared SuccessEnvelope contract instead of endpoint-specific wrapper shapes.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - edge-functions
contract-visible: Edge function create, list, get, publish, invoke, and compose responses now advertise canonical SuccessEnvelope compliance in the public OpenAPI contract.
Migration: Consumers should continue reading response data from the data field; the public contract now reflects the shared canonical envelope shape consistently across edge function operations.
2026-08-27 · previous
Axiom API 0.1.66
Converge ruleset entity_type schema with the canonical ADR-0097 product ruleset_type allowlist.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - rulesets
contract-visible: Ruleset create and read schemas now publish the canonical product ruleset_type values and mark legacy rule conditions/actions as compatibility metadata.
Migration: Consumers should send canonical ruleset_type values such as claims_assessment, eligibility, and premium_rating instead of retired lane words such as claims, underwriting, or pricing.
2026-08-27 · previous
Axiom API 0.1.65
Records the ruleset composition materialization wiring and sanitized runtime evidence corpus refresh for ADR-0097 convergence.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - rulesets
contract-visible: Ruleset composition materialization now uses the canonical persisted composition loader, and the public sanitized runtime evidence corpus reflects the updated REST composition handler.
Migration: No consumer migration required; this is runtime wiring and evidence convergence for existing ruleset composition surfaces.
2026-08-26 · previous
Axiom API 0.1.64
Refresh generated public contract proof artifacts while upgrading CI Ruff tooling.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - public-contract-proof
contract-visible: Regenerated operation semantic spine, header telemetry proof, wire convergence, SDK ergonomics, agent index, sanitized runtime evidence corpus, and contract corpus inventory artifacts for the current public API surface.
Migration: No consumer migration required; this is a generated proof and publication metadata refresh with no intentional runtime API behavior change.
2026-08-26 · previous
Axiom API 0.1.63
Classifies transport-surface proof posture and references so bounded non-beta transport surfaces are explicit in protected-main API contract evidence.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - transport-surfaces
contract-visible: Transport surface records now carry explicit proof posture and proof references for bounded non-beta-facing surfaces.
Migration: No consumer migration required; transport payload shapes are unchanged.
2026-08-26 · previous
Axiom API 0.1.62
Classifies explanation-tree read and immutable no-persistence routes so generated public operation projections match protected-main authority.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - operation-authority
contract-visible: Explanation-tree operation authority metadata now distinguishes read-only retrieval from immutable no-persistence endpoints.
Migration: No consumer migration required; SDK-visible operation shapes are unchanged.
2026-08-26 · previous
Axiom API 0.1.61
Publish metadata-only W02 runtime evidence corpus for provider-admissible API runtime and negative-evidence adjudication.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-evidence
contract-visible: Adds a sanitized runtime evidence corpus that records operation/runtime/test path metadata, hashes, and negative-evidence markers without raw source content or tenant payload examples.
Migration: No consumer migration required; this is metadata-only API evidence publication with no SDK surface change.
2026-08-26 · previous
Axiom API 0.1.60
Publish per-operation consumer proof for generated SDK and agent-index consumers.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-consumer-proof
contract-visible: Adds a generated consumer-proof matrix that separates live generated SDK and agent-index proof from historical W02 discovery references for each public operation.
Migration: No request or response migration is required; this is additive public contract metadata and proof.
2026-08-26 · previous
Axiom API 0.1.59
Publish transport-surface proof metadata for registered non-REST API boundaries.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - transport-surfaces
contract-visible: Transport surface registry entries now expose delivery, retry, receipt, ordering, replay, redaction, and tenant-isolation proof posture.
Migration: No SDK migration is required; this is contract metadata for transport boundary proof and does not change REST payload shapes.
2026-08-26 · previous
Axiom API 0.1.58
Adds a governed public response/error envelope profile policy and CI guard for alpha migration exceptions.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-contract
contract-visible: Public API envelope and error profile divergence is now classified against a canonical JSON:API target, with bare and mixed profiles restricted to explicit alpha migration exceptions and rejected for beta-facing operations.
Migration: No consumer wire-shape migration is required by this release record. Existing API 0.1.x consumers see no SDK-visible contract shape change; this records governance and publication metadata only.
2026-08-26 · previous
Axiom API 0.1.57
Refreshes public operation inventory and semantic spine metadata against the current public API contract so audit/security metadata remains current.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - public API contract metadata
contract-visible: Public operation inventory and semantic spine metadata now select the current API contract and preserve public audit metadata for sensitive operations.
Migration: No client migration required; SDK operation surfaces are unchanged.
2026-08-26 · previous
Axiom API 0.1.56
Adds governed publication disposition metadata for operation-authority entries that are not present in the public operation inventory.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - public API contract metadata
contract-visible: Public contract metadata now explains whether operation-authority entries are public, internal, future-public, or otherwise explicitly excluded from the public operation inventory.
Migration: No client migration required; SDK operation surfaces are unchanged.
2026-08-26 · previous
Axiom API 0.1.55
Public operation inventory now exposes runtime availability for operations that are intentionally published as unavailable.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-contract-portfolio
contract-visible: Adds runtime availability metadata to public operation inventory entries so 501/unavailable operations are explicit to consumers and audit tooling.
Migration: No consumer migration required; this is additive metadata in generated public contract inventory.
2026-08-25 · previous
Axiom API 0.1.54
Public operation inventory now projects operation-authority audit obligations as audit_contract metadata for audited operations.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - security-contracts
contract-visible: Public operation inventory consumers can inspect audit obligation metadata for audited operations; no request or response wire shape changes.
Migration: No consumer migration required; this is additive metadata in generated public contract inventory.
2026-08-25 · previous
Axiom API 0.1.53
Admin tenant creation now documents the platform_admin realm-role requirement instead of a legacy X-Admin-Token header placeholder.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - security
contract-visible: The /v1/admin/tenants contract no longer advertises the legacy X-Admin-Token parameter and now declares the platform_admin realm-role security requirement.
Migration: Consumers must authenticate as a platform_admin actor; do not send or depend on X-Admin-Token for tenant administration.
2026-08-24 · previous
Axiom API 0.1.52
Publishes the internal WorkSession SDK entrypoints for the collaboration surface while preserving the existing public /v1 contract projection.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - developer-preview-sdk
contract-visible: Adds internal WorkSession SDK helpers and consumer import proof for WorkSession session reads, authority decisions, evidence bundles, and event replay.
Migration: No public API migration is required. Internal collaboration-surface consumers may import the new @axiom/sdk internal WorkSession entrypoints.
2026-08-24 · previous
Axiom API 0.1.51
Adds the browser-facing WorkSession read contract, realtime replay transport, and smoke-test identity prerequisites.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - WorkSession API
contract-visible: Adds public WorkSession read endpoints and the WorkSession realtime replay WebSocket contract used by browser clients.
Migration: Consumers can mint a WorkSession-scoped realtime ticket with POST /v1/realtime/ticket and present it on the WorkSession replay WebSocket transport for the selected session; existing APIs are unchanged.
2026-08-24 · previous
Axiom API 0.1.50
Clarifies that internal WorkSession operations are excluded from developer-preview contract projections while the existing public /v1 surface remains unchanged.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - developer-preview-contract
contract-visible: The public developer contract excludes internal WorkSession routes and preserves the existing public operation surface.
Migration: No consumer API migration is required. Clients continue using the existing public /v1 operations.
2026-08-23 · previous
Axiom API 0.1.49
Clarifies that generated public operation metadata records the selected public API source bundle and digest used for operation-bound semantic artefact selection.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - public-operation-metadata
contract-visible: Generated public operation inventory and semantic spine metadata now record selected source bundle, selected public contract version, and digest parity evidence for AI-agent and SDK consumers.
Migration: No consumer API migration required. Clients may continue using the same /v1 operations; generated consumers can use the release metadata to audit selected source provenance.
2026-08-22 · previous
Axiom API 0.1.48
Classify /v1/products as a retired-route evidence token and enforce the boundary in CI without changing the active /v1/covers API surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-governance
contract-visible: The retired /v1/products route family is now governed by a machine-readable evidence boundary. Current API, SDK, learning, runtime, and developer guidance surfaces remain on /v1/covers; historical mentions are allowed only as classified evidence.
Migration: No client migration required; this is governance and CI enforcement for the already-retired /v1/products route family.
2026-08-22 · previous
Axiom API 0.1.47
Record Events/Assertions transport surfaces as not beta-facing in alpha with explicit promotion gates and reevaluation triggers.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events
contract-visible: Events/Assertions transport-surface metadata now records beta posture, promotion gates, and reevaluation triggers for async ingress event status and related surfaces.
Migration: No client migration required; this is contract governance metadata only.
2026-08-22 · previous
Axiom API 0.1.46
Rename the public Covers/Products aggregate root from the retired product-rooted route family to /v1/covers and publish the matching SDK/resource surface.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Clarified - covers-products
contract-visible: The Covers/Products public API root is now /v1/covers; product-rooted operations are removed from the current public contract.
Migration: Regenerate clients from API contract 0.1.46. Replace product-rooted route calls with /v1/covers, replace client.products with client.covers, replace product cover subresource calls with cover sections, and use covers:read/covers:write scopes.
2026-08-22 · previous
Axiom API 0.1.45
Declare and prove capability admission for Events/Assertions reporting and claim authorisation routes.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events
contract-visible: Events report and claim authorisation surfaces are now tied to explicit capability admission and seeded permission-set authority.
Migration: Consumers should ensure operator roles include the events.report and claims.authorise capabilities before calling these routes.
2026-08-22 · previous
Axiom API 0.1.44
Corrects Events/Assertions placeholder and retired operation exposure so audited claim analytics, audit, close, PDF, workflow, and security audit surfaces publish explicit live, unavailable, or retired dispositions.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events-assertions-contract
contract-visible: Corrected audited Events/Assertions operations so runtime-backed routes no longer publish placeholder/unavailable metadata, intentionally unavailable routes publish explicit 501 posture, and the retired claim workflow operation is removed from the published contract.
Migration: Regenerate clients from API contract 0.1.44. Do not call retired getClaimWorkflow; use claim detail plus audit surfaces. Treat unavailable analytics and claims-ratio routes as alpha-unavailable until their runtime implementations land.
2026-08-22 · previous
Axiom API 0.1.43
Publishes the migrated events, claims, assertions, inbox, and webhook delivery contract projections through the generated OpenAPI assembly.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events-claims-contracts
contract-visible: Events, claims, assertions, inbox message intake, and webhook delivery status operations now use the contract-generated OpenAPI projections in the published API bundle.
Migration: No client migration is required; operation IDs and routes remain stable while the published contract metadata is refreshed.
2026-08-22 · previous
Axiom API 0.1.42
Publishes Premium calculation, collection, and cancellation-refund command projections with canonical money shapes and fresh generated SDK clients.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Premium/Payment
contract-visible: Premium calculation now projects canonical money objects, and Premium collection/refund command surfaces are present in the public developer contract and generated clients.
Migration: Consumers should treat Premium calculation amount fields as money objects with amount_minor and currency_code, and regenerate clients from API 0.1.42 / SDK 0.1.28 before using the newly published Premium command helpers.
2026-08-22 · previous
Axiom API 0.1.41
Align public payment-schedule unavailable operations with the runtime NOT_IMPLEMENTED envelope and document listPaymentSchedules as the only supported schedule surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - premium-payment
contract-visible: Payment schedule create/detail/pause/resume operations now publish NOT_IMPLEMENTED 501 examples matching runtime; listPaymentSchedules remains the supported read-only cadence view.
Migration: Consumers should treat createPaymentSchedule, getPaymentSchedule, pausePaymentSchedule, and resumePaymentSchedule as unavailable operations and use listPaymentSchedules only for read-only cadence inspection until first-class schedule support lands.
2026-08-22 · previous
Axiom API 0.1.40
Clarifies that public Payment lifecycle states are pending, completed, and cancelled while provider settlement outcomes remain internal billing evidence.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - premiums/payments
contract-visible: PaymentStatus is clarified to the public lifecycle states pending, completed, and cancelled; failed, refunded, reversed, voided, and provider-specific settlement outcomes are internal evidence rather than public lifecycle states.
Migration: Consumers should treat public payment.status as pending, completed, or cancelled. Provider failure, refund, reversal, and void evidence must be read from billing/provider evidence surfaces rather than from PaymentStatus.
2026-08-21 · previous
Axiom API 0.1.39
Clarifies that public payment create, process, and cancel mutations require Idempotency-Key for replay-safe write handling.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - payments
contract-visible: Payment create, process, and cancel operations now declare the required Idempotency-Key request header in the public API contract.
Migration: API consumers must send a stable Idempotency-Key header when creating, processing, or canceling payments; retry the same operation with the same key for safe replay.
2026-08-21 · previous
Axiom API 0.1.38
Restores and proves public parties route-prefix coverage, aligns policy product-id handling, and documents route-prefix smoke proof for the 0.1.38 alpha contract.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - runtime,openapi,sdk,developer-experience
contract-visible: Adds live route-prefix smoke coverage for health, parties, products, party groups, and rulesets; restores parties prefix proof; aligns policy bind/direct product identifier handling; tightens ruleset add-rule validation.
Migration: Consumers should verify API version 0.1.38 or later before rerunning Wave 4 route/policy retests. No client code migration is expected beyond consuming regenerated SDK metadata.
2026-08-21 · previous
Axiom API 0.1.37
Restores route-prefix proof for external-builder UAT and reconciles policy bind, direct policy, tenant-id, and ruleset add-rule contract surfaces after API 0.1.33 regressions.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - api-runtime
contract-visible: Adds live route-prefix smoke coverage for protected parties/product/ruleset surfaces, documents lowercase tenant identifiers and tenant-admission pagination metadata, constrains add-rule codes before persistence, accepts typed product identifiers consistently on bind/direct policy paths, and maps missing pricing ruleset conditions to structured validation responses.
Migration: Regenerate strict clients from API contract 0.1.37 before continuing Wave 4 retests. Treat route-prefix smoke as the deployment proof that declared protected routes reach Axiom middleware; use typed prd_ product identifiers consistently across quote, bind, and direct policy paths.
2026-08-21 · previous
Axiom API 0.1.36
Clarifies canonical Covers/Products contract authority wording and aligns the async ingress status transport route template with runtime admission.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - contract-authority-and-ingress-transport
contract-visible: Canonicalised contract-authority wording to Covers/Products and aligned the async ingress status route template with the runtime colon-parameter form; no wire schema or SDK surface changed.
Migration: No consumer migration required; the public OpenAPI and SDK surface are unchanged.
2026-08-21 · previous
Axiom API 0.1.35
Clarifies the policies.bind contract description to use the canonical covers/products primitive wording and exposes the already-defined async ingress status path in the bundled OpenAPI projection.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - policies.bind
contract-visible: Updated the policies.bind description from product/cover context to covers/products context; no request, response, status, header, permission, or operation semantics changed.
- Fixed - async-ingress
contract-visible: Added the missing OpenAPI template reference for GET /v1/ingress/events/{ingress_id}, matching the existing ingress path file, transport-surface entry, operation authority, and runtime route.
Migration: No consumer migration required; policies.bind is wording-only and async ingress status projection now matches the already-defined runtime and contract source.
2026-08-21 · previous
Axiom API 0.1.34
Clarifies async ingress as durable receipt first, validation second, and adds tenant-scoped ingress status polling.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - async-ingress
contract-visible: POST /v1/ingress/events now documents received/status_url receipt semantics and GET /v1/ingress/events/{ingress_id} exposes the durable mailroom status trail for validation and processing outcomes.
Migration: Regenerate strict clients from API contract 0.1.34. Treat 202 from POST /v1/ingress/events as durable receipt only; poll the returned status_url for validation_failed, accepted, processing_failed, or completed outcomes before assuming a domain event exists.
2026-08-21 · previous
Axiom API 0.1.33
Converges the Wave 3 external-builder surfaces for product-to-policy prerequisites, payment method vocabulary, schema/runtime response truth, policy date and attribution handling, bind pricing preconditions, and Google cel-go numeric authoring guidance.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - developer-experience
contract-visible: Clarifies the product -> pricing ruleset -> product binding -> quote/policy journey, aligns payment method contract/runtime vocabulary, and corrects schema truth for lowercase typed IDs, lowercase currency, tenant-list metadata, assertion telemetry, and product cover status.
- Fixed - policy
runtime-parity: Direct policy creation now accepts the published YYYY-MM-DD date shape and RFC3339 date-time values, normalizes them before persistence, and returns structured 422 validation errors for invalid date input instead of opaque server errors.
- Clarified - policy
contract-visible: The createPolicy request schema now states that created_by is optional caller metadata; authoritative attribution comes from the authenticated actor context.
- Fixed - policy
runtime-parity: Inline and quote-backed policy bind premium calculation now carries the effective_date pricing fact into the product rating path so missing pricing ruleset preconditions surface as their stable product error codes.
- Clarified - rulesets
contract-visible: Ruleset contract and developer guidance now explain that JSON numeric facts may bind as CEL double values and that integer-only operators such as modulo require explicit int(), uint(), or double() conversions.
Migration: Regenerate strict clients from API contract 0.1.33 before retesting Wave 3 surfaces. Builders should follow the documented product -> pricing ruleset -> product binding -> quote/policy sequence, use the documented payment method values, send YYYY-MM-DD or RFC3339 values for direct policy effective_date and expiry_date, treat created_by as optional caller metadata, and add explicit numeric conversions when Google CEL reports overload errors such as "no such overload: _%_."
2026-08-21 · previous
Axiom API 0.1.32
Document Policy bind idempotency as the Idempotency-Key header used by runtime replay storage.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - policies
contract-visible: The policies.bind contract now names Idempotency-Key as the canonical idempotency key source, matching the REST bind handler and replay storage.
Migration: Consumers should continue supplying the Idempotency-Key header for POST /v1/policies/bind; body external_reference is not the bind idempotency source.
2026-08-21 · previous
Axiom API 0.1.31
Document runtime enforcement of the Policy bind scope.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - policies
contract-visible: The policies.bind contract now points to runtime enforcement through Policy route capability declarations and role-to-permission authorization checks.
Migration: Consumers should continue sending Bearer tokens with the policies:bind scope for POST /v1/policies/bind; unauthorized tenant grants are denied at runtime.
2026-08-21 · previous
Axiom API 0.1.30
Converges the public Policy lifecycle status vocabulary on draft, quoted, bound, active, lapsed, cancelled, and expired.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - policies
contract-visible: Policy.status now uses bound for issued policies and explicit terminal statuses for termination outcomes instead of issued or terminated.
Migration: Consumers should map issued to bound and terminated to the applicable cancelled, lapsed, or expired terminal status.
2026-08-20 · previous
Axiom API 0.1.29
Product activation attribution now comes from the authenticated actor context; the legacy activated_by request field is optional, deprecated, and ignored.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - products
contract-visible: Product activation no longer requires callers to send activated_by. Attribution is derived from the authenticated actor context, while activated_by remains as a deprecated compatibility field.
Migration: Stop sending activated_by on product activation requests; clients may send an empty body and rely on authenticated actor context for attribution.
2026-08-20 · previous
Axiom API 0.1.28
Corrects duplicate add-rule behavior so repeated rule codes return a structured conflict response instead of an opaque 500 response.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - rulesets
contract-visible: Duplicate rule-code submissions on POST /v1/rulesets/{id}/rules are now classified before persistence and return a structured conflict response. This closes the strengthened UAT R9 duplicate-rule residual without exposing persistence internals.
Migration: Consumers should treat duplicate rule-code submissions as conflict responses and avoid retrying them as transient platform failures. Regenerate SDKs from API 0.1.28 so generated clients classify duplicate add-rule responses correctly.
2026-08-20 · previous
Axiom API 0.1.27
Converges Product/Cover lifecycle statuses and makes cover-item kind catalogue-governed in public Product/Cover contract metadata.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - products-covers
contract-visible: Product and Cover lifecycle status metadata now align with runtime/domain lifecycle values, and CoverItem.type is documented as a cover-item-kinds catalogue code rather than a closed benefit/peril enum.
Migration: No wire field rename is introduced; clients should treat CoverItem.type as an open catalogue code. Existing benefit/peril values remain seeded examples.
2026-08-20 · previous
Axiom API 0.1.26
Corrects Product activate and add-cover mutation metadata so public contract projections classify persisted tenant-visible changes accurately.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - products-covers
contract-visible: Product activation and cover-add operations are classified as tenant-visible mutations with audit operation metadata aligned to runtime behavior.
Migration: No consumer payload migration is required; generated contract metadata and SDK-facing operation evidence become more precise.
2026-08-20 · previous
Axiom API 0.1.25
Publishes the Product audit feed as a first-class Product operation and restores pricing-rule assignment to the public SDK-visible Product/Cover operation surface.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Product/Cover public API
contract-visible: Adds the Product audit feed to the first-class Product OpenAPI projection and includes pricing-rule assignment in the public SDK-visible Product operation inventory.
Migration: Consumers may use GET /v1/covers/{id}/audit for Product audit entries and POST /v1/covers/{id}/pricing-rules through generated SDK clients.
2026-08-19 · previous
Axiom API 0.1.24
Align product creation, public error safety, CEL rules execution, rule outcome semantics, and strict-schema nullability with the published alpha API contract.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Runtime and rules contract truth
contract-visible: Updated the public contract for the alpha recovery wave: product cover identity creation, centralized client-safe errors, Google CEL rules execution, deterministic rule outcomes, explicit no-hidden-rule behaviour, and nullable fields observed on strict validator surfaces.
Migration: Regenerate clients from API contract 0.1.24 before retesting product creation or ruleset authoring. Treat earlier 0.1.22 product-write and ruleset-result behaviour as superseded alpha evidence until live proof on this release is available.
2026-08-19 · previous
Axiom API 0.1.23
Publishes Party balance and role revocation as runtime-backed public operations and adds contract authority for Party role revocation.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - parties
contract-visible: GET /v1/parties/{id}/balance and DELETE /v1/parties/{id}/roles/{roleId} are now visible in the public Party contract with runtime-required tenant context and path parameters; role revocation is tied to the parties.revokeRole contract.
Migration: No runtime migration required. Consumers generated from API 0.1.23 should treat Party balance and role revocation as available alpha Party operations and supply the required X-Tenant-Context and path parameters.
2026-08-19 · previous
Axiom API 0.1.22
Stop publishing JSON:API success-profile claims for operations whose public response schema is the legacy data/status envelope.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Public contract wire profile metadata
contract-visible: Corrected generated public OpenAPI metadata so x-axiom-wire-success-profile is emitted only when the derived public success response profile is JSON:API. Legacy data/status responses now publish legacy-envelope in x-axiom-contract-consistency and public maturity metadata instead of being upgraded by source annotations.
Migration: Do not generate SDK deserializers from x-axiom-wire-success-profile alone on contracts before 0.1.22. Use x-axiom-contract-consistency.response_profile or the response schema; operations without x-axiom-wire-success-profile may still return the documented legacy envelope during alpha.
2026-08-19 · previous
Axiom API 0.1.21
Party role_type and relationship_type public surfaces resolve through tenant catalogue authority instead of hardcoded runtime enumerations.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - parties
contract-visible: Role and relationship type values are tenant catalogue codes; malformed code shape still fails at the API boundary and unknown tenant vocabulary fails during catalogue resolution.
Migration: Consumers should treat role_type and relationship_type as tenant catalogue codes, not generated closed enums.
2026-08-19 · previous
Axiom API 0.1.20
Classify closeClaim as an unavailable alpha route-accountability surface until terminal-state authority and closure workflow runtime are implemented.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Claim lifecycle route accountability
contract-visible: Corrected POST /v1/claims/{id}/close so the public contract no longer advertises a successful close response while the runtime returns 501. The operation remains visible for route accountability and now declares unavailable alpha runtime posture until claim terminal-state authority, irreversible closure workflow, and closure audit semantics are implemented.
Migration: Do not call POST /v1/claims/{id}/close for client workflows in API 0.1.20. Treat claim closure as alpha-unavailable and keep terminal claim lifecycle work behind the governed runtime implementation slice.
2026-08-19 · previous
Axiom API 0.1.19
Corrects the public Party audit response contract to include audit context fields observed during alpha UAT while preserving the declared decision/input old/new value audit substance.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - public-contract-accuracy
contract-visible: GET /v1/parties/{id}/audit now declares purpose, compliance_category, data_classification, and additional_context alongside the existing audit substance fields so strict consumers no longer reject runtime Party audit events.
Migration: No runtime migration required. Consumers generated from the corrected OpenAPI contract should accept the additional audit context fields on Party audit events.
2026-08-19 · previous
Axiom API 0.1.18
Corrects the public role-types contract to match the runtime catalogue-shaped response and offset metadata observed during alpha UAT.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - public-contract-accuracy
contract-visible: GET /v1/parties/role-types now documents catalogue entry objects with role metadata and offset pagination meta instead of a string array with total-only metadata.
Migration: No runtime migration required. Consumers generated from the corrected OpenAPI contract should treat role-types as catalogue objects.
2026-08-19 · previous
Axiom API 0.1.17
Align ruleset OpenAPI with runtime enum and request-body truth, unwrap documented ruleset test facts, return conflict for inactive ruleset tests, and allow dotted fact selector evaluation.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - rulesets
contract-visible: Ruleset API documentation and runtime now agree on ruleset entity_type values, rule_type values, deploy/test-rule bodies, inactive-test conflict semantics, and dotted fact selector evaluation for alpha builder UAT.
Migration: No database migration.
2026-08-17 · previous
Axiom API 0.1.16
Completes the public wire-contract header and telemetry proof burn-down for the remaining residual operations.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Wire convergence
contract-visible: Adds operation-bound proof for closeBillingCycle, getEvent, applyProrationAdjustment, listPartyAudit, listPartyPolicyGroups, and exportReport so public headers and telemetry are no longer alpha migration debt.
Migration: No consumer migration required; this release clarifies and proves existing response header and telemetry posture.
2026-08-17 · previous
Axiom API 0.1.15
Publishes operation-bound header and telemetry proof for public intake and object operations, reducing residual API 0.1.x wire-convergence debt.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - headers-telemetry
contract-visible: Converged public header and response telemetry evidence for ingestArchiveObject, receiveInboxMessage, ingestEvent, and initiateObjectUpload.
Migration: No client migration required. Consumers gain clearer contract evidence for bounded intake/object responses and SDK-visible metadata.
2026-08-17 · previous
Axiom API 0.1.14
Adds operation-bound header and response telemetry proof for residual public Premiums operations.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Contract proof
contract-visible: Residual Premiums operations now have operation-bound public header and telemetry proof for bounded validation or unavailable responses.
Migration: No client migration required. Consumers may observe the patch-level API contract version and refreshed generated reference artifacts.
2026-08-17 · previous
Axiom API 0.1.13
Publishes operation-bound Replacements header and response telemetry proof and reduces DXR-M9 public wire-convergence debt.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Public contract telemetry proof
contract-visible: Adds operation-bound runtime proof for the public Replacements operation family and updates the wire-convergence matrix/report to classify those five operations as header/telemetry converged.
Migration: No runtime or SDK migration required; this is a public proof and documentation patch release.
2026-08-17 · previous
Axiom API 0.1.12
Adds operation-bound header and telemetry proof for selected public Events API operations, reducing documented alpha wire-convergence debt without changing request or response payload semantics.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - events-header-telemetry-proof
contract-visible: Selected Events operations now carry generated public contract evidence for X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, tenant-context posture, and response telemetry on operation-bound bounded runtime paths.
Migration: No application migration is required. Consumers should continue using the published Events routes and may rely on the updated API reference and SDK metadata to identify the improved header and telemetry proof posture.
2026-08-16 · previous
Axiom API 0.1.11
Adds operation-bound header and telemetry proof for selected public Ledger API operations, reducing documented alpha wire-convergence debt without changing request or response payload semantics.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - ledger-header-telemetry-proof
contract-visible: Ledger operations now carry generated public contract evidence for X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, tenant-context posture, and response telemetry on operation-bound bounded runtime paths.
Migration: No application migration is required. Consumers should continue using the published Ledger routes and may rely on the updated API reference and SDK metadata to identify the improved header and telemetry proof posture.
2026-08-16 · previous
Axiom API 0.1.10
Adds operation-bound header and telemetry proof for selected public Catalogue API operations, reducing documented alpha wire-convergence debt without changing request or response payload semantics.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - catalogue-header-telemetry-proof
contract-visible: Catalogue operations now carry generated public contract evidence for X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, tenant-context posture, and response telemetry on operation-bound bounded runtime paths.
Migration: No application migration is required. Consumers should continue using the published Catalogue routes and may rely on the updated API reference and SDK metadata to identify the improved header and telemetry proof posture.
2026-08-16 · previous
Axiom API 0.1.9
Adds operation-bound header and telemetry proof for the public Quotes API family, reducing documented alpha wire-convergence debt without changing request or response payload semantics.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - quotes-header-telemetry-proof
contract-visible: Quotes operations now carry generated public contract evidence for X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, tenant-context posture, and response telemetry on operation-bound validation paths.
Migration: No application migration is required. Consumers should continue using the published Quotes routes and may rely on the updated API reference and SDK metadata to identify the improved header and telemetry proof posture.
2026-08-16 · previous
Axiom API 0.1.8
Adds operation-bound header and telemetry proof for the public Policies API family, reducing documented alpha wire-convergence debt without changing request or response payload semantics.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - policies-header-telemetry-proof
contract-visible: Policies operations now carry generated public contract evidence for X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, tenant-context posture, and response telemetry on operation-bound validation paths.
Migration: No application migration is required. Consumers should continue using the published Policies routes and may rely on the updated API reference and SDK metadata to identify the improved header and telemetry proof posture.
2026-08-16 · previous
Axiom API 0.1.7
Publishes operation-bound header and telemetry proof for the public Claims API family.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - headers-telemetry
contract-visible: Adds operation-bound runtime proof for Claims public API headers, correlation, server timing, tenant-context posture, deprecation headers, and response telemetry evidence.
Migration: No consumer code migration required. Consumers may treat the Claims API family as carrying operation-bound header and telemetry proof in the developer-preview contract evidence.
2026-08-16 · previous
Axiom API 0.1.6
Publishes operation-bound header and telemetry proof for the public Rulesets API family.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - headers-telemetry
contract-visible: Adds operation-bound runtime proof for Rulesets public API headers, correlation, server timing, tenant-context posture, and response telemetry evidence.
Migration: No consumer code migration required. Consumers may treat the Rulesets API family as carrying operation-bound header and telemetry proof in the developer-preview contract evidence.
2026-08-16 · previous
Axiom API 0.1.5
Publishes operation-bound header and telemetry proof for the public Vendors API family.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - headers-telemetry
contract-visible: Adds operation-bound runtime proof for Vendors public API headers, correlation, server timing, tenant-context posture, and response telemetry evidence.
Migration: No consumer code migration required. Consumers may treat the Vendors API family as carrying operation-bound header and telemetry proof in the developer-preview contract evidence.
2026-08-16 · previous
Axiom API 0.1.4
Publishes operation-bound header and telemetry proof for the public Party Groups API family.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - headers-telemetry
contract-visible: Adds operation-bound runtime proof for Party Groups public API headers, correlation, server timing, tenant-context posture, and response telemetry evidence.
Migration: No consumer code migration required. Consumers may treat the Party Groups API family as carrying operation-bound header and telemetry proof in the developer-preview contract evidence.
2026-08-16 · previous
Axiom API 0.1.3
Publishes operation-bound Products header and telemetry proof as a visible patch release.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Products header and telemetry proof
contract-visible: Added operation-bound runtime proof for selected Products operations, binding public Products read/write flows to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, server-minted tenant context, and controlled tenant-owned response scope.
Migration: No application migration is required. Consumers should treat 0.1.3 as the visible patch release for Products proof metadata and regenerated public API artefacts.
2026-08-16 · previous
Axiom API 0.1.2
Publishes operation-bound Parties header and telemetry proof as a visible patch release.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Parties header and telemetry proof
contract-visible: Added operation-bound runtime proof for selected Parties operations, binding public Parties read/write flows to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, server-minted tenant context, and controlled tenant-owned response scope.
Migration: No application migration is required. Consumers should treat 0.1.2 as the visible patch release for Parties proof metadata and regenerated public API artefacts.
2026-08-16 · previous
Axiom API 0.1.1
Publishes operation-bound Mailroom webhook header and telemetry proof as a visible patch release.
- API family
v1
- Version impact
patch
- Contract authority
api/contracts
- Clarified - Mailroom webhook header and telemetry proof
contract-visible: Added operation-bound runtime proof for registerWebhookEndpoint and getWebhookDeliveryStatus success responses, binding the public Mailroom webhook operations to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, server-minted tenant context, and controlled tenant-owned webhook response scope.
Migration: No application migration is required. Consumers should treat 0.1.1 as the visible patch release for the Mailroom webhook proof metadata and regenerated public API artefacts.
2026-08-09 · previous
Axiom API 0.1.0
Axiom API 0.1.0 is the first developer-preview contract line for admitted alpha consumers. It publishes the /v1 API family, generated OpenAPI reference, tenant-context posture, SDK compatibility evidence, agent-readable contract metadata, scoped bundles, and the first contract-shaped starting surface for client and agent integration work.
- API family
v1
- Version impact
minor-breaking
- Contract authority
api/contracts
- Added - API reference
contract-visible: Published a generated, versioned OpenAPI reference for the /v1 developer preview contract.
- Added - Tenant context
runtime-parity: Documented the admitted-alpha tenant-context model: authenticate, discover admitted tenants, mint server-issued tenant context, and send it on tenant-scoped calls.
- Added - Developer experience
docs-only: Added public quickstart, guide, machine-readable llms.txt, resource bundles, and collection exports for API consumers and AI agents.
- Added - Agent contract index
agent-metadata: Added machine-readable operation metadata so AI coding agents can find operation maturity, auth posture, tenant-context posture, SDK exposure, and scoped bundle references without scraping prose.
- Added - Scoped bundles
contract-visible: Added generated OpenAPI bundle manifests and journey-scoped bundles so consumers can inspect smaller contract slices for bootstrap, parties, policies, claims, benefits, documents, and operational health.
- Added - SDK ergonomics
sdk-visible: Added SDK ergonomics evidence that classifies envelope, pagination, identifier, money, coded-value, auth, and tenant-context exposure for generated TypeScript and Python clients.
- Clarified - Quote success envelopes
sdk-visible: Classified quote create, list, retrieve, approve, decline, bind, and supersession-chain operations as JSON:API success-envelope operations based on their shared success envelope schemas and runtime success handlers.
- Clarified - Product success envelopes
sdk-visible: Classified product create, list, retrieve, update, activate, pricing-rule list, cover list, and cover create operations as JSON:API success-envelope operations based on their shared success envelope schemas and runtime success handlers.
- Clarified - Party-group success envelopes
sdk-visible: Classified party-group list, create, retrieve, update, member, role, traversal, evaluation, and audit operations as JSON:API success-envelope operations based on their shared success envelope schemas and runtime success handlers.
- Clarified - Alpha auth and retry semantics
runtime-parity: Added explicit alpha auth, tenant-context, and retry semantics so safe read calls, restricted mutations, bootstrap operations, and support evidence have a governed consumer contract.
- Clarified - Public safety
docs-only: Removed non-public delivery context, unsupported performance commitments, and client-specific language so the developer surface remains tenant-neutral and public-safe.
- Clarified - Public OpenAPI runtime contract
runtime-parity: Bound the runtime-served OpenAPI endpoints and health contract provenance to the same public developer-preview bundle published through the versioned developer reference, while retaining the full internal OpenAPI bundle for governed repository tooling.
- Added - Public OpenAPI structural validity
contract-visible: Added a generated public OpenAPI structural-validity gate for the versioned developer reference and scoped public bundles so developer documentation remains machine-consumable by Redocly, SDK tooling, and AI agents.
- Clarified - Public envelope metadata
sdk-visible: Relaxed empty object projections for success envelope meta, links, and telemetry fields to explicit string-keyed object maps so generated OpenAPI, scoped bundles, API reference, and TypeScript/Python SDK models no longer advertise impossible closed-empty extension objects.
- Clarified - Webhook and async alpha posture
contract-visible: Corrected the admitted-alpha webhook endpoint registration and async ingress contract posture so generated docs no longer imply unavailable event subscription catalogues, body-level ingress idempotency, or stable webhook semantics before the governed follow-on contracts land.
- Clarified - Webhook receiver verification
runtime-parity: Clarified the admitted-alpha outbound webhook receiver verification contract for HMAC-signed deliveries, including timestamp format, signature base string, replay-window guidance, constant-time comparison, and failure posture for malformed, stale, or mismatched signatures.
- Clarified - Webhook delivery semantics
runtime-parity: Clarified the admitted-alpha outbound webhook delivery model as at-least-once and unordered. The delivery id is reused across retry attempts for the same delivery record, but is not a stable canonical event id across endpoints, event streams, or schema revisions.
- Clarified - Webhook subscription catalogue
contract-visible: Clarified that webhook endpoint registration in 0.1.0 records receiver transport settings only. Event subscription catalogues, routing rules, replay policy, ordering keys, and tenant-owned event schema publication are governed separately and are not public self-service payload fields.
- Clarified - Async event schema catalogue
contract-visible: Clarified that async ingress event types, payload schemas, and promotion rules are not public self-service catalogues in API 0.1.0. The ingress route accepts tenant-owned boundary data for asynchronous handling; a 202 response means durable boundary acceptance only, not validation, promotion, or domain mutation.
- Clarified - Async ingress transport exception
runtime-parity: Accepted async ingress as a governed transport exception for API 0.1.0 and added a static parity verifier tying the transport registry, operation authority, OpenAPI route, endpoint-specific 202 response, tenant-context requirement, header-or-hash idempotency, and runtime tests together.
- Added - Public error catalogue
docs-only: Published a generated, versioned public error catalogue from public OpenAPI help_url values, and moved public error help_url examples from versionless /errors/... links to the versioned /api/reference/0.1.0/errors/<CODE>/ path. Added a public error-link validator wired into public-safety and API contract checks, and linked the catalogue from the developer home page, API guide, and llms.txt. No identifier, money, response pagination, or runtime behavior semantics changed.
- Added - Exact money contract
sdk-visible: Added the public exact-money inventory, alpha exception classifications, generated OpenAPI money annotations, and TypeScript/Python source-only money codecs so consumers do not treat monetary values as unsafe JSON floats while API 0.1.0 remains in developer preview.
- Added - Identifier contract
contract-visible: Added generated identifier-shape metadata and a public identifier inventory so consumers can tell whether each public id field is a typed-prefix identifier, UUID, or explicit alpha exception without reverse-engineering examples or runtime handlers.
- Clarified - Tenant-context auth parity
runtime-parity: Aligned the public tenant-context contract with runtime enforcement so missing, malformed, expired, unsupported, and unauthorized X-Tenant-Context values fail with explicit public error semantics while unauthenticated tenant-bootstrap routes remain correctly classified for admitted alpha access flows.
- Added - Five Acts examples
docs-only: Added public Five Acts developer-example conformance checks and aligned generated examples, collections, and public guide references with the selected API 0.1.0 contract, including the admitted-alpha async ingress transport exception.
- Clarified - Rulesets cursor pagination
sdk-visible: Converged the public listRulesets operation from legacy limit/offset pagination to canonical cursor pagination using page[size], page[after], has_more, and next_cursor metadata. API 0.1.0 remains under the governed alpha wave version hold while pagination debt is burned down.
- Clarified - Assertions success envelope
sdk-visible: Converged the public listAssertions and getAssertion operations from legacy-envelope classification to the canonical JSON success-envelope profile already used by their runtime handlers. API 0.1.0 remains under the governed alpha wave version hold while envelope debt is burned down.
- Clarified - Payments cursor pagination
sdk-visible: Converged the public listPayments operation from legacy limit/offset pagination to canonical cursor pagination using page[size], page[after], has_more, and next_cursor metadata. API 0.1.0 remains under the governed alpha wave version hold while pagination debt is burned down.
- Clarified - Party payments cursor pagination
sdk-visible: Converged the public getPartyPayments operation from legacy limit/offset pagination to canonical cursor pagination using page[size], page[after], has_more, and next_cursor metadata. API 0.1.0 remains under the governed alpha wave version hold while pagination debt is burned down.
- Clarified - Parties pagination
sdk-visible: Converged the public listParties operation on runtime-proven cursor pagination, removed the legacy limit/offset/sort contract shape from the public reference, and updated TypeScript and Python SDK paging helpers so developer-preview consumers can iterate parties without relying on offset-style assumptions.
- Clarified - SDK bootstrap
sdk-visible: Exposed the public health bootstrap operation through the generated TypeScript and Python developer-preview SDK clients and aligned successful non-enveloped response handling so SDK examples can prove API reachability without dropping to raw HTTP.
- Clarified - Agent route manifests
agent-metadata: Bound the generated agent contract index and public bundle manifest to the versioned public OpenAPI contract, and added route-validity checks so recommended bootstrap and first-flow operation references cannot drift away from the published API 0.1.0 operation inventory.
- Added - Lifecycle guide
docs-only: Added a public lifecycle and state guide so developers and AI agents can display contract-visible status fields without inventing tenant-owned vocabulary, hidden workflow transitions, or unavailable mutation behaviour.
- Clarified - SDK contract projections
agent-metadata: Refreshed generated operation semantics, agent contract index, SDK ergonomics, and alpha auth tenant-context retry metadata so the public health bootstrap operation and backend-owned SDK consumption path remain consistent across contract, SDK, and agent-facing surfaces.
- Clarified - API collections and alpha access
docs-only: Refreshed the generated Postman and Insomnia collections so tenant-context minting uses an explicit tenant_id variable instead of a static request body, and recorded the alpha access request boundary for approved tenant admission evidence while API 0.1.0 remains in developer preview.
- Clarified - Public API examples
contract-visible: Validated public OpenAPI examples against the versioned developer-preview contract and refreshed generated SDK operation tests so example payloads, public catalogue entry access, scoped bundles, and developer reference artefacts stay aligned with API 0.1.0 without introducing a public version bump.
- Clarified - Pagination contract
sdk-visible: Classified the finite party role-type and role-type usage lists as governed bounded-list pagination exceptions. The public OpenAPI, semantic spine, wire-convergence matrix, SDK ergonomics contract, and developer reference now agree that these endpoints intentionally expose meta.total without cursor traversal while broader pagination convergence continues under the DXR-M9 reduction queue.
- Clarified - Report export errors
contract-visible: Converged the public exportReport error response on the shared JSON:API ErrorResponse contract and tightened the wire-convergence guard so API 0.1.0 no longer carries residual error-envelope alpha migration debt for this binary export operation. The successful export response remains a named binary-content alpha posture and is not over-claimed as a JSON success envelope.
- Clarified - Introspection header and telemetry proof
contract-visible: Added operation-bound alpha proof for the public health and OpenAPI introspection operations, binding each route to public auth, tenant-context-free posture, header evidence, telemetry evidence, and no-tenant-business-data proof. Header and telemetry convergence debt is not reclassified until browser-visible header exposure and response-level telemetry proof are complete.
- Clarified - Benefits success envelopes
contract-visible: Converged the public benefits operation family on explicit success envelope metadata across OpenAPI, public bundles, SDK ergonomics, operation manifests, and wire-convergence projections while keeping API 0.1.0 in the accepted alpha version-hold wave.
- Clarified - Introspection header and telemetry proof
contract-visible: The X-API-Version response header is now emitted on the unknown-API- version rejection path, not only on successful requests, so a client that mis-targets a retired or unrecognised version still observes the pinned contract version on the response. Tightened the public header-and-telemetry-proof check and its regression test coverage for the introspection routes. Header and telemetry convergence debt is not reclassified by this wave; broader convergence remains tracked under the same DXR-M9 reduction queue.
- Clarified - Assertions cursor pagination
sdk-visible: Converged the public listAssertions operation on cursor pagination in the OpenAPI contract and generated SDK surfaces. Clients now use page[size] and page[after] and receive the shared cursor pagination metadata shape while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Claim reserve success envelopes
contract-visible: Converged the public claim reserve operation family on explicit success-envelope metadata across OpenAPI, public bundles, SDK ergonomics, operation manifests, and wire-convergence projections while keeping API 0.1.0 in the accepted alpha version-hold wave.
- Clarified - Events cursor pagination
sdk-visible: Converged the public listEvents operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Audit cursor pagination
sdk-visible: Converged the public getRecentAuditEntries operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Products cursor pagination
sdk-visible: Converged the public listProducts operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Party groups cursor pagination
sdk-visible: Converged the public listPartyGroups operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Party audit cursor pagination
sdk-visible: Converged the public listPartyAudit operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Party-group audit cursor pagination
sdk-visible: Converged the public listPartyGroupAudit operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Premiums cursor pagination
sdk-visible: Converged the public listPremiums operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Policies cursor pagination
sdk-visible: Converged the public listPolicies operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Claims cursor pagination
sdk-visible: Converged the public listClaims operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Catalogue entries bounded-list pagination
sdk-visible: Classified the public listCatalogueEntries operation as an explicit API 0.1.0 bounded-list exception. The point-in-time entries read no longer publishes page traversal parameters, rejects legacy limit pagination fail-loud at runtime, and points full-history traversal to the cursor-paginated entries history operation while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Payment schedules cursor pagination
sdk-visible: Converged the public listPaymentSchedules operation on cursor pagination in the runtime handler, OpenAPI contract, generated developer reference, and SDK-visible public projections. Clients now use page[size] and page[after], receive shared cursor metadata, and get fail-loud correction when legacy limit/offset pagination is supplied while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Analytics route accountability
contract-visible: Corrected the public getTopProducts analytics operation so API 0.1.0 no longer advertises unavailable list/query semantics or a success payload while the runtime returns 501. The route remains visible for accountability, but generated docs and SDK projections now treat it as an unavailable not-list operation until tenant-owned analytics projections are implemented.
- Clarified - Inbox receive success envelope
sdk-visible: Converged the public receiveInboxMessage operation on the canonical success-envelope response shape in runtime, OpenAPI, generated developer reference, and SDK-visible public projections. Accepted and duplicate receipts now sit under the shared data envelope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Analytics route accountability
contract-visible: Classified the public analytics route family as runtime-unavailable route-accountability entries for API 0.1.0. The dashboard, claims-by-status, monthly-revenue, and top-products routes now publish their real 501 JSON:API error posture instead of unavailable 200 success payloads, while tenant-owned analytics projections remain governed follow-on runtime work.
- Clarified - Recent audit success envelope
sdk-visible: Converged the public getRecentAuditEntries operation on the canonical success-envelope response shape in runtime, OpenAPI, generated developer reference, and SDK-visible public projections. Recent audit entries now return a shared success envelope with data and meta page fields while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Rulesets success envelopes
sdk-visible: Converged the public rulesets operation family on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. The public contract now reflects the runtime-emitted data and meta envelopes for rulesets, business rules, rule deletion, and ruleset test responses while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Payments success envelopes
sdk-visible: Converged the public payments operation family on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. Payment list, create, read, update, process, and cancel responses now compose the shared success envelope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Invoices success envelopes
sdk-visible: Converged the public invoice operation family on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. Invoice list, read, and finalize responses now compose the shared success envelope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Billing cycle close success envelope
sdk-visible: Converged the public close billing cycle operation on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. The close cycle response now composes the shared invoice success envelope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Payment schedule list success envelope
sdk-visible: Converged the public list payment schedules operation on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. The implemented list operation now composes the shared payment-schedule list success envelope; create and read schedule operations remain separately governed alpha debt until their runtime success paths are available.
- Clarified - Compliance report success envelope
sdk-visible: Converged the public getComplianceReport operation on the canonical success-envelope response shape in runtime, OpenAPI, generated developer reference, and SDK-visible public projections. Compliance reports now return under the shared data envelope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Ledger success envelopes
sdk-visible: Converged the public ledger operation family on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. Account balance, ledger entry list, correction lineage, reversal creation, and integrity verification responses now compose the shared success envelope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Auth bootstrap success envelopes
sdk-visible: Converged the public auth-bootstrap tenant discovery and tenant-context mint operations on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. The access model, tenant admission checks, and private tenant-context token semantics remain unchanged while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Mailroom webhook success envelopes
sdk-visible: Converged the public Mailroom webhook endpoint registration and delivery status operations on the canonical success-envelope response shape in runtime, OpenAPI, generated developer reference, and SDK-visible public projections. Error responses remain on the JSON:API error profile while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Premiums success envelopes
sdk-visible: Converged the public premiums read, create, and proration-balance operations on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. Runtime already emitted the shared success envelope; this change aligns the public wire profile with that proof while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Evidence-pack success envelopes
sdk-visible: Converged the public evidence-pack assembly and retrieval operations on the canonical success-envelope response shape in runtime, OpenAPI, generated developer reference, and SDK-visible public projections. Evidence-pack assembly is documented at its implemented 200 success status while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Archive ingest success envelope
sdk-visible: Converged the public archive-object ingestion operation on the canonical success-envelope response shape in OpenAPI, generated developer reference, and SDK-visible public projections. Runtime already emitted the shared success envelope; this change aligns the public wire profile with that proof while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Payment schedule runtime availability
sdk-visible: Reclassified payment schedule create and detail operations as route-accountability surfaces in API 0.1.0 because the runtime currently returns 501 until those workflows are implemented. The public contract no longer advertises unavailable 2xx success responses for those operations; list, pause, and resume semantics remain unchanged while API 0.1.0 stays in the accepted alpha version-hold wave.
- Clarified - Evidence-record success envelopes
sdk-visible: Converged the public evidence-record create, retrieve, query, batch verification, and integrity-verification operations on the canonical success-envelope response shape in runtime, OpenAPI, generated developer reference, and SDK-visible public projections. Error responses remain on the JSON:API error profile while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Event success envelopes
sdk-visible: Converged the public event read, document upload, event report, and event-effective proration adjustment operations on the canonical success-envelope response shape in OpenAPI, generated contract projections, developer reference, and SDK-visible public projections. Runtime already emitted the shared success envelope for these operations; this change aligns the public wire profile with that proof while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Policy success envelopes
sdk-visible: Converged the public policy create, list, retrieve, version, issue, activate, endorsement, certificate, and bind operations on the canonical success-envelope response shape in OpenAPI, generated contract projections, developer reference, and SDK-visible public projections. Runtime already emitted the shared success envelope for these operations; this change aligns the public wire profile with that proof while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Party success envelopes
sdk-visible: Converged the public party read, write, role, contact, identity, relationship, audit, policy-group, inverse party-group, payment, and role-type operations on the canonical success-envelope response shape in OpenAPI, generated contract projections, developer reference, and SDK-visible public projections. Runtime already emitted the shared success envelope for these operations; this change aligns the public wire profile with that proof while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Claim success envelopes and binary exports
sdk-visible: Converged the public claim list, submit, retrieve, assess, authorise, pay, close, investigation, recovery, and recovery-correction operations on the canonical success-envelope response shape in OpenAPI, generated contract projections, developer reference, and SDK-visible public projections. File-return routes such as claim PDF and report export are now classified as explicit binary success-body exceptions rather than JSON success envelopes while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Catalogue entries bounded-list body
sdk-visible: Classified the public catalogue entries point-in-time read as an explicit bounded-list success-body exception. The operation intentionally returns entries and count without cursor traversal; full-history traversal remains on the cursor-paginated entries history route while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Analytics header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public analytics unavailable routes. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the deliberate 501 alpha response to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and no tenant business data while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Payment-schedule header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public payment-schedule unavailable routes. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the deliberate 501 alpha response to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and no tenant business data while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Tenant-bootstrap header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public tenant-bootstrap routes that discover admitted tenants and mint server-authoritative tenant-context tokens. The proof exercises bearer-authenticated requests without requiring X-Tenant-Context and binds the 200 bootstrap responses to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and SDK-visible bootstrap response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - List payment schedules header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public listPaymentSchedules read path. The proof exercises an authenticated bearer plus server-minted tenant-context request through the live router and binds the 200 cursor-page response to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned read-response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Benefits header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public benefits read operations. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the 200 responses for getBenefitAvailable and getBenefitBalance to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned read-response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Assertions header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public assertions read operations. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the 200 responses for listAssertions and getAssertion to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned read-response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Invoices header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public invoice operations. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the 200 responses for listInvoices, getInvoice, and finalizeInvoice to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned invoice response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Recent-audit header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public recent-audit read operation. The proof exercises an authenticated bearer plus server-minted tenant-context request through the live router and binds the 200 cursor-page response for getRecentAuditEntries to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-scoped read-response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Compliance report header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public compliance report read operation. The proof exercises an authenticated bearer plus server-minted tenant-context request through the live router and binds the 200 response for getComplianceReport to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned compliance report response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Premium read header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public premium read operations. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the 200 responses for listPremiums and getPremium to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned premium response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Payments header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public payments operations. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the success responses for listPayments, createPayment, getPayment, updatePayment, cancelPayment, and processPayment to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned payment response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Evidence-record header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public evidence-record operations. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the success responses for createEvidenceRecord, queryEvidence, verifyEvidence, getEvidenceRecord, and verifyEvidenceIntegrity to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned evidence response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Evidence-pack header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public evidence-pack operations. The proof exercises authenticated bearer plus server-minted tenant-context requests through the live router and binds the 200 responses for assembleEvidencePack and getEvidencePack to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned evidence-pack response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
- Clarified - Job-status header and telemetry proof
contract-visible: Added operation-bound runtime proof for the public job-status operation. The proof exercises an authenticated bearer plus server-minted tenant-context request through the live router and binds the 200 response for getJobStatus to X-API-Version, X-Correlation-ID, X-Request-ID, bounded Server-Timing, CORS exposure posture, public response telemetry posture, and controlled tenant-owned job status response scope while API 0.1.0 remains in the accepted alpha version-hold wave.
Migration: No migration is required. This wave keeps the API contract version at 0.1.0 while strengthening release evidence, generated metadata, SDK visibility, and public documentation discipline for admitted alpha consumers.