@kortexya/reasoninglayer 1.16.0 → 1.17.0

package/README.md

@@ -263,4 +263,4 @@ pnpm run docs:build             # Build documentation site
 
 ## License
 
-MIT
+Proprietary — © Kortexya. All rights reserved. Not for redistribution.

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.16.0";
+var SDK_VERSION = "1.17.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -587,6 +587,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "per_strategy_taxonomies",
   "propsOverride",
   "props_override",
+  "referencedTerms",
+  "referenced_terms",
   "roleMinimums",
   "role_minimums",
   "scope",
@@ -594,6 +596,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "scores_by_name",
   "sortNames",
   "sort_names",
+  "toolResults",
+  "tool_results",
   "topK",
   "top_k",
   "values"
@@ -996,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): ≾̇ = ((≾̃ .− ∼) ⊍ ≤)⁺
    *
@@ -1013,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
   });
@@ -1042,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
    *
@@ -1148,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.
    *
@@ -1623,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
    */
@@ -3043,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.
    *
@@ -3095,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
    *
@@ -3161,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
@@ -5864,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.
    *
@@ -6655,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
@@ -6671,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
@@ -8700,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
@@ -9040,6 +9172,24 @@ 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).
    *
@@ -9376,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
    *
@@ -9409,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
    *
@@ -9890,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.
    *
@@ -9959,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
@@ -10258,6 +10494,24 @@ var Speakers = class {
     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
    *
@@ -10524,6 +10778,22 @@ var Documents = class {
   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
    *
@@ -19742,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();
-        };
       }
     });
   }
@@ -28750,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) {
@@ -28784,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 ?? []
   };
@@ -28796,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,
@@ -28840,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) {
@@ -28851,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,
@@ -28861,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) {
@@ -28889,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,
@@ -28896,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) {
@@ -28917,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) {