@kortexya/reasoninglayer 1.0.1 → 1.2.0

package/dist/index.d.cts

@@ -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.0.1";
+declare const SDK_VERSION = "1.2.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -605,6 +605,12 @@ interface AddPendingReviewResponse {
 }
 /** Request to add a rule (a term with antecedents). */
 interface AddRuleRequest$1 {
+    /**
+     * Optional engine-side aggregator declared on the rule head.
+     * When present, the rule's head term receives an `"aggregator"` feature
+     * containing a serialized `RuleAggregator` descriptor.
+     */
+    aggregator?: null | RuleAggregatorDto;
     /**
      * Antecedent terms (body of the rule)
      * These go into the `when` feature
@@ -801,6 +807,51 @@ interface AlignmentStatsDto {
      */
     entities_unaligned: number;
 }
+/** Request body for `POST /api/v1/operations/anti-unify`. */
+interface AntiUnifyRequest$1 {
+    /**
+     * First Ψ-term id; must already be registered in the tenant's
+     * term store.
+     * @format uuid
+     */
+    term1_id: string;
+    /**
+     * Second Ψ-term id; must already be registered in the tenant's
+     * term store.
+     * @format uuid
+     */
+    term2_id: string;
+}
+/**
+ * Response from anti-unification.
+ *
+ * The engine creates the LGG term inside the tenant's term store and
+ * returns its id; the full enriched [`TermDto`] is included so
+ * callers can inspect features and free variables in a single
+ * round-trip.
+ */
+interface AntiUnifyResponse$1 {
+    /**
+     * Computation time in milliseconds (engine + lock acquisition).
+     * @format int64
+     * @min 0
+     */
+    computation_time_ms: number;
+    /** Full enriched view of the LGG term (sort, features, references). */
+    lgg: TermDto$1;
+    /**
+     * Id of the newly-created LGG term.
+     * @format uuid
+     */
+    lgg_term_id: string;
+}
+interface AppendRequest$1 {
+    data_versions?: Record<string, string>;
+    extra?: Record<string, any>;
+    request_hash: string;
+    request_path: string;
+    response_hash: string;
+}
 /** Request to append residuations during unification */
 interface AppendResiduationsRequest$1 {
     session_id: string;
@@ -1131,6 +1182,30 @@ interface AttestationDto$1 {
     /** Human-readable verification description */
     verification_details: string;
 }
+/**
+ * One immutable, hash-chained audit record.
+ *
+ * Field order matters for hashing: serialisation is via `serde_json`
+ * with sorted keys, so insertion order is irrelevant — only the field
+ * *names* drive the canonical JSON layout.
+ */
+interface AuditRecord$1 {
+    actor?: null | UserId;
+    data_versions: Record<string, string>;
+    extra: Record<string, object>;
+    git_revision: string;
+    id: AuditRecordId;
+    prev_hash: string;
+    record_hash: string;
+    request_hash: string;
+    request_path: string;
+    response_hash: string;
+    tenant_id: TenantId;
+    /** @format date-time */
+    timestamp: string;
+}
+/** @format uuid */
+type AuditRecordId = string;
 /** An augmentation target identified by calibration. */
 interface AugmentationTargetDto$1 {
     /** Specific feature (if feature-level target). */
@@ -1155,6 +1230,24 @@ interface AugmentationTargetDto$1 {
     /** Sort name. */
     sort_name: string;
 }
+/** Trace entry for a single fired knowledge axiom. */
+interface AxiomFiringDto {
+    /**
+     * Combined antecedent truth (product t-norm over antecedent gates).
+     * @format double
+     */
+    antecedent_truth: number;
+    /**
+     * Reichenbach satisfaction `1 − a + a · c`.
+     * @format double
+     */
+    reichenbach_satisfaction: number;
+    /**
+     * The rule that fired.
+     * @format uuid
+     */
+    rule_id: string;
+}
 /** Request to backtrack to a marker or most recent choice point */
 interface BacktrackRequest {
     /**
@@ -1675,6 +1768,32 @@ interface BoundConstraintDto$1 {
     /** Target feature name that will be constrained */
     target: string;
 }
+/** Request: diff two MVCC branches of the tenant's term store. */
+interface BranchDiffRequest {
+    /** Source branch (the "before"). */
+    branch_a: string;
+    /** Target branch (the "after"). */
+    branch_b: string;
+    /**
+     * Cap the number of changed terms to render.
+     * @format int32
+     * @min 0
+     */
+    limit?: number;
+}
+interface BranchDiffResponse {
+    /** @min 0 */
+    added_count: number;
+    /** @min 0 */
+    changed_count: number;
+    /**
+     * `VisualizationGraph` with each node carrying
+     * `properties.diff = "added" | "removed" | "changed"`.
+     */
+    graph: VisualizationGraphDto$1;
+    /** @min 0 */
+    removed_count: number;
+}
 /** Request to broadcast a message to all agents. */
 interface BroadcastMessageRequest$1 {
     /** Message content (arbitrary JSON) */
@@ -2052,6 +2171,16 @@ interface CandidateMatchDto$1 {
      */
     term_id: string;
 }
+interface CaptureSnapshotRequest$1 {
+    /** @format date-time */
+    captured_after?: string | null;
+    /**
+     * @format int32
+     * @min 0
+     */
+    max_entries?: number | null;
+    request_path_pattern: string;
+}
 /** Request to check if one variable is a causal ancestor of another */
 interface CausalAncestorRequest$1 {
     /** The potential ancestor variable */
@@ -2496,6 +2625,19 @@ interface CollectionResponse {
     /** Collection DTO */
     collection: CollectionDto$1;
 }
+/**
+ * Request body for `POST /api/v1/flow-networks/{id}/commit` —
+ * structural mutations applied in a single atomic step.
+ */
+interface CommitFlowNetworkRequest$1 {
+    /**
+     * Edges to append.  Source/destination must reference declared
+     * nodes.
+     */
+    add_edges?: FlowEdgeDto[];
+    /** Capacity updates keyed by edge label. */
+    update_capacities?: EdgeCapacityUpdateDto[];
+}
 /** Request to commit to an alternative */
 interface CommitRequest$1 {
     /**
@@ -3155,6 +3297,44 @@ interface CopyTermResponse {
     copy_mode: CopyModeDto$1;
     original_term_id: string;
 }
+/**
+ * One coreference group — a target Ψ-term that appears as the value
+ * of multiple `(term, feature)` source-pairs in the rendered subgraph.
+ */
+interface CoreferenceGroupDto {
+    /**
+     * Distinguishes Aït-Kaci's strict coreference (Reference-typed
+     * feature pointing at the same Ψ-term across positions) from
+     * looser shared-value clustering (multiple terms ground to the
+     * same scalar/typed value). The strict variant satisfies the
+     * OSF identity ↤ relation; the loose variant is a useful
+     * dataviz signal but not strictly a variable in the OSF sense.
+     */
+    kind?: string;
+    /** All `(term, feature_name)` pairs that hold this reference. */
+    references: CoreferenceSourceDto[];
+    /**
+     * Visual tag (e.g. "X1", "X2") for this group — clients can label
+     * both ends of an identity edge with this string to mirror
+     * Aït-Kaci's `t1 ⊓ X = t2 ⊓ X` notation.
+     */
+    tag: string;
+    /**
+     * The shared target term id (the same Ψ-term every source points at).
+     * @format uuid
+     */
+    target_term_id: string;
+}
+/** One `(term, feature)` pair contributing to a coreference group. */
+interface CoreferenceSourceDto {
+    /** The feature name on that term whose value is the shared target. */
+    feature_name: string;
+    /**
+     * The Ψ-term that owns the feature.
+     * @format uuid
+     */
+    term_id: string;
+}
 /** Request to correct an entity before approval */
 interface CorrectEntityRequest$1 {
     /** Corrected features */
@@ -3329,6 +3509,22 @@ interface CreateExecutionSessionRequest$1 {
     /** @format uuid */
     tenant_id: string;
 }
+/** Request body for `POST /api/v1/flow-networks`. */
+interface CreateFlowNetworkRequest$1 {
+    /**
+     * Optional human-readable description.  Stored only as part of the
+     * response for inspection convenience.
+     */
+    description?: string | null;
+    /** Initial edges.  Order is preserved in inspection responses. */
+    edges: FlowEdgeDto[];
+    /** Node names.  Must be unique. */
+    nodes: string[];
+    /** Sink node name.  Must appear in `nodes`, distinct from `source`. */
+    sink: string;
+    /** Source node name.  Must appear in `nodes`. */
+    source: string;
+}
 /**
  * Request to create and persist a goal.
  *
@@ -3503,6 +3699,13 @@ interface CreateSortRequest$1 {
     name?: string;
     /** Parent sort IDs */
     parents?: string[];
+    /**
+     * Existential witnesses — proof obligations a term must discharge to
+     * belong to this sort. Each entry is a JSON `ExistentialWitness`
+     * (variables, constraints, certainty). When witness validation
+     * cannot conclude immediately the term is residuated.
+     */
+    witnesses?: object[];
 }
 /** Request to create a new computation space */
 interface CreateSpaceRequest$1 {
@@ -3528,6 +3731,16 @@ interface CreateStoreTermRequest$1 {
 interface CreateTermRequest$1 {
     /** Features map */
     features: Record<string, ValueDto$1>;
+    /**
+     * Optional client-supplied TermId. When present, the term is created
+     * with that id; if a term with that id already exists in the tenant,
+     * the handler returns 200 with the existing term instead of 409 —
+     * re-runs of an idempotent seed script become safe.
+     *
+     * When absent, the server allocates a fresh UUID.
+     * @format uuid
+     */
+    id?: string | null;
     /**
      * Owner ID
      * @format uuid
@@ -3941,6 +4154,59 @@ interface DereferenceResponse$1 {
     is_bound: boolean;
     original_id: string;
 }
+/**
+ * Request for the forward-chain derivation visualization.
+ *
+ * Runs the homoiconic forward chainer with provenance enabled, then
+ * emits a meta-hypergraph: one node per Ψ-term (input fact, rule, or
+ * derived fact); one hyperedge per rule application grouping
+ * (rule, antecedents..., produced_fact). Aggregate contributors are
+ * included on the same hyperedge when present.
+ */
+interface DerivationVisualizationRequest {
+    /**
+     * Restrict the rendered subgraph to the ancestors of these
+     * terms (transitive provenance closure). When empty, the full
+     * derivation lattice is returned.
+     */
+    focus_term_ids?: string[];
+    /**
+     * Whether to include aggregate-contributor edges on each step.
+     * Defaults to true.
+     */
+    include_aggregates?: boolean;
+    /**
+     * Cap on chainer iterations. Defaults to 100.
+     * @format int32
+     * @min 0
+     */
+    max_iterations?: number;
+}
+/** Response for derivation-lattice visualization. */
+interface DerivationVisualizationResponse {
+    /**
+     * Number of derived (non-input) facts in the trace.
+     * @min 0
+     */
+    derived_count: number;
+    /**
+     * Whether the chainer reached a fixpoint (true) or hit
+     * max_iterations (false).
+     */
+    fixpoint_reached: boolean;
+    /** The derivation graph (meta-hypergraph over Ψ-terms). */
+    graph: VisualizationGraphDto$1;
+    /**
+     * Number of forward-chainer iterations the trace covers.
+     * @min 0
+     */
+    iterations: number;
+    /**
+     * Number of distinct rule applications recorded.
+     * @min 0
+     */
+    rule_application_count: number;
+}
 /** Request for derived inference (Phase 4). */
 interface DerivedInferenceRequest$1 {
     /** Pairs of feature vectors for inference. */
@@ -4780,6 +5046,25 @@ interface DriveDto$1 {
     /** Drive type (curiosity, competence, social, autonomy) */
     drive_type: string;
 }
+/** Loss weighting (paper eq. 4) — `data_weight + knowledge_weight = 1.0`. */
+interface DualWeightedLossDto {
+    /**
+     * Weight on the data-axiom satisfaction.
+     * @format double
+     */
+    data_weight: number;
+    /**
+     * Weight on the knowledge-axiom satisfaction.
+     * @format double
+     */
+    knowledge_weight: number;
+    /**
+     * `p` parameter for the `pMeanError` aggregator.
+     * @format int32
+     * @min 0
+     */
+    p_aggregator: number;
+}
 /** Request for dynamic sort addition (Phase 6). */
 interface DynamicAddSortRequest$1 {
     /** Feature names associated with this sort. */
@@ -5009,8 +5294,37 @@ interface E2ETrainingResponse$1 {
     /** Whether E2E training was triggered successfully. */
     triggered: boolean;
 }
+/** Replace the capacity of a labelled edge. */
+interface EdgeCapacityUpdateDto {
+    /**
+     * New capacity (must be ≥ 0).
+     * @format int64
+     */
+    capacity: number;
+    /** Edge label declared at construction or via a prior commit. */
+    label: string;
+}
+/** Flow snapshot for a single forward edge. */
+interface EdgeFlowDto {
+    /**
+     * Original capacity.
+     * @format int64
+     */
+    capacity: number;
+    /**
+     * Flow currently routed through this edge in the solver's output.
+     * @format int64
+     */
+    flow: number;
+    /** Source node name. */
+    from: string;
+    /** Caller-supplied label, if any. */
+    label?: string | null;
+    /** Destination node name. */
+    to: string;
+}
 /** Edge type in the graph */
-type EdgeTypeDto$1 = "subtype" | "multiple_inheritance" | "glb_path" | "lub_path" | "constraint_dependency" | "propagation" | "feature" | "coreference" | "trigger_dependency" | "relation_source" | "relation_target" | {
+type EdgeTypeDto$1 = "subtype" | "multiple_inheritance" | "glb_path" | "lub_path" | "constraint_dependency" | "propagation" | "feature" | "coreference" | "trigger_dependency" | "relation_source" | "relation_target" | "identity" | "derivation" | {
     custom: string;
 };
 /** FuzzyNumber shape for effect prediction response */
@@ -5331,6 +5645,24 @@ interface EpisodeStatsResponse$1 {
      */
     total_episodes: number;
 }
+/** Per-epoch training metrics. */
+interface EpochMetricsDto {
+    /**
+     * `pMeanError` over the data-axiom satisfactions (`K_D`).
+     * @format double
+     */
+    data_satisfaction: number;
+    /**
+     * `pMeanError` over the knowledge-axiom satisfactions (`K_K`).
+     * @format double
+     */
+    knowledge_satisfaction: number;
+    /**
+     * Dual-weighted loss `1 − ( w_D · K_D + w_K · K_K )`.
+     * @format double
+     */
+    total_loss: number;
+}
 /** An equivalence class of sorts */
 interface EquivalenceClass {
     /**
@@ -6321,6 +6653,14 @@ interface FindBySortRequest$1 {
      * returned. Omit or pass an empty map to disable filtering.
      */
     filter?: object | null;
+    /**
+     * Optional cap on the number of returned terms. When set, the handler
+     * truncates the post-filter result list to this many terms. Useful for
+     * UI explain/combo paths that scan tens of evidence rows but never
+     * need the full thousands. Omit (or 0) for no cap.
+     * @min 0
+     */
+    limit?: number | null;
     /**
      * Sort ID to search for (takes precedence over sort_name)
      * @format uuid
@@ -6435,6 +6775,63 @@ interface FixSuggestionDto$1 {
     /** Type of fix (e.g., "add_fact", "modify_feature", "narrow_sort", "add_rule") */
     fix_type?: string | null;
 }
+/** Strategy chosen at solve time. */
+type FlowAlgorithmDto = {
+    kind: "max_flow";
+} | {
+    kind: "min_cost_max_flow";
+} | {
+    kind: "classify_edges";
+} | {
+    kind: "classify_edges_optimal";
+} | {
+    kind: "min_cut";
+};
+/** A single directed edge specification. */
+interface FlowEdgeDto {
+    /**
+     * Capacity (must be ≥ 0).
+     * @format int64
+     */
+    capacity: number;
+    /**
+     * Optional per-unit-flow cost.  Defaults to zero — pure max-flow
+     * algorithms ignore this field.
+     * @format int64
+     */
+    cost?: number | null;
+    /** Source node name. */
+    from: string;
+    /**
+     * Optional caller-supplied label.  Must be unique.  Used to
+     * reference the edge in `commit` requests and to identify it in
+     * solver output.
+     */
+    label?: string | null;
+    /** Destination node name. */
+    to: string;
+}
+/** Status snapshot returned by every endpoint that does not solve. */
+interface FlowNetworkResponse$1 {
+    /** Optional description echoed from the create request. */
+    description?: string | null;
+    /**
+     * Number of declared forward edges.
+     * @min 0
+     */
+    edge_count: number;
+    /** Stable identifier assigned at creation; clones receive a new id. */
+    id: string;
+    /**
+     * Number of declared nodes.
+     * @min 0
+     */
+    node_count: number;
+    /** Sink node name. */
+    sink: string;
+    /** Source node name. */
+    source: string;
+}
 /** Request for forall */
 interface ForallRequest$1 {
     /** Generator goal that produces solutions */
@@ -6701,6 +7098,33 @@ type FunctionValueDto$1 = {
 } | {
     type: "Uninstantiated";
 };
+/**
+ * Request: render the LIFE-function definitions in the tenant's
+ * term store.
+ */
+interface FunctionsVisualizationRequest {
+    /**
+     * Maximum number of functions to render.
+     * @format int32
+     * @min 0
+     */
+    limit?: number;
+    /** Optional: restrict to functions matching this name prefix. */
+    name_prefix?: string | null;
+}
+interface FunctionsVisualizationResponse {
+    /**
+     * Number of functions surfaced.
+     * @min 0
+     */
+    function_count: number;
+    /**
+     * Function definitions as a Ψ-term hyperedge graph: each
+     * function becomes a hyperedge whose corners are head + body
+     * + each equation, color-distinguished by role.
+     */
+    graph: VisualizationGraphDto$1;
+}
 /** Request for fuzzy merge operation */
 interface FuzzyMergeRequest$1 {
     /**
@@ -7875,6 +8299,64 @@ interface GoalSummaryDto$1 {
      */
     min_degree?: number | null;
 }
+/**
+ * Request: render the graded-poset structure of the tenant's sort
+ * hierarchy. Each sort becomes a poset element; dimension = depth
+ * from root (Top); coverings = parent→child relationships.
+ *
+ * Surfaces the boundary B(σ) and coboundary C(σ) sets per element
+ * as `properties.boundary` / `properties.coboundary` strings, plus
+ * emits 4-adjacency edges (lower / upper N↑/N↓) when requested.
+ */
+interface GradedPosetRequest {
+    /**
+     * Include lower 4-adjacency edges (N↓): pairs (σ₁, σ₂) ∈ B(σ)
+     * that share an element in B(σ₁) ∩ B(σ₂).
+     */
+    include_lower_adjacencies?: boolean;
+    /** Include upper 4-adjacency edges (N↑). */
+    include_upper_adjacencies?: boolean;
+    /**
+     * Maximum sort elements to return (0 = unlimited). Default 500.
+     * 4-adjacency on a 20k-sort hierarchy emits ~300k edges, which
+     * is too much for in-browser layout — paginate to keep the UI
+     * responsive.
+     * @min 0
+     */
+    limit?: number;
+    /**
+     * Skip this many sort elements (paired with `limit`).
+     * @min 0
+     */
+    offset?: number;
+}
+interface GradedPosetResponse {
+    /** @min 0 */
+    covering_count: number;
+    /** @min 0 */
+    element_count: number;
+    /**
+     * Poset rendering. Elements at dimension `n` get
+     * `level=n`. Coverings are subtype edges; 4-adjacency edges
+     * carry `edge_type=Custom("LowerAdjacency"|"UpperAdjacency")`.
+     */
+    graph: VisualizationGraphDto$1;
+    /** @min 0 */
+    limit?: number;
+    /**
+     * Maximum dimension in the poset.
+     * @min 0
+     */
+    max_dimension: number;
+    /** @min 0 */
+    offset?: number;
+    /**
+     * Pagination: total elements available before offset/limit
+     * applied. Drives "load next page" controls.
+     * @min 0
+     */
+    total_count?: number;
+}
 /** An edge connecting two nodes */
 interface GraphEdgeDto$1 {
     /** Color of the edge (hex string) */
@@ -7976,6 +8458,7 @@ interface GroundTruthEntry$1 {
      */
     term_id: string;
 }
+type GroundTruthStatus$1 = "Pending" | "Validated" | "Refuted" | "Unknown";
 /** Statistics for entity grounding (linking to external ontologies) */
 interface GroundingStatsDto$1 {
     /**
@@ -8094,7 +8577,7 @@ interface HyperedgeDto$1 {
     source_term_id?: string | null;
 }
 /** Hyperedge type */
-type HyperedgeTypeDto$1 = "term_features" | "constraint_variables" | "unification_result" | {
+type HyperedgeTypeDto$1 = "term_features" | "constraint_variables" | "unification_result" | "coreference_group" | "derivation_step" | "aggregate" | "negation" | "entailment" | "bound_constraint" | "multiple_inheritance" | "refraction" | "fuzzy_belt" | "meta_rule" | "learned_rule" | {
     custom: string;
 };
 /** Request for OSF term hypergraph visualization */
@@ -8103,7 +8586,21 @@ interface HypergraphRequest$1 {
     generate_dot?: boolean;
     /** Whether to include hyperedges */
     include_hyperedges?: boolean;
-    /** Whether to include relation Psi-terms as intermediate hypergraph nodes */
+    /**
+     * When `true`, run the tagged forward chainer (probabilistic
+     * semiring) on the visible subgraph and emit a per-term certainty
+     * tag in the response's `provenance_tags`. Default false because
+     * the chainer is O((n+m)·k) on rule count.
+     */
+    include_provenance?: boolean;
+    /**
+     * Whether to include relation Psi-terms as intermediate hypergraph nodes.
+     * Defaults to `true` — relation Ψ-terms (terms with source + target +
+     * relation_type) are a first-class part of the term graph, and omitting
+     * them by default leaves cross-entity links invisible to clients that
+     * don't know they have to ask. Pass `false` to skip the scan when only
+     * the per-term feature decomposition is needed.
+     */
     include_relations?: boolean;
     /**
      * Maximum depth to traverse
@@ -8126,10 +8623,31 @@ interface HypergraphRequest$1 {
 interface HypergraphResponse$1 {
     /** S-connected components (if s_threshold > 0) */
     components?: ComponentDto$1[];
+    /**
+     * Coreference groups: when multiple `(term, feature)` pairs point at
+     * the same target Ψ-term via Reference values, those references
+     * share an OSF-style tag (X). Aït-Kaci's Ψ-terms are graphs, not
+     * trees — a renderer that draws each Reference as an independent
+     * edge loses the identity. Each group is shipped with an auto-
+     * generated visual tag so the client can label both endpoints.
+     */
+    coreferences?: CoreferenceGroupDto[];
     /** Degree distribution */
     degree_distribution: DegreeDistributionDto$1;
     /** The visualization graph */
     graph: VisualizationGraphDto$1;
+    /**
+     * Provenance / certainty tag per visible Ψ-term, in `[0.0, 1.0]`.
+     *
+     * Encoded by the OSFKB `ProvenanceSemiring` — see
+     * `crates/domain/src/types/provenance_semiring.rs`. Values are
+     * best-effort: an asserted (root) fact yields `1.0`; a forward-
+     * chained fact yields the tagged-FC certainty if the request
+     * asks for it (`include_provenance: true`); otherwise defaults
+     * to `1.0`. Renderers are expected to map this to polygon fill
+     * opacity so audit-ability is visually obvious.
+     */
+    provenance_tags?: Record<string, number>;
     /** Statistics */
     stats: HypergraphStats$1;
 }
@@ -8828,6 +9346,13 @@ interface IngestionStatsDto$1 {
     /** Token usage from LLM API calls during this ingestion */
     token_usage?: TokenUsageDto$1;
 }
+/** Inline Ψ-term feature payload for a single prediction. */
+interface InlineInferenceTermDto {
+    /** Per-antecedent flat feature vectors. */
+    antecedent_features: Record<string, number[]>;
+    /** Temporal feature sequence for the conclusion gate. */
+    temporal_features: TemporalSequenceDto;
+}
 /** Outcome of an integrated cognitive cycle. */
 interface IntegratedCycleOutcomeDto$1 {
     /** Actions executed */
@@ -9211,6 +9736,15 @@ type KbChangeDto$1 = {
     term2: string;
     type: "Coreference";
 };
+/** One labelled training Ψ-term. */
+interface LabelledTermDto {
+    /** Per-antecedent flat feature vectors. */
+    antecedent_features: Record<string, number[]>;
+    /** Ground-truth label for the conclusion sort. */
+    label: MortalityLabelDto;
+    /** Temporal feature sequence for the conclusion gate. */
+    temporal_features: TemporalSequenceDto;
+}
 /** Statistics about the lattice */
 interface LatticeStats$1 {
     /**
@@ -9244,6 +9778,89 @@ interface LatticeStats$1 {
      */
     total_sorts: number;
 }
+/**
+ * Request for the viewport-tile lattice endpoint. Designed for
+ * million-scale rendering: the server pre-computes a stable global
+ * layout for the tenant once (per hierarchy snapshot), and clients
+ * fetch only the nodes whose (x, y) fall inside their viewport.
+ *
+ * The layout is deterministic: y = BFS level × level_spacing,
+ * x = hash(sort_id) % width within that level. Not paper-faithful,
+ * but produces stable coordinates that don't require a real force
+ * layout — usable on tenants where 1M nodes can't be laid out
+ * online.
+ */
+interface LatticeTileRequest {
+    /**
+     * When true, emit one synthetic Feature node per declared
+     * feature on each sort, with an edge from the sort to the
+     * feature. Lets clients render the "starburst" galaxy view
+     * where each sort is a center surrounded by feature spokes.
+     * Default false to preserve the millions-scale wire budget.
+     */
+    include_features?: boolean;
+    /**
+     * Max features per sort when `include_features` is true.
+     * Bounds bandwidth on densely-typed tenants (some sorts
+     * declare 80+ features). Default 32.
+     * @min 0
+     */
+    max_features_per_sort?: number;
+    /**
+     * Hard cap on emitted nodes — when the viewport contains more
+     * than this, the client should zoom in. Default 5000.
+     * @min 0
+     */
+    max_nodes?: number;
+    /** @format double */
+    max_x: number;
+    /** @format double */
+    max_y: number;
+    /**
+     * Viewport bounds in lattice coordinate space. Nodes outside
+     * these bounds are not emitted.
+     * @format double
+     */
+    min_x: number;
+    /** @format double */
+    min_y: number;
+    /**
+     * Optional zoom level (0 = whole graph, increasing = closer).
+     * At lower zooms we emit fewer edges (top-K by node degree)
+     * to keep responses tractable. Default 1.0.
+     * @format double
+     */
+    zoom?: number;
+}
+interface LatticeTileResponse {
+    /** @min 0 */
+    emitted_count: number;
+    /**
+     * Subgraph of the lattice within the viewport. Each node has
+     * `position.x`, `position.y` set so the client can place it
+     * directly without running a layout.
+     */
+    graph: VisualizationGraphDto$1;
+    /** @format double */
+    layout_max_x: number;
+    /** @format double */
+    layout_max_y: number;
+    /**
+     * Bounds of the full layout (so clients can compute "where am I?").
+     * @format double
+     */
+    layout_min_x: number;
+    /** @format double */
+    layout_min_y: number;
+    /** Was the response truncated by max_nodes? */
+    truncated: boolean;
+    /**
+     * Total nodes that fell in the viewport before max_nodes
+     * truncation — drives "zoom in to see all" affordance.
+     * @min 0
+     */
+    viewport_count: number;
+}
 /** Request for lattice (sort hierarchy) visualization */
 interface LatticeVisualizationRequest$1 {
     /** Whether to generate DOT output */
@@ -9254,12 +9871,24 @@ interface LatticeVisualizationRequest$1 {
     layout_algorithm?: LayoutAlgorithmDto$1;
     /** Layout direction preference */
     layout_direction?: LayoutDirectionDto$1;
+    /**
+     * Maximum sort elements to return (0 = unlimited). Default 500
+     * keeps heavy-hierarchy responses (20k+ sorts) tractable.
+     * Paginate by stepping `offset` if the full set is needed.
+     * @min 0
+     */
+    limit?: number;
     /**
      * Maximum depth to traverse (default: unlimited)
      * @format int32
      * @min 0
      */
     max_depth?: number | null;
+    /**
+     * Skip this many sort elements (paired with `limit`).
+     * @min 0
+     */
+    offset?: number;
     /**
      * Optional root sort ID to start from
      * @format uuid
@@ -9270,8 +9899,24 @@ interface LatticeVisualizationRequest$1 {
 interface LatticeVisualizationResponse$1 {
     /** The visualization graph */
     graph: VisualizationGraphDto$1;
+    /**
+     * Pagination: limit used (0 = unlimited).
+     * @min 0
+     */
+    limit?: number;
+    /**
+     * Pagination: offset used in this response.
+     * @min 0
+     */
+    offset?: number;
     /** Statistics about the lattice */
     stats: LatticeStats$1;
+    /**
+     * Pagination: total sorts available before offset/limit applied.
+     * Clients can use this to drive a "load next page" UI.
+     * @min 0
+     */
+    total_count?: number;
 }
 /** Per-layer verification result. */
 interface LayerResultDto$1 {
@@ -10660,6 +11305,18 @@ interface MetaSortsResponse$1 {
      */
     variable: string;
 }
+/** Min-cut partition output. */
+interface MinCutDto {
+    /**
+     * Cut edges (saturated forward edges crossing source-side →
+     * sink-side).  Their summed `capacity` equals the max flow value.
+     */
+    cut_edges: EdgeFlowDto[];
+    /** Names of nodes on the sink side of the cut. */
+    sink_side: string[];
+    /** Names of nodes on the source side of the cut. */
+    source_side: string[];
+}
 /** Information about what's missing from a query */
 interface MissingInfoDto$1 {
     /** Human-readable description */
@@ -10758,6 +11415,8 @@ interface MonadicFixpointResponse$1 {
      */
     max_depth: number;
 }
+/** Conclusion-side ground-truth label. */
+type MortalityLabelDto = "positive" | "negative";
 /** Full motivation state DTO combining drives, deficits, and curiosity. */
 interface MotivationStateDto$1 {
     /** Curiosity targets sorted by exploration priority */
@@ -10964,7 +11623,7 @@ interface NlQueryResultItem$1 {
     sort_name: string;
 }
 /** Node type in the graph */
-type NodeTypeDto$1 = "sort" | "synthetic_sort" | "root_sort" | "bottom_sort" | "constraint" | "fd_variable" | "term" | "feature" | "reference" | "residuated_term" | "trigger" | "relation" | {
+type NodeTypeDto$1 = "sort" | "synthetic_sort" | "root_sort" | "bottom_sort" | "constraint" | "fd_variable" | "term" | "feature" | "reference" | "residuated_term" | "trigger" | "relation" | "rule" | {
     custom: string;
 };
 /** Number format options */
@@ -11155,6 +11814,85 @@ interface OntologyRagStatsDto$1 {
     /** @min 0 */
     terms_unified: number;
 }
+/**
+ * Top-level orchestrator configuration DTO.
+ *
+ * Mirrors
+ * [`OrchestratorConfig`](osfkb_application::services::osf_neural_predicate_orchestrator::OrchestratorConfig)
+ * with API-friendly enum encodings.
+ */
+interface OrchestratorConfigDto {
+    /** Antecedent-sort gate bindings. */
+    antecedent_bindings: SortGateBindingDto[];
+    /** Conclusion-sort gate binding (typically `Temporal`). */
+    conclusion_binding: SortGateBindingDto;
+    /** Knowledge-axiom rule ids registered in the tenant's homoiconic KB. */
+    knowledge_axioms: string[];
+    /** Loss weighting and `pMean` aggregator hyperparameters. */
+    loss: DualWeightedLossDto;
+    /** Training-loop hyperparameters. */
+    training: TrainingHyperparametersDto;
+}
+/** Request body for `POST /api/v1/inference/orchestrator/configure`. */
+interface OrchestratorConfigureRequest {
+    /** The orchestrator configuration to register for the calling tenant. */
+    config: OrchestratorConfigDto;
+}
+/** Response for the configure endpoint. */
+interface OrchestratorConfigureResponse {
+    /**
+     * UUID for retrieving and using this config in subsequent train/predict
+     * calls.
+     * @format uuid
+     */
+    config_id: string;
+}
+/** Request body for `POST /api/v1/inference/orchestrator/predict`. */
+type OrchestratorPredictRequest = PredictTermDto & {
+    /**
+     * Identifier returned by the configure endpoint.
+     * @format uuid
+     */
+    config_id: string;
+};
+/** Response for the predict endpoint. */
+interface OrchestratorPredictResponse {
+    /** Per-axiom firing trace. */
+    axiom_trace: AxiomFiringDto[];
+    /**
+     * Conclusion-sort truth value τ(x ⊑ conclusion_sort).
+     * @format double
+     */
+    conclusion_probability: number;
+    /**
+     * Final fused confidence via noisy-OR over fired knowledge axioms.
+     * @format double
+     */
+    fused_confidence: number;
+}
+/** Request body for `POST /api/v1/inference/orchestrator/train`. */
+interface OrchestratorTrainRequest {
+    /**
+     * Identifier returned by the configure endpoint.
+     * @format uuid
+     */
+    config_id: string;
+    /**
+     * One or more labelled training Ψ-terms to consume in this call. Each
+     * call performs a single training epoch.
+     */
+    labelled_terms: LabelledTermDto[];
+}
+/** Response for the train endpoint. */
+interface OrchestratorTrainResponse {
+    /**
+     * Whether training stopped early (always `false` when only one epoch is
+     * run per call; reserved for future multi-epoch extensions).
+     */
+    early_stopped: boolean;
+    /** One entry per training epoch executed in this call. */
+    epochs: EpochMetricsDto[];
+}
 /**
  * Request for pure OSF search
  *
@@ -11806,6 +12544,37 @@ interface PredictPreferencesRequest$1 {
 interface PredictPreferencesResponse$1 {
     predictions: PreferencePrediction$1[];
 }
+/**
+ * Inference Ψ-term — either inline features or a reference to a persisted
+ * term id (reserved for future use; currently inline-only).
+ */
+type PredictTermDto = InlineInferenceTermDto;
+interface PredictionEntry$1 {
+    /**
+     * Verdict at capture time. Always `Pending` for newly captured
+     * snapshots.
+     */
+    captured_status: GroundTruthStatus$1;
+    id: PredictionEntryId;
+    request_hash: string;
+    /**
+     * Domain-shaped opaque payload (e.g. `{"drug": "...", "disease": "...", "score": 0.87}`).
+     * The engine does NOT interpret this — only the consumer's
+     * `GroundTruthProviderPort` does.
+     */
+    response_summary: object;
+    /** Back-pointer into the audit ledger this prediction was captured from. */
+    source_record_id: AuditRecordId;
+    /** @format date-time */
+    validated_at?: string | null;
+    /**
+     * Verdict after the most recent `validate()` call. `None` until
+     * validation has run.
+     */
+    validated_status?: null | GroundTruthStatus$1;
+}
+/** @format uuid */
+type PredictionEntryId = string;
 /** Prediction error DTO. */
 interface PredictionErrorDto$1 {
     /** Actual outcome */
@@ -11825,6 +12594,16 @@ interface PredictionErrorDto$1 {
     /** Predicted outcome */
     predicted: string;
 }
+interface PredictionSnapshot$1 {
+    /** @format date-time */
+    captured_at: string;
+    entries: PredictionEntry$1[];
+    filter: SnapshotFilter$1;
+    id: PredictionSnapshotId;
+    tenant_id: TenantId;
+}
+/** @format uuid */
+type PredictionSnapshotId = string;
 /** A user preference. */
 interface PreferenceDto$1 {
     /**
@@ -13584,6 +14363,25 @@ interface RowUnifyResponse$1 {
     /** Unified row type (if successful) */
     unified?: null | RowTypeDto$1;
 }
+/**
+ * Rule aggregator descriptor for engine-side aggregation on rule heads.
+ *
+ * When present, the engine aggregates multiple proofs of the same rule
+ * that share the same `group_by` feature values, applying `op` to the
+ * `target` feature. This eliminates run-to-run variance from proof-order
+ * sensitivity and makes `max_solutions` cap unique groups, not raw proofs.
+ */
+interface RuleAggregatorDto {
+    /**
+     * Feature names that define the aggregation group key.
+     * Proofs with identical values for all `group_by` features are merged.
+     */
+    group_by: string[];
+    /** Aggregation operator: "sum", "max", "min", "count", or "first". */
+    op: string;
+    /** Feature name whose value is aggregated within each group. */
+    target: string;
+}
 /** A rule clause (OSF clause) */
 interface RuleClauseDto$1 {
     /** Constraints on variables in this clause */
@@ -14214,6 +15012,21 @@ interface SingleCopyRequest$1 {
     copy_mode: CopyModeDto$1;
     term_id: string;
 }
+interface SnapshotFilter$1 {
+    /** @format date-time */
+    captured_after?: string | null;
+    /**
+     * @format int32
+     * @min 0
+     */
+    max_entries?: number | null;
+    /**
+     * Glob-style pattern matched against `AuditRecord::request_path`.
+     * Required — without it the snapshot would capture the entire
+     * ledger, which is rarely useful.
+     */
+    request_path_pattern: string;
+}
 /** Request for soft unification (Phase 2). */
 interface SoftUnifyRequest$1 {
     /**
@@ -14283,6 +15096,35 @@ interface SolveConstraintResponse$1 {
     success: boolean;
     suspended_constraints: string[];
 }
+/** Request body for `POST /api/v1/flow-networks/{id}/solve`. */
+interface SolveFlowNetworkRequest$1 {
+    /** Algorithm to dispatch. */
+    algorithm: FlowAlgorithmDto;
+}
+/**
+ * Solver output.  Fields irrelevant to the chosen algorithm are
+ * omitted via `skip_serializing_if`.
+ */
+interface SolveFlowNetworkResponse$1 {
+    /** Echo of the algorithm dispatched. */
+    algorithm: FlowAlgorithmDto;
+    /** Per-edge classification (classify_* algorithms only). */
+    classifications?: any[] | null;
+    /** Per-edge flow snapshot. */
+    edge_flows: EdgeFlowDto[];
+    /** Min-cut partition (min_cut algorithm only). */
+    min_cut?: null | MinCutDto;
+    /**
+     * Total cost of the realised flow (mcmf only).
+     * @format int64
+     */
+    total_cost?: number | null;
+    /**
+     * Total flow source → sink (max-flow / mcmf / min-cut).
+     * @format int64
+     */
+    total_flow?: number | null;
+}
 /** Response with ancestor sorts */
 interface SortAncestorsResponse {
     ancestors: SortInfoDto$1[];
@@ -14507,6 +15349,21 @@ interface SortDto$1 {
      */
     tenant_id: string;
 }
+/** Binding between a sort and the gate that scores its subsumption. */
+interface SortGateBindingDto {
+    /**
+     * Architecture flavour (selects which port the orchestrator dispatches
+     * to).
+     */
+    architecture: SubsumptionArchitectureDto;
+    /**
+     * Sort whose subsumption truth the gate scores.
+     * @format uuid
+     */
+    sort_id: string;
+    /** Optional weak anchor (only meaningful for `ResiduationMlp`). */
+    weak_anchor?: null | ThresholdAnchorDto;
+}
 /** Basic sort information */
 interface SortInfoDto$1 {
     id: string;
@@ -14537,6 +15394,71 @@ interface SortListResponse$1 {
      */
     total?: number;
 }
+/**
+ * Request for the focus-based "neighborhood" view of the sort
+ * hierarchy. Designed to scale to tenants with millions of sorts —
+ * instead of trying to display the entire lattice, the client picks
+ * a focus sort and asks for its N-hop neighborhood, capped at
+ * `max_nodes` so the wire payload and renderer load are bounded.
+ *
+ * Edges to nodes outside the returned set are kept (so accumulating
+ * successive neighborhoods stitches the global graph) but with the
+ * off-set endpoint represented by its UUID-derived id.
+ */
+interface SortNeighborhoodRequest {
+    /**
+     * Maximum hop distance (BFS depth). Default 2.
+     * @format int32
+     * @min 0
+     */
+    hops?: number;
+    /**
+     * Whether to include both ancestors (parents) AND descendants
+     * (children). Default true.
+     */
+    include_ancestors?: boolean;
+    include_descendants?: boolean;
+    /**
+     * When true, also emit 4-adjacency siblings of the focus
+     * (sorts sharing a common parent or child). Default false.
+     */
+    include_siblings?: boolean;
+    /**
+     * Hard cap on returned nodes. When BFS exceeds this, the
+     * expansion stops and the closest `max_nodes` are emitted.
+     * Default 5000 — keeps the client renderer responsive.
+     * @min 0
+     */
+    max_nodes?: number;
+    /**
+     * Focus sort. The neighborhood is centred here.
+     * @format uuid
+     */
+    sort_id: string;
+}
+interface SortNeighborhoodResponse {
+    /**
+     * Number of nodes actually returned.
+     * @min 0
+     */
+    emitted_count: number;
+    /**
+     * Subgraph centred on the focus sort. The focus node has
+     * `properties.role = "focus"`; ancestors carry `role = "ancestor"`,
+     * descendants `role = "descendant"`, siblings `role = "sibling"`.
+     * `level` on each node is the signed hop distance from focus
+     * (positive = descendant, negative = ancestor).
+     */
+    graph: VisualizationGraphDto$1;
+    /**
+     * Total number of sorts within `hops` of focus before
+     * truncation — clients can use this to surface "showing N of M".
+     * @min 0
+     */
+    reachable_count: number;
+    /** Was the BFS truncated by `max_nodes`? */
+    truncated: boolean;
+}
 /** API representation of sort origin/provenance */
 type SortOriginDto$1 = {
     /** @format uuid */
@@ -15240,6 +16162,53 @@ interface SubstringRequest$1 {
 interface SubstringResponse {
     result: string;
 }
+/**
+ * Architecture choice for a single sort-subsumption gate.
+ *
+ * Tagged on a `kind` discriminator to keep the OpenAPI schema flat.
+ */
+type SubsumptionArchitectureDto = {
+    /**
+     * Hidden layer width.
+     * @min 0
+     */
+    hidden_dim: number;
+    /**
+     * Input feature dimension.
+     * @min 0
+     */
+    input_dim: number;
+    kind: "residuation_mlp";
+} | {
+    /**
+     * Hidden state width per LSTM direction.
+     * @min 0
+     */
+    hidden_dim: number;
+    /**
+     * Per-timestep feature dimension.
+     * @min 0
+     */
+    input_dim: number;
+    kind: "temporal";
+    /**
+     * Number of stacked BiLSTM layers.
+     * @min 0
+     */
+    n_lstm_layers: number;
+};
+interface SummaryResponse$1 {
+    /**
+     * @format int64
+     * @min 0
+     */
+    n_records: number;
+    per_actor: Record<string, number>;
+    per_request_path: Record<string, number>;
+    tenant_id: string;
+    ts_first?: string | null;
+    ts_last?: string | null;
+}
 /** Information about a suspended (incomplete) query */
 interface SuspendedQueryDto$1 {
     /**
@@ -15539,6 +16508,23 @@ interface TemporalPlanResponse$1 {
     /** Selected term IDs in temporal order */
     selected_term_ids: string[];
 }
+/** Variable-length temporal feature sequence in row-major form. */
+interface TemporalSequenceDto {
+    /** Row-major buffer of length `seq_len * input_dim`. */
+    data: number[];
+    /**
+     * Per-timestep feature dimension.
+     * @min 0
+     */
+    input_dim: number;
+    /**
+     * Number of timesteps.
+     * @min 0
+     */
+    seq_len: number;
+}
+/** @format uuid */
+type TenantId = string;
 /** Information about a single tenant in the system. */
 interface TenantInfo {
     /**
@@ -15617,6 +16603,23 @@ type TermInputDto$1 = {
     features?: Record<string, FeatureInputValueDto$1>;
     sort_name: string;
 };
+/**
+ * Request for paginated raw term listing. Parallel to the lattice
+ * pagination endpoint but for Ψ-terms — gives clients a default-fast
+ * "show me terms" view that bypasses the in-memory term store.
+ */
+interface TermListRequest {
+    /**
+     * Page size. Default 500.
+     * @min 0
+     */
+    limit?: number;
+    /**
+     * Page offset.
+     * @min 0
+     */
+    offset?: number;
+}
 /** Response for term list operations */
 interface TermListResponse$1 {
     /**
@@ -15649,7 +16652,7 @@ interface TermResponse$1 {
     witness_proofs?: WitnessProofDto$1[];
 }
 /** Term completion state (Hassan's LIFE semantics) */
-type TermState$1 = "complete" | "residuated" | "no_witnesses";
+type TermState$1 = "complete" | "residuated" | "failed" | "no_witnesses";
 /** Response with term store session info */
 interface TermStoreSessionResponse$1 {
     session_id: string;
@@ -15665,6 +16668,29 @@ interface TermTranslationDto {
     copied_id: string;
     original_id: string;
 }
+/** Threshold-based weak anchor for an antecedent gate. */
+interface ThresholdAnchorDto {
+    /**
+     * Index into the gate's input feature vector that the threshold reads.
+     * @min 0
+     */
+    feature_index: number;
+    /**
+     * Synthetic samples drawn for pre-anchoring.
+     * @min 0
+     */
+    samples: number;
+    /**
+     * Pre-anchoring training steps.
+     * @min 0
+     */
+    steps: number;
+    /**
+     * Threshold value; samples ≥ threshold are anchor-labelled `true`.
+     * @format double
+     */
+    threshold: number;
+}
 /** Token usage from LLM API calls during ingestion */
 interface TokenUsageDto$1 {
     /**
@@ -15792,6 +16818,35 @@ interface TrainingExampleDto$1 {
     /** Data source (real, synthetic, negative). */
     source: string;
 }
+/** Training-loop hyperparameters. */
+interface TrainingHyperparametersDto {
+    /**
+     * Mini-batch size.
+     * @min 0
+     */
+    batch_size: number;
+    /**
+     * Early-stopping patience.
+     * @min 0
+     */
+    early_stopping_patience: number;
+    /**
+     * Total training epochs.
+     * @min 0
+     */
+    epochs: number;
+    /**
+     * AdamW learning rate.
+     * @format double
+     */
+    learning_rate: number;
+    /**
+     * PRNG seed for deterministic batch construction.
+     * @format int64
+     * @min 0
+     */
+    seed?: number;
+}
 /** Response for training trigger endpoints. */
 interface TrainingTriggerResponse$1 {
     /** Error message if training failed to trigger. */
@@ -16328,6 +17383,8 @@ interface UpdateVisibilityRequest$1 {
     /** New visibility level */
     visibility: VisibilityDto$1;
 }
+/** @format uuid */
+type UserId = string;
 /**
  * Request for witness-validated term creation
  *
@@ -16413,6 +17470,37 @@ interface ValidatedUnifyResponse$1 {
     /** Witnesses satisfied during unification */
     witnesses_satisfied: WitnessInstantiationDto$1[];
 }
+interface ValidationReportDto$1 {
+    completed_at: string;
+    /**
+     * @format int64
+     * @min 0
+     */
+    n_pending: number;
+    /**
+     * @format int64
+     * @min 0
+     */
+    n_refuted: number;
+    /**
+     * @format int64
+     * @min 0
+     */
+    n_total: number;
+    /**
+     * @format int64
+     * @min 0
+     */
+    n_unknown: number;
+    /**
+     * @format int64
+     * @min 0
+     */
+    n_validated: number;
+    snapshot_id: string;
+    /** @format double */
+    validation_rate?: number | null;
+}
 /** DTO for validation rules (client-side validation from FeatureDescriptor constraints) */
 interface ValidationRuleDto$1 {
     /** Feature/field name this rule applies to */
@@ -16677,6 +17765,12 @@ interface VerifyFaithfulnessResponse$1 {
      */
     score: number;
 }
+interface VerifyResponse$1 {
+    /** @min 0 */
+    n_violations: number;
+    ok: boolean;
+    violations: any[];
+}
 /**
  * Request for OSF-aware round-trip faithfulness verification.
  *
@@ -18705,7 +19799,7 @@ declare class Terms<SecurityDataType = unknown> {
  * - `"residuated"` — some witnesses are suspended (missing information)
  * - `"no_witnesses"` — the sort has no witness requirements
  */
-type TermState = 'complete' | 'residuated' | 'no_witnesses';
+type TermState = 'complete' | 'residuated' | 'failed' | 'no_witnesses';
 /**
  * Proof that a term satisfies a type witness.
  *
@@ -19741,6 +20835,16 @@ declare class Inference<SecurityDataType = unknown> {
      * @secure
      */
     clearFacts: (tenantId: string, params?: RequestParams) => Promise<HttpResponse<ClearFactsResponse$1, any>>;
+    /**
+     * @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: OrchestratorConfigureRequest, params?: RequestParams) => Promise<HttpResponse<OrchestratorConfigureResponse, void>>;
     /**
      * @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.
      *
@@ -19844,6 +20948,26 @@ declare class Inference<SecurityDataType = unknown> {
      * @secure
      */
     nafProve: (data: NafProveRequest$1, params?: RequestParams) => Promise<HttpResponse<BackwardChainResponse$1, any>>;
+    /**
+     * @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: OrchestratorPredictRequest, params?: RequestParams) => Promise<HttpResponse<OrchestratorPredictResponse, void>>;
+    /**
+     * @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: OrchestratorTrainRequest, params?: RequestParams) => Promise<HttpResponse<OrchestratorTrainResponse, void>>;
 }
 
 /**
@@ -23723,7 +24847,7 @@ type ResiduationStateFilter = 'pending' | 'suspended' | 'ready' | 'completed' |
  * @remarks
  * Can be a predefined node type or a custom type name.
  */
-type NodeTypeDto = 'sort' | 'synthetic_sort' | 'root_sort' | 'bottom_sort' | 'constraint' | 'fd_variable' | 'term' | 'feature' | 'reference' | 'residuated_term' | 'trigger' | 'relation' | {
+type NodeTypeDto = 'sort' | 'synthetic_sort' | 'root_sort' | 'bottom_sort' | 'constraint' | 'fd_variable' | 'term' | 'feature' | 'reference' | 'residuated_term' | 'trigger' | 'relation' | 'rule' | {
     custom: string;
 };
 /**
@@ -23732,7 +24856,7 @@ type NodeTypeDto = 'sort' | 'synthetic_sort' | 'root_sort' | 'bottom_sort' | 'co
  * @remarks
  * Can be a predefined edge type or a custom type name.
  */
-type EdgeTypeDto = 'subtype' | 'multiple_inheritance' | 'glb_path' | 'lub_path' | 'constraint_dependency' | 'propagation' | 'feature' | 'coreference' | 'trigger_dependency' | 'relation_source' | 'relation_target' | {
+type EdgeTypeDto = 'subtype' | 'multiple_inheritance' | 'glb_path' | 'lub_path' | 'constraint_dependency' | 'propagation' | 'feature' | 'coreference' | 'trigger_dependency' | 'relation_source' | 'relation_target' | 'identity' | 'derivation' | {
     custom: string;
 };
 /**
@@ -23741,7 +24865,7 @@ type EdgeTypeDto = 'subtype' | 'multiple_inheritance' | 'glb_path' | 'lub_path'
  * @remarks
  * Can be a predefined hyperedge type or a custom type name.
  */
-type HyperedgeTypeDto = 'term_features' | 'constraint_variables' | 'unification_result' | {
+type HyperedgeTypeDto = 'term_features' | 'constraint_variables' | 'unification_result' | 'coreference_group' | 'derivation_step' | 'aggregate' | 'negation' | 'entailment' | 'bound_constraint' | 'multiple_inheritance' | 'refraction' | 'fuzzy_belt' | 'meta_rule' | 'learned_rule' | {
     custom: string;
 };
 /**
@@ -28684,6 +29808,16 @@ declare class ReviewsClient {
 declare class Visualization<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * @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: BranchDiffRequest, params?: RequestParams) => Promise<HttpResponse<BranchDiffResponse, any>>;
     /**
      * No description
      *
@@ -28694,6 +29828,46 @@ declare class Visualization<SecurityDataType = unknown> {
      * @secure
      */
     getConstraintGraph: (data: ConstraintGraphRequest$1, params?: RequestParams) => Promise<HttpResponse<ConstraintGraphResponse$1, any>>;
+    /**
+     * @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?: RequestParams) => Promise<HttpResponse<void, any>>;
+    /**
+     * @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: DerivationVisualizationRequest, params?: RequestParams) => Promise<HttpResponse<DerivationVisualizationResponse, any>>;
+    /**
+     * 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: FunctionsVisualizationRequest, params?: RequestParams) => Promise<HttpResponse<FunctionsVisualizationResponse, any>>;
+    /**
+     * 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: GradedPosetRequest, params?: RequestParams) => Promise<HttpResponse<GradedPosetResponse, any>>;
     /**
      * No description
      *
@@ -28714,6 +29888,16 @@ declare class Visualization<SecurityDataType = unknown> {
      * @secure
      */
     getLatticeDot: (params?: RequestParams) => Promise<HttpResponse<void, any>>;
+    /**
+     * @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: LatticeTileRequest, params?: RequestParams) => Promise<HttpResponse<LatticeTileResponse, any>>;
     /**
      * @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.
      *
@@ -28734,6 +29918,26 @@ declare class Visualization<SecurityDataType = unknown> {
      * @secure
      */
     getResiduationState: (data: ResiduationStateRequest$1, params?: RequestParams) => Promise<HttpResponse<ResiduationStateResponse$1, any>>;
+    /**
+     * @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: SortNeighborhoodRequest, params?: RequestParams) => Promise<HttpResponse<SortNeighborhoodResponse, any>>;
+    /**
+     * 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: TermListRequest, params?: RequestParams) => Promise<HttpResponse<TermListResponse$1, any>>;
     /**
      * No description
      *
@@ -28754,6 +29958,16 @@ declare class Visualization<SecurityDataType = unknown> {
      * @secure
      */
     getTriggerDependencies: (data: TriggerDependencyRequest$1, params?: RequestParams) => Promise<HttpResponse<TriggerDependencyResponse$1, any>>;
+    /**
+     * @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: UnifyTermsRequest$1, params?: RequestParams) => Promise<HttpResponse<UnifyTermsResponse$1, any>>;
     /**
      * No description
      *
@@ -39819,6 +41033,362 @@ declare class SchedulingClient {
     optimize(request: SchedulingOptimizeRequest): Promise<SchedulingOptimizeResponse>;
 }
 
+declare class FlowNetworks<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * 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: string, params?: RequestParams) => Promise<HttpResponse<FlowNetworkResponse$1, void>>;
+    /**
+     * 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: string, data: CommitFlowNetworkRequest$1, params?: RequestParams) => Promise<HttpResponse<FlowNetworkResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags flow-networks
+     * @name CreateFlowNetwork
+     * @summary Create a new flow network.
+     * @request POST:/api/v1/flow-networks
+     * @secure
+     */
+    createFlowNetwork: (data: CreateFlowNetworkRequest$1, params?: RequestParams) => Promise<HttpResponse<FlowNetworkResponse$1, void>>;
+    /**
+     * 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: string, params?: RequestParams) => Promise<HttpResponse<FlowNetworkResponse$1, void>>;
+    /**
+     * 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: string, data: SolveFlowNetworkRequest$1, params?: RequestParams) => Promise<HttpResponse<SolveFlowNetworkResponse$1, void>>;
+}
+
+/**
+ * Strategy chosen at solve time.
+ *
+ * The flow network is algorithm-agnostic — the same persisted graph
+ * can be solved with different algorithms, and the response shape
+ * narrows the relevant fields per algorithm.
+ *
+ * - `"max_flow"` — Dinic's algorithm.  Returns `totalFlow` + per-edge flow.
+ * - `"min_cost_max_flow"` — Successive-shortest-path MCMF.  Returns
+ *   `totalFlow`, `totalCost`, per-edge flow.  Edges should carry `cost`.
+ * - `"classify_edges"` — Dulmage–Mendelsohn residual classification.
+ *   Returns per-edge `always_used` / `never_used` / `sometimes_used`.
+ * - `"classify_edges_optimal"` — As above, but only over **optimal**
+ *   (min-cost) max-flow solutions.
+ * - `"min_cut"` — Source-sink min cut.  Returns the cut partition and
+ *   the saturated cut edges.
+ */
+type FlowAlgorithm = {
+    kind: 'max_flow';
+} | {
+    kind: 'min_cost_max_flow';
+} | {
+    kind: 'classify_edges';
+} | {
+    kind: 'classify_edges_optimal';
+} | {
+    kind: 'min_cut';
+};
+/**
+ * A single directed edge in the flow network.
+ */
+interface EdgeSpec {
+    /** Source node name.  Must appear in the network's node list. */
+    from: string;
+    /** Destination node name.  Must appear in the network's node list. */
+    to: string;
+    /** Capacity (must be ≥ 0). */
+    capacity: number;
+    /**
+     * Optional per-unit-flow cost.  Defaults to zero — pure max-flow
+     * algorithms ignore this field.
+     */
+    cost?: number | null;
+    /**
+     * Optional caller-supplied label.  Must be unique across the
+     * network when present.  Used to reference the edge in commit
+     * requests and to identify it in solver output.
+     */
+    label?: string | null;
+}
+/**
+ * Input to {@link FlowNetworksClient.create}.
+ */
+interface CreateFlowNetworkRequest {
+    /** Node names.  Must be unique. */
+    nodes: string[];
+    /** Source node name.  Must appear in `nodes`. */
+    source: string;
+    /** Sink node name.  Must appear in `nodes`, distinct from `source`. */
+    sink: string;
+    /** Initial edges.  Order is preserved in inspection responses. */
+    edges: EdgeSpec[];
+    /**
+     * Optional human-readable description.  Stored only as part of the
+     * response for inspection convenience.
+     */
+    description?: string | null;
+}
+/**
+ * Status snapshot returned by every endpoint that does not solve
+ * (create, get, clone, commit).
+ */
+interface FlowNetworkResponse {
+    /** Stable identifier assigned at creation; clones receive a new id. */
+    id: string;
+    /** Source node name. */
+    source: string;
+    /** Sink node name. */
+    sink: string;
+    /** Number of declared nodes. */
+    nodeCount: number;
+    /** Number of declared forward edges. */
+    edgeCount: number;
+    /** Optional description echoed from the create request. */
+    description?: string | null;
+}
+/**
+ * Replace the capacity of a labelled edge.
+ */
+interface EdgeCapacityUpdate {
+    /** Edge label declared at construction or via a prior commit. */
+    label: string;
+    /** New capacity (must be ≥ 0). */
+    capacity: number;
+}
+/**
+ * Input to {@link FlowNetworksClient.commit}.
+ *
+ * @remarks
+ * Both fields are optional and may be supplied together.  Capacity
+ * updates apply before new edges are appended.
+ */
+interface CommitFlowNetworkRequest {
+    /** Capacity updates keyed by edge label. */
+    updateCapacities?: EdgeCapacityUpdate[];
+    /**
+     * Edges to append.  Source/destination must reference declared
+     * nodes.
+     */
+    addEdges?: EdgeSpec[];
+}
+/**
+ * Input to {@link FlowNetworksClient.solve}.
+ */
+interface SolveFlowNetworkRequest {
+    /** Algorithm to dispatch. */
+    algorithm: FlowAlgorithm;
+}
+/**
+ * Flow snapshot for a single forward edge.
+ */
+interface EdgeFlow {
+    /** Source node name. */
+    from: string;
+    /** Destination node name. */
+    to: string;
+    /** Caller-supplied label, if any. */
+    label?: string | null;
+    /** Original capacity. */
+    capacity: number;
+    /** Flow currently routed through this edge in the solver's output. */
+    flow: number;
+}
+/** Edge feasibility class. */
+type EdgeClass = 'always_used' | 'never_used' | 'sometimes_used';
+/**
+ * Per-edge classification produced by the `classify_edges` /
+ * `classify_edges_optimal` algorithms.
+ */
+interface EdgeClassification {
+    from: string;
+    to: string;
+    label?: string | null;
+    /** Class string: `"always_used"`, `"never_used"`, `"sometimes_used"`. */
+    class: EdgeClass;
+}
+/**
+ * Min-cut partition output (only populated when `algorithm.kind`
+ * is `"min_cut"`).
+ */
+interface MinCutReport {
+    /** Names of nodes on the source side of the cut. */
+    sourceSide: string[];
+    /** Names of nodes on the sink side of the cut. */
+    sinkSide: string[];
+    /**
+     * Cut edges (saturated forward edges crossing source-side →
+     * sink-side).  Their summed `capacity` equals the max flow value.
+     */
+    cutEdges: EdgeFlow[];
+}
+/**
+ * Solver output.  Fields irrelevant to the chosen algorithm are
+ * undefined (the backend omits them via `skip_serializing_if`).
+ */
+interface SolveFlowNetworkResponse {
+    /** Echo of the algorithm dispatched. */
+    algorithm: FlowAlgorithm;
+    /** Per-edge flow snapshot. */
+    edgeFlows: EdgeFlow[];
+    /** Total flow source → sink (max-flow / mcmf / min-cut). */
+    totalFlow?: number | null;
+    /** Total cost of the realised flow (mcmf only). */
+    totalCost?: number | null;
+    /** Per-edge classification (classify_* algorithms only). */
+    classifications?: EdgeClassification[] | null;
+    /** Min-cut partition (min_cut algorithm only). */
+    minCut?: MinCutReport | null;
+}
+
+type flowNetworks_CommitFlowNetworkRequest = CommitFlowNetworkRequest;
+type flowNetworks_CreateFlowNetworkRequest = CreateFlowNetworkRequest;
+type flowNetworks_EdgeCapacityUpdate = EdgeCapacityUpdate;
+type flowNetworks_EdgeClass = EdgeClass;
+type flowNetworks_EdgeClassification = EdgeClassification;
+type flowNetworks_EdgeFlow = EdgeFlow;
+type flowNetworks_EdgeSpec = EdgeSpec;
+type flowNetworks_FlowAlgorithm = FlowAlgorithm;
+type flowNetworks_FlowNetworkResponse = FlowNetworkResponse;
+type flowNetworks_MinCutReport = MinCutReport;
+type flowNetworks_SolveFlowNetworkRequest = SolveFlowNetworkRequest;
+type flowNetworks_SolveFlowNetworkResponse = SolveFlowNetworkResponse;
+declare namespace flowNetworks {
+  export type { flowNetworks_CommitFlowNetworkRequest as CommitFlowNetworkRequest, flowNetworks_CreateFlowNetworkRequest as CreateFlowNetworkRequest, flowNetworks_EdgeCapacityUpdate as EdgeCapacityUpdate, flowNetworks_EdgeClass as EdgeClass, flowNetworks_EdgeClassification as EdgeClassification, flowNetworks_EdgeFlow as EdgeFlow, flowNetworks_EdgeSpec as EdgeSpec, flowNetworks_FlowAlgorithm as FlowAlgorithm, flowNetworks_FlowNetworkResponse as FlowNetworkResponse, flowNetworks_MinCutReport as MinCutReport, flowNetworks_SolveFlowNetworkRequest as SolveFlowNetworkRequest, flowNetworks_SolveFlowNetworkResponse as SolveFlowNetworkResponse };
+}
+
+/**
+ * Resource client for the generic flow-network engine.
+ *
+ * @remarks
+ * The engine persists a directed capacitated graph under a stable id
+ * and dispatches a chosen algorithm (max-flow, min-cost max-flow,
+ * edge-classification, min-cut) over it.  Domain shapes (scheduling,
+ * transportation, …) become translators that build a
+ * {@link CreateFlowNetworkRequest}; the engine itself knows nothing
+ * about agents, days, or shifts.
+ *
+ * Lifecycle mirrors the `/spaces` resource: `create` → optional
+ * `clone` (for what-if branches) → optional `commit` (capacity tweaks
+ * / edge appends) → `solve`.
+ *
+ * @example Solve max-flow on a tiny network
+ * ```typescript
+ * const network = await client.flowNetworks.create({
+ *   nodes: ['s', 'a', 'b', 't'],
+ *   source: 's',
+ *   sink: 't',
+ *   edges: [
+ *     { from: 's', to: 'a', capacity: 3 },
+ *     { from: 's', to: 'b', capacity: 2 },
+ *     { from: 'a', to: 't', capacity: 2 },
+ *     { from: 'b', to: 't', capacity: 3 },
+ *   ],
+ * });
+ *
+ * const result = await client.flowNetworks.solve(network.id, {
+ *   algorithm: { kind: 'max_flow' },
+ * });
+ *
+ * console.log(result.totalFlow); // 4
+ * ```
+ *
+ * @example What-if branch via clone + commit
+ * ```typescript
+ * const branch = await client.flowNetworks.clone(network.id);
+ * await client.flowNetworks.commit(branch.id, {
+ *   updateCapacities: [{ label: 'edge-a-t', capacity: 5 }],
+ * });
+ * const result = await client.flowNetworks.solve(branch.id, {
+ *   algorithm: { kind: 'max_flow' },
+ * });
+ * ```
+ */
+declare class FlowNetworksClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: FlowNetworks);
+    /**
+     * 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).
+     */
+    create(request: CreateFlowNetworkRequest): Promise<FlowNetworkResponse>;
+    /**
+     * Fetch the current status snapshot of a flow network.
+     *
+     * @throws HTTP 404 if the id is unknown.
+     */
+    get(networkId: string): Promise<FlowNetworkResponse>;
+    /**
+     * 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.
+     */
+    clone(networkId: string): Promise<FlowNetworkResponse>;
+    /**
+     * 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.
+     */
+    commit(networkId: string, request: CommitFlowNetworkRequest): Promise<FlowNetworkResponse>;
+    /**
+     * 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.
+     */
+    solve(networkId: string, request: SolveFlowNetworkRequest): Promise<SolveFlowNetworkResponse>;
+}
+
 declare class Osfql<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
@@ -41392,6 +42962,442 @@ declare class UiClient {
     catalog(): Promise<UICatalogResponse>;
 }
 
+declare class Compliance<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name Append
+     * @summary `POST /api/v1/compliance/audit/append`
+     * @request POST:/api/v1/compliance/audit/append
+     * @secure
+     */
+    append: (data: AppendRequest$1, params?: RequestParams) => Promise<HttpResponse<AuditRecord$1, any>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name CaptureSnapshot
+     * @summary `POST /api/v1/predictions/snapshot`
+     * @request POST:/api/v1/predictions/snapshot
+     * @secure
+     */
+    captureSnapshot: (data: CaptureSnapshotRequest$1, params?: RequestParams) => Promise<HttpResponse<PredictionSnapshot$1, any>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name GetSnapshot
+     * @summary `GET /api/v1/predictions/snapshot/{id}`
+     * @request GET:/api/v1/predictions/snapshot/{id}
+     * @secure
+     */
+    getSnapshot: (id: string, params?: RequestParams) => Promise<HttpResponse<PredictionSnapshot$1, any>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name List
+     * @summary `GET /api/v1/compliance/audit/list`
+     * @request GET:/api/v1/compliance/audit/list
+     * @secure
+     */
+    list: (query?: {
+        /**
+         * @format int32
+         * @min 0
+         */
+        limit?: number | null;
+        request_path_pattern?: string | null;
+    }, params?: RequestParams) => Promise<HttpResponse<AuditRecord$1[], any>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name Summary
+     * @summary `GET /api/v1/compliance/audit/summary`
+     * @request GET:/api/v1/compliance/audit/summary
+     * @secure
+     */
+    summary: (params?: RequestParams) => Promise<HttpResponse<SummaryResponse$1, any>>;
+    /**
+     * @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: string, params?: RequestParams) => Promise<HttpResponse<ValidationReportDto$1, any>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name Verify
+     * @summary `GET /api/v1/compliance/audit/verify`
+     * @request GET:/api/v1/compliance/audit/verify
+     * @secure
+     */
+    verify: (params?: RequestParams) => Promise<HttpResponse<VerifyResponse$1, void>>;
+}
+
+/**
+ * Hash-chained audit ledger and prediction-snapshot validation —
+ * `/api/v1/compliance/*` and `/api/v1/predictions/*`.
+ *
+ * Every API call (or any explicitly logged event) becomes an append-
+ * only `AuditRecord` whose `record_hash` chains into the previous
+ * record's `prev_hash`.  Snapshots freeze a slice of the ledger
+ * matching a request-path glob and let an external validator
+ * mark each prediction `Validated` / `Refuted` / `Unknown`.
+ *
+ * @module
+ */
+/** Verdict of a prediction snapshot entry against ground truth. */
+type GroundTruthStatus = 'Pending' | 'Validated' | 'Refuted' | 'Unknown';
+/**
+ * Body for `POST /api/v1/compliance/audit/append` — record one event
+ * in the tenant's audit ledger.
+ */
+interface AppendRequest {
+    /** Hash of the request body (caller chooses the hashing scheme). */
+    requestHash: string;
+    /** Path of the request being audited (e.g. `/api/v1/inference/backward-chain`). */
+    requestPath: string;
+    /** Hash of the response body. */
+    responseHash: string;
+    /** Optional map of input-data versions in effect at request time. */
+    dataVersions?: Record<string, string>;
+    /** Optional bag of caller-defined metadata. */
+    extra?: Record<string, unknown>;
+}
+/** A single record in the tenant's hash-chained audit ledger. */
+interface AuditRecord {
+    /** Stable id of this record. */
+    id: string;
+    /** Tenant the record belongs to. */
+    tenantId: string;
+    /** Optional actor (user id) who triggered the request. */
+    actor?: string | null;
+    /** ISO-8601 timestamp at which the record was appended. */
+    timestamp: string;
+    /** Path of the audited request. */
+    requestPath: string;
+    /** Hash of the audited request body. */
+    requestHash: string;
+    /** Hash of the audited response body. */
+    responseHash: string;
+    /** Hash of the previous record (forms the chain). */
+    prevHash: string;
+    /** Hash of this record (computed from all other fields). */
+    recordHash: string;
+    /** Git revision of the engine that wrote this record. */
+    gitRevision: string;
+    /** Map of input-data versions in effect when the record was written. */
+    dataVersions: Record<string, string>;
+    /** Caller-defined metadata. */
+    extra: Record<string, unknown>;
+}
+/** Filter for `GET /api/v1/compliance/audit/list`. */
+interface ListAuditOptions {
+    /** Limit on the number of records returned. */
+    limit?: number;
+    /** Glob-style filter on `requestPath`. */
+    requestPathPattern?: string;
+}
+/**
+ * Response of `GET /api/v1/compliance/audit/summary` — top-line
+ * counts over the tenant's full ledger.
+ */
+interface SummaryResponse {
+    /** Number of records in the ledger. */
+    nRecords: number;
+    /** Counts grouped by actor id. */
+    perActor: Record<string, number>;
+    /** Counts grouped by request path. */
+    perRequestPath: Record<string, number>;
+    /** Tenant id (echoed back). */
+    tenantId: string;
+    /** ISO-8601 timestamp of the first record in the ledger. */
+    tsFirst?: string;
+    /** ISO-8601 timestamp of the last record. */
+    tsLast?: string;
+}
+/**
+ * Response of `GET /api/v1/compliance/audit/verify` — re-walks the
+ * hash chain and reports any breaks.
+ */
+interface VerifyResponse {
+    /** True iff the chain is intact. */
+    ok: boolean;
+    /** Number of detected violations. */
+    nViolations: number;
+    /** Raw violation entries (engine-defined shape). */
+    violations: unknown[];
+}
+/**
+ * Filter description that is persisted on each snapshot — mirrors the
+ * `CaptureSnapshotRequest` minus the request-side optionality
+ * (capture always records the resolved filter that was applied).
+ */
+interface SnapshotFilter {
+    /** Glob-style pattern on `AuditRecord.requestPath`. */
+    requestPathPattern: string;
+    /** Lower bound on `AuditRecord.timestamp`. */
+    capturedAfter?: string | null;
+    /** Optional cap on the number of entries. */
+    maxEntries?: number | null;
+}
+/** Body of `POST /api/v1/predictions/snapshot`. */
+interface CaptureSnapshotRequest {
+    /** Glob-style pattern that selects which audit records to freeze. */
+    requestPathPattern: string;
+    /** Lower bound on `AuditRecord.timestamp` (ISO-8601). */
+    capturedAfter?: string;
+    /** Cap on the number of frozen entries. */
+    maxEntries?: number;
+}
+/** A single prediction frozen into a snapshot, awaiting validation. */
+interface PredictionEntry {
+    /** Stable id of this entry within the snapshot. */
+    id: string;
+    /** Hash of the audited request body that produced the prediction. */
+    requestHash: string;
+    /** Domain-shaped opaque payload — the engine never interprets it. */
+    responseSummary: unknown;
+    /** Back-pointer to the audit record this entry was derived from. */
+    sourceRecordId: string;
+    /** Verdict at capture time — always `Pending`. */
+    capturedStatus: GroundTruthStatus;
+    /** Verdict after the most recent validation pass; `null` until run. */
+    validatedStatus?: GroundTruthStatus | null;
+    /** ISO-8601 timestamp of the most recent validation pass. */
+    validatedAt?: string | null;
+}
+/** A frozen slice of the audit ledger — the unit of validation. */
+interface PredictionSnapshot {
+    /** Stable id of the snapshot. */
+    id: string;
+    /** Tenant the snapshot belongs to. */
+    tenantId: string;
+    /** ISO-8601 timestamp at which the snapshot was captured. */
+    capturedAt: string;
+    /** Filter that defined which audit records made it in. */
+    filter: SnapshotFilter;
+    /** Prediction entries the snapshot froze. */
+    entries: PredictionEntry[];
+}
+/** Result of a `validate-stub` pass over a snapshot. */
+interface ValidationReportDto {
+    /** Snapshot the report applies to. */
+    snapshotId: string;
+    /** ISO-8601 timestamp of the validation pass. */
+    completedAt: string;
+    /** Total entries considered. */
+    nTotal: number;
+    /** Entries verdict-`Pending`. */
+    nPending: number;
+    /** Entries verdict-`Validated`. */
+    nValidated: number;
+    /** Entries verdict-`Refuted`. */
+    nRefuted: number;
+    /** Entries whose ground truth couldn't be resolved. */
+    nUnknown: number;
+    /** Validated / non-pending ratio (null when no non-pending entries). */
+    validationRate?: number | null;
+}
+
+type compliance_AppendRequest = AppendRequest;
+type compliance_AuditRecord = AuditRecord;
+type compliance_CaptureSnapshotRequest = CaptureSnapshotRequest;
+type compliance_GroundTruthStatus = GroundTruthStatus;
+type compliance_ListAuditOptions = ListAuditOptions;
+type compliance_PredictionEntry = PredictionEntry;
+type compliance_PredictionSnapshot = PredictionSnapshot;
+type compliance_SnapshotFilter = SnapshotFilter;
+type compliance_SummaryResponse = SummaryResponse;
+type compliance_ValidationReportDto = ValidationReportDto;
+type compliance_VerifyResponse = VerifyResponse;
+declare namespace compliance {
+  export type { compliance_AppendRequest as AppendRequest, compliance_AuditRecord as AuditRecord, compliance_CaptureSnapshotRequest as CaptureSnapshotRequest, compliance_GroundTruthStatus as GroundTruthStatus, compliance_ListAuditOptions as ListAuditOptions, compliance_PredictionEntry as PredictionEntry, compliance_PredictionSnapshot as PredictionSnapshot, compliance_SnapshotFilter as SnapshotFilter, compliance_SummaryResponse as SummaryResponse, compliance_ValidationReportDto as ValidationReportDto, compliance_VerifyResponse as VerifyResponse };
+}
+
+/**
+ * Resource client for the hash-chained audit ledger and prediction-
+ * snapshot validation pipeline (`/api/v1/compliance/*` and
+ * `/api/v1/predictions/*`).
+ *
+ * @remarks
+ * Two cooperating mechanisms:
+ *
+ *  - **Audit ledger** — every API call (or anything explicitly
+ *    appended via {@link append}) becomes an immutable
+ *    `AuditRecord` whose `recordHash` chains into the previous
+ *    record's `prevHash`.  {@link verify} re-walks the chain and
+ *    reports breaks; {@link summary} returns top-line counts.
+ *
+ *  - **Prediction snapshots** — {@link captureSnapshot} freezes a
+ *    slice of the ledger matching a request-path glob, producing a
+ *    `PredictionSnapshot` with one `PredictionEntry` per audited
+ *    prediction.  Each entry starts `Pending`; an external validator
+ *    (against ground truth) flips them to `Validated` / `Refuted` /
+ *    `Unknown` and {@link validateStub} surfaces a ratio report.
+ *
+ * Delegates to the generated `Compliance` route class for type-safe
+ * HTTP calls.
+ */
+declare class ComplianceClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: Compliance);
+    /**
+     * 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).
+     */
+    append(request: AppendRequest): Promise<AuditRecord>;
+    /**
+     * List audit records for this tenant, optionally filtered.
+     *
+     * @param options - Limit / glob filter on `requestPath`.
+     */
+    list(options?: ListAuditOptions): Promise<AuditRecord[]>;
+    /**
+     * Top-line counts over the tenant's full ledger — useful for
+     * dashboards and quick health checks.
+     */
+    summary(): Promise<SummaryResponse>;
+    /**
+     * 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.
+     */
+    verify(): Promise<VerifyResponse>;
+    /**
+     * 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.
+     */
+    captureSnapshot(request: CaptureSnapshotRequest): Promise<PredictionSnapshot>;
+    /**
+     * Fetch a previously-captured snapshot by id.
+     */
+    getSnapshot(id: string): Promise<PredictionSnapshot>;
+    /**
+     * 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`.
+     */
+    validateStub(id: string): Promise<ValidationReportDto>;
+}
+
+declare class Operations<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * @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: AntiUnifyRequest$1, params?: RequestParams) => Promise<HttpResponse<AntiUnifyResponse$1, void>>;
+}
+
+/**
+ * Anti-unify two Ψ-terms — request body for
+ * `POST /api/v1/operations/anti-unify`.
+ *
+ * The two referenced terms must already exist in the tenant's term
+ * store.  The engine computes their Least General Generalisation (LGG)
+ * using `osfkb_domain::operations::ilp::AntiUnificationEngine` and
+ * persists the resulting Ψ-term.
+ */
+interface AntiUnifyRequest {
+    /** First Ψ-term id (must already be registered in the tenant). */
+    term1Id: string;
+    /** Second Ψ-term id (must already be registered in the tenant). */
+    term2Id: string;
+}
+/**
+ * Result of an anti-unification call.
+ *
+ * Carries the newly-created LGG term's id plus an enriched view
+ * (sort name, display name, referenced-term summaries) so callers
+ * don't need a follow-up `getTerm` round-trip.
+ */
+interface AntiUnifyResponse {
+    /** Id of the newly-created LGG term. */
+    lggTermId: string;
+    /** Enriched view of the LGG term. */
+    lgg: TermDto;
+    /** Engine + lock-acquisition time, in milliseconds. */
+    computationTimeMs: number;
+}
+
+type operations_AntiUnifyRequest = AntiUnifyRequest;
+type operations_AntiUnifyResponse = AntiUnifyResponse;
+declare namespace operations {
+  export type { operations_AntiUnifyRequest as AntiUnifyRequest, operations_AntiUnifyResponse as AntiUnifyResponse };
+}
+
+/**
+ * Resource client for low-level term-graph operations.
+ *
+ * @remarks
+ * Currently exposes anti-unification — the Inductive Logic
+ * Programming building block that computes the Least General
+ * Generalisation (LGG) of two Ψ-terms.  More operations may surface
+ * here over time; the namespace is reserved for engine-internal
+ * primitives that are useful to expose as standalone calls rather
+ * than as part of a larger pipeline.
+ *
+ * Delegates to the generated `Operations` route class for type-safe
+ * HTTP calls.
+ */
+declare class OperationsClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: Operations);
+    /**
+     * 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).
+     */
+    antiUnify(request: AntiUnifyRequest): Promise<AntiUnifyResponse>;
+}
+
 /** Core knowledge base operations — types, records, rules, functions, constraints, and queries. */
 interface CoreGroup {
     readonly types: SortsClient;
@@ -41413,10 +43419,11 @@ interface AiGroup {
     readonly context: ContextClient;
     readonly rlTraining: RlTrainingClient;
 }
-/** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling. */
+/** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling, flow networks. */
 interface ReasoningGroup {
     readonly optimize: OptimizeClient;
     readonly scheduling: SchedulingClient;
+    readonly flowNetworks: FlowNetworksClient;
     readonly ilp: IlpClient;
     readonly cdl: CdlClient;
     readonly execution: ExecutionClient;
@@ -41566,6 +43573,8 @@ declare class ReasoningLayerClient {
     readonly optimize: OptimizeClient;
     /** Scheduling feasibility via capacitated bipartite b-matching (staff rostering, assignment problems). */
     readonly scheduling: SchedulingClient;
+    /** Generic flow-network resource: max-flow, min-cost max-flow, edge classification, min-cut over a persisted graph. */
+    readonly flowNetworks: FlowNetworksClient;
     /** OSFQL execution operations. */
     readonly osfql: OsfqlClient;
     /** Conversational AI operations (NL → OSFQL with self-correction). */
@@ -41578,6 +43587,10 @@ declare class ReasoningLayerClient {
     readonly rlTraining: RlTrainingClient;
     /** Sort-driven UI descriptor operations (describe, action, catalog). */
     readonly ui: UiClient;
+    /** Hash-chained audit ledger and prediction-snapshot validation. */
+    readonly compliance: ComplianceClient;
+    /** Low-level term-graph operations (anti-unification / LGG). */
+    readonly operations: OperationsClient;
     private _core?;
     private _ai?;
     private _reasoning?;
@@ -41609,7 +43622,7 @@ declare class ReasoningLayerClient {
     get core(): CoreGroup;
     /** AI and machine learning operations — agents, oversight, neuro-symbolic, RAG, generation, context, RL training. */
     get ai(): AiGroup;
-    /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling. */
+    /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling, flow networks. */
     get reasoningOps(): ReasoningGroup;
     /** Analysis operations — causal, statistical, fuzzy, scenarios, communities, visualization. */
     get analysisOps(): AnalysisGroup;
@@ -42683,4 +44696,4 @@ declare function toUntaggedFeatures(features: PlainFeatureMap): Record<string, F
  */
 declare function toTermInputDto(input: PsiTermInput | TermInputDto): TermInputDto;
 
-export { ANY_ROLE, actionReviews as ActionReviews, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, type AiGroup, analysis as Analysis, type AnalysisGroup, ApiError, type ApiResponse, type AuthConfig, AuthenticationError, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, causal as Causal, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, collections as Collections, communities as Communities, type ConstrainedPlainVar, ConstraintViolationError, constraints as Constraints, control as Control, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTurnsResponse, type CoreGroup, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateSortRequest, type CreateTermRequest, type DataGroup, discovery as Discovery, type ErrorResponse$1 as ErrorResponse, execution as Execution, extract as Extract, type FeatureInputValueDto, type FeatureValueDto, ForbiddenError, type ForwardChainRequest, type ForwardChainResponse, functions as Functions, fuzzy as Fuzzy, FuzzyShape, type FuzzyShapeDto, generation as Generation, type GlbRequest, type GlbResponse, health as Health, homoiconic as Homoiconic, ilp as ILP, imageExtraction as ImageExtraction, inference as Inference, type IngestPaperRequest, type IngestPaperResponse, ingestion as Ingestion, IngestionFailedError, IngestionSession, type IngestionSyncOptions, type Interceptor, InternalServerError, type JsonValue$1 as JsonValue, LP, type ListConversationsResponse, type LubRequest, type LubResponse, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, optimize as Optimize, type OsfSearchRequest, type OsfSearchResponse, osfql as Osfql, type OsfqlRequest, type OsfqlResponse, type OsfqlValue, oversight as Oversight, type PaginationParams, type PaperMetadataDto, type PaperSource, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, preferences as Preferences, proofEngine as ProofEngine, type PsiTermDto, type PsiTermInput, query as Query, rag as RAG, RateLimitError, type RateLimitInfo, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, reviews as Reviews, row as Row, SDK_VERSION, scenarios as Scenarios, scheduling as Scheduling, type SearchPapersRequest, type SearchPapersResponse, SortBuilder, type SortDto, type SortInfoDto, sorts as Sorts, sources as Sources, spaces as Spaces, statistical as Statistical, synthetic as Synthetic, type SystemGroup, type TermDto, type TermInputArg, type TermInputDto, type TermListResponse, type TermPatternDto, type TermResponse, terms as Terms, TimeoutError, type TurnDto, type UpdateTermRequest, utilities as Utilities, ValidationError, Value, type ValueDto, values as Values, type VerifyClaimRequest, type VerifyClaimResponse, visualization as Visualization, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WorkflowGroup, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };
+export { ANY_ROLE, actionReviews as ActionReviews, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, type AiGroup, analysis as Analysis, type AnalysisGroup, ApiError, type ApiResponse, type AuthConfig, AuthenticationError, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, causal as Causal, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, collections as Collections, communities as Communities, compliance as Compliance, type ConstrainedPlainVar, ConstraintViolationError, constraints as Constraints, control as Control, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTurnsResponse, type CoreGroup, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateSortRequest, type CreateTermRequest, type DataGroup, discovery as Discovery, type ErrorResponse$1 as ErrorResponse, execution as Execution, extract as Extract, type FeatureInputValueDto, type FeatureValueDto, flowNetworks as FlowNetworks, ForbiddenError, type ForwardChainRequest, type ForwardChainResponse, functions as Functions, fuzzy as Fuzzy, FuzzyShape, type FuzzyShapeDto, generation as Generation, type GlbRequest, type GlbResponse, health as Health, homoiconic as Homoiconic, ilp as ILP, imageExtraction as ImageExtraction, inference as Inference, type IngestPaperRequest, type IngestPaperResponse, ingestion as Ingestion, IngestionFailedError, IngestionSession, type IngestionSyncOptions, type Interceptor, InternalServerError, type JsonValue$1 as JsonValue, LP, type ListConversationsResponse, type LubRequest, type LubResponse, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, operations as Operations, optimize as Optimize, type OsfSearchRequest, type OsfSearchResponse, osfql as Osfql, type OsfqlRequest, type OsfqlResponse, type OsfqlValue, oversight as Oversight, type PaginationParams, type PaperMetadataDto, type PaperSource, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, preferences as Preferences, proofEngine as ProofEngine, type PsiTermDto, type PsiTermInput, query as Query, rag as RAG, RateLimitError, type RateLimitInfo, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, reviews as Reviews, row as Row, SDK_VERSION, scenarios as Scenarios, scheduling as Scheduling, type SearchPapersRequest, type SearchPapersResponse, SortBuilder, type SortDto, type SortInfoDto, sorts as Sorts, sources as Sources, spaces as Spaces, statistical as Statistical, synthetic as Synthetic, type SystemGroup, type TermDto, type TermInputArg, type TermInputDto, type TermListResponse, type TermPatternDto, type TermResponse, terms as Terms, TimeoutError, type TurnDto, type UpdateTermRequest, utilities as Utilities, ValidationError, Value, type ValueDto, values as Values, type VerifyClaimRequest, type VerifyClaimResponse, visualization as Visualization, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WorkflowGroup, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };