@monoes/monomindcli 2.16.12 → 2.16.13

package/dist/src/memory/memory-kg.d.ts

@@ -88,553 +88,25 @@
  *
  * @module v1/cli/memory/memory-kg
  */
-export declare const KG_NODES_NS = "kg:nodes";
-export declare const KG_EDGES_NS = "kg:edges";
-export declare const RULES_NS = "rules";
-/** Name → entity index. Index rows are NOT claims, so they live outside the
- *  three claim namespaces: putting them in `kg:nodes` would make them seed
- *  candidates for `kgSearch` and rows in `kgStats`. */
-export declare const KG_NAMES_NS = "kg:names";
-/** Derived adjacency index namespace (K7). See `KgNamespaces.adj`. */
-export declare const KG_ADJ_NS = "kg:adj";
-/** Derived origin-support index namespace (K7). See `KgNamespaces.originIdx`. */
-export declare const KG_ORIGIN_IDX_NS = "kg:origin-idx";
-/** Derived-index status namespace (K7). See `KgNamespaces.indexStatus`. */
-export declare const KG_INDEX_STATUS_NS = "kg:index-status";
-/**
- * Version of the identity scheme implemented by `entityId`/`edgeKey`/`ruleKey`.
- *
- * Bump when a derivation changes. Entries written under an older scheme are not
- * orphaned: resolution probes the previous key shape and adopts the row in
- * place (see `resolveEntity`), so a bump costs a second keyed lookup on the
- * miss path rather than a migration.
- *
- * Version 1 was the name-only scheme (`n:<normalized-name>`, truncated to 200
- * characters), under which `Person:Alex` and `Service:Alex` were one entity and
- * two names first differing at character 250 were one entity.
- */
-export declare const KG_ID_VERSION = 2;
-/** Mint an entity id from the full identity tuple.
- *
- *  This MINTS; it does not RESOLVE. A caller that computes an id and writes to
- *  it bypasses the name index and re-forks the entities the index exists to
- *  keep together — every ingest path goes through `resolveEntity` instead. */
-export declare function nodeKey(type: string, name: string): string;
-export interface KgNodeInput {
-    name: string;
-    /** Basic type, cognee-style ("Person", "Tool", "Service") — not over-specific. */
-    type?: string;
-    description?: string;
-    nodeSet?: string;
-}
-export interface KgEdgeInput {
-    source: string;
-    target: string;
-    /** snake_case relation name. */
-    relation: string;
-    /** One-sentence concrete fact using the endpoint names. */
-    description?: string;
-    sourceType?: string;
-    targetType?: string;
-}
-export interface KgIngestResult {
-    success: boolean;
-    nodesAdded: number;
-    nodesMerged: number;
-    edgesAdded: number;
-    edgesMerged: number;
-    /** Writes the bridge refused, one message each (capped at MAX_FAILURES).
-     *  Non-empty ⇒ `success` is false and the counters describe only what
-     *  actually persisted. */
-    failures?: string[];
-    error?: string;
-    /** Items the payload asked for that this call refused. Present only when
-     *  non-zero, so a caller who sent a clean payload sees a clean result. */
-    nodesRejected?: number;
-    edgesRejected?: number;
-    /** Items dropped because the payload exceeded the per-call cap. The cap has
-     *  not changed; what has changed is that it is now REPORTED instead of being
-     *  a silent `.slice()`. */
-    nodesTruncated?: number;
-    edgesTruncated?: number;
-    /** Why items were rejected, one message each (capped at MAX_FAILURES). */
-    rejections?: string[];
-    /** Endpoint entities created because an edge named them and they did not
-     *  exist. Edge-only ingestion used to succeed with zero nodes and one edge,
-     *  leaving a fact unreachable through both of its own endpoints. */
-    placeholders?: number;
-    /** Same-name entities this call did NOT merge with, one message each. A
-     *  same-name match is a CANDIDATE, not a merge. */
-    ambiguities?: string[];
-    /** Elements whose support ledger hit `MAX_CLAIMS` on this call, so their
-     *  oldest provenance was dropped. Never silent. */
-    provenanceTruncated?: number;
-}
-/** cognee DataPoint normalization: lowercase, spaces→_, strip apostrophes. */
-export declare function normalizeName(name: string): string;
-/** Who owns a set of graph facts. `org` absent = project-shared knowledge. */
-export interface KgScope {
-    org?: string;
-}
-export interface KgNamespaces {
-    nodes: string;
-    edges: string;
-    rules: string;
-    /** Name → entity index backing `resolveEntity`. Holds no claims. */
-    names: string;
-    /** Derived adjacency index: entity id -> edge keys touching it (K7). Holds
-     *  no claims either — every entry is rebuildable from `edges`. */
-    adj: string;
-    /** Derived origin-support index: origin ref -> {ns,key} refs it supports,
-     *  across nodes/edges/rules (K7). Rebuildable from all three. */
-    originIdx: string;
-    /** This scope's derived-index build/readiness state (K7). One row. */
-    indexStatus: string;
-}
-/** The namespaces a scope owns. Every read and write in this module resolves
- *  through here, which is what makes ownership enforced rather than advisory:
- *  there is no code path that reaches an org's facts without naming that org,
- *  and none that reaches every org at once. */
-export declare function kgNamespaces(scope?: KgScope): KgNamespaces;
-/** Stamp the asserting org onto a provenance ref, so a claim's origin says WHO
- *  asserted it and not merely which run id — `run:m4x2` alone is ambiguous
- *  across orgs, and a promoted claim in the shared graph would otherwise carry
- *  an origin no one owns.
- *
- *  Applied by the ingest/rollback entry points rather than by callers: a
- *  caller that forgets is exactly how ownership stopped being enforced. */
-export declare function kgQualifyOrigin(originRef: string, scope?: KgScope): string;
-/** How a claim came to exist.
- *
- *  `asserted` — someone stated it: an LLM distillation, an explicit
- *  `memory_kg_ingest`, an org's `org_learn`.
- *  `heuristic` — `heuristicExtract` inferred it from two names appearing in one
- *  sentence. Nobody asserted it, and the module header has always called it
- *  lower-trust; until now nothing downstream could tell the two apart. */
-export type KgExtractionMethod = 'asserted' | 'heuristic';
-/** One origin's assertion about an element. An origin re-asserting replaces its
- *  own contribution — a run stands behind its latest word, not its first. */
-export interface KgClaim {
-    origin: string;
-    description: string;
-    /** Assertion time, and the ordering that decides which claim is current. */
-    at: number;
-    /** Absent on rows written before extraction method was recorded. Absent means
-     *  UNKNOWN, never `asserted` — defaulting an unrecorded method to the higher
-     *  trust would relabel every old co-occurrence guess as a stated fact. */
-    method?: KgExtractionMethod;
-}
-/** An entity the name index knows about. */
-export interface KgNameCandidate {
-    id: string;
-    /** Identity-bearing type bucket; '' for an entity asserted without a type. */
-    type: string;
-}
-/** Merge extracted nodes/edges into the KG.
- *
- *  Identity is the (type, name) tuple resolved through the name index, so an
- *  entity is idempotent under re-extraction but two different things sharing a
- *  name stay two things. Each write adds this origin's CONTRIBUTION to the
- *  element's claim ledger, from which the description and `origin_refs` are
- *  derived — which is what lets a later ingest correct an earlier one and lets
- *  rollback put the earlier one back.
- *
- *  The COMPLETE payload is validated before anything is written, and every edge
- *  endpoint is made to exist (as a placeholder entity when the caller named one
- *  that does not) before the edge lands. An edge whose endpoint could not be
- *  created is rejected rather than written: retrieval is seeded from nodes, so
- *  an edge with a missing endpoint is a fact that cannot be found through
- *  either of the things it is about.
- *
- *  NOT ATOMIC — the memory bridge has no transaction primitive, so a failure
- *  part-way through leaves earlier writes persisted. The counters therefore
- *  report only what actually landed, `failures` lists what did not, and
- *  `success` is false whenever anything was refused. A partial ingest is safe
- *  to retry: every write is a keyed upsert. */
-export declare function kgIngest(options: {
-    nodes: KgNodeInput[];
-    edges?: KgEdgeInput[];
-    /** Provenance: run id, session id, or doc hash this extraction came from.
-     *  Stored qualified by `scope` — see `kgQualifyOrigin`. */
-    originRef: string;
-    /** Owner of these facts. Omit for project-shared knowledge. */
-    scope?: KgScope;
-    /** How this payload was produced. Defaults to `asserted`; `heuristicExtract`
-     *  callers must pass `heuristic` so a co-occurrence guess is not stored as a
-     *  stated fact. Recorded per origin, so the same element can hold a heuristic
-     *  claim from one run and an asserted one from another. */
-    method?: KgExtractionMethod;
-    dbPath?: string;
-}): Promise<KgIngestResult>;
-export interface RuleVerdict {
-    rule: string;
-    /** `failed` — the candidate was fine, but a write the caller was told about
-     *  did not land. It is neither `invalid` (which blames the caller's input)
-     *  nor `accepted`/`already_known` (which claim the graph now holds it). Both
-     *  of those used to be reported unconditionally, so a caller reading verdicts
-     *  saw every rule land while the aggregate `accepted` count said zero. */
-    verdict: 'accepted' | 'already_known' | 'invalid' | 'failed';
-    similarTo?: string;
-}
-/** Stage-2 of cognee's curator/writer distillation: the CALLER (an LLM agent)
- *  proposes candidate rules; this accepts each unless a semantically
- *  near-identical rule exists (embedding dedup — deterministic keys can't
- *  collapse paraphrases). Accepted rules are stored both as KG nodes
- *  (node_set=rules) and as plain `rules`-namespace entries so the existing
- *  injection/search surfaces pick them up with zero new plumbing.
- *
- *  A candidate that dedups against an existing rule still ADDS its origin to
- *  that rule's support set: two independent runs asserting the same rule mean
- *  the rule survives either one being rolled back. Dropping the second origin
- *  (as this used to) made rollback of the FIRST run delete knowledge the
- *  second run independently vouched for.
- *
- *  Like `kgIngest`, NOT atomic — see that function's note. */
-export declare function kgIngestRules(options: {
-    rules: {
-        rule: string;
-        context?: string;
-    }[];
-    originRef: string;
-    /** Owner of these rules. Omit for project-shared knowledge. */
-    scope?: KgScope;
-    dbPath?: string;
-    /** Similarity above which a candidate is already_known (default 0.78 —
-     *  MiniLM paraphrases of the same rule commonly land 0.78-0.9; cognee's
-     *  equivalent control is prompt-injected LLM judgment, which we approximate). */
-    dedupThreshold?: number;
-}): Promise<{
-    success: boolean;
-    verdicts: RuleVerdict[];
-    accepted: number;
-    failures?: string[];
-    error?: string;
-    /** Candidates dropped by the per-call cap, reported rather than sliced away
-     *  in silence. */
-    rulesTruncated?: number;
-}>;
-/** List stored rules (for injection or review). */
-export declare function kgListRules(options?: {
-    dbPath?: string;
-    limit?: number;
-    scope?: KgScope;
-}): Promise<{
-    rule: string;
-    key: string;
-}[]>;
-export interface KgSearchResult {
-    success: boolean;
-    /** Rendered triplet lines, best first. */
-    context: string;
-    triplets: {
-        source: string;
-        relation: string;
-        target: string;
-        fact: string;
-        score: number;
-        /** How this edge came to exist. Absent means the edge predates method
-         *  recording — not recorded, which is not the same as `asserted`. */
-        method?: KgExtractionMethod;
-        /** Live origins disagree about what this edge says. Present only when true. */
-        conflict?: boolean;
-        /** The edge's bridge entry id — feed this straight to `memory_feedback`
-         *  (`bridgeApplyFeedback`/`bridgeRecordUsage`) to rate THIS relationship
-         *  directly, rather than only the seed entity that surfaced it (K5). */
-        id: string;
-        /** The edge's stable graph key (`e:<hash>`, see `edgeKey`), for direct
-         *  `bridgeGetEntry` lookup or diagnostics — distinct from `id` above. */
-        key: string;
-    }[];
-    seeds: {
-        name: string;
-        type: string;
-        description: string;
-        score: number;
-        id: string;
-    }[];
-    /** True when the edge scan did NOT cover the whole namespace — the scan hit
-     *  `SEARCH_EDGE_SCAN_MAX`, or the backend became unreadable partway. A
-     *  relationship that exists may be missing from `triplets`; absence here is
-     *  not evidence of absence in the graph. */
-    truncated?: boolean;
-    /** Edge rows actually read, so a caller can see how close it ran to the cap. */
-    scannedEdges?: number;
-    /** What the seed retrieval ACTUALLY ran, straight from the bridge — never what
-     *  was hoped for. `keyword-fallback` means the vector path was tried and did
-     *  not serve these results. Absent only when the bridge reported nothing. */
-    method?: 'semantic' | 'keyword' | 'keyword-fallback';
-    /** Why the vector path did not serve the seeds (absent when it did). */
-    fallbackReason?: string;
-    error?: string;
-}
-/** Seeded retrieval → neighborhood → triplet ranking (cognee's brute-force
- *  triplet search, scaled down). Seed scores already carry the Phase 1 feedback
- *  blend, and the seed retrieval may be vector or keyword — `method` on the
- *  result says which actually ran.
- *
- *  Ranking weighs exactly two evidence signals, both read off the claim ledger:
- *  extraction method and description conflict. It deliberately does NOT model
- *  source credibility, claim freshness, or whether the relation itself answers
- *  the query — those need an evaluation set to tune against, and guessing at
- *  them would be the same overclaim this weighting exists to correct. */
-export declare function kgSearch(options: {
-    query: string;
-    dbPath?: string;
-    limit?: number;
-    nodeSet?: string;
-    /** Whose graph to search. Omit for project-shared knowledge; a scoped search
-     *  never reaches another org's facts, and never the shared graph either. */
-    scope?: KgScope;
-}): Promise<KgSearchResult>;
-export declare function kgGlossary(options?: {
-    dbPath?: string;
-    limit?: number;
-    /** Whose entity names to offer. The coordinator glossary MUST be scoped:
-     *  suggesting another org's entity names is how one org's claims get merged
-     *  into another's graph under a shared name. */
-    scope?: KgScope;
-}): Promise<string[]>;
-/** Withdraw `originRef`'s support from the graph: remove it from every
- *  node/edge/rule it backs, and delete the element once no origin remains.
- *
- *  The withdrawn ref is REWRITTEN out of the surviving elements' origin lists,
- *  not left behind. Retaining it (as this used to) meant a second rollback saw
- *  a two-entry list and retained again — so an element could outlive the
- *  withdrawal of every origin that ever supported it.
- *
- *  The scan is EXHAUSTIVE: it pages each namespace to the end rather than
- *  reading one capped list. A capped scan let an element past the cap keep a
- *  withdrawn origin while the caller was told the rollback succeeded.
- *
- *  Collect-then-mutate is deliberate: deleting a row pulls every later row back
- *  one position, so a delete inside the page loop would make an advancing
- *  offset skip whatever slid into the gap. (Rewrites are no longer a hazard —
- *  the bridge's upsert reuses the existing entry id and preserves `createdAt`
- *  rather than re-inserting at the head of the default ordering — but this
- *  function deletes as well as rewrites.) Only origin-carrying entries are
- *  retained during the scan, so memory tracks the rollback's own footprint, not
- *  the namespace size. */
-export declare function kgRollback(options: {
-    originRef: string;
-    /** Whose knowledge to withdraw from. A rollback can only reach the named
-     *  scope's namespaces — an org's rollback is an ownership boundary, not just
-     *  a label on the output. */
-    scope?: KgScope;
-    dbPath?: string;
-}): Promise<{
-    success: boolean;
-    deleted: number;
-    retained: number;
-    failures?: string[];
-    error?: string;
-    /** Edges deleted because this rollback removed an endpoint they name. A
-     *  relation between two things is not a fact once one of them is gone, and
-     *  retrieval is node-seeded, so leaving them behind left unreachable rows
-     *  claiming a graph that no longer exists. */
-    danglingEdgesRemoved?: number;
-}>;
-export interface KgPromoteResult {
-    success: boolean;
-    nodes: number;
-    edges: number;
-    rules: number;
-    /** Origin the shared copy carries, so the promotion can be withdrawn on its
-     *  own and the shared graph records who shared the claim. */
-    promotedAs: string;
-    failures?: string[];
-    error?: string;
-}
-/** Copy one origin's claims out of an org's scope into project-shared
- *  knowledge.
- *
- *  Sharing is deliberate, never a side effect of learning: `kgIngest` under a
- *  scope only ever writes that org's namespaces, and this is the one path a
- *  claim takes across the boundary. The org keeps its own copy untouched — the
- *  shared copy is an INDEPENDENT assertion under `promoted:<org-ref>`, so
- *  rolling back either side leaves the other standing, and a shared claim
- *  always names the org that vouched for it.
- *
- *  Like ingest, NOT atomic: the counters report what actually landed. */
-export declare function kgPromote(options: {
-    /** The org-side ref to promote, unqualified (e.g. `run:m4x2`). */
-    originRef: string;
-    /** Owner the claims are promoted FROM. Promoting from the shared scope is a
-     *  no-op and is refused rather than silently duplicating. */
-    from: KgScope;
-    dbPath?: string;
-}): Promise<KgPromoteResult>;
-export interface ConsolidationCandidate {
-    name: string;
-    type: string;
-    description: string;
-    edgeCount: number;
-    /** Neighborhood facts to merge into one canonical description. */
-    neighborhood: string[];
-}
-/** Entities whose descriptions are stale relative to their connectivity —
- *  the LLM half runs in the LIVE agent: it rewrites each candidate's
- *  description from the neighborhood facts and resubmits via memory_kg_ingest.
- *  A resubmission is a NEW contribution and therefore the current one, so a
- *  shorter but better-supported summary now wins; under "longest description
- *  wins" a consolidation that tightened the prose was silently discarded.
- *  No LLM here (fully local constraint). */
-export declare function kgConsolidateCandidates(options?: {
-    dbPath?: string;
-    /** Minimum edges for a node to qualify (default 3). */
-    minEdges?: number;
-    limit?: number;
-    scope?: KgScope;
-}): Promise<ConsolidationCandidate[]>;
-/** Real counts, not page lengths. `bridgeListEntries.total` reports how many
- *  rows that one call returned, so the old capped list made a 10,001-node graph
- *  report exactly 10,000 forever.
- *
- *  Tries a real indexed `SELECT COUNT(*) WHERE namespace = ?` first
- *  (`bridgeCountEntries`, K7) — cheap and exact, since every row in a KG
- *  namespace is exactly one node/edge/rule (the name index lives in its own
- *  namespace). Falls back to the paginated scan — one query per 1,000 rows,
- *  still exact — when the loaded bridge predates `bridgeCountEntries`, or a
- *  test double doesn't stub it. */
-export declare function kgStats(options?: {
-    dbPath?: string;
-    /** Whose graph to measure. Counting every org's facts under one org's name
-     *  is what made `org memory <name> stats` a fiction. */
-    scope?: KgScope;
-}): Promise<{
-    nodes: number;
-    edges: number;
-    rules: number;
-}>;
-export interface KgReferenceEdge {
-    key: string;
-    src: string;
-    dst: string;
-    relation: string;
-    originRefs: string[];
-}
-/** Complete, uncapped read of every edge touching `endpointId` (as either
- *  src or dst) and/or asserted by `originRef` — at least one filter is
- *  required. This is the ground truth an indexed adjacency/origin lookup
- *  (K7) must agree with once one exists: an exhaustive paged scan, the same
- *  mechanism `kgRollback` already trusts for origin withdrawal, so it never
- *  depends on an index and never inherits the old first-page cap.
- *
- *  `truncated: true` means the scan did not finish — an incomplete answer,
- *  never an empty one. Callers comparing this against a future index must
- *  treat a truncated reference read as "unknown", not as "no matches". */
-export declare function kgReferenceEdges(options: {
-    endpointId?: string;
-    originRef?: string;
-    scope?: KgScope;
-    dbPath?: string;
-}): Promise<{
-    success: boolean;
-    edges: KgReferenceEdge[];
-    truncated?: boolean;
-    error?: string;
-}>;
-export type KgIndexState = 'absent' | 'building' | 'validating' | 'ready' | 'failed';
-export interface KgIndexStatus {
-    state: KgIndexState;
-    schemaVersion: number;
-    /** Resume point for an interrupted `kgRebuildIndex`. */
-    cursor?: {
-        phase: 'nodes' | 'edges' | 'rules';
-        offset: number;
-    };
-    counts?: {
-        nodes: number;
-        edges: number;
-        rules: number;
-    };
-    startedAt?: number;
-    updatedAt?: number;
-    error?: string;
-    /** Only meaningful when `state === 'failed'`. True for a build-phase
-     *  failure (the backend went unavailable mid-scan, or a dual-write hook
-     *  hit an error after `ready`): everything already written is still
-     *  correct, just incomplete, so the next call RESUMES from `cursor`. False
-     *  for a validation-phase failure (the built index disagreed with an
-     *  independent reference read): something already written is wrong, not
-     *  merely incomplete, so the next call restarts a fresh scan — resuming
-     *  would re-derive the same mistake instead of correcting it. */
-    resumable?: boolean;
-}
-/** This scope's derived-index build/readiness state. `absent` means no one
- *  has ever called `kgRebuildIndex` for it — every read behaves exactly as
- *  it did before this index existed. */
-export declare function kgIndexStatus(options?: {
-    scope?: KgScope;
-    dbPath?: string;
-}): Promise<KgIndexStatus>;
-export interface KgRebuildResult {
-    success: boolean;
-    status: KgIndexStatus;
-    validation?: {
-        sampledEntities: number;
-        sampledOrigins: number;
-        full: boolean;
-    };
-    error?: string;
-}
-/** (Re)build a scope's derived index from canonical data — nodes, then
- *  edges, then rules, that fixed order, resuming from the last checkpointed
- *  `{phase, offset}` rather than restarting when a prior call was
- *  interrupted mid-build. Every write here (`addToAdj`/`addToOriginIndex`)
- *  is idempotent, so a page reprocessed after an interruption cannot
- *  duplicate an entry.
- *
- *  A concurrent ingest/rollback during the build is safe, not just tolerated:
- *  the dual-write hooks run whenever state is not `absent`/`failed`, so a
- *  write made mid-build is captured whether or not the scan has reached that
- *  row yet — at worst twice, which idempotency absorbs for free. The one
- *  residual race (a row deleted between the scan reading it and the scan's
- *  own write landing) can leave a dangling ref in the index; it is never
- *  observable as wrong data, because every indexed READ
- *  (`kgIndexedEdgesByEndpoint`/`kgIndexedByOrigin`) returns `null` — and the
- *  caller falls back to the exhaustive scan — the instant it cannot resolve
- *  a ref it holds. This is the backend's real capability (single-row CAS,
- *  no cross-row transaction), used honestly rather than claiming atomicity
- *  it cannot provide.
- *
- *  Ends in `validating`: samples up to `VALIDATE_SAMPLE` of the entities and
- *  origins the scan actually saw, and re-reads them through the just-built
- *  index, comparing against a FRESH, independent reference read
- *  (`kgReferenceEdges`/`collectByOrigin`) — not the in-memory data the build
- *  itself computed, which would only prove the build agrees with itself. A
- *  write that silently failed, or a concurrent change the dual-write hooks
- *  missed, is exactly what this catches before the index is ever trusted. */
-export declare function kgRebuildIndex(options?: {
-    scope?: KgScope;
-    dbPath?: string;
-}): Promise<KgRebuildResult>;
-export interface KgIntegrityResult {
-    success: boolean;
-    edges: number;
-    /** Edges naming an endpoint that does not exist. Retrieval is node-seeded,
-     *  so such an edge is a fact unreachable through either of the things it is
-     *  about — it can only be found by a check like this one. */
-    dangling: {
-        key: string;
-        missing: string[];
-    }[];
-    /** True when the edge scan did not cover the namespace: absence of a dangling
-     *  edge here is then not evidence that there is none. */
-    truncated?: boolean;
-    error?: string;
-}
-/** Verify that every edge's endpoints exist.
- *
- *  `kgIngest` now creates missing endpoints before writing an edge and
- *  `kgRollback` removes edges whose endpoints it deleted, so a healthy graph
- *  reports nothing. This exists for graphs written before either rule, and as
- *  the check that says so rather than assuming it. */
-export declare function kgIntegrityCheck(options?: {
-    dbPath?: string;
-    scope?: KgScope;
-    /** Dangling edges to report before stopping (default 100). */
-    limit?: number;
-}): Promise<KgIntegrityResult>;
+import type { KgEdgeInput, KgNodeInput } from './memory-kg-model.js';
+export type { KgClaim, KgExtractionMethod } from './memory-kg-claims.js';
+export type { KgIndexState, KgIndexStatus } from './memory-kg-index.js';
+export { kgIndexStatus } from './memory-kg-index.js';
+export { kgIngest } from './memory-kg-ingest.js';
+export type { KgEdgeInput, KgIngestResult, KgNamespaces, KgNodeInput, KgScope, } from './memory-kg-model.js';
+export { KG_ADJ_NS, KG_EDGES_NS, KG_ID_VERSION, KG_INDEX_STATUS_NS, KG_NAMES_NS, KG_NODES_NS, KG_ORIGIN_IDX_NS, kgNamespaces, kgQualifyOrigin, nodeKey, normalizeName, RULES_NS, } from './memory-kg-model.js';
+export type { KgNameCandidate } from './memory-kg-names.js';
+export type { ConsolidationCandidate, KgPromoteResult } from './memory-kg-promote.js';
+export { kgConsolidateCandidates, kgPromote, kgStats } from './memory-kg-promote.js';
+export type { KgIntegrityResult, KgRebuildResult } from './memory-kg-rebuild.js';
+export { kgIntegrityCheck, kgRebuildIndex } from './memory-kg-rebuild.js';
+export { kgRollback } from './memory-kg-rollback.js';
+export type { RuleVerdict } from './memory-kg-rules.js';
+export { kgIngestRules, kgListRules } from './memory-kg-rules.js';
+export type { KgReferenceEdge } from './memory-kg-scan.js';
+export { kgReferenceEdges } from './memory-kg-scan.js';
+export type { KgSearchResult } from './memory-kg-search.js';
+export { kgGlossary, kgSearch } from './memory-kg-search.js';
 /** Regex extraction for when no LLM is in the loop (memory-palace lineage):
  *  proper-noun phrases and `code identifiers` become entities, sentence
  *  co-occurrence becomes `mentioned_with` edges. Lower-trust by design — real

package/dist/src/memory/memory-kg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-kg.d.ts","sourceRoot":"","sources":["../../../src/memory/memory-kg.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"memory-kg.d.ts","sourceRoot":"","sources":["../../../src/memory/memory-kg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGrE,YAAY,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACzE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,YAAY,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,WAAW,EACX,OAAO,GACR,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,SAAS,EACT,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,OAAO,EACP,aAAa,EACb,QAAQ,GACT,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,YAAY,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACtF,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACrF,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAClE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAI7D;;;;;;;;kEAQkE;AAClE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE,CAoHhD"}