agent-kb 0.1.0

package/dist/api/index.d.ts

@@ -0,0 +1,756 @@
+/**
+ * Clock abstraction for deterministic timestamps in tests and production.
+ *
+ * SystemClock  — real wall-clock time via Date.toISOString().
+ * FixedClock   — frozen timestamp; call set(iso) to advance for tests.
+ */
+interface Clock {
+    /** Returns an ISO-8601 timestamp string (e.g. '2024-01-15T10:30:00.000Z'). */
+    now(): string;
+}
+
+/**
+ * T09 — WriteLock: single-writer serialization via OS advisory lock.
+ *
+ * All write operations serialize through this lock so file + SQLite
+ * mutations never interleave. Acquisition is synchronous (the engine's
+ * write path is synchronous).
+ */
+interface WriteLock {
+    /** Acquire the write lock (retry until timeoutMs), run fn, then release. */
+    withLock<T>(fn: () => T): T;
+}
+
+type Envelope<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: KbErrorBody;
+};
+interface KbErrorBody {
+    code: ErrorCode;
+    message: string;
+    details?: unknown[];
+}
+type ErrorCode = 'NOT_FOUND' | 'VALIDATION_ERROR' | 'SCHEMA_CONFLICT' | 'SCHEMA_VIOLATION' | 'DUPLICATE_ID' | 'BROKEN_LINK' | 'CARDINALITY_VIOLATION' | 'ILLEGAL_TRANSITION' | 'CONCURRENCY_CONFLICT' | 'LINK_CONSTRAINT' | 'CHANGESET_ALREADY_DECIDED' | 'POLICY_DENIED' | 'MIGRATION_ERROR' | 'FEATURE_DISABLED' | 'LOCK_TIMEOUT' | 'IO_ERROR' | 'PARSE_ERROR' | 'VECTOR_INDEX_FAILED' | 'VECTOR_DIM_MISMATCH' | 'INTERNAL';
+type EntityId = string;
+type Handle = string;
+type Ref = EntityId | Handle;
+declare const isHandle: (r: Ref) => r is Handle;
+type FieldValue = string | number | boolean | null | FieldValue[] | {
+    [k: string]: unknown;
+};
+interface EntityRecord {
+    id: EntityId;
+    type: string;
+    rev: number;
+    fields: Record<string, FieldValue>;
+    meta: EntityMeta;
+}
+interface EntityMeta {
+    created_at: string;
+    created_by?: string;
+    updated_at: string;
+    updated_by?: string;
+    last_changeset?: string;
+    last_verified_at?: string;
+    source_refs?: string[];
+}
+interface Link {
+    from: EntityId;
+    relation: string;
+    to: EntityId;
+    created_at: string;
+    created_by?: string;
+    changeset_id?: string;
+}
+type Op = CreateOp | UpdateOp | DeleteOp | LinkOp | UnlinkOp;
+interface CreateOp {
+    op: 'create';
+    entity: string;
+    handle: Handle;
+    fields: Record<string, FieldValue>;
+}
+interface UpdateOp {
+    op: 'update';
+    id: EntityId;
+    base_rev: number;
+    set: SetSpec;
+}
+interface DeleteOp {
+    op: 'delete';
+    id: EntityId;
+    base_rev: number;
+}
+interface LinkOp {
+    op: 'link';
+    from: Ref;
+    relation: string;
+    to: Ref;
+    base_rev?: number;
+}
+interface UnlinkOp {
+    op: 'unlink';
+    from: EntityId;
+    relation: string;
+    to: EntityId;
+}
+type SetSpec = Record<string, FieldValue | ListMutation>;
+interface ListMutation {
+    add?: unknown[];
+    remove?: unknown[];
+}
+type ChangeSetStatus = 'proposed' | 'accepted' | 'rejected' | 'superseded';
+interface ChangeSet {
+    id: string;
+    status: ChangeSetStatus;
+    by: string;
+    reason: string;
+    created_at: string;
+    decided_at?: string;
+    decided_by?: string;
+    ops: Op[];
+    result?: AcceptResult;
+    conflict?: ConflictReport;
+    reject_reason?: string;
+}
+interface NewChangeSet {
+    by: string;
+    reason: string;
+    ops: Op[];
+}
+interface AcceptResult {
+    handle_map: Record<Handle, EntityId>;
+    event_ids: string[];
+}
+interface ConflictReport {
+    stale: {
+        id: EntityId;
+        base_rev: number;
+        current_rev: number;
+    }[];
+}
+type EventType = 'ENTITY_CREATED' | 'ENTITY_UPDATED' | 'ENTITY_DELETED' | 'LINK_CREATED' | 'LINK_REMOVED' | 'CHANGESET_ACCEPTED' | 'CHANGESET_REJECTED' | 'CHANGESET_SUPERSEDED' | 'MIGRATION_APPLIED';
+interface KbEvent {
+    seq: number;
+    id: string;
+    type: EventType;
+    timestamp: string;
+    actor?: string;
+    entity_type?: string;
+    entity_id?: EntityId;
+    changeset_id?: string;
+    payload?: unknown;
+}
+type FieldType = 'text' | 'longtext' | 'int' | 'number' | 'bool' | 'enum' | 'date' | 'ref' | 'list' | 'json';
+type ScalarType = Exclude<FieldType, 'list'>;
+interface FieldDef {
+    type: FieldType;
+    required?: boolean;
+    default?: FieldValue;
+    unique?: boolean;
+    values?: string[];
+    items?: ScalarType;
+    entity?: string;
+}
+interface Lifecycle {
+    field: string;
+    initial: string;
+    transitions: Record<string, string[]>;
+}
+interface EntityDef {
+    kind: 'entity';
+    name: string;
+    id_prefix: string;
+    fields: Record<string, FieldDef>;
+    lifecycle?: Lifecycle;
+    search_fields?: string[];
+}
+type Cardinality = 'one_to_one' | 'one_to_many' | 'many_to_many';
+type OnDelete = 'block' | 'cascade' | 'detach';
+interface RelationDef {
+    kind: 'relation';
+    name: string;
+    from: string;
+    to: string;
+    cardinality: Cardinality;
+    on_delete?: {
+        from: OnDelete;
+        to: OnDelete;
+    };
+}
+interface IndexDef {
+    kind: 'index';
+    entity: string;
+    fields: string[];
+}
+interface KnowledgeModel {
+    entities: Map<string, EntityDef>;
+    relations: Map<string, RelationDef>;
+    indexes: IndexDef[];
+    validators: Map<string, FieldsValidator>;
+}
+type Direction = 'out' | 'in' | 'both';
+type ScalarOrArray = FieldValue | FieldValue[];
+type OperatorClause = Partial<Record<'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains', FieldValue | FieldValue[]>>;
+type WhereClause = Record<string, ScalarOrArray | OperatorClause>;
+type GroupedLinks = {
+    out: Record<string, EntityId[]>;
+    in: Record<string, EntityId[]>;
+};
+interface GetQuery {
+    id: EntityId;
+    include?: 'links'[];
+}
+interface FindQuery {
+    entity: string;
+    where?: WhereClause;
+    order_by?: string;
+    order?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+interface RelatedQuery {
+    id: EntityId;
+    depth?: number;
+    relations?: string[];
+    direction?: Direction;
+}
+interface SearchQuery {
+    text: string;
+    types?: string[];
+    limit?: number;
+    mode?: 'fts' | 'semantic' | 'hybrid';
+}
+interface GraphNode {
+    id: EntityId;
+    type: string;
+    fields?: Record<string, FieldValue>;
+    via?: string;
+}
+interface GraphEdge {
+    from: EntityId;
+    relation: string;
+    to: EntityId;
+}
+interface RelatedResult {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+interface TraceResult {
+    root: GraphNode;
+    branches: TraceBranch[];
+}
+interface TraceBranch {
+    node: GraphNode;
+    via: string;
+    children: TraceBranch[];
+}
+interface SearchHit {
+    id: EntityId;
+    type: string;
+    score: number;
+    snippet?: string;
+}
+interface Hop {
+    rel: string;
+    dir: Direction;
+}
+type SlotDef = TraversalSlot | EventSlot;
+interface TraversalSlot {
+    name: string;
+    from: '$root' | string | (string | '$root')[];
+    self?: boolean;
+    via?: Hop[];
+    via_any?: Hop[][];
+    fields?: string[];
+}
+interface EventSlot {
+    name: string;
+    events_for: '$slots' | string[];
+    window_days?: number;
+    limit?: number;
+}
+interface Recipe {
+    recipe: string;
+    root: string;
+    slots: SlotDef[];
+}
+interface ContextPack {
+    root: {
+        type: string;
+        id: EntityId;
+    };
+    recipe: string;
+    generated_at: string;
+    fingerprint: string;
+    slots: Record<string, SlotResult>;
+}
+type SlotResult = ContextNode | ContextNode[] | EventRef[];
+interface ContextNode {
+    id?: EntityId;
+    via?: string;
+    [field: string]: unknown;
+}
+interface EventRef {
+    event: EventType;
+    entity_id?: EntityId;
+    at: string;
+    changeset_id?: string;
+}
+interface Config {
+    project: {
+        name: string;
+        kb_version: number;
+    };
+    storage: {
+        entities_path: string;
+        links_path: string;
+        event_log_path: string;
+        sqlite_path: string;
+    };
+    search: {
+        fts_enabled: boolean;
+        vector_enabled: boolean;
+        embedding_provider: string | null;
+        embedding_model?: string;
+        embedding_host?: string;
+        embedding_dim?: number;
+    };
+    docs: {
+        generate_markdown: boolean;
+        docs_path: string;
+    };
+    change_sets: {
+        default_mode: 'propose' | 'direct';
+        require_acceptance: boolean;
+    };
+    trace_paths: Record<string, Hop[][]>;
+    context_recipes: Record<string, Recipe>;
+    policies: PolicyConfig;
+    concurrency: {
+        lock_timeout_ms: number;
+    };
+    mcp: {
+        enabled: boolean;
+        port: number;
+    };
+}
+interface PolicyConfig {
+    default_mode: 'propose' | 'direct';
+    direct_write: {
+        allowed_actors: string[];
+    };
+    change_set_required_for: string[];
+    protected_entities: string[];
+}
+interface Violation {
+    code: ErrorCode;
+    op?: number;
+    entity?: string;
+    field?: string;
+    message: string;
+}
+interface FieldsValidator {
+    validate(fields: Record<string, FieldValue>): Violation[];
+}
+
+/**
+ * FileStore — canonical file storage for Agent KB (T07).
+ *
+ * Owns every read/write of the canonical JSON/JSONL files that form the source
+ * of truth. All writes are atomic (via T03 utilities). This module may only
+ * import from @/types, @/errors, @/util, and Node builtins.
+ *
+ * Canonical layout (relative to kbDir):
+ *   entities/<type-kebab>/<ID>.json
+ *   entities/_links.jsonl          — current link set (full rewrite)
+ *   events/events.jsonl            — append-only event history
+ *   change-sets/{proposed,accepted,rejected,superseded}/<ID>.json
+ *   schema/*.json
+ *   snapshots/                     — tar archives (NOT part of fingerprint)
+ */
+
+interface ChangeSetSummary {
+    id: string;
+    status: ChangeSetStatus;
+    by: string;
+    reason: string;
+    created_at: string;
+    decided_at?: string;
+}
+
+/**
+ * validate — dry-run a ChangeSet against canonical state (T12 §18.2).
+ *
+ * Pure read path: acquires no lock, writes no file, bumps no counter.
+ * Returns a ValidateResult with all violations (from the 8-rule pipeline)
+ * and a previewHandleMap projecting handle→EntityId WITHOUT consuming IDs.
+ */
+
+/** Returned by `validate`. Exported so the facade (T15) can use it. */
+interface ValidateResult {
+    valid: boolean;
+    violations: Violation[];
+    previewHandleMap?: Record<Handle, EntityId>;
+}
+
+/**
+ * EmbeddingProvider seam (T32, design §21).
+ *
+ * Provides a pluggable, synchronous embedding interface. The default provider
+ * is Ollama (`embedding_provider: 'ollama'`). When no provider is configured,
+ * the factory returns `NoneProvider`, which throws `FEATURE_DISABLED` on
+ * `embed()` — the same pattern used by `DisabledVectorAdapter`.
+ *
+ * Extension points (NOT implemented — out of scope for T32):
+ *   - `'transformers'`: in-process provider; needs a Worker+Atomics sync bridge.
+ *   - `'openai'`: remote provider via the OpenAI embeddings API.
+ * Both can be wired into `createEmbeddingProvider` when selected.
+ */
+
+/**
+ * Synchronous batch embedding provider.
+ *
+ * `embed` is synchronous — see `ollama.ts` for the rationale.
+ *
+ * @property id  - Provider identifier (e.g. `'ollama'`, `'none'`).
+ * @property dim - Dimension of every returned vector (0 for `NoneProvider`).
+ */
+interface EmbeddingProvider {
+    readonly id: string;
+    readonly dim: number;
+    /**
+     * Embed `texts` and return one vector per input, in input order.
+     *
+     * @param texts - Strings to embed. `[]` → `[]` (no network call).
+     * @returns Flat array of `number[]`, each of length `dim`.
+     * @throws `KbError { code: 'FEATURE_DISABLED' }` when `id === 'none'`.
+     */
+    embed(texts: string[]): number[][];
+}
+
+/**
+ * T19 — Verify service (design §21).
+ *
+ * A READ-ONLY whole-KB health check usable in CI. Surfaces drift and invariant
+ * violations; NEVER mutates or auto-fixes. The factory takes the stores and
+ * clock as dependencies — NO write lock, NO coordinator, NO coordinator.
+ *
+ * Checks (all run on every call; divergence only when opts.events is true):
+ *   1. broken_link    — link whose from/to entity is absent from the index
+ *   2. orphan         — entity of a relation-participating type with zero links
+ *   3. invalid_status — lifecycle field holds a value outside the declared enum
+ *   4. duplicate_id   — same id under two different type directories
+ *   5. stuck_changeset — proposed changeset older than stuckDays
+ *   6. stale_code     — CodeFile entity whose resolved path does not exist
+ *   7. stale_entity   — entity linked to a CodeFile whose ENTITY_UPDATED postdates last_verified_at
+ *   8. divergence     — event-log shadow vs on-disk entity set disagrees
+ *
+ * Dependency direction: imports @/types, @/util, @/storage/* (file + index).
+ * Does NOT import facade / CLI / MCP / changeset / coordinator / migration /
+ * context / search.
+ */
+
+type FindingKind = 'broken_link' | 'orphan' | 'invalid_status' | 'duplicate_id' | 'stuck_changeset' | 'stale_code' | 'stale_entity' | 'divergence';
+interface Finding {
+    kind: FindingKind;
+    message: string;
+    entity_id?: EntityId;
+    details?: Record<string, unknown>;
+}
+/** ok === findings.length === 0 */
+interface VerifyReport {
+    findings: Finding[];
+    ok: boolean;
+}
+
+/**
+ * T21 — Scan service (detect → propose).
+ *
+ * Walks the working tree, classifies files, diffs against known CodeFile
+ * entities, and PROPOSES a changeset for review — never writes canonical
+ * state directly.
+ *
+ * Dependency direction: imports @/types, @/util, node:fs, node:path, and
+ * the detectors module. Does NOT import facade / CLI / MCP / coordinator /
+ * migration / verify / docs / context / search.
+ *
+ * DEFERRED: MODIFIES / EXPOSED_BY link inference (symbol analysis, V2).
+ */
+
+interface DetectedFile {
+    /** Relative to root, POSIX separators. */
+    path: string;
+    kind: string;
+    language?: string;
+}
+interface Candidate {
+    kind: 'create' | 'update' | 'gone';
+    path: string;
+    id?: EntityId;
+}
+interface ScanResult {
+    detected: DetectedFile[];
+    candidates: Candidate[];
+    /** Present only when propose:true was passed AND ops were emitted. */
+    changeSetId?: string;
+}
+
+/**
+ * Export service — T43.
+ *
+ * Produces two read-only KB projections (json + graph) from the live model and
+ * storage reads. Read-only, lock-free (mirrors verify / docs / scan).
+ *
+ * Dependency direction: imports @/types, @/storage/file-store. Does NOT import
+ * facade / CLI / MCP / coordinator / changeset / migration.
+ */
+
+/**
+ * Payload for `export --format json`.
+ * All entities (with their full fields) and all links (from/relation/to).
+ * Deterministic: entities sorted by id, links sorted by (from, relation, to).
+ */
+interface JsonExportPayload {
+    entities: EntityRecord[];
+    links: {
+        from: EntityId;
+        relation: string;
+        to: EntityId;
+    }[];
+}
+/**
+ * Payload for `export --format graph`.
+ * Nodes (one per entity) and edges (one per link) for graph tooling.
+ * Deterministic: nodes sorted by id, edges sorted by (from, relation, to).
+ */
+interface GraphExportPayload {
+    nodes: {
+        id: EntityId;
+        type: string;
+        /** Present when the entity has a `name` or `title` string field. */
+        label?: string;
+    }[];
+    edges: {
+        from: EntityId;
+        relation: string;
+        to: EntityId;
+    }[];
+}
+
+/**
+ * AgentKbEngine facade + construction helpers (T15, design §9 / §10).
+ *
+ * The single shared contract every transport (CLI, MCP, in-process API) calls —
+ * and only this. Every method returns an `Envelope` and NEVER throws across the
+ * boundary: the uniform `guard()` wrapper turns a `KbError` into a typed error
+ * envelope and any other throw into `INTERNAL`.
+ *
+ * This module sits at the TOP of the engine layer. It may import config / schema
+ * / storage / engine services / util / errors / types / yaml / node — but never a
+ * transport (`@/cli`, `@/mcp`, `@/api`). Transport-agnostic: NO `console` /
+ * `process` usage.
+ */
+
+interface InitResult {
+    path: string;
+    created: string[];
+}
+interface StatusResult {
+    entities: Record<string, number>;
+    pending_change_sets: number;
+    index_healthy: boolean;
+    /** Whether semantic/vector search is effectively enabled (a real adapter is wired). */
+    vector_enabled: boolean;
+}
+interface ReindexResult {
+    fingerprint: string;
+}
+interface SchemaApplyResult {
+    applied: boolean;
+    violations?: Violation[];
+}
+interface MigrateResult {
+    applied: string[];
+}
+/**
+ * Discriminated union: the payload type narrows with `format`.
+ * No `unknown` reaches consumers.
+ */
+type ExportResult = {
+    format: 'json';
+    data: JsonExportPayload;
+} | {
+    format: 'graph';
+    data: GraphExportPayload;
+};
+interface SchemaFieldDesc {
+    name: string;
+    type: string;
+    required: boolean;
+    /** Allowed values for an `enum` field (agent-relevant; omitted otherwise). */
+    values?: string[];
+    /** Target entity type for a `ref` field (omitted otherwise). */
+    entity?: string;
+    /** Element scalar type for a `list` field (omitted otherwise). */
+    items?: string;
+    /** Whether the field is uniquely constrained (omitted when not set). */
+    unique?: boolean;
+    /** Declared default value (omitted when the field has none). */
+    default?: FieldValue;
+}
+interface SchemaEntityDesc {
+    name: string;
+    id_prefix: string;
+    fields: SchemaFieldDesc[];
+    search_fields?: string[];
+}
+interface SchemaRelationDesc {
+    name: string;
+    from: string;
+    to: string;
+    cardinality: string;
+    on_delete?: {
+        from: string;
+        to: string;
+    };
+}
+interface SchemaDescription {
+    entities: SchemaEntityDesc[];
+    relations: SchemaRelationDesc[];
+    /** Context recipe names, sorted alphabetically. */
+    recipes: string[];
+}
+interface AgentKbEngine {
+    init(opts?: {
+        force?: boolean;
+    }): Envelope<InitResult>;
+    status(): Envelope<StatusResult>;
+    applySchema(args: {
+        file: string;
+        dryRun?: boolean;
+    }): Envelope<SchemaApplyResult>;
+    migrate(opts?: {
+        allowDataLoss?: boolean;
+    }): Envelope<MigrateResult>;
+    reindex(): Envelope<ReindexResult>;
+    get(q: GetQuery): Envelope<{
+        entity: EntityRecord;
+        links?: GroupedLinks;
+    }>;
+    find(q: FindQuery): Envelope<{
+        items: EntityRecord[];
+        total: number;
+    }>;
+    related(q: RelatedQuery): Envelope<RelatedResult>;
+    trace(args: {
+        id: EntityId;
+    }): Envelope<TraceResult>;
+    search(q: SearchQuery): Envelope<{
+        hits: SearchHit[];
+    }>;
+    context(args: {
+        id: EntityId;
+        recipe?: string;
+        maxDepth?: number;
+    }): Envelope<ContextPack>;
+    why(args: {
+        id: EntityId;
+        root: EntityId;
+        recipe?: string;
+    }): Envelope<{
+        via: string | null;
+    }>;
+    propose(args: {
+        changeSet: ChangeSet | NewChangeSet;
+    }): Envelope<{
+        id: string;
+        status: ChangeSetStatus;
+    }>;
+    validate(args: {
+        id?: string;
+        changeSet?: ChangeSet;
+    }): Envelope<ValidateResult>;
+    accept(args: {
+        id: string;
+        by?: string;
+    }): Envelope<AcceptResult>;
+    reject(args: {
+        id: string;
+        reason: string;
+        by?: string;
+    }): Envelope<{
+        status: ChangeSetStatus;
+    }>;
+    listChangeSets(args?: {
+        status?: ChangeSetStatus;
+    }): Envelope<{
+        changeSets: ChangeSetSummary[];
+    }>;
+    generateDocs(): Envelope<{
+        written: string[];
+    }>;
+    scan(opts?: {
+        propose?: boolean;
+    }): Envelope<ScanResult>;
+    verify(opts?: {
+        events?: boolean;
+    }): Envelope<VerifyReport>;
+    snapshot(args?: {
+        name?: string;
+    }): Envelope<{
+        path: string;
+    }>;
+    export(args: {
+        format: 'json' | 'graph';
+    }): Envelope<ExportResult>;
+    describeSchema(): Envelope<SchemaDescription>;
+}
+/**
+ * The object `openKb` returns: the §9 contract plus a resource-lifecycle
+ * `close()` (releases the IndexStore DB handle). `close()` is deliberately NOT
+ * part of `AgentKbEngine` — that interface is the byte-for-byte §9 transport
+ * surface — so it lives on this superset instead.
+ */
+interface OpenedKb extends AgentKbEngine {
+    close(): void;
+}
+
+/**
+ * openKb — construct the AgentKbEngine facade (design §10).
+ *
+ * Loads + validates config, opens FileStore / IndexStore / WriteLock, loads the
+ * schema into a MUTABLE model holder, builds the StorageCoordinator, runs startup
+ * recovery (§15: replay an interrupted journal, else reindex on fingerprint
+ * drift), wires the changeset + query services with the injected clock / lock,
+ * and returns the facade. The facade shares the SAME model holder the services
+ * read through, so `reindex()` can refresh the model in place.
+ *
+ * If `.agent-kb/` is absent, only `init` is permitted; every other call returns
+ * `NOT_FOUND`.
+ *
+ * Dependency direction: the facade is the TOP of the engine layer — it imports
+ * config / schema / storage / engine services / util, never a transport.
+ * Transport-agnostic: no `console` / `process` usage.
+ */
+
+interface OpenKbDeps {
+    /** Project dir; `.agent-kb` lives at `<root>/.agent-kb`. */
+    root: string;
+    /** Default: system clock. Tests inject a fixed clock. */
+    clock?: Clock;
+    /** Default: file lock at `locks/write.lock`. */
+    lock?: WriteLock;
+    /**
+     * Embedding provider for the real vector adapter (T33). Injection seam for
+     * tests (a deterministic fake) — production resolves it from config via
+     * `createEmbeddingProvider(config.search)`. Only consulted when
+     * `search.vector_enabled` is true; a `none` provider keeps vectors disabled.
+     */
+    embeddingProvider?: EmbeddingProvider;
+}
+declare function openKb(deps: OpenKbDeps): OpenedKb;
+
+export { type AcceptResult, type AgentKbEngine, type Candidate, type Cardinality, type ChangeSet, type ChangeSetStatus, type ChangeSetSummary, type Config, type ConflictReport, type ContextNode, type ContextPack, type CreateOp, type DeleteOp, type DetectedFile, type Direction, type EntityDef, type EntityId, type EntityMeta, type EntityRecord, type Envelope, type ErrorCode, type EventRef, type EventSlot, type EventType, type ExportResult, type FieldDef, type FieldType, type FieldValue, type FieldsValidator, type FindQuery, type Finding, type FindingKind, type GetQuery, type GraphEdge, type GraphExportPayload, type GraphNode, type GroupedLinks, type Handle, type Hop, type IndexDef, type InitResult, type JsonExportPayload, type KbErrorBody, type KbEvent, type KnowledgeModel, type Lifecycle, type Link, type LinkOp, type ListMutation, type MigrateResult, type NewChangeSet, type OnDelete, type Op, type OpenKbDeps, type OpenedKb, type OperatorClause, type PolicyConfig, type Recipe, type Ref, type ReindexResult, type RelatedQuery, type RelatedResult, type RelationDef, type ScalarOrArray, type ScalarType, type ScanResult, type SchemaApplyResult, type SearchHit, type SearchQuery, type SetSpec, type SlotDef, type SlotResult, type StatusResult, type TraceBranch, type TraceResult, type TraversalSlot, type UnlinkOp, type UpdateOp, type ValidateResult, type VerifyReport, type Violation, type WhereClause, isHandle, openKb };