@kortexya/reasoninglayer 1.15.0 → 1.17.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.15.0";
+var SDK_VERSION = "1.17.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -550,6 +550,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "antecedentFeatures",
   "antecedent_features",
   "bindings",
+  "classScores",
+  "class_scores",
   "coefficients",
   "conceptValues",
   "concept_values",
@@ -585,6 +587,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "per_strategy_taxonomies",
   "propsOverride",
   "props_override",
+  "referencedTerms",
+  "referenced_terms",
   "roleMinimums",
   "role_minimums",
   "scope",
@@ -592,6 +596,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "scores_by_name",
   "sortNames",
   "sort_names",
+  "toolResults",
+  "tool_results",
   "topK",
   "top_k",
   "values"
@@ -994,6 +1000,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags sorts
+   * @name GetFuzzySubsumption
+   * @summary Get the fuzzy subsumption degree `sub ⊑· sup` between two sorts
+   * @request POST:/api/v1/sorts/subsumption/get
+   */
+  getFuzzySubsumption = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/subsumption/get`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Per Definition IV.5 (Milanese & Pasi 2024): ≾̇ = ((≾̃ .− ∼) ⊍ ≤)⁺
    *
@@ -1011,16 +1033,17 @@ var Sorts = class {
     ...params
   });
   /**
-   * No description
+   * @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`.
    *
    * @tags sorts
    * @name GetSort
    * @summary Get a sort by ID
    * @request GET:/api/v1/sorts/{id}
    */
-  getSort = (id, params = {}) => this.http.request({
+  getSort = (id, query, params = {}) => this.http.request({
     path: `/api/v1/sorts/${id}`,
     method: "GET",
+    query,
     format: "json",
     ...params
   });
@@ -1040,6 +1063,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The bulk companion of `?format=osfql` on the by-id route: a single deterministic, re-parseable `text/plain` block of commented `DEFINE` statements (one per sort, ordered by name) for LLM prompt conditioning and replayable export. Supports the tenant listing's filters (`name_prefix`, `include_system`, `needs_review`, `llm_extracted`, and `offset`/`limit`, applied after the deterministic ordering so pages are stable). The `ETag` is the SHA-256 of the body, so prompt-conditioning consumers get a stable cache key for "schema unchanged".
+   *
+   * @tags sorts
+   * @name GetSortsSchema
+   * @summary Export the authenticated tenant's schema as one OSFQL DDL block
+   * @request GET:/api/v1/sorts/schema
+   * @secure
+   */
+  getSortsSchema = (query, params = {}) => this.http.request({
+    path: `/api/v1/sorts/schema`,
+    method: "GET",
+    query,
+    secure: true,
+    ...params
+  });
   /**
    * No description
    *
@@ -1146,6 +1185,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Subsumption is **directional**: ⊑·(s₁, s₂) and ⊑·(s₂, s₁) are different assertions. For the symmetric relation use `/api/v1/sorts/similarity`. The degree must be in [0, 1] and the assignment must keep the relation a fuzzy partial order (max–min transitivity, antisymmetry); one that does not is rejected rather than stored.
+   *
+   * @tags sorts
+   * @name SetFuzzySubsumption
+   * @summary Set the fuzzy subsumption degree `sub ⊑· sup` between two sorts
+   * @request POST:/api/v1/sorts/subsumption
+   */
+  setFuzzySubsumption = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/subsumption`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Similarity is symmetric: ∼(s₁, s₂) = ∼(s₂, s₁) Degree must be in [0, 1] range.
    *
@@ -1162,6 +1217,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Poll this after `POST /api/v1/sorts/index` (which is fire-and-forget) to know whether the embedding pass is still `running`, has completed (`last_indexed_count`), or failed (`last_error`).
+   *
+   * @tags sorts
+   * @name SortIndexStatus
+   * @summary GET /api/v1/sorts/index/status
+   * @request GET:/api/v1/sorts/index/status
+   * @secure
+   */
+  sortIndexStatus = (params = {}) => this.http.request({
+    path: `/api/v1/sorts/index/status`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -1605,11 +1676,11 @@ var Inference = class {
     ...params
   });
   /**
-   * @description # DEPRECATED This endpoint is deprecated. Use `DELETE /api/v1/terms/{term_id}` for individual terms. # TRUE HOMOICONIC API # Authorization Requires X-Tenant-Id header.
+   * @description This drops the hydrated base facts, the forward-chain `persist_derived` facts and the residuation store, then forgets the hydration flag so the next request reloads the base facts from PostgreSQL. **It does not delete durable data.** The terms are the authority; this is their cache. That makes it the retraction primitive forward chaining otherwise lacks. Chaining is monotonic — delete a `blocks` edge and the derived "A blocks B" survives every later pass, so the KB keeps asserting a relationship the user removed. Clearing and re-chaining rebuilds the closure from the terms that actually exist. # History Until 2026-07-28 this handler enumerated every term in the tenant and deleted it from PostgreSQL, while calling itself "clear facts" and reporting `"Cleared N facts/rules"`. It is reachable with an ordinary tenant credential — unlike `/api/v1/admin/clear-tenant/{tenant_id}`, which gateways block — so a caller reading the name, the path or the response body had no way to know it was a tenant wipe. It destroyed a live tenant that way. Use `DELETE /api/v1/terms/{term_id}` to delete a term, and the admin route to wipe a tenant; deleting durable data must not be something an endpoint does as a side effect of its name. # Authorization Requires X-Tenant-Id header, and the path tenant must match it.
    *
    * @tags inference
    * @name ClearFacts
-   * @summary Clear all facts and rules for a tenant
+   * @summary Clear a tenant's in-memory inference working set.
    * @request DELETE:/api/v1/inference/facts/{tenant_id}
    * @secure
    */
@@ -1952,6 +2023,21 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Server->client only (thinking / tool / inference / phase events). It's plain HTTP, so it traverses the zanzibar gateway — which proxies HTTP and mints `X-Tenant-Id`, but does NOT proxy WebSocket upgrades. Client->server control (ChatMessage / Abort / Redirect) is a separate POST for SSE clients. Auth and the ownership gate are identical to the WS handler. Endpoint: `GET /api/v1/cognitive/agents/{agent_id}/events` (Accept: text/event-stream)
+   *
+   * @tags cognitive
+   * @name CognitiveSseHandler
+   * @summary SSE transport for the *same* cognitive event stream as `cognitive_ws_handler`.
+   * @request GET:/api/v1/cognitive/agents/{agent_id}/events
+   * @secure
+   */
+  cognitiveSseHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/events`,
+    method: "GET",
+    secure: true,
+    ...params
+  });
   /**
    * @description ## Example ```bash curl -X POST http://localhost:3000/api/v1/cognitive/agents \ -H "Content-Type: application/json" \ -d '{"name": "reasoning_agent", "tenant_id": "..."}' ```
    *
@@ -2000,6 +2086,20 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Reads the persisted, tenant-scoped `ActionReviewConfig` from the registry (hydrating agents first so a restored snapshot's config is visible), or sensible defaults when none has been set. Complements the PUT so the UI's oversight editor can load what's actually stored instead of a local stand-in.
+   *
+   * @tags cognitive
+   * @name GetActionReviewConfigHandler
+   * @summary Get the tenant's current HITL action-review (oversight) configuration.
+   * @request GET:/api/v1/cognitive/agents/action-review-config
+   */
+  getActionReviewConfigHandler = (params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/action-review-config`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns drives, deficits, curiosity targets, and the dominant drive. Tenant is identified by the `X-Tenant-Id` header.
    *
@@ -2016,6 +2116,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name GetAgentPlanHandler
+   * @summary GET /api/v1/cognitive/agents/{agent_id}/plan — inspect an agent's committed intentions: the plan/HTN step sequence, `current_step` (executed-so-far), and status. Read-only observability for the planner verification harness (§4.2).
+   * @request GET:/api/v1/cognitive/agents/{agent_id}/plan
+   * @secure
+   */
+  getAgentPlanHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/plan`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -2032,6 +2148,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name GetAgentWorldModelHandler
+   * @summary GET /api/v1/cognitive/agents/{agent_id}/world-model — inspect an agent's learned transition model P(s'|s,a). Read-only observability for the world-model verification harness (§4.2 of the productionization plan) and a future UI surface: returns the agent's transition rules with resolved sort names + the rule count. An agent with no learned transitions yet returns `has_world_model:false` (or an empty rule set), which is a valid state — not an error.
+   * @request GET:/api/v1/cognitive/agents/{agent_id}/world-model
+   * @secure
+   */
+  getAgentWorldModelHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/world-model`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns beliefs, goals, intentions, pending perceptions, activations, recent episodes, and rule utilities. Tenant is identified by the `X-Tenant-Id` header.
    *
@@ -2096,6 +2228,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name PauseAgentHandler
+   * @summary POST /api/v1/cognitive/agents/{agent_id}/pause — pause an agent (persisted).
+   * @request POST:/api/v1/cognitive/agents/{agent_id}/pause
+   * @secure
+   */
+  pauseAgentHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/pause`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description This enables the agent to learn from user corrections and preferences. All feedback is stored as Ψ-terms for TRUE HOMOICONICITY - they are queryable, unifiable, and can be reasoned about by the agent. ## Feedback Rating - `+1`: Result was correct/helpful - increases rule utility - `0`: Neutral - no learning - `-1`: Result was wrong - decreases rule utility, triggers correction learning ## Corrections When a correction is provided: 1. A `user_correction` Ψ-term is created with the correct answer pattern 2. Rules that produced the wrong result have their utility decreased 3. A new rule may be learned from the correction ## Preferences When a preference is provided: 1. A `user_preference` Ψ-term is created (subsort of constraint) 2. Future reasoning can consider this preference
    *
@@ -2128,6 +2276,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name ResumeAgentHandler
+   * @summary POST /api/v1/cognitive/agents/{agent_id}/resume — resume a paused agent.
+   * @request POST:/api/v1/cognitive/agents/{agent_id}/resume
+   * @secure
+   */
+  resumeAgentHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/resume`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Executes: perceive → reason → act → learn
    *
@@ -2192,6 +2356,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name StopAgentHandler
+   * @summary POST /api/v1/cognitive/agents/{agent_id}/stop — soft-stop an agent (persisted; distinct from DELETE, which permanently destroys the agent + its goals).
+   * @request POST:/api/v1/cognitive/agents/{agent_id}/stop
+   * @secure
+   */
+  stopAgentHandler = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/stop`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description When subscribed, the agent will receive notifications about changes to the specified sorts and features, enabling reactive behavior. ## Example ```bash curl -X POST http://localhost:3000/api/v1/cognitive/agents/subscribe \ -H "Content-Type: application/json" \ -d '{"agent_id": "...", "tenant_id": "...", "watched_sorts": ["person", "event"]}' ```
    *
@@ -2682,6 +2862,24 @@ var Ingestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Two import targets, selected by [`IngestKifRequest::persist`]: * `persist == false` (default): the import runs in a fresh, **request-scoped** world (no shared tenant state is mutated), so the inference is attributable entirely to the submitted SUO-KIF. The tenant id only namespaces the ephemeral sorts. * `persist == true`: the import lands in the **tenant's persistent substrate** — the shared per-tenant `VersionedHierarchy` and `DomainTermStore` ([`AppState::inference_for_auth`]). The sorts, facts, and rules survive the request and are visible to every subsequent call on the same tenant. Caches are invalidated afterwards so the next query observes the new state. Either way, authentication is required and an optional `goal`/`query` is proved against the axioms produced by *this* import.
+   *
+   * @tags ingestion
+   * @name IngestKif
+   * @summary Import SUO-KIF and, optionally, prove a ground goal against the imported axioms.
+   * @request POST:/api/v1/ingest/kif
+   * @secure
+   */
+  ingestKif = (data, params = {}) => this.http.request({
+    path: `/api/v1/ingest/kif`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/ingest/markdown This endpoint accepts markdown content and extracts entities using: 1. Semantic chunking for large documents 2. LLM-based entity extraction 3. Sort reconciliation (optionally creating new sorts) 4. Entity deduplication against existing knowledge base # Headers - `X-Tenant-Id`: Tenant ID for multi-tenancy isolation (required) # Request Body - `content`: The markdown content to ingest - `owner_id`: User ID who owns the ingested data - `config`: Optional configuration overrides # Response - `success`: Whether ingestion completed successfully - `stats`: Statistics about the ingestion (chunks, entities, sorts) - `pending_review`: Entities that need human review for deduplication # Size Limits - Maximum content size is 100KB. For larger documents, use the document ingestion endpoint which handles chunking automatically.
    *
@@ -2898,6 +3096,21 @@ var StructuredIngestion = class {
     secure: true,
     ...params
   });
+  /**
+   * @description Refused with 409 while a registered source still references the file's path (the source's adapter would otherwise hold a dangling `file_path`). After that source is unregistered, the delete succeeds (204). A missing sidecar (no such upload id) is 404.
+   *
+   * @tags structured_ingestion
+   * @name DeleteSourceFile
+   * @summary Delete a tenant-uploaded source file (#107).
+   * @request DELETE:/api/v1/sources/files/{id}
+   * @secure
+   */
+  deleteSourceFile = (id, params = {}) => this.http.request({
+    path: `/api/v1/sources/files/${id}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
   /**
    * @description Performs schema introspection on the source to discover types (sorts), features (fields), and relations. This is a preview operation - no data is ingested. `type_filter` narrows the discovery to a named subset **without re-registering the source** — the escape hatch a client uses after `/tables` when the source is over the discovery cap (#66, Gap 2). It conjoins with the source config's own `include_tables`: a request narrows *within* the registration, it cannot widen past it.
    *
@@ -2950,6 +3163,22 @@ var StructuredIngestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Walks `{base}/{tenant_id}/*\/​.meta.json`. A missing tenant dir yields an empty list (200), not 404 — a tenant that never uploaded is not an error.
+   *
+   * @tags structured_ingestion
+   * @name ListSourceFiles
+   * @summary List the calling tenant's uploaded source files (#107).
+   * @request GET:/api/v1/sources/files
+   * @secure
+   */
+  listSourceFiles = (params = {}) => this.http.request({
+    path: `/api/v1/sources/files`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -3016,6 +3245,24 @@ var StructuredIngestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Multipart, one field named `file`. Streamed to disk under `{base}/{tenant_id}/{id}/{safe_name}` with a `.meta.json` sidecar. The response `path` is the engine-internal location handed to `POST /api/v1/sources` as `config.file_path` (csv/parquet) or `config.database_path` (sqlite).
+   *
+   * @tags structured_ingestion
+   * @name UploadSourceFile
+   * @summary Upload a file-based source artifact for the calling tenant (#107).
+   * @request POST:/api/v1/sources/files
+   * @secure
+   */
+  uploadSourceFile = (data, params = {}) => this.http.request({
+    path: `/api/v1/sources/files`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "multipart/form-data" /* FormData */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/NeuroSymbolic.ts
@@ -3562,6 +3809,60 @@ var Communities = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description `POST /api/v1/analysis/centrality` Builds the tenant's reference graph from its terms (the same read-only projection community detection uses) and computes the requested centrality measure. Centrality is a **read-only analytic** — it never asserts facts or feeds the chainer. Scores are returned sorted descending (ties broken by node id for determinism), optionally truncated to `top_k`.
+   *
+   * @tags communities
+   * @name ComputeCentrality
+   * @summary Compute a node-centrality measure over the tenant's reference graph.
+   * @request POST:/api/v1/analysis/centrality
+   * @secure
+   */
+  computeCentrality = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/centrality`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description `POST /api/v1/analysis/cohesion` Read-only: total triangle count plus the per-node local clustering coefficient (sorted descending, ties broken by node id).
+   *
+   * @tags communities
+   * @name ComputeCohesion
+   * @summary Structural-cohesion metrics over the tenant's reference graph.
+   * @request POST:/api/v1/analysis/cohesion
+   * @secure
+   */
+  computeCohesion = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/cohesion`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description `POST /api/v1/analysis/path` Read-only: BFS shortest path (`source..=target`) over the undirected reference graph, or `null` when `target` is unreachable.
+   *
+   * @tags communities
+   * @name ComputePath
+   * @summary Shortest path between two nodes (and the graph's connected-component count).
+   * @request POST:/api/v1/analysis/path
+   * @secure
+   */
+  computePath = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/path`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/communities/detect Runs Leiden community detection on terms belonging to the specified tenant. Creates Community and CommunityMembership PsiTerms in the knowledge base.
    *
@@ -3580,6 +3881,21 @@ var Communities = class {
     format: "json",
     ...params
   });
+  /**
+   * @description `GET /api/v1/graph/export?tenant_id=…&format=graphml|gexf|csv-nodes|csv-edges|dot` Read-only: returns the serialized graph as raw text with the matching content type. The graph is the same `Value::Reference` projection the analytics use, labelled by each term's `name` feature.
+   *
+   * @tags communities
+   * @name ExportGraph
+   * @summary Export the tenant's reference graph to a graph-interchange format.
+   * @request GET:/api/v1/graph/export
+   * @secure
+   */
+  exportGraph = (params = {}) => this.http.request({
+    path: `/api/v1/graph/export`,
+    method: "GET",
+    secure: true,
+    ...params
+  });
   /**
    * @description POST /api/v1/communities/memberships Returns all communities that a term belongs to, with membership degrees.
    *
@@ -3598,6 +3914,24 @@ var Communities = class {
     format: "json",
     ...params
   });
+  /**
+   * @description `POST /api/v1/analysis/link-prediction` Read-only: returns ranked candidate targets (not already adjacent) with positive score. The scores are **proposals** — a caller turning one into a KB edge must route it through the engine's `gate_arc_proposals` sort-gate; this endpoint never asserts.
+   *
+   * @tags communities
+   * @name PredictLinks
+   * @summary Score candidate links from a source node (link prediction).
+   * @request POST:/api/v1/analysis/link-prediction
+   * @secure
+   */
+  predictLinks = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/link-prediction`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/communities/search Search for communities by various criteria: - ByEntities: Find communities containing specific terms - ByImpact: Find high-impact communities - ByLevel: Find communities at a specific hierarchy level - ByKeyword: Search community reports by keyword
    *
@@ -5588,6 +5922,24 @@ var Discovery = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Validates the request, converts DTOs to domain types, calls the learner port from `AppState`, and maps the result to a response DTO. Input bounds are validated to prevent DoS: - `samples.len()` <= 10,000 - `num_restarts` <= 100 - `max_epochs` <= 50,000 - `depth` in 1..=6
+   *
+   * @tags discovery
+   * @name DiscoverEml
+   * @summary Handler for `POST /discover/eml`.
+   * @request POST:/api/v1/discover/eml
+   * @secure
+   */
+  discoverEml = (data, params = {}) => this.http.request({
+    path: `/api/v1/discover/eml`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/discovery/predict Finds similar historical patterns and predicts effects using fuzzy search with PRODUCT t-norm reweighting for better aggregation.
    *
@@ -5614,6 +5966,22 @@ var Extraction = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description Read-only with respect to the knowledge base: certification inspects the tenant's sort lattice and never writes a term. Certificates *are* written to the verification certificate store, so the batch is auditable afterwards.
+   *
+   * @tags extraction
+   * @name CertifyExtraction
+   * @summary `POST /api/v1/extraction/certify` — gate a batch of extraction candidates through the OSF well-sortedness certifier before they may become durable KB content.
+   * @request POST:/api/v1/extraction/certify
+   */
+  certifyExtraction = (data, params = {}) => this.http.request({
+    path: `/api/v1/extraction/certify`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Uses GLiNER2 (zero-shot NER) with sort names from the tenant's knowledge base, guaranteeing that all returned entity labels are valid sort names. Label selection (when no explicit labels provided): Embed the input text and ANN-search the pre-computed sort embedding index (Qdrant) for the most semantically similar HPO sorts. This is O(log n) and typically returns 20-100 highly relevant labels from 19K+ HPO sorts. Requires: - GLiNER2 NER service (`GLINER_NER_URL`) - Qdrant vector store for semantic label selection If either is not configured, returns a 500 error.
    *
@@ -6234,6 +6602,24 @@ var Fuzzy = class {
     format: "json",
     ...params
   });
+  /**
+   * @description POST /api/v1/fuzzy/score The complement of `/fuzzy/similar`: that one retrieves and ranks a whole sort; this grades a set the caller already chose — typically the top hits of a *semantic* search — against a preference ψ-term, so a two-stage pipeline can retrieve semantically and grade by fuzzy OSF unification, then combine the two scores upstream with a t-norm. A 65-minute course against a "≤1h" fuzzy preference scores ~0.83 (membership), not the hard 0 a boolean filter gave it.
+   *
+   * @tags fuzzy
+   * @name ScoreTerms
+   * @summary Score a GIVEN set of candidate terms against a query ψ-term.
+   * @request POST:/api/v1/fuzzy/score
+   * @secure
+   */
+  scoreTerms = (data, params = {}) => this.http.request({
+    path: `/api/v1/fuzzy/score`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Constraints.ts
@@ -6387,7 +6773,7 @@ var Reasoning = class {
     this.http = http;
   }
   /**
-   * @description POST /api/v1/reasoning/disentailment Disentailment A =/=> B means: "if A holds, then B must NOT hold" Returns whether the disentailment is violated (conflict: both A and B hold)
+   * @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.
    *
    * @tags reasoning
    * @name Disentailment
@@ -6403,7 +6789,7 @@ var Reasoning = class {
     ...params
   });
   /**
-   * @description POST /api/v1/reasoning/entailment Returns whether antecedent entails consequent
+   * @description POST /api/v1/reasoning/entailment Answers `facts ⊨ antecedent ⇒ consequent`, hierarchy-aware and graded. A clause holds in the fact base to the degree that some fact *witnesses* it — that is, to the degree the clause subsumes a fact — so a `sparrow` fact establishes the clause `animal` without an `animal` fact being supplied. The consequent is additionally established when it subsumes the antecedent it would follow from. See [`osfkb_domain::operations::homoiconic_entailment`] for the full semantics. `entails` is the crisp reading of `degree`; `degree`, `antecedent_degree` and `consequent_degree` are computed from the sort lattice (crisply, and through explicit fuzzy `⊑·` relations and approved sort similarity), never cast from the boolean.
    *
    * @tags reasoning
    * @name Entailment
@@ -8432,6 +8818,20 @@ var Health = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags health
+   * @name HealthCheckApi
+   * @summary `GET /api/v1/health` — the same enriched health check under the `/api/v1` prefix. The playground front proxy forwards only `/api/*` to the engine (and answers the bare `/health` itself with a static OK), so THIS is the path that makes the deployed `build_info.version` publicly readable — a stale rollout must never be indistinguishable from a fresh one.
+   * @request GET:/api/v1/health
+   */
+  healthCheckApi = (params = {}) => this.http.request({
+    path: `/api/v1/health`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Scheduling.ts
@@ -8736,6 +9136,24 @@ var Generation = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description Returns 503 when no in-process Gemma is loaded (the server was not started with `OSFKB_OSFQL_GEMMA_DIR`), and 400 when `allowed` is empty.
+   *
+   * @tags generation
+   * @name ConstrainedGenerate
+   * @summary Generate an answer constrained to an OSF-feasible set via the application-tier decoder.
+   * @request POST:/api/v1/constrained/generate
+   * @secure
+   */
+  constrainedGenerate = (data, params = {}) => this.http.request({
+    path: `/api/v1/constrained/generate`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -8754,6 +9172,58 @@ var Generation = class {
     format: "json",
     ...params
   });
+  /**
+   * @description POST /api/v1/text/generate
+   *
+   * @tags generation
+   * @name GenerateText
+   * @summary Run the caller's system prompt over their text.
+   * @request POST:/api/v1/text/generate
+   * @secure
+   */
+  generateText = (data, params = {}) => this.http.request({
+    path: `/api/v1/text/generate`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Returns `503` when no in-process Gemma is loaded (server started without `OSFKB_OSFQL_GEMMA_DIR`), `400` on an empty prompt, and `422` when the tenant has no persisted lattice to constrain to (ingest a theory with `persist:true` first).
+   *
+   * @tags generation
+   * @name GroundedGenerate
+   * @summary Generate grounded prose via the two-pass (constrained derivation → free realization) pipeline.
+   * @request POST:/api/v1/generate/grounded
+   * @secure
+   */
+  groundedGenerate = (data, params = {}) => this.http.request({
+    path: `/api/v1/generate/grounded`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags generation
+   * @name RawGenerate
+   * @summary Raw, ungrounded generation from the **same in-process Gemma** the grounded endpoint uses — a bare chat-prompt free decode with NO substrate, NO feasibility proof, and NO lattice mask. This is the honest "WITHOUT — Raw LLM" baseline for the demo's left panel: the identical local model, answering the identical question, with nothing from the knowledge base — so the side-by-side isolates exactly what ReasoningLayer's substrate adds. Returns `503` when no local Gemma is loaded (server started without `OSFKB_OSFQL_GEMMA_DIR`) and `400` on an empty prompt.
+   * @request POST:/api/v1/generate/raw
+   */
+  rawGenerate = (data, params = {}) => this.http.request({
+    path: `/api/v1/generate/raw`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Rag.ts
@@ -8836,6 +9306,7 @@ var Osfql = class {
     path: `/api/v1/osfql/catalog`,
     method: "GET",
     query,
+    format: "json",
     ...params
   });
 };
@@ -9055,6 +9526,58 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name CreateDsr
+   * @summary File a GDPR data subject request
+   * @request POST:/api/v1/dsr
+   * @secure
+   */
+  createDsr = (data, params = {}) => this.http.request({
+    path: `/api/v1/dsr`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description **Dry run by default.** An exact match on an identifying feature is the only deterministic way to resolve a person to terms, but exactness is not uniqueness — two people share a name. Erasing on a bare match would silently destroy a homonym's data, and erasure is irreversible, so the plan has to be inspectable before it runs. Pass `confirm: true` once the match has been reviewed.
+   *
+   * @tags compliance
+   * @name EraseSubject
+   * @summary Plan or execute erasure of a data subject's terms
+   * @request POST:/api/v1/dsr/{id}/erase
+   * @secure
+   */
+  eraseSubject = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}/erase`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name GetDsr
+   * @summary Read a data subject request
+   * @request GET:/api/v1/dsr/{id}
+   * @secure
+   */
+  getDsr = (id, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -9088,6 +9611,22 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name ListDsr
+   * @summary List a data subject's requests
+   * @request GET:/api/v1/dsr
+   * @secure
+   */
+  listDsr = (params = {}) => this.http.request({
+    path: `/api/v1/dsr`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -9160,6 +9699,22 @@ var Operations = class {
     format: "json",
     ...params
   });
+  /**
+   * @description `POST /api/v1/operations/anti-unify/batch` One in-process left fold of the binary LGG — associative up to variable renaming, so the result equals the client-side pairwise chain while costing a single round trip. Every intermediate LGG is persisted and returned in `steps` (the generalization ladder).
+   *
+   * @tags operations
+   * @name AntiUnifyBatch
+   * @summary Anti-unify N Ψ-terms (Least General Generalisation of the whole set).
+   * @request POST:/api/v1/operations/anti-unify/batch
+   */
+  antiUnifyBatch = (data, params = {}) => this.http.request({
+    path: `/api/v1/operations/anti-unify/batch`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Actions.ts
@@ -9553,6 +10108,24 @@ var OntologyBridge = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The gap this closes (#133): the engine could lower OSFQL to a source's native language and could execute native queries, and the two were never reachable together over HTTP. `POST /api/v1/osfql` runs against the knowledge base and never consults a binding; `POST /api/v1/ontology/transpile` emits the query text and stops. A `transpile`-mode source — which deliberately ingests nothing — therefore had no way to be queried at all, and asking about its data returned an empty result indistinguishable from a broken connector. The dialect is derived from the source's type, never taken from the caller: the binding says which source answers for the sort, and that source's type is the only dialect that could run. Letting a caller name one would let them ask for Cypher against Postgres. The emitted query is returned with the rows. Transpile mode's claim is that OSFQL becomes a native query against the operator's own database; returning only rows leaves that unverifiable.
+   *
+   * @tags ontology_bridge
+   * @name ExecuteTranspiled
+   * @summary Transpile an OSFQL MATCH and execute it on the source it is bound to.
+   * @request POST:/api/v1/ontology/query
+   * @secure
+   */
+  executeTranspiled = (data, params = {}) => this.http.request({
+    path: `/api/v1/ontology/query`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Produces query tools, write tools, and inference tools from the current sort hierarchy and SQL bindings, along with a system prompt suitable for grounding an LLM.
    *
@@ -9622,7 +10195,7 @@ var OntologyBridge = class {
     ...params
   });
   /**
-   * @description Parses the OSFQL query, compiles it, and transpiles the first `ScanBySort` operation to SQL using the current sort-table bindings.
+   * @description Parses the OSFQL query, compiles it, and transpiles EVERY `ScanBySort` operation into one statement using the current sort-table bindings — a JOIN for the SQL dialects, a multi-pattern MATCH for Cypher. A plan operation that is not a scan is refused by name rather than dropped: `fully_transpilable` is what a caller checks to decide whether the emitted text is the whole question, and it reported `true` for a query half of which was never emitted (#134).
    *
    * @tags ontology_bridge
    * @name Transpile
@@ -9656,12 +10229,571 @@ var OntologyBridge = class {
   });
 };
 
+// src/api-spec/generated/Demo.ts
+var Demo = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Returns `404` when the SUMO files cannot be read (bad `OSFKB_SUMO_DIR`/override), `400` when the assembled source fails to import, and `200` with the tenant's sort count + form count on success.
+   *
+   * @tags demo
+   * @name DemoSeed
+   * @summary Seed the request tenant's persistent substrate with full SUMO + the demo scenario situations.
+   * @request POST:/api/v1/demo/seed
+   * @secure
+   */
+  demoSeed = (data, params = {}) => this.http.request({
+    path: `/api/v1/demo/seed`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Reward.ts
+var Reward = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * No description
+   *
+   * @tags reward
+   * @name Score
+   * @summary `POST /api/v1/reward/score` — score a candidate query execution-free for the authenticated tenant. Returns `404` if the sort name is unknown to the lattice.
+   * @request POST:/api/v1/reward/score
+   * @secure
+   */
+  score = (data, params = {}) => this.http.request({
+    path: `/api/v1/reward/score`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Translation.ts
+var Translation = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description POST /api/v1/translate
+   *
+   * @tags translation
+   * @name Translate
+   * @summary Translate text into a target language.
+   * @request POST:/api/v1/translate
+   * @secure
+   */
+  translate = (data, params = {}) => this.http.request({
+    path: `/api/v1/translate`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Streaming.ts
+var Streaming = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Build a Count-Min sketch from `items`, then return the estimated frequency for each key in `query_keys`. Strings are hashed to `u64` before insertion.  The same hash is used for queries, so counts are consistent within a call.  The returned `estimated_count` is an over-estimate: it never falls below the true count, and with (ε, δ) accuracy parameters it exceeds the true count by at most ε · N with probability 1 − δ. No tenant context is required.
+   *
+   * @tags streaming
+   * @name Frequency
+   * @summary `POST /api/v1/streaming/frequency`
+   * @request POST:/api/v1/streaming/frequency
+   */
+  frequency = (data, params = {}) => this.http.request({
+    path: `/api/v1/streaming/frequency`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Build a Misra-Gries sketch from the supplied batch and return the candidate heavy hitters with their lower-bound counts. The algorithm uses `O(capacity)` memory regardless of the stream cardinality.  Every item whose true frequency exceeds `N / (capacity + 1)` is guaranteed to be present in the output. No tenant context is required; the sketch is ephemeral to the call.
+   *
+   * @tags streaming
+   * @name HeavyHitters
+   * @summary `POST /api/v1/streaming/heavy-hitters`
+   * @request POST:/api/v1/streaming/heavy-hitters
+   */
+  heavyHitters = (data, params = {}) => this.http.request({
+    path: `/api/v1/streaming/heavy-hitters`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Build a Bloom filter, insert every item in `insert_items`, then test each item in `test_items` for membership. **Zero false negatives** — every inserted item will test as present. False positives are possible at a rate that depends on `bit_count`, `hash_count`, and the number of distinct items inserted. No tenant context is required.
+   *
+   * @tags streaming
+   * @name Membership
+   * @summary `POST /api/v1/streaming/membership`
+   * @request POST:/api/v1/streaming/membership
+   */
+  membership = (data, params = {}) => this.http.request({
+    path: `/api/v1/streaming/membership`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Conformal.ts
+var Conformal = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Compute a split-conformal non-conformity threshold from a labeled calibration set.  Returns the threshold `τ` and a coverage certificate. The returned `threshold` should be passed verbatim to `POST /api/v1/conformal/predict`.
+   *
+   * @tags conformal
+   * @name Calibrate
+   * @summary `POST /api/v1/conformal/calibrate`
+   * @request POST:/api/v1/conformal/calibrate
+   */
+  calibrate = (data, params = {}) => this.http.request({
+    path: `/api/v1/conformal/calibrate`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Apply a pre-computed conformal threshold to unlabeled test inputs and return prediction sets with coverage certificates. A class `y` is included in an input's prediction set iff `1 − class_scores[y] ≤ threshold` (equivalently, `class_scores[y] ≥ 1 − threshold`). When no class meets this criterion the prediction set is empty and `abstains = true` is set on that input's result.
+   *
+   * @tags conformal
+   * @name Predict
+   * @summary `POST /api/v1/conformal/predict`
+   * @request POST:/api/v1/conformal/predict
+   */
+  predict = (data, params = {}) => this.http.request({
+    path: `/api/v1/conformal/predict`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Vision.ts
+var Vision = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Requires the deployment to have a [`VJepaPerceptionService`] mounted as an Axum extension. If absent, the route should not be registered; if it is registered without the extension, this handler returns 503. Mounted at `POST /api/v1/vision/encode-clip` by the production composition root when the V-JEPA service is configured.
+   *
+   * @tags vision
+   * @name EncodeClip
+   * @summary Encode a video clip end-to-end through V-JEPA + the head + the substrate, returning per-frame Ψ-term prediction summaries.
+   * @request POST:/api/v1/vision/encode-clip
+   * @secure
+   */
+  encodeClip = (data, params = {}) => this.http.request({
+    path: `/api/v1/vision/encode-clip`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Anonymization.ts
+var Anonymization = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description Batch-anonymize a set of records using either k-anonymity or HIPAA Safe Harbor de-identification.  Returns the processed records together with a full compliance report. Accepts up to 10 000 records per call.  For larger batches partition the input and call in parallel. Returns `200 OK` with [`AnonymizeResponse`] on success.
+   *
+   * @tags anonymization
+   * @name AnonymizeRecords
+   * @summary `POST /api/v1/anonymize`
+   * @request POST:/api/v1/anonymize
+   * @secure
+   */
+  anonymizeRecords = (data, params = {}) => this.http.request({
+    path: `/api/v1/anonymize`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Speakers.ts
+var Speakers = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description DELETE /api/v1/speakers/{id}
+   *
+   * @tags speakers
+   * @name DeleteSpeaker
+   * @summary Delete a speaker profile by id.
+   * @request DELETE:/api/v1/speakers/{id}
+   * @secure
+   */
+  deleteSpeaker = (id, params = {}) => this.http.request({
+    path: `/api/v1/speakers/${id}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speakers/enroll
+   *
+   * @tags speakers
+   * @name EnrollSpeaker
+   * @summary Enroll (or re-enroll) a speaker voiceprint.
+   * @request POST:/api/v1/speakers/enroll
+   * @secure
+   */
+  enrollSpeaker = (data, params = {}) => this.http.request({
+    path: `/api/v1/speakers/enroll`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speakers/identify
+   *
+   * @tags speakers
+   * @name IdentifySpeakers
+   * @summary Identify which enrolled voices speak in a piece of audio — no transcript.
+   * @request POST:/api/v1/speakers/identify
+   * @secure
+   */
+  identifySpeakers = (data, params = {}) => this.http.request({
+    path: `/api/v1/speakers/identify`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/speakers
+   *
+   * @tags speakers
+   * @name ListSpeakers
+   * @summary List the tenant's enrolled speaker profiles (embeddings withheld).
+   * @request GET:/api/v1/speakers
+   * @secure
+   */
+  listSpeakers = (params = {}) => this.http.request({
+    path: `/api/v1/speakers`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Speech.ts
+var Speech = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description DELETE /api/v1/speech/voices/{id}
+   *
+   * @tags speech
+   * @name DeleteVoice
+   * @summary Delete a cloned voice, upstream conditioning included.
+   * @request DELETE:/api/v1/speech/voices/{id}
+   * @secure
+   */
+  deleteVoice = (id, params = {}) => this.http.request({
+    path: `/api/v1/speech/voices/${id}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speech/voices
+   *
+   * @tags speech
+   * @name EnrollVoice
+   * @summary Enroll (or re-enroll) a cloned voice.
+   * @request POST:/api/v1/speech/voices
+   * @secure
+   */
+  enrollVoice = (data, params = {}) => this.http.request({
+    path: `/api/v1/speech/voices`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/speech/engines
+   *
+   * @tags speech
+   * @name ListEngines
+   * @summary Report per-engine availability.
+   * @request GET:/api/v1/speech/engines
+   * @secure
+   */
+  listEngines = (params = {}) => this.http.request({
+    path: `/api/v1/speech/engines`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/speech/voices
+   *
+   * @tags speech
+   * @name ListVoices
+   * @summary List the tenant's cloned voices plus available presets.
+   * @request GET:/api/v1/speech/voices
+   * @secure
+   */
+  listVoices = (params = {}) => this.http.request({
+    path: `/api/v1/speech/voices`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speech/session
+   *
+   * @tags speech
+   * @name OpenSpeechSession
+   * @summary Open a speech-to-speech session.
+   * @request POST:/api/v1/speech/session
+   * @secure
+   */
+  openSpeechSession = (data, params = {}) => this.http.request({
+    path: `/api/v1/speech/session`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speech/synthesize
+   *
+   * @tags speech
+   * @name SynthesizeSpeech
+   * @summary Synthesize speech.
+   * @request POST:/api/v1/speech/synthesize
+   * @secure
+   */
+  synthesizeSpeech = (data, params = {}) => this.http.request({
+    path: `/api/v1/speech/synthesize`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    ...params
+  });
+  /**
+   * @description POST /api/v1/speech/transcribe
+   *
+   * @tags speech
+   * @name TranscribeSpeech
+   * @summary Transcribe a short utterance.
+   * @request POST:/api/v1/speech/transcribe
+   * @secure
+   */
+  transcribeSpeech = (data, params = {}) => this.http.request({
+    path: `/api/v1/speech/transcribe`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Connectors.ts
+var Connectors = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description POST /api/v1/connectors/manage
+   *
+   * @tags connectors
+   * @name Add
+   * @summary Add a connector instance to the tenant.
+   * @request POST:/api/v1/connectors/manage
+   * @secure
+   */
+  add = (data, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/connectors/manage/{name}/disconnect
+   *
+   * @tags connectors
+   * @name Disconnect
+   * @summary Disconnect a connector (revoke tokens, set status=disconnected).
+   * @request POST:/api/v1/connectors/manage/{name}/disconnect
+   * @secure
+   */
+  disconnect = (name, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage/${name}/disconnect`,
+    method: "POST",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description GET /api/v1/connectors/manage
+   *
+   * @tags connectors
+   * @name List
+   * @summary List tenant's connectors.
+   * @request GET:/api/v1/connectors/manage
+   * @secure
+   */
+  list = (params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/connector-types
+   *
+   * @tags connectors
+   * @name ListTypes
+   * @summary List available connector types (global catalog).
+   * @request GET:/api/v1/connector-types
+   */
+  listTypes = (params = {}) => this.http.request({
+    path: `/api/v1/connector-types`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description GET /api/v1/connectors/manage/{name}/oauth/callback
+   *
+   * @tags connectors
+   * @name OauthCallback
+   * @summary OAuth callback — exchanges code for tokens, returns HTML that posts message to opener.
+   * @request GET:/api/v1/connectors/manage/{name}/oauth/callback
+   */
+  oauthCallback = (name, query, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage/${name}/oauth/callback`,
+    method: "GET",
+    query,
+    ...params
+  });
+  /**
+   * @description DELETE /api/v1/connectors/manage/{name}
+   *
+   * @tags connectors
+   * @name Remove
+   * @summary Remove a connector from the tenant (cascades: deletes tokens).
+   * @request DELETE:/api/v1/connectors/manage/{name}
+   * @secure
+   */
+  remove = (name, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage/${name}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description POST /api/v1/connectors/manage/{name}/connect
+   *
+   * @tags connectors
+   * @name StartOauth
+   * @summary Start OAuth flow — returns auth URL for popup.
+   * @request POST:/api/v1/connectors/manage/{name}/connect
+   * @secure
+   */
+  startOauth = (name, params = {}) => this.http.request({
+    path: `/api/v1/connectors/manage/${name}/connect`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
+};
+
 // src/api-spec/generated/Documents.ts
 var Documents = class {
   http;
   constructor(http) {
     this.http = http;
   }
+  /**
+   * No description
+   *
+   * @tags documents
+   * @name EraseDocument
+   * @summary Erase a document and everything extracted from it
+   * @request DELETE:/api/v1/documents/{id}
+   * @secure
+   */
+  eraseDocument = (id, params = {}) => this.http.request({
+    path: `/api/v1/documents/${id}`,
+    method: "DELETE",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -11121,6 +12253,15 @@ function RejectLearnedSimilarityResponseFromApiToFront(dto) {
     message: dto.message
   };
 }
+function SortIndexStatusResponseFromApiToFront(dto) {
+  const out = {
+    running: dto.running,
+    totalSorts: dto.total_sorts
+  };
+  if (dto.last_error != null) out.lastError = dto.last_error;
+  if (dto.last_indexed_count != null) out.lastIndexedCount = dto.last_indexed_count;
+  return out;
+}
 
 // src/resources/sorts.ts
 var SortsClient = class {
@@ -11336,6 +12477,16 @@ var SortsClient = class {
   async indexSorts() {
     await this.sorts.indexSorts();
   }
+  /**
+   * Report the status of the background sort-indexing pass.
+   *
+   * @returns Whether a re-index is running, the most recent run's indexed
+   *   count and any error, plus the total data-sort denominator.
+   */
+  async sortIndexStatus() {
+    const response = await this.sorts.sortIndexStatus();
+    return SortIndexStatusResponseFromApiToFront(response.data);
+  }
   /**
    * Update the review status of a sort.
    *
@@ -14687,6 +15838,25 @@ function FindSimilarRequestFromFrontToApi(model) {
     fail_on_unknown: model.failOnUnknown
   };
 }
+function ScoreTermsRequestFromFrontToApi(model) {
+  return {
+    ...QueryTermFromFrontToApi(model),
+    fail_on_unknown: model.failOnUnknown,
+    similarity_mode: model.similarityMode,
+    term_ids: model.termIds
+  };
+}
+function ScoredTermFromApiToFront(dto) {
+  return {
+    degree: dto.degree,
+    termId: dto.term_id
+  };
+}
+function ScoreTermsResponseFromApiToFront(dto) {
+  return {
+    scores: dto.scores.map(ScoredTermFromApiToFront)
+  };
+}
 function SimilarityMatchFromApiToFront(dto) {
   return {
     confidencePercent: dto.confidence_percent,
@@ -14857,6 +16027,18 @@ var FuzzyClient = class {
     });
     return PredictEffectResponseFromApiToFront(response.data);
   }
+  /**
+   * Score a given set of candidate terms against a query ψ-term.
+   *
+   * @param request - The query ψ-term (`QueryTerm`) plus the candidate
+   *   `termIds` and optional scoring knobs.
+   * @returns The candidates with their fuzzy-unification degrees, in
+   *   input order.
+   */
+  async scoreTerms(request) {
+    const response = await this.api.scoreTerms(ScoreTermsRequestFromFrontToApi(request));
+    return ScoreTermsResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/visualization.ts
@@ -18472,6 +19654,35 @@ function IngestRdfRequestFromFrontToApi(model) {
     parse_shacl: model.parseShacl
   };
 }
+function IngestKifRequestFromFrontToApi(model) {
+  const dto = { content: model.content };
+  if (model.goal !== void 0) dto.goal = model.goal;
+  if (model.persist !== void 0) dto.persist = model.persist;
+  if (model.query !== void 0) dto.query = model.query;
+  return dto;
+}
+function IngestKifResponseFromApiToFront(dto) {
+  const out = {
+    capturedNonHorn: dto.captured_non_horn,
+    constraintRules: dto.constraint_rules,
+    disjunctiveRules: dto.disjunctive_rules,
+    facts: dto.facts,
+    forms: dto.forms,
+    hornRules: dto.horn_rules,
+    instantiatedRules: dto.instantiated_rules,
+    nafRules: dto.naf_rules,
+    residueByShape: dto.residue_by_shape,
+    residueExamples: dto.residue_examples,
+    rules: dto.rules,
+    skolemized: dto.skolemized,
+    sorts: dto.sorts,
+    subclassEdges: dto.subclass_edges,
+    success: dto.success,
+    temporalDetached: dto.temporal_detached
+  };
+  if (dto.provable != null) out.provable = dto.provable;
+  return out;
+}
 function TranslateRdfRequestFromFrontToApi(model) {
   return {
     content: model.content,
@@ -18801,20 +20012,21 @@ var IngestionSession = class {
         }));
         return;
       }
-      const timer = setTimeout(resolve, ms);
+      let onAbort;
+      const timer = setTimeout(() => {
+        if (signal && onAbort) {
+          signal.removeEventListener("abort", onAbort);
+        }
+        resolve();
+      }, ms);
       if (signal) {
-        const onAbort = () => {
+        onAbort = () => {
           clearTimeout(timer);
           reject(new ReasoningLayerError("Ingestion polling was aborted", {
             cause: signal.reason
           }));
         };
         signal.addEventListener("abort", onAbort, { once: true });
-        const originalResolve = resolve;
-        resolve = () => {
-          signal.removeEventListener("abort", onAbort);
-          originalResolve();
-        };
       }
     });
   }
@@ -18918,6 +20130,21 @@ var IngestionClient = class {
     );
     return IngestRdfResponseFromApiToFront(response.data);
   }
+  /**
+   * Import SUO-KIF and, optionally, prove a ground goal against the
+   * imported axioms.
+   *
+   * @param request - The SUO-KIF source, an optional `goal`/`query` to
+   *   prove, and a `persist` flag (import into the tenant substrate vs an
+   *   ephemeral request-scoped world).
+   * @returns Import counts (forms, facts, rules, sorts, …) plus, when a
+   *   goal/query was supplied, a `provable` verdict and the non-firing
+   *   residue breakdown.
+   */
+  async ingestKif(request) {
+    const response = await this.api.ingestKif(IngestKifRequestFromFrontToApi(request));
+    return IngestKifResponseFromApiToFront(response.data);
+  }
   /**
    * Translate RDF into the engine's term representation without writing
    * anything to the knowledge base.
@@ -21533,6 +22760,66 @@ function SearchCommunitiesResponseFromApiToFront(dto) {
     stats: CommunitySearchStatsDtoFromApiToFront(dto.stats)
   };
 }
+function NodeScoreFromApiToFront(dto) {
+  return {
+    nodeId: dto.node_id,
+    score: dto.score
+  };
+}
+function CentralityRequestFromFrontToApi(model) {
+  const dto = {
+    measure: model.measure,
+    tenant_id: model.tenantId
+  };
+  if (model.topK !== void 0) dto.top_k = model.topK;
+  return dto;
+}
+function CentralityResponseFromApiToFront(dto) {
+  return {
+    edgeCount: dto.edge_count,
+    measure: dto.measure,
+    nodeCount: dto.node_count,
+    scores: dto.scores.map(NodeScoreFromApiToFront)
+  };
+}
+function CohesionRequestFromFrontToApi(model) {
+  return { tenant_id: model.tenantId };
+}
+function CohesionResponseFromApiToFront(dto) {
+  return {
+    clustering: dto.clustering.map(NodeScoreFromApiToFront),
+    nodeCount: dto.node_count,
+    triangleCount: dto.triangle_count
+  };
+}
+function PathRequestFromFrontToApi(model) {
+  return {
+    source: model.source,
+    target: model.target,
+    tenant_id: model.tenantId
+  };
+}
+function PathResponseFromApiToFront(dto) {
+  const out = { componentCount: dto.component_count };
+  if (dto.path !== void 0 && dto.path !== null) out.path = dto.path;
+  return out;
+}
+function LinkPredictionRequestFromFrontToApi(model) {
+  const dto = {
+    measure: model.measure,
+    source: model.source,
+    tenant_id: model.tenantId
+  };
+  if (model.topK !== void 0) dto.top_k = model.topK;
+  return dto;
+}
+function LinkPredictionResponseFromApiToFront(dto) {
+  return {
+    measure: dto.measure,
+    predictions: dto.predictions.map(NodeScoreFromApiToFront),
+    source: dto.source
+  };
+}
 
 // src/resources/communities.ts
 var CommunitiesClient = class {
@@ -21572,6 +22859,48 @@ var CommunitiesClient = class {
     const response = await this.api.searchCommunities(SearchCommunitiesRequestFromFrontToApi(request));
     return SearchCommunitiesResponseFromApiToFront(response.data);
   }
+  /**
+   * Compute a centrality measure over the tenant's term graph.
+   *
+   * @param request - The measure, tenant id, and an optional `topK` cap.
+   * @returns Node scores sorted descending, plus graph node/edge counts.
+   */
+  async computeCentrality(request) {
+    const response = await this.api.computeCentrality(CentralityRequestFromFrontToApi(request));
+    return CentralityResponseFromApiToFront(response.data);
+  }
+  /**
+   * Compute graph cohesion (local clustering coefficients + triangle count).
+   *
+   * @param request - The tenant id.
+   * @returns Per-node clustering coefficients, node count, and triangle count.
+   */
+  async computeCohesion(request) {
+    const response = await this.api.computeCohesion(CohesionRequestFromFrontToApi(request));
+    return CohesionResponseFromApiToFront(response.data);
+  }
+  /**
+   * Find the shortest path between two nodes in the tenant's term graph.
+   *
+   * @param request - Source node, target node, and tenant id.
+   * @returns The shortest path as a node sequence (when reachable) plus the
+   *   connected-component count.
+   */
+  async computePath(request) {
+    const response = await this.api.computePath(PathRequestFromFrontToApi(request));
+    return PathResponseFromApiToFront(response.data);
+  }
+  /**
+   * Predict candidate links from a source node using a graph heuristic.
+   *
+   * @param request - The heuristic, source node, tenant id, and an optional
+   *   `topK` cap.
+   * @returns Candidate targets with positive score, sorted descending.
+   */
+  async predictLinks(request) {
+    const response = await this.api.predictLinks(LinkPredictionRequestFromFrontToApi(request));
+    return LinkPredictionResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/utilities.ts
@@ -22404,6 +23733,33 @@ function PredictFromDiscoveryResponseFromApiToFront(dto) {
     success: dto.success
   };
 }
+function EmlSampleFromFrontToApi(model) {
+  return {
+    inputs: model.inputs,
+    target: model.target
+  };
+}
+function DiscoverEmlRequestFromFrontToApi(model) {
+  const dto = {
+    depth: model.depth,
+    samples: model.samples.map(EmlSampleFromFrontToApi)
+  };
+  if (model.maxEpochs !== void 0) dto.max_epochs = model.maxEpochs;
+  if (model.numRestarts !== void 0) dto.num_restarts = model.numRestarts;
+  return dto;
+}
+function DiscoverEmlResponseFromApiToFront(dto) {
+  const out = {
+    epochsRun: dto.epochs_run,
+    finalLoss: dto.final_loss,
+    snapped: dto.snapped,
+    success: dto.success
+  };
+  if (dto.expression_depth != null) out.expressionDepth = dto.expression_depth;
+  if (dto.expression_leaf_count != null) out.expressionLeafCount = dto.expression_leaf_count;
+  if (dto.expression_rpn != null) out.expressionRpn = dto.expression_rpn;
+  return out;
+}
 
 // src/resources/discovery.ts
 var DiscoveryClient = class {
@@ -22433,6 +23789,19 @@ var DiscoveryClient = class {
     const response = await this.api.predictFromDiscovery(PredictFromDiscoveryRequestFromFrontToApi(request));
     return PredictFromDiscoveryResponseFromApiToFront(response.data);
   }
+  /**
+   * Discover a closed-form expression from samples via parameterised EML.
+   *
+   * @param request - Tree-depth bound, training samples, and optional
+   *   epoch/restart caps.
+   * @returns The discovered expression (RPN + depth/leaf-count when
+   *   recovered) plus the training stats (epochs, final loss, snap +
+   *   success flags).
+   */
+  async discoverEml(request) {
+    const response = await this.api.discoverEml(DiscoverEmlRequestFromFrontToApi(request));
+    return DiscoverEmlResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/extract.ts
@@ -25670,6 +27039,56 @@ function GenerateDocumentResponseFromApiToFront(dto) {
     verification: dto.verification ? VerificationDtoFromApiToFront(dto.verification) : void 0
   };
 }
+function ConstrainedGenerateRequestFromFrontToApi(model) {
+  const dto = {
+    allowed: model.allowed,
+    prompt: model.prompt
+  };
+  if (model.maxTokens !== void 0) dto.max_tokens = model.maxTokens;
+  return dto;
+}
+function ConstrainedGenerateResponseFromApiToFront(dto) {
+  return {
+    allowed: dto.allowed,
+    answer: dto.answer,
+    maskedOut: dto.masked_out,
+    tokens: dto.tokens
+  };
+}
+function RawGenerateRequestFromFrontToApi(model) {
+  const dto = { prompt: model.prompt };
+  if (model.maxTokens !== void 0) dto.max_tokens = model.maxTokens;
+  return dto;
+}
+function RawGenerateResponseFromApiToFront(dto) {
+  return { prose: dto.prose };
+}
+function GroundedGenerateRequestFromFrontToApi(model) {
+  const dto = { prompt: model.prompt };
+  if (model.goalDest !== void 0) dto.goal_dest = model.goalDest;
+  if (model.goalDistance !== void 0) dto.goal_distance = model.goalDistance;
+  if (model.goalFeasible !== void 0) dto.goal_feasible = model.goalFeasible;
+  if (model.goalTarget !== void 0) dto.goal_target = model.goalTarget;
+  if (model.maxTokens !== void 0) dto.max_tokens = model.maxTokens;
+  if (model.mode !== void 0) dto.mode = model.mode;
+  if (model.prose !== void 0) dto.prose = model.prose;
+  if (model.steerMargin !== void 0) dto.steer_margin = model.steerMargin;
+  return dto;
+}
+function GroundedGenerateResponseFromApiToFront(dto) {
+  const out = {
+    admittedTerms: dto.admitted_terms,
+    derivation: dto.derivation,
+    feasibleModes: dto.feasible_modes,
+    mode: dto.mode,
+    prose: dto.prose,
+    refutedModes: dto.refuted_modes
+  };
+  if (dto.certify_outcome != null) out.certifyOutcome = dto.certify_outcome;
+  if (dto.model_pick != null) out.modelPick = dto.model_pick;
+  if (dto.recommended_mode != null) out.recommendedMode = dto.recommended_mode;
+  return out;
+}
 
 // src/resources/generation.ts
 var GenerationClient = class {
@@ -25712,6 +27131,46 @@ var GenerationClient = class {
     const response = await this.api.generateDocument(GenerateDocumentRequestFromFrontToApi(request));
     return GenerateDocumentResponseFromApiToFront(response.data);
   }
+  /**
+   * Masked-decode one answer from an OSF-feasible allowed set
+   * (`POST /api/v1/constrained/generate`).
+   *
+   * @param request - The allowed set, an optional token cap, and the prompt.
+   * @returns The decoded answer (guaranteed inside `allowed`), the masked-out
+   *   alternatives, and the per-step token deltas.
+   */
+  async constrainedGenerate(request) {
+    const response = await this.api.constrainedGenerate(
+      ConstrainedGenerateRequestFromFrontToApi(request)
+    );
+    return ConstrainedGenerateResponseFromApiToFront(response.data);
+  }
+  /**
+   * Free, ungrounded local-model decode (`POST /api/v1/generate/raw`).
+   *
+   * @param request - The prompt and an optional token cap.
+   * @returns The raw, ungrounded answer.
+   */
+  async rawGenerate(request) {
+    const response = await this.api.rawGenerate(RawGenerateRequestFromFrontToApi(request));
+    return RawGenerateResponseFromApiToFront(response.data);
+  }
+  /**
+   * Lattice-grounded anti-hallucination generation
+   * (`POST /api/v1/generate/grounded`).
+   *
+   * @param request - The prompt, an optional goal (target/destination) for
+   *   feasibility, the anti-hallucination `mode`, and decode knobs.
+   * @returns The lattice-constrained derivation, the free-prose answer, the
+   *   feasible/refuted/recommended motion modes, and (certify mode) the
+   *   certification outcome.
+   */
+  async groundedGenerate(request) {
+    const response = await this.api.groundedGenerate(
+      GroundedGenerateRequestFromFrontToApi(request)
+    );
+    return GroundedGenerateResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/rag.ts
@@ -27232,6 +28691,13 @@ function ListConversationsResponseFromApiToFront(dto) {
     conversations: dto.conversations.map(ConversationSummaryDtoFromApiToFront)
   };
 }
+function CompareModelDtoFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    kind: dto.kind,
+    label: dto.label
+  };
+}
 function ConversationTurnsResponseFromApiToFront(dto) {
   return {
     conversationId: dto.conversation_id,
@@ -27340,6 +28806,30 @@ var ConversationClient = class {
     });
     return ListConversationsResponseFromApiToFront(response.data);
   }
+  /**
+   * List the registered comparison models so the UI can populate a
+   * selector / compare panel.
+   *
+   * @returns The available comparison models (endpoint- or candle-backed).
+   * @throws {ApiError} If the request fails.
+   *
+   * @example
+   * ```typescript
+   * const models = await client.conversation.listModels();
+   * for (const m of models) {
+   *   console.log(`${m.id} (${m.kind}): ${m.label}`);
+   * }
+   * ```
+   */
+  async listModels() {
+    const response = await this.http.request({
+      path: "/api/v1/conversation/models",
+      method: "GET",
+      secure: true,
+      format: "json"
+    });
+    return (response.data ?? []).map(CompareModelDtoFromApiToFront);
+  }
   /**
    * Get all turns for a conversation.
    *
@@ -27531,7 +29021,15 @@ function PaperMetadataFromApiToFront(dto) {
     abstractText: dto.abstract_text ?? null,
     citationCount: dto.citation_count ?? null,
     source: dto.source,
-    fullTextUrl: dto.full_text_url ?? null
+    fullTextUrl: dto.full_text_url ?? null,
+    paperKey: dto.paper_key ?? null
+  };
+}
+function PaperRefFromApiToFront(dto) {
+  return {
+    paperKey: dto.paper_key,
+    doi: dto.doi ?? null,
+    title: dto.title
   };
 }
 function PaperSearchResultFromApiToFront(dto) {
@@ -27565,6 +29063,8 @@ function ResearchCycleResultFromApiToFront(dto) {
     papersIngested: dto.papers_ingested,
     claimsVerified: dto.claims_verified,
     contradictionsDetected: dto.contradictions_detected,
+    contradictionsResolved: dto.contradictions_resolved ?? 0,
+    claimsMerged: dto.claims_merged ?? 0,
     processingTimeMs: dto.processing_time_ms,
     searchQueries: dto.search_queries ?? []
   };
@@ -27577,6 +29077,7 @@ function ResearchSessionResponseFromApiToFront(raw) {
     status: dto.status,
     error: dto.error ?? null,
     cycles: (dto.cycles ?? []).map(ResearchCycleResultFromApiToFront),
+    papers: (dto.papers ?? []).map(PaperMetadataFromApiToFront),
     totalPapersIngested: dto.total_papers_ingested,
     totalFindings: dto.total_findings,
     totalContradictions: dto.total_contradictions,
@@ -27621,7 +29122,9 @@ function EvidenceItemSummaryFromApiToFront(dto) {
     qualityWeight: dto.quality_weight,
     supports: dto.supports,
     contribution: dto.contribution,
-    paperDoi: dto.paper_doi ?? null
+    paperDoi: dto.paper_doi ?? null,
+    paperKey: dto.paper_key ?? null,
+    paperTitle: dto.paper_title ?? null
   };
 }
 function ProvenanceStepFromApiToFront(dto) {
@@ -27632,6 +29135,13 @@ function ProvenanceStepFromApiToFront(dto) {
     timestamp: dto.timestamp ?? null
   };
 }
+function ResiduatedFeatureFromApiToFront(dto) {
+  return {
+    featureName: dto.feature_name,
+    neededSort: dto.needed_sort ?? null,
+    infoGain: dto.info_gain
+  };
+}
 function ResearchFindingFromApiToFront(dto) {
   return {
     claimId: dto.claim_id,
@@ -27642,7 +29152,9 @@ function ResearchFindingFromApiToFront(dto) {
     contradictingEvidence: (dto.contradicting_evidence ?? []).map(EvidenceItemSummaryFromApiToFront),
     provenanceChain: (dto.provenance_chain ?? []).map(ProvenanceStepFromApiToFront),
     residuated: dto.residuated,
-    residuationReason: dto.residuation_reason ?? null
+    residuationReason: dto.residuation_reason ?? null,
+    residuatedFeatures: (dto.residuated_features ?? []).map(ResiduatedFeatureFromApiToFront),
+    sources: (dto.sources ?? []).map(PaperRefFromApiToFront)
   };
 }
 function ResearchFindingsResponseFromApiToFront(raw) {
@@ -27670,6 +29182,17 @@ function ResearchGapsResponseFromApiToFront(raw) {
     total: dto.total
   };
 }
+function ContradictionResolutionFromApiToFront(dto) {
+  return {
+    preferredClaimId: dto.preferred_claim_id,
+    dismissedClaimId: dto.dismissed_claim_id,
+    preferredTruthfulness: dto.preferred_truthfulness,
+    dismissedTruthfulness: dto.dismissed_truthfulness,
+    strategy: dto.strategy,
+    confidence: dto.confidence,
+    explanation: dto.explanation
+  };
+}
 function ContradictionFromApiToFront(dto) {
   return {
     claimAId: dto.claim_a_id,
@@ -27677,7 +29200,10 @@ function ContradictionFromApiToFront(dto) {
     statementA: dto.statement_a,
     statementB: dto.statement_b,
     confidence: dto.confidence,
-    explanation: dto.explanation
+    explanation: dto.explanation,
+    resolution: dto.resolution ? ContradictionResolutionFromApiToFront(dto.resolution) : null,
+    claimASources: (dto.claim_a_sources ?? []).map(PaperRefFromApiToFront),
+    claimBSources: (dto.claim_b_sources ?? []).map(PaperRefFromApiToFront)
   };
 }
 function ResearchContradictionsResponseFromApiToFront(raw) {
@@ -27698,7 +29224,9 @@ function ResearchStatisticsFromApiToFront(dto) {
     totalContradictions: dto.total_contradictions,
     totalProcessingTimeMs: dto.total_processing_time_ms,
     gapsResolved: dto.gaps_resolved,
-    gapsRemaining: dto.gaps_remaining
+    gapsRemaining: dto.gaps_remaining,
+    claimsMerged: dto.claims_merged ?? 0,
+    contradictionsResolved: dto.contradictions_resolved ?? 0
   };
 }
 function ReportVerificationFromApiToFront(dto) {
@@ -28859,6 +30387,14 @@ function AuditRecordFromApiToFront(dto) {
     extra: dto.extra
   };
 }
+function AuditPageFromApiToFront(dto) {
+  return {
+    records: dto.records.map(AuditRecordFromApiToFront),
+    total: dto.total,
+    limit: dto.limit ?? null,
+    offset: dto.offset
+  };
+}
 function SummaryResponseFromApiToFront(dto) {
   const out = {
     nRecords: dto.n_records,
@@ -28948,18 +30484,39 @@ var ComplianceClient = class {
     return AuditRecordFromApiToFront(response.data);
   }
   /**
-   * List audit records for this tenant, optionally filtered.
+   * List audit records for this tenant — paged, sorted, and filtered.
+   *
+   * @param options - Page / sort / filter controls. Defaults to a
+   *   bounded first page (`sort_by=timestamp`, `sort_order=desc`,
+   *   `limit=50`) — most-recent-first, matching the backend default.
+   *   Pass `all: true` to fetch the full filtered set for export.
+   * @returns A page of records plus the filtered `total`, the `limit`
+   *   applied (`null` when `all` was set), and the zero-based `offset`.
    *
-   * @param options - Limit / glob filter on `requestPath`.
+   * @remarks
+   * The backend clamps `limit` to `1..=200` and defaults it to `50`
+   * when omitted (unless `all` is set). `total` reflects the active
+   * `requestPathPattern` / `since` / `until` filter, not the raw
+   * tenant count — so `{shown} of {total}` and the rendered rows stay
+   * consistent under the same filter. Sort enums are wire-serialised
+   * `snake_case` (`timestamp` / `request_path` / `actor`) and `asc` /
+   * `desc` lowercase; the shipped {@link AuditSortField} /
+   * {@link AuditSortOrder} literals match verbatim.
    */
   async list(options = {}) {
     const query = {};
-    if (options.limit !== void 0) query.limit = options.limit;
     if (options.requestPathPattern !== void 0) {
       query.request_path_pattern = options.requestPathPattern;
     }
+    if (options.since !== void 0) query.since = options.since;
+    if (options.until !== void 0) query.until = options.until;
+    if (options.sortBy !== void 0) query.sort_by = options.sortBy;
+    if (options.sortOrder !== void 0) query.sort_order = options.sortOrder;
+    if (options.limit !== void 0) query.limit = options.limit;
+    if (options.offset !== void 0) query.offset = options.offset;
+    if (options.all !== void 0) query.all = options.all;
     const response = await this.api.list(query);
-    return response.data.map(AuditRecordFromApiToFront);
+    return AuditPageFromApiToFront(response.data);
   }
   /**
    * Top-line counts over the tenant's full ledger — useful for
@@ -29039,6 +30596,19 @@ function AntiUnifyResponseFromApiToFront(dto) {
     computationTimeMs: dto.computation_time_ms
   };
 }
+function AntiUnifyBatchRequestFromFrontToApi(model) {
+  return {
+    term_ids: model.termIds
+  };
+}
+function AntiUnifyBatchResponseFromApiToFront(dto) {
+  return {
+    computationTimeMs: dto.computation_time_ms,
+    lgg: TermDtoFromApiToFront(dto.lgg),
+    lggTermId: dto.lgg_term_id,
+    steps: dto.steps
+  };
+}
 
 // src/resources/operations.ts
 var OperationsClient = class {
@@ -29067,6 +30637,25 @@ var OperationsClient = class {
     );
     return AntiUnifyResponseFromApiToFront(response.data);
   }
+  /**
+   * Compute the anti-unification (LGG) of a batch of Ψ-terms via a left
+   * fold over 2..=64 term ids.
+   *
+   * @param request - The term ids to generalise, in fold order.
+   * @returns The final LGG term + enriched view + the intermediate LGG
+   *   ids from the fold + total timing.
+   *
+   * @remarks
+   * All ids must already be registered in the tenant's term store. The
+   * final LGG is persisted; `steps` is empty when exactly two terms are
+   * supplied.
+   */
+  async antiUnifyBatch(request) {
+    const response = await this.api.antiUnifyBatch(
+      AntiUnifyBatchRequestFromFrontToApi(request)
+    );
+    return AntiUnifyBatchResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/actions.ts
@@ -34316,6 +35905,1016 @@ var OntologyExportClient = class {
   }
 };
 
+// src/normalizers/demo.ts
+function DemoSeedRequestFromFrontToApi(model) {
+  const dto = {};
+  if (model.sumoDir !== void 0) dto.sumo_dir = model.sumoDir;
+  return dto;
+}
+function DemoSeedResponseFromApiToFront(dto) {
+  return {
+    forms: dto.forms,
+    sorts: dto.sorts
+  };
+}
+
+// src/resources/demo.ts
+var DemoClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Seed the request tenant's persistent substrate with full SUMO + the
+   * demo scenario situations.
+   *
+   * @param request - Optional SUMO source-directory override.
+   * @returns The imported form count and the tenant's total sort count.
+   *
+   * @throws {ApiError} `404` if the SUMO files cannot be read, `400` if
+   *   the assembled source fails to import.
+   */
+  async seed(request = {}) {
+    const response = await this.api.demoSeed(DemoSeedRequestFromFrontToApi(request));
+    return DemoSeedResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/reward.ts
+function RewardScoreRequestFromFrontToApi(model) {
+  const dto = { sort: model.sort };
+  if (model.constraints !== void 0) dto.constraints = model.constraints;
+  if (model.maxInstances !== void 0) dto.max_instances = model.maxInstances;
+  if (model.negativeIds !== void 0) dto.negative_ids = model.negativeIds;
+  if (model.objective !== void 0) dto.objective = model.objective;
+  if (model.positiveIds !== void 0) dto.positive_ids = model.positiveIds;
+  if (model.targetSort !== void 0) dto.target_sort = model.targetSort;
+  return dto;
+}
+function RewardScoreResponseFromApiToFront(dto) {
+  const out = {
+    certifiedNonEmpty: dto.certified_non_empty,
+    estimatedExtent: dto.estimated_extent,
+    reward: dto.reward
+  };
+  if (dto.covers_negative != null) out.coversNegative = dto.covers_negative;
+  if (dto.covers_positive != null) out.coversPositive = dto.covers_positive;
+  if (dto.precision != null) out.precision = dto.precision;
+  if (dto.recall != null) out.recall = dto.recall;
+  return out;
+}
+
+// src/resources/reward.ts
+var RewardClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Score a candidate query execution-free for the authenticated tenant.
+   *
+   * @param request - The query spec (sort, objective, optional
+   *   constraints / instance ids).
+   * @returns A sound reward signal plus the certificate and coverage
+   *   breakdown.
+   *
+   * @throws {ApiError} `404` if the sort name is unknown to the lattice.
+   */
+  async score(request) {
+    const response = await this.api.score(RewardScoreRequestFromFrontToApi(request));
+    return RewardScoreResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/translation.ts
+function TranslateRequestFromFrontToApi(model) {
+  const dto = {
+    target_lang: model.targetLang,
+    text: model.text
+  };
+  if (model.sourceLang !== void 0) dto.source_lang = model.sourceLang;
+  return dto;
+}
+function TranslateResponseFromApiToFront(dto) {
+  const out = {
+    targetLang: dto.target_lang,
+    translatedText: dto.translated_text
+  };
+  if (dto.model !== void 0) out.model = dto.model;
+  return out;
+}
+
+// src/resources/translation.ts
+var TranslationClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Translate text into a target language.
+   *
+   * @param request - Source text, target language, and an optional
+   *   source-language hint.
+   * @returns The translated text plus the echoed target language and
+   *   the model label, when known.
+   */
+  async translate(request) {
+    const response = await this.api.translate(TranslateRequestFromFrontToApi(request));
+    return TranslateResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/streaming.ts
+function SketchDimensionsFromFrontToApi(model) {
+  const dto = {};
+  if (model.delta !== void 0) dto.delta = model.delta;
+  if (model.depth !== void 0) dto.depth = model.depth;
+  if (model.epsilon !== void 0) dto.epsilon = model.epsilon;
+  if (model.width !== void 0) dto.width = model.width;
+  return dto;
+}
+function FrequencyEstimateFromApiToFront(dto) {
+  return {
+    estimatedCount: dto.estimated_count,
+    key: dto.key
+  };
+}
+function FrequencyRequestFromFrontToApi(model) {
+  return {
+    dimensions: SketchDimensionsFromFrontToApi(model.dimensions),
+    items: model.items,
+    query_keys: model.queryKeys
+  };
+}
+function FrequencyResponseFromApiToFront(dto) {
+  return {
+    depth: dto.depth,
+    estimates: dto.estimates.map(FrequencyEstimateFromApiToFront),
+    width: dto.width
+  };
+}
+function HeavyHitterItemFromApiToFront(dto) {
+  return {
+    count: dto.count,
+    item: dto.item
+  };
+}
+function HeavyHittersRequestFromFrontToApi(model) {
+  return {
+    capacity: model.capacity,
+    items: model.items
+  };
+}
+function HeavyHittersResponseFromApiToFront(dto) {
+  return {
+    capacity: dto.capacity,
+    heavyHitters: dto.heavy_hitters.map(HeavyHitterItemFromApiToFront),
+    maxUndercount: dto.max_undercount,
+    total: dto.total
+  };
+}
+function BloomFilterStatsFromApiToFront(dto) {
+  return {
+    bitCount: dto.bit_count,
+    estimatedLoad: dto.estimated_load,
+    hashCount: dto.hash_count,
+    insertions: dto.insertions,
+    setBits: dto.set_bits
+  };
+}
+function MembershipRequestFromFrontToApi(model) {
+  return {
+    bit_count: model.bitCount,
+    hash_count: model.hashCount,
+    insert_items: model.insertItems,
+    test_items: model.testItems
+  };
+}
+function MembershipResultFromApiToFront(dto) {
+  return {
+    item: dto.item,
+    member: dto.member
+  };
+}
+function MembershipResponseFromApiToFront(dto) {
+  return {
+    filterStats: BloomFilterStatsFromApiToFront(dto.filter_stats),
+    membership: dto.membership.map(MembershipResultFromApiToFront)
+  };
+}
+
+// src/resources/streaming.ts
+var StreamingClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Estimate the frequency of each query key via a Count-Min sketch.
+   *
+   * @param request - The sketch dimensions, the stream `items`, and the
+   *   `queryKeys` to estimate.
+   * @returns The sketch dimensions actually used and one estimate per
+   *   query key, in request order.
+   *
+   * @throws {ApiError} `400` if `items`/`queryKeys` exceed their limits
+   *   or the sketch dimensions are invalid.
+   */
+  async frequency(request) {
+    const response = await this.api.frequency(FrequencyRequestFromFrontToApi(request));
+    return FrequencyResponseFromApiToFront(response.data);
+  }
+  /**
+   * Find candidate heavy hitters via a Misra-Gries sketch.
+   *
+   * @param request - The counter `capacity` and the stream `items`.
+   * @returns Candidate heavy hitters sorted by count descending, plus
+   *   the worst-case under-count bound.
+   *
+   * @throws {ApiError} `400` if `capacity < 1` or `items` exceeds the limit.
+   */
+  async heavyHitters(request) {
+    const response = await this.api.heavyHitters(HeavyHittersRequestFromFrontToApi(request));
+    return HeavyHittersResponseFromApiToFront(response.data);
+  }
+  /**
+   * Test membership of items in a Bloom filter built from `insertItems`.
+   *
+   * @param request - The `bitCount`, `hashCount`, `insertItems`, and
+   *   `testItems`.
+   * @returns Filter load statistics and one membership verdict per test
+   *   item, in request order. Zero false negatives.
+   *
+   * @throws {ApiError} `400` if `bitCount`/`hashCount < 1` or the item
+   *   arrays exceed their limits.
+   */
+  async membership(request) {
+    const response = await this.api.membership(MembershipRequestFromFrontToApi(request));
+    return MembershipResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/conformal.ts
+function CalibrationSampleFromFrontToApi(model) {
+  return {
+    class_scores: model.classScores,
+    input_id: model.inputId,
+    true_label: model.trueLabel
+  };
+}
+function TestInputFromFrontToApi(model) {
+  return {
+    class_scores: model.classScores,
+    input_id: model.inputId
+  };
+}
+function ConformalCalibrateRequestFromFrontToApi(model) {
+  return {
+    alpha: model.alpha,
+    samples: model.samples.map(CalibrationSampleFromFrontToApi)
+  };
+}
+function ConformalCalibrateResponseFromApiToFront(dto) {
+  return {
+    algorithm: dto.algorithm,
+    alpha: dto.alpha,
+    empiricalCoverage: dto.empirical_coverage,
+    meetsTargetCoverage: dto.meets_target_coverage,
+    nSamples: dto.n_samples,
+    quantileRank: dto.quantile_rank,
+    threshold: dto.threshold
+  };
+}
+function ConformalPredictRequestFromFrontToApi(model) {
+  return {
+    alpha: model.alpha,
+    n_calibration_samples: model.nCalibrationSamples,
+    test_inputs: model.testInputs.map(TestInputFromFrontToApi),
+    threshold: model.threshold
+  };
+}
+function CoverageCertificateFromApiToFront(dto) {
+  return {
+    algorithm: dto.algorithm,
+    alpha: dto.alpha,
+    nCalibrationSamples: dto.n_calibration_samples,
+    nominalCoverage: dto.nominal_coverage,
+    threshold: dto.threshold
+  };
+}
+function ConformalPredictionFromApiToFront(dto) {
+  return {
+    abstains: dto.abstains,
+    inputId: dto.input_id,
+    predictionSet: dto.prediction_set,
+    topClass: dto.top_class,
+    topClassNonConformity: dto.top_class_non_conformity
+  };
+}
+function ConformalPredictResponseFromApiToFront(dto) {
+  return {
+    coverageCertificate: CoverageCertificateFromApiToFront(dto.coverage_certificate),
+    predictions: dto.predictions.map(ConformalPredictionFromApiToFront)
+  };
+}
+
+// src/resources/conformal.ts
+var ConformalClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Compute a split-conformal non-conformity threshold from a labeled
+   * calibration set.
+   *
+   * @param request - The calibration set (samples + target miscoverage
+   *   `α`).
+   * @returns The computed threshold `τ` plus a coverage certificate and
+   *   sanity-check coverage stats.
+   *
+   * @throws {ApiError} `400` if `alpha` is outside `(0, 1)` or the
+   *   calibration set is empty.
+   */
+  async calibrate(request) {
+    const response = await this.api.calibrate(ConformalCalibrateRequestFromFrontToApi(request));
+    return ConformalCalibrateResponseFromApiToFront(response.data);
+  }
+  /**
+   * Apply a pre-computed conformal threshold to unlabeled test inputs
+   * and return prediction sets with coverage certificates.
+   *
+   * @param request - The threshold `τ`, calibration `α` and sample count
+   *   (from a prior `calibrate` call), and the test inputs to predict
+   *   for.
+   * @returns Per-input conformal prediction results plus a coverage
+   *   certificate, in request order.
+   *
+   * @throws {ApiError} `400` if the test-input count exceeds 10 000.
+   */
+  async predict(request) {
+    const response = await this.api.predict(ConformalPredictRequestFromFrontToApi(request));
+    return ConformalPredictResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/vision.ts
+function EncoderConfigOverridesFromFrontToApi(model) {
+  const dto = {};
+  if (model.numFrames !== void 0) dto.num_frames = model.numFrames;
+  if (model.patchSize !== void 0) dto.patch_size = model.patchSize;
+  if (model.sessionId !== void 0) dto.session_id = model.sessionId;
+  if (model.targetHeight !== void 0) dto.target_height = model.targetHeight;
+  if (model.targetWidth !== void 0) dto.target_width = model.targetWidth;
+  return dto;
+}
+function FrameSummaryFromApiToFront(dto) {
+  return {
+    frameIndex: dto.frame_index,
+    numPredictedObjects: dto.num_predicted_objects,
+    numResiduatedFeatures: dto.num_residuated_features,
+    objectLabels: dto.object_labels
+  };
+}
+function EncodeClipRequestFromFrontToApi(model) {
+  const dto = {
+    clip_id: model.clipId,
+    video_b64: model.videoB64
+  };
+  if (model.configOverrides !== void 0) {
+    dto.config_overrides = model.configOverrides === null ? null : EncoderConfigOverridesFromFrontToApi(model.configOverrides);
+  }
+  if (model.fps !== void 0) dto.fps = model.fps;
+  if (model.sourceUri !== void 0) dto.source_uri = model.sourceUri;
+  return dto;
+}
+function EncodeClipResponseFromApiToFront(dto) {
+  const out = {
+    clipId: dto.clip_id,
+    embeddingDim: dto.embedding_dim,
+    encodeElapsedMs: dto.encode_elapsed_ms,
+    frames: dto.frames.map(FrameSummaryFromApiToFront),
+    modelId: dto.model_id,
+    numInputFrames: dto.num_input_frames,
+    paddedFrameIndices: dto.padded_frame_indices,
+    totalObjects: dto.total_objects,
+    totalResiduatedFeatures: dto.total_residuated_features
+  };
+  if (dto.model_version != null) out.modelVersion = dto.model_version;
+  return out;
+}
+
+// src/resources/vision.ts
+var VisionClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Encode a video clip end-to-end and return per-frame predictions.
+   *
+   * @param request - The clip spec (base64 video, clip id, optional
+   *   config overrides / fps / source uri).
+   * @returns The embedding plus per-frame Ψ-term prediction summaries.
+   *
+   * @throws {ApiError} `503` if no V-JEPA perception service is mounted.
+   */
+  async encodeClip(request) {
+    const response = await this.api.encodeClip(EncodeClipRequestFromFrontToApi(request));
+    return EncodeClipResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/anonymization.ts
+function quasiIdentifierFromFrontToApi(q) {
+  switch (q.type) {
+    case "numeric":
+      return { type: "numeric", precision: q.precision };
+    case "string":
+      return { type: "string", prefix_length: q.prefixLength };
+    case "categorical":
+      return { type: "categorical" };
+    case "hierarchical":
+      return { type: "hierarchical", hierarchy: q.hierarchy };
+    case "date":
+      return { type: "date", granularity: q.granularity };
+  }
+}
+function anonymizationModeFromFrontToApi(mode) {
+  if (mode.type === "k_anonymity") {
+    const quasiIdentifiers = {};
+    for (const [field, q] of Object.entries(mode.quasiIdentifiers)) {
+      quasiIdentifiers[field] = quasiIdentifierFromFrontToApi(q);
+    }
+    return { type: "k_anonymity", k: mode.k, quasi_identifiers: quasiIdentifiers };
+  }
+  if (mode.fieldIdentifiers !== void 0) {
+    return {
+      type: "safe_harbor",
+      field_identifiers: mode.fieldIdentifiers
+    };
+  }
+  return { type: "safe_harbor" };
+}
+function AnonymizeRequestFromFrontToApi(model) {
+  const dto = {
+    records: model.records,
+    mode: anonymizationModeFromFrontToApi(model.mode)
+  };
+  if (model.enforcement !== void 0) dto.enforcement = model.enforcement;
+  return dto;
+}
+function kAnonymityViolationFromApiToFront(wire) {
+  return {
+    quasiValues: wire.quasi_values,
+    count: wire.count,
+    requiredK: wire.required_k,
+    suggestion: wire.suggestion
+  };
+}
+function equivalenceClassFromApiToFront(wire) {
+  return {
+    quasiValues: wire.quasi_values,
+    count: wire.count,
+    recordIndices: wire.record_indices
+  };
+}
+function kAnonymityResultFromApiToFront(wire) {
+  return {
+    isKAnonymous: wire.is_k_anonymous,
+    k: wire.k,
+    totalRecords: wire.total_records,
+    equivalenceClassCount: wire.equivalence_class_count,
+    violations: wire.violations.map(kAnonymityViolationFromApiToFront),
+    equivalenceClasses: wire.equivalence_classes.map(equivalenceClassFromApiToFront),
+    minClassSize: wire.min_class_size,
+    maxClassSize: wire.max_class_size,
+    avgClassSize: wire.avg_class_size,
+    checkedAt: wire.checked_at
+  };
+}
+function recordSafeHarborStatusFromApiToFront(dto) {
+  return {
+    recordIndex: dto.record_index,
+    wasCompliant: dto.was_compliant,
+    suppressedFields: dto.suppressed_fields,
+    violationCount: dto.violation_count
+  };
+}
+function safeHarborSummaryFromApiToFront(dto) {
+  return {
+    compliantCount: dto.compliant_count,
+    deIdentifiedCount: dto.de_identified_count,
+    perRecord: dto.per_record.map(recordSafeHarborStatusFromApiToFront)
+  };
+}
+function AnonymizeResponseFromApiToFront(dto) {
+  const out = {
+    outputRecords: dto.output_records,
+    suppressedIndices: dto.suppressed_indices,
+    suppressedCount: dto.suppressed_count
+  };
+  if (dto.k_anonymity_result != null) {
+    out.kAnonymityResult = kAnonymityResultFromApiToFront(
+      dto.k_anonymity_result
+    );
+  }
+  if (dto.safe_harbor_summary != null) {
+    out.safeHarborSummary = safeHarborSummaryFromApiToFront(dto.safe_harbor_summary);
+  }
+  return out;
+}
+
+// src/resources/anonymization.ts
+var AnonymizationClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Batch-anonymize a set of records using k-anonymity or HIPAA Safe Harbor.
+   *
+   * @param request - The record batch, the anonymization mode + params, and
+   *   an optional enforcement strategy (defaults to `suppress`).
+   * @returns The processed records plus a full compliance report
+   *   (k-anonymity analysis or Safe Harbor summary).
+   *
+   * @throws {ApiError} `400` on an empty batch, > 10 000 records, or an
+   *   invalid anonymization mode.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.anonymization.anonymize({
+   *   records: [{ name: 'Alice', age: '42', zip: '12345' }],
+   *   mode: {
+   *     type: 'k_anonymity',
+   *     k: 5,
+   *     quasiIdentifiers: { age: { type: 'numeric', precision: 10 } },
+   *   },
+   * });
+   * console.log(result.kAnonymityResult?.isKAnonymous);
+   * ```
+   */
+  async anonymize(request) {
+    const response = await this.api.anonymizeRecords(AnonymizeRequestFromFrontToApi(request), {
+      headers: { [RAW_BODY_HEADER]: "1" }
+    });
+    return AnonymizeResponseFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/speakers.ts
+function EnrollSpeakerRequestFromFrontToApi(model) {
+  const dto = { audio: model.audio, name: model.name };
+  if (model.audioMime !== void 0) dto.audio_mime = model.audioMime;
+  return dto;
+}
+function EnrollSpeakerResponseFromApiToFront(dto) {
+  return {
+    dim: dto.dim,
+    id: dto.id,
+    name: dto.name,
+    sampleSecs: dto.sample_secs
+  };
+}
+function SpeakerProfileFromApiToFront(dto) {
+  return {
+    createdAt: dto.created_at,
+    id: dto.id,
+    name: dto.name,
+    sampleSecs: dto.sample_secs
+  };
+}
+function ListSpeakersResponseFromApiToFront(dto) {
+  return { speakers: dto.speakers.map(SpeakerProfileFromApiToFront) };
+}
+
+// src/resources/speakers.ts
+var SpeakersClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Enroll (or re-enroll) a speaker voiceprint for the authenticated tenant.
+   *
+   * @remarks
+   * Request body uses plain JSON keys (`audio`, `audio_mime`, `name`) with no
+   * user-keyed maps and no case-sensitive enum values, so the default bridge
+   * snake_casing is correct.
+   *
+   * @param request - The base64 audio sample, optional MIME hint, and name.
+   * @returns The embedding dimensionality, stable profile id, name, and
+   *   seconds of speech embedded.
+   *
+   * @throws {ApiError} On a non-2xx response (e.g. malformed audio).
+   */
+  async enrollSpeaker(request) {
+    const response = await this.api.enrollSpeaker(EnrollSpeakerRequestFromFrontToApi(request));
+    return EnrollSpeakerResponseFromApiToFront(response.data);
+  }
+  /**
+   * List the tenant's enrolled speaker profiles (embeddings withheld).
+   *
+   * @returns The stored speaker profiles for the authenticated tenant.
+   *
+   * @throws {ApiError} On a non-2xx response.
+   */
+  async listSpeakers() {
+    const response = await this.api.listSpeakers();
+    return ListSpeakersResponseFromApiToFront(response.data);
+  }
+  /**
+   * Delete a speaker profile by id.
+   *
+   * @param request - The stable profile (term) id of the speaker to delete.
+   *
+   * @throws {ApiError} `404` if no profile exists for the given id.
+   */
+  async deleteSpeaker(request) {
+    await this.api.deleteSpeaker(request.id);
+  }
+};
+
+// src/normalizers/speech.ts
+function VoiceConsentFromFrontToApi(model) {
+  const dto = {
+    granted_by: model.grantedBy,
+    method: model.method
+  };
+  if (model.reference !== void 0) dto.reference = model.reference;
+  return dto;
+}
+function VoiceConsentFromApiToFront(dto) {
+  const out = {
+    grantedBy: dto.granted_by,
+    method: dto.method
+  };
+  if (dto.reference != null) out.reference = dto.reference;
+  return out;
+}
+function VoiceProfileFromApiToFront(dto) {
+  return {
+    consent: VoiceConsentFromApiToFront(dto.consent),
+    createdAt: dto.created_at,
+    engine: dto.engine,
+    hasIcl: dto.has_icl,
+    id: dto.id,
+    name: dto.name,
+    sampleSecs: dto.sample_secs
+  };
+}
+function SpeechEngineFromApiToFront(dto) {
+  const out = {
+    available: dto.available,
+    engine: dto.engine,
+    presetSpeakers: dto.preset_speakers,
+    supportsCloning: dto.supports_cloning
+  };
+  if (dto.reason != null) out.reason = dto.reason;
+  return out;
+}
+function EnrollVoiceRequestFromFrontToApi(model) {
+  const dto = {
+    audio: model.audio,
+    consent: VoiceConsentFromFrontToApi(model.consent),
+    name: model.name
+  };
+  if (model.audioMime !== void 0) dto.audio_mime = model.audioMime;
+  if (model.engine !== void 0) dto.engine = model.engine;
+  if (model.transcript !== void 0) dto.transcript = model.transcript;
+  return dto;
+}
+function ListEnginesResponseFromApiToFront(dto) {
+  return {
+    engines: dto.engines.map(SpeechEngineFromApiToFront)
+  };
+}
+function ListVoicesResponseFromApiToFront(dto) {
+  return {
+    presets: dto.presets,
+    voices: dto.voices.map(VoiceProfileFromApiToFront)
+  };
+}
+function OpenSpeechSessionRequestFromFrontToApi(model) {
+  const dto = {};
+  if (model.conversationId !== void 0) dto.conversation_id = model.conversationId;
+  if (model.engine !== void 0) dto.engine = model.engine;
+  if (model.language !== void 0) dto.language = model.language;
+  if (model.voiceId !== void 0) dto.voice_id = model.voiceId;
+  return dto;
+}
+function OpenSpeechSessionResponseFromApiToFront(dto) {
+  return {
+    engine: dto.engine,
+    fullDuplex: dto.full_duplex,
+    inputSampleRate: dto.input_sample_rate,
+    sessionId: dto.session_id,
+    wsUrl: dto.ws_url
+  };
+}
+function SynthesizeSpeechRequestFromFrontToApi(model) {
+  const dto = { text: model.text };
+  if (model.refAudioBase64 !== void 0) dto.ref_audio_base64 = model.refAudioBase64;
+  if (model.description !== void 0) dto.description = model.description;
+  if (model.engine !== void 0) dto.engine = model.engine;
+  if (model.format !== void 0) dto.format = model.format;
+  if (model.instruction !== void 0) dto.instruction = model.instruction;
+  if (model.language !== void 0) dto.language = model.language;
+  if (model.maxDurationS !== void 0) dto.max_duration_s = model.maxDurationS;
+  if (model.refText !== void 0) dto.ref_text = model.refText;
+  if (model.seed !== void 0) dto.seed = model.seed;
+  if (model.speaker !== void 0) dto.speaker = model.speaker;
+  if (model.voiceId !== void 0) dto.voice_id = model.voiceId;
+  return dto;
+}
+function TranscribeSpeechRequestFromFrontToApi(model) {
+  const dto = { audio_base64: model.audioBase64 };
+  if (model.audioMime !== void 0) dto.audio_mime = model.audioMime;
+  if (model.format !== void 0) dto.format = model.format;
+  if (model.language !== void 0) dto.language = model.language;
+  return dto;
+}
+function TranscribeSpeechResponseFromApiToFront(dto) {
+  const out = {
+    model: dto.model,
+    text: dto.text
+  };
+  if (dto.duration_secs != null) out.durationSecs = dto.duration_secs;
+  return out;
+}
+
+// src/resources/speech.ts
+var SpeechClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Enroll (or re-enroll) a cloned voice from a reference clip.
+   *
+   * @param request - The enrollment spec (audio, consent, name, etc.).
+   * @returns The registered voice profile.
+   *
+   * @throws {ApiError} `400` if the clip is too short or consent is missing.
+   *
+   * @remarks
+   * Wire format: the request body is a JSON object with snake_case keys
+   * (`audio`, `audio_mime`, `consent`, `engine`, `name`, `transcript`);
+   * the response is a `VoiceProfileDto` with snake_case fields, normalized
+   * to camelCase here.
+   */
+  async enrollVoice(request) {
+    const response = await this.api.enrollVoice(
+      EnrollVoiceRequestFromFrontToApi(request)
+    );
+    return VoiceProfileFromApiToFront(response.data);
+  }
+  /**
+   * Report per-engine availability and capabilities.
+   *
+   * @returns The list of speech engines and their preset speakers.
+   *
+   * @remarks
+   * Wire format: the response is a `ListEnginesResponse` with snake_case
+   * fields, normalized to camelCase here.
+   */
+  async listEngines() {
+    const response = await this.api.listEngines();
+    return ListEnginesResponseFromApiToFront(response.data);
+  }
+  /**
+   * List the tenant's cloned voices plus available presets.
+   *
+   * @returns The enrolled voices and preset speaker names per engine.
+   *
+   * @remarks
+   * Wire format: the response is a `ListVoicesResponse` with snake_case
+   * fields (the `presets` map is returned verbatim), normalized to
+   * camelCase here.
+   */
+  async listVoices() {
+    const response = await this.api.listVoices();
+    return ListVoicesResponseFromApiToFront(response.data);
+  }
+  /**
+   * Open a speech-to-speech session.
+   *
+   * @param request - The session spec (engine, language, voice id, etc.).
+   * @returns The opened session, including the WebSocket media URL.
+   *
+   * @remarks
+   * Wire format: the request body is a JSON object with snake_case keys
+   * (`conversation_id`, `engine`, `language`, `voice_id`); the response is
+   * an `OpenSpeechSessionResponse` with snake_case fields, normalized to
+   * camelCase here.
+   */
+  async openSpeechSession(request) {
+    const response = await this.api.openSpeechSession(
+      OpenSpeechSessionRequestFromFrontToApi(request)
+    );
+    return OpenSpeechSessionResponseFromApiToFront(response.data);
+  }
+  /**
+   * Synthesize speech to raw audio bytes.
+   *
+   * @param request - The synthesis spec (text, engine, voice id, etc.).
+   * @returns The raw fetch `Response`. The body is raw audio bytes
+   *   (`content-type: audio/wav` on success); read it via
+   *   `.arrayBuffer()` or `.blob()`. Check `response.ok` / `response.status`
+   *   before reading the body — a non-2xx response body is a JSON
+   *   `ApiError`, a 2xx response body is audio.
+   *
+   * @throws {ApiError} On a non-2xx response (the error body is JSON, not
+   *   audio — inspect it before consuming the stream).
+   *
+   * @remarks
+   * Wire format: the request body is a JSON object with snake_case keys
+   * (`ref_audio_base64`, `max_duration_s`, `voice_id`, etc.). The response
+   * is NOT JSON — it is a binary audio stream, so this method returns the
+   * raw `Response` unchanged rather than a normalized DTO.
+   */
+  async synthesizeSpeech(request) {
+    const response = await this.api.synthesizeSpeech(
+      SynthesizeSpeechRequestFromFrontToApi(request)
+    );
+    return response;
+  }
+  /**
+   * Transcribe a short utterance.
+   *
+   * @param request - The transcription spec (base64 audio, mime, etc.).
+   * @returns The recognized text plus the model and optional duration.
+   *
+   * @remarks
+   * Wire format: the request body is a JSON object with snake_case keys
+   * (`audio_base64`, `audio_mime`, `format`, `language`); the response is
+   * a `TranscribeSpeechResponse` with snake_case fields, normalized to
+   * camelCase here.
+   */
+  async transcribeSpeech(request) {
+    const response = await this.api.transcribeSpeech(
+      TranscribeSpeechRequestFromFrontToApi(request)
+    );
+    return TranscribeSpeechResponseFromApiToFront(response.data);
+  }
+  /**
+   * Delete a cloned voice, upstream conditioning included.
+   *
+   * @param voiceId - The voice (term) id to delete.
+   *
+   * @remarks
+   * Wire format: no body; the voice id is a path parameter. Returns no
+   * content on success.
+   */
+  async deleteVoice(voiceId) {
+    await this.api.deleteVoice(voiceId);
+  }
+};
+
+// src/normalizers/connectors.ts
+function AddConnectorRequestFromFrontToApi(model) {
+  return {
+    name: model.name,
+    type: model.type
+  };
+}
+function AddConnectorResponseFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    name: dto.name,
+    status: dto.status
+  };
+}
+function ConnectorTypeFromApiToFront(dto) {
+  const out = {
+    authType: dto.auth_type,
+    displayName: dto.display_name,
+    typeName: dto.type_name
+  };
+  if (dto.icon_url !== void 0) out.iconUrl = dto.icon_url;
+  return out;
+}
+function ConnectorInstanceFromApiToFront(dto) {
+  const out = {
+    displayName: dto.display_name,
+    id: dto.id,
+    name: dto.name,
+    status: dto.status,
+    typeName: dto.type_name
+  };
+  if (dto.connected_at !== void 0) out.connectedAt = dto.connected_at;
+  if (dto.connected_by !== void 0) out.connectedBy = dto.connected_by;
+  return out;
+}
+function OAuthStartResponseFromApiToFront(dto) {
+  return {
+    authUrl: dto.auth_url
+  };
+}
+
+// src/resources/connectors.ts
+var ConnectorsClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * List the connector types this build supports.
+   *
+   * @returns Every connector type's wire name, display name, auth type,
+   *   and optional icon URL.
+   */
+  async listTypes() {
+    const response = await this.api.listTypes();
+    return (response.data ?? []).map(ConnectorTypeFromApiToFront);
+  }
+  /**
+   * List all registered connector instances.
+   *
+   * @returns The registered instances, each with its connection status.
+   */
+  async list() {
+    const response = await this.api.list();
+    return (response.data ?? []).map(ConnectorInstanceFromApiToFront);
+  }
+  /**
+   * Register a new connector instance.
+   *
+   * @param request - The instance name and the connector type to register.
+   * @returns The newly-registered instance id, name, and status.
+   */
+  async add(request) {
+    const response = await this.api.add(AddConnectorRequestFromFrontToApi(request));
+    return AddConnectorResponseFromApiToFront(response.data);
+  }
+  /**
+   * Remove a registered connector instance.
+   *
+   * @param name - The instance name.
+   */
+  async remove(name) {
+    await this.api.remove(name);
+  }
+  /**
+   * Start an OAuth flow for a connector instance.
+   *
+   * @param name - The instance name.
+   * @returns The authorization URL the caller should redirect the user to.
+   */
+  async startOauth(name) {
+    const response = await this.api.startOauth(name);
+    return OAuthStartResponseFromApiToFront(response.data);
+  }
+  /**
+   * Disconnect a connector instance (drop its stored credentials).
+   *
+   * @param name - The instance name.
+   */
+  async disconnect(name) {
+    await this.api.disconnect(name);
+  }
+  /**
+   * OAuth callback — the provider redirects here after authorization.
+   *
+   * @param name - The instance name.
+   * @param query - The OAuth callback parameters (`code` on success;
+   *   `error`/`errorDescription` on failure; the opaque `state`).
+   * @returns The raw `Response` — the backend returns an HTML page that
+   *   posts a message to the opener window. The caller usually does not
+   *   need the body; check `response.ok` for transport errors.
+   *
+   * @remarks
+   * This endpoint is normally hit by the browser (the OAuth provider's
+   * redirect target), not called directly by SDK consumers. It is exposed
+   * for completeness / server-side testing.
+   */
+  async oauthCallback(name, query = {}) {
+    const response = await this.api.oauthCallback(name, query);
+    return response;
+  }
+};
+
 // src/client.ts
 var ReasoningLayerClient = class {
   /** Sort (type hierarchy) operations. */
@@ -34482,6 +37081,26 @@ var ReasoningLayerClient = class {
   agui;
   /** Ontology export — OWL ontology and SHACL shapes projected from the sort lattice. */
   ontologyExport;
+  /** Demo substrate seeding — full SUMO + demo scenarios into the tenant substrate. */
+  demo;
+  /** Execution-free reward scoring for candidate queries (recall / precision). */
+  reward;
+  /** Language translation (text → target language, markdown preserved). */
+  translation;
+  /** Probabilistic streaming sketches (Count-Min frequency, Misra-Gries heavy hitters, Bloom membership). */
+  streaming;
+  /** Split-conformal prediction — calibrate a non-conformity threshold, then predict with coverage certificates. */
+  conformal;
+  /** Video-clip encoding (V-JEPA substrate; per-frame predicted-sort labels). */
+  vision;
+  /** GDPR/HIPAA batch anonymization (k-anonymity or Safe Harbor). */
+  anonymization;
+  /** Speaker voiceprint enrollment + listing. */
+  speakers;
+  /** Speech synthesis / transcription / voice cloning + realtime session setup. */
+  speech;
+  /** External data connectors — register / list / remove / connect / disconnect + OAuth callback. */
+  connectors;
   // ─── Group Caches ─────────────────────────────────────────────────
   _core;
   _ai;
@@ -34789,6 +37408,16 @@ var ReasoningLayerClient = class {
     this.guardrail = new GuardrailClient(generatedGuardrail);
     this.agui = new AguiClient(generatedAgui);
     this.ontologyExport = new OntologyExportClient(generatedOntologyExport);
+    this.demo = new DemoClient(new Demo(generatedHttp));
+    this.reward = new RewardClient(new Reward(generatedHttp));
+    this.translation = new TranslationClient(new Translation(generatedHttp));
+    this.streaming = new StreamingClient(new Streaming(generatedHttp));
+    this.conformal = new ConformalClient(new Conformal(generatedHttp));
+    this.vision = new VisionClient(new Vision(generatedHttp));
+    this.anonymization = new AnonymizationClient(new Anonymization(generatedHttp));
+    this.speakers = new SpeakersClient(new Speakers(generatedHttp));
+    this.speech = new SpeechClient(new Speech(generatedHttp));
+    this.connectors = new ConnectorsClient(new Connectors(generatedHttp));
   }
 };
 
@@ -35042,6 +37671,36 @@ var agui_exports = {};
 // src/types/ontology-export.ts
 var ontology_export_exports = {};
 
+// src/types/demo.ts
+var demo_exports = {};
+
+// src/types/reward.ts
+var reward_exports = {};
+
+// src/types/translation.ts
+var translation_exports = {};
+
+// src/types/streaming.ts
+var streaming_exports = {};
+
+// src/types/conformal.ts
+var conformal_exports = {};
+
+// src/types/vision.ts
+var vision_exports = {};
+
+// src/types/anonymization.ts
+var anonymization_exports = {};
+
+// src/types/speakers.ts
+var speakers_exports = {};
+
+// src/types/speech.ts
+var speech_exports = {};
+
+// src/types/connectors.ts
+var connectors_exports = {};
+
 // src/builders/value.ts
 var Value = {
   /**
@@ -36053,6 +38712,7 @@ exports.Actions = actions_exports;
 exports.Admin = admin_exports;
 exports.Agui = agui_exports;
 exports.Analysis = analysis_exports;
+exports.Anonymization = anonymization_exports;
 exports.ApiError = ApiError;
 exports.AuthenticationError = AuthenticationError;
 exports.Authz = authz_exports;
@@ -36066,7 +38726,9 @@ exports.Collections = collections_exports;
 exports.Communities = communities_exports;
 exports.Compliance = compliance_exports;
 exports.ComplianceMarkings = compliance_markings_exports;
+exports.Conformal = conformal_exports;
 exports.Conformance = conformance_exports;
+exports.Connectors = connectors_exports;
 exports.Constraint = Constraint;
 exports.ConstraintViolationError = ConstraintViolationError;
 exports.Constraints = constraints_exports;
@@ -36074,6 +38736,7 @@ exports.Control = control_exports;
 exports.Conversation = conversation_exports;
 exports.Corpus = corpus_exports;
 exports.DL = dl_exports;
+exports.Demo = demo_exports;
 exports.Discovery = discovery_exports;
 exports.DocumentCheck = document_check_exports;
 exports.Documents = documents_exports;
@@ -36127,6 +38790,7 @@ exports.ReasoningLayerClient = ReasoningLayerClient;
 exports.ReasoningLayerError = ReasoningLayerError;
 exports.Research = research_exports;
 exports.Reviews = reviews_exports;
+exports.Reward = reward_exports;
 exports.Row = row_exports;
 exports.SDK_VERSION = SDK_VERSION;
 exports.Sat = sat_exports;
@@ -36139,17 +38803,22 @@ exports.Sorts = sorts_exports;
 exports.Sources = sources_exports;
 exports.Spaces = spaces_exports;
 exports.Sparql = sparql_exports;
+exports.Speakers = speakers_exports;
+exports.Speech = speech_exports;
 exports.Statistical = statistical_exports;
+exports.Streaming = streaming_exports;
 exports.Synthetic = synthetic_exports;
 exports.Temporal = temporal_exports;
 exports.Terms = terms_exports;
 exports.TimeoutError = TimeoutError;
+exports.Translation = translation_exports;
 exports.UI = ui_exports;
 exports.Utilities = utilities_exports;
 exports.ValidationError = ValidationError;
 exports.Value = Value;
 exports.Values = values_exports;
 exports.Verification = verification_exports;
+exports.Vision = vision_exports;
 exports.Visualization = visualization_exports;
 exports.WebSocketClient = WebSocketClient;
 exports.WebSocketConnection = WebSocketConnection;