fix: resolve implements before staged calls

Author: tae2089

internal/app/ingest/incremental/incremental.go

@@ -306,6 +306,8 @@ func (s *Syncer) syncBatchesWithExisting(ctx context.Context, syncStore Store, s
 	}
 
 	lookup := newImportIndexedLookup(syncStore)
+	// Resolve every implementation relationship before any call edge. Interface
+	// dispatch may depend on an implements edge stored in a later spool record.
 	for _, path := range edgeSpool.records {
 		record, err := edgeSpool.readRecord(path)
 		if err != nil {
@@ -315,7 +317,20 @@ func (s *Syncer) syncBatchesWithExisting(ctx context.Context, syncStore Store, s
 		for _, file := range record.Files {
 			parsedFiles = append(parsedFiles, parsedSyncFile{filePath: file.FilePath, edges: file.Edges})
 		}
-		if err := s.resolveAndUpsertEdges(ctx, syncStore, lookup, parsedFiles, stats); err != nil {
+		if err := s.resolveAndUpsertImplements(ctx, syncStore, lookup, parsedFiles, stats); err != nil {
+			return nil, err
+		}
+	}
+	for _, path := range edgeSpool.records {
+		record, err := edgeSpool.readRecord(path)
+		if err != nil {
+			return nil, err
+		}
+		parsedFiles := make([]parsedSyncFile, 0, len(record.Files))
+		for _, file := range record.Files {
+			parsedFiles = append(parsedFiles, parsedSyncFile{filePath: file.FilePath, edges: file.Edges})
+		}
+		if err := s.resolveAndUpsertOtherEdges(ctx, syncStore, lookup, parsedFiles, stats); err != nil {
 			return nil, err
 		}
 	}
@@ -419,7 +434,25 @@ func (s *Syncer) stageBatch(ctx context.Context, syncStore Store, files map[stri
 // @sideEffect upserts resolved graph edges through the sync store.
 // @mutates graph edges, stats.Unresolved
 func (s *Syncer) resolveAndUpsertEdges(ctx context.Context, syncStore Store, lookup resolve.NodeLookup, parsedFiles []parsedSyncFile, stats *SyncStats) error {
-	implementsEdges, otherByFile := partitionParsedSyncEdges(parsedFiles)
+	if err := s.resolveAndUpsertImplements(ctx, syncStore, lookup, parsedFiles, stats); err != nil {
+		return err
+	}
+	return s.resolveAndUpsertOtherEdges(ctx, syncStore, lookup, parsedFiles, stats)
+}
+
+// resolveAndUpsertImplements resolves only implementation relationships from one parsed file set.
+// @intent let staged reconciliation finish a global implements pass before resolving interface-dispatch calls.
+// @sideEffect upserts resolved implements edges through the sync store.
+// @mutates graph edges, stats.Unresolved
+func (s *Syncer) resolveAndUpsertImplements(ctx context.Context, syncStore Store, lookup resolve.NodeLookup, parsedFiles []parsedSyncFile, stats *SyncStats) error {
+	var implementsEdges []graph.Edge
+	for _, parsed := range parsedFiles {
+		for _, edge := range parsed.edges {
+			if edge.Kind == graph.EdgeKindImplements {
+				implementsEdges = append(implementsEdges, edge)
+			}
+		}
+	}
 	for _, edgeChunk := range splitEdgeChunks(implementsEdges) {
 		resolved, err := resolve.ResolveWithOptions(ctx, lookup, edgeChunk, s.opts)
 		if err != nil {
@@ -434,6 +467,15 @@ func (s *Syncer) resolveAndUpsertEdges(ctx context.Context, syncStore Store, loo
 			return err
 		}
 	}
+	return nil
+}
+
+// resolveAndUpsertOtherEdges resolves non-implements relationships after implementation state is complete.
+// @intent preserve file-local import warmup while making interface call resolution independent of spool record order.
+// @sideEffect upserts resolved call, import, contains, and related edges through the sync store.
+// @mutates graph edges, stats.Unresolved
+func (s *Syncer) resolveAndUpsertOtherEdges(ctx context.Context, syncStore Store, lookup resolve.NodeLookup, parsedFiles []parsedSyncFile, stats *SyncStats) error {
+	_, otherByFile := partitionParsedSyncEdges(parsedFiles)
 	importsByFile := importEdgesByFile(otherByFile)
 	for _, parsed := range parsedFiles {
 		edges := otherByFile[parsed.filePath]

internal/app/ingest/incremental/incremental_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/tae2089/code-context-graph/internal/adapters/outbound/treesitter"
+	"github.com/tae2089/code-context-graph/internal/app/ingest"
 	"github.com/tae2089/code-context-graph/internal/domain/graph"
 	"github.com/tae2089/code-context-graph/internal/domain/reference"
 )
@@ -701,6 +702,55 @@ func TestIncremental_ResolvesCallEdgesAcrossMultipleFilesInBatch(t *testing.T) {
 	}
 }
 
+func TestSyncBatchesWithExisting_ResolvesImplementsBeforeEarlierCallBatch(t *testing.T) {
+	st := newStore()
+	st.nodes["mcp.FlowTracer"] = &graph.Node{ID: 10, QualifiedName: "mcp.FlowTracer", Kind: graph.NodeKindType, Name: "FlowTracer", FilePath: "mcp/deps.go", StartLine: 1, EndLine: 3, Hash: "iface", Language: "go"}
+	st.nodes["mcp/deps.go"] = &graph.Node{ID: 11, QualifiedName: "mcp/deps.go", Kind: graph.NodeKindFile, Name: "mcp/deps.go", FilePath: "mcp/deps.go", StartLine: 1, EndLine: 3, Hash: "iface", Language: "go"}
+	parser := &staticParser{result: map[string]parseResult{
+		"cmd/main.go": {
+			nodes: []graph.Node{
+				{QualifiedName: "cmd/main.go", Kind: graph.NodeKindFile, Name: "cmd/main.go", FilePath: "cmd/main.go", StartLine: 1, EndLine: 20, Hash: "main", Language: "go"},
+				{QualifiedName: "main.Run", Kind: graph.NodeKindFunction, Name: "Run", FilePath: "cmd/main.go", StartLine: 3, EndLine: 8, Hash: "main", Language: "go"},
+			},
+			edges: []graph.Edge{
+				{Kind: graph.EdgeKindImportsFrom, FilePath: "cmd/main.go", Line: 1, Fingerprint: "imports_from:cmd/main.go:github.com/example/project/mcp:1"},
+				{Kind: graph.EdgeKindCalls, FilePath: "cmd/main.go", Line: 4, Fingerprint: "calls:cmd/main.go:h.deps.FlowTracer.TraceFlow:4"},
+			},
+		},
+		"flows/tracer.go": {
+			nodes: []graph.Node{
+				{QualifiedName: "flows/tracer.go", Kind: graph.NodeKindFile, Name: "flows/tracer.go", FilePath: "flows/tracer.go", StartLine: 1, EndLine: 20, Hash: "impl", Language: "go"},
+				{QualifiedName: "flows.Tracer", Kind: graph.NodeKindClass, Name: "Tracer", FilePath: "flows/tracer.go", StartLine: 3, EndLine: 7, Hash: "impl", Language: "go"},
+				{QualifiedName: "flows.Tracer.TraceFlow", Kind: graph.NodeKindFunction, Name: "TraceFlow", FilePath: "flows/tracer.go", StartLine: 5, EndLine: 6, Hash: "impl", Language: "go"},
+			},
+			edges: []graph.Edge{{Kind: graph.EdgeKindImplements, FilePath: "flows/tracer.go", Line: 3, Fingerprint: "implements:flows/tracer.go:flows.Tracer:mcp.FlowTracer"}},
+		},
+	}}
+
+	source := ingest.FileBatchSource(func(visitor ingest.FileBatchVisitor) error {
+		for _, files := range []map[string]ingest.FileInfo{
+			{"cmd/main.go": {Hash: "main", Content: []byte("package main")}},
+			{"flows/tracer.go": {Hash: "impl", Content: []byte("package flows")}},
+		} {
+			if err := visitor(files); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+
+	syncer := New(st, parser)
+	if _, err := syncer.SyncBatchesWithExisting(context.Background(), source, nil); err != nil {
+		t.Fatal(err)
+	}
+	for _, edge := range st.upsertedEdges {
+		if edge.Kind == graph.EdgeKindCalls && edge.FromNodeID != 0 && edge.ToNodeID != 0 {
+			return
+		}
+	}
+	t.Fatalf("expected earlier call batch to resolve after later implements batch, got %+v", st.upsertedEdges)
+}
+
 func TestIncremental_BatchesNodesBeforeResolvingEdges(t *testing.T) {
 	st := newStore()
 	st.nodes["mcp.FlowTracer"] = &graph.Node{ID: 10, QualifiedName: "mcp.FlowTracer", Kind: graph.NodeKindType, Name: "FlowTracer", FilePath: "mcp/deps.go", StartLine: 1, EndLine: 3, Hash: "iface", Language: "go"}