gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/pipeline-phases/communities.d.ts

@@ -4,7 +4,7 @@
  * Detects code communities via Leiden algorithm and creates
  * Community nodes + MEMBER_OF edges.
  *
- * @deps    mro
+ * @deps    mro, pruneLocalSymbols
  * @reads   graph (all nodes and relationships)
  * @writes  graph (Community nodes, MEMBER_OF edges)
  */

package/dist/core/ingestion/pipeline-phases/communities.js

@@ -4,7 +4,7 @@
  * Detects code communities via Leiden algorithm and creates
  * Community nodes + MEMBER_OF edges.
  *
- * @deps    mro
+ * @deps    mro, pruneLocalSymbols
  * @reads   graph (all nodes and relationships)
  * @writes  graph (Community nodes, MEMBER_OF edges)
  */
@@ -14,7 +14,10 @@ import { isDev } from '../utils/env.js';
 import { logger } from '../../logger.js';
 export const communitiesPhase = {
     name: 'communities',
-    deps: ['mro', 'structure'],
+    // `pruneLocalSymbols` is declared explicitly (not just transitively via `mro`)
+    // so community detection always reads the trimmed graph even if a future option
+    // drops `mro` from the phase list.
+    deps: ['mro', 'pruneLocalSymbols', 'structure'],
     async execute(ctx, deps) {
         const { totalFiles } = getPhaseOutput(deps, 'structure');
         ctx.onProgress({

package/dist/core/ingestion/pipeline-phases/cross-file.d.ts

@@ -1,20 +1,21 @@
 /**
  * Phase: crossFile
  *
- * Cross-file binding propagation: seeds downstream files with resolved
- * type bindings from upstream exports. Files are processed in topological
- * import order so upstream bindings are available when downstream files
- * are re-resolved.
+ * Accumulator disposal anchor. The legacy cross-file call re-resolution that
+ * this phase used to run (`runCrossFileBindingPropagation`) was owned by the
+ * call-resolution DAG and skipped every registry-primary language; RING4-1
+ * (#942) deleted the DAG, so the propagation is gone and this phase now only
+ * disposes the `BindingAccumulator`. It is kept as a phase (rather than folded
+ * into `parse`) so disposal stays sequenced after every accumulator consumer.
  *
  * @deps    parse, routes, tools, orm (waits for all post-parse phases)
- * @reads   exportedTypeMap, allPaths, totalFiles
- * @writes  graph (refined CALLS edges via re-resolution)
+ * @reads   totalFiles, bindingAccumulator
+ * @writes  nothing (disposal only)
  *
  * **Accumulator ownership / residual risk.** This phase is the sole
  * disposer of the `BindingAccumulator` produced by `parse`. The dispose
  * call lives inside a `finally` block in `execute()` so that a throw
- * inside `runCrossFileBindingPropagation` (or anywhere else in the body)
- * still releases the accumulator's heap. The dependency declaration
+ * anywhere in the body still releases the accumulator's heap. The dependency declaration
  * (`deps: ['parse', 'routes', 'tools', 'orm']`) plus the runner's
  * topological scheduling guarantee that every other consumer of the
  * accumulator has finished before this phase starts, so disposing here

package/dist/core/ingestion/pipeline-phases/cross-file.js

@@ -1,20 +1,21 @@
 /**
  * Phase: crossFile
  *
- * Cross-file binding propagation: seeds downstream files with resolved
- * type bindings from upstream exports. Files are processed in topological
- * import order so upstream bindings are available when downstream files
- * are re-resolved.
+ * Accumulator disposal anchor. The legacy cross-file call re-resolution that
+ * this phase used to run (`runCrossFileBindingPropagation`) was owned by the
+ * call-resolution DAG and skipped every registry-primary language; RING4-1
+ * (#942) deleted the DAG, so the propagation is gone and this phase now only
+ * disposes the `BindingAccumulator`. It is kept as a phase (rather than folded
+ * into `parse`) so disposal stays sequenced after every accumulator consumer.
  *
  * @deps    parse, routes, tools, orm (waits for all post-parse phases)
- * @reads   exportedTypeMap, allPaths, totalFiles
- * @writes  graph (refined CALLS edges via re-resolution)
+ * @reads   totalFiles, bindingAccumulator
+ * @writes  nothing (disposal only)
  *
  * **Accumulator ownership / residual risk.** This phase is the sole
  * disposer of the `BindingAccumulator` produced by `parse`. The dispose
  * call lives inside a `finally` block in `execute()` so that a throw
- * inside `runCrossFileBindingPropagation` (or anywhere else in the body)
- * still releases the accumulator's heap. The dependency declaration
+ * anywhere in the body still releases the accumulator's heap. The dependency declaration
  * (`deps: ['parse', 'routes', 'tools', 'orm']`) plus the runner's
  * topological scheduling guarantee that every other consumer of the
  * accumulator has finished before this phase starts, so disposing here
@@ -30,14 +31,13 @@
  * disposes on the failure path). Do not silently rely on the GC.
  */
 import { getPhaseOutput } from './types.js';
-import { runCrossFileBindingPropagation } from './cross-file-impl.js';
 import { isDev } from '../utils/env.js';
 import { logger } from '../../logger.js';
 export const crossFilePhase = {
     name: 'crossFile',
     deps: ['parse', 'routes', 'tools', 'orm'],
     async execute(ctx, deps) {
-        const { exportedTypeMap, allPathSet, totalFiles, bindingAccumulator, resolutionContext } = getPhaseOutput(deps, 'parse');
+        const { totalFiles, bindingAccumulator } = getPhaseOutput(deps, 'parse');
         try {
             // Telemetry must run BEFORE dispose: totalBindings, fileCount, and
             // estimateMemoryBytes() all return 0 once dispose() clears the
@@ -51,8 +51,12 @@ export const crossFilePhase = {
                     logger.info(`📦 BindingAccumulator: EMPTY — 0 bindings across 0 files despite ${totalFiles} parsed files. If the codebase has typed bindings, this indicates an upstream regression.`);
                 }
             }
-            const filesReprocessed = await runCrossFileBindingPropagation(ctx.graph, resolutionContext, exportedTypeMap, allPathSet, totalFiles, ctx.repoPath, ctx.pipelineStart, ctx.onProgress);
-            return { filesReprocessed };
+            // Legacy cross-file call re-resolution was owned by the call-resolution
+            // DAG (registry-primary languages skipped it entirely). With the DAG
+            // removed (RING4-1 #942), scope-resolution owns all CALLS edges and no
+            // cross-file re-resolution pass runs here. This phase survives solely to
+            // dispose the BindingAccumulator on the runner's behalf (see finally).
+            return { filesReprocessed: 0 };
         }
         finally {
             // Single dispose call site for the accumulator — runs on both the

package/dist/core/ingestion/pipeline-phases/index.d.ts

@@ -14,6 +14,7 @@ export { toolsPhase, type ToolsOutput, type ToolDef } from './tools.js';
 export { ormPhase, type ORMOutput } from './orm.js';
 export { crossFilePhase, type CrossFileOutput } from './cross-file.js';
 export { scopeResolutionPhase, type ScopeResolutionOutput, } from '../scope-resolution/pipeline/phase.js';
+export { pruneLocalSymbolsPhase, type PruneLocalSymbolsOutput } from './prune-local-symbols.js';
 export { mroPhase, type MROOutput } from './mro.js';
 export { communitiesPhase, type CommunitiesOutput } from './communities.js';
 export { processesPhase, type ProcessesOutput } from './processes.js';

package/dist/core/ingestion/pipeline-phases/index.js

@@ -15,6 +15,7 @@ export { toolsPhase } from './tools.js';
 export { ormPhase } from './orm.js';
 export { crossFilePhase } from './cross-file.js';
 export { scopeResolutionPhase, } from '../scope-resolution/pipeline/phase.js';
+export { pruneLocalSymbolsPhase } from './prune-local-symbols.js';
 export { mroPhase } from './mro.js';
 export { communitiesPhase } from './communities.js';
 export { processesPhase } from './processes.js';

package/dist/core/ingestion/pipeline-phases/mro.d.ts

@@ -4,7 +4,7 @@
  * Computes Method Resolution Order (MRO) and creates METHOD_OVERRIDES
  * and METHOD_IMPLEMENTS edges.
  *
- * @deps    crossFile, scopeResolution
+ * @deps    crossFile, scopeResolution, pruneLocalSymbols
  * @reads   graph (all nodes and relationships)
  * @writes  graph (METHOD_OVERRIDES, METHOD_IMPLEMENTS edges)
  */

package/dist/core/ingestion/pipeline-phases/mro.js

@@ -4,7 +4,7 @@
  * Computes Method Resolution Order (MRO) and creates METHOD_OVERRIDES
  * and METHOD_IMPLEMENTS edges.
  *
- * @deps    crossFile, scopeResolution
+ * @deps    crossFile, scopeResolution, pruneLocalSymbols
  * @reads   graph (all nodes and relationships)
  * @writes  graph (METHOD_OVERRIDES, METHOD_IMPLEMENTS edges)
  */
@@ -14,7 +14,7 @@ import { isDev } from '../utils/env.js';
 import { logger } from '../../logger.js';
 export const mroPhase = {
     name: 'mro',
-    deps: ['crossFile', 'scopeResolution', 'structure'],
+    deps: ['crossFile', 'scopeResolution', 'pruneLocalSymbols', 'structure'],
     async execute(ctx, deps) {
         const { totalFiles } = getPhaseOutput(deps, 'structure');
         ctx.onProgress({

package/dist/core/ingestion/pipeline-phases/parse-impl.d.ts

@@ -2,9 +2,12 @@
  * Parse implementation — chunked parse + resolve loop.
  *
  * This is the core parsing engine of the ingestion pipeline. It reads
- * source files in byte-budget chunks (~20MB each), parses via worker
- * pool (or sequential fallback), resolves imports/calls/heritage per
- * chunk, and synthesizes wildcard import bindings.
+ * source files in byte-budget chunks (~20MB each), parses via the worker
+ * pool (the sole parse path — there is no sequential fallback), and emits
+ * route CALLS edges. Import,
+ * call, and inheritance resolution are owned by the scope-resolution
+ * phase, not here (RING4-1 #942 removed the legacy call DAG; RING4-2 #943
+ * removed the legacy per-file import resolution + wildcard synthesis).
  *
  * Consumed by the parse phase (`parse.ts`) — the phase file handles
  * dependency wiring while the heavy implementation lives here.
@@ -13,8 +16,7 @@
  */
 import { BindingAccumulator } from '../binding-accumulator.js';
 import { type ExportedTypeMap } from '../call-processor.js';
-import { createResolutionContext } from '../model/resolution-context.js';
-import { ASTCache } from '../ast-cache.js';
+import { type MutableSemanticModel } from '../model/index.js';
 import { type PipelineProgress } from '../../../_shared/index.js';
 import type { ExtractedDecoratorRoute, ExtractedFetchCall, ExtractedORMQuery, ExtractedRoute, ExtractedToolDef, FetchWrapperDef } from '../workers/parse-worker.js';
 import type { KnowledgeGraph } from '../../graph/types.js';
@@ -24,16 +26,38 @@ type ScannedFile = {
     size: number;
 };
 type ProgressFn = (progress: PipelineProgress) => void;
+/**
+ * Handle a worker-pool startup failure by FAILING FAST with the captured cause
+ * (#1741). The pool self-heals *transient* worker crashes on its own — a
+ * bounded, jittered startup restart loop (see worker-pool.ts) — so this is
+ * reached only when that self-heal is EXHAUSTED, or a deterministic crash-loop
+ * was detected, or the pool could not even be constructed. In every such case
+ * the workers genuinely cannot start.
+ *
+ * There is no sequential parser to silently degrade to — that fallback was
+ * removed (and it had masked a worker-startup regression as a 2-hour "stuck"
+ * run in #1741, rc99: a dropped `logger.warn` plus an unbounded sequential
+ * grind). GitNexus surfaces the real crash and aborts so the operator fixes the
+ * worker startup (commonly a missing build). The pool's own crash
+ * classification (`crashClass` on WorkerPoolInitializationError) sharpens the
+ * message.
+ *
+ * @throws always — an actionable Error carrying the captured worker crash.
+ * @internal Exported for unit tests; production callers are the parse loop's
+ *           two worker-startup catch sites below.
+ */
+export declare function handleWorkerStartupFailure(err: Error): never;
 /**
  * Chunked parse + resolve loop.
  *
- * Reads source in byte-budget chunks (~20MB each). For each chunk:
- * 1. Parse via worker pool (or sequential fallback)
- * 2. Resolve imports from extracted data
- * 3. Synthesize wildcard import bindings (Go/Ruby/C++/Swift/Python)
- * 4. Resolve heritage + routes per chunk; defer worker CALLS until all chunks
- *    have contributed heritage so interface-dispatch implementor map is complete
- * 5. Collect TypeEnv bindings for cross-file propagation
+ * Reads source in byte-budget chunks (~20MB each):
+ * 1. Parse each chunk via the worker pool (the sole parse path)
+ * 2. After all chunks parse, emit route CALLS edges (deferred so resolution
+ *    sees the full repo graph) and collect the exported-type map
+ * 3. Collect TypeEnv bindings for cross-file propagation
+ *
+ * Import, call, and inheritance edges are emitted by the scope-resolution
+ * phase, not here (RING4-1 #942 / RING4-2 #943 removed the legacy passes).
  */
 export declare function runChunkedParseAndResolve(graph: KnowledgeGraph, scannedFiles: ScannedFile[], allPaths: string[], totalFiles: number, repoPath: string, pipelineStart: number, onProgress: ProgressFn, options?: PipelineOptions): Promise<{
     exportedTypeMap: ExportedTypeMap;
@@ -44,17 +68,15 @@ export declare function runChunkedParseAndResolve(graph: KnowledgeGraph, scanned
     allToolDefs: ExtractedToolDef[];
     allORMQueries: ExtractedORMQuery[];
     bindingAccumulator: BindingAccumulator;
-    resolutionContext: ReturnType<typeof createResolutionContext>;
+    /** SemanticModel populated during parse — scope-resolution reads its
+     *  TypeRegistry / MethodRegistry / SymbolTable indexes. */
+    model: MutableSemanticModel;
+    /** Whether a worker pool was actually constructed for this run. False
+     *  means no pool was needed: a warm all-cache-hit run replays cached
+     *  worker output without spawning workers, or there were no parseable
+     *  files. There is no sequential parser — the pool is the sole parse path
+     *  whenever a chunk misses the cache. */
     usedWorkerPool: boolean;
-    /** Cross-phase tree-sitter Tree cache populated by the sequential
-     *  parse path. Distinct from the chunk-local `astCache` used inside
-     *  the parse loop (that one is cleared between chunks). Empty when
-     *  every chunk ran via the worker pool (workers can't return native
-     *  tree-sitter Trees across the MessageChannel). Downstream phases
-     *  (scope-resolution) read from this to skip re-parsing the same
-     *  source. See plan
-     *  docs/plans/2026-04-20-002-perf-parse-heritage-mro-plan.md (Unit 4). */
-    scopeTreeCache: ASTCache;
     /** Worker-produced ParsedFile artifacts aggregated across chunks.
      *  Threaded into scope-resolution as a re-extract cache so the warm-
      *  cache analyze run can skip the dominant `extractParsedFile` cost