@kortexya/reasoninglayer 1.22.0 → 1.24.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.22.0";
+var SDK_VERSION = "1.24.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -956,7 +956,7 @@ var Sorts = class {
     ...params
   });
   /**
-   * @description # Authorization Requires X-Tenant-Id header. The sort must belong to the tenant. # Errors - 404 Not Found: Sort doesn't exist - 400 Bad Request: Sort has children (would orphan them)
+   * @description # Authorization Requires X-Tenant-Id header. The sort must belong to the tenant. # The terms Deletion already refuses to orphan a CHILD SORT, and says so (`"would orphan 1 child sort(s)"`). It said nothing about the sort's TERMS and left them behind: still listed by `GET /api/v1/terms`, carrying a `sort_id` that answers `404`, unreachable by sort, with no schema to validate against and nothing reporting the state (#213). A term pointing at a deleted sort is the same kind of orphan as a child sort, so it gets the same guard. The disposition is the caller's and is named in the query: `terms=refuse` (the default) refuses while the sort is inhabited and says how many terms hold it; `terms=delete` deletes them with it and reports the count. Neither is silent, which is the whole of what was wrong. # Errors - 404 Not Found: Sort doesn't exist - 400 Bad Request: Sort has children (would orphan them), or holds terms under the default `terms=refuse`
    *
    * @tags sorts
    * @name DeleteSort
@@ -964,10 +964,27 @@ var Sorts = class {
    * @request DELETE:/api/v1/sorts/{id}
    * @secure
    */
-  deleteSort = (id, params = {}) => this.http.request({
+  deleteSort = (id, query, params = {}) => this.http.request({
     path: `/api/v1/sorts/${id}`,
     method: "DELETE",
+    query,
     secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags sorts
+   * @name GenerateSortProposals
+   * @summary Turn recurrent observations into proposed sorts for review.
+   * @request POST:/api/v1/sorts/proposals/generate
+   */
+  generateSortProposals = (query, params = {}) => this.http.request({
+    path: `/api/v1/sorts/proposals/generate`,
+    method: "POST",
+    query,
+    format: "json",
     ...params
   });
   /**
@@ -1015,7 +1032,7 @@ var Sorts = class {
     ...params
   });
   /**
-   * @description Per Definition IV.5 (Milanese & Pasi 2024): ≾̇ = ((≾̃ .− ∼) ⊍ ≤)⁺
+   * @description Per Definition IV.5 (Milanese & Pasi, IEEE TFS 2024 — CC-BY manuscript in reasoninglayer-sources/pdf_sources/), verbatim: ≺∼· ≝ ((≺∼ .− ∼) ⊍ ⪯)⊕ The combined chain preorder ≺∼ of Definition IV.1 with every DIRECTLY-similar pair deleted (`.−` zeroes the pair — it is not an arithmetic difference), the crisp order unioned back, and the result re-closed. A chain survives when its ENDPOINTS are not directly similar: slasher ⪯ horror ∼₀.₅ thriller keeps 0.5 while (horror, thriller) itself answers 0 — two similar sorts meet through their GLB instead (Fig. 4c: horror ⩏ thriller = slasher). The combined ≺∼ — where a direct ∼ edge IS a step; the coarse retrieval mode of Example V.4 — backs equivalence classes and term substitutability internally. (History: the differencing form here is ORIGINAL and faithful; #203 swapped in the combined semantics, and a 2026-08-23 pass re-documented that as correct from secondary sources. The accepted manuscript settled it the other way.)
    *
    * @tags sorts
    * @name GetPreorderDegree
@@ -1030,6 +1047,21 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Computed on the TENANT-VISIBLE hierarchy — unlike the legacy `equivalence-classes` route, which computes process-wide and filters (#114), so here αs and the order describe exactly the sorts the caller can see. Granularity per Example V.4: `combined` (Def. IV.1's ≺∼, default) or `similarity_deleted` (Def. IV.5's ≺∼·).
+   *
+   * @tags sorts
+   * @name GetQuotientOrder
+   * @summary Definition IV.9 in full over the caller's tenant lattice: the quotient classes with their degrees αs and the fuzzy partial order between them.
+   * @request GET:/api/v1/sorts/quotient-order
+   */
+  getQuotientOrder = (query, params = {}) => this.http.request({
+    path: `/api/v1/sorts/quotient-order`,
+    method: "GET",
+    query,
+    format: "json",
+    ...params
+  });
   /**
    * @description With `?format=osfql` the sort is returned as its commented OSFQL `DEFINE` block (`text/plain`, `ETag` = SHA-256 of the body) instead of the JSON DTO — the single-sort companion of `GET /api/v1/sorts/schema`.
    *
@@ -1138,6 +1170,20 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags sorts
+   * @name ListObservations
+   * @summary List the tenant's unknown-term observations.
+   * @request GET:/api/v1/sorts/proposals
+   */
+  listObservations = (params = {}) => this.http.request({
+    path: `/api/v1/sorts/proposals`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
   /**
    * @description By default, system-defined sorts (built-in types like Thing, Person, etc.) are excluded from the response. Use `include_system=true` to include them.
    *
@@ -1153,6 +1199,76 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The authoring half of the tenant's ubiquitous language: what a concept is called (`skos:prefLabel` stays the `name`), what else people call it (`altLabel`), what it means (`definition`), when to use it (`scopeNote`), what it sits beside (`related`), and whether it is still the term to use (`SortStatus`). Only fields present in the body mutate. Every referenced sort is resolved **before** anything is written, so a patch naming a concept that does not exist fails whole rather than half-applying.
+   *
+   * @tags sorts
+   * @name PatchSort
+   * @summary Curate one concept's vocabulary and lifecycle
+   * @request PATCH:/api/v1/sorts/{id}
+   * @secure
+   */
+  patchSort = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/${id}`,
+    method: "PATCH",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description The feature-level twin of the sort rename `PATCH /api/v1/sorts/{id}` carries (#185), and it could not be built out of an add and a remove because removal did not exist (#213). Nominal for the SCHEMA: the declaration keeps everything it says and the position it holds in the declaration order, and every subsort that inherited it is renamed with it. It is NOT nominal for the DATA — a feature is keyed by name, not by id, so a term that binds the old name keeps its value under a name the sort no longer declares. That is well-sorted under the open world, which is why the count is reported rather than the rename refused; pass `cascade_terms` to move the values too. The new name is held to the same OSFQL identifier rule as a sort rename (#176), in the `feature_name` position — which admits no dot. Every bound constraint written over the renamed declaration moves with it. Renaming a sort's own OVERRIDE leaves it inheriting the ancestor's declaration under the OLD name, so nothing is un-declared and a cascade leaves the values alone — `still_declared` says so. A sort with more than 512 persisted subsorts is refused, for the same reason a removal is: an edit applied to part of a subtree can be neither finished nor undone. # Errors - 400 Bad Request: an unreadable name, a name already declared here or on a subsort, no such declaration, an inherited one, or a shared sort - 404 Not Found: no such sort for this tenant
+   *
+   * @tags sorts
+   * @name PatchSortFeature
+   * @summary Rename one feature declaration on a sort
+   * @request PATCH:/api/v1/sorts/{id}/features/{feature}
+   * @secure
+   */
+  patchSortFeature = (id, feature, data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/${id}/features/${feature}`,
+    method: "PATCH",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description The analysis runs inside the hierarchy write lock (sync); the memory and audit writes happen strictly after the lock is released ([`SortDiscoveryOrchestrator::record`]), never under it.
+   *
+   * @tags sorts
+   * @name ProposeSortsClosedLoop
+   * @summary Run FCA sort discovery AND record the closed-loop trail (L5): every Proposed sort gets a memory decision-episode entry and a tamper-evident audit record, returned as receipts beside the analysis.
+   * @request POST:/api/v1/sorts/discovery/propose
+   */
+  proposeSortsClosedLoop = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/discovery/propose`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/sorts/propose-structural-similarities Derives sort-proximity candidates from the lattice structure (exact Wu-Palmer by default; ancestor Jaccard or the Lorentz geometry on request) and enters them into the SAME review queue as the behavioural learner: `GET /learned-similarities` lists them (with their crisp-meet status as evidence), `…/approve` ratifies one into ∼, `…/reject` drops it. Nothing reaches the active ∼ relation without a reviewer — derived proximity is not a Def A.10 similarity (vision-keeper ruling 2026-08-30). # Authorization Requires X-Tenant-Id header; only pairs whose both ends are visible to the tenant are proposed.
+   *
+   * @tags sorts
+   * @name ProposeStructuralSimilarities
+   * @summary Propose structural similarity candidates for review
+   * @request POST:/api/v1/sorts/propose-structural-similarities
+   * @secure
+   */
+  proposeStructuralSimilarities = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/propose-structural-similarities`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/sorts/learned-similarities/reject Rejects a proposed or conflicted learned similarity with a reason. Rejected similarities are not used in reasoning.
    *
@@ -1169,6 +1285,23 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The operation `Sort::remove_feature` could always express and no route could reach: every `remove_feature` call in this crate before #213 was `PsiTerm::remove_feature`, which drops a VALUE from a term — a different operation on a different type. The only route that amended a declaration at all was the backfill inside `bulk_create_sorts`, and it merges: a batch naming only the features to keep leaves the others in place. The declaration is removed from this sort and from every subsort that inherited it. An INHERITED declaration is refused with the ancestor named — it belongs to the sort that introduced it, and removing the copy here would be undone by the next propagation. # The terms Removing a declaration does not invalidate the values written under it. OSF is open: a term may carry a feature its sort does not declare, and only a `@closed` sort says otherwise. So the terms are REPORTED (`terms_binding`) and left alone unless `cascade_terms` asks for the value to go with the declaration. Removing the sort's own OVERRIDE of an ancestor's declaration puts it back to INHERITING that one, so the feature is still declared and the values are still governed — `still_declared` says so, and a cascade leaves them alone. # What goes with it Every bound constraint written over the removed declaration (`CHECK valid_to <= person.death_date` names `valid_to`), because one left naming a feature the sort no longer declares stops applying and is still emitted into the DDL export. ⚠️ Not recoverable through the sort DTOs — the route back is OSFQL `CHECK ON <sort> (…)`. # Refused for a large subtree A sort with more than 512 persisted subsorts is refused: the edit has to reach every subsort that materialised the inherited copy, and one applied to part of a subtree can be neither finished nor undone. # Errors - 400 Bad Request: no such declaration, an inherited one, or a shared sort - 404 Not Found: no such sort for this tenant
+   *
+   * @tags sorts
+   * @name RemoveSortFeature
+   * @summary Remove one feature declaration from a sort
+   * @request DELETE:/api/v1/sorts/{id}/features/{feature}
+   * @secure
+   */
+  removeSortFeature = (id, feature, query, params = {}) => this.http.request({
+    path: `/api/v1/sorts/${id}/features/${feature}`,
+    method: "DELETE",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -1742,6 +1875,23 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * @description # The disposition is the caller's `?derivations=refuse` (the default) refuses while the rule still supports materialized conclusions and says how many; `?derivations=retract` withdraws them with it and reports the counts. A delete that silently drops derivations is as wrong as one that silently keeps them, so neither is the unnamed default. # Authorization Requires `X-Tenant-Id`. Runs the same delete guard as `DELETE /api/v1/terms/{id}` — a rule is a policy-relevant object, and withdrawing one changes what the engine will conclude. Honours `If-Match` against the conclusion's content ETag, and requires it under `OSFKB_REQUIRE_IF_MATCH=1`. Every request is captured by the audit middleware.
+   *
+   * @tags inference
+   * @name DeleteRule
+   * @summary Delete a rule.
+   * @request DELETE:/api/v1/inference/rules/{id}
+   * @secure
+   */
+  deleteRule = (id, query, params = {}) => this.http.request({
+    path: `/api/v1/inference/rules/${id}`,
+    method: "DELETE",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Never writes to the KB — returns validated drafts for human review.
    *
@@ -1864,16 +2014,16 @@ var Inference = class {
     ...params
   });
   /**
-   * @description # Authorization Requires X-Tenant-Id header.
+   * @description # Authorization Requires X-Tenant-Id header, and the path tenant must equal it. # The path segment Named `{id}` because `DELETE` and `PUT` on the same path address ONE RULE by term id (#231), and one segment cannot carry two names. Here it is the tenant — and a redundant one, since any value but the authenticated principal is refused.
    *
    * @tags inference
    * @name GetRules
    * @summary Get all rules (clauses with antecedents) for a tenant
-   * @request GET:/api/v1/inference/rules/{tenant_id}
+   * @request GET:/api/v1/inference/rules/{id}
    * @secure
    */
-  getRules = (tenantId, params = {}) => this.http.request({
-    path: `/api/v1/inference/rules/${tenantId}`,
+  getRules = (id, params = {}) => this.http.request({
+    path: `/api/v1/inference/rules/${id}`,
     method: "GET",
     secure: true,
     format: "json",
@@ -1931,6 +2081,24 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * @description # An edit addresses ONE clause "Edit the rule for X" is ambiguous, because the authoring UI's "add clause" writes a *second* rule with the same conclusion, OR-unioned with the first. The path names a single rule term — one disjunct — so a client cannot silently edit the wrong one. # The old rule is withdrawn, not amended Everything `DELETE` does happens, always with the retract disposition: an edit that leaves the pre-edit clause's conclusions standing is exactly the defect this route exists to fix. The replacement is created through the same code `POST /api/v1/inference/rules` runs, so creation's guards — #227's guard canonicalisation, #219's range restriction, #217's certainty distinction — hold for an edit too, and a rejected replacement leaves the rule base untouched because the build runs BEFORE the clause is de-indexed. The response carries `previous_rule_id` alongside the new rule: a rule's id is its conclusion term id, so an edit changes it by construction. When the replacement is content-addressed to the same id (identical conclusion under `OSFKB_RULE_STABLE_IDS=1`), the two are equal and the edit was applied in place — the outgoing clause's now-unused antecedents are still collected and deleted. # Authorization Identical to `DELETE`: the delete guard on the outgoing rule, `If-Match` against its conclusion, and audit capture.
+   *
+   * @tags inference
+   * @name ReplaceRule
+   * @summary Replace a rule.
+   * @request PUT:/api/v1/inference/rules/{id}
+   * @secure
+   */
+  replaceRule = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/inference/rules/${id}`,
+    method: "PUT",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description In OSF/LIFE terms, the orchestrator pushes the conclusion gate and each antecedent gate toward the dual-weighted satisfaction objective `1 − ( w_D · K_D + w_K · K_K )` (paper eq. 4). Each call performs exactly one epoch over the supplied batch — the response carries the per-epoch metrics for that single epoch (multi-epoch aggregation is the caller's responsibility). # Authorization Requires `X-Tenant-Id` header.
    *
@@ -6774,6 +6942,24 @@ var Reasoning = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description POST /api/v1/assessment/ordinal
+   *
+   * @tags reasoning
+   * @name AssessOrdinal
+   * @summary Grade criteria against evidence on an ordinal scale.
+   * @request POST:/api/v1/assessment/ordinal
+   * @secure
+   */
+  assessOrdinal = (data, params = {}) => this.http.request({
+    path: `/api/v1/assessment/ordinal`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/reasoning/disentailment Disentailment A =/=> B means: "if A holds, then B must NOT hold". Returns whether the disentailment is violated — the conflict where the facts establish A and B follows anyway. This is hierarchy-aware and graded on the same footing as the entailment route, so a conflict reachable only through the sort lattice (a `contaminated` clause held by a `lead_paint` fact that subsumes it) is detected without that clause being supplied as a fact. `A ⇏ B` is violated exactly to the degree `A ⇒ B` is established, so `degree` here reports the complement: how strongly the disentailment still holds.
    *
@@ -7996,6 +8182,22 @@ var Analysis = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description Enumerates formal concepts over the tenant's terms, scores each concept's extent against the target feature, and where a concept's own extent is too small to decide, climbs to the most specific generalization that can. Concepts defined by the target are refused as circular; concepts nothing above can certify are counted as abstentions.
+   *
+   * @tags analysis
+   * @name AnalyzeCertifiedGeneralization
+   * @summary Certify feature classes against a recorded outcome.
+   * @request POST:/api/v1/analysis/certified-generalization
+   */
+  analyzeCertifiedGeneralization = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/certified-generalization`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Runs Ganter's Next Closure algorithm on existing PsiTerms to discover formal concepts (feature-set intersections) not captured by existing sorts. Returns ranked recommendations with confidence scores and optional auto-creation. When `fuzzy_thresholds` is non-empty, also runs fuzzy FCA at each alpha-cut level.
    *
@@ -8012,6 +8214,22 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Membership is containment of the intent's feature names, so definitions mined on one population score another without a shared context. This is what makes mined concepts usable as features on data the mining never saw.
+   *
+   * @tags analysis
+   * @name AssignConceptFeatures
+   * @summary Apply supplied feature definitions to the tenant's terms.
+   * @request POST:/api/v1/analysis/concept-features/assign
+   */
+  assignConceptFeatures = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/concept-features/assign`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns a [`RuleBaseCertificateDto`]: whether forward reasoning is guaranteed to halt (with the ranking-function depth bound), and whether it is order-independent (with the theorem discharged, or a concrete conflicting rule pair). The analysis is read-only over the tenant's knowledge base.
    *
@@ -8068,6 +8286,102 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Each installed rule reads: *for any term of `subject_sort_id` carrying every feature in the conjunction, conclude `target_feature`* — at the conjunction's certified lower bound, which becomes the rule's fuzzy certainty. An empty `installed` list is an abstention: nothing certified at this bound, and the store is unchanged.
+   *
+   * @tags analysis
+   * @name InstallConceptRules
+   * @summary Mine the tenant's terms and install every certifying conjunction as a rule.
+   * @request POST:/api/v1/analysis/concept-rules
+   */
+  installConceptRules = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/concept-rules`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description A candidate reached by neither kind of hypothesis comes back `undetermined_no_hypothesis`, and one reached by both comes back `undetermined_contradictory` — different facts, reported apart, because the second says the examples disagree and the first says they are silent.
+   *
+   * @tags analysis
+   * @name LearnHypotheses
+   * @summary Learn the descriptions of a class that no counter-example carries, and classify candidates against them.
+   * @request POST:/api/v1/analysis/hypotheses
+   */
+  learnHypotheses = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/hypotheses`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description This is the symbolic object of symbolic data analysis: the unit of interest is the group, its description is interval-valued where its members differ, and — once stored — it is an ordinary sort. A candidate whose deciding feature was never measured comes back `residuated`, naming what it is waiting for, rather than being reported outside the cohort.
+   *
+   * @tags analysis
+   * @name MaterializeCohort
+   * @summary Store a group's shared description as a sort, and classify candidates against the cohort it becomes.
+   * @request POST:/api/v1/analysis/cohorts
+   */
+  materializeCohort = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/cohorts`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Searches the concept lattice downward from the top concept, scoring every conjunction on its own joint extent — not on a fold over its parts, which cannot recover an interaction. Conjunctions whose certified lower bound clears the population rate are returned strongest-first; an empty list is an abstention rather than a rate of zero.
+   *
+   * @tags analysis
+   * @name MineConceptFeatures
+   * @summary Mine the tenant's terms for conjunctions certifiably enriched for a target.
+   * @request POST:/api/v1/analysis/concept-features
+   */
+  mineConceptFeatures = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/concept-features`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description The `accuracy_bound` is the reason to prefer this over a plain search: at zero the returned region is provably optimal, and above the caller's tolerance the honest reading is "not yet decided" rather than "here is the answer". `skipped` says how many terms could not be used, because a population that quietly shrank would make the bound optimistic.
+   *
+   * @tags analysis
+   * @name MineIntervalPatterns
+   * @summary Mine the numeric regions that best separate a class, and report how much better any region could still be.
+   * @request POST:/api/v1/analysis/interval-patterns
+   */
+  mineIntervalPatterns = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/interval-patterns`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description A returned class with `generalized: true` and a `sort` naming neither of its members' sorts is the case this endpoint exists for: a point in the lattice that no attribute names, reached because the least upper bound of two sorts is a derivation in the hierarchy. An empty `classes` list is an abstention, not a rate of zero.
+   *
+   * @tags analysis
+   * @name MineLggClasses
+   * @summary Mine the tenant's terms for classes certifiably enriched for a target, generalizing by sort rather than by conjunction.
+   * @request POST:/api/v1/analysis/lgg-classes
+   */
+  mineLggClasses = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/lgg-classes`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description The counterexample must have all premise features but lack at least one conclusion feature.
    *
@@ -8084,6 +8398,22 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description A returned concept with `generalized: true` and a `sort` naming none of its members' sorts is the case this endpoint exists for: a point in the lattice no attribute names, reached because the least upper bound of two sorts is a derivation in the hierarchy. Read `truncated` before reading `concepts` as "what the population contains". An empty `concepts` list is an abstention, not a rate of zero. ⚠️ `concepts[].lower_bound` is a **ranking key, not a certificate**: the search chose those concepts by looking at the very degrees the bound is computed on. Send a `holdout` to get claims — the search then sees only the selection half, and `certificates[]` carries bounds measured on data it never saw, corrected for the number of claims rather than the number searched.
+   *
+   * @tags analysis
+   * @name SearchLattice
+   * @summary Search the tenant's terms for concepts certifiably enriched for a target, spending a stated budget where the evidence is rather than in worklist order.
+   * @request POST:/api/v1/analysis/lattice-search
+   */
+  searchLattice = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/lattice-search`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Builds a formal context from the tenant's knowledge base terms and initializes the Ganter exploration protocol.
    *
@@ -9021,7 +9351,7 @@ var Admin = class {
     ...params
   });
   /**
-   * @description Explicitly creates a tenant's inference state and sort hierarchy, optionally seeding initial sorts. Idempotent. No X-Tenant-Id header required.
+   * @description Explicitly creates a tenant's registry row, inference state and sort hierarchy, optionally seeding initial sorts and storing a display label. Idempotent. No X-Tenant-Id header required. Refuses a deleted tenant's UUID with 409 rather than resurrecting it.
    *
    * @tags admin
    * @name CreateTenant
@@ -9037,11 +9367,41 @@ var Admin = class {
     ...params
   });
   /**
-   * @description Returns all tenant IDs that have terms or ingestion sessions, with counts. No X-Tenant-Id header required. Works in both PostgreSQL and in-memory modes.
+   * @description Destructive self-service operation: clears every trace of the caller's own tenant's data, then tombstones its registry row. The tenant's UUID is refused everywhere with 410 afterwards and cannot be recreated. There is no un-delete.
+   *
+   * @tags admin
+   * @name DeleteMyTenant
+   * @summary Delete the authenticated tenant (wipe + tombstone)
+   * @request POST:/api/v1/delete-tenant
+   * @secure
+   */
+  deleteMyTenant = (params = {}) => this.http.request({
+    path: `/api/v1/delete-tenant`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Clears every trace of the tenant's data (identical to the clear-tenant wipe), then tombstones its registry row. A deleted tenant's UUID is refused everywhere with 410 and cannot be recreated (409). There is no un-delete.
+   *
+   * @tags admin
+   * @name DeleteTenant
+   * @summary Delete a tenant (wipe + tombstone)
+   * @request DELETE:/api/v1/admin/tenants/{tenant_id}
+   */
+  deleteTenant = (tenantId, params = {}) => this.http.request({
+    path: `/api/v1/admin/tenants/${tenantId}`,
+    method: "DELETE",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Returns every tenant registered in the tenant registry and not tombstoned, with its display label and term/session counts. A cleared tenant stays listed with zeroed counts; a deleted tenant is not listed. Requires the platform_admin role. Works in both PostgreSQL and in-memory modes.
    *
    * @tags admin
    * @name ListTenants
-   * @summary List all tenants with data
+   * @summary List all live tenants
    * @request GET:/api/v1/admin/tenants
    */
   listTenants = (params = {}) => this.http.request({
@@ -9064,6 +9424,56 @@ var Admin = class {
     format: "json",
     ...params
   });
+  /**
+   * @description PLATFORM-scoped: a base is cross-tenant state, so only a platform admin may write it. Tenant deltas keep flowing through the Sentinel's pack surface (`/api/v1/sentinel/packs/...`), where D5 refuses any delta that loosens a base constraint.
+   *
+   * @tags admin
+   * @name RegisterBasePack
+   * @summary Register (or refresh) an industry BASE pack — the shared layer every tenant delta of that industry overlays (coupling plan WS7).
+   * @request PUT:/api/v1/admin/packs/base
+   */
+  registerBasePack = (data, params = {}) => this.http.request({
+    path: `/api/v1/admin/packs/base`,
+    method: "PUT",
+    body: data,
+    type: "text/plain",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Sets the caller's own tenant display label. `name: null` clears it. The label is metadata only — never unique, never a lookup key.
+   *
+   * @tags admin
+   * @name RenameMyTenant
+   * @summary Set, change, or clear the authenticated tenant's label
+   * @request PATCH:/api/v1/tenants/me
+   * @secure
+   */
+  renameMyTenant = (data, params = {}) => this.http.request({
+    path: `/api/v1/tenants/me`,
+    method: "PATCH",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Sets the tenant's display label. `name: null` clears it. The label is metadata only — never unique, never a lookup key.
+   *
+   * @tags admin
+   * @name RenameTenant
+   * @summary Set, change, or clear a tenant's label
+   * @request PATCH:/api/v1/admin/tenants/{tenant_id}
+   */
+  renameTenant = (tenantId, data, params = {}) => this.http.request({
+    path: `/api/v1/admin/tenants/${tenantId}`,
+    method: "PATCH",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns event-processing counters (submitted/processed/failed/in-flight), the materialization LSN, the last handler error (if any, truncated to 512 chars), the per-tenant materialization sentinel, the current derived-facts row count, and a racy hint about whether a rebuild is in flight. Intended for operator dashboards; the supervisor itself does not depend on this endpoint.
    *
@@ -9112,6 +9522,76 @@ var Ontology = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description Every verdict is derived from the base itself — the lattice's parent edges, the feature bounds declared on sorts, and the disjointness rules the axiom integrator emitted. Nothing is trusted from the caller.
+   *
+   * @tags ontology
+   * @name CheckOwl2
+   * @summary Run the OWL 2 validators over the tenant's live ontology.
+   * @request POST:/api/v1/ontology/checks/owl2
+   * @secure
+   */
+  checkOwl2 = (data, params = {}) => this.http.request({
+    path: `/api/v1/ontology/checks/owl2`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags ontology
+   * @name CreateCompetencyQuestion
+   * @summary Record a competency question.
+   * @request POST:/api/v1/ontology/competency-questions
+   * @secure
+   */
+  createCompetencyQuestion = (data, params = {}) => this.http.request({
+    path: `/api/v1/ontology/competency-questions`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags ontology
+   * @name EnrichOntology
+   * @summary Propose external-ontology links. Writes nothing.
+   * @request POST:/api/v1/ontology/enrich
+   * @secure
+   */
+  enrichOntology = (data, params = {}) => this.http.request({
+    path: `/api/v1/ontology/enrich`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags ontology
+   * @name EvaluateCompetencyQuestions
+   * @summary Run the accepted questions against the base.
+   * @request POST:/api/v1/ontology/competency-questions/evaluate
+   * @secure
+   */
+  evaluateCompetencyQuestions = (params = {}) => this.http.request({
+    path: `/api/v1/ontology/competency-questions/evaluate`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description # Errors - 503 if no LLM is configured - 422 if the LLM returns invalid JSON after retries - 502 if the LLM service fails
    *
@@ -9130,6 +9610,72 @@ var Ontology = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags ontology
+   * @name ListCompetencyQuestions
+   * @summary Every competency question the tenant holds.
+   * @request GET:/api/v1/ontology/competency-questions
+   * @secure
+   */
+  listCompetencyQuestions = (params = {}) => this.http.request({
+    path: `/api/v1/ontology/competency-questions`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Every figure is derived from the tenant's live lattice and term store. A stage is `complete` only when its bar is actually met; nothing here trusts the caller.
+   *
+   * @tags ontology
+   * @name OntologyPipelineStatus
+   * @summary Per-stage completeness of the ontology pipeline, measured from the base
+   * @request GET:/api/v1/ontology/pipeline/status
+   * @secure
+   */
+  ontologyPipelineStatus = (params = {}) => this.http.request({
+    path: `/api/v1/ontology/pipeline/status`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags ontology
+   * @name OntologyQualityReport
+   * @summary Judge the tenant's ontology.
+   * @request GET:/api/v1/ontology/quality-report
+   * @secure
+   */
+  ontologyQualityReport = (params = {}) => this.http.request({
+    path: `/api/v1/ontology/quality-report`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags ontology
+   * @name SetCompetencyQuestionStatus
+   * @summary Accept or reject a question.
+   * @request PATCH:/api/v1/ontology/competency-questions/{key}
+   * @secure
+   */
+  setCompetencyQuestionStatus = (key, data, params = {}) => this.http.request({
+    path: `/api/v1/ontology/competency-questions/${key}`,
+    method: "PATCH",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Generation.ts
@@ -9580,6 +10126,22 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name GetEuAiActConformity
+   * @summary `GET /api/v1/compliance/conformity`
+   * @request GET:/api/v1/compliance/conformity
+   * @secure
+   */
+  getEuAiActConformity = (params = {}) => this.http.request({
+    path: `/api/v1/compliance/conformity`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -12174,7 +12736,13 @@ function FeatureDescriptorDtoFromApiToFront(dto) {
     name: dto.name,
     expectedSort: dto.expected_sort ?? void 0,
     expectedTypeHint: dto.expected_type_hint ?? void 0,
-    required: dto.required,
+    // The spec made this optional and documents the default explicitly:
+    // "Defaults to `false` when absent." A relation is an appropriateness
+    // declaration — it says what the value's sort must be, not that the
+    // feature must be present — so the minimal relational descriptor omits it.
+    // Kept non-optional on the SDK surface so a consumer never handles
+    // `undefined` for a question the wire already answers.
+    required: dto.required ?? false,
     constraint: dto.constraint ? ConstraintDtoFromApiToFront(dto.constraint) : void 0
   };
 }
@@ -12300,6 +12868,8 @@ function BulkCreateSortsRequestFromFrontToApi(model) {
 function BulkSortErrorFromApiToFront(dto) {
   return {
     name: dto.name,
+    kind: dto.kind,
+    sortCreated: dto.sort_created,
     error: dto.error
   };
 }
@@ -13769,6 +14339,35 @@ function GetRulesResponseFromApiToFront(dto) {
     rules: dto.rules.map(RuleEntryDtoFromApiToFront)
   };
 }
+function RuleWithdrawalReportFromApiToFront(dto) {
+  return {
+    ruleId: dto.rule_id,
+    termsDeleted: dto.terms_deleted,
+    termsRetainedShared: dto.terms_retained_shared,
+    derivationsRemoved: dto.derivations_removed,
+    derivationsWeakened: dto.derivations_weakened,
+    derivationsTruncated: dto.derivations_truncated,
+    consequencesInvalidated: dto.consequences_invalidated,
+    queuedEventsCancelled: dto.queued_events_cancelled
+  };
+}
+function RuleCertificationDeltaFromApiToFront(dto) {
+  return {
+    terminatedBefore: dto.terminated_before,
+    terminatesAfter: dto.terminates_after,
+    orderIndependentBefore: dto.order_independent_before,
+    orderIndependentAfter: dto.order_independent_after,
+    regressed: dto.regressed
+  };
+}
+function ReplaceRuleResponseFromApiToFront(dto) {
+  return {
+    previousRuleId: dto.previous_rule_id,
+    term: PsiTermDtoFromApiToFront(dto.term),
+    withdrawal: RuleWithdrawalReportFromApiToFront(dto.withdrawal),
+    certification: RuleCertificationDeltaFromApiToFront(dto.certification)
+  };
+}
 function MetaSortsResponseFromApiToFront(dto) {
   return {
     absConstraint: dto.abs_constraint,
@@ -14256,6 +14855,89 @@ var InferenceClient = class {
     const response = await this.api.getRules(this.tenantId);
     return GetRulesResponseFromApiToFront(response.data);
   }
+  /**
+   * Withdraw one rule from the knowledge base.
+   *
+   * @param ruleId - Term id of the rule (its conclusion), as returned by
+   *   {@link InferenceClient.addRule} or {@link InferenceClient.getRules}.
+   * @param options - `derivations` decides what happens to the conclusions the
+   *   rule derived. Defaults to `'refuse'`.
+   * @returns What the withdrawal removed, tier by tier.
+   * @throws {ApiError} 400 if the id names a fact rather than a rule, or if the
+   *   rule still supports derivations under the default `'refuse'`; 403 for a
+   *   system, plugin-owned or bootstrap rule; 404 if no such rule exists.
+   *
+   * @remarks
+   * A rule is not a row. Withdrawing one deletes its conclusion AND the
+   * antecedent pattern, guard and variable terms it exclusively owns — a
+   * conclusion-only delete would leave those patterns readable as ordinary
+   * facts — while keeping every term the rest of the knowledge base still
+   * holds.
+   *
+   * `'refuse'` (the default) refuses while the rule still proves materialized
+   * conclusions and says how many; `'retract'` withdraws them with it. A delete
+   * that silently drops derivations is as wrong as one that silently keeps
+   * them, so neither is the unnamed default.
+   *
+   * @example
+   * ```typescript
+   * const report = await client.inference.deleteRule(ruleId, { derivations: 'retract' });
+   * console.log(report.termsDeleted, report.derivationsRemoved);
+   * ```
+   */
+  async deleteRule(ruleId, options) {
+    const response = await this.api.deleteRule(
+      ruleId,
+      options?.derivations === void 0 ? void 0 : { derivations: options.derivations }
+    );
+    return RuleWithdrawalReportFromApiToFront(response.data);
+  }
+  /**
+   * Replace one rule with a new one.
+   *
+   * @param ruleId - Term id of the rule (its conclusion) to replace.
+   * @param request - The replacement rule, in the same shape
+   *   {@link InferenceClient.addRule} takes.
+   * @returns The replacement, the id it replaced, what the withdrawal removed,
+   *   and how the rule base's guarantees moved.
+   * @throws {ApiError} 422 if the replacement is rejected by the authoring
+   *   guards — in which case the original rule is left live; 400/403/404 as for
+   *   {@link InferenceClient.deleteRule}.
+   *
+   * @remarks
+   * A rule's id IS its conclusion term id, so an edit changes it by
+   * construction. The response carries `previousRuleId` alongside the new
+   * rule; a client holding the old id must adopt the new one.
+   *
+   * The path names ONE rule term — one disjunct. Two rules with the same
+   * conclusion are OR-unioned, so "edit the rule for X" is ambiguous and this
+   * addresses a single clause.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.inference.replaceRule(ruleId, {
+   *   term: psi('retiree', { name: Var('N') }),
+   *   antecedents: [psi('person', { name: Var('N') })],
+   * });
+   * console.log(result.previousRuleId, '->', result.term.termId);
+   * if (result.certification.regressed) {
+   *   console.warn('the edit weakened the rule base guarantees');
+   * }
+   * ```
+   */
+  async replaceRule(ruleId, request) {
+    const wireRequest = {
+      term: convertTermArg(request.term),
+      antecedents: request.antecedents?.map(convertTermArg),
+      certainty: request.certainty,
+      aggregator: request.aggregator
+    };
+    const response = await this.api.replaceRule(
+      ruleId,
+      AddRuleRequestFromFrontToApi(wireRequest)
+    );
+    return ReplaceRuleResponseFromApiToFront(response.data);
+  }
   /**
    * Query for matching data by searching rules and facts backwards from a goal pattern.
    *
@@ -17363,6 +18045,17 @@ function TrailEntryDtoFromApiToFront(dto) {
         prevLower: dto.prev_lower,
         prevUpper: dto.prev_upper
       };
+    case "term_creation":
+      return {
+        type: "term_creation",
+        termId: dto.term_id
+      };
+    case "term_removal":
+      return {
+        type: "term_removal",
+        termId: dto.term_id,
+        sortId: dto.sort_id
+      };
   }
 }
 function ResiduationGoalDtoFromFrontToApi(model) {
@@ -22740,6 +23433,8 @@ function DiscoveredSortDtoFromApiToFront(dto) {
     description: dto.description,
     features: dto.features.map(DiscoveredFeatureDtoFromApiToFront),
     name: dto.name,
+    sourceTypeKey: dto.source_type_key,
+    sortName: dto.sort_name,
     sourceName: dto.source_name,
     suggestedParents: dto.suggested_parents
   };
@@ -27043,6 +27738,7 @@ function ClearTenantResponseFromApiToFront(dto) {
 function TenantInfoFromApiToFront(dto) {
   return {
     tenantId: dto.tenant_id,
+    name: dto.name,
     termCount: dto.term_count,
     sessionCount: dto.session_count
   };
@@ -27054,6 +27750,7 @@ function ListTenantsResponseFromApiToFront(dto) {
 }
 function CreateTenantRequestFromFrontToApi(model) {
   return {
+    name: model.name,
     owner_user_id: model.ownerUserId,
     seed_sorts: model.seedSorts,
     tenant_id: model.tenantId
@@ -27063,7 +27760,25 @@ function CreateTenantResponseFromApiToFront(dto) {
   return {
     created: dto.created,
     seededSorts: dto.seeded_sorts,
-    tenantId: dto.tenant_id
+    tenantId: dto.tenant_id,
+    name: dto.name
+  };
+}
+function DeleteTenantResponseFromApiToFront(dto) {
+  return {
+    ...ClearTenantResponseFromApiToFront(dto),
+    deletedAt: dto.deleted_at
+  };
+}
+function UpdateTenantNameRequestFromFrontToApi(model) {
+  return {
+    name: model.name
+  };
+}
+function UpdateTenantNameResponseFromApiToFront(dto) {
+  return {
+    tenantId: dto.tenant_id,
+    name: dto.name
   };
 }
 
@@ -27214,6 +27929,128 @@ var AdminClient = class {
     const response = await this.api.createTenant(CreateTenantRequestFromFrontToApi(request));
     return CreateTenantResponseFromApiToFront(response.data);
   }
+  /**
+   * Delete a tenant (platform-admin).
+   *
+   * @param tenantId - The UUID of the tenant to delete.
+   * @returns The wipe report plus the tombstone outcome.
+   * @throws {ApiError} `404` when no registry row exists for the UUID; `410`
+   *   when the tenant was already deleted; `403` without the `platform_admin`
+   *   role; `500` when the data reset failed (a partial wipe may have occurred).
+   *
+   * @remarks
+   * **DESTRUCTIVE AND IRREVERSIBLE. There is no un-delete.**
+   *
+   * Clears every trace of the tenant's data (identical to the clear-tenant
+   * wipe), then tombstones its registry row. The tenant stops existing:
+   * every later request naming its UUID is refused with `410`, it disappears
+   * from `listTenants`, and `createTenant` on the same UUID refuses with `409`
+   * rather than resurrecting it. A fresh UUID is the workaround.
+   *
+   * This is not {@link clearTenantData}: a clear wipes the tenant's data but
+   * the tenant continues to exist — its id stays valid, it can be re-populated,
+   * and it is still listed with zeroed counts. A delete retires the id.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.admin.deleteTenant('550e8400-e29b-41d4-a716-446655440000');
+   * console.log(result.message);
+   * console.log(`Deleted at: ${result.deletedAt}`);
+   * ```
+   */
+  async deleteTenant(tenantId) {
+    const response = await this.api.deleteTenant(tenantId);
+    return DeleteTenantResponseFromApiToFront(response.data);
+  }
+  /**
+   * Delete the authenticated tenant (self-service).
+   *
+   * @returns The wipe report plus the tombstone outcome.
+   * @throws {ApiError} `404` when the caller's tenant was never materialized;
+   *   `410` when it was already deleted; `500` when the data reset failed
+   *   (a partial wipe may have occurred).
+   *
+   * @remarks
+   * **DESTRUCTIVE AND IRREVERSIBLE. There is no un-delete.**
+   *
+   * The self-service mirror of {@link deleteTenant}: the target tenant is
+   * resolved server-side from the caller's own `X-Tenant-Id` header, never
+   * from a path or body parameter, so it always deletes the authenticated
+   * principal's own tenant. No `platform_admin` role is required. Afterwards
+   * the tenant's UUID is refused with `410` everywhere and cannot be
+   * recreated — the caller must switch to a different tenant id.
+   *
+   * This is not {@link clearMyTenantData}: a clear wipes the caller's data but
+   * the tenant continues to exist. A delete retires the id permanently.
+   *
+   * @example
+   * ```typescript
+   * // Deletes the calling tenant's own identity — no tenant ID is passed.
+   * const result = await client.admin.deleteMyTenant();
+   * console.log(`Tenant retired at: ${result.deletedAt}`);
+   * ```
+   */
+  async deleteMyTenant() {
+    const response = await this.api.deleteMyTenant();
+    return DeleteTenantResponseFromApiToFront(response.data);
+  }
+  /**
+   * Set, change, or clear a tenant's label (platform-admin).
+   *
+   * @param tenantId - The UUID of the tenant to rename.
+   * @param request - The new label. `name: null` (or an empty request) clears it.
+   * @returns The tenant id and the label now stored.
+   * @throws {ApiError} `404` when no registry row exists for the UUID; `410`
+   *   when the tenant is deleted (its label is frozen); `422` when the name is
+   *   empty after trim or over 200 characters; `403` without the
+   *   `platform_admin` role.
+   *
+   * @remarks
+   * The label is display metadata only: not unique, not a lookup key, never
+   * parsed. The UUID remains the tenant's only identity. The stored label
+   * survives a clear and leaves with a delete.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.admin.renameTenant('550e8400-…', { name: 'Research' });
+   * console.log(result.name); // the stored, trimmed label
+   * ```
+   */
+  async renameTenant(tenantId, request) {
+    const response = await this.api.renameTenant(
+      tenantId,
+      UpdateTenantNameRequestFromFrontToApi(request)
+    );
+    return UpdateTenantNameResponseFromApiToFront(response.data);
+  }
+  /**
+   * Set, change, or clear the authenticated tenant's label (self-service).
+   *
+   * @param request - The new label. `name: null` (or an empty request) clears it.
+   * @returns The tenant id and the label now stored.
+   * @throws {ApiError} `404` when the caller's tenant was never materialized;
+   *   `410` when it is deleted; `422` when the name is empty after trim or
+   *   over 200 characters.
+   *
+   * @remarks
+   * The self-service mirror of {@link renameTenant}: the target tenant is
+   * resolved server-side from the caller's own `X-Tenant-Id` header, so it
+   * always renames the authenticated principal's own tenant. No
+   * `platform_admin` role is required.
+   *
+   * @example
+   * ```typescript
+   * // Renames the calling tenant — no tenant ID is passed.
+   * const result = await client.admin.renameMyTenant({ name: 'My workspace' });
+   * console.log(result.name);
+   * ```
+   */
+  async renameMyTenant(request) {
+    const response = await this.api.renameMyTenant(
+      UpdateTenantNameRequestFromFrontToApi(request)
+    );
+    return UpdateTenantNameResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/image-extraction.ts
@@ -28629,6 +29466,10 @@ function OsfqlValueFromApiToFront(value) {
   switch (value["type"]) {
     case "null":
       return { type: "null" };
+    // The record does not carry the feature. No payload, and no `undefined`
+    // either: dropping the key would hide the absence the answer is about.
+    case "unbound":
+      return { type: "unbound" };
     case "integer":
       return typeof payload === "number" ? { type: "integer", value: payload } : void 0;
     case "float":
@@ -28756,6 +29597,36 @@ function OsfqlDiagnoseResponseFromApiToFront(dto) {
     diagnostics: dto.diagnostics.map(OsfqlDiagnosticFromApiToFront)
   };
 }
+function OsfqlCatalogEntryFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    statement: dto.statement,
+    family: dto.family,
+    category: dto.category,
+    subOps: dto.sub_ops,
+    brief: dto.brief,
+    full: dto.full,
+    syntax: dto.syntax,
+    examples: dto.examples,
+    risk: dto.risk,
+    execution: OsfqlCatalogExecutionFromApiToFront(dto.execution),
+    uiAffinity: {
+      display: dto.ui_affinity.display ?? void 0,
+      action: dto.ui_affinity.action ?? void 0
+    },
+    returns: dto.returns,
+    // Absent means "needs nothing", which is false for nearly every statement —
+    // so an absent array is a wire-shape surprise, not a default. `?? []` keeps
+    // the shipped type total; the engine sends the field for all entries.
+    needs: dto.needs ?? [],
+    pitfalls: dto.pitfalls ?? []
+  };
+}
+function OsfqlCatalogExecutionFromApiToFront(dto) {
+  if (dto === "Executes") return { status: "executes" };
+  if (dto === "PlanOnly") return { status: "planOnly" };
+  return { status: "partial", note: dto.Partial };
+}
 
 // src/resources/osfql.ts
 var OsfqlClient = class {
@@ -28868,24 +29739,34 @@ var OsfqlClient = class {
     return OsfqlDiagnoseResponseFromApiToFront(response.data);
   }
   /**
-   * Fetch the OSFQL statement catalog, optionally filtered by category.
+   * Fetch the OSFQL statement catalog — the engine's own description of every
+   * statement it implements.
    *
-   * @param category - Optional category filter: `read`, `write`, `control`, or `meta`.
-   * @returns The raw catalog payload, typed as `unknown`.
+   * @param category - Optional filter: `read`, `write`, `control`, or `meta`
+   *   (case-insensitive). Omit for the whole catalog; an unrecognised value
+   *   yields an empty list rather than an error.
+   * @returns One {@link OsfqlCatalogEntry} per statement.
    * @throws {ApiError} If the request fails.
    *
    * @remarks
-   * This is a DEBUG/introspection endpoint. The backend publishes **no response schema** for
-   * it in the OpenAPI document, and its payload deliberately mixes casing (`risk` is
-   * snake_case while the sibling `family` / `category` enums are PascalCase). The SDK
-   * therefore returns the parsed JSON body as `unknown` rather than inventing a shipped type
-   * that the spec does not guarantee — narrow it at the call site.
+   * The backend publishes a response schema for this endpoint, so the payload
+   * is normalized like any other. It previously returned `unknown` because the
+   * spec carried none — and because the endpoint answered HTTP 500 to every
+   * request until `kortexya/reasoninglayer#176` repaired its response DTO, so
+   * no caller had ever received a body to type.
+   *
+   * ⚠️ The enum VALUES mix casing deliberately and are preserved verbatim:
+   * `risk` is snake_case (`additive_write`), while `family`, `category`,
+   * `returns` and both halves of `uiAffinity` are PascalCase (`Query`, `Read`,
+   * `Bindings`, `Table`). Only keys are camelCased.
    *
    * @example
    * ```typescript
-   * const catalog: unknown = await client.osfql.catalog('write');
-   * if (Array.isArray(catalog)) {
-   *   console.log(catalog.length);
+   * const catalog = await client.osfql.catalog('write');
+   * for (const entry of catalog) {
+   *   if (entry.execution.status === 'partial') {
+   *     console.warn(`${entry.id} is partial: ${entry.execution.note}`);
+   *   }
    * }
    * ```
    */
@@ -28897,7 +29778,7 @@ var OsfqlClient = class {
       secure: true,
       format: "json"
     });
-    return response.data;
+    return response.data.map(OsfqlCatalogEntryFromApiToFront);
   }
 };
 
@@ -28946,7 +29827,22 @@ function SchemaExcerptDtoFromApiToFront(dto) {
     featureNames: dto.feature_names
   };
 }
+function CitationCheckDtoFromApiToFront(dto) {
+  return {
+    marker: dto.marker,
+    variable: dto.variable ?? void 0,
+    assertedValue: dto.asserted_value ?? void 0,
+    verdict: dto.verdict,
+    repair: dto.repair ?? void 0,
+    repairVariables: dto.repair_variables,
+    observedValues: dto.observed_values,
+    observedTotal: dto.observed_total,
+    scope: dto.scope,
+    scopeLabel: dto.scope_label ?? void 0
+  };
+}
 function ClaimAnnotationDtoFromApiToFront(dto) {
+  const wire = dto;
   return {
     text: dto.text,
     span: dto.span,
@@ -28956,7 +29852,8 @@ function ClaimAnnotationDtoFromApiToFront(dto) {
     sourceExcerpts: dto.source_excerpts?.map(SourceExcerptDtoFromApiToFront),
     schemaExcerpts: dto.schema_excerpts?.map(SchemaExcerptDtoFromApiToFront),
     osfqlQuery: dto.osfql_query ?? void 0,
-    derivationSummary: dto.derivation_summary ? DerivationSummaryDtoFromApiToFront(dto.derivation_summary) : void 0
+    derivationSummary: dto.derivation_summary ? DerivationSummaryDtoFromApiToFront(dto.derivation_summary) : void 0,
+    citationChecks: wire.citation_checks?.map(CitationCheckDtoFromApiToFront)
   };
 }
 function ProofTraceNodeDtoFromApiToFront(dto) {