@monoes/monomindcli 2.16.11 → 2.16.13

package/dist/src/memory/memory-kg-model.js

@@ -0,0 +1,158 @@
+/**
+ * Memory Knowledge Graph — namespaces, limits, identity (entity/edge/rule
+ * keys), the ingest input/result types, and scope (org ownership). Split out
+ * of memory-kg.ts, which re-exports the public symbols; see that module's
+ * header for the design.
+ */
+import { createHash } from 'node:crypto';
+export const KG_NODES_NS = 'kg:nodes';
+export const KG_EDGES_NS = 'kg:edges';
+export 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 const KG_NAMES_NS = 'kg:names';
+/** Derived adjacency index namespace (K7). See `KgNamespaces.adj`. */
+export const KG_ADJ_NS = 'kg:adj';
+/** Derived origin-support index namespace (K7). See `KgNamespaces.originIdx`. */
+export const KG_ORIGIN_IDX_NS = 'kg:origin-idx';
+/** Derived-index status namespace (K7). See `KgNamespaces.indexStatus`. */
+export const KG_INDEX_STATUS_NS = 'kg:index-status';
+const MAX_NAME_LEN = 200;
+export const MAX_DESC_LEN = 2000;
+/** Nodes/edges/rules accepted per call. Overflow is REPORTED, never sliced away
+ *  in silence — see `KgIngestResult.nodesTruncated`. */
+export const MAX_NODES_PER_CALL = 500;
+export const MAX_EDGES_PER_CALL = 1000;
+export const MAX_RULES_PER_CALL = 50;
+/** Per-origin description contributions retained on one element.
+ *
+ *  A cap has to exist — the bridge caps a stored value, and an element asserted
+ *  by ten thousand runs would otherwise stop being writable. What must NOT
+ *  happen is the old `origin_refs.slice(-100)`, which dropped the oldest
+ *  provenance and left the entry claiming complete history. Past this cap the
+ *  oldest contributions are dropped AND the entry records `origins_dropped`
+ *  with `provenance_complete: false`, so a reader can tell that a rollback of an
+ *  old origin may find nothing to withdraw. */
+export const MAX_CLAIMS = 200;
+// ── Identity ────────────────────────────────────────────────────────
+/**
+ * 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 const KG_ID_VERSION = 2;
+/** Identity-grade name normalization: the same folding as `normalizeName` but
+ *  WITHOUT its 200-character truncation, which silently merged long names that
+ *  differ only past the cut. `normalizeName` keeps truncating because it feeds
+ *  tags and display, where length matters and collisions do not. */
+export function canonicalName(name) {
+    return String(name).trim().toLowerCase().replace(/['’]/g, '').replace(/\s+/g, '_');
+}
+/** Types that assert nothing. A generic label must not fork an entity away from
+ *  its typed self, so it maps to the empty discriminator and is resolved by
+ *  name (see `resolveEntity`). */
+const GENERIC_TYPES = new Set(['', 'entity', 'unknown']);
+/** The identity-bearing part of a type: '' when the caller told us nothing. */
+export function typeBucket(type) {
+    const t = canonicalName(type ?? '');
+    return GENERIC_TYPES.has(t) ? '' : t;
+}
+/** Hash a tuple injectively: every component is length-prefixed, so no
+ *  component's content can masquerade as a delimiter or bleed into its
+ *  neighbour, and no two distinct tuples share an input string. Same discipline
+ *  as monograph's `symbolId`/`fileId` (packages/@monomind/monograph/src/types.ts),
+ *  and adopted here for the same reason — the previous scheme lost distinctions
+ *  to truncation and to an unescaped separator. */
+export function hashTuple(components) {
+    const canonical = components.map((c) => `${Buffer.byteLength(c, 'utf8')}:${c}`).join('');
+    return createHash('sha256').update(canonical, 'utf8').digest('hex').slice(0, 32);
+}
+/** 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 function nodeKey(type, name) {
+    return `n:${hashTuple([String(KG_ID_VERSION), typeBucket(type), canonicalName(name)])}`;
+}
+/** The pre-`KG_ID_VERSION` key for a name: name-only, truncated at 200. Probed
+ *  on a miss so existing graphs keep working without being re-keyed. */
+export function legacyNodeKey(name) {
+    return `n:${normalizeName(name)}`;
+}
+/** cognee DataPoint normalization: lowercase, spaces→_, strip apostrophes. */
+export function normalizeName(name) {
+    return String(name)
+        .trim()
+        .toLowerCase()
+        .replace(/['’]/g, '')
+        .replace(/\s+/g, '_')
+        .slice(0, MAX_NAME_LEN);
+}
+/** Edge identity: the endpoint IDs (already collision-free) plus the relation,
+ *  hashed injectively so a relation containing the old `|` separator can no
+ *  longer forge a different edge's key. */
+export function edgeKey(srcKey, relation, dstKey) {
+    return `e:${hashTuple([String(KG_ID_VERSION), srcKey, canonicalName(relation), dstKey])}`;
+}
+/** The pre-`KG_ID_VERSION` edge key, for the same in-place adoption as
+ *  `legacyNodeKey`. Composed from the RESOLVED endpoint keys, so it names the
+ *  legacy edge exactly when both endpoints are themselves legacy rows. */
+export function legacyEdgeKey(srcKey, relation, dstKey) {
+    return `e:${srcKey}|${normalizeName(relation)}|${dstKey}`;
+}
+/** Rule identity: the full rule text. The old key truncated the normalized rule
+ *  at 120 characters, so two rules sharing a long preamble were one rule. */
+export function ruleKey(rule) {
+    return `rule:${hashTuple([String(KG_ID_VERSION), canonicalName(rule)])}`;
+}
+export function legacyRuleKey(rule) {
+    return `rule:${normalizeName(rule).slice(0, 120)}`;
+}
+/** 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 function kgNamespaces(scope) {
+    const org = scope?.org?.trim();
+    if (!org)
+        return {
+            nodes: KG_NODES_NS,
+            edges: KG_EDGES_NS,
+            rules: RULES_NS,
+            names: KG_NAMES_NS,
+            adj: KG_ADJ_NS,
+            originIdx: KG_ORIGIN_IDX_NS,
+            indexStatus: KG_INDEX_STATUS_NS,
+        };
+    const suffix = `:org:${normalizeName(org)}`;
+    return {
+        nodes: KG_NODES_NS + suffix,
+        edges: KG_EDGES_NS + suffix,
+        rules: RULES_NS + suffix,
+        names: KG_NAMES_NS + suffix,
+        adj: KG_ADJ_NS + suffix,
+        originIdx: KG_ORIGIN_IDX_NS + suffix,
+        indexStatus: KG_INDEX_STATUS_NS + suffix,
+    };
+}
+/** 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 function kgQualifyOrigin(originRef, scope) {
+    const org = scope?.org?.trim();
+    return org ? `org:${normalizeName(org)}/${originRef}` : originRef;
+}
+//# sourceMappingURL=memory-kg-model.js.map

package/dist/src/memory/memory-kg-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-kg-model.js","sourceRoot":"","sources":["../../../src/memory/memory-kg-model.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,64 @@
+/**
+ * Memory Knowledge Graph — the name index and merge index, and entity
+ * resolution through them (same-name candidates without name-only
+ * identity). Split out of memory-kg.ts, which re-exports the public
+ * symbols.
+ */
+import type { KgNamespaces } from './memory-kg-model.js';
+import type { FailureLog } from './memory-kg-scan.js';
+/** 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;
+}
+/** @returns the indexed entities, or null when the backend could not be read.
+ *
+ *  The null is load-bearing: an unreadable index looks exactly like an empty
+ *  one, and treating a read failure as "no entities with this name" would make
+ *  the next write REPLACE the row with a single entry, erasing every other
+ *  same-name entity from the index. A later generic assertion would then see one
+ *  candidate and adopt it — a silent wrong merge caused by a read hiccup. */
+export declare function readNameIndex(name: string, ns: KgNamespaces, dbPath: string | undefined): Promise<KgNameCandidate[] | null>;
+/** Persist (or clear) the index row for one name.
+ *
+ *  The index is a HINT, not a source of truth: it is written after the entity
+ *  write lands, and a row that goes stale — pointing at an entity a rollback
+ *  removed — self-heals, because resolving onto a missing id makes the next
+ *  ingest create that entity fresh with an empty claim ledger, which is exactly
+ *  what a new entity is. Nothing reads the index to decide what the graph
+ *  contains; `kgStats`, `kgSearch` and `kgRollback` all read the claim
+ *  namespaces. */
+export declare function writeNameIndex(name: string, entities: KgNameCandidate[], ns: KgNamespaces, dbPath: string | undefined, failures: FailureLog): Promise<void>;
+/** What resolving a name against the index produced. */
+interface ResolvedEntity {
+    id: string;
+    /** Same-name entities this assertion did NOT merge with. Reported, never
+     *  merged away — "Alex the person" and "Alex the service" are candidates for
+     *  a human or a consolidation pass to judge, not a merge the graph may do on
+     *  its own. */
+    candidates: KgNameCandidate[];
+    /** Index content to persist for this name, or null when it is already
+     *  correct. Written only after the entity write lands, so a refused write
+     *  never leaves the index pointing at an entity that does not exist. */
+    index: KgNameCandidate[] | null;
+}
+/**
+ * Resolve (type, name) to the entity that should carry the assertion.
+ *
+ * Identity is the (type, name) tuple, so distinct types are distinct entities.
+ * The one thing name-only identity got right — a generic label must not fork an
+ * entity away from its typed self — is preserved here instead of in the key:
+ *
+ *  - exact type-bucket match  → that entity
+ *  - generic assertion, exactly one same-name entity → adopt it
+ *  - typed assertion, exactly one same-name entity and it is untyped → adopt it
+ *    and promote its type (its ID does not change, so references stay valid)
+ *  - anything else            → a new entity, with the alternatives as candidates
+ *
+ * @returns null when the name index could not be read — the caller must refuse
+ * the assertion rather than resolve it against an index it could not see.
+ */
+export declare function resolveEntity(name: string, type: string, ns: KgNamespaces, dbPath: string | undefined): Promise<ResolvedEntity | null>;
+export {};
+//# sourceMappingURL=memory-kg-names.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-kg-names.d.ts","sourceRoot":"","sources":["../../../src/memory/memory-kg-names.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AASzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAItD,4CAA4C;AAC5C,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;CACd;AAgBD;;;;;;6EAM6E;AAC7E,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,YAAY,EAChB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,OAAO,CAAC,eAAe,EAAE,GAAG,IAAI,CAAC,CAMnC;AAED;;;;;;;;kBAQkB;AAClB,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,eAAe,EAAE,EAC3B,EAAE,EAAE,YAAY,EAChB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,QAAQ,EAAE,UAAU,GACnB,OAAO,CAAC,IAAI,CAAC,CAkBf;AAmDD,wDAAwD;AACxD,UAAU,cAAc;IACtB,EAAE,EAAE,MAAM,CAAC;IACX;;;mBAGe;IACf,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B;;4EAEwE;IACxE,KAAK,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,YAAY,EAChB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CA+ChC"}

package/dist/src/memory/memory-kg-names.js

@@ -0,0 +1,187 @@
+/**
+ * Memory Knowledge Graph — the name index and merge index, and entity
+ * resolution through them (same-name candidates without name-only
+ * identity). Split out of memory-kg.ts, which re-exports the public
+ * symbols.
+ */
+import { mergeKey } from './entity-name-key.js';
+import { bridgeDeleteEntry, bridgeGetEntry, bridgeStoreEntry } from './memory-bridge.js';
+import { canonicalName, hashTuple, KG_ID_VERSION, legacyNodeKey, nodeKey, typeBucket, } from './memory-kg-model.js';
+function nameIndexKey(name) {
+    return `nm:${hashTuple([String(KG_ID_VERSION), canonicalName(name)])}`;
+}
+/** A coarser, additive index alongside the exact one: bucketed by `mergeKey`
+ *  (case/separator/plural-insensitive), so "Node.js" and "nodejs" land in the
+ *  same bucket even though their exact `nameIndexKey`s differ. Purely a hint
+ *  like the exact index — `resolveEntity` still applies the same (type, name)
+ *  merge rules to whatever it finds here, so a bucket hit is a candidate,
+ *  never an automatic cross-type merge. */
+function mergeIndexKey(name) {
+    return `nmk:${hashTuple([String(KG_ID_VERSION), mergeKey(name)])}`;
+}
+/** @returns the indexed entities, or null when the backend could not be read.
+ *
+ *  The null is load-bearing: an unreadable index looks exactly like an empty
+ *  one, and treating a read failure as "no entities with this name" would make
+ *  the next write REPLACE the row with a single entry, erasing every other
+ *  same-name entity from the index. A later generic assertion would then see one
+ *  candidate and adopt it — a silent wrong merge caused by a read hiccup. */
+export async function readNameIndex(name, ns, dbPath) {
+    const res = await bridgeGetEntry({ key: nameIndexKey(name), namespace: ns.names, dbPath });
+    if (!res)
+        return null;
+    const raw = res.entry?.metadata?.entities;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((c) => c && typeof c.id === 'string');
+}
+/** Persist (or clear) the index row for one name.
+ *
+ *  The index is a HINT, not a source of truth: it is written after the entity
+ *  write lands, and a row that goes stale — pointing at an entity a rollback
+ *  removed — self-heals, because resolving onto a missing id makes the next
+ *  ingest create that entity fresh with an empty claim ledger, which is exactly
+ *  what a new entity is. Nothing reads the index to decide what the graph
+ *  contains; `kgStats`, `kgSearch` and `kgRollback` all read the claim
+ *  namespaces. */
+export async function writeNameIndex(name, entities, ns, dbPath, failures) {
+    const key = nameIndexKey(name);
+    if (!entities.length) {
+        await bridgeDeleteEntry({ key, namespace: ns.names, dbPath });
+        return;
+    }
+    const res = await bridgeStoreEntry({
+        key,
+        value: name,
+        namespace: ns.names,
+        dbPath,
+        upsert: true,
+        generateEmbeddingFlag: false,
+        tags: ['kg', 'name-index'],
+        metadata: { kg: 'name', name, entities },
+    });
+    failures.add(res, `name index ${key}`);
+    await writeMergeIndex(name, entities, ns, dbPath, failures);
+}
+/** Add `entities` into the merge-key bucket for `name`, unioned with whatever
+ *  other exact spellings already sharing that bucket contributed. Additive
+ *  only — a name written with fewer entities than before (e.g. a rollback's
+ *  survivor list) never removes another spelling's candidates from the shared
+ *  bucket. That is a smaller staleness cost than the exact index already
+ *  accepts, and self-heals the same way: a stale candidate that no longer
+ *  resolves to a live entity simply is not adopted. */
+async function writeMergeIndex(name, entities, ns, dbPath, failures) {
+    const key = mergeIndexKey(name);
+    const existing = await bridgeGetEntry({ key, namespace: ns.names, dbPath });
+    const prior = existing?.entry?.metadata?.entities;
+    const merged = new Map();
+    if (Array.isArray(prior))
+        for (const c of prior)
+            if (c && typeof c.id === 'string')
+                merged.set(c.id, c);
+    for (const c of entities)
+        merged.set(c.id, c);
+    const res = await bridgeStoreEntry({
+        key,
+        value: mergeKey(name),
+        namespace: ns.names,
+        dbPath,
+        upsert: true,
+        generateEmbeddingFlag: false,
+        tags: ['kg', 'name-merge-index'],
+        metadata: { kg: 'name-merge', mergeKey: mergeKey(name), entities: [...merged.values()] },
+    });
+    failures.add(res, `merge index ${key}`);
+}
+/** @returns candidates from the merge-key bucket, or null on a read failure —
+ *  same null-is-load-bearing contract as `readNameIndex`. */
+async function readMergeIndex(name, ns, dbPath) {
+    const res = await bridgeGetEntry({ key: mergeIndexKey(name), namespace: ns.names, dbPath });
+    if (!res)
+        return null;
+    const raw = res.entry?.metadata?.entities;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((c) => c && typeof c.id === 'string');
+}
+/**
+ * Resolve (type, name) to the entity that should carry the assertion.
+ *
+ * Identity is the (type, name) tuple, so distinct types are distinct entities.
+ * The one thing name-only identity got right — a generic label must not fork an
+ * entity away from its typed self — is preserved here instead of in the key:
+ *
+ *  - exact type-bucket match  → that entity
+ *  - generic assertion, exactly one same-name entity → adopt it
+ *  - typed assertion, exactly one same-name entity and it is untyped → adopt it
+ *    and promote its type (its ID does not change, so references stay valid)
+ *  - anything else            → a new entity, with the alternatives as candidates
+ *
+ * @returns null when the name index could not be read — the caller must refuse
+ * the assertion rather than resolve it against an index it could not see.
+ */
+export async function resolveEntity(name, type, ns, dbPath) {
+    const bucket = typeBucket(type);
+    let known = await readNameIndex(name, ns, dbPath);
+    if (known === null)
+        return null;
+    /** True when the index row already holds exactly `known` — the only case in
+     *  which an unchanged resolution needs no index write. */
+    let indexed = known.length > 0;
+    if (!indexed) {
+        // Nothing indexed. Before minting, probe the pre-KG_ID_VERSION key: an
+        // existing graph's rows are adopted IN PLACE (keeping their key, and so
+        // keeping the edges whose keys embed it) rather than re-keyed or orphaned.
+        const legacyKey = legacyNodeKey(name);
+        const legacy = await bridgeGetEntry({ key: legacyKey, namespace: ns.nodes, dbPath });
+        if (legacy?.found && legacy.entry) {
+            const md = legacy.entry.metadata;
+            known = [{ id: legacyKey, type: typeBucket(typeof md.type === 'string' ? md.type : '') }];
+            indexed = false;
+        }
+    }
+    if (!indexed && known.length === 0) {
+        // Still nothing under this exact spelling — check for a spelling variant
+        // (case, separators, a plain plural) already known under the same
+        // merge-key bucket. A hit is only a CANDIDATE: it still goes through the
+        // exact/promote/mint rules below, so it can never merge across types.
+        const merged = await readMergeIndex(name, ns, dbPath);
+        if (merged && merged.length > 0)
+            known = merged;
+    }
+    const exact = known.find((c) => c.type === bucket);
+    if (exact)
+        return { id: exact.id, candidates: others(known, exact.id), index: indexed ? null : known };
+    // A generic assertion adopts the one entity that bears this name; a typed
+    // assertion adopts a lone UNTYPED entity and PROMOTES it — same id, so every
+    // edge and returned reference to it stays valid. A typed assertion never
+    // absorbs a differently-typed entity, and neither adopts when the name is
+    // already ambiguous.
+    if (known.length === 1 && (!bucket || !known[0].type)) {
+        const only = known[0];
+        const promoted = { id: only.id, type: bucket || only.type };
+        return { id: only.id, candidates: [], index: [promoted] };
+    }
+    const minted = { id: mintEntityId(type, name, known), type: bucket };
+    return { id: minted.id, candidates: known, index: [...known, minted] };
+}
+/** An ID for a new entity that no entity under this name already uses.
+ *
+ *  `nodeKey(type, name)` alone is not sufficient, because promotion decouples
+ *  an entity's ID from its current type: an entity minted untyped keeps the
+ *  `''`-bucket ID after a typed assertion promotes it, so a LATER untyped
+ *  assertion would re-derive that same ID and write its claims into the
+ *  promoted entity — while simultaneously reporting that entity as one it had
+ *  "kept separate from". The discriminator is bumped only on collision, so the
+ *  first entity of a (type, name) still gets exactly `nodeKey(type, name)`. */
+function mintEntityId(type, name, known) {
+    const taken = new Set(known.map((c) => c.id));
+    let id = nodeKey(type, name);
+    for (let n = 1; taken.has(id); n++)
+        id = `n:${hashTuple([String(KG_ID_VERSION), typeBucket(type), canonicalName(name), String(n)])}`;
+    return id;
+}
+function others(known, id) {
+    return known.filter((c) => c.id !== id);
+}
+//# sourceMappingURL=memory-kg-names.js.map

package/dist/src/memory/memory-kg-names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-kg-names.js","sourceRoot":"","sources":["../../../src/memory/memory-kg-names.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,79 @@
+/**
+ * Memory Knowledge Graph — graph maintenance reads and moves: kgPromote
+ * (org-owned → project-shared, explicit), consolidation candidates, and
+ * kgStats. Split out of memory-kg.ts, which re-exports the public symbols.
+ */
+import type { KgScope } from './memory-kg-model.js';
+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;
+}>;
+//# sourceMappingURL=memory-kg-promote.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-kg-promote.d.ts","sourceRoot":"","sources":["../../../src/memory/memory-kg-promote.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAA4C,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAc9F,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd;iEAC6D;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;yEAUyE;AACzE,wBAAsB,SAAS,CAAC,OAAO,EAAE;IACvC,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB;iEAC6D;IAC7D,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,eAAe,CAAC,CAmI3B;AAID,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;;;4CAM4C;AAC5C,wBAAsB,uBAAuB,CAAC,OAAO,CAAC,EAAE;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CA+CpC;AAID;;;;;;;;;mCASmC;AACnC,wBAAsB,OAAO,CAAC,OAAO,CAAC,EAAE;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;4DACwD;IACxD,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAsB3D"}