@kortexya/reasoninglayer 1.0.1 → 1.2.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.0.1";
+var SDK_VERSION = "1.2.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
    *
@@ -7440,6 +7653,100 @@ var Scheduling = class {
   });
 };
 
+// src/api-spec/generated/FlowNetworks.ts
+var FlowNetworks = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name CloneFlowNetwork
+   * @summary Clone a flow network for what-if analysis.
+   * @request POST:/api/v1/flow-networks/{network_id}/clone
+   * @secure
+   */
+  cloneFlowNetwork = (networkId, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks/${networkId}/clone`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name CommitFlowNetwork
+   * @summary Commit structural mutations (capacity updates and/or new edges).
+   * @request POST:/api/v1/flow-networks/{network_id}/commit
+   * @secure
+   */
+  commitFlowNetwork = (networkId, data, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks/${networkId}/commit`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name CreateFlowNetwork
+   * @summary Create a new flow network.
+   * @request POST:/api/v1/flow-networks
+   * @secure
+   */
+  createFlowNetwork = (data, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name GetFlowNetwork
+   * @summary Get a flow network's status.
+   * @request GET:/api/v1/flow-networks/{network_id}
+   * @secure
+   */
+  getFlowNetwork = (networkId, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks/${networkId}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags flow-networks
+   * @name SolveFlowNetwork
+   * @summary Solve a flow network with the chosen algorithm.
+   * @request POST:/api/v1/flow-networks/{network_id}/solve
+   * @secure
+   */
+  solveFlowNetwork = (networkId, data, params = {}) => this.http.request({
+    path: `/api/v1/flow-networks/${networkId}/solve`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
 // src/api-spec/generated/Admin.ts
 var Admin = class {
   http;
@@ -7745,6 +8052,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") {
@@ -20697,6 +21153,181 @@ var SchedulingClient = class {
   }
 };
 
+// src/normalizers/flow-networks.ts
+function EdgeSpecFromFrontToApi(edge) {
+  const dto = {
+    from: edge.from,
+    to: edge.to,
+    capacity: edge.capacity
+  };
+  if (edge.cost !== void 0 && edge.cost !== null) {
+    dto.cost = edge.cost;
+  }
+  if (edge.label !== void 0 && edge.label !== null) {
+    dto.label = edge.label;
+  }
+  return dto;
+}
+function EdgeCapacityUpdateFromFrontToApi(update) {
+  return { label: update.label, capacity: update.capacity };
+}
+function CreateFlowNetworkRequestFromFrontToApi(request) {
+  const dto = {
+    nodes: request.nodes,
+    source: request.source,
+    sink: request.sink,
+    edges: request.edges.map(EdgeSpecFromFrontToApi)
+  };
+  if (request.description !== void 0 && request.description !== null) {
+    dto.description = request.description;
+  }
+  return dto;
+}
+function CommitFlowNetworkRequestFromFrontToApi(request) {
+  const dto = {};
+  if (request.updateCapacities !== void 0) {
+    dto.update_capacities = request.updateCapacities.map(
+      EdgeCapacityUpdateFromFrontToApi
+    );
+  }
+  if (request.addEdges !== void 0) {
+    dto.add_edges = request.addEdges.map(EdgeSpecFromFrontToApi);
+  }
+  return dto;
+}
+function SolveFlowNetworkRequestFromFrontToApi(request) {
+  return { algorithm: request.algorithm };
+}
+function FlowNetworkResponseFromApiToFront(dto) {
+  return {
+    id: dto.id,
+    source: dto.source,
+    sink: dto.sink,
+    nodeCount: dto.node_count,
+    edgeCount: dto.edge_count,
+    description: dto.description ?? void 0
+  };
+}
+function EdgeFlowFromApiToFront(dto) {
+  return {
+    from: dto.from,
+    to: dto.to,
+    label: dto.label ?? void 0,
+    capacity: dto.capacity,
+    flow: dto.flow
+  };
+}
+function EdgeClassificationFromApiToFront(dto) {
+  return {
+    from: dto.from,
+    to: dto.to,
+    label: dto.label ?? void 0,
+    class: dto.class
+  };
+}
+function MinCutFromApiToFront(dto) {
+  return {
+    sourceSide: dto.source_side,
+    sinkSide: dto.sink_side,
+    cutEdges: dto.cut_edges.map(EdgeFlowFromApiToFront)
+  };
+}
+function SolveFlowNetworkResponseFromApiToFront(dto) {
+  const wireClassifications = dto.classifications;
+  return {
+    algorithm: dto.algorithm,
+    edgeFlows: dto.edge_flows.map(EdgeFlowFromApiToFront),
+    totalFlow: dto.total_flow ?? void 0,
+    totalCost: dto.total_cost ?? void 0,
+    classifications: wireClassifications ? wireClassifications.map(EdgeClassificationFromApiToFront) : void 0,
+    minCut: dto.min_cut ? MinCutFromApiToFront(dto.min_cut) : void 0
+  };
+}
+
+// src/resources/flow-networks.ts
+var FlowNetworksClient = class {
+  /** @internal */
+  api;
+  /** @internal */
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Create and persist a new flow network.
+   *
+   * @param request - graph shape, source/sink, and initial edges.
+   * @returns metadata for the new network (including its id).
+   * @throws HTTP 400 if the input is malformed (duplicate node names,
+   *   source/sink not in `nodes`, edges referencing unknown nodes,
+   *   negative capacities, duplicate edge labels).
+   */
+  async create(request) {
+    const response = await this.api.createFlowNetwork(
+      CreateFlowNetworkRequestFromFrontToApi(request)
+    );
+    return FlowNetworkResponseFromApiToFront(response.data);
+  }
+  /**
+   * Fetch the current status snapshot of a flow network.
+   *
+   * @throws HTTP 404 if the id is unknown.
+   */
+  async get(networkId) {
+    const response = await this.api.getFlowNetwork(networkId);
+    return FlowNetworkResponseFromApiToFront(response.data);
+  }
+  /**
+   * Clone an existing flow network for what-if analysis.  The clone
+   * receives a new id and its own mutable graph; the original is
+   * unaffected.
+   *
+   * @throws HTTP 404 if the id is unknown.
+   */
+  async clone(networkId) {
+    const response = await this.api.cloneFlowNetwork(networkId);
+    return FlowNetworkResponseFromApiToFront(response.data);
+  }
+  /**
+   * Apply structural mutations to an existing network: replace
+   * capacities of labelled edges and/or append new edges.  Both
+   * fields on the request are optional; capacity updates apply
+   * before new edges are added.
+   *
+   * @throws HTTP 400 if a referenced label is unknown, an appended
+   *   edge references undeclared nodes, or capacities are negative.
+   * @throws HTTP 404 if the id is unknown.
+   */
+  async commit(networkId, request) {
+    const response = await this.api.commitFlowNetwork(
+      networkId,
+      CommitFlowNetworkRequestFromFrontToApi(request)
+    );
+    return FlowNetworkResponseFromApiToFront(response.data);
+  }
+  /**
+   * Run the chosen algorithm against the persisted network.
+   *
+   * @remarks
+   * The response shape narrows per algorithm:
+   *
+   * - `max_flow` — `totalFlow` + `edgeFlows`.
+   * - `min_cost_max_flow` — `totalFlow`, `totalCost`, `edgeFlows`.
+   * - `classify_edges` / `classify_edges_optimal` — `classifications`.
+   * - `min_cut` — `totalFlow`, `edgeFlows`, `minCut`.
+   *
+   * Fields irrelevant to the chosen algorithm are `undefined`.
+   *
+   * @throws HTTP 404 if the id is unknown.
+   */
+  async solve(networkId, request) {
+    const response = await this.api.solveFlowNetwork(
+      networkId,
+      SolveFlowNetworkRequestFromFrontToApi(request)
+    );
+    return SolveFlowNetworkResponseFromApiToFront(response.data);
+  }
+};
+
 // src/normalizers/osfql.ts
 function OsfqlResponseFromApiToFront(dto) {
   return {
@@ -21759,6 +22390,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. */
@@ -21849,6 +22717,8 @@ var ReasoningLayerClient = class {
   optimize;
   /** Scheduling feasibility via capacitated bipartite b-matching (staff rostering, assignment problems). */
   scheduling;
+  /** Generic flow-network resource: max-flow, min-cost max-flow, edge classification, min-cut over a persisted graph. */
+  flowNetworks;
   /** OSFQL execution operations. */
   osfql;
   /** Conversational AI operations (NL → OSFQL with self-correction). */
@@ -21861,6 +22731,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;
@@ -21924,11 +22798,12 @@ var ReasoningLayerClient = class {
       rlTraining: this.rlTraining
     };
   }
-  /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling. */
+  /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling, flow networks. */
   get reasoningOps() {
     return this._reasoning ??= {
       optimize: this.optimize,
       scheduling: this.scheduling,
+      flowNetworks: this.flowNetworks,
       ilp: this.ilp,
       cdl: this.cdl,
       execution: this.execution,
@@ -22084,6 +22959,7 @@ var ReasoningLayerClient = class {
     this.rag = new RagClient(generatedRag);
     this.optimize = new OptimizeClient(generatedInference, generatedSorts, generatedQuery, generatedTerms, resolved.tenantId);
     this.scheduling = new SchedulingClient(new Scheduling(generatedHttp));
+    this.flowNetworks = new FlowNetworksClient(new FlowNetworks(generatedHttp));
     this.osfql = new OsfqlClient(generatedOsfql);
     this.conversation = new ConversationClient(generatedHttp);
     this.research = new ResearchClient(generatedHttp);
@@ -22093,6 +22969,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));
   }
 };
 
@@ -22235,6 +23113,9 @@ __export(scheduling_exports, {
 });
 var ANY_ROLE = "any";
 
+// src/types/flow-networks.ts
+var flow_networks_exports = {};
+
 // src/types/ilp.ts
 var ilp_exports = {};
 
@@ -22247,6 +23128,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 +23823,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;
@@ -22943,6 +23831,7 @@ exports.Conversation = conversation_exports;
 exports.Discovery = discovery_exports;
 exports.Execution = execution_exports;
 exports.Extract = extract_exports;
+exports.FlowNetworks = flow_networks_exports;
 exports.ForbiddenError = ForbiddenError;
 exports.Functions = functions_exports;
 exports.Fuzzy = fuzzy_exports;
@@ -22963,6 +23852,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;