gitnexus 1.6.10-aptos.1 → 1.6.10-aptos.2

package/dist/_shared/graph/types.d.ts

@@ -98,9 +98,10 @@ export type NodeProperties = {
     /**
      * Node-location precision. `'precise'` = per-symbol file/span from the
      * move-flow `facts` query; `'module'` = only the containing module/type file
-     * is known; `'package'` = coarse package-root fallback.
+     * is known; `'package'` = coarse package-root fallback; `'external'` =
+     * declaration belongs to a dependency outside the indexed repository.
      */
-    locationFidelity?: 'precise' | 'module' | 'package';
+    locationFidelity?: 'precise' | 'module' | 'package' | 'external';
     text?: string;
     /** BasicBlock: space-joined leaf callee names invoked in the block — the
      *  statement-precise inter-procedural reach substrate for impact mode. */

package/dist/_shared/graph/types.d.ts.map

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

package/dist/_shared/lbug/schema-constants.d.ts

@@ -7,7 +7,7 @@
  * Full DDL schemas remain in each package's own schema.ts because
  * the CLI uses native LadybugDB and the web uses WASM.
  */
-export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Section", "Struct", "Enum", "EnumVariant", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Variable", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Route", "Tool", "BasicBlock"];
+export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Section", "Struct", "Enum", "EnumVariant", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Type", "Const", "Static", "Variable", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Route", "Tool", "BasicBlock"];
 export type NodeTableName = (typeof NODE_TABLES)[number];
 export declare const REL_TABLE_NAME = "CodeRelation";
 export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "HAS_METHOD", "HAS_PROPERTY", "ACCESSES", "METHOD_OVERRIDES", "OVERRIDES", "METHOD_IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS", "HANDLES_ROUTE", "FETCHES", "HANDLES_TOOL", "ENTRY_POINT_OF", "WRAPS", "QUERIES", "INJECTS", "FRIEND_OF", "READS_RESOURCE", "WRITES_RESOURCE", "ACQUIRES", "USES_TYPE", "EMITS", "CFG", "REACHING_DEF", "TAINTED", "SANITIZES", "TAINT_PATH", "CDG", "POST_DOMINATE"];

package/dist/_shared/lbug/schema-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,uXAmCd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,qdA2CZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}
+{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,+XAoCd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,qdA2CZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}

package/dist/_shared/lbug/schema-constants.js

@@ -28,6 +28,7 @@ export const NODE_TABLES = [
     'Trait',
     'Impl',
     'TypeAlias',
+    'Type',
     'Const',
     'Static',
     'Variable',

package/dist/_shared/lbug/schema-constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,aAAa;IACb,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;IACN,2EAA2E;IAC3E,YAAY;CACJ,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;IACT,SAAS;IACT,gEAAgE;IAChE,WAAW;IACX,gBAAgB;IAChB,iBAAiB;IACjB,UAAU;IACV,WAAW;IACX,OAAO;IACP,yEAAyE;IACzE,yEAAyE;IACzE,6EAA6E;IAC7E,KAAK;IACL,cAAc;IACd,SAAS;IACT,WAAW;IACX,YAAY;IACZ,4EAA4E;IAC5E,uEAAuE;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,KAAK;IACL,eAAe;CACP,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}
+{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,aAAa;IACb,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,MAAM;IACN,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;IACN,2EAA2E;IAC3E,YAAY;CACJ,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;IACT,SAAS;IACT,gEAAgE;IAChE,WAAW;IACX,gBAAgB;IAChB,iBAAiB;IACjB,UAAU;IACV,WAAW;IACX,OAAO;IACP,yEAAyE;IACzE,yEAAyE;IACzE,6EAA6E;IAC7E,KAAK;IACL,cAAc;IACd,SAAS;IACT,WAAW;IACX,YAAY;IACZ,4EAA4E;IAC5E,uEAAuE;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,KAAK;IACL,eAAe;CACP,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}

package/dist/core/incremental/subgraph-extract.d.ts

@@ -9,6 +9,9 @@
  *   - Every graph-wide node (Community, Process) — these are regenerated
  *     each run by the communities/processes phases and must be fully
  *     rewritten.
+ *   - Every external dependency node (`locationFidelity: 'external'`, no
+ *     filePath) — regenerated each run by the standalone ingest phase and
+ *     delete-all'd by the orchestrator, same contract as Community/Process.
  *   - Every relationship where AT LEAST ONE endpoint is in the writable
  *     set above. Relationships entirely between unchanged-file nodes
  *     are skipped — their rows are still in the DB and re-inserting

package/dist/core/incremental/subgraph-extract.js

@@ -9,6 +9,9 @@
  *   - Every graph-wide node (Community, Process) — these are regenerated
  *     each run by the communities/processes phases and must be fully
  *     rewritten.
+ *   - Every external dependency node (`locationFidelity: 'external'`, no
+ *     filePath) — regenerated each run by the standalone ingest phase and
+ *     delete-all'd by the orchestrator, same contract as Community/Process.
  *   - Every relationship where AT LEAST ONE endpoint is in the writable
  *     set above. Relationships entirely between unchanged-file nodes
  *     are skipped — their rows are still in the DB and re-inserting
@@ -49,6 +52,19 @@
  */
 import { createKnowledgeGraph } from '../graph/graph.js';
 const isGraphWide = (label) => label === 'Community' || label === 'Process';
+/**
+ * Externally-declared dependency symbols (compiler-backed ingesters stamp
+ * `locationFidelity: 'external'`) carry no filePath, so the file-keyed
+ * delete/write cycle can never refresh them — an external symbol first
+ * referenced during an incremental run would be skipped here while its edges
+ * are extracted, and the dangling endpoints would fail the rel COPY into the
+ * per-row fallback (which silently drops them). They are regenerated
+ * whole-program by every ingest run, so they get the Community/Process
+ * treatment: the orchestrator delete-alls them first
+ * (`deleteAllExternalNodes`) and this extractor re-includes them from the
+ * fresh graph.
+ */
+const isExternalNode = (n) => n.properties?.locationFidelity === 'external';
 /**
  * Relationship types whose VALIDITY is a whole-program property, not a
  * function of their endpoints' files (#2084 M4 U6). `TAINT_PATH` (cross-
@@ -95,7 +111,7 @@ export const extractChangedSubgraph = (fullGraph, toWriteSet) => {
     const writableNodeIds = new Set();
     fullGraph.forEachNode((n) => {
         const filePath = n.properties?.filePath;
-        const include = (filePath && toWriteSet.has(filePath)) || isGraphWide(n.label);
+        const include = (filePath && toWriteSet.has(filePath)) || isGraphWide(n.label) || isExternalNode(n);
         if (include) {
             sub.addNode(n);
             writableNodeIds.add(n.id);

package/dist/core/ingestion/pipeline-phases/standalone-ingest.d.ts

@@ -5,6 +5,13 @@ import type { PipelinePhase } from './types.js';
  */
 export interface StandaloneIngestOutput {
     readonly ingestedFiles: ReadonlySet<string>;
+    /**
+     * Whether this run produced a complete replacement snapshot of external
+     * dependency nodes. `false` tells incremental persistence to preserve the
+     * prior snapshot because at least one standalone-ingest input was skipped.
+     * Omitted is treated as complete for backward-compatible custom phases.
+     */
+    readonly externalNodeSnapshotComplete?: boolean;
     /**
      * Operator-actionable warnings the ingester wants surfaced in the persistent
      * CLI summary (e.g. a package it had to skip or ingest at degraded fidelity).

package/dist/core/ingestion/pipeline-phases/standalone-ingest.js

@@ -2,5 +2,8 @@
 export const emptyStandaloneIngestPhase = {
     name: 'standaloneIngest',
     deps: ['structure'],
-    execute: () => Promise.resolve({ ingestedFiles: new Set() }),
+    execute: () => Promise.resolve({
+        ingestedFiles: new Set(),
+        externalNodeSnapshotComplete: true,
+    }),
 };

package/dist/core/ingestion/pipeline.d.ts

@@ -17,7 +17,7 @@
 import { type PipelineProgress } from '../../_shared/index.js';
 import { PipelineResult } from '../../types/pipeline.js';
 import { type StandaloneIngestOutput, type PipelinePhase } from './pipeline-phases/index.js';
-export interface PipelineOptions {
+export interface PipelineOptions<TStandaloneIngest extends StandaloneIngestOutput = StandaloneIngestOutput> {
     /**
      * Skip MRO, community detection, and process extraction for faster test runs.
      * The `pruneLocalSymbols` phase still runs — it is graph construction (it cleans
@@ -187,7 +187,7 @@ export interface PipelineOptions {
      */
     keepLocalValueSymbols?: boolean;
     /** Optional compiler-backed or otherwise standalone ingester. */
-    standaloneIngestPhase?: PipelinePhase<StandaloneIngestOutput>;
+    standaloneIngestPhase?: PipelinePhase<TStandaloneIngest>;
     /**
      * Extra fetch-wrapper function names to treat as HTTP consumers, threaded
      * from `.gitnexusrc` `fetchWrappers` via `AnalyzeOptions` (#1589/#1852
@@ -217,5 +217,5 @@ export interface PipelineOptions {
  * asserts the produced list is byte-identical to the legacy array for every
  * options combination.
  */
-export declare function buildPhaseList(options?: PipelineOptions): PipelinePhase[];
-export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: PipelineOptions) => Promise<PipelineResult>;
+export declare function buildPhaseList<TStandaloneIngest extends StandaloneIngestOutput>(options?: PipelineOptions<TStandaloneIngest>): PipelinePhase[];
+export declare const runPipelineFromRepo: <TStandaloneIngest extends StandaloneIngestOutput = StandaloneIngestOutput>(repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: PipelineOptions<TStandaloneIngest>) => Promise<PipelineResult<TStandaloneIngest>>;

package/dist/core/ingestion/pipeline.js

@@ -81,14 +81,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
     const { totalFiles, usedWorkerPool } = getPhaseOutput(results, 'parse');
     let communityResult;
     let processResult;
-    // Standalone-ingest warnings, passed through opaquely (language-neutral).
-    let ingestWarnings;
-    try {
-        ingestWarnings = getPhaseOutput(results, 'standaloneIngest').ingestWarnings;
-    }
-    catch {
-        /* phase filtered out of this run — nothing to surface */
-    }
+    // Standalone ingest is always registered (it defaults to the empty phase),
+    // so its output — and the language-neutral warnings it passes through — are
+    // always present.
+    const standaloneIngest = getPhaseOutput(results, 'standaloneIngest');
     const scopeResolutionOutput = getPhaseOutput(results, 'scopeResolution');
     const resolutionOutcomes = scopeResolutionOutput.resolutionOutcomes;
     // Streamed PDG-emit manifest (#2202): present only when streaming was on.
@@ -118,6 +114,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         resolutionOutcomes,
         usedWorkerPool,
         pdgEmitManifest,
-        ingestWarnings,
+        standaloneIngest,
     };
 };

package/dist/core/ingestion/process-processor.d.ts

@@ -2,7 +2,8 @@
  * Process Detection Processor
  *
  * Detects execution flows (Processes) in the code graph by:
- * 1. Finding entry points (functions with no internal callers)
+ * 1. Finding entry points (explicit graph roots plus functions that call
+ *    others but have few callers)
  * 2. Tracing forward via CALLS edges (BFS)
  * 3. Grouping and deduplicating similar paths
  * 4. Labeling with heuristic names

package/dist/core/ingestion/process-processor.js

@@ -2,7 +2,8 @@
  * Process Detection Processor
  *
  * Detects execution flows (Processes) in the code graph by:
- * 1. Finding entry points (functions with no internal callers)
+ * 1. Finding entry points (explicit graph roots plus functions that call
+ *    others but have few callers)
  * 2. Tracing forward via CALLS edges (BFS)
  * 3. Grouping and deduplicating similar paths
  * 4. Labeling with heuristic names
@@ -33,14 +34,11 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
     // Build lookup maps
     const membershipMap = new Map();
     memberships.forEach((m) => membershipMap.set(m.nodeId, m.communityId));
-    const callsEdges = buildCallsGraph(knowledgeGraph);
-    const reverseCallsEdges = buildReverseCallsGraph(knowledgeGraph);
-    const nodeMap = new Map();
-    for (const n of knowledgeGraph.iterNodes())
-        nodeMap.set(n.id, n);
-    // Step 1: Find entry points (functions that call others but have few callers)
-    const entryPoints = findEntryPoints(knowledgeGraph, reverseCallsEdges, callsEdges);
-    onProgress?.(`Found ${entryPoints.length} entry points, tracing flows...`, 20);
+    const { forward: callsEdges, reverse: reverseCallsEdges } = buildCallsAdjacency(knowledgeGraph);
+    // Step 1: Find entry points — explicit ENTRY_POINT_OF graph roots plus
+    // heuristic ones (functions that call others but have few callers).
+    const explicitEntryPointIds = collectExplicitEntryPointIds(knowledgeGraph);
+    const entryPoints = findEntryPoints(knowledgeGraph, reverseCallsEdges, callsEdges, explicitEntryPointIds);
     onProgress?.(`Found ${entryPoints.length} entry points, tracing flows...`, 20);
     // Step 2: Trace processes from each entry point
     const allTraces = [];
@@ -55,14 +53,20 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
     }
     onProgress?.(`Found ${allTraces.length} traces, deduplicating...`, 60);
     // Step 3: Deduplicate similar traces (subset removal)
-    const uniqueTraces = deduplicateTraces(allTraces);
+    const uniqueTraces = deduplicateTraces(allTraces, explicitEntryPointIds);
     // Step 3b: Deduplicate by entry+terminal pair (keep longest path per pair)
     const endpointDeduped = deduplicateByEndpoints(uniqueTraces);
     onProgress?.(`Deduped ${uniqueTraces.length} → ${endpointDeduped.length} unique endpoint pairs`, 70);
-    // Step 4: Limit to max processes (prioritize longer traces)
-    const limitedTraces = endpointDeduped
-        .sort((a, b) => b.length - a.length)
-        .slice(0, cfg.maxProcesses);
+    // Step 4: Interleave compiler-declared and heuristic roots so a large
+    // explicit API surface cannot consume the entire process budget.
+    // Each tier still prefers longer traces.
+    const explicitTraces = endpointDeduped
+        .filter((trace) => explicitEntryPointIds.has(trace[0]))
+        .sort((a, b) => b.length - a.length);
+    const heuristicTraces = endpointDeduped
+        .filter((trace) => !explicitEntryPointIds.has(trace[0]))
+        .sort((a, b) => b.length - a.length);
+    const limitedTraces = interleaveTiers(explicitTraces, heuristicTraces).slice(0, cfg.maxProcesses);
     onProgress?.(`Creating ${limitedTraces.length} process nodes...`, 80);
     // Step 5: Create process nodes
     const processes = [];
@@ -81,8 +85,8 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
         // Determine process type
         const processType = communities.length > 1 ? 'cross_community' : 'intra_community';
         // Generate label
-        const entryNode = nodeMap.get(entryPointId);
-        const terminalNode = nodeMap.get(terminalId);
+        const entryNode = knowledgeGraph.getNode(entryPointId);
+        const terminalNode = knowledgeGraph.getNode(terminalId);
         const entryName = entryNode?.properties.name || 'Unknown';
         const terminalName = terminalNode?.properties.name || 'Unknown';
         const heuristicLabel = `${capitalize(entryName)} → ${capitalize(terminalName)}`;
@@ -130,29 +134,55 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
  * traces to jump across unrelated code areas.
  */
 const MIN_TRACE_CONFIDENCE = 0.5;
-const buildCallsGraph = (graph) => {
-    const adj = new Map();
+/** Build forward and reverse CALLS adjacency lists in one relationship scan. */
+const buildCallsAdjacency = (graph) => {
+    const forward = new Map();
+    const reverse = new Map();
+    const push = (adj, key, value) => {
+        const bucket = adj.get(key);
+        if (bucket === undefined)
+            adj.set(key, [value]);
+        else
+            bucket.push(value);
+    };
     for (const rel of graph.iterRelationships()) {
         if (rel.type === 'CALLS' && rel.confidence >= MIN_TRACE_CONFIDENCE) {
-            if (!adj.has(rel.sourceId)) {
-                adj.set(rel.sourceId, []);
-            }
-            adj.get(rel.sourceId).push(rel.targetId);
+            push(forward, rel.sourceId, rel.targetId);
+            push(reverse, rel.targetId, rel.sourceId);
         }
     }
-    return adj;
+    return { forward, reverse };
 };
-const buildReverseCallsGraph = (graph) => {
-    const adj = new Map();
-    for (const rel of graph.iterRelationships()) {
-        if (rel.type === 'CALLS' && rel.confidence >= MIN_TRACE_CONFIDENCE) {
-            if (!adj.has(rel.targetId)) {
-                adj.set(rel.targetId, []);
-            }
-            adj.get(rel.targetId).push(rel.sourceId);
-        }
+/** IDs of nodes carrying a pre-phase ENTRY_POINT_OF edge (compiler-backed
+ *  runtime/API roots stamped by the standalone ingest phase). */
+function collectExplicitEntryPointIds(graph) {
+    const ids = new Set();
+    for (const rel of graph.iterRelationshipsByType('ENTRY_POINT_OF')) {
+        // Only callable roots qualify. Route/Tool→Process ENTRY_POINT_OF edges
+        // are created after this phase; the label filter keeps them out even if
+        // phase ordering ever changes.
+        const label = graph.getNode(rel.sourceId)?.label;
+        if (label === 'Function' || label === 'Method')
+            ids.add(rel.sourceId);
     }
-    return adj;
+    return ids;
+}
+/** Global cap on heuristic (non-explicit) entry points, to prevent explosion
+ *  on large polyglot repos. Explicit graph roots are interleaved separately. */
+const HEURISTIC_ENTRY_POINT_BUDGET = 200;
+/** Comparator combinator: explicit items first, then a secondary order. */
+const explicitFirst = (isExplicit, then) => (a, b) => Number(isExplicit(b)) - Number(isExplicit(a)) || then(a, b);
+/** Alternate between two independently ranked tiers, starting with primary. */
+const interleaveTiers = (primary, secondary) => {
+    const interleaved = [];
+    const length = Math.max(primary.length, secondary.length);
+    for (let i = 0; i < length; i++) {
+        if (i < primary.length)
+            interleaved.push(primary[i]);
+        if (i < secondary.length)
+            interleaved.push(secondary[i]);
+    }
+    return interleaved;
 };
 /**
  * Find functions/methods that are good entry points for tracing.
@@ -164,8 +194,14 @@ const buildReverseCallsGraph = (graph) => {
  *
  * Test files are excluded entirely.
  */
-const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
+const findEntryPoints = (graph, reverseCallsEdges, callsEdges, explicitEntryPointIds) => {
     const symbolTypes = new Set(['Function', 'Method']);
+    // ENTRY_POINT_OF is the graph-wide, language-neutral signal for a known
+    // runtime/API root. Only edges emitted BEFORE this phase count — today
+    // that is compiler-backed standalone ingesters; the
+    // Route/Tool ENTRY_POINT_OF edges are created after process extraction
+    // and point Route/Tool→Process, so they never land here. These roots must
+    // survive the global heuristic top-200 budget on large polyglot repos.
     const entryPointCandidates = [];
     for (const node of graph.iterNodes()) {
         if (!symbolTypes.has(node.label))
@@ -182,17 +218,22 @@ const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
         // Calculate entry point score using new scoring system
         const { score: baseScore, reasons } = calculateEntryPointScore(node.properties.name, (node.properties.language ?? SupportedLanguages.JavaScript), node.properties.isExported ?? false, callers.length, callees.length, filePath);
         let score = baseScore;
+        const explicit = explicitEntryPointIds.has(node.id);
+        if (explicit)
+            reasons.push('graph-entry-point');
         const astFrameworkMultiplier = node.properties.astFrameworkMultiplier ?? 1.0;
         if (astFrameworkMultiplier > 1.0) {
             score *= astFrameworkMultiplier;
             reasons.push(`framework-ast:${node.properties.astFrameworkReason || 'decorator'}`);
         }
-        if (score > 0) {
-            entryPointCandidates.push({ id: node.id, score, reasons });
+        if (explicit || score > 0) {
+            entryPointCandidates.push({ id: node.id, score, reasons, explicit });
         }
     }
-    // Sort by score descending and return top candidates
-    const sorted = entryPointCandidates.sort((a, b) => b.score - a.score);
+    // Rank each tier independently, then interleave them. This retains the
+    // explicit-root guarantee without letting a large compiler-backed package
+    // starve every heuristic root before the trace budget is reached.
+    const sorted = entryPointCandidates.sort(explicitFirst((candidate) => candidate.explicit, (a, b) => b.score - a.score));
     // DEBUG: Log top candidates with new scoring details
     if (sorted.length > 0 && isDev) {
         logger.info(`[Process] Top 10 entry point candidates (new scoring):`);
@@ -204,9 +245,11 @@ const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
             logger.info(`     score: ${c.score.toFixed(2)} = [${c.reasons.join(' × ')}]`);
         });
     }
-    return sorted
-        .slice(0, 200) // Limit to prevent explosion
-        .map((c) => c.id);
+    const explicit = sorted.filter((candidate) => candidate.explicit);
+    const heuristic = sorted
+        .filter((candidate) => !candidate.explicit)
+        .slice(0, HEURISTIC_ENTRY_POINT_BUDGET);
+    return interleaveTiers(explicit, heuristic).map((candidate) => candidate.id);
 };
 // ============================================================================
 // HELPER: Trace from entry point (BFS)
@@ -262,21 +305,24 @@ const traceFromEntryPoint = (entryId, callsEdges, config) => {
  * Merge traces that are subsets of other traces.
  * Keep longer traces, remove redundant shorter ones.
  */
-const deduplicateTraces = (traces) => {
+const deduplicateTraces = (traces, explicitEntryPointIds = new Set()) => {
     if (traces.length === 0)
         return [];
     // Sort by length descending
     const sorted = [...traces].sort((a, b) => b.length - a.length);
     const unique = [];
+    // Cache each kept trace's join key so the redundancy scan below doesn't
+    // recompute `existing.join('->')` on every comparison.
+    const uniqueKeys = [];
     for (const trace of sorted) {
-        // Check if this trace is a subset of any already-added trace
         const traceKey = trace.join('->');
-        const isSubset = unique.some((existing) => {
-            const existingKey = existing.join('->');
-            return existingKey.includes(traceKey);
-        });
-        if (!isSubset) {
+        // Explicit entry points dedupe on exact equality; heuristic traces are
+        // dropped when a longer kept trace already contains them as a substring.
+        const exactOnly = explicitEntryPointIds.has(trace[0]);
+        const isRedundant = uniqueKeys.some((existingKey) => exactOnly ? existingKey === traceKey : existingKey.includes(traceKey));
+        if (!isRedundant) {
             unique.push(trace);
+            uniqueKeys.push(traceKey);
         }
     }
     return unique;

package/dist/core/lbug/csv-generator.js

@@ -449,6 +449,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
         const MULTI_LANG_TYPES = [
             'Struct',
             'Enum',
+            'Type',
             'EnumVariant',
             'Macro',
             'Typedef',

package/dist/core/lbug/lbug-adapter.d.ts

@@ -295,12 +295,7 @@ export declare const deleteNodesForFile: (filePath: string, dbPath?: string) =>
 }>;
 /**
  * Chunk size for {@link deleteNodesForFiles}. 200 paths keeps each
- * statement ~13KB (well inside parser limits) while a ~700-file write set
- * still collapses from ~13,000 statements to 124: 31 statements per chunk
- * (1 CodeEmbedding join-delete + 30 filePath-bearing node tables — the
- * 32-table NODE_TABLES roster minus Community/Process) × 4 chunks. The
- * original "~40" claim under-counted the per-chunk statement fan-out
- * (tri-review 4669518496 accuracy sweep).
+ * statement ~13KB while batching one delete per file-backed table.
  */
 export declare const DELETE_FILES_CHUNK_SIZE = 200;
 /**
@@ -320,9 +315,7 @@ export declare const DELETE_FILES_CHUNK_SIZE = 200;
  * binder error on the embedding join-delete: a DB created without
  * EMBEDDING_SCHEMA cannot own embedding rows, so skipping that one
  * statement is sound, while failing would brick every incremental run on
- * such a DB until `--force`. Statement count per chunk is unchanged by the
- * multi-label join: 1 embedding join-delete + 30 node-table deletes = 31
- * (the rejected per-label fallback shape would have been 19 + 30 = 49).
+ * such a DB until `--force`.
  * Singleton-connection only: the analyze writeback owns the write lock,
  * and `queryAndDrain` routes through `withConnLock` for it (the WAL
  * checkpoint driver is live during this).
@@ -381,6 +374,24 @@ export declare const queryImportersBatch: (targetFilePaths: readonly string[], o
 export declare const deleteAllCommunitiesAndProcesses: () => Promise<{
     nodesDeleted: number;
 }>;
+/**
+ * Drop every externally-declared dependency node (and, via DETACH, its
+ * edges). Used at the start of an incremental writeback: external nodes have
+ * no filePath, so `deleteNodesForFiles` can never remove them and the
+ * file-keyed write set can never refresh them. The standalone ingest phase
+ * regenerates the full external surface every run and
+ * `extractChangedSubgraph` re-includes it (`isExternalNode`), so
+ * delete-all-then-rebuild keeps first-referenced externals from dangling
+ * their edges — same contract as Community/Process. Crash-recovery matches
+ * INJECTS: delete-then-COPY is not atomic, and the `incrementalInProgress`
+ * dirty flag forces a full rebuild if we die between them.
+ *
+ * Every external label is backticked unconditionally so this table list stays
+ * safe even if it diverges from BACKTICK_TABLES in the future.
+ */
+export declare const deleteAllExternalNodes: () => Promise<{
+    nodesDeleted: number;
+}>;
 /**
  * Drop every interprocedural `TAINT_PATH` relationship (#2084 M4 U6). Used at
  * the start of an incremental `--pdg` writeback so the `taintSummaries` phase

package/dist/core/lbug/lbug-adapter.js

@@ -1072,6 +1072,7 @@ const BACKTICK_TABLES = new Set([
     'Trait',
     'Impl',
     'TypeAlias',
+    'Type',
     'Const',
     'Static',
     'Property',
@@ -2019,12 +2020,7 @@ export const deleteNodesForFile = async (filePath, dbPath) => {
 };
 /**
  * Chunk size for {@link deleteNodesForFiles}. 200 paths keeps each
- * statement ~13KB (well inside parser limits) while a ~700-file write set
- * still collapses from ~13,000 statements to 124: 31 statements per chunk
- * (1 CodeEmbedding join-delete + 30 filePath-bearing node tables — the
- * 32-table NODE_TABLES roster minus Community/Process) × 4 chunks. The
- * original "~40" claim under-counted the per-chunk statement fan-out
- * (tri-review 4669518496 accuracy sweep).
+ * statement ~13KB while batching one delete per file-backed table.
  */
 export const DELETE_FILES_CHUNK_SIZE = 200;
 /**
@@ -2044,9 +2040,7 @@ export const DELETE_FILES_CHUNK_SIZE = 200;
  * binder error on the embedding join-delete: a DB created without
  * EMBEDDING_SCHEMA cannot own embedding rows, so skipping that one
  * statement is sound, while failing would brick every incremental run on
- * such a DB until `--force`. Statement count per chunk is unchanged by the
- * multi-label join: 1 embedding join-delete + 30 node-table deletes = 31
- * (the rejected per-label fallback shape would have been 19 + 30 = 49).
+ * such a DB until `--force`.
  * Singleton-connection only: the analyze writeback owns the write lock,
  * and `queryAndDrain` routes through `withConnLock` for it (the WAL
  * checkpoint driver is live during this).
@@ -2220,32 +2214,37 @@ export const queryImportersBatch = async (targetFilePaths, options = {}) => {
     return [...importers].sort();
 };
 /**
- * Drop every Community and Process node (and their MEMBER_OF /
- * STEP_IN_PROCESS edges via DETACH DELETE). Used at the start of an
- * incremental run so the communities and processes phases regenerate
- * them from scratch on the merged graph — required for the
- * "Leiden runs on the FULL graph" correctness invariant.
+ * Shared mechanics for the delete-all-nodes-by-label family
+ * ({@link deleteAllCommunitiesAndProcesses}, {@link deleteAllExternalNodes}).
+ * For each label: count matching nodes, then `DETACH DELETE` them if any.
+ * The whole loop runs inside `withConnLock` so it cannot execute concurrently
+ * with the WAL-checkpoint driver's CHECKPOINT on the singleton connection
+ * (this runs during incremental --pdg writeback while the driver is live;
+ * mirrors the wrapped deleteAllInterprocTaintPaths / deleteAllCallSummaries).
+ * A missing table on a freshly-initialized DB is swallowed — it simply holds
+ * no rows to delete.
+ *
+ * `labels` are pre-formatted label tokens (the caller decides backticking).
+ * `filter` is an optional Cypher predicate on the bound node `n`
+ * (e.g. `WHERE n.locationFidelity = 'external'`); omitted → delete all rows.
  */
-export const deleteAllCommunitiesAndProcesses = async () => {
+const deleteAllNodesByLabels = async (labels, filter = '') => {
     const c = conn;
     if (!c) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
-    // count + DETACH DELETE run inside the connection lock so they cannot execute
-    // concurrently with the WAL-checkpoint driver's CHECKPOINT on the singleton
-    // connection. This runs during incremental --pdg writeback while the driver is
-    // live; mirrors the wrapped deleteAllInterprocTaintPaths / deleteAllCallSummaries.
+    const clause = filter ? ` ${filter}` : '';
     return withConnLock(async () => {
         let nodesDeleted = 0;
-        for (const label of ['Community', 'Process']) {
+        for (const label of labels) {
             let countResult;
             try {
-                countResult = await c.query(`MATCH (n:${label}) RETURN count(n) AS cnt`);
+                countResult = await c.query(`MATCH (n:${label})${clause} RETURN count(n) AS cnt`);
                 const result = Array.isArray(countResult) ? countResult[0] : countResult;
                 const rows = await result.getAll();
                 const count = Number(rows[0]?.cnt ?? rows[0]?.[0] ?? 0);
                 if (count > 0) {
-                    await closeQueryResults(await c.query(`MATCH (n:${label}) DETACH DELETE n`));
+                    await closeQueryResults(await c.query(`MATCH (n:${label})${clause} DETACH DELETE n`));
                     nodesDeleted += count;
                 }
             }
@@ -2260,6 +2259,36 @@ export const deleteAllCommunitiesAndProcesses = async () => {
         return { nodesDeleted };
     });
 };
+/**
+ * Drop every Community and Process node (and their MEMBER_OF /
+ * STEP_IN_PROCESS edges via DETACH DELETE). Used at the start of an
+ * incremental run so the communities and processes phases regenerate
+ * them from scratch on the merged graph — required for the
+ * "Leiden runs on the FULL graph" correctness invariant.
+ */
+export const deleteAllCommunitiesAndProcesses = async () => deleteAllNodesByLabels(['Community', 'Process']);
+/**
+ * Node tables that can hold externally-declared dependency symbols
+ * (`locationFidelity = 'external'`, filePath '') — the labels
+ * `ExternalMoveSymbols` in move-linker materializes. Extend alongside it.
+ */
+const EXTERNAL_NODE_TABLES = ['Module', 'Function', 'Type'];
+/**
+ * Drop every externally-declared dependency node (and, via DETACH, its
+ * edges). Used at the start of an incremental writeback: external nodes have
+ * no filePath, so `deleteNodesForFiles` can never remove them and the
+ * file-keyed write set can never refresh them. The standalone ingest phase
+ * regenerates the full external surface every run and
+ * `extractChangedSubgraph` re-includes it (`isExternalNode`), so
+ * delete-all-then-rebuild keeps first-referenced externals from dangling
+ * their edges — same contract as Community/Process. Crash-recovery matches
+ * INJECTS: delete-then-COPY is not atomic, and the `incrementalInProgress`
+ * dirty flag forces a full rebuild if we die between them.
+ *
+ * Every external label is backticked unconditionally so this table list stays
+ * safe even if it diverges from BACKTICK_TABLES in the future.
+ */
+export const deleteAllExternalNodes = async () => deleteAllNodesByLabels(EXTERNAL_NODE_TABLES.map((t) => `\`${t}\``), `WHERE n.locationFidelity = 'external'`);
 /**
  * Shared mechanics for the delete-all-relationships-of-one-type family
  * ({@link deleteAllInterprocTaintPaths}, {@link deleteAllCallSummaries},