gitnexus 1.6.10-aptos.0 → 1.6.10-aptos.2

package/README.md

@@ -375,6 +375,31 @@ described in [Move compiler provisioning](#move-compiler-provisioning) —
 including the `MOVE_FLOW` override and `GITNEXUS_SKIP_MOVE_FLOW=1` for
 air-gapped hosts.
 
+### Analyzing real-world Move repositories
+
+Real repos routinely contain Move packages that cannot build standalone (test
+fixtures, examples, fuzzer corpora — `aptos-core` alone has 470+). `analyze`
+handles them per package instead of giving up:
+
+- **Unbuildable packages are skipped with a warning**, not fatal: their
+  `.move` files stay out of the graph and the final summary names each skipped
+  package with the compiler's first diagnostic. Set `GITNEXUS_MOVE_STRICT=1`
+  to make any build failure abort the analyze instead.
+- **`_` placeholder addresses** (`econia = "_"` in `[addresses]`) are caught
+  pre-flight — MoveFlow has no dev-mode build, so set concrete addresses in
+  `Move.toml` or exclude the package.
+- **Builds with compiler errors still yield facts, at reduced fidelity**: the
+  MoveFlow compiler silently omits inferred `acquires` data from erroring
+  builds, so such packages are ingested with a persistent
+  "compiled with errors" warning. A common cause is a framework dependency
+  newer than MoveFlow's pinned compiler (e.g. unrecognized spec pragmas).
+- **`.gitnexusignore`** (gitignore syntax, repo root) excludes directories from
+  analysis entirely — the fastest way to scope large repos to the packages you
+  care about, and the remedy the skip warnings suggest.
+- **Cold builds of git-based framework dependencies can exceed the 5-minute
+  compile budget**; raise it with `GITNEXUS_MOVE_FLOW_TIMEOUT_MS` (e.g.
+  `1800000` for 30 min) for the first analyze.
+
 ## Release candidates
 
 Stable releases publish to the default `latest` dist-tag. When a pull request

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":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,OAAO,GACP,UAAU,GACV,QAAQ,GACR,UAAU,GACV,WAAW,GACX,MAAM,GACN,WAAW,GACX,QAAQ,GACR,MAAM,GACN,aAAa,GACb,WAAW,GACX,SAAS,GAET,QAAQ,GACR,OAAO,GACP,SAAS,GACT,OAAO,GACP,WAAW,GACX,OAAO,GACP,MAAM,GACN,WAAW,GACX,OAAO,GACP,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,UAAU,GACV,YAAY,GACZ,aAAa,GACb,UAAU,GACV,SAAS,GACT,OAAO,GACP,MAAM,GAGN,aAAa,GAGb,YAAY,CAAC;AAEjB,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAAC;IACvC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,WAAW,GAAG,KAAK,CAAC;IAEjC,WAAW,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAAC;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;4EACwE;IACxE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAEvB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IAItB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAClF,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;;;;yBAMqB;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,eAAe,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,4DAA4D;IAC5D,mBAAmB,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IACxC,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC;IAC9C,sEAAsE;IACtE,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACrE;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;IAEpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;8EAC0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,OAAO,GACP,UAAU,GACV,kBAAkB,GAClB,WAAW,GACX,mBAAmB,GACnB,SAAS,GACT,MAAM,GACN,SAAS,GACT,WAAW,GACX,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,cAAc,GACd,UAAU,GACV,WAAW,GACX,iBAAiB,GACjB,eAAe,GACf,SAAS,GACT,cAAc,GACd,gBAAgB,GAChB,OAAO,GACP,SAAS;AACX;;;;;;;;;;;0EAW0E;GACxE,SAAS;AACX;;;;;;qEAMqE;AAErE,kEAAkE;GAChE,WAAW;AACb,gEAAgE;GAC9D,gBAAgB;AAClB,kEAAkE;GAChE,iBAAiB;AACnB,+DAA+D;GAC7D,UAAU;AACZ,2DAA2D;GACzD,WAAW;AACb,6EAA6E;GAC3E,OAAO,GACP,qBAAqB;AACvB;;;;;;gEAMgE;GAC9D,aAAa;AAOf,6EAA6E;GAC3E,KAAK;AACP;;;;qCAIqC;GACnC,cAAc;AAChB,qDAAqD;GACnD,SAAS;AACX,6CAA6C;GAC3C,WAAW;AACb;8EAC8E;GAC5E,YAAY;AACd;;;;qEAIqE;GACnE,KAAK;AACP;;;;;;0EAM0E;GACxE,eAAe;AACjB;;;;;;;;;;;oCAWoC;GAClC,cAAc,CAAC;AAEnB,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,cAAc,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,gBAAgB,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,SAAS;QAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACxB,EAAE,CAAC;CACL"}
+{"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/cli/analyze.js

@@ -1193,6 +1193,14 @@ const analyzeCommandImpl = async (inputPath, cliOptions, runnerIdentityAtBootstr
                 `  Install it once with network access (GITNEXUS_LBUG_EXTENSION_INSTALL=auto) then rerun, or\n` +
                 `  run \`gitnexus analyze --repair-fts\` when connected. Run \`gitnexus doctor\` for details.`);
         }
+        // Standalone-ingest warnings (skipped/degraded Move packages) share the
+        // FTS warning's rationale: mid-run progress lines scroll away, so anything
+        // the operator must act on has to reappear in the final summary.
+        if (result.ingestWarnings && result.ingestWarnings.length > 0) {
+            for (const warning of result.ingestWarnings) {
+                console.log(`\n  Warning: ${warning}`);
+            }
+        }
         try {
             await fs.access(getGlobalRegistryPath());
         }

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,19 @@ 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).
+     * Language-neutral: the pipeline passes these through without interpreting.
+     */
+    readonly ingestWarnings?: readonly string[];
 }
 /** Default no-op used when the caller does not supply a standalone ingester. */
 export declare const emptyStandaloneIngestPhase: PipelinePhase<StandaloneIngestOutput>;

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,6 +81,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
     const { totalFiles, usedWorkerPool } = getPhaseOutput(results, 'parse');
     let communityResult;
     let processResult;
+    // 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.
@@ -110,5 +114,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         resolutionOutcomes,
         usedWorkerPool,
         pdgEmitManifest,
+        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