@ryanstark24/sfgraph-core 1.4.0 → 1.6.0

package/dist/ingest/live-ingest.js

@@ -1,21 +1,41 @@
+import { existsSync, readFileSync } from "node:fs";
 import { asQualifiedName } from "@ryanstark24/sfgraph-shared";
 import { resolveApexMethodArity } from "../parsers/apex/arity-resolver.js";
+import { retargetApexInterfaceRefs } from "../parsers/apex/interface-ref-resolver.js";
+import { resolveAuraEmbeds } from "../parsers/aura/embed-resolver.js";
 import { resolveCrossFlavor } from "../parsers/cross-flavor-resolver.js";
 import { resolveFlowApexMethods } from "../parsers/flow/invocable-resolver.js";
-import { parserRegistry } from "../parsers/registry.js";
+import { resolveFormulaRelationshipHops } from "../parsers/object/formula-hop-resolver.js";
 // Ensure all parsers are registered before we look them up.
 import "../parsers/index.js";
 import { auditDanglingEdges } from "../analyze/audit-graph.js";
 import { populateAnalysisTables } from "../analyze/populate.js";
-import { EmbeddingQueue } from "../embedding/index.js";
+import { REL_TYPES } from "../domain/rel-types.js";
+import { EmbeddingCache, EmbeddingPool, EmbeddingQueue, defaultEmbeddingWorkerUrl, hashEmbedText, } from "../embedding/index.js";
+import { tokenizeIdentifier } from "../embedding/tokenize.js";
 import { resolveOrg } from "../extractors/live-org/auth.js";
 import { bulkRetrieve } from "../extractors/live-org/bulk-retrieve.js";
 import { probeCapabilities } from "../extractors/live-org/capabilities.js";
 import { startLivenessProbe } from "../extractors/live-org/liveness.js";
 import { dataPool, metadataPool, toolingPool } from "../extractors/live-org/rate-limit.js";
 import { iterChanges } from "../extractors/live-org/source-member.js";
+// SourceMember MemberType -> the node LABEL the parsers actually store under,
+// for the (rare) types whose label differs from the member type. The LWC parser
+// labels nodes "LWC", not "LightningComponentBundle", so an obsolete-LWC delete
+// keyed by the raw member type was a silent no-op. METADATA_CATEGORY is NOT
+// usable here: its LWC/AURA values ARE the member-type strings, not the labels.
+const MEMBER_TYPE_TO_NODE_LABEL = {
+    LightningComponentBundle: "LWC",
+    AuraDefinitionBundle: "AuraComponent",
+};
 import { loadAllRules } from "../parsers/rules/_loader.js";
-import { evaluateDeletionGuard, resolveMaxDropRatio } from "./detect-deletions-guard.js";
+import { evaluateDeletionGuard, isSkipProtected, resolveMaxDropRatio, skipProtection, } from "./detect-deletions-guard.js";
+import { hasGoodPriorOwned, isParseFailureOnly, isQuarantinedFor, isQuarantinedRow, memberContentHash, memberFailureStamp, memberRowsGeneration, ownedQnames, quarantinedOutcome, } from "./member-rows.js";
+import { OFFLINE_CAPS } from "./offline-org.js";
+import { parseMember } from "./parse-member.js";
+import { parsePool, resolveParseWorkers, } from "./parse-pool.js";
+export { adaptParserInput } from "./parse-member.js";
+import { createIngestProfiler } from "./profile.js";
 const NOOP_LOG = {
     debug: () => { },
     info: () => { },
@@ -25,23 +45,56 @@ const NOOP_LOG = {
 /** Print a consolidated end-of-run summary of metadata types that were
  *  skipped during ingest, grouped by failure category, with a targeted
  *  remediation block per category. */
-function printSkipSummary(report, orgAlias) {
+/**
+ * Entries of the previous skip report at `path` (same org) whose label a
+ * scoped run did NOT re-run. Missing / malformed / other-org report: none.
+ * A `discovery` only-label re-runs every generic:* source (bulkRetrieve), so
+ * their entries are not carried either (review N3).
+ */
+export function carriedOverSkips(path, orgId, reRun) {
+    try {
+        if (!existsSync(path))
+            return [];
+        const prev = JSON.parse(readFileSync(path, "utf8"));
+        if (prev.orgId !== undefined && prev.orgId !== orgId)
+            return [];
+        return (prev.skips ?? []).filter((s) => s &&
+            typeof s.label === "string" &&
+            !reRun.has(s.label) &&
+            !(reRun.has("discovery") && s.label.startsWith("generic:")));
+    }
+    catch {
+        return [];
+    }
+}
+/** A skip reason without a leading "<label>: " — source errors already name
+ *  their source, which the summary bullet prints anyway. */
+function bulletReason(s) {
+    return s.reason.startsWith(`${s.label}: `) ? s.reason.slice(s.label.length + 2) : s.reason;
+}
+export function printSkipSummary(report, orgAlias) {
     const byCategory = new Map();
     for (const s of report.skips) {
         const arr = byCategory.get(s.category) ?? [];
         arr.push({ label: s.label, reason: s.reason });
         byCategory.set(s.category, arr);
     }
-    const total = report.skips.length;
+    const unreadableCount = byCategory.get("unreadable")?.length ?? 0;
+    const total = report.skips.length - unreadableCount;
     console.log("");
-    console.log(`⚠ ${total} metadata ${total === 1 ? "type was" : "types were"} skipped during this ingest.`);
-    console.log("  The rest of the graph completed successfully — these types are simply absent.");
+    if (total > 0) {
+        console.log(`⚠ ${total} metadata ${total === 1 ? "type was" : "types were"} skipped during this ingest.`);
+        console.log("  The rest of the graph completed successfully — these types are simply absent.");
+    }
+    if (unreadableCount > 0) {
+        console.log(`⚠ ${unreadableCount} metadata ${unreadableCount === 1 ? "type (or some of its members)" : "types (or some of their members)"} could not be read: the org refused them (unreadable — see below).`);
+    }
     if (byCategory.has("insufficient_access")) {
         const list = byCategory.get("insufficient_access") ?? [];
         console.log("");
         console.log(`  Insufficient access (${list.length}):`);
         for (const s of list)
-            console.log(`    • ${s.label}: ${s.reason}`);
+            console.log(`    • ${s.label}: ${bulletReason(s)}`);
         console.log("");
         console.log("  How to fix permanently:");
         console.log("    1. Have an admin assign your user a permission set with:");
@@ -78,66 +131,47 @@ function printSkipSummary(report, orgAlias) {
         console.log("");
         console.log(`  Network errors (${list.length}):`);
         for (const s of list)
-            console.log(`    • ${s.label}: ${s.reason}`);
+            console.log(`    • ${s.label}: ${bulletReason(s)}`);
         console.log("    How to fix: check connectivity to your org and re-run.");
     }
+    if (byCategory.has("unreadable")) {
+        const list = byCategory.get("unreadable") ?? [];
+        console.log("");
+        console.log(`  Unreadable (org refused; re-run with --retry-skipped to try again) (${list.length}):`);
+        for (const s of list)
+            console.log(`    • ${s.label}: ${bulletReason(s)}`);
+        console.log("    The org rejected these reads as invalid, or returned the same error on");
+        console.log("    repeated reads, so they were not auto-retried in this run. To try again:");
+        console.log(`         sfgraph ingest --org ${orgAlias} --retry-skipped`);
+    }
     if (byCategory.has("unknown")) {
         const list = byCategory.get("unknown") ?? [];
         console.log("");
         console.log(`  Other (${list.length}):`);
         for (const s of list)
-            console.log(`    • ${s.label}: ${s.reason}`);
+            console.log(`    • ${s.label}: ${bulletReason(s)}`);
     }
     console.log("");
 }
-/** Live-org Apex extractor wraps body in a `{body, metaXml}` JSON envelope
- *  so we can forward Tooling-row ApiVersion/Status to the parser. Filesystem
- *  extractor still passes raw body. Detect by trying JSON.parse — if it
- *  yields an object with `body`, unwrap; otherwise treat as raw body. */
-function unwrapApexEnvelope(content) {
-    if (!content)
-        return { body: "" };
-    if (content[0] !== "{")
-        return { body: content };
-    try {
-        const parsed = JSON.parse(content);
-        if (parsed && typeof parsed === "object" && typeof parsed.body === "string") {
-            const out = { body: parsed.body };
-            if (typeof parsed.metaXml === "string")
-                out.metaXml = parsed.metaXml;
-            return out;
-        }
-    }
-    catch {
-        /* fallthrough — raw body */
-    }
-    return { body: content };
-}
-/** Maps the Vlocity runner's emitted memberType (the bare VlocityDataPackType)
- *  to the parser-registry key the four rich Vlocity parsers register under.
- *  Only these four DataPack types have dedicated parsers; the other ~44 fall
- *  through to the opaque node parser (node-only, by design). */
-const VLOCITY_MEMBER_TO_PARSER = {
-    DataRaptor: "VlocityDataRaptor",
-    VlocityDataRaptor: "VlocityDataRaptor",
-    IntegrationProcedure: "VlocityIntegrationProcedure",
-    VlocityIntegrationProcedure: "VlocityIntegrationProcedure",
-    OmniScript: "VlocityOmniScript",
-    VlocityOmniScript: "VlocityOmniScript",
-    VlocityCard: "VlocityCard",
-};
 /**
  * Build the text embedded for a node's semantic vector. Beyond the
  * label/qname/description baseline, this folds in CONFIG VALUES so
  * `find_similar` matches on what a config artifact actually resolves to —
  * a Custom Metadata record's field values, a Custom Label's text, a Custom
  * Setting's rows. Without this, searching "endpoint for product push" can't
- * reach `End_Point_Urls.ProductPush_PLDT` because only its name was embedded.
+ * reach `Endpoint_Url.ProductPush_Acme` because only its name was embedded.
  * Exported for tests.
  */
 export function buildEmbedText(label, qname, attributes) {
     const a = attributes ?? {};
     const parts = [`${label}: ${qname}`];
+    // Word-split the identifier so semantic search matches on word boundaries
+    // (`account controller` → AccountController, `customer tier` → Customer_Tier__c).
+    // Only the name part after the label prefix; skip if it adds nothing.
+    const namePart = qname.includes(":") ? qname.slice(qname.indexOf(":") + 1) : qname;
+    const words = tokenizeIdentifier(namePart);
+    if (words && words !== namePart.toLowerCase())
+        parts.push(words);
     if (typeof a.description === "string" && a.description)
         parts.push(a.description);
     // Custom Metadata record field values: [{field,value}] | {field:value} | object.
@@ -173,6 +207,20 @@ export function buildEmbedText(label, qname, attributes) {
             }
         }
     }
+    // Structural attributes that make automation findable by WHAT it acts on:
+    // a trigger's object + DML events ("on Account before insert"), a Flow's
+    // process type ("AutoLaunchedFlow"/"Flow"). Gated by label — CustomField (and
+    // other nodes) also carry an `object` attribute (their parent SObject), and
+    // appending "on Account" to every field was pure noise in the embedding.
+    if (label === "ApexTrigger" && typeof a.object === "string" && a.object) {
+        const ev = Array.isArray(a.events)
+            ? a.events.filter((x) => typeof x === "string").join(" ")
+            : "";
+        parts.push(`on ${a.object}${ev ? ` ${ev}` : ""}`);
+    }
+    if (label === "Flow" && typeof a.processType === "string" && a.processType) {
+        parts.push(a.processType);
+    }
     return parts.join("\n");
 }
 function stringifyConfigVal(v) {
@@ -188,134 +236,6 @@ function stringifyConfigVal(v) {
     }
     return String(v);
 }
-/** Exported for tests — maps a RawMember to the registered parser's input shape. */
-export function adaptParserInput(ref, content) {
-    switch (ref.memberType) {
-        case "ApexClass": {
-            const { body, metaXml } = unwrapApexEnvelope(content);
-            return {
-                type: "ApexClass",
-                input: { className: ref.memberName, body, ...(metaXml ? { metaXml } : {}) },
-            };
-        }
-        case "ApexTrigger": {
-            const { body, metaXml } = unwrapApexEnvelope(content);
-            return {
-                type: "ApexTrigger",
-                input: { triggerName: ref.memberName, body, ...(metaXml ? { metaXml } : {}) },
-            };
-        }
-        case "LightningComponentBundle": {
-            try {
-                const parsed = JSON.parse(content || "{}");
-                return {
-                    type: "LightningComponentBundle",
-                    input: { bundleName: parsed.bundleName ?? ref.memberName, files: parsed.files ?? {} },
-                };
-            }
-            catch {
-                return null;
-            }
-        }
-        case "Flow":
-            return { type: "Flow", input: { fullName: ref.memberName, xml: content } };
-        case "CustomObject":
-            return { type: "CustomObject", input: { apiName: ref.memberName, objectXml: content } };
-        case "Profile":
-            return { type: "Profile", input: { name: ref.memberName, xml: content } };
-        case "PermissionSet":
-            return { type: "PermissionSet", input: { name: ref.memberName, xml: content } };
-        case "SharingRules":
-            return { type: "SharingRules", input: { object: ref.memberName, xml: content } };
-        case "NamedCredential":
-            return { type: "NamedCredential", input: { name: ref.memberName, xml: content } };
-        case "ExternalServiceRegistration":
-            return { type: "ExternalServiceRegistration", input: { name: ref.memberName, xml: content } };
-        case "OmniProcess":
-        case "OmniUiCard":
-        case "OmniDataTransform":
-        case "OmniIntegrationProcedure": {
-            let metadata = content;
-            try {
-                metadata = JSON.parse(content);
-            }
-            catch {
-                /* keep raw */
-            }
-            return { type: ref.memberType, input: { name: ref.memberName, metadata } };
-        }
-        // The Vlocity runner emits the bare VlocityDataPackType as memberType
-        // ("DataRaptor", "IntegrationProcedure", "OmniScript", "VlocityCard"),
-        // but the four rich parsers register under "Vlocity"-prefixed type names
-        // ("VlocityDataRaptor", …). Without this mapping the runner's members
-        // never matched a case here and fell through to the opaque fallback —
-        // shallow nodes with zero DR_/IP_/OS_ edges. Only "VlocityCard" happened
-        // to align on both sides, which is why a real ingest produced VC edges
-        // but no DataRaptor/IP/OmniScript lineage. The golden tests call the
-        // parsers directly, so this runner→dispatch seam was never covered.
-        // The legacy "Vlocity*"-prefixed keys are kept too in case any caller
-        // (or a future filesystem source) emits them.
-        case "DataRaptor":
-        case "VlocityDataRaptor":
-        case "IntegrationProcedure":
-        case "VlocityIntegrationProcedure":
-        case "OmniScript":
-        case "VlocityOmniScript":
-        case "VlocityCard": {
-            let datapack = content;
-            try {
-                datapack = JSON.parse(content);
-            }
-            catch {
-                /* keep raw */
-            }
-            return {
-                type: VLOCITY_MEMBER_TO_PARSER[ref.memberType] ?? ref.memberType,
-                input: { name: ref.memberName, datapack },
-            };
-        }
-        default: {
-            // Long-tail metadata types: route to a registered parser when one
-            // exists (the 21 rule-based YAML parsers register under their raw
-            // metadata type name, e.g. "Layout", "Dashboard"), otherwise fall
-            // back to the opaque node parser so the member still becomes a
-            // graph node. Before this fallback every generic-extractor member
-            // was silently dropped here — extracted, logged as ✓, and never
-            // merged — which left grant/reference edges dangling (e.g. 59k
-            // GRANTS_TAB_ACCESS edges pointing at CustomTab nodes that were
-            // never created).
-            if (parserRegistry.for(ref.memberType)) {
-                return { type: ref.memberType, input: genericRuleInput(ref.memberName, content) };
-            }
-            return {
-                type: "OpaqueMetadata",
-                input: { metadataType: ref.memberType, name: ref.memberName, raw: content },
-            };
-        }
-    }
-}
-/**
- * Build the `{ name, xml, ...siblings }` input shape the rule-based parsers'
- * `xml-string` coercion expects. Filesystem sources hand us raw XML; the
- * live generic extractor hands us the JSON-serialized `metadata.read()`
- * object — whose keys mirror the parsed XML root, so they can be promoted
- * to sibling keys directly (coerceInput merges siblings into the record).
- */
-function genericRuleInput(name, content) {
-    const s = (content ?? "").trimStart();
-    if (s.startsWith("<"))
-        return { name, xml: content };
-    let parsed = {};
-    try {
-        const j = JSON.parse(s);
-        if (j && typeof j === "object" && !Array.isArray(j))
-            parsed = j;
-    }
-    catch {
-        /* not JSON — leave record empty; the node still gets name + label */
-    }
-    return { xml: "", ...parsed, name };
-}
 export async function liveIngest(opts) {
     const logger = opts.logger ?? NOOP_LOG;
     // Load declarative rule parsers (idempotent).
@@ -352,28 +272,40 @@ export async function liveIngest(opts) {
     catch (e) {
         logger.warn("live-ingest: markSyncStarted failed", { err: e.message });
     }
+    // Opt-in profiling (SFGRAPH_INGEST_PROFILE=<file>); no-op otherwise.
+    // Created before the try so the finally can flush on failure too.
+    const profiler = createIngestProfiler();
+    // Embedding resources, owned here so the finally can release them on any path.
+    let embedQueue = null;
+    let ownedEmbedder = null;
+    let embedCache = null;
     // W1.5-08: the rest of the ingest runs inside this try so a thrown
     // exception still flips `sync_in_progress` back to 0 via markSyncFailed.
     // Per-resolver try/catch isolation inside bulkRetrieve / live-ingest is
     // preserved — this wrapper only catches exceptions that escape *all* of
     // those inner handlers (i.e. genuinely fatal failures).
     try {
-        const caps = await probeCapabilities(resolved.conn);
+        const caps = opts.metadataSource ? OFFLINE_CAPS : await probeCapabilities(resolved.conn);
         logger.info("live-ingest: probed capabilities", { caps });
         // Discovery is also invoked implicitly inside bulkRetrieve, but logging the
         // type-count up-front gives operators a quick coverage signal.
-        try {
-            const { discoverMetadataTypes } = await import("../extractors/live-org/discovery.js");
-            const discovered = await discoverMetadataTypes(resolved.conn, apiVersion);
-            logger.info("live-ingest: discovered metadata types", { count: discovered.length });
-        }
-        catch (e) {
-            logger.warn("live-ingest: metadata.describe failed", { err: e.message });
+        if (!opts.metadataSource) {
+            try {
+                const { discoverMetadataTypes } = await import("../extractors/live-org/discovery.js");
+                const discovered = await discoverMetadataTypes(resolved.conn, apiVersion);
+                logger.info("live-ingest: discovered metadata types", { count: discovered.length });
+            }
+            catch (e) {
+                logger.warn("live-ingest: metadata.describe failed", { err: e.message });
+            }
         }
         const existing = graph.getOrg(resolved.orgId);
         const requestedMode = opts.mode ?? "auto";
         let mode;
-        if (requestedMode === "auto") {
+        if (opts.metadataSource) {
+            mode = "full";
+        }
+        else if (requestedMode === "auto") {
             mode = existing?.lastSyncedAt && caps.sourceTracking ? "incremental" : "full";
         }
         else {
@@ -390,6 +322,11 @@ export async function liveIngest(opts) {
         let membersProcessed = 0;
         let parseErrors = 0;
         let deletions = 0;
+        // Incremental detects changed/added members but cannot fetch their content
+        // yet, so it skips them. If we then advanced the watermark past them, the
+        // next incremental would start AFTER those changes and never see them —
+        // silent permanent data loss. Track the count so we can HOLD the watermark.
+        let incrementalUnfetched = 0;
         // Set in the full-sync branch if the bulkRetrieve stream itself throws.
         // Detect-deletions reads it post-fan-out to bail out instead of mass-
         // wiping nodes that were never visited due to the abort.
@@ -410,18 +347,125 @@ export async function liveIngest(opts) {
         // the legacy `${label}: ${reason}` strings from skipReport.skips into the
         // final LiveIngestResult.warnings array. See bulk-retrieve.ts WedgeCoordinator.
         const wedgeWarnings = [];
+        // Task 10 rebuild fast path. On a full ingest into an org whose graph is
+        // empty at start, run the fan-out inside the store's bulk-load window:
+        // deferred secondary indexes, synchronous=OFF, one transaction per 2,000
+        // members, and no per-member delete probes for keys not yet written (the
+        // store tracks what this run wrote, so repeats are still reconciled and
+        // the graph is identical to the slow path). SFGRAPH_DISABLE_FASTPATH=1
+        // forces the per-member path (used by the same-output test and gate).
+        const fastPathDisabled = process.env.SFGRAPH_DISABLE_FASTPATH === "1";
+        const graphEmptyAtStart = !fastPathDisabled &&
+            mode === "full" &&
+            opts.rebuild !== false &&
+            typeof graph.beginBulk === "function" &&
+            typeof graph.endBulk === "function" &&
+            typeof graph.isOrgEmpty === "function" &&
+            graph.isOrgEmpty(resolved.orgId);
+        // A vector store on its own connection would hit SQLITE_BUSY behind the
+        // held bulk transaction, so keep per-member commits in that case.
+        const vectorDb = opts.vectorStore?.db;
+        const graphDb = graph.db;
+        const sharedConnection = vectorDb === undefined || vectorDb === graphDb;
+        // Every other full ingest (a normal sync, a delta's merge) writes into a
+        // graph that MCP servers may be reading, so the bulk window's relaxed
+        // pragmas and dropped indexes are not an option. It still groups members
+        // into plain transactions (store.beginBatch: BEGIN IMMEDIATE, committed
+        // only between members, at most ~200 ms each), which removes most of the
+        // per-member commit cost. Same SQLITE_BUSY rule as the bulk window: a
+        // vector store on its own connection keeps per-member commits.
+        const batchWrites = !fastPathDisabled &&
+            !graphEmptyAtStart &&
+            mode === "full" &&
+            sharedConnection &&
+            typeof graph.beginBatch === "function" &&
+            typeof graph.endBatch === "function";
+        let bulkOpen = false;
+        let batchOpen = false;
+        let bulkFailure = null;
+        const openBulk = () => {
+            if (graphEmptyAtStart && !bulkOpen) {
+                graph.beginBulk?.({
+                    freshOrgId: resolved.orgId,
+                    ...(sharedConnection ? {} : { batchTransactions: false }),
+                });
+                bulkOpen = true;
+            }
+            else if (batchWrites && !batchOpen) {
+                try {
+                    graph.beginBatch?.();
+                    batchOpen = true;
+                }
+                catch (e) {
+                    // e.g. the caller holds a transaction: keep per-member commits.
+                    logger.debug("live-ingest: write batching unavailable", { err: e.message });
+                }
+            }
+        };
+        const closeBulk = () => {
+            if (batchOpen) {
+                batchOpen = false;
+                graph.endBatch?.();
+            }
+            if (!bulkOpen)
+                return;
+            bulkOpen = false;
+            graph.endBulk?.();
+        };
         const parseCtxBase = {
             orgId: resolved.orgId,
             parseTimestamp: new Date(now).toISOString(),
             namespace: null,
             logger,
         };
-        const embedQueue = opts.vectorStore
-            ? new EmbeddingQueue({
+        // Task 11a: embeddings run off the graph-ready path. Inference happens in
+        // a worker thread (compiled builds) or an injected embedder, with up to 4
+        // batches in flight to keep it fed. The queue is HELD until graph ready:
+        // texts buffer (bounded by backpressure, which still forces batches out)
+        // and no inference competes for CPU with the graph build — measured, an
+        // overlapping worker slowed fan-out by ~45%. A persistent text → vector
+        // cache makes --rebuild skip the model for unchanged texts. The org is flagged `embeddings_pending` until every
+        // vector is written, so find_similar can fall back to text search and the
+        // next ingest can fill whatever a no-wait / failed run left behind. The
+        // flag is set lazily, when the queue first has real vector work (a text
+        // past the unchanged check at dispatch, or live work abandoned), so a
+        // re-sync with nothing to embed keeps find_similar's vector leg on.
+        let embedError = null;
+        let wasEmbeddingsPending = false;
+        if (opts.vectorStore) {
+            const workerUrl = opts.embedder ? null : defaultEmbeddingWorkerUrl();
+            ownedEmbedder = opts.embedder ? null : workerUrl ? new EmbeddingPool({ workerUrl }) : null;
+            const embedder = opts.embedder ?? ownedEmbedder;
+            if (opts.embeddingCacheFile) {
+                try {
+                    embedCache = EmbeddingCache.open(opts.embeddingCacheFile);
+                }
+                catch (e) {
+                    logger.warn("live-ingest: embedding cache unavailable", { err: e.message });
+                }
+            }
+            wasEmbeddingsPending = graph.getEmbeddingStatus?.(resolved.orgId)?.pending ?? false;
+            const maxPendingChars = Number.parseInt(process.env.SFGRAPH_EMBED_MAX_PENDING_CHARS ?? "", 10);
+            embedQueue = new EmbeddingQueue({
                 vectorStore: opts.vectorStore,
-                onError: (err) => logger.warn("live-ingest: embedding batch failed", { err: err.message }),
-            })
-            : null;
+                hold: true,
+                ...(maxPendingChars > 0 ? { maxPendingChars } : {}),
+                onWork: () => {
+                    if (!wasEmbeddingsPending)
+                        graph.setEmbeddingsPending?.(resolved.orgId, true);
+                },
+                onCacheError: (err) => {
+                    logger.warn("live-ingest: embedding cache write failed", { err: err.message });
+                },
+                ...(embedder ? { embed: (t) => embedder.embed(t), maxInFlight: 4 } : {}),
+                ...(embedCache ? { cache: embedCache } : {}),
+                onError: (err) => {
+                    if (!embedError)
+                        embedError = err;
+                    logger.warn("live-ingest: embedding batch failed", { err: err.message });
+                },
+            });
+        }
         const handleParsed = (parsed) => {
             if (parsed.nodes.length) {
                 graph.mergeNodes(parsed.nodes);
@@ -437,8 +481,29 @@ export async function liveIngest(opts) {
                     bucket.add(qn);
                 }
             }
-            if (parsed.edges.length)
-                graph.mergeEdges(parsed.edges);
+            // A parser's ParseResult is the COMPLETE authoritative outgoing-edge set
+            // for the member it parsed, so reconcile: prune any prior outgoing edge
+            // from these sources that the member no longer emits (fixes "immortal
+            // edges" — a SOQL/DML/CALLS that lingered after the code dropped it on a
+            // non-rebuild re-sync). Resolver post-passes (arity / overlap / reflection)
+            // re-add their cross-cutting edges afterward, so this is safe.
+            // N-5: a method the member still emits but that now has NO outgoing
+            // edge (its only call was removed) is not a source in `parsed.edges`,
+            // so it is named explicitly and its stale edges are pruned too.
+            const methodSrcs = [];
+            for (const n of parsed.nodes) {
+                if (n.label === "ApexMethod" || n.label === "TestMethod") {
+                    methodSrcs.push(String(n.qualifiedName));
+                }
+            }
+            if (parsed.edges.length || methodSrcs.length) {
+                graph.mergeEdges(parsed.edges, {
+                    reconcileSources: true,
+                    ...(methodSrcs.length
+                        ? { reconcileExtraSrcs: { orgId: resolved.orgId, qnames: methodSrcs } }
+                        : {}),
+                });
+            }
             if (parsed.snippets?.length) {
                 graph.transaction(() => {
                     for (const s of parsed.snippets ?? []) {
@@ -446,52 +511,117 @@ export async function liveIngest(opts) {
                     }
                 });
             }
-            if (embedQueue) {
+            // Fold the stored source snippet into the search text for code nodes so
+            // search matches on what the code DOES, not just its name/attrs. (The
+            // snippet text lives in parsed.snippets, not on the node.) Bounded to a
+            // few KB — MiniLM truncates to its token window anyway, and we keep the
+            // structured buildEmbedText prefix first so identity stays dominant. The
+            // SAME text feeds both the vector index and the FTS keyword index; FTS is
+            // populated regardless of embedQueue so it works as the embedder-down
+            // fallback leg of hybrid search.
+            if (parsed.nodes.length) {
+                const snippetByQname = new Map();
+                for (const s of parsed.snippets ?? []) {
+                    snippetByQname.set(String(s.qualifiedName), s.sourceText);
+                }
                 for (const n of parsed.nodes) {
-                    embedQueue.push({
-                        qname: String(n.qualifiedName),
-                        text: buildEmbedText(n.label, String(n.qualifiedName), n.attributes),
-                        orgId: String(n.orgId),
-                        label: n.label,
+                    const qn = String(n.qualifiedName);
+                    let text = buildEmbedText(n.label, qn, n.attributes);
+                    const snippet = snippetByQname.get(qn);
+                    if (snippet)
+                        text += `\n${snippet.slice(0, 4000)}`;
+                    graph.upsertNodeFts(n.orgId, n.qualifiedName, n.label, text);
+                    if (embedQueue) {
+                        embedQueue.push({ qname: qn, text, orgId: String(n.orgId), label: n.label });
+                    }
+                }
+            }
+        };
+        // Purge a deleted node's vector so it stops surfacing as a phantom
+        // find_similar hit. The vec0 table lives in the VectorStore (not the graph
+        // store); feature-detect since lightweight sinks may not implement delete.
+        const purgeNodeVector = (qname) => {
+            const sink = opts.vectorStore;
+            if (sink && typeof sink.deleteNodeVector === "function") {
+                try {
+                    sink.deleteNodeVector(resolved.orgId, qname);
+                }
+                catch (e) {
+                    logger.warn("live-ingest: vector purge failed", {
+                        qname: String(qname),
+                        err: e.message,
                     });
                 }
             }
         };
         const debugProcess = process.env.SFGRAPH_DEBUG_INGEST === "1";
-        const processOne = async (ref, content) => {
+        // Per-member timings, filled by applyMember (parse vs. store write) and
+        // consumed by the member loop. Reset on every call. These are shared
+        // closure state: applyMember must NOT be called concurrently.
+        let lastParseMs = 0;
+        let lastWriteMs = 0;
+        // Apply one member's parse outcome to the graph (or delete an obsolete
+        // member). Always on the main thread, in member order: the parse may have
+        // run in a worker (parsePool), the writes never do.
+        const applyMember = (ref, outcome) => {
             const qnameForLog = `${ref.memberType}:${ref.memberName}`;
+            lastParseMs = 0;
+            lastWriteMs = 0;
             if (ref.obsolete) {
-                // Build the qualified name same way parsers would: best-effort by member name.
-                const qname = asQualifiedName(`${ref.memberType}:${ref.memberName}`);
+                // Build the qname with the node's LABEL, not the raw SourceMember type:
+                // e.g. LightningComponentBundle is stored as `LWC:<name>`, so the old
+                // `${memberType}:${name}` never matched and LWC deletes were silent
+                // no-ops. Fall back to memberType when no mapping exists.
+                const label = MEMBER_TYPE_TO_NODE_LABEL[ref.memberType] ?? ref.memberType;
+                const qname = asQualifiedName(`${label}:${ref.memberName}`);
                 if (debugProcess)
                     console.log(`ingest: [trace] delete ← ${qnameForLog}`);
+                // Cascade to contained children (a class/trigger owns ApexMethod /
+                // TestMethod nodes via CONTAINS_METHOD). Deleting only the parent left
+                // the method nodes — and their edges/snippets/vectors — orphaned.
+                for (const e of graph.listEdgesFrom(resolved.orgId, qname, REL_TYPES.CONTAINS_METHOD)) {
+                    const child = e.dstQualifiedName;
+                    graph.deleteEdgesFor(resolved.orgId, child);
+                    graph.deleteNode(resolved.orgId, child);
+                    purgeNodeVector(child);
+                }
                 graph.deleteEdgesFor(resolved.orgId, qname);
                 graph.deleteNode(resolved.orgId, qname);
+                purgeNodeVector(qname);
                 if (debugProcess)
                     console.log(`ingest: [trace] delete ✓ ${qnameForLog}`);
                 deletions += 1;
                 return;
             }
-            const adapted = adaptParserInput(ref, content);
-            if (!adapted)
-                return;
-            const parser = parserRegistry.for(adapted.type);
-            if (!parser)
+            // Building the parser input threw: surfaces to the member loop's catch.
+            if (outcome.kind === "error" && outcome.phase === "adapt")
+                throw new Error(outcome.message);
+            if (outcome.kind === "skip")
                 return;
+            // Emitted when the result is applied (in member order); the parse itself
+            // may have run earlier in a worker.
+            if (debugProcess)
+                console.log(`ingest: [trace] parse ← ${qnameForLog}`);
+            lastParseMs = outcome.parseMs;
             try {
-                const ctx = {
-                    ...parseCtxBase,
-                    sourceUri: ref.sourceUri,
-                    namespace: ref.namespace ?? null,
-                };
-                if (debugProcess)
-                    console.log(`ingest: [trace] parse ← ${qnameForLog}`);
-                const result = await parser.parse(adapted.input, ctx);
+                if (outcome.kind === "error") {
+                    const err = new Error(outcome.message);
+                    if (outcome.stack)
+                        err.stack = outcome.stack;
+                    throw err;
+                }
+                const result = outcome.result;
                 if (debugProcess)
                     console.log(`ingest: [trace] parse ✓ ${qnameForLog} (nodes=${result.nodes.length} edges=${result.edges.length})`);
                 if (debugProcess)
                     console.log(`ingest: [trace] graph-merge ← ${qnameForLog}`);
-                handleParsed(result);
+                const tWrite = performance.now();
+                try {
+                    handleParsed(result);
+                }
+                finally {
+                    lastWriteMs = performance.now() - tWrite;
+                }
                 if (debugProcess)
                     console.log(`ingest: [trace] graph-merge ✓ ${qnameForLog}`);
                 membersProcessed += 1;
@@ -508,13 +638,161 @@ export async function liveIngest(opts) {
                 }
             }
         };
+        // Task 11c: member rows (delta ingest's record of what each member owns)
+        // and the ghost sweep, on a full ingest of a metadataSource. The rows are
+        // cleared now and rewritten only once the ingest completes, so an
+        // interrupted run leaves no rows and the next delta falls back to a full
+        // rebuild. The ghost sweep deletes what a member owned last run that no
+        // member owns now (a deleted / renamed file), before the resolvers run.
+        if (opts.delta && (!opts.metadataSource || mode !== "full")) {
+            throw new Error("liveIngest: delta hooks need a metadataSource and mode 'full'");
+        }
+        const deltaHooks = opts.delta;
+        const priorRows = !deltaHooks &&
+            opts.metadataSource &&
+            mode === "full" &&
+            graph.listMemberRows &&
+            graph.replaceMemberRows
+            ? graph.listMemberRows(resolved.orgId)
+            : null;
+        if (priorRows && priorRows.length > 0)
+            graph.clearMemberRows?.(resolved.orgId);
+        const memberRows = priorRows ? new Map() : null;
+        const priorRowByKey = new Map((priorRows ?? []).map((r) => [r.key, r]));
+        const keptPrior = [];
+        // T15 N5-1: members quarantined by earlier runs (workers kept failing on
+        // that exact content) are not parsed again until their content changes.
+        const quarantinedKeys = new Set((priorRows ?? []).filter((r) => isQuarantinedRow(r)).map((r) => r.key));
+        const quarantinePreset = (m) => quarantinedKeys.has(m.ref.sourceUri) &&
+            isQuarantinedFor(priorRowByKey.get(m.ref.sourceUri), memberContentHash(m.content))
+            ? quarantinedOutcome()
+            : undefined;
+        const recordMemberRow = (member, outcome, errored) => {
+            if (!memberRows)
+                return;
+            const key = member.ref.sourceUri;
+            const prior = priorRowByKey.get(key);
+            const owned = outcome.kind === "parsed" ? ownedQnames(outcome.result) : [];
+            if (errored || (isParseFailureOnly(owned) && hasGoodPriorOwned(prior))) {
+                // Keep what it owned (its nodes are not re-emitted, nor swept). A
+                // member that parsed to ParseError only (N2-1) or whose parse threw
+                // records the hash of its broken content and is skipped until it
+                // changes; one whose merge failed is retried by every delta.
+                if (hasGoodPriorOwned(prior))
+                    keptPrior.push(key);
+                memberRows.set(key, {
+                    key,
+                    ...memberFailureStamp(member, outcome, errored, prior),
+                    owned: [...new Set([...(prior?.owned ?? []), ...owned])],
+                });
+                return;
+            }
+            memberRows.set(key, {
+                key,
+                fingerprint: member.fingerprint ?? "",
+                hash: memberContentHash(member.content),
+                owned,
+            });
+        };
+        const finishMemberRows = () => {
+            if (!memberRows || !priorRows)
+                return;
+            if (streamAborted) {
+                memberRows.clear();
+                return;
+            }
+            if (priorRows.length === 0)
+                return;
+            // Members the source indexed but could not load (unreadable, malformed)
+            // keep their previous graph and row (retried by the next delta).
+            const unloaded = opts.metadataSource?.unloadedKeys?.();
+            if (unloaded) {
+                for (const r of priorRows) {
+                    if (!unloaded.has(r.key) || memberRows.has(r.key))
+                        continue;
+                    memberRows.set(r.key, { ...r, fingerprint: "" });
+                    keptPrior.push(r.key);
+                }
+            }
+            if (keptPrior.length > 0) {
+                wedgeWarnings.push(`wedge:ingest:kept-prior:members=${keptPrior.length}`);
+                logger.warn("live-ingest: unreadable / unparseable members keep their previous graph", {
+                    members: keptPrior.slice(0, 20),
+                });
+            }
+            if (memberRows.size === 0) {
+                // Same guard as detect-deletions' empty-stream refusal: a source that
+                // yielded no members at all (wrong path, unreadable tree) must not
+                // wipe the graph. No rows are written, so the next delta rebuilds.
+                wedgeWarnings.push(`wedge:ghost-sweep:refuse:reason=empty-stream:priorMembers=${priorRows.length}`);
+                logger.warn("live-ingest: ghost sweep refused (the source yielded no members)", {
+                    priorMembers: priorRows.length,
+                });
+                return;
+            }
+            // Qnames match case-insensitively (the store's NOCASE): `ApexClass:Util`
+            // re-emitted as `ApexClass:UTIL` is the same node, not a ghost.
+            const ownedNow = new Set();
+            for (const r of memberRows.values())
+                for (const q of r.owned)
+                    ownedNow.add(q.toLowerCase());
+            const ghosts = [];
+            for (const r of priorRows) {
+                for (const q of r.owned)
+                    if (!ownedNow.has(q.toLowerCase()))
+                        ghosts.push(q);
+            }
+            if (ghosts.length === 0)
+                return;
+            let removed = 0;
+            graph.transaction(() => {
+                graph.deleteEdgesFrom?.(resolved.orgId, ghosts);
+                graph.deleteReflectionEdges?.(resolved.orgId, { dsts: ghosts });
+                for (const q of new Set(ghosts)) {
+                    const qn = asQualifiedName(q);
+                    if (!graph.getNode(resolved.orgId, qn))
+                        continue;
+                    graph.deleteNode(resolved.orgId, qn);
+                    purgeNodeVector(qn);
+                    removed += 1;
+                }
+            });
+            deletions += removed;
+            if (removed > 0)
+                logger.info("live-ingest: ghost sweep removed nodes of vanished members", { removed });
+        };
+        // Serial parse + apply (incremental deletions).
+        const processOne = async (ref, content) => {
+            const outcome = ref.obsolete
+                ? { kind: "skip", parseMs: 0 }
+                : await parseMember(ref, content, parseCtxBase, logger);
+            applyMember(ref, outcome);
+        };
         if (mode === "incremental") {
             const sinceIso = existing?.lastSyncedAt
                 ? new Date(existing.lastSyncedAt).toISOString()
                 : new Date(now - 24 * 3600 * 1000).toISOString();
+            // Incremental applies DELETIONS (obsolete members need no content) but
+            // does NOT re-parse changed/added members: their content is not fetched
+            // here, and calling processOne(ref, "") would overwrite real node
+            // attributes with empty-parse garbage and emit no edges — actively
+            // degrading the graph. Until per-member content fetch lands, changed
+            // members are counted and the user is told to run a full ingest to
+            // refresh them. (Deletions are still valuable and safe.)
+            let changedNotApplied = 0;
             for await (const ref of iterChanges(resolved.conn, resolved.orgId, sinceIso)) {
-                // For incremental, content is best fetched on-demand; for deletions we skip content.
-                await processOne(ref, "");
+                if (ref.obsolete) {
+                    await processOne(ref, "");
+                }
+                else {
+                    changedNotApplied += 1;
+                }
+            }
+            incrementalUnfetched = changedNotApplied;
+            if (changedNotApplied > 0) {
+                const msg = `incremental: ${changedNotApplied} changed/added member(s) detected but NOT refreshed (content fetch not implemented for incremental). The sync watermark is being HELD so the next run re-detects them. Run \`sfgraph ingest --org ${resolved.alias} --rebuild\` (or --mode full) to capture them.`;
+                logger.warn(msg);
+                wedgeWarnings.push(`incremental:contentNotFetched:count=${changedNotApplied}`);
             }
         }
         else {
@@ -537,7 +815,8 @@ export async function liveIngest(opts) {
             // different edge tables rather than competing for the same row, but
             // the pre-fan-out ordering preserves the "parsed wins" guarantee for
             // the (rare) case where a parser does emit REFERENCES.
-            if (!opts.disableMcdBaseline) {
+            openBulk();
+            if (!opts.disableMcdBaseline && !opts.metadataSource) {
                 try {
                     const { runMcdBaseline } = await import("../extractors/live-org/extractors/mcd-baseline.js");
                     const mcdCtx = {
@@ -614,7 +893,7 @@ export async function liveIngest(opts) {
                 // benefit. The probe's job is observability, not control flow.
                 // Disable via SFGRAPH_NO_LIVENESS_PROBE=1 for hermetic test runs
                 // where the mock connection has no identity() implementation.
-                if (process.env.SFGRAPH_NO_LIVENESS_PROBE !== "1") {
+                if (process.env.SFGRAPH_NO_LIVENESS_PROBE !== "1" && !opts.metadataSource) {
                     livenessProbe = startLivenessProbe(resolved.conn);
                 }
                 // Wall-clock heartbeat — always on. Without this, silent phases (where
@@ -667,6 +946,17 @@ export async function liveIngest(opts) {
                         console.error(`ingest: [debug] received ${sig} after ${Math.round((Date.now() - fanOutStart) / 1000)}s — processed=${progressCount} lastSource=${lastMemberLabel}`);
                         console.error(new Error(`signal:${sig}`).stack);
                         process.exitCode = 130;
+                        // rel-08: a breadcrumb only — never swallow the signal. Drop the
+                        // debug handlers; if nothing else handles it (an embedding host
+                        // or the CLI would), re-raise so the default action terminates.
+                        // Review minor 12: on the library path the default action kills
+                        // the process without the finally blocks, so the ingest lock file
+                        // and sync_in_progress stay behind; the next run reclaims both
+                        // through the dead-owner (stale pid) check (rel-02).
+                        for (const h of installedSignalHandlers.splice(0))
+                            process.off(h.sig, h.fn);
+                        if (process.listenerCount(sig) === 0)
+                            process.kill(process.pid, sig);
                     };
                     const onUsr2 = () => {
                         const mem = process.memoryUsage();
@@ -679,21 +969,65 @@ export async function liveIngest(opts) {
                         process.on(h.sig, h.fn);
                 }
                 try {
-                    for await (const member of bulkRetrieve(resolved.conn, caps, resolved.orgId, {
-                        skipReport,
-                        warnings: wedgeWarnings,
-                        ...(opts.onlyLabels ? { onlyLabels: opts.onlyLabels } : {}),
-                        // The bulk-retrieve flag name follows the same convention as
-                        // the bulk-retrieve's other opts; semantically it's "do the
-                        // retrieve()" which is now on by default. Caller-side disable
-                        // routes through this same boolean inverted.
-                        ...(opts.disableOmnistudioRetrieve ? {} : { enableOmnistudioRetrieve: true }),
-                        // jsforce attaches the version it negotiated on conn.version; fall
-                        // back to a sensible recent release if absent (mocks, etc.)
-                        apiVersion: resolved.conn.version ?? "60.0",
-                    })) {
+                    const memberStream = deltaHooks
+                        ? deltaHooks.members
+                        : opts.metadataSource
+                            ? opts.metadataSource.iter()
+                            : bulkRetrieve(resolved.conn, caps, resolved.orgId, {
+                                skipReport,
+                                warnings: wedgeWarnings,
+                                ...(opts.onlyLabels ? { onlyLabels: opts.onlyLabels } : {}),
+                                ...(opts.explicitOnlyLabels ? { explicitOnlyLabels: true } : {}),
+                                // The bulk-retrieve flag name follows the same convention as
+                                // the bulk-retrieve's other opts; semantically it's "do the
+                                // retrieve()" which is now on by default. Caller-side disable
+                                // routes through this same boolean inverted.
+                                ...(opts.disableOmnistudioRetrieve ? {} : { enableOmnistudioRetrieve: true }),
+                                // jsforce attaches the version it negotiated on conn.version; fall
+                                // back to a sensible recent release if absent (mocks, etc.)
+                                apiVersion: resolved.conn.version ?? "60.0",
+                            });
+                    const tFanout = performance.now();
+                    // Task 11b: parse in worker threads (SFGRAPH_PARSE_WORKERS, default
+                    // min(4, availableParallelism - 1); 0 = main thread), apply in member
+                    // order here.
+                    const parseStats = opts.parsePool?.stats ?? {
+                        workers: 0,
+                        pooled: 0,
+                        inProcess: 0,
+                        fallbacks: 0,
+                        crashes: 0,
+                        oomFallbacks: 0,
+                    };
+                    const parsed = parsePool(memberStream, {
+                        orgId: parseCtxBase.orgId,
+                        parseTimestamp: parseCtxBase.parseTimestamp,
+                        logger,
+                        workers: opts.parsePool?.workers ?? resolveParseWorkers(),
+                        ...(opts.parsePool?.workerUrl !== undefined
+                            ? { workerUrl: opts.parsePool.workerUrl }
+                            : {}),
+                        ...(opts.parsePool?.minMembers !== undefined
+                            ? { minMembers: opts.parsePool.minMembers }
+                            : {}),
+                        stats: parseStats,
+                        ...(quarantinedKeys.size > 0 ? { preset: quarantinePreset } : {}),
+                    });
+                    for await (const { member, outcome } of parsed) {
+                        const errorsBefore = parseErrors;
+                        if (batchOpen)
+                            graph.batchMemberStart?.();
                         try {
-                            await processOne(member.ref, member.content);
+                            applyMember(member.ref, outcome);
+                            if (profiler.enabled) {
+                                profiler.member({
+                                    qname: `${member.ref.memberType}:${member.ref.memberName}`,
+                                    label: member.ref.memberType,
+                                    bytes: member.content.length,
+                                    parseMs: lastParseMs,
+                                    writeMs: lastWriteMs,
+                                });
+                            }
                         }
                         catch (e) {
                             parseErrors += 1;
@@ -702,6 +1036,33 @@ export async function liveIngest(opts) {
                                 error: e.message,
                             });
                         }
+                        // Task 11c: member rows (what each member owns) for delta ingest.
+                        const errored = outcome.kind === "error" || parseErrors > errorsBefore;
+                        if (deltaHooks)
+                            deltaHooks.onMember(member, outcome, errored);
+                        else if (memberRows && member.fingerprint !== undefined) {
+                            recordMemberRow(member, outcome, errored);
+                        }
+                        if (bulkOpen || batchOpen) {
+                            // Outside the per-member catch: if SQLite rolled back the bulk
+                            // transaction (SQLITE_FULL / IOERR / NOMEM), up to 2,000 earlier
+                            // members are gone, so the ingest must fail, not count one error.
+                            // The same holds for a live-graph batch.
+                            try {
+                                if (bulkOpen)
+                                    graph.bulkMemberDone?.();
+                                else
+                                    graph.batchMemberDone?.();
+                            }
+                            catch (e) {
+                                bulkFailure = e;
+                                break;
+                            }
+                        }
+                        // Backpressure: past the queued-text bound, wait for forced
+                        // batches to drain (the only inference during fan-out).
+                        if (embedQueue?.overCapacity)
+                            await embedQueue.waitForCapacity();
                         progressCount += 1;
                         lastActivityAt = Date.now();
                         lastMemberLabel = `${member.ref.memberType}:${member.ref.memberName}`;
@@ -719,6 +1080,9 @@ export async function liveIngest(opts) {
                                 gs.checkpoint();
                         }
                     }
+                    profiler.phase("fanout", performance.now() - tFanout);
+                    // Always printed (serial too) so bench runs can record the counts.
+                    console.log(`ingest: parse pool: ${parseStats.workers} workers, ${parseStats.pooled} parsed in workers, ${parseStats.inProcess} on main (${parseStats.fallbacks} fallbacks, ${parseStats.crashes} worker crashes, ${parseStats.oomFallbacks ?? 0} heap-cap re-parses)`);
                     console.log(`ingest: fan-out complete (${progressCount} members in ${Math.round((Date.now() - fanOutStart) / 1000)}s)`);
                     const gs = graph;
                     if (typeof gs.checkpoint === "function")
@@ -731,6 +1095,8 @@ export async function liveIngest(opts) {
                     logger.warn("live-ingest: bulkRetrieve stream aborted", {
                         error: e.message,
                     });
+                    // Never a silent partial ingest: the abort is in the result's warnings.
+                    wedgeWarnings.push(`stream:aborted:${String(e.message).slice(0, 200)}`);
                 }
             }
             finally {
@@ -741,6 +1107,31 @@ export async function liveIngest(opts) {
                 livenessProbe?.stop();
                 for (const h of installedSignalHandlers)
                     process.off(h.sig, h.fn);
+                // Commit the last bulk batch and rebuild the deferred indexes before
+                // any post-pass reads the graph.
+                const tEndBulk = performance.now();
+                closeBulk();
+                if (graphEmptyAtStart)
+                    profiler.phase("endBulk", performance.now() - tEndBulk);
+            }
+            if (bulkFailure)
+                throw bulkFailure;
+            if (deltaHooks) {
+                // A partial stream must not be finalized as a delta: fail, keeping
+                // the pending marker, so the next delta replays it.
+                if (streamAborted)
+                    throw new Error("delta: member stream aborted");
+                deltaHooks.afterMerge();
+            }
+            else if (memberRows) {
+                finishMemberRows();
+            }
+            // A scoped run (auto-retry pass, --retry-skipped, --only) re-ran only
+            // `onlyLabels`: carry the previous report's entries for every OTHER
+            // label forward, so unreadable / insufficient_access entries it did
+            // not touch stay in the report, the summary and the warnings (I2).
+            if (opts.onlyLabels && opts.skipReportPath) {
+                skipReport.skips.push(...carriedOverSkips(opts.skipReportPath, resolved.orgId, opts.onlyLabels));
             }
             // End-of-run skip summary. Grouped by category so the remediation is
             // targeted to the specific class of failure.
@@ -762,19 +1153,16 @@ export async function liveIngest(opts) {
                 }
             }
         }
-        if (embedQueue) {
-            try {
-                await embedQueue.drain();
-            }
-            catch (e) {
-                logger.warn("live-ingest: embed drain failed", { err: e.message });
-            }
-        }
+        // Mark the end of input (the held queue still runs nothing until graph ready).
+        embedQueue?.startDrain();
         // Full-sync deletion detection: compute previously-known minus touched and
         // delete the difference. Skipped on incremental (SourceMember handles it),
         // skipped if any parse error occurred this run (avoid mass-wipe on
         // transient SF errors).
-        if (opts.detectDeletions && mode === "full") {
+        // Fast path: an org that was empty at start has no stale qnames — every
+        // persisted node was touched by this run — so the sweep (and its
+        // deleteEdgesFor calls) would be a no-op; skip it.
+        if (opts.detectDeletions && !opts.metadataSource && mode === "full" && !graphEmptyAtStart) {
             if (streamAborted) {
                 logger.warn("live-ingest: detect-deletions skipped because bulkRetrieve stream aborted — touchedQnames is incomplete and a full deletion sweep would wrongly wipe untouched-but-still-present nodes");
             }
@@ -790,7 +1178,18 @@ export async function liveIngest(opts) {
                     // compounds with the W1.5-01/02 wedge cascade). Now we evaluate the
                     // guard per label and refuse when the implied drop is suspicious.
                     const maxDropRatio = resolveMaxDropRatio(process.env.SFGRAPH_DETECT_DELETIONS_MAX_DROP_RATIO);
-                    const labels = graph.listAllLabels();
+                    // Task 11c: a node from a source this run skipped (or carried a
+                    // skip for) is never "stale" — the source touched nothing.
+                    const protection = skipProtection(skipReport.skips);
+                    if (protection.refuseAll) {
+                        const warning = `wedge:detect-deletions:refuse:label=*:reason=skipped-source:skips=${protection.unknownLabels.join(",")}`;
+                        wedgeWarnings.push(warning);
+                        logger.warn("live-ingest: detect-deletions refused (a skipped source has no type mapping)", {
+                            skips: protection.unknownLabels,
+                        });
+                    }
+                    const labels = protection.refuseAll ? [] : graph.listAllLabels();
+                    let protectedCount = 0;
                     for (const label of labels) {
                         const priorCount = graph.countNodesByLabel(resolved.orgId, label);
                         const touchedCount = touchedQnamesByLabel.get(label)?.size ?? 0;
@@ -818,8 +1217,13 @@ export async function liveIngest(opts) {
                             const q = String(node.qualifiedName);
                             if (touchedSet?.has(q))
                                 continue;
+                            if (isSkipProtected(protection, node)) {
+                                protectedCount += 1;
+                                continue;
+                            }
                             graph.deleteEdgesFor(resolved.orgId, asQualifiedName(q));
                             graph.deleteNode(resolved.orgId, asQualifiedName(q));
+                            purgeNodeVector(asQualifiedName(q));
                             deletions += 1;
                             labelDeletions += 1;
                         }
@@ -830,12 +1234,50 @@ export async function liveIngest(opts) {
                             });
                         }
                     }
+                    if (protectedCount > 0) {
+                        logger.info("live-ingest: detect-deletions kept nodes of skipped sources", {
+                            count: protectedCount,
+                        });
+                    }
                 }
                 catch (e) {
                     logger.warn("live-ingest: detect-deletions failed", { err: e.message });
                 }
             }
         }
+        // Backfill: an earlier run returned before its vectors were all written
+        // (--no-wait-embeddings, a worker crash, a kill). Every embedded text is
+        // also stored verbatim as the node's FTS body, so re-queue the docs this
+        // run did not touch whose stored vector is missing or stale.
+        let backfilled = 0;
+        if (embedQueue && wasEmbeddingsPending && graph.listFtsDocs) {
+            const sink = opts.vectorStore;
+            try {
+                for (const doc of graph.listFtsDocs(resolved.orgId)) {
+                    if (touchedQnames.has(doc.qname))
+                        continue;
+                    const stored = sink?.getContentHash?.(resolved.orgId, asQualifiedName(doc.qname));
+                    if (stored && stored === hashEmbedText(doc.body))
+                        continue;
+                    embedQueue.push({
+                        qname: doc.qname,
+                        text: doc.body,
+                        orgId: String(resolved.orgId),
+                        label: doc.label,
+                    });
+                    backfilled += 1;
+                    if (embedQueue.overCapacity)
+                        await embedQueue.waitForCapacity();
+                }
+            }
+            catch (e) {
+                logger.warn("live-ingest: embedding backfill failed", { err: e.message });
+            }
+            if (backfilled > 0) {
+                logger.info("live-ingest: re-queued pending embeddings", { backfilled });
+            }
+            embedQueue.startDrain();
+        }
         // -----------------------------------------------------------------------
         // Post-merge resolver passes. Each step is isolated in try/catch so a
         // single resolver bug never breaks ingest — it just reports zero work done.
@@ -843,14 +1285,30 @@ export async function liveIngest(opts) {
         let crossFlavorEdges = 0;
         let arityResolved = 0;
         let flowMethodsResolved = 0;
+        let vlocityApexResult;
+        let drRelationshipsResult;
         let danglingEdges = 0;
         let overlapResult = { matched: 0, diverged: 0, empty: 0, annotated: 0 };
         let reflectionEdges = 0;
+        // T15 I-2: post-merge steps that threw. A full ingest only warns; a delta
+        // must not finalize (see below).
+        const postFailures = [];
         // Synth a ParseContext for post-passes that need to mint edges/nodes.
         const postCtx = {
             ...parseCtxBase,
             sourceUri: "post-merge://resolver",
         };
+        // review I4: re-target Aura `<c:name>` embeds at the bundles that exist.
+        try {
+            const auraEmbeds = resolveAuraEmbeds(graph, resolved.orgId);
+            if (auraEmbeds.retargeted > 0) {
+                logger.info("live-ingest: aura embed resolver re-targeted embeds", { ...auraEmbeds });
+            }
+        }
+        catch (e) {
+            postFailures.push("aura embed resolver");
+            logger.warn("live-ingest: aura embed resolver failed", { err: e.message });
+        }
         if (!opts.disableCrossFlavor) {
             try {
                 crossFlavorEdges = resolveCrossFlavor(graph, {
@@ -865,6 +1323,7 @@ export async function liveIngest(opts) {
                 }
             }
             catch (e) {
+                postFailures.push("cross-flavor resolver");
                 logger.warn("live-ingest: cross-flavor resolver failed", { err: e.message });
             }
         }
@@ -889,12 +1348,14 @@ export async function liveIngest(opts) {
                 }
             }
             catch (e) {
+                postFailures.push("omnistudio overlap detector");
                 logger.warn("live-ingest: omnistudio overlap detector failed", {
                     err: e.message,
                 });
             }
         }
         if (!opts.disableFlowInvocableResolve) {
+            const tPhase = performance.now();
             try {
                 const flowResult = resolveFlowApexMethods(graph, resolved.orgId, postCtx);
                 flowMethodsResolved = flowResult.resolved;
@@ -908,14 +1369,134 @@ export async function liveIngest(opts) {
                 }
             }
             catch (e) {
+                postFailures.push("flow→apex resolver");
                 logger.warn("live-ingest: flow→apex resolver failed", { err: e.message });
             }
+            profiler.phase("resolver:flow-apex", performance.now() - tPhase);
+        }
+        if (!opts.disableVlocityApexResolve) {
+            const tPhase = performance.now();
+            try {
+                const { resolveVlocityApex } = await import("../parsers/vlocity/apex-resolver.js");
+                vlocityApexResult = resolveVlocityApex(graph, resolved.orgId, postCtx);
+                if (vlocityApexResult.scanned > 0)
+                    logger.info("live-ingest: vlocity→apex resolver", vlocityApexResult);
+            }
+            catch (e) {
+                postFailures.push("vlocity-apex-resolver");
+                logger.warn(`vlocity-apex-resolver:failed:${e.message}`);
+                wedgeWarnings.push(`vlocity-apex-resolver:failed:${e.message}`);
+            }
+            profiler.phase("resolver:vlocity-apex", performance.now() - tPhase);
+        }
+        if (!opts.disableDrRelationshipResolve) {
+            const tPhase = performance.now();
+            try {
+                const { resolveDataRaptorRelationships } = await import("../parsers/vlocity/dr-relationship-resolver.js");
+                drRelationshipsResult = resolveDataRaptorRelationships(graph, resolved.orgId, postCtx);
+                if (drRelationshipsResult.scanned > 0)
+                    logger.info("live-ingest: dataraptor relationship-path resolver", drRelationshipsResult);
+            }
+            catch (e) {
+                postFailures.push("dr-relationship-resolver");
+                logger.warn(`dr-relationship-resolver:failed:${e.message}`);
+                wedgeWarnings.push(`dr-relationship-resolver:failed:${e.message}`);
+            }
+            profiler.phase("resolver:dr-relationship", performance.now() - tPhase);
+        }
+        if (!opts.disableFlowRelationshipResolve) {
+            const tPhase = performance.now();
+            try {
+                const { resolveFlowRelationshipPaths } = await import("../parsers/flow/relationship-resolver.js");
+                const fr = resolveFlowRelationshipPaths(graph, resolved.orgId, postCtx);
+                if (fr.scanned > 0)
+                    logger.info("live-ingest: flow relationship-path resolver", { ...fr });
+            }
+            catch (e) {
+                postFailures.push("flow-relationship-resolver");
+                logger.warn(`flow-relationship-resolver:failed:${e.message}`);
+                wedgeWarnings.push(`flow-relationship-resolver:failed:${e.message}`);
+            }
+            profiler.phase("resolver:flow-relationship", performance.now() - tPhase);
+        }
+        if (!opts.disableLwcFieldKeyResolve) {
+            const tPhase = performance.now();
+            try {
+                const { resolveLwcFieldKeys } = await import("../parsers/lwc/field-key-resolver.js");
+                const r = resolveLwcFieldKeys(graph, resolved.orgId, postCtx);
+                if (r.scanned > 0)
+                    logger.info("live-ingest: lwc field-key resolver", { ...r });
+            }
+            catch (e) {
+                postFailures.push("lwc-field-key-resolver");
+                logger.warn(`lwc-field-key-resolver:failed:${e.message}`);
+                wedgeWarnings.push(`lwc-field-key-resolver:failed:${e.message}`);
+            }
+            profiler.phase("resolver:lwc-field-key", performance.now() - tPhase);
+        }
+        if (!opts.disableVlocityNameMatchResolve) {
+            const tPhase = performance.now();
+            try {
+                const { resolveVlocityNameMatches } = await import("../parsers/vlocity/name-match-resolver.js");
+                const nm = resolveVlocityNameMatches(graph, resolved.orgId, postCtx);
+                if (nm.scanned > 0)
+                    logger.info("live-ingest: vlocity name-match resolver", { ...nm });
+            }
+            catch (e) {
+                postFailures.push("vlocity-name-match-resolver");
+                logger.warn(`vlocity-name-match-resolver:failed:${e.message}`);
+                wedgeWarnings.push(`vlocity-name-match-resolver:failed:${e.message}`);
+            }
+            profiler.phase("resolver:vlocity-name-match", performance.now() - tPhase);
+        }
+        if (!opts.disableApexRefResolve) {
+            const tPhase = performance.now();
+            try {
+                const { resolveApexReferences } = await import("../parsers/apex/ref-resolver.js");
+                const { apexRefNoWorkResult } = await import("./resolver-gates.js");
+                // Skip its whole-graph reads when it provably has no input and no
+                // earlier output to prune (same result object it would return).
+                const ar = apexRefNoWorkResult(graph, resolved.orgId) ??
+                    resolveApexReferences(graph, resolved.orgId, postCtx);
+                if (ar.edgesEmitted > 0 || ar.pathsUnresolved > 0 || ar.dynamicSoqlFieldsSkipped > 0)
+                    logger.info("live-ingest: apex ref resolver", { ...ar });
+            }
+            catch (e) {
+                postFailures.push("apex-ref-resolver");
+                logger.warn(`apex-ref-resolver:failed:${e.message}`);
+                wedgeWarnings.push(`apex-ref-resolver:failed:${e.message}`);
+            }
+            profiler.phase("resolver:apex-ref", performance.now() - tPhase);
+        }
+        // `ApexClass:X` references to an interface X (no class X): move them onto
+        // `ApexInterface:X`. Before arity, which then sees interface method calls
+        // under their real owner.
+        let interfaceRefsRetargeted = 0;
+        if (!opts.disableInterfaceRetarget) {
+            const tPhase = performance.now();
+            try {
+                const names = deltaHooks?.retargetInterfaceNames();
+                interfaceRefsRetargeted = retargetApexInterfaceRefs(graph, resolved.orgId, names ? { interfaceNames: names } : {});
+                if (interfaceRefsRetargeted > 0) {
+                    logger.info("live-ingest: apex interface references retargeted", {
+                        interfaceRefsRetargeted,
+                    });
+                }
+            }
+            catch (e) {
+                postFailures.push("apex interface retarget");
+                logger.warn("live-ingest: apex interface retarget failed", { err: e.message });
+            }
+            profiler.phase("resolver:interface-retarget", performance.now() - tPhase);
         }
         if (!opts.disableArityResolve) {
+            const tPhase = performance.now();
             try {
+                const scope = deltaHooks?.arityScope();
                 const arityResult = resolveApexMethodArity(graph, {
                     orgId: resolved.orgId,
                     ctx: postCtx,
+                    ...(scope ? { scope } : {}),
                 });
                 arityResolved = arityResult.resolved;
                 if (arityResult.scanned > 0) {
@@ -929,18 +1510,39 @@ export async function liveIngest(opts) {
                 }
             }
             catch (e) {
+                postFailures.push("apex arity resolver");
                 logger.warn("live-ingest: apex arity resolver failed", { err: e.message });
             }
+            profiler.phase("resolver:arity", performance.now() - tPhase);
+        }
+        // A formula's second-hop field guess moves onto the CustomField that
+        // declares that relationshipName.
+        if (!opts.disableFormulaHopResolve) {
+            const tPhase = performance.now();
+            try {
+                const sources = deltaHooks?.hopSources();
+                const hop = resolveFormulaRelationshipHops(graph, resolved.orgId, sources ? { sources } : {});
+                if (hop.moved > 0)
+                    logger.info("live-ingest: formula relationship hops resolved", { ...hop });
+            }
+            catch (e) {
+                postFailures.push("formula hop resolver");
+                logger.warn("live-ingest: formula hop resolver failed", { err: e.message });
+            }
+            profiler.phase("resolver:formula-hop", performance.now() - tPhase);
         }
         // Reflection walker: runs BEFORE the dangling-edge audit so any
         // REFERENCES edges it emits are validated by the audit alongside
         // parser-emitted edges. Default on; disable via disableReflectionWalker.
         if (!opts.disableReflectionWalker) {
+            const tPhase = performance.now();
             try {
                 const { walkBlobsForReferences } = await import("../parsers/generic/reflection-walker.js");
+                const sourceQnames = deltaHooks?.reflectionSources();
                 const reflectionResult = walkBlobsForReferences(graph, {
                     orgId: resolved.orgId,
                     ctx: postCtx,
+                    ...(sourceQnames ? { sourceQnames } : {}),
                 });
                 reflectionEdges = reflectionResult.edgesEmitted;
                 if (reflectionEdges > 0) {
@@ -953,12 +1555,16 @@ export async function liveIngest(opts) {
                 }
             }
             catch (e) {
+                postFailures.push("reflection walker");
                 logger.warn("live-ingest: reflection walker failed", {
                     err: e.message,
                 });
             }
+            profiler.phase("resolver:reflection", performance.now() - tPhase);
         }
-        if (!opts.disableAudit) {
+        // The audit only reports (it changes nothing): a delta skips it.
+        if (!opts.disableAudit && !deltaHooks) {
+            const tPhase = performance.now();
             try {
                 const auditResult = auditDanglingEdges(graph, resolved.orgId, { sampleSize: 25 });
                 danglingEdges = auditResult.danglingCount;
@@ -974,29 +1580,151 @@ export async function liveIngest(opts) {
                 }
             }
             catch (e) {
+                postFailures.push("graph audit");
                 logger.warn("live-ingest: graph audit failed", { err: e.message });
             }
+            profiler.phase("audit", performance.now() - tPhase);
         }
         const completedIso = new Date().toISOString();
+        // N4: when incremental skipped changed members it couldn't fetch, do NOT
+        // advance the watermark past them — hold it at the prior value so the next
+        // incremental re-detects (and keeps warning about) those changes instead of
+        // stepping over them forever. generation still increments / in-progress
+        // still clears (markSyncComplete does both regardless of the timestamp).
+        const holdWatermark = incrementalUnfetched > 0 && existing?.lastSyncedAt != null;
+        const watermarkIso = holdWatermark
+            ? new Date(existing.lastSyncedAt).toISOString()
+            : completedIso;
+        // N-1: the held queue has not dispatched yet, so its lazy `onWork` flag
+        // may not be set. Make `embeddings_pending` durable BEFORE the sync is
+        // marked complete: a crash between here and the drain must leave the
+        // next ingest knowing vectors are missing (it backfills them).
+        if (embedQueue && !wasEmbeddingsPending && embedQueue.hasVectorWork()) {
+            try {
+                graph.setEmbeddingsPending?.(resolved.orgId, true);
+            }
+            catch (e) {
+                logger.warn("live-ingest: setEmbeddingsPending failed", { err: e.message });
+            }
+        }
+        const populate = async () => {
+            if (!opts.analysisDb)
+                return;
+            const tDead = performance.now();
+            try {
+                await populateAnalysisTables(graph, resolved.orgId, opts.analysisDb);
+            }
+            catch (e) {
+                postFailures.push("populate analysis tables");
+                logger.warn("live-ingest: populate analysis tables failed", {
+                    err: e.message,
+                });
+            }
+            profiler.phase("deadcode", performance.now() - tDead);
+        };
+        // T15 I-2: a delta whose resolver or dead-code pass failed is not a clean
+        // sync. Populate runs before the sync is marked complete, and any failure
+        // throws here: the pending marker and member rows stay as they were, so the
+        // next delta replays the touched members with every resolver at full scope
+        // (the outer catch marks the sync failed; the generation does not move).
+        if (deltaHooks) {
+            await populate();
+            if (postFailures.length > 0) {
+                throw new Error(`delta: post-merge step(s) failed (${postFailures.join(", ")}); not finalized, the next delta re-derives at full scope`);
+            }
+        }
         try {
             // W1.5-08: markSyncComplete subsumes the old touchSync — it updates
             // last_synced_at AND increments sync_generation AND clears the
             // in-progress flag, atomically in one transaction.
-            graph.markSyncComplete(resolved.orgId, completedIso);
+            graph.markSyncComplete(resolved.orgId, watermarkIso);
         }
         catch (e) {
             logger.warn("live-ingest: markSyncComplete failed", { err: e.message });
         }
-        if (opts.analysisDb) {
+        opts.onPhase?.("sync-complete");
+        if (!deltaHooks)
+            await populate();
+        // Task 11c: the ingest is complete; record what each member owns.
+        if (deltaHooks)
+            deltaHooks.finalize();
+        else if (memberRows && !streamAborted) {
             try {
-                await populateAnalysisTables(graph, resolved.orgId, opts.analysisDb);
+                graph.replaceMemberRows?.(resolved.orgId, [...memberRows.values()], memberRowsGeneration());
             }
             catch (e) {
-                logger.warn("live-ingest: populate analysis tables failed", {
-                    err: e.message,
-                });
+                logger.warn("live-ingest: member rows write failed", { err: e.message });
             }
         }
+        // T15 N5-1: surface members skipped after repeated parse-worker failures.
+        const parseQuarantined = deltaHooks
+            ? (deltaHooks.quarantinedCount?.() ?? 0)
+            : memberRows
+                ? [...memberRows.values()].filter((r) => isQuarantinedRow(r)).length
+                : 0;
+        if (parseQuarantined > 0) {
+            logger.warn("live-ingest: members skipped after repeated parse-worker failures (until their content changes)", { count: parseQuarantined });
+        }
+        // Graph ready: merges, resolvers and the dead-code cache are done. Only
+        // embeddings may still be in flight.
+        const graphReadyMs = Date.now() - startedAt;
+        console.log(`graph ready in ${(graphReadyMs / 1000).toFixed(1)}s`);
+        profiler.phase("graph-ready", graphReadyMs, true);
+        let embeddings;
+        if (embedQueue) {
+            const q = embedQueue;
+            let pendingLeft = 0;
+            if (opts.waitEmbeddings === false) {
+                // Cache hits are cheap: write them before returning, so a warm no-wait
+                // run still completes its vectors. Only model work is deferred.
+                try {
+                    q.flushCached();
+                }
+                catch (e) {
+                    // Items may have been dropped mid-flush: keep the flag set.
+                    if (!embedError)
+                        embedError = e;
+                    logger.warn("live-ingest: cached vector flush failed", { err: e.message });
+                }
+                pendingLeft = q.abandon() + q.stats.failed;
+                const err = embedError;
+                if (pendingLeft > 0 || err) {
+                    console.log(`embeddings deferred: ${pendingLeft} texts pending (cached vectors written: ${q.stats.cached}); find_similar uses text search until an ingest that waits for embeddings fills them`);
+                }
+                else {
+                    graph.setEmbeddingsPending?.(resolved.orgId, false);
+                }
+            }
+            else {
+                try {
+                    // drain() releases the held queue.
+                    await q.drain();
+                }
+                catch (e) {
+                    if (!embedError)
+                        embedError = e;
+                }
+                const doneMs = Date.now() - startedAt;
+                const err = embedError;
+                if (err) {
+                    pendingLeft = q.stats.failed;
+                    console.error(`embeddings failed: ${err.message} — ${q.stats.failed} texts left unembedded; they will be filled on the next ingest`);
+                }
+                else {
+                    graph.setEmbeddingsPending?.(resolved.orgId, false);
+                    console.log(`embeddings done in ${(doneMs / 1000).toFixed(1)}s (cached ${q.stats.cached} / computed ${q.stats.computed})`);
+                }
+                profiler.phase("embeddings", doneMs, true);
+            }
+            const err = embedError;
+            embeddings = {
+                ...q.stats,
+                pending: pendingLeft,
+                backfilled,
+                doneMs: Date.now() - startedAt,
+                ...(err ? { error: err.message } : {}),
+            };
+        }
         if (opts.snapshotStore) {
             try {
                 opts.snapshotStore.prune(resolved.orgId, opts.snapshotRetentionDays ?? 30);
@@ -1015,7 +1743,11 @@ export async function liveIngest(opts) {
             durationMs: Date.now() - startedAt,
             crossFlavorEdges,
             arityResolved,
+            parseQuarantined,
+            interfaceRefsRetargeted,
             flowMethodsResolved,
+            vlocityApex: vlocityApexResult,
+            drRelationships: drRelationshipsResult,
             danglingEdges,
             reflectionEdges,
             overlap: overlapResult,
@@ -1026,9 +1758,27 @@ export async function liveIngest(opts) {
                 // with Phase 1's structured-warnings refactor (W1-01).
                 ...wedgeWarnings,
             ],
+            graphReadyMs,
+            ...(streamAborted ? { streamAborted: true } : {}),
+            ...(embeddings ? { embeddings } : {}),
         };
     }
     catch (e) {
+        embedQueue?.abandon();
+        // Never leave a bulk window (open transaction, dropped indexes) or a
+        // batch window (open transaction) behind.
+        try {
+            graph.endBatch?.();
+        }
+        catch {
+            /* best-effort */
+        }
+        try {
+            graph.endBulk?.();
+        }
+        catch {
+            /* best-effort */
+        }
         // W1.5-08: ingest threw before reaching markSyncComplete. Flip
         // sync_in_progress back to 0 (and clear sync_started_at) so concurrent
         // MCP readers don't see an orphaned in_progress flag forever. Generation
@@ -1045,5 +1795,20 @@ export async function liveIngest(opts) {
         }
         throw e;
     }
+    finally {
+        profiler.close();
+        try {
+            await ownedEmbedder?.close();
+        }
+        catch {
+            /* best-effort */
+        }
+        try {
+            embedCache?.close();
+        }
+        catch {
+            /* best-effort */
+        }
+    }
 }
 //# sourceMappingURL=live-ingest.js.map