@kortexya/reasoninglayer 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.0.0";
+var SDK_VERSION = "1.1.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -1519,6 +1519,24 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * @description In OSF/LIFE terms, an orchestrator wires neural sort-subsumption gates (`τ(x ⊑ S) ∈ [0, 1]`) for a conclusion sort and a set of antecedent sorts. Knowledge axioms reference homoiconic rule Ψ-terms registered in the tenant's KB. The first call lazily instantiates the underlying Candle-backed gates; subsequent calls within the same tenant share gate state. # Authorization Requires `X-Tenant-Id` header.
+   *
+   * @tags inference
+   * @name ConfigureOrchestrator
+   * @summary Register an OSF Neural-Predicate Orchestrator configuration for the calling tenant.
+   * @request POST:/api/v1/inference/orchestrator/configure
+   * @secure
+   */
+  configureOrchestrator = (data, params = {}) => this.http.request({
+    path: `/api/v1/inference/orchestrator/configure`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description # TRUE HOMOICONICITY Goals are first-class Ψ-terms that can be created, persisted, and reused. This endpoint creates a goal from clauses and optional constraints, persists it to PostgreSQL, and returns the goal ID for later use. # Authorization Requires X-Tenant-Id header.
    *
@@ -1690,6 +1708,42 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * @description In OSF/LIFE terms, the orchestrator forwards the Ψ-term through the conclusion gate to read `τ(x ⊑ conclusion_sort)`, then for each knowledge axiom evaluates its antecedent gates and combines them with the conclusion truth via Reichenbach (`1 − a + a · c`). The fused confidence aggregates per-axiom modus-ponens witness strength via noisy-OR. # Authorization Requires `X-Tenant-Id` header.
+   *
+   * @tags inference
+   * @name PredictWithOrchestrator
+   * @summary Score a single Ψ-term: conclusion subsumption probability + per-axiom firing trace + noisy-OR fused confidence.
+   * @request POST:/api/v1/inference/orchestrator/predict
+   * @secure
+   */
+  predictWithOrchestrator = (data, params = {}) => this.http.request({
+    path: `/api/v1/inference/orchestrator/predict`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description In OSF/LIFE terms, the orchestrator pushes the conclusion gate and each antecedent gate toward the dual-weighted satisfaction objective `1 − ( w_D · K_D + w_K · K_K )` (paper eq. 4). Each call performs exactly one epoch over the supplied batch — the response carries the per-epoch metrics for that single epoch (multi-epoch aggregation is the caller's responsibility). # Authorization Requires `X-Tenant-Id` header.
+   *
+   * @tags inference
+   * @name TrainOrchestrator
+   * @summary Run one training epoch over a labelled Ψ-term batch.
+   * @request POST:/api/v1/inference/orchestrator/train
+   * @secure
+   */
+  trainOrchestrator = (data, params = {}) => this.http.request({
+    path: `/api/v1/inference/orchestrator/train`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Cognitive.ts
@@ -4271,6 +4325,24 @@ var Visualization = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description Note: when MVCC branching isn't materialized as named branches in the user's store, this endpoint surfaces an empty diff. The shape is preserved so clients can rely on it without conditional code.
+   *
+   * @tags visualization
+   * @name GetBranchDiffVisualization
+   * @summary Render the diff between two MVCC branches of the tenant's term store. Each visible Ψ-term carries `properties.diff` ∈ `{added, removed, changed}` so the renderer can color-distinguish.
+   * @request POST:/api/v1/visualization/branch-diff
+   * @secure
+   */
+  getBranchDiffVisualization = (data, params = {}) => this.http.request({
+    path: `/api/v1/visualization/branch-diff`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -4289,6 +4361,75 @@ var Visualization = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Each event is a JSON-encoded `DerivationStepEvent` with shape: ```json { "iteration": 3, "rule_id": "uuid", "antecedents": ["uuid",...], "derived_fact": "uuid" } ``` Sent once per record produced during the chainer pass. The client can animate each polygon emerging as its premise edges arrive.
+   *
+   * @tags visualization
+   * @name GetDerivationStream
+   * @summary SSE channel that streams the forward-chainer's derivation steps as they fire, instead of blocking until the full trace is assembled.
+   * @request GET:/api/v1/visualization/derivation/stream
+   * @secure
+   */
+  getDerivationStream = (params = {}) => this.http.request({
+    path: `/api/v1/visualization/derivation/stream`,
+    method: "GET",
+    secure: true,
+    ...params
+  });
+  /**
+   * @description Runs the homoiconic forward chainer with provenance enabled and emits a [`VisualizationGraph`] in which: - **Nodes** are Ψ-terms (each one is either an asserted fact, a rule, or a derived fact). Rules surface as `NodeType::Rule`. - **Edges** are `EdgeType::Derivation`, oriented antecedent → rule-application → produced-fact, mirroring the proof DAG. - **Hyperedges** are `HyperedgeType::DerivationStep` — one per rule application, grouping the rule with all its antecedents plus the produced fact. Rendering each step as a polygon makes "this fact came from these premises via this rule" visually atomic — exactly the idea behind Aït-Kaci & Sasaki's proof-tree diagrams in OSF/LIFE papers.
+   *
+   * @tags visualization
+   * @name GetDerivationVisualization
+   * @summary Get the forward-chain derivation lattice as a meta-hypergraph.
+   * @request POST:/api/v1/visualization/derivation
+   * @secure
+   */
+  getDerivationVisualization = (data, params = {}) => this.http.request({
+    path: `/api/v1/visualization/derivation`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags visualization
+   * @name GetFunctionsVisualization
+   * @summary Render the LIFE-style function definitions in the tenant's term store. A LIFE function is itself a Ψ-term (homoiconic) — typically a term whose sort is `function` (or a subtype) carrying features `head`, `body`, optional `equations`. This handler scans the store for terms matching that signature and emits one TermFeatures-style hyperedge per function so each is visually atomic.
+   * @request POST:/api/v1/visualization/functions
+   * @secure
+   */
+  getFunctionsVisualization = (data, params = {}) => this.http.request({
+    path: `/api/v1/visualization/functions`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags visualization
+   * @name GetGradedPosetVisualization
+   * @summary Render the graded-poset projection of the tenant's sort hierarchy per "Weisfeiler & Lehman Go Categorical" (Choi, Kim, Yun 2026): - elements = sorts - dimension(σ) = topological depth from the lattice top - coverings = parent → child (subtype) - 4-adjacency edges when requested
+   * @request POST:/api/v1/visualization/graded-poset
+   * @secure
+   */
+  getGradedPosetVisualization = (data, params = {}) => this.http.request({
+    path: `/api/v1/visualization/graded-poset`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -4322,6 +4463,24 @@ var Visualization = class {
     secure: true,
     ...params
   });
+  /**
+   * @description The layout is computed once per tenant (per hierarchy snapshot) and cached. Coordinates are stable across requests, so the client can pan/zoom by submitting different bboxes and the same node always lands at the same screen position.
+   *
+   * @tags visualization
+   * @name GetLatticeTile
+   * @summary Render only the lattice nodes that fall inside the client's viewport, using a stable pre-computed deterministic layout. This scales to millions of sorts because the per-request work is O(K) where K is the number of nodes inside the viewport, not O(N).
+   * @request POST:/api/v1/visualization/lattice-tile
+   * @secure
+   */
+  getLatticeTile = (data, params = {}) => this.http.request({
+    path: `/api/v1/visualization/lattice-tile`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns a graph representation of the sort hierarchy with nodes for each sort and edges for subtype relationships. Supports filtering by root sort and depth.
    *
@@ -4358,6 +4517,42 @@ var Visualization = class {
     format: "json",
     ...params
   });
+  /**
+   * @description BFS expands ancestors and/or descendants from the focus, emitting each visited sort with its signed hop distance as `level`. When the visit count would exceed `max_nodes`, the BFS halts and the `truncated` flag is set; the closest sorts are kept.
+   *
+   * @tags visualization
+   * @name GetSortNeighborhood
+   * @summary Render an N-hop neighborhood around a focus sort, capped at `max_nodes`. Designed for tenants with millions of sorts — the client never sees the full lattice; it browses by picking a focus and walking outward.
+   * @request POST:/api/v1/visualization/sort-neighborhood
+   * @secure
+   */
+  getSortNeighborhood = (data, params = {}) => this.http.request({
+    path: `/api/v1/visualization/sort-neighborhood`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags visualization
+   * @name GetTermListVisualization
+   * @summary Paginated raw list of Ψ-terms for visualization. Mirrors the `lattice` endpoint but for terms — at 9M terms in the drug-discovery tenant the first page returns sub-second without loading the in-memory term store.
+   * @request POST:/api/v1/visualization/term-list
+   * @secure
+   */
+  getTermListVisualization = (data, params = {}) => this.http.request({
+    path: `/api/v1/visualization/term-list`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -4392,6 +4587,24 @@ var Visualization = class {
     format: "json",
     ...params
   });
+  /**
+   * @description **Unify (`⊔`)**: computes the meet on the Ψ-term lattice — the most-specific term that subsumes both operands. Variables in either operand bind to the corresponding sub-term in the other. **Anti-unify (`⊓`)**: computes the join — the least-general generalization (LGG) that subsumes both operands, introducing fresh variables where they disagree. This is the operation Aït-Kaci & Sasaki used for ILP rule synthesis. The handler runs the operation in a sandbox (trail-undone after snapshot) so the tenant's term store is not mutated by a visualization request. Returns operand1, operand2, and the result as polygons in one `VisualizationGraph`, with `properties.role` distinguishing each.
+   *
+   * @tags visualization
+   * @name GetUnifyTermsVisualization
+   * @summary Render the unification (or anti-unification) of two Ψ-terms.
+   * @request POST:/api/v1/visualization/unify-terms
+   * @secure
+   */
+  getUnifyTermsVisualization = (data, params = {}) => this.http.request({
+    path: `/api/v1/visualization/unify-terms`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -7745,6 +7958,155 @@ var Ui = class {
   });
 };
 
+// src/api-spec/generated/Compliance.ts
+var Compliance = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name Append
+   * @summary `POST /api/v1/compliance/audit/append`
+   * @request POST:/api/v1/compliance/audit/append
+   * @secure
+   */
+  append = (data, params = {}) => this.http.request({
+    path: `/api/v1/compliance/audit/append`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name CaptureSnapshot
+   * @summary `POST /api/v1/predictions/snapshot`
+   * @request POST:/api/v1/predictions/snapshot
+   * @secure
+   */
+  captureSnapshot = (data, params = {}) => this.http.request({
+    path: `/api/v1/predictions/snapshot`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name GetSnapshot
+   * @summary `GET /api/v1/predictions/snapshot/{id}`
+   * @request GET:/api/v1/predictions/snapshot/{id}
+   * @secure
+   */
+  getSnapshot = (id, params = {}) => this.http.request({
+    path: `/api/v1/predictions/snapshot/${id}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name List
+   * @summary `GET /api/v1/compliance/audit/list`
+   * @request GET:/api/v1/compliance/audit/list
+   * @secure
+   */
+  list = (query, params = {}) => this.http.request({
+    path: `/api/v1/compliance/audit/list`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name Summary
+   * @summary `GET /api/v1/compliance/audit/summary`
+   * @request GET:/api/v1/compliance/audit/summary
+   * @secure
+   */
+  summary = (params = {}) => this.http.request({
+    path: `/api/v1/compliance/audit/summary`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Runs validation with a built-in stub provider that returns `Pending` for every entry. Real consumers wire their own `GroundTruthProviderPort` implementation and call `PredictionLedgerPort::validate` from a service.
+   *
+   * @tags compliance
+   * @name ValidateStub
+   * @summary `POST /api/v1/predictions/snapshot/{id}/validate-stub`
+   * @request POST:/api/v1/predictions/snapshot/{id}/validate-stub
+   * @secure
+   */
+  validateStub = (id, params = {}) => this.http.request({
+    path: `/api/v1/predictions/snapshot/${id}/validate-stub`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name Verify
+   * @summary `GET /api/v1/compliance/audit/verify`
+   * @request GET:/api/v1/compliance/audit/verify
+   * @secure
+   */
+  verify = (params = {}) => this.http.request({
+    path: `/api/v1/compliance/audit/verify`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+};
+
+// src/api-spec/generated/Operations.ts
+var Operations = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * @description `POST /api/v1/operations/anti-unify` Accepts two Ψ-term ids and returns the LGG term computed by the engine's [`AntiUnificationEngine`](osfkb_domain::operations::ilp::AntiUnificationEngine). The LGG is persisted in the tenant's term store; the response carries both its id and an enriched view (sort name + display name + referenced-term summaries).
+   *
+   * @tags operations
+   * @name AntiUnify
+   * @summary Anti-unify two Ψ-terms (Least General Generalisation).
+   * @request POST:/api/v1/operations/anti-unify
+   */
+  antiUnify = (data, params = {}) => this.http.request({
+    path: `/api/v1/operations/anti-unify`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
 // src/normalizers/sorts.ts
 function ConstraintDtoFromApiToFront(dto) {
   if (dto.type === "FuzzyPathSimilarity") {
@@ -9152,10 +9514,19 @@ function ConstraintInputDtoFromFrontToApi(model) {
   }
 }
 function BackwardChainResponseFromApiToFront(dto) {
+  const wireRefs = dto.referenced_terms;
+  let referencedTerms;
+  if (wireRefs) {
+    referencedTerms = {};
+    for (const [uuid, term] of Object.entries(wireRefs)) {
+      referencedTerms[uuid] = TermDtoFromApiToFront(term);
+    }
+  }
   return {
     solutions: dto.solutions.map(SolutionDtoFromApiToFront),
     queryTimeMs: dto.query_time_ms,
-    goalId: dto.goal_id ?? void 0
+    goalId: dto.goal_id ?? void 0,
+    referencedTerms
   };
 }
 function ForwardChainResponseFromApiToFront(dto) {
@@ -9527,7 +9898,8 @@ function BackwardChainRequestFromFrontToApi(model) {
     max_solutions: model.maxSolutions,
     min_certainty: model.minCertainty,
     timeout_ms: model.timeoutMs ?? void 0,
-    constraints: model.constraints?.map(ConstraintInputDtoFromFrontToApi)
+    constraints: model.constraints?.map(ConstraintInputDtoFromFrontToApi),
+    expand_bindings: model.expandBindings
   };
 }
 function ForwardChainRequestFromFrontToApi(model) {
@@ -9680,6 +10052,12 @@ var InferenceClient = class {
    *
    * The `timeout_ms` field on the request is a wall-clock timeout for the search.
    * When it fires, the backend returns whatever solutions have been found so far.
+   *
+   * Pass `expandBindings: true` to receive the full {@link TermDto} of every
+   * Ψ-term transitively referenced by a solution's bindings in the
+   * `referencedTerms` sidecar map of the response. Lets the caller read complex
+   * bound values (lists of nested Ψ-terms etc.) without follow-up
+   * `terms.get(uuid)` calls.
    */
   async backwardChain(request) {
     const wireRequest = {
@@ -21759,6 +22137,243 @@ var UiClient = class {
   }
 };
 
+// src/normalizers/compliance.ts
+function AppendRequestFromFrontToApi(model) {
+  const dto = {
+    request_path: model.requestPath,
+    request_hash: model.requestHash,
+    response_hash: model.responseHash
+  };
+  if (model.dataVersions !== void 0) dto.data_versions = model.dataVersions;
+  if (model.extra !== void 0) dto.extra = model.extra;
+  return dto;
+}
+function AuditRecordFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    tenantId: dto.tenant_id,
+    actor: dto.actor ?? null,
+    timestamp: dto.timestamp,
+    requestPath: dto.request_path,
+    requestHash: dto.request_hash,
+    responseHash: dto.response_hash,
+    prevHash: dto.prev_hash,
+    recordHash: dto.record_hash,
+    gitRevision: dto.git_revision,
+    dataVersions: dto.data_versions,
+    extra: dto.extra
+  };
+}
+function SummaryResponseFromApiToFront(dto) {
+  const out = {
+    nRecords: dto.n_records,
+    perActor: dto.per_actor,
+    perRequestPath: dto.per_request_path,
+    tenantId: dto.tenant_id
+  };
+  if (dto.ts_first) out.tsFirst = dto.ts_first;
+  if (dto.ts_last) out.tsLast = dto.ts_last;
+  return out;
+}
+function VerifyResponseFromApiToFront(dto) {
+  return {
+    ok: dto.ok,
+    nViolations: dto.n_violations,
+    violations: dto.violations
+  };
+}
+function CaptureSnapshotRequestFromFrontToApi(model) {
+  const dto = {
+    request_path_pattern: model.requestPathPattern
+  };
+  if (model.capturedAfter !== void 0) dto.captured_after = model.capturedAfter;
+  if (model.maxEntries !== void 0) dto.max_entries = model.maxEntries;
+  return dto;
+}
+function snapshotFilterFromApi(dto) {
+  return {
+    requestPathPattern: dto.request_path_pattern,
+    capturedAfter: dto.captured_after ?? null,
+    maxEntries: dto.max_entries ?? null
+  };
+}
+function predictionEntryFromApi(dto) {
+  return {
+    id: dto.id,
+    requestHash: dto.request_hash,
+    responseSummary: dto.response_summary,
+    sourceRecordId: dto.source_record_id,
+    capturedStatus: dto.captured_status,
+    validatedStatus: dto.validated_status ?? null,
+    validatedAt: dto.validated_at ?? null
+  };
+}
+function PredictionSnapshotFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    tenantId: dto.tenant_id,
+    capturedAt: dto.captured_at,
+    filter: snapshotFilterFromApi(dto.filter),
+    entries: dto.entries.map(predictionEntryFromApi)
+  };
+}
+function ValidationReportDtoFromApiToFront(dto) {
+  return {
+    snapshotId: dto.snapshot_id,
+    completedAt: dto.completed_at,
+    nTotal: dto.n_total,
+    nPending: dto.n_pending,
+    nValidated: dto.n_validated,
+    nRefuted: dto.n_refuted,
+    nUnknown: dto.n_unknown,
+    validationRate: dto.validation_rate ?? null
+  };
+}
+
+// src/resources/compliance.ts
+var ComplianceClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  // ---------------------------------------------------------------
+  // Audit ledger
+  // ---------------------------------------------------------------
+  /**
+   * Append one record to the tenant's audit ledger.
+   *
+   * @param request - Hashes + path + optional metadata.
+   * @returns The freshly appended record (with `recordHash` /
+   *   `prevHash` populated by the engine).
+   */
+  async append(request) {
+    const response = await this.api.append(AppendRequestFromFrontToApi(request));
+    return AuditRecordFromApiToFront(response.data);
+  }
+  /**
+   * List audit records for this tenant, optionally filtered.
+   *
+   * @param options - Limit / glob filter on `requestPath`.
+   */
+  async list(options = {}) {
+    const query = {};
+    if (options.limit !== void 0) query.limit = options.limit;
+    if (options.requestPathPattern !== void 0) {
+      query.request_path_pattern = options.requestPathPattern;
+    }
+    const response = await this.api.list(query);
+    return response.data.map(AuditRecordFromApiToFront);
+  }
+  /**
+   * Top-line counts over the tenant's full ledger — useful for
+   * dashboards and quick health checks.
+   */
+  async summary() {
+    const response = await this.api.summary();
+    return SummaryResponseFromApiToFront(response.data);
+  }
+  /**
+   * Re-walk the hash chain end-to-end and report any breaks.
+   *
+   * @returns `ok: true` when the chain is intact.  `violations` is
+   *   an engine-defined opaque list when it isn't.
+   */
+  async verify() {
+    const response = await this.api.verify();
+    return VerifyResponseFromApiToFront(response.data);
+  }
+  // ---------------------------------------------------------------
+  // Prediction snapshots
+  // ---------------------------------------------------------------
+  /**
+   * Capture a frozen slice of the audit ledger for later validation.
+   *
+   * @param request - Glob-style path filter + optional time / count
+   *   bounds.
+   * @returns The freshly persisted snapshot, including every
+   *   captured `PredictionEntry`.
+   *
+   * @remarks
+   * The `requestPathPattern` is mandatory.  Without it the snapshot
+   * would freeze the entire ledger, which is rarely useful.
+   */
+  async captureSnapshot(request) {
+    const response = await this.api.captureSnapshot(
+      CaptureSnapshotRequestFromFrontToApi(request)
+    );
+    return PredictionSnapshotFromApiToFront(response.data);
+  }
+  /**
+   * Fetch a previously-captured snapshot by id.
+   */
+  async getSnapshot(id) {
+    const response = await this.api.getSnapshot(id);
+    return PredictionSnapshotFromApiToFront(response.data);
+  }
+  /**
+   * Run the stub validator over a snapshot and return a
+   * pending/validated/refuted/unknown report.
+   *
+   * @param id - Snapshot id.
+   *
+   * @remarks
+   * "Stub" is the in-engine validator that defers the actual
+   * ground-truth resolution to a `GroundTruthProviderPort` registered
+   * on the backend.  Without a registered provider every entry stays
+   * `Pending`.
+   */
+  async validateStub(id) {
+    const response = await this.api.validateStub(id);
+    return ValidationReportDtoFromApiToFront(response.data);
+  }
+};
+
+// src/normalizers/operations.ts
+function AntiUnifyRequestFromFrontToApi(model) {
+  return {
+    term1_id: model.term1Id,
+    term2_id: model.term2Id
+  };
+}
+function AntiUnifyResponseFromApiToFront(dto) {
+  return {
+    lggTermId: dto.lgg_term_id,
+    lgg: TermDtoFromApiToFront(dto.lgg),
+    computationTimeMs: dto.computation_time_ms
+  };
+}
+
+// src/resources/operations.ts
+var OperationsClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Compute the anti-unification (Least General Generalisation) of
+   * two Ψ-terms.
+   *
+   * @param request - The two term ids to generalise.
+   * @returns The newly-created LGG term + enriched view + timing.
+   *
+   * @remarks
+   * Both ids must already be registered in the tenant's term store.
+   * The LGG is persisted; subsequent calls with the same operands
+   * still produce a fresh LGG term (idempotency is not guaranteed at
+   * this layer — wrap in your own cache if you need it).
+   */
+  async antiUnify(request) {
+    const response = await this.api.antiUnify(
+      AntiUnifyRequestFromFrontToApi(request)
+    );
+    return AntiUnifyResponseFromApiToFront(response.data);
+  }
+};
+
 // src/client.ts
 var ReasoningLayerClient = class {
   /** Sort (type hierarchy) operations. */
@@ -21861,6 +22476,10 @@ var ReasoningLayerClient = class {
   rlTraining;
   /** Sort-driven UI descriptor operations (describe, action, catalog). */
   ui;
+  /** Hash-chained audit ledger and prediction-snapshot validation. */
+  compliance;
+  /** Low-level term-graph operations (anti-unification / LGG). */
+  operations;
   // ─── Group Caches ─────────────────────────────────────────────────
   _core;
   _ai;
@@ -22093,6 +22712,8 @@ var ReasoningLayerClient = class {
     this.context = new ContextClient(generatedContext);
     this.rlTraining = new RlTrainingClient(generatedRlTraining);
     this.ui = new UiClient(generatedUi);
+    this.compliance = new ComplianceClient(new Compliance(generatedHttp));
+    this.operations = new OperationsClient(new Operations(generatedHttp));
   }
 };
 
@@ -22247,6 +22868,12 @@ var osfql_exports = {};
 // src/types/conversation.ts
 var conversation_exports = {};
 
+// src/types/compliance.ts
+var compliance_exports = {};
+
+// src/types/operations.ts
+var operations_exports = {};
+
 // src/types/research.ts
 var research_exports = {};
 
@@ -22936,6 +23563,7 @@ exports.Causal = causal_exports;
 exports.Cognitive = cognitive_exports;
 exports.Collections = collections_exports;
 exports.Communities = communities_exports;
+exports.Compliance = compliance_exports;
 exports.ConstraintViolationError = ConstraintViolationError;
 exports.Constraints = constraints_exports;
 exports.Control = control_exports;
@@ -22963,6 +23591,7 @@ exports.NetworkError = NetworkError;
 exports.NeuroSymbolic = neuro_symbolic_exports;
 exports.NotFoundError = NotFoundError;
 exports.Ontology = ontology_exports;
+exports.Operations = operations_exports;
 exports.Optimize = optimize_exports;
 exports.Osfql = osfql_exports;
 exports.Oversight = oversight_exports;