@kortexya/reasoninglayer 1.16.0 → 1.17.0

package/dist/index.d.ts

@@ -109,7 +109,7 @@ type JsonValue$1 = string | number | boolean | null | JsonValue$1[] | object;
  * This is the single source of truth for the version constant.
  * The `scripts/release.sh` script updates this value alongside `package.json`.
  */
-declare const SDK_VERSION = "1.16.0";
+declare const SDK_VERSION = "1.17.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -1964,6 +1964,22 @@ interface AuditRecord$1 {
 }
 /** @format uuid */
 type AuditRecordId = string;
+/**
+ * Sortable [`AuditRecord`] field for the paged list read API
+ * ([`crate::ports::audit::AuditPort::list_page`]).
+ *
+ * Wire serialisation is `snake_case` (`timestamp`, `request_path`,
+ * `actor`) via `serde(rename_all)`. Defaults to [`AuditSortField::Timestamp`].
+ */
+type AuditSortField$1 = "timestamp" | "request_path" | "actor";
+/**
+ * Sort direction for the paged list read API
+ * ([`crate::ports::audit::AuditPort::list_page`]).
+ *
+ * Wire serialisation is `lowercase` (`asc`, `desc`). Defaults to
+ * [`AuditSortOrder::Desc`] so the most recent entries surface first.
+ */
+type AuditSortOrder$1 = "desc" | "asc";
 /** One audited assumption */
 interface AuditedAssumptionDto$1 {
     /** The assumption kind audited */
@@ -3244,6 +3260,23 @@ interface CancelDocumentResponse {
     /** Human-readable message describing what happened */
     message: string;
 }
+/**
+ * A candidate entity — a Ψ-term-to-be, its sort named rather than resolved because the
+ * sort may not exist yet (which residuates).
+ */
+interface CandidateEntityDto {
+    /**
+     * Extractor confidence in [0, 1]. Advisory — it does not affect the verdict.
+     * @format double
+     */
+    confidence?: number;
+    /** Extracted features, by name. */
+    features?: Record<string, CandidateValueDto>;
+    /** Batch-local id, used to attach relations to this entity. */
+    local_id: string;
+    /** Sort name this entity claims. */
+    sort: string;
+}
 /** A candidate match for entity deduplication */
 interface CandidateMatchDto$1 {
     /**
@@ -3257,6 +3290,40 @@ interface CandidateMatchDto$1 {
      */
     term_id: string;
 }
+/**
+ * A candidate relation — a feature edge whose endpoint sorts the caller supplies so the
+ * fact is self-contained for certification.
+ */
+interface CandidateRelationDto {
+    /**
+     * Extractor confidence in [0, 1]. Advisory.
+     * @format double
+     */
+    confidence?: number;
+    /** Predicate (feature) name. */
+    predicate: string;
+    /** `local_id` of the source entity. */
+    source: string;
+    /** Sort name of the source endpoint. */
+    source_sort: string;
+    /** `local_id` of the target entity. */
+    target: string;
+    /** Sort name of the target endpoint. */
+    target_sort: string;
+}
+/**
+ * A candidate feature value. `value` absent ⇒ the extractor does not know it, which
+ * residuates rather than refutes.
+ */
+interface CandidateValueDto {
+    /** Surface form of the value, as extracted. Omit for an unknown value. */
+    value?: string | null;
+    /**
+     * Primitive type the extractor believes this value has: `String`, `Integer`,
+     * `Real`, `Boolean`, or `DateTime`. Defaults to `String`.
+     */
+    value_type?: string | null;
+}
 interface CaptureSnapshotRequest$1 {
     /** @format date-time */
     captured_after?: string | null;
@@ -4096,8 +4163,27 @@ interface ClearFactsResponse$1 {
  * the operation succeeded without affecting other tenants.
  */
 interface ClearTenantResponse$1 {
+    /**
+     * Number of SQL ontology bindings deleted for this tenant.
+     *
+     * A binding names the source, table and columns a tenant's data lives in,
+     * so it is tenant data in its own right. It used to survive the wipe,
+     * which is how #124 became visible: the connectors page kept listing
+     * bindings whose sources had just been erased.
+     * @min 0
+     */
+    bindings_deleted?: number;
     /** Whether the cache was invalidated */
     cache_invalidated: boolean;
+    /**
+     * Number of materialized derived facts deleted for this tenant.
+     *
+     * The derived-facts repository has always been able to truncate a tenant;
+     * only the separate admin endpoint ever asked it to, so derived Ψ-terms
+     * outlived the facts they were derived from (#124).
+     * @min 0
+     */
+    derived_facts_deleted?: number;
     /**
      * Number of document fingerprints deleted
      * @min 0
@@ -4122,6 +4208,14 @@ interface ClearTenantResponse$1 {
      * @min 0
      */
     reviews_deleted: number;
+    /**
+     * Total rows deleted across every table in `tables_wiped`.
+     *
+     * Counts the tables that have no named counter above, which is most of
+     * them — the named counters predate #124 and were never the full set.
+     * @min 0
+     */
+    rows_deleted_total?: number;
     /**
      * Number of ingestion sessions deleted
      * @min 0
@@ -4129,6 +4223,20 @@ interface ClearTenantResponse$1 {
     sessions_deleted: number;
     /** Whether the sort hierarchy snapshot was deleted */
     sorts_deleted: boolean;
+    /**
+     * Tenant-scoped tables deliberately left intact, each with its reason.
+     *
+     * Non-empty means this erasure was deliberately partial. Reported so a
+     * retention policy can never again be mistaken for complete erasure.
+     */
+    tables_retained?: RetainedTableDto[];
+    /**
+     * Every table the wipe deleted from, children before parents.
+     *
+     * Derived from the live schema, not from a list in the source, so a table
+     * added by a later migration appears here without a code change.
+     */
+    tables_wiped?: string[];
     /** The tenant whose data was cleared */
     tenant_id: string;
     /**
@@ -4136,6 +4244,16 @@ interface ClearTenantResponse$1 {
      * @min 0
      */
     terms_deleted: number;
+    /**
+     * Number of vector-store points deleted for this tenant.
+     *
+     * Reported to the caller because it is the one count an erasure request
+     * cannot verify any other way: vector payloads carry the embedded text, so
+     * a wipe that left them behind would report every table emptied while the
+     * tenant's data stayed readable and retrievable by similarity.
+     * @min 0
+     */
+    vectors_deleted: number;
 }
 /** Response for clearing all terms for a tenant */
 interface ClearTermsResponse$1 {
@@ -4638,7 +4756,15 @@ interface CompareDocumentsRequestDto {
     document_a_id: string;
     /** @format uuid */
     document_b_id: string;
+    /**
+     * Include the clause section — terms sorted under the tenant's
+     * `document.clause` vocabulary (default true)
+     */
     include_clause_diff?: boolean;
+    /**
+     * Include the entity section — everything outside the tenant's
+     * `document.clause` vocabulary (default true)
+     */
     include_entity_diff?: boolean;
     /** @format double */
     threshold?: number | null;
@@ -5706,6 +5832,18 @@ interface CreateCurriedFunctionRequest$1 {
     /** @format uuid */
     tenant_id: string;
 }
+/** Request body for filing a data subject request. */
+interface CreateDsrRequest {
+    /** Identifier of the data subject filing the request. */
+    data_subject: string;
+    /**
+     * Which right is being exercised (Art. 15-22), as the domain's tagged enum.
+     *
+     * Described to OpenAPI as an opaque object: deriving a schema would force a
+     * utoipa dependency into the domain, which must stay free of them.
+     */
+    request_type: object;
+}
 /** Request to create a new execution session with trail-based backtracking */
 interface CreateExecutionSessionRequest$1 {
     /** Optional name for the session */
@@ -7074,6 +7212,11 @@ interface DisentailmentRequest$1 {
 }
 /** Response from disentailment check. */
 interface DisentailmentResponse$1 {
+    /**
+     * How strongly the supplied facts establish the antecedent, μ ∈ [0,1].
+     * @format double
+     */
+    antecedent_degree: number;
     /**
      * Computation time in milliseconds
      * @format int64
@@ -7081,10 +7224,31 @@ interface DisentailmentResponse$1 {
      */
     computation_time_ms: number;
     /**
-     * Confidence degree
+     * Confidence degree.
+     *
+     * Certainty in the result, which is governed by how strongly the facts
+     * establish the antecedent: with no support the verdict is vacuous. Equal
+     * to `antecedent_degree`, and graded where it was previously a `1.0`/`0.0`
+     * cast of "the antecedent was found".
      * @format double
      */
     confidence: number;
+    /**
+     * How strongly the consequent is established, μ ∈ [0,1] — by the facts, or
+     * by the antecedent it would follow from.
+     * @format double
+     */
+    consequent_degree: number;
+    /**
+     * Graded degree to which the disentailment still holds, μ ∈ [0,1].
+     *
+     * `1 - violation_degree`, where the violation degree is
+     * `min(antecedent_degree, consequent_degree)` — the degree to which the
+     * antecedent forces the consequent it was supposed to exclude. `holds` is
+     * this degree read crisply.
+     * @format double
+     */
+    degree: number;
     /** Whether the disentailment holds (antecedent is false, or consequent is false) */
     holds: boolean;
     /** Whether the disentailment is violated (both antecedent AND consequent hold = conflict) */
@@ -7366,6 +7530,26 @@ interface DocumentDto {
      */
     version: number;
 }
+/**
+ * What a document erasure actually removed.
+ *
+ * Counts are reported rather than a bare 204 because erasure is auditable: a
+ * caller has to be able to show *what* went, and a silent success is
+ * indistinguishable from a cascade that walked nothing.
+ */
+interface DocumentErasureReport {
+    /** Whether the document registry row was removed. */
+    document_deleted: boolean;
+    /** The document that was erased. */
+    document_id: string;
+    /** Whether the fingerprint row (which held the term provenance) was removed. */
+    fingerprint_deleted: boolean;
+    /**
+     * Terms removed via the full per-term cascade.
+     * @min 0
+     */
+    terms_deleted: number;
+}
 /** Per-document knowledge graph response. */
 interface DocumentGraphResponse {
     /** Community id → size (legend data) */
@@ -7892,6 +8076,28 @@ interface DriveDto$1 {
     /** Drive type (curiosity, competence, social, autonomy) */
     drive_type: string;
 }
+/** A request record as returned to callers. */
+interface DsrRecordResponse {
+    /** The data subject this request belongs to. */
+    data_subject: string;
+    /** Statutory deadline (UTC). */
+    deadline: string;
+    /** Request id, stable from submission through closure. */
+    id: string;
+    /**
+     * Whether the stored record still matches its own integrity hash.
+     *
+     * Surfaced rather than merely checked so a caller can tell an intact
+     * record from a tampered one instead of trusting the response.
+     */
+    integrity_verified: boolean;
+    /** Whether the deadline has already passed without closure. */
+    overdue: boolean;
+    /** When the request was received (UTC). */
+    received_at: string;
+    /** Current lifecycle status, serialized from the domain enum. */
+    status: any;
+}
 /** Loss weighting (paper eq. 4) — `data_weight + knowledge_weight = 1.0`. */
 interface DualWeightedLossDto {
     /**
@@ -8433,10 +8639,20 @@ interface EnrollSpeakerRequest$1 {
     /** MIME hint (e.g. `"audio/wav"`) for decoding the sample. */
     audio_mime?: string | null;
     /**
-     * Display name for this speaker. Re-enrolling the same name (case-insensitive)
-     * overwrites the existing profile.
+     * Display name for this speaker. Re-enrolling the same (name, variant)
+     * pair — case-insensitive — overwrites the existing profile.
      */
     name: string;
+    /**
+     * Optional sample label, so one person can hold SEVERAL embeddings
+     * ("15-s read-aloud", "meeting 07-30", "sung sample"). This is the
+     * singing fix: a voice is not one point in embedding space, and TitaNet
+     * is speech-trained, so a sung sample is what makes that artist's other
+     * songs match. Matching needs no changes for this — supplying several
+     * prints that share a name already resolves each cluster to the best
+     * cosine overall.
+     */
+    variant?: string | null;
 }
 /** Response from enrolling a speaker voiceprint. */
 interface EnrollSpeakerResponse$1 {
@@ -8457,6 +8673,8 @@ interface EnrollSpeakerResponse$1 {
      * @format double
      */
     sample_secs: number;
+    /** Sample label, when one was supplied. */
+    variant?: string | null;
 }
 /** Request to enroll (or re-enroll) a cloned voice. */
 interface EnrollVoiceRequest$1 {
@@ -8494,6 +8712,14 @@ interface EntailmentRequest$1 {
 }
 /** Response from entailment check. */
 interface EntailmentResponse$1 {
+    /**
+     * How strongly the supplied facts establish the antecedent, μ ∈ [0,1].
+     *
+     * `max { μ⊒(antecedent, f) : f ∈ facts }` — a fact witnesses the antecedent
+     * when the antecedent subsumes it, so a `sparrow` fact supports `animal`.
+     * @format double
+     */
+    antecedent_degree: number;
     /**
      * Computation time in milliseconds
      * @format int64
@@ -8501,10 +8727,31 @@ interface EntailmentResponse$1 {
      */
     computation_time_ms: number;
     /**
-     * Confidence degree
+     * Confidence degree.
+     *
+     * Equal to `degree`. Retained for callers written against the previous
+     * shape, where it was a `1.0`/`0.0` cast of `entails`.
      * @format double
      */
     confidence: number;
+    /**
+     * How strongly the consequent is established, μ ∈ [0,1].
+     *
+     * The better of the two routes: witnessed by the facts, or subsuming the
+     * antecedent it would follow from.
+     * @format double
+     */
+    consequent_degree: number;
+    /**
+     * Graded entailment degree μ ∈ [0,1] — `min(antecedent_degree, consequent_degree)`.
+     *
+     * `entails` is this degree read crisply. A value strictly between 0 and 1
+     * means the two are related only through a fuzzy sort relation (an explicit
+     * `⊑·` degree or an approved sort similarity), not through the crisp
+     * hierarchy.
+     * @format double
+     */
+    degree: number;
     /** Whether antecedent entails consequent */
     entails: boolean;
 }
@@ -8995,6 +9242,39 @@ type EvidenceSourceDto$1 = {
     /** @format double */
     unified_degree: number;
 };
+/**
+ * Request to transpile an OSFQL query and run it on the bound source (#133).
+ *
+ * No dialect field: the binding names the source and the source's type
+ * decides the dialect. Asking a caller to supply it would let them ask for
+ * Cypher against Postgres, which is not a question with an answer.
+ */
+interface ExecuteTranspiledRequest {
+    /** OSFQL query to transpile and execute. */
+    osfql: string;
+}
+/** Rows from a live source, with the query that fetched them. */
+interface ExecuteTranspiledResponse {
+    /** Dialect of `query` — `postgres`, `mysql`, `sqlite`, `cypher` or `cql`. */
+    dialect: string;
+    /**
+     * The query that was executed, in the source's own language.
+     *
+     * Returned with the rows rather than behind a separate call: transpile
+     * mode's claim is that OSFQL becomes a native query against the
+     * operator's database, and this is what makes that claim checkable.
+     */
+    query: string;
+    /**
+     * Number of rows returned.
+     * @min 0
+     */
+    row_count: number;
+    /** Rows as returned by the source, one object per record. */
+    rows: any[];
+    /** The source the query ran against. */
+    source_id: string;
+}
 /**
  * ExecutionGoalDto
  * Execution engine goal, discriminated by the 'type' field. Variants: unify, prove, eval, type_disj, cut, if_then_else.
@@ -9333,6 +9613,44 @@ interface ExtractedEntityDto$1 {
     /** The text span that was recognized in the input */
     text: string;
 }
+/** Request body for `POST /api/v1/extraction/certify`. */
+interface ExtractionCertifyRequest {
+    /**
+     * Conformal coverage floor. Defaults to 0.95; only affects conformal (non-sound)
+     * emissions.
+     * @format double
+     */
+    conformal_floor?: number | null;
+    /** Candidate entities, certified in submission order. */
+    entities?: CandidateEntityDto[];
+    /** Candidate relations, certified after the entities. */
+    relations?: CandidateRelationDto[];
+}
+/** Response for `POST /api/v1/extraction/certify`. */
+interface ExtractionCertifyResponse {
+    /**
+     * Candidates the gate withheld.
+     * @min 0
+     */
+    abstained: number;
+    /**
+     * Candidates the gate admitted.
+     * @min 0
+     */
+    emitted: number;
+    /** Per-candidate dispositions, in submission order (entities then relations). */
+    facts: FactOutcomeDto[];
+    /**
+     * Candidates whose certification suspended pending more information.
+     * @min 0
+     */
+    suspended: number;
+    /**
+     * Number of candidates submitted.
+     * @min 0
+     */
+    total: number;
+}
 /** A single extraction prediction. */
 interface ExtractionPredictionDto$1 {
     /**
@@ -9462,6 +9780,39 @@ interface FactConfidenceEntry$1 {
      */
     term_id: string;
 }
+/** The gate's disposition for one candidate fact. */
+interface FactOutcomeDto {
+    /**
+     * Content-addressed id of the persisted certificate, for every disposition —
+     * refusals included, so a withheld verdict stays addressable in the audit trail.
+     */
+    certificate?: string | null;
+    /**
+     * Verdict confidence (`1.0` for a sound proof). Only meaningful for `emitted`.
+     * @format double
+     */
+    confidence?: number | null;
+    /** `emitted`, `suspended`, or `abstained`. */
+    disposition: string;
+    /**
+     * Stable diagnostic label: `entity:<Sort>:<local_id>` or
+     * `relation:<predicate>:<source>→<target>`.
+     */
+    label: string;
+    /**
+     * `true` when the verdict was a sound proof rather than a conformal emission.
+     * Only meaningful for `emitted`.
+     */
+    proven?: boolean | null;
+    /** For `abstained`: why the candidate was withheld. */
+    reason?: string | null;
+    /** Lattice-derived repair suggestions, aligned with `violations`. */
+    repair_hints?: RepairHintDto[];
+    /** Declared obligations this candidate broke. Non-empty only for a refutation. */
+    violations?: ViolationDto$1[];
+    /** For `suspended`: the facts whose arrival should resume certification. */
+    wake_triggers?: string[];
+}
 /**
  * Response for the factory-reset operation.
  *
@@ -9469,10 +9820,23 @@ interface FactConfidenceEntry$1 {
  * so operators can verify the operation succeeded.
  */
 interface FactoryResetResponse$1 {
+    /**
+     * Number of SQL ontology bindings dropped across all tenants
+     * @min 0
+     */
+    bindings_deleted?: number;
     /** Whether the cache (Valkey / in-memory) was flushed */
     cache_cleared: boolean;
     /** Human-readable summary message */
     message: string;
+    /**
+     * The tables that were truncated.
+     *
+     * Discovered from the live schema rather than hard-coded, so this is the
+     * only way for a caller to tell a complete reset from one whose discovery
+     * came back short (#124).
+     */
+    postgres_tables?: string[];
     /**
      * Number of PostgreSQL tables that were truncated
      * @min 0
@@ -11285,6 +11649,41 @@ interface GetFactsResponse$1 {
     /** List of facts */
     facts: PsiTermDto$1[];
 }
+/** Request to read the fuzzy subsumption degree `sub ⊑· sup` */
+interface GetFuzzySubsumptionRequest {
+    /**
+     * The subsumed (more specific) sort
+     * @format uuid
+     */
+    sub_sort_id: string;
+    /**
+     * The subsuming (more general) sort
+     * @format uuid
+     */
+    sup_sort_id: string;
+}
+/** Response for a fuzzy subsumption query */
+interface GetFuzzySubsumptionResponse {
+    /**
+     * Subsumption degree ⊑·(sub, sup) ∈ [0,1]
+     *
+     * Falls back through the explicit relation, then approved similarity,
+     * then the crisp hierarchy — so `1.0` may mean a crisp subtype edge
+     * rather than an explicitly asserted degree.
+     * @format double
+     */
+    degree: number;
+    /**
+     * The subsumed sort
+     * @format uuid
+     */
+    sub_sort_id: string;
+    /**
+     * The subsuming sort
+     * @format uuid
+     */
+    sup_sort_id: string;
+}
 /** Request to get HTN methods. */
 interface GetHtnMethodsRequest {
     /**
@@ -12409,6 +12808,46 @@ interface IdentifyEffectResponse$1 {
     /** Treatment variable */
     treatment: string;
 }
+/**
+ * Optional overrides for identification. Every field defaults to the MEDIA
+ * setting, which is stricter than the meeting path's.
+ */
+interface IdentifyOptionsDto {
+    /**
+     * Minimum cosine to accept a match (default 0.6, vs 0.5 for meetings).
+     * @format float
+     */
+    match_threshold?: number | null;
+    /**
+     * Minimum seconds of speech for a cluster to be reported (default 5).
+     * @format double
+     */
+    min_speech_secs?: number | null;
+    /**
+     * Run vocal separation first (default `true`) — what lets a voice under
+     * music be matched at all.
+     */
+    separate?: boolean | null;
+}
+/** Request to identify which enrolled voices speak in a piece of audio. */
+interface IdentifySpeakersRequest {
+    /** Base64-encoded audio to analyze (any container the transcriber decodes). */
+    audio: string;
+    /** MIME hint (e.g. `"audio/webm"`). */
+    audio_mime?: string | null;
+    /** Tuning knobs; omitted means the media defaults. */
+    options?: null | IdentifyOptionsDto;
+}
+/** Response from identifying voices in audio. */
+interface IdentifySpeakersResponse {
+    detections: SpeakerDetectionDto[];
+    /** @format double */
+    duration_secs: number;
+    /** Whether vocal separation actually ran. */
+    separated: boolean;
+    unknown_clusters: UnknownClusterDto[];
+    warnings: string[];
+}
 /** An entity extracted from a visual element in the image. */
 interface ImageExtractedEntityDto$1 {
     /**
@@ -14782,6 +15221,12 @@ interface ListSourcesResponse$1 {
 }
 /** Response listing a tenant's speaker profiles. */
 interface ListSpeakersResponse$1 {
+    /**
+     * The same profiles grouped by person, since one name may now hold
+     * several samples and the UI lists people, not embeddings.
+     */
+    people?: SpeakerPersonDto[];
+    /** Every stored profile, one entry per sample. */
     speakers: SpeakerProfileDto[];
 }
 /** Request to list module symbols */
@@ -17455,7 +17900,15 @@ interface OsfDiffRequestDto {
     a: object;
     /** Selector for side B */
     b: object;
+    /**
+     * Include the clause section — terms sorted under the tenant's
+     * `document.clause` vocabulary (default true)
+     */
     include_clause_diff?: boolean;
+    /**
+     * Include the entity section — everything outside the tenant's
+     * `document.clause` vocabulary (default true)
+     */
     include_entity_diff?: boolean;
     /**
      * Minimum match degree (default 0.7)
@@ -17660,6 +18113,16 @@ interface OsfqlRequest$1 {
      * clients are byte-identical.
      */
     reactive?: boolean;
+    /**
+     * Which data model the program is answered under.
+     *
+     * **Set this to `rdf` when running a statement returned by
+     * `POST /api/v1/sparql/translate`** — that is the whole point of the switch. It is a
+     * single flag rather than several because the settings it carries are not
+     * independently useful here: getting one right and another wrong yields answers that
+     * are silently wrong rather than obviously broken.
+     */
+    semantics?: OsfqlSemantics;
 }
 /** Response from executing an OSFQL program. */
 interface OsfqlResponse$1 {
@@ -17690,6 +18153,8 @@ interface OsfqlResponse$1 {
      */
     updated_term_ids?: string[];
 }
+/** The data model an OSFQL program is answered under — see [`OsfqlRequest::semantics`]. */
+type OsfqlSemantics = "osf" | "rdf";
 /** A bound value in an OSFQL result. */
 type OsfqlValueDto = {
     type: "null";
@@ -17715,6 +18180,13 @@ type OsfqlValueDto = {
     type: "boolean";
     /** Boolean value. */
     value: boolean;
+} | {
+    type: "datetime";
+    /**
+     * UTC datetime instant, rendered in its RFC 3339 `Z`-suffixed form — the value
+     * of a `date`/`timestamp` feature binding (or a MIN/MAX aggregate over one).
+     */
+    value: string;
 } | {
     type: "list";
     /** Ordered list value. */
@@ -19687,6 +20159,15 @@ interface ReleaseResiduationsResponse$1 {
     /** @min 0 */
     remaining_suspended: number;
 }
+/** A lattice-derived suggestion for discharging one violated obligation. */
+interface RepairHintDto {
+    /** Why that replacement discharges it. */
+    rationale: string;
+    /** The concrete replacement that would discharge the obligation. */
+    suggestion: string;
+    /** The feature or predicate the hint applies to. */
+    target: string;
+}
 /** Request to reprocess failed documents */
 interface ReprocessFailedRequest {
     /**
@@ -20036,6 +20517,13 @@ interface ResumptionOptionDto$1 {
     /** Unique identifier for this option */
     id: string;
 }
+/** One table a tenant erasure deliberately left standing, and why. */
+interface RetainedTableDto {
+    /** Why this table survives a tenant erasure */
+    reason: string;
+    /** Table name in the `public` schema */
+    table: string;
+}
 /** Request to retract a rule */
 interface RetractRuleRequest$1 {
     /** If provided, retract rules matching this pattern */
@@ -21602,6 +22090,37 @@ interface SetFeatureResponse$1 {
     success: boolean;
     term_id: string;
 }
+/**
+ * Request to set the fuzzy subsumption degree `sub ⊑· sup`
+ *
+ * The field names are `sub`/`sup` rather than `sort1`/`sort2` because the
+ * relation is **directional**: swapping them asserts something else. The
+ * symmetric relation is `/api/v1/sorts/similarity`.
+ */
+interface SetFuzzySubsumptionRequest {
+    /**
+     * Subsumption degree ∈ [0,1]
+     * @format double
+     */
+    degree: number;
+    /**
+     * The subsumed (more specific) sort
+     * @format uuid
+     */
+    sub_sort_id: string;
+    /**
+     * The subsuming (more general) sort
+     * @format uuid
+     */
+    sup_sort_id: string;
+}
+/** Response for setting a fuzzy subsumption degree */
+interface SetFuzzySubsumptionResponse {
+    /** Message */
+    message: string;
+    /** Whether the operation succeeded */
+    success: boolean;
+}
 /**
  * Request to transition a goal to a terminal status.
  *
@@ -21945,17 +22464,43 @@ interface SoftUnifyRequest$1 {
 }
 /** Response for soft unification. */
 interface SoftUnifyResponse$1 {
-    /** @format double */
+    /**
+     * Combined confidence μ ∈ [0,1] — the product of `sort_score` and
+     * `feature_score`, per the domain's soft-unification quantale.
+     * @format double
+     */
     confidence: number;
     /**
+     * Wall-clock time for the computation.
      * @format int64
      * @min 0
      */
     elapsed_ms: number;
-    /** @format double */
+    /**
+     * Whether a box-embedding adapter contributed to `sort_score`.
+     *
+     * `false` means the sort axis was scored from the hierarchy alone
+     * (subsumption and fuzzy subsumption). The scores are measured either way —
+     * this reports which evidence was available, so a caller can tell a
+     * hierarchy-only answer from an embedding-backed one.
+     */
+    embeddings_used: boolean;
+    /**
+     * Feature compatibility μ ∈ [0,1], averaged over the union of both terms'
+     * features. A feature only one side carries scores 0.5 (open world), not 0.
+     * @format double
+     */
     feature_score: number;
+    /**
+     * What hard OSF unification says about the same pair. Independent of the
+     * scores above: terms can be highly similar and still fail to unify.
+     */
     hard_compatible: boolean;
-    /** @format double */
+    /**
+     * Sort compatibility μ ∈ [0,1]: exact match or subsumption → 1.0, then box
+     * containment, then fuzzy subsumption.
+     * @format double
+     */
     sort_score: number;
 }
 /** A solution from backward chaining or open-world inference. */
@@ -23006,6 +23551,23 @@ type SpaceStatusDto$1 = {
     count: number;
     type: "alternatives";
 };
+/** A recognized voice. */
+interface SpeakerDetectionDto {
+    name: string;
+    /**
+     * Cosine similarity of the accepted match.
+     * @format float
+     */
+    score: number;
+    spans: SpeechSpanDto[];
+    /** @format double */
+    speech_secs: number;
+}
+/** One person and all the samples enrolled for them. */
+interface SpeakerPersonDto {
+    name: string;
+    profiles: SpeakerProfileDto[];
+}
 /** A stored speaker profile (embedding withheld). */
 interface SpeakerProfileDto {
     /** ISO-8601 timestamp of enrollment. */
@@ -23022,6 +23584,8 @@ interface SpeakerProfileDto {
      * @format double
      */
     sample_secs: number;
+    /** Sample label, when one was supplied at enrollment. */
+    variant?: string | null;
 }
 /** Volume-specificity verification sub-DTO. */
 interface SpecificityDto$1 {
@@ -23062,6 +23626,13 @@ interface SpeechEngineDto {
     /** Whether it can clone from a reference clip. */
     supports_cloning: boolean;
 }
+/** One speaking interval, in seconds from the start of the audio. */
+interface SpeechSpanDto {
+    /** @format double */
+    end: number;
+    /** @format double */
+    start: number;
+}
 /**
  * Request to start a new attribute exploration session.
  *
@@ -23359,6 +23930,35 @@ interface StructuredIngestionStatsDto$1 {
      */
     terms_projected: number;
 }
+/** What a subject erasure matched, and what it removed. */
+interface SubjectErasureReport {
+    /** Whether this call executed, or only planned. */
+    confirmed: boolean;
+    /** The data subject named by the request being fulfilled. */
+    data_subject: string;
+    /** Feature that was matched on. */
+    feature: string;
+    /** Ids of every term matching the subject, whether or not they were erased. */
+    matched_terms: string[];
+    /**
+     * Terms actually removed (zero on a dry run).
+     * @min 0
+     */
+    terms_deleted: number;
+}
+/** Body for fulfilling an erasure request against the knowledge base. */
+interface SubjectErasureRequest {
+    /** Execute the erasure. Defaults to false — a dry run returning the plan. */
+    confirm?: boolean;
+    /**
+     * Which feature holds the subject's identifier (e.g. `"name"`, `"email"`).
+     *
+     * Named by the caller rather than guessed: only the operator knows which
+     * feature identifies a person in their schema, and guessing wrong would
+     * either miss the subject's data or match somebody else's.
+     */
+    feature: string;
+}
 /** Request to subscribe agent to KB changes. */
 interface SubscribeToKbRequest$1 {
     /**
@@ -24049,7 +24649,14 @@ interface TermBindingDto$1 {
 }
 /** API representation of a term */
 interface TermDto$1 {
-    /** Human-readable display name extracted from features (name/label/title/...) */
+    /**
+     * Human-readable display name extracted from features under a total,
+     * deterministic precedence: a feature the sort annotates `displayLabel`,
+     * then one annotated `isIdentifier`, then the conventional keys
+     * (name/label/title/...), then the sort's declared feature order, then
+     * undeclared features in lexicographic key order. The same term always
+     * yields the same value.
+     */
     display_name?: string | null;
     /** Features map */
     features: Record<string, ValueDto$1>;
@@ -24221,6 +24828,44 @@ interface TestInputDto {
     /** Caller-assigned identifier echoed in the response. */
     input_id: string;
 }
+/** Run the caller's own system prompt over a piece of text. */
+interface TextGenerateRequest {
+    /**
+     * Output-token cap for one model call. Clamped down to the deployment's
+     * own maximum — the engine's per-sequence budget covers prompt AND
+     * generation, and the caller does not know it.
+     * @format int32
+     * @min 0
+     */
+    max_tokens?: number | null;
+    /**
+     * The system prompt, applied verbatim.
+     *
+     * This is the whole point of the endpoint. A client that versions its own
+     * prompts (and stands behind the pairing of prompt version + output) must
+     * be able to send the prompt it versioned; a service-side rewording would
+     * silently answer a different question.
+     */
+    system: string;
+    /**
+     * Decode temperature. Absent = greedy, the only setting under which a
+     * versioned prompt yields a reproducible answer.
+     * @format float
+     */
+    temperature?: number | null;
+    /**
+     * The text to transform. Sent to the model as the user turn, verbatim —
+     * never wrapped — so the answer stays diff-able against the input.
+     */
+    text: string;
+}
+/** The generated text. */
+interface TextGenerateResponse {
+    /** Label of the backend that answered, when known. */
+    model?: string | null;
+    /** The model's answer, trimmed of surrounding whitespace. */
+    text: string;
+}
 /** Threshold-based weak anchor for an antecedent gate. */
 interface ThresholdAnchorDto {
     /**
@@ -25241,6 +25886,17 @@ interface UnifyTermsResponse$1 {
     /** The resulting unified term ID (if successful) */
     unified_term_id?: string | null;
 }
+/**
+ * A cluster that carried enough speech to report but matched no profile —
+ * the raw material for "this is …" enrollment from media.
+ */
+interface UnknownClusterDto {
+    /** @format int32 */
+    cluster: number;
+    spans: SpeechSpanDto[];
+    /** @format double */
+    speech_secs: number;
+}
 /** Request to update a collection */
 interface UpdateCollectionRequest$1 {
     /** Optional description */
@@ -25425,6 +26081,37 @@ interface UpgradeRequest {
     /** The content-addressed bundle id of the target version (UUID string). */
     to_bundle_id: string;
 }
+/**
+ * Metadata for a tenant-uploaded file-based source artifact (#107).
+ *
+ * Returned by `POST /api/v1/sources/files` (the upload) and listed by
+ * `GET /api/v1/sources/files`. The `path` is the engine-internal location
+ * written into a registered source's `config.file_path` (csv/parquet) or
+ * `config.database_path` (sqlite); the api-layer path-traversal guard
+ * accepts exactly these uploaded paths (plus configured allow-tree entries).
+ * `uploaded_at` follows the `chrono::DateTime<chrono::Utc>` convention used
+ * by `SourceSummaryDto::last_sync_at` so the field round-trips through the
+ * same utoipa `chrono` schema generator as the rest of the ingestion DTOs.
+ */
+interface UploadedSourceFileDto {
+    /** The `SourceFileId` (UUID v4) of the upload, also the `{id}` path param. */
+    id: string;
+    /** Sanitized basename of the uploaded file (no path separators). */
+    name: string;
+    /** Engine-internal absolute path the registered source's config points at. */
+    path: string;
+    /**
+     * Size of the stored file in bytes.
+     * @format int64
+     * @min 0
+     */
+    size: number;
+    /**
+     * Upload timestamp (RFC 3339 UTC).
+     * @format date-time
+     */
+    uploaded_at: string;
+}
 /** @format uuid */
 type UserId = string;
 /**
@@ -26314,6 +27001,15 @@ declare class Sorts<SecurityDataType = unknown> {
      * @request GET:/api/v1/sorts/equivalence-classes
      */
     getEquivalenceClasses: (params?: RequestParams) => Promise<HttpResponse<GetEquivalenceClassesResponse$1, any>>;
+    /**
+     * 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: GetFuzzySubsumptionRequest, params?: RequestParams) => Promise<HttpResponse<GetFuzzySubsumptionResponse, any>>;
     /**
      * @description Per Definition IV.5 (Milanese & Pasi 2024): ≾̇ = ((≾̃ .− ∼) ⊍ ≤)⁺
      *
@@ -26324,14 +27020,21 @@ declare class Sorts<SecurityDataType = unknown> {
      */
     getPreorderDegree: (data: GetPreorderDegreeRequest$1, params?: RequestParams) => Promise<HttpResponse<GetPreorderDegreeResponse$1, any>>;
     /**
-     * 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: string, params?: RequestParams) => Promise<HttpResponse<SortResponse$1, void>>;
+    getSort: (id: string, query?: {
+        /**
+         * Optional response format. `osfql` renders the sort as its commented
+         * `DEFINE` DDL (`text/plain`); `json` (or absent) keeps the JSON DTO.
+         * The bulk schema route (`/api/v1/sorts/schema`) accepts only `osfql`.
+         */
+        format?: string | null;
+    }, params?: RequestParams) => Promise<HttpResponse<SortResponse$1, void>>;
     /**
      * No description
      *
@@ -26341,6 +27044,55 @@ declare class Sorts<SecurityDataType = unknown> {
      * @request POST:/api/v1/sorts/similarity/get
      */
     getSortSimilarity: (data: GetSortSimilarityRequest$1, params?: RequestParams) => Promise<HttpResponse<GetSortSimilarityResponse$1, any>>;
+    /**
+     * @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?: {
+        /**
+         * Optional response format. `osfql` renders the sort as its commented
+         * `DEFINE` DDL (`text/plain`); `json` (or absent) keeps the JSON DTO.
+         * The bulk schema route (`/api/v1/sorts/schema`) accepts only `osfql`.
+         */
+        format?: string | null;
+        /**
+         * Include system-defined sorts in the response.
+         * System sorts are built-in types like Thing, Person, etc.
+         * Defaults to false (system sorts are excluded by default).
+         */
+        include_system?: boolean;
+        /**
+         * Maximum number of sorts to return. When omitted, no cap is
+         * applied (legacy behaviour). Recommended page size for
+         * production tenants: 50_000.
+         * @min 0
+         */
+        limit?: number | null;
+        /** Filter to only show LLM-extracted sorts */
+        llm_extracted?: boolean | null;
+        /**
+         * Filter to sorts whose name starts with this prefix.
+         * Supports comma-separated multiple prefixes (e.g. "drug_,target_,pathway_,disease_").
+         * Server-side filtering avoids transferring millions of irrelevant sorts.
+         */
+        name_prefix?: string | null;
+        /** Filter to only show sorts needing review */
+        needs_review?: boolean | null;
+        /**
+         * Zero-indexed pagination offset. Combined with ``limit`` this
+         * lets clients stream a production tenant (1 M+ sorts, ~500 MB
+         * uncompressed) as a sequence of small responses, avoiding the
+         * ``IncompleteRead`` a single-response transfer reliably hits
+         * above ~30 MB.
+         * @min 0
+         */
+        offset?: number | null;
+    }, params?: RequestParams) => Promise<HttpResponse<string, void>>;
     /**
      * No description
      *
@@ -26445,6 +27197,15 @@ declare class Sorts<SecurityDataType = unknown> {
         /** Search query (sort name substring) */
         q: string;
     }, params?: RequestParams) => Promise<HttpResponse<SearchSortsResponse, any>>;
+    /**
+     * @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: SetFuzzySubsumptionRequest, params?: RequestParams) => Promise<HttpResponse<SetFuzzySubsumptionResponse, any>>;
     /**
      * @description Similarity is symmetric: ∼(s₁, s₂) = ∼(s₂, s₁) Degree must be in [0, 1] range.
      *
@@ -29120,11 +29881,11 @@ declare class Inference<SecurityDataType = unknown> {
      */
     bulkRetractTerms: (data: BulkRetractTermsRequest, params?: RequestParams) => Promise<HttpResponse<BulkRetractTermsResponse, any>>;
     /**
-     * @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
      */
@@ -42351,7 +43112,7 @@ declare class Reasoning<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
     /**
-     * @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
@@ -42360,7 +43121,7 @@ declare class Reasoning<SecurityDataType = unknown> {
      */
     disentailment: (data: DisentailmentRequest$1, params?: RequestParams) => Promise<HttpResponse<DisentailmentResponse$1, any>>;
     /**
-     * @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
@@ -45217,6 +45978,16 @@ declare class StructuredIngestion<SecurityDataType = unknown> {
      * @secure
      */
     deleteSource: (sourceId: string, params?: RequestParams) => Promise<HttpResponse<void, void>>;
+    /**
+     * @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: string, params?: RequestParams) => Promise<HttpResponse<void, void>>;
     /**
      * @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.
      *
@@ -45247,6 +46018,16 @@ declare class StructuredIngestion<SecurityDataType = unknown> {
      * @secure
      */
     ingestFromSource: (sourceId: string, data: IngestFromSourceRequest$1, params?: RequestParams) => Promise<HttpResponse<IngestFromSourceResponse$1, void>>;
+    /**
+     * @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?: RequestParams) => Promise<HttpResponse<UploadedSourceFileDto[], any>>;
     /**
      * No description
      *
@@ -45287,6 +46068,16 @@ declare class StructuredIngestion<SecurityDataType = unknown> {
      * @secure
      */
     registerSource: (data: RegisterSourceRequest$1, params?: RequestParams) => Promise<HttpResponse<RegisterSourceResponse$1, void>>;
+    /**
+     * @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: string, params?: RequestParams) => Promise<HttpResponse<UploadedSourceFileDto, void>>;
 }
 
 /**
@@ -47998,6 +48789,15 @@ declare class DiscoveryClient {
 declare class Extraction<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * @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: ExtractionCertifyRequest, params?: RequestParams) => Promise<HttpResponse<ExtractionCertifyResponse, void>>;
     /**
      * @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.
      *
@@ -48096,6 +48896,16 @@ declare class DocumentAnalysis<SecurityDataType = unknown> {
 declare class Documents<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * No description
+     *
+     * @tags documents
+     * @name EraseDocument
+     * @summary Erase a document and everything extracted from it
+     * @request DELETE:/api/v1/documents/{id}
+     * @secure
+     */
+    eraseDocument: (id: string, params?: RequestParams) => Promise<HttpResponse<DocumentErasureReport, void>>;
     /**
      * No description
      *
@@ -52708,6 +53518,15 @@ declare class Health<SecurityDataType = unknown> {
      * @request GET:/health
      */
     healthCheck: (params?: RequestParams) => Promise<HttpResponse<EnrichedHealthResponse$1, EnrichedHealthResponse$1>>;
+    /**
+     * 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?: RequestParams) => Promise<HttpResponse<EnrichedHealthResponse$1, EnrichedHealthResponse$1>>;
 }
 
 /** Build information from the backend server. */
@@ -53434,6 +54253,16 @@ declare class Generation<SecurityDataType = unknown> {
      * @secure
      */
     generateDocument: (data: GenerateDocumentRequest$1, params?: RequestParams) => Promise<HttpResponse<GenerateDocumentResponse$1, void>>;
+    /**
+     * @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: TextGenerateRequest, params?: RequestParams) => Promise<HttpResponse<TextGenerateResponse, void>>;
     /**
      * @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).
      *
@@ -56229,6 +57058,33 @@ interface PaperMetadataDto {
     source: PaperSource;
     /** URL to full text. */
     fullTextUrl?: string | null;
+    /**
+     * Stable paper identity (`doi:…`, `pmid:…`, `arxiv:…` or `title:…`).
+     *
+     * The join key between a paper listed on a session and the `paperKey`
+     * carried by findings, evidence items and contradiction sides — `doi`,
+     * `pmid` and `arxivId` are each individually optional, so this is the only
+     * identifier guaranteed for every paper. `null` only when talking to a
+     * backend that predates paper attribution.
+     */
+    paperKey?: string | null;
+}
+/**
+ * A citable reference to the paper a statement came from.
+ *
+ * Claims, evidence items and contradiction sides are keyed internally by
+ * OSFKB term UUIDs, which no consumer can resolve back to a document. This is
+ * the resolvable counterpart: `paperKey` is the stable identity, and
+ * `doi`/`title` are carried alongside so rendering a citation needs no second
+ * lookup.
+ */
+interface PaperRefDto {
+    /** Stable paper identity (`doi:…`, `pmid:…`, `arxiv:…` or `title:…`). */
+    paperKey: string;
+    /** DOI of the paper, when it has one. */
+    doi?: string | null;
+    /** Paper title, for display. */
+    title: string;
 }
 /** A search result with relevance score. */
 interface PaperSearchResultDto {
@@ -56280,6 +57136,13 @@ interface ResearchSessionResponse {
     error?: string | null;
     /** Results from each completed cycle. */
     cycles: ResearchCycleResultDto[];
+    /**
+     * Papers ingested so far, with full metadata (title, authors, DOI, URL).
+     *
+     * This is the session's actual corpus — `totalPapersIngested` is only its
+     * length. Empty against a backend that does not send it.
+     */
+    papers: PaperMetadataDto[];
     /** Total papers ingested. */
     totalPapersIngested: number;
     /** Total findings. */
@@ -56335,6 +57198,10 @@ interface ResearchCycleResultDto {
     claimsVerified: number;
     /** Contradictions detected. */
     contradictionsDetected: number;
+    /** Contradictions resolved via evidence comparison. `0` if the backend omits it. */
+    contradictionsResolved: number;
+    /** Claims merged via entailment detection. `0` if the backend omits it. */
+    claimsMerged: number;
     /** Processing time for this cycle in milliseconds. */
     processingTimeMs: number;
     /** Search queries used. */
@@ -56372,6 +57239,14 @@ interface EvidenceItemSummaryDto {
     contribution: number;
     /** DOI of the paper providing this evidence. */
     paperDoi?: string | null;
+    /**
+     * Stable key of the paper providing this evidence.
+     *
+     * Present even when the paper has no DOI, which `paperDoi` cannot cover.
+     */
+    paperKey?: string | null;
+    /** Title of the paper providing this evidence, for display. */
+    paperTitle?: string | null;
 }
 /** A step in the provenance chain. */
 interface ProvenanceStepDto {
@@ -56384,6 +57259,21 @@ interface ProvenanceStepDto {
     /** Timestamp (ISO 8601). */
     timestamp?: string | null;
 }
+/**
+ * A feature that is residuated — suspended because data is missing.
+ *
+ * Per-feature rather than binary at the claim level: each entry names a
+ * specific piece of missing information that, once supplied, would strengthen
+ * or change the assessment.
+ */
+interface ResiduatedFeatureDto {
+    /** Feature name that is missing or incomplete. */
+    featureName: string;
+    /** What sort would satisfy this feature. */
+    neededSort?: string | null;
+    /** Information gain from resolving this feature (0.0-1.0). */
+    infoGain: number;
+}
 /** A verified research finding. */
 interface ResearchFindingDto {
     /** OSFKB term ID of the claim. */
@@ -56404,6 +57294,16 @@ interface ResearchFindingDto {
     residuated: boolean;
     /** Reason for residuation. */
     residuationReason?: string | null;
+    /** Specific features that are residuated, enabling targeted gap filling. */
+    residuatedFeatures: ResiduatedFeatureDto[];
+    /**
+     * Papers the claim was extracted from.
+     *
+     * `claimId` is an OSFKB term UUID and is not resolvable by a consumer; this
+     * is what makes the finding citable. A claim drawn from several papers
+     * carries several refs. Empty when the backend has no attribution for it.
+     */
+    sources: PaperRefDto[];
 }
 /** Response containing research findings. */
 interface ResearchFindingsResponse {
@@ -56436,6 +57336,31 @@ interface ResearchGapsResponse {
     /** Total gaps count. */
     total: number;
 }
+/** Strategy used to resolve a contradiction between two claims. */
+type ResolutionStrategyDto = 'EvidenceStrength' | 'EvidenceCount' | 'Unresolvable';
+/**
+ * Resolution of a detected contradiction, by evidence-strength comparison.
+ *
+ * When two claims contradict, their evidence assessment scores are compared:
+ * the better-supported claim is preferred and the weaker one dismissed. A
+ * `strategy` of `'Unresolvable'` means the two sides were too close to call.
+ */
+interface ContradictionResolutionDto {
+    /** ID of the preferred claim (stronger evidence). */
+    preferredClaimId: string;
+    /** ID of the dismissed claim (weaker evidence). */
+    dismissedClaimId: string;
+    /** Truthfulness score of the preferred claim. */
+    preferredTruthfulness: number;
+    /** Truthfulness score of the dismissed claim. */
+    dismissedTruthfulness: number;
+    /** Strategy used to resolve the contradiction. */
+    strategy: ResolutionStrategyDto;
+    /** Confidence in the resolution (0.0-1.0). */
+    confidence: number;
+    /** Human-readable explanation of the resolution. */
+    explanation: string;
+}
 /** A detected contradiction between two claims. */
 interface ContradictionDto {
     /** OSFKB term ID of the first claim. */
@@ -56450,6 +57375,17 @@ interface ContradictionDto {
     confidence: number;
     /** Explanation of the contradiction. */
     explanation: string;
+    /** Resolution of the contradiction, if it was resolved by evidence comparison. */
+    resolution?: ContradictionResolutionDto | null;
+    /**
+     * Papers the first claim was extracted from.
+     *
+     * Without it "these two claims disagree" is unactionable — a reader cannot
+     * tell which literature each side comes from.
+     */
+    claimASources: PaperRefDto[];
+    /** Papers the second claim was extracted from. */
+    claimBSources: PaperRefDto[];
 }
 /** Response containing contradictions. */
 interface ResearchContradictionsResponse {
@@ -56480,6 +57416,10 @@ interface ResearchStatisticsDto {
     gapsResolved: number;
     /** Knowledge gaps remaining. */
     gapsRemaining: number;
+    /** Claims merged via entailment detection. `0` if the backend omits it. */
+    claimsMerged: number;
+    /** Contradictions resolved via evidence comparison. `0` if the backend omits it. */
+    contradictionsResolved: number;
 }
 /** Report verification result. */
 interface ReportVerificationDto {
@@ -56557,6 +57497,7 @@ interface VerifyClaimResponse {
 }
 
 type research_ContradictionDto = ContradictionDto;
+type research_ContradictionResolutionDto = ContradictionResolutionDto;
 type research_CreateResearchSessionRequest = CreateResearchSessionRequest;
 type research_CreateResearchSessionResponse = CreateResearchSessionResponse;
 type research_EvidenceItemSummaryDto = EvidenceItemSummaryDto;
@@ -56565,6 +57506,7 @@ type research_IngestPaperResponse = IngestPaperResponse;
 type research_KnowledgeGapDto = KnowledgeGapDto;
 type research_ListResearchSessionsResponse = ListResearchSessionsResponse;
 type research_PaperMetadataDto = PaperMetadataDto;
+type research_PaperRefDto = PaperRefDto;
 type research_PaperSearchResultDto = PaperSearchResultDto;
 type research_PaperSource = PaperSource;
 type research_ProvenanceStepDto = ProvenanceStepDto;
@@ -56580,13 +57522,15 @@ type research_ResearchSessionResponse = ResearchSessionResponse;
 type research_ResearchSessionStatusDto = ResearchSessionStatusDto;
 type research_ResearchSessionSummaryDto = ResearchSessionSummaryDto;
 type research_ResearchStatisticsDto = ResearchStatisticsDto;
+type research_ResiduatedFeatureDto = ResiduatedFeatureDto;
+type research_ResolutionStrategyDto = ResolutionStrategyDto;
 type research_RunResearchCycleRequest = RunResearchCycleRequest;
 type research_SearchPapersRequest = SearchPapersRequest;
 type research_SearchPapersResponse = SearchPapersResponse;
 type research_VerifyClaimRequest = VerifyClaimRequest;
 type research_VerifyClaimResponse = VerifyClaimResponse;
 declare namespace research {
-  export type { research_ContradictionDto as ContradictionDto, research_CreateResearchSessionRequest as CreateResearchSessionRequest, research_CreateResearchSessionResponse as CreateResearchSessionResponse, research_EvidenceItemSummaryDto as EvidenceItemSummaryDto, research_IngestPaperRequest as IngestPaperRequest, research_IngestPaperResponse as IngestPaperResponse, research_KnowledgeGapDto as KnowledgeGapDto, research_ListResearchSessionsResponse as ListResearchSessionsResponse, research_PaperMetadataDto as PaperMetadataDto, research_PaperSearchResultDto as PaperSearchResultDto, research_PaperSource as PaperSource, research_ProvenanceStepDto as ProvenanceStepDto, research_ReportVerificationDto as ReportVerificationDto, research_ResearchContradictionsResponse as ResearchContradictionsResponse, research_ResearchCycleResponse as ResearchCycleResponse, research_ResearchCycleResultDto as ResearchCycleResultDto, research_ResearchFindingDto as ResearchFindingDto, research_ResearchFindingsResponse as ResearchFindingsResponse, research_ResearchGapsResponse as ResearchGapsResponse, research_ResearchReportResponse as ResearchReportResponse, research_ResearchSessionResponse as ResearchSessionResponse, research_ResearchSessionStatusDto as ResearchSessionStatusDto, research_ResearchSessionSummaryDto as ResearchSessionSummaryDto, research_ResearchStatisticsDto as ResearchStatisticsDto, research_RunResearchCycleRequest as RunResearchCycleRequest, research_SearchPapersRequest as SearchPapersRequest, research_SearchPapersResponse as SearchPapersResponse, research_VerifyClaimRequest as VerifyClaimRequest, research_VerifyClaimResponse as VerifyClaimResponse };
+  export type { research_ContradictionDto as ContradictionDto, research_ContradictionResolutionDto as ContradictionResolutionDto, research_CreateResearchSessionRequest as CreateResearchSessionRequest, research_CreateResearchSessionResponse as CreateResearchSessionResponse, research_EvidenceItemSummaryDto as EvidenceItemSummaryDto, research_IngestPaperRequest as IngestPaperRequest, research_IngestPaperResponse as IngestPaperResponse, research_KnowledgeGapDto as KnowledgeGapDto, research_ListResearchSessionsResponse as ListResearchSessionsResponse, research_PaperMetadataDto as PaperMetadataDto, research_PaperRefDto as PaperRefDto, research_PaperSearchResultDto as PaperSearchResultDto, research_PaperSource as PaperSource, research_ProvenanceStepDto as ProvenanceStepDto, research_ReportVerificationDto as ReportVerificationDto, research_ResearchContradictionsResponse as ResearchContradictionsResponse, research_ResearchCycleResponse as ResearchCycleResponse, research_ResearchCycleResultDto as ResearchCycleResultDto, research_ResearchFindingDto as ResearchFindingDto, research_ResearchFindingsResponse as ResearchFindingsResponse, research_ResearchGapsResponse as ResearchGapsResponse, research_ResearchReportResponse as ResearchReportResponse, research_ResearchSessionResponse as ResearchSessionResponse, research_ResearchSessionStatusDto as ResearchSessionStatusDto, research_ResearchSessionSummaryDto as ResearchSessionSummaryDto, research_ResearchStatisticsDto as ResearchStatisticsDto, research_ResiduatedFeatureDto as ResiduatedFeatureDto, research_ResolutionStrategyDto as ResolutionStrategyDto, research_RunResearchCycleRequest as RunResearchCycleRequest, research_SearchPapersRequest as SearchPapersRequest, research_SearchPapersResponse as SearchPapersResponse, research_VerifyClaimRequest as VerifyClaimRequest, research_VerifyClaimResponse as VerifyClaimResponse };
 }
 
 /**
@@ -57868,6 +58812,36 @@ declare class Compliance<SecurityDataType = unknown> {
      * @secure
      */
     captureSnapshot: (data: CaptureSnapshotRequest$1, params?: RequestParams) => Promise<HttpResponse<PredictionSnapshot$1, any>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name CreateDsr
+     * @summary File a GDPR data subject request
+     * @request POST:/api/v1/dsr
+     * @secure
+     */
+    createDsr: (data: CreateDsrRequest, params?: RequestParams) => Promise<HttpResponse<DsrRecordResponse, void>>;
+    /**
+     * @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: string, data: SubjectErasureRequest, params?: RequestParams) => Promise<HttpResponse<SubjectErasureReport, void>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name GetDsr
+     * @summary Read a data subject request
+     * @request GET:/api/v1/dsr/{id}
+     * @secure
+     */
+    getDsr: (id: string, params?: RequestParams) => Promise<HttpResponse<DsrRecordResponse, void>>;
     /**
      * No description
      *
@@ -57918,12 +58892,22 @@ declare class Compliance<SecurityDataType = unknown> {
          */
         since?: string | null;
         /** Sort field. Defaults to `timestamp`. */
-        sort_by?: any;
+        sort_by?: AuditSortField$1;
         /** Sort direction. Defaults to `desc` (most-recent-first). */
-        sort_order?: any;
+        sort_order?: AuditSortOrder$1;
         /** Inclusive upper bound on `timestamp` (RFC 3339). */
         until?: string | null;
     }, params?: RequestParams) => Promise<HttpResponse<AuditPage$1, void>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name ListDsr
+     * @summary List a data subject's requests
+     * @request GET:/api/v1/dsr
+     * @secure
+     */
+    listDsr: (params?: RequestParams) => Promise<HttpResponse<DsrRecordResponse[], any>>;
     /**
      * No description
      *
@@ -60187,6 +61171,16 @@ declare class OntologyBridge<SecurityDataType = unknown> {
      * @secure
      */
     bulkBindSorts: (data: BulkBindSortsRequest$1, params?: RequestParams) => Promise<HttpResponse<BulkBindSortsResponse$1, any>>;
+    /**
+     * @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: ExecuteTranspiledRequest, params?: RequestParams) => Promise<HttpResponse<ExecuteTranspiledResponse, void>>;
     /**
      * @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.
      *
@@ -60228,7 +61222,7 @@ declare class OntologyBridge<SecurityDataType = unknown> {
      */
     listBindings: (params?: RequestParams) => Promise<HttpResponse<ListBindingsResponse$1, any>>;
     /**
-     * @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
@@ -69433,6 +70427,16 @@ declare class Speakers<SecurityDataType = unknown> {
      * @secure
      */
     enrollSpeaker: (data: EnrollSpeakerRequest$1, params?: RequestParams) => Promise<HttpResponse<EnrollSpeakerResponse$1, void>>;
+    /**
+     * @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: IdentifySpeakersRequest, params?: RequestParams) => Promise<HttpResponse<IdentifySpeakersResponse, void>>;
     /**
      * @description GET /api/v1/speakers
      *