@monoes/monomindcli 2.16.12 → 2.16.14

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

@@ -0,0 +1,248 @@
+/**
+ * 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 { bridgeCountEntries } from './memory-bridge.js';
+import { kgIngest } from './memory-kg-ingest.js';
+import { kgNamespaces, kgQualifyOrigin, MAX_DESC_LEN, MAX_EDGES_PER_CALL, MAX_NODES_PER_CALL, MAX_RULES_PER_CALL, } from './memory-kg-model.js';
+import { kgIngestRules } from './memory-kg-rules.js';
+import { collectByOrigin, FailureLog, scanNamespace } from './memory-kg-scan.js';
+/** 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 async function kgPromote(options) {
+    const empty = { nodes: 0, edges: 0, rules: 0 };
+    if (!options.from?.org?.trim())
+        return {
+            success: false,
+            ...empty,
+            promotedAs: '',
+            error: 'promotion needs an owning org to promote from',
+        };
+    const ns = kgNamespaces(options.from);
+    const sourceRef = kgQualifyOrigin(options.originRef, options.from);
+    const promotedAs = `promoted:${sourceRef}`;
+    const failures = new FailureLog();
+    try {
+        const [nodeHits, edgeHits, ruleHits] = await Promise.all([
+            collectByOrigin(ns.nodes, sourceRef, options.dbPath),
+            collectByOrigin(ns.edges, sourceRef, options.dbPath),
+            collectByOrigin(ns.rules, sourceRef, options.dbPath),
+        ]);
+        // A partial read would promote a partial claim set while reporting the
+        // whole origin as shared.
+        for (const [name, hit] of [
+            ['nodes', nodeHits],
+            ['edges', edgeHits],
+            ['rules', ruleHits],
+        ])
+            if (!hit.covered)
+                failures.note(`${name}: memory backend unavailable`);
+        if (failures.failed)
+            return {
+                success: false,
+                ...empty,
+                promotedAs,
+                failures: failures.messages,
+                error: failures.summary(),
+            };
+        // Rule NODES are re-created by kgIngestRules; promoting them again through
+        // kgIngest would double-count and strip their rules-namespace entry.
+        const nodes = nodeHits.entries
+            .filter((e) => {
+            const md = (e.metadata ?? {});
+            return md.node_set !== 'rules' && String(md.type ?? '').toLowerCase() !== 'rule';
+        })
+            .map((e) => {
+            const md = (e.metadata ?? {});
+            return {
+                name: String(md.name ?? e.key),
+                type: String(md.type ?? 'entity'),
+                description: String(md.description ?? ''),
+                nodeSet: typeof md.node_set === 'string' ? md.node_set : undefined,
+            };
+        });
+        const edges = edgeHits.entries.map((e) => {
+            const md = (e.metadata ?? {});
+            return {
+                source: String(md.source_name ?? md.src ?? ''),
+                target: String(md.target_name ?? md.dst ?? ''),
+                relation: String(md.relation ?? 'related_to'),
+                description: String(md.description ?? ''),
+            };
+        });
+        const rules = ruleHits.entries.map((e) => {
+            const md = (e.metadata ?? {});
+            return { rule: String(md.rule ?? e.content.split('\n')[0]) };
+        });
+        let promotedNodes = 0, promotedEdges = 0, promotedRules = 0;
+        /** A batch that REJECTED part of what it was handed did not promote the
+         *  whole origin, so it cannot be reported as a clean share. Rejections are
+         *  not in `failures` — they are the caller's payload being refused, not the
+         *  bridge failing — so they have to be carried across explicitly. */
+        const carry = (res, what) => {
+            if (res.failures?.length)
+                for (const m of res.failures)
+                    failures.note(m);
+            const rejected = (res.nodesRejected ?? 0) + (res.edgesRejected ?? 0);
+            if (rejected)
+                failures.note(`${what}: ${rejected} item(s) rejected — ${res.rejections?.[0]}`);
+        };
+        // kgIngest caps a call at 500 nodes / 1000 edges, so a large origin has to
+        // be promoted in batches rather than silently truncated. Nodes go first so
+        // every edge endpoint already exists when the edges land.
+        for (let i = 0; i < nodes.length; i += MAX_NODES_PER_CALL) {
+            const res = await kgIngest({
+                nodes: nodes.slice(i, i + MAX_NODES_PER_CALL),
+                originRef: promotedAs,
+                dbPath: options.dbPath,
+            });
+            promotedNodes += res.nodesAdded + res.nodesMerged;
+            carry(res, 'promoted nodes');
+        }
+        for (let i = 0; i < edges.length; i += MAX_EDGES_PER_CALL) {
+            const res = await kgIngest({
+                nodes: [],
+                edges: edges.slice(i, i + MAX_EDGES_PER_CALL),
+                originRef: promotedAs,
+                dbPath: options.dbPath,
+            });
+            promotedEdges += res.edgesAdded + res.edgesMerged;
+            carry(res, 'promoted edges');
+        }
+        for (let i = 0; i < rules.length; i += MAX_RULES_PER_CALL) {
+            const res = await kgIngestRules({
+                rules: rules.slice(i, i + MAX_RULES_PER_CALL),
+                originRef: promotedAs,
+                dbPath: options.dbPath,
+            });
+            promotedRules += res.accepted;
+            if (res.failures?.length)
+                for (const m of res.failures)
+                    failures.note(m);
+            const invalid = res.verdicts.filter((v) => v.verdict === 'invalid').length;
+            if (invalid)
+                failures.note(`promoted rules: ${invalid} rejected as invalid`);
+        }
+        return {
+            success: !failures.failed,
+            nodes: promotedNodes,
+            edges: promotedEdges,
+            rules: promotedRules,
+            promotedAs,
+            ...(failures.failed ? { failures: failures.messages, error: failures.summary() } : {}),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            ...empty,
+            promotedAs,
+            ...(failures.messages.length ? { failures: failures.messages } : {}),
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/** 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 async function kgConsolidateCandidates(options) {
+    const minEdges = options?.minEdges ?? 3;
+    const limit = options?.limit ?? 10;
+    const ns = kgNamespaces(options?.scope);
+    // Degree index over the FULL edge namespace. Only the first 12 facts per node
+    // are kept (that is all the result exposes), so the index costs a bounded
+    // amount per node rather than one string per edge.
+    const degree = new Map();
+    await scanNamespace(ns.edges, options?.dbPath, (page) => {
+        for (const e of page) {
+            const md = e.metadata;
+            for (const end of [String(md.src ?? ''), String(md.dst ?? '')]) {
+                if (!end)
+                    continue;
+                const slot = degree.get(end) ?? { count: 0, facts: [] };
+                slot.count++;
+                if (slot.facts.length < 12)
+                    slot.facts.push(e.content);
+                degree.set(end, slot);
+            }
+        }
+    });
+    let candidates = [];
+    await scanNamespace(ns.nodes, options?.dbPath, (page) => {
+        for (const n of page) {
+            const md = n.metadata;
+            const slot = degree.get(n.key);
+            if (!slot || slot.count < minEdges)
+                continue;
+            const description = String(md.description ?? '');
+            // Cap the growth target at MAX_DESC_LEN — a very-high-degree node whose
+            // description is already at the cap can never "grow out" of candidacy and
+            // would otherwise permanently occupy a slot.
+            if (description.length >= Math.min(40 * slot.count, MAX_DESC_LEN))
+                continue;
+            candidates.push({
+                name: String(md.name ?? n.key),
+                type: String(md.type ?? 'entity'),
+                description,
+                edgeCount: slot.count,
+                neighborhood: slot.facts,
+            });
+        }
+        // Ranking is per-node, so keeping only the running top-`limit` after each
+        // page gives the same answer as ranking every node at the end.
+        candidates.sort((a, b) => b.edgeCount - a.edgeCount);
+        candidates = candidates.slice(0, limit);
+    });
+    return candidates;
+}
+// ── Stats ───────────────────────────────────────────────────────────
+/** 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 async function kgStats(options) {
+    const ns = kgNamespaces(options?.scope);
+    const count = async (namespace) => {
+        try {
+            const real = await bridgeCountEntries(namespace, options?.dbPath);
+            if (real !== null)
+                return real;
+        }
+        catch {
+            /* bridgeCountEntries unavailable on this loaded bridge (or a test
+               double that doesn't stub it) — fall back to the exhaustive scan. */
+        }
+        let n = 0;
+        await scanNamespace(namespace, options?.dbPath, (page) => {
+            n += page.length;
+        });
+        return n;
+    };
+    const [nodes, edges, rules] = await Promise.all([
+        count(ns.nodes),
+        count(ns.edges),
+        count(ns.rules),
+    ]);
+    return { nodes, edges, rules };
+}
+//# sourceMappingURL=memory-kg-promote.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-kg-promote.js","sourceRoot":"","sources":["../../../src/memory/memory-kg-promote.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EACL,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAgBjF;;;;;;;;;;yEAUyE;AACzE,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,OAO/B;IACC,MAAM,KAAK,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAC/C,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE;QAC5B,OAAO;YACL,OAAO,EAAE,KAAK;YACd,GAAG,KAAK;YACR,UAAU,EAAE,EAAE;YACd,KAAK,EAAE,+CAA+C;SACvD,CAAC;IAEJ,MAAM,EAAE,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,MAAM,SAAS,GAAG,eAAe,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,MAAM,UAAU,GAAG,YAAY,SAAS,EAAE,CAAC;IAC3C,MAAM,QAAQ,GAAG,IAAI,UAAU,EAAE,CAAC;IAElC,IAAI,CAAC;QACH,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACvD,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC;YACpD,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC;YACpD,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC;SACrD,CAAC,CAAC;QACH,uEAAuE;QACvE,0BAA0B;QAC1B,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI;YACxB,CAAC,OAAO,EAAE,QAAQ,CAAC;YACnB,CAAC,OAAO,EAAE,QAAQ,CAAC;YACnB,CAAC,OAAO,EAAE,QAAQ,CAAC;SACX;YACR,IAAI,CAAC,GAAG,CAAC,OAAO;gBAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,8BAA8B,CAAC,CAAC;QACzE,IAAI,QAAQ,CAAC,MAAM;YACjB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,GAAG,KAAK;gBACR,UAAU;gBACV,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,KAAK,EAAE,QAAQ,CAAC,OAAO,EAAE;aAC1B,CAAC;QAEJ,2EAA2E;QAC3E,qEAAqE;QACrE,MAAM,KAAK,GAAkB,QAAQ,CAAC,OAAO;aAC1C,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;YACZ,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAA4B,CAAC;YACzD,OAAO,EAAE,CAAC,QAAQ,KAAK,OAAO,IAAI,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,KAAK,MAAM,CAAC;QACnF,CAAC,CAAC;aACD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACT,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAA4B,CAAC;YACzD,OAAO;gBACL,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC;gBAC9B,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,QAAQ,CAAC;gBACjC,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC,WAAW,IAAI,EAAE,CAAC;gBACzC,OAAO,EAAE,OAAO,EAAE,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS;aACnE,CAAC;QACJ,CAAC,CAAC,CAAC;QACL,MAAM,KAAK,GAAkB,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACtD,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAA4B,CAAC;YACzD,OAAO;gBACL,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,WAAW,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC;gBAC9C,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,WAAW,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC;gBAC9C,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC,QAAQ,IAAI,YAAY,CAAC;gBAC7C,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC,WAAW,IAAI,EAAE,CAAC;aAC1C,CAAC;QACJ,CAAC,CAAC,CAAC;QACH,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACvC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAA4B,CAAC;YACzD,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/D,CAAC,CAAC,CAAC;QAEH,IAAI,aAAa,GAAG,CAAC,EACnB,aAAa,GAAG,CAAC,EACjB,aAAa,GAAG,CAAC,CAAC;QACpB;;;6EAGqE;QACrE,MAAM,KAAK,GAAG,CAAC,GAAmB,EAAE,IAAY,EAAE,EAAE;YAClD,IAAI,GAAG,CAAC,QAAQ,EAAE,MAAM;gBAAE,KAAK,MAAM,CAAC,IAAI,GAAG,CAAC,QAAQ;oBAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACzE,MAAM,QAAQ,GAAG,CAAC,GAAG,CAAC,aAAa,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,IAAI,CAAC,CAAC,CAAC;YACrE,IAAI,QAAQ;gBAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,KAAK,QAAQ,uBAAuB,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAChG,CAAC,CAAC;QACF,2EAA2E;QAC3E,2EAA2E;QAC3E,0DAA0D;QAC1D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,kBAAkB,EAAE,CAAC;YAC1D,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC;gBACzB,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,kBAAkB,CAAC;gBAC7C,SAAS,EAAE,UAAU;gBACrB,MAAM,EAAE,OAAO,CAAC,MAAM;aACvB,CAAC,CAAC;YACH,aAAa,IAAI,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC;YAClD,KAAK,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;QAC/B,CAAC;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,kBAAkB,EAAE,CAAC;YAC1D,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC;gBACzB,KAAK,EAAE,EAAE;gBACT,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,kBAAkB,CAAC;gBAC7C,SAAS,EAAE,UAAU;gBACrB,MAAM,EAAE,OAAO,CAAC,MAAM;aACvB,CAAC,CAAC;YACH,aAAa,IAAI,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC;YAClD,KAAK,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;QAC/B,CAAC;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,kBAAkB,EAAE,CAAC;YAC1D,MAAM,GAAG,GAAG,MAAM,aAAa,CAAC;gBAC9B,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,kBAAkB,CAAC;gBAC7C,SAAS,EAAE,UAAU;gBACrB,MAAM,EAAE,OAAO,CAAC,MAAM;aACvB,CAAC,CAAC;YACH,aAAa,IAAI,GAAG,CAAC,QAAQ,CAAC;YAC9B,IAAI,GAAG,CAAC,QAAQ,EAAE,MAAM;gBAAE,KAAK,MAAM,CAAC,IAAI,GAAG,CAAC,QAAQ;oBAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACzE,MAAM,OAAO,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,MAAM,CAAC;YAC3E,IAAI,OAAO;gBAAE,QAAQ,CAAC,IAAI,CAAC,mBAAmB,OAAO,sBAAsB,CAAC,CAAC;QAC/E,CAAC;QAED,OAAO;YACL,OAAO,EAAE,CAAC,QAAQ,CAAC,MAAM;YACzB,KAAK,EAAE,aAAa;YACpB,KAAK,EAAE,aAAa;YACpB,KAAK,EAAE,aAAa;YACpB,UAAU;YACV,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACvF,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO;YACL,OAAO,EAAE,KAAK;YACd,GAAG,KAAK;YACR,UAAU;YACV,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACpE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;SACxD,CAAC;IACJ,CAAC;AACH,CAAC;AAaD;;;;;;4CAM4C;AAC5C,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,OAM7C;IACC,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,CAAC,CAAC;IACxC,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,EAAE,CAAC;IACnC,MAAM,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAExC,8EAA8E;IAC9E,0EAA0E;IAC1E,mDAAmD;IACnD,MAAM,MAAM,GAAG,IAAI,GAAG,EAA8C,CAAC;IACrE,MAAM,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;QACtD,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;YACrB,MAAM,EAAE,GAAG,CAAC,CAAC,QAAmC,CAAC;YACjD,KAAK,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;gBAC/D,IAAI,CAAC,GAAG;oBAAE,SAAS;gBACnB,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;gBACxD,IAAI,CAAC,KAAK,EAAE,CAAC;gBACb,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,EAAE;oBAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBACvD,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,IAAI,UAAU,GAA6B,EAAE,CAAC;IAC9C,MAAM,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;QACtD,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;YACrB,MAAM,EAAE,GAAG,CAAC,CAAC,QAAmC,CAAC;YACjD,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,GAAG,QAAQ;gBAAE,SAAS;YAC7C,MAAM,WAAW,GAAG,MAAM,CAAC,EAAE,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC;YACjD,wEAAwE;YACxE,0EAA0E;YAC1E,6CAA6C;YAC7C,IAAI,WAAW,CAAC,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC;gBAAE,SAAS;YAC5E,UAAU,CAAC,IAAI,CAAC;gBACd,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC;gBAC9B,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,IAAI,QAAQ,CAAC;gBACjC,WAAW;gBACX,SAAS,EAAE,IAAI,CAAC,KAAK;gBACrB,YAAY,EAAE,IAAI,CAAC,KAAK;aACzB,CAAC,CAAC;QACL,CAAC;QACD,0EAA0E;QAC1E,+DAA+D;QAC/D,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QACrD,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IACH,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,uEAAuE;AAEvE;;;;;;;;;mCASmC;AACnC,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,OAK7B;IACC,MAAM,EAAE,GAAG,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACxC,MAAM,KAAK,GAAG,KAAK,EAAE,SAAiB,EAAE,EAAE;QACxC,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAClE,IAAI,IAAI,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAC;QACjC,CAAC;QAAC,MAAM,CAAC;YACP;kFACsE;QACxE,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,MAAM,aAAa,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;YACvD,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC;QACnB,CAAC,CAAC,CAAC;QACH,OAAO,CAAC,CAAC;IACX,CAAC,CAAC;IACF,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC9C,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC;QACf,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC;QACf,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC;KAChB,CAAC,CAAC;IACH,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AACjC,CAAC"}

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

@@ -0,0 +1,77 @@
+/**
+ * Memory Knowledge Graph — K7 index rebuild/repair (kgRebuildIndex, with
+ * resume and validation against the reference reads) and the graph
+ * integrity check. Split out of memory-kg.ts, which re-exports the public
+ * symbols.
+ */
+import type { KgIndexStatus } from './memory-kg-index.js';
+import type { KgScope } from './memory-kg-model.js';
+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>;
+//# sourceMappingURL=memory-kg-rebuild.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-kg-rebuild.d.ts","sourceRoot":"","sources":["../../../src/memory/memory-kg-rebuild.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAU1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAoBpD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,CAAC,EAAE;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;IAChF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;6EA0B6E;AAC7E,wBAAsB,cAAc,CAAC,OAAO,CAAC,EAAE;IAC7C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,eAAe,CAAC,CAqL3B;AAID,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd;;iEAE6D;IAC7D,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IAC/C;6DACyD;IACzD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;sDAKsD;AACtD,wBAAsB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAmD7B"}

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

@@ -0,0 +1,299 @@
+/**
+ * Memory Knowledge Graph — K7 index rebuild/repair (kgRebuildIndex, with
+ * resume and validation against the reference reads) and the graph
+ * integrity check. Split out of memory-kg.ts, which re-exports the public
+ * symbols.
+ */
+import { bridgeGetEntry, bridgeListEntries } from './memory-bridge.js';
+import { addToAdj, addToOriginIndex, KG_INDEX_SCHEMA_VERSION, kgIndexedByOrigin, kgIndexedEdgesByEndpoint, readIndexStatus, writeIndexStatus, } from './memory-kg-index.js';
+import { kgNamespaces } from './memory-kg-model.js';
+import { clearNamespace, collectByOrigin, kgReferenceEdges, originsOf, SCAN_PAGE, scanNamespace, } from './memory-kg-scan.js';
+// ── Rebuild (K7): the one function that builds/repairs the derived index ──
+/** Entities/origins sampled for post-build validation. A scan that saw fewer
+ *  than this many distinct entities AND origins gets FULL validation, not a
+ *  sample — most real scopes will. `KgRebuildResult.status.validation` says
+ *  which happened, honestly, rather than letting "validated" imply "all". */
+const VALIDATE_SAMPLE = 200;
+function phaseOrder(phase) {
+    return phase === 'edges' ? 1 : phase === 'rules' ? 2 : 0;
+}
+function sameEdgeKeySet(a, b) {
+    const ak = new Set(a.map((e) => e.key));
+    const bk = new Set(b.map((e) => e.key));
+    if (ak.size !== bk.size)
+        return false;
+    for (const k of ak)
+        if (!bk.has(k))
+            return false;
+    return true;
+}
+/** (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 async function kgRebuildIndex(options) {
+    const ns = kgNamespaces(options?.scope);
+    const dbPath = options?.dbPath;
+    let status = await readIndexStatus(ns, dbPath);
+    // Resume from the checkpointed cursor for an interrupted build or a
+    // resumable (build-phase) failure; a fresh scan for everything else —
+    // `absent`, `ready` (this call IS the deliberate re-verify), and a
+    // validation-phase failure, where something already written was wrong.
+    const resume = status.state === 'building' || (status.state === 'failed' && status.resumable);
+    if (!resume) {
+        status = {
+            state: 'building',
+            schemaVersion: KG_INDEX_SCHEMA_VERSION,
+            cursor: { phase: 'nodes', offset: 0 },
+            counts: { nodes: 0, edges: 0, rules: 0 },
+            startedAt: Date.now(),
+        };
+        if (!(await writeIndexStatus(ns, status, dbPath))) {
+            return { success: false, status, error: 'could not persist initial build status' };
+        }
+    }
+    const seenEntities = [];
+    const seenOrigins = [];
+    const noteEntity = (id) => {
+        if (id && !seenEntities.includes(id) && seenEntities.length < VALIDATE_SAMPLE) {
+            seenEntities.push(id);
+        }
+    };
+    const noteOrigin = (ref) => {
+        if (!seenOrigins.includes(ref) && seenOrigins.length < VALIDATE_SAMPLE)
+            seenOrigins.push(ref);
+    };
+    // `addToAdj`/`addToOriginIndex` only APPEND onto whatever is already
+    // there. That's exactly right for a RESUME (everything present was
+    // written earlier in this same build attempt), but wrong for a FRESH
+    // build: a stale or corrupted entry left over from a PRIOR build (e.g.
+    // the exact thing a failed validation just caught) would never be
+    // cleared, only added to. So a fresh build clears both derived-index
+    // namespaces up front, once, before touching any phase — every write for
+    // the rest of THIS build attempt, in this call or a later one resuming
+    // it, can then safely append, because the namespace is known to hold only
+    // rows this attempt wrote.
+    if (!resume) {
+        const adjCleared = await clearNamespace(ns.adj, dbPath);
+        const originCleared = await clearNamespace(ns.originIdx, dbPath);
+        if (!adjCleared || !originCleared) {
+            status = { ...status, state: 'failed', error: 'could not clear prior index before rebuild' };
+            await writeIndexStatus(ns, status, dbPath);
+            return { success: false, status, error: status.error };
+        }
+    }
+    const phases = [
+        { phase: 'nodes', namespace: ns.nodes },
+        { phase: 'edges', namespace: ns.edges },
+        { phase: 'rules', namespace: ns.rules },
+    ];
+    try {
+        for (const { phase, namespace } of phases) {
+            if (phaseOrder(status.cursor?.phase) > phaseOrder(phase))
+                continue; // already scanned
+            let offset = status.cursor?.phase === phase ? (status.cursor.offset ?? 0) : 0;
+            let count = status.counts?.[phase] ?? 0;
+            for (;;) {
+                const page = await bridgeListEntries({ namespace, limit: SCAN_PAGE, offset, dbPath });
+                if (!page) {
+                    // The cursor stays exactly where it was: everything indexed before
+                    // this page is still correct, only incomplete, so a retry resumes.
+                    status = {
+                        ...status,
+                        state: 'failed',
+                        resumable: true,
+                        error: `${namespace}: backend unavailable during rebuild`,
+                    };
+                    await writeIndexStatus(ns, status, dbPath);
+                    return { success: false, status, error: status.error };
+                }
+                for (const e of page.entries) {
+                    const md = (e.metadata ?? {});
+                    count++;
+                    if (phase === 'edges' && md.kg === 'edge') {
+                        const src = String(md.src ?? '');
+                        const dst = String(md.dst ?? '');
+                        if (src) {
+                            await addToAdj(ns, src, e.key, dbPath);
+                            noteEntity(src);
+                        }
+                        if (dst && dst !== src) {
+                            await addToAdj(ns, dst, e.key, dbPath);
+                            noteEntity(dst);
+                        }
+                    }
+                    if (phase === 'nodes')
+                        noteEntity(e.key);
+                    for (const originRef of originsOf(e)) {
+                        await addToOriginIndex(ns, originRef, { ns: namespace, key: e.key }, dbPath);
+                        noteOrigin(originRef);
+                    }
+                }
+                offset += page.entries.length;
+                status = {
+                    ...status,
+                    cursor: { phase, offset },
+                    counts: { ...status.counts, [phase]: count },
+                };
+                await writeIndexStatus(ns, status, dbPath);
+                if (page.entries.length < SCAN_PAGE)
+                    break; // last page of this namespace
+            }
+        }
+        status = { ...status, state: 'validating' };
+        await writeIndexStatus(ns, status, dbPath);
+        const mismatches = [];
+        for (const id of seenEntities) {
+            const indexed = await kgIndexedEdgesByEndpoint(ns, id, dbPath);
+            const reference = await kgReferenceEdges({ endpointId: id, scope: options?.scope, dbPath });
+            if (indexed === null || !reference.success || reference.truncated) {
+                mismatches.push(`entity ${id}: reference read incomplete`);
+                continue;
+            }
+            if (!sameEdgeKeySet(indexed, reference.edges))
+                mismatches.push(`entity ${id}: adjacency mismatch`);
+        }
+        for (const originRef of seenOrigins) {
+            const indexed = await kgIndexedByOrigin(ns, originRef, dbPath);
+            if (indexed === null) {
+                mismatches.push(`origin ${originRef}: index unreadable`);
+                continue;
+            }
+            const refA = await collectByOrigin(ns.nodes, originRef, dbPath);
+            const refB = await collectByOrigin(ns.edges, originRef, dbPath);
+            const refC = await collectByOrigin(ns.rules, originRef, dbPath);
+            if (!refA.covered || !refB.covered || !refC.covered) {
+                mismatches.push(`origin ${originRef}: reference scan incomplete`);
+                continue;
+            }
+            const expected = new Set([
+                ...refA.entries.map((e) => `${ns.nodes}|${e.key}`),
+                ...refB.entries.map((e) => `${ns.edges}|${e.key}`),
+                ...refC.entries.map((e) => `${ns.rules}|${e.key}`),
+            ]);
+            const indexedKeys = new Set(indexed.map((e) => `${e.ns}|${e.entry.key}`));
+            if (expected.size !== indexedKeys.size || [...expected].some((k) => !indexedKeys.has(k))) {
+                mismatches.push(`origin ${originRef}: support-index mismatch`);
+            }
+        }
+        const full = seenEntities.length < VALIDATE_SAMPLE && seenOrigins.length < VALIDATE_SAMPLE;
+        const validation = {
+            sampledEntities: seenEntities.length,
+            sampledOrigins: seenOrigins.length,
+            full,
+        };
+        if (mismatches.length) {
+            const summary = mismatches.slice(0, 5).join('; ');
+            status = {
+                ...status,
+                state: 'failed',
+                error: `validation failed: ${summary}${mismatches.length > 5 ? ` (+${mismatches.length - 5} more)` : ''}`,
+            };
+            await writeIndexStatus(ns, status, dbPath);
+            return { success: false, status, validation, error: status.error };
+        }
+        status = { ...status, state: 'ready', error: undefined };
+        await writeIndexStatus(ns, status, dbPath);
+        return { success: true, status, validation };
+    }
+    catch (err) {
+        status = {
+            ...status,
+            state: 'failed',
+            error: err instanceof Error ? err.message : String(err),
+        };
+        try {
+            await writeIndexStatus(ns, status, dbPath);
+        }
+        catch {
+            /* best-effort — see markIndexFailed */
+        }
+        return { success: false, status, error: status.error };
+    }
+}
+/** 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 async function kgIntegrityCheck(options) {
+    const ns = kgNamespaces(options?.scope);
+    const limit = options?.limit ?? 100;
+    const dangling = [];
+    let edges = 0;
+    try {
+        /** Endpoint id → exists. One keyed lookup per DISTINCT endpoint. */
+        const seen = new Map();
+        const exists = async (id) => {
+            const hit = seen.get(id);
+            if (hit !== undefined)
+                return hit;
+            const res = await bridgeGetEntry({ key: id, namespace: ns.nodes, dbPath: options?.dbPath });
+            const found = Boolean(res?.found && res.entry);
+            seen.set(id, found);
+            return found;
+        };
+        // Collect first, then probe: the probes are reads, but interleaving many
+        // per page would hold the page open far longer than the scan needs.
+        const rows = [];
+        const covered = await scanNamespace(ns.edges, options?.dbPath, (page) => {
+            for (const e of page) {
+                const md = (e.metadata ?? {});
+                if (md.kg !== 'edge')
+                    continue;
+                edges++;
+                rows.push({ key: e.key, src: String(md.src ?? ''), dst: String(md.dst ?? '') });
+            }
+        });
+        for (const row of rows) {
+            if (dangling.length >= limit)
+                break;
+            const missing = [];
+            if (!row.src || !(await exists(row.src)))
+                missing.push(row.src || '<no src>');
+            if (!row.dst || !(await exists(row.dst)))
+                missing.push(row.dst || '<no dst>');
+            if (missing.length)
+                dangling.push({ key: row.key, missing });
+        }
+        return {
+            success: true,
+            edges,
+            dangling,
+            ...(covered && dangling.length < limit ? {} : { truncated: true }),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            edges,
+            dangling,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=memory-kg-rebuild.js.map