perf: resolve each distinct cross-ref target once per sync pass

SyncNamespace issued one ResolveCCGRef round-trip per @see tag and per
inbound row, although many rows share the same (namespace, path,
symbol) target — comment binding alone duplicates every ref across the
function and file node. Memoize matcher outcomes per distinct target
for the duration of one sync pass; the memo stays valid across the
outbound and inbound phases because a sync pass rewrites only
cross_refs rows, never the node tables the matcher reads.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: tae2089

internal/app/crossref/service.go

@@ -52,17 +52,49 @@ func (s *Service) SyncNamespace(ctx context.Context) error {
 		return trace.New("cross-ref store is not configured")
 	}
 	ns := requestctx.FromContext(ctx)
-	if err := s.rebuildOutbound(ctx, ns); err != nil {
+	memo := map[targetKey]resolution{}
+	if err := s.rebuildOutbound(ctx, ns, memo); err != nil {
 		return trace.Wrap(err, "rebuild outbound cross refs")
 	}
-	if err := s.reresolveInbound(ctx, ns); err != nil {
+	if err := s.reresolveInbound(ctx, ns, memo); err != nil {
 		return trace.Wrap(err, "re-resolve inbound cross refs")
 	}
 	return nil
 }
 
+// targetKey identifies one distinct symbolic resolution target within a sync pass.
+// @intent resolve every distinct (namespace, path, symbol) target once per sync instead of once per referencing row.
+type targetKey struct {
+	namespace string
+	path      string
+	symbol    string
+}
+
+// resolution caches one matcher outcome for reuse across rows that share a target.
+type resolution struct {
+	id     *uint
+	status graph.CrossRefStatus
+}
+
+// resolveOnce memoizes resolve results per distinct target for the duration of one sync pass.
+// @intent collapse the per-row resolve round-trips (N+1) down to one query per distinct target.
+// @domainRule the memo stays valid across the outbound and inbound phases because a sync pass
+// only rewrites cross_refs rows, never the node tables the matcher reads.
+func (s *Service) resolveOnce(ctx context.Context, ref reference.Ref, memo map[targetKey]resolution) (*uint, graph.CrossRefStatus, error) {
+	key := targetKey{namespace: ref.Namespace, path: ref.Path, symbol: ref.Symbol}
+	if cached, ok := memo[key]; ok {
+		return cached.id, cached.status, nil
+	}
+	id, status, err := s.resolve(ctx, ref)
+	if err != nil {
+		return nil, status, err
+	}
+	memo[key] = resolution{id: id, status: status}
+	return id, status, nil
+}
+
 // @intent replace the namespace's outbound rows with rows derived from its current annotations.
-func (s *Service) rebuildOutbound(ctx context.Context, ns string) error {
+func (s *Service) rebuildOutbound(ctx context.Context, ns string, memo map[targetKey]resolution) error {
 	tags, err := s.Store.ListAnnotationCCGRefs(ctx, ns)
 	if err != nil {
 		return err
@@ -79,7 +111,7 @@ func (s *Service) rebuildOutbound(ctx context.Context, ns string) error {
 			s.logger().Debug("skipping malformed ccg ref", "node_id", tag.NodeID, "value", tag.Value, "error", err)
 			continue
 		}
-		resolvedID, status, err := s.resolve(ctx, *ref)
+		resolvedID, status, err := s.resolveOnce(ctx, *ref, memo)
 		if err != nil {
 			return err
 		}
@@ -99,14 +131,14 @@ func (s *Service) rebuildOutbound(ctx context.Context, ns string) error {
 }
 
 // @intent update inbound rows whose resolution changed after this namespace's nodes were rebuilt.
-func (s *Service) reresolveInbound(ctx context.Context, ns string) error {
+func (s *Service) reresolveInbound(ctx context.Context, ns string, memo map[targetKey]resolution) error {
 	inbound, err := s.Store.ListInboundCrossRefs(ctx, ns)
 	if err != nil {
 		return err
 	}
 	for _, row := range inbound {
 		ref := reference.Ref{Raw: row.Raw, Namespace: row.ToNamespace, Path: row.ToPath, Symbol: row.ToSymbol}
-		resolvedID, status, err := s.resolve(ctx, ref)
+		resolvedID, status, err := s.resolveOnce(ctx, ref, memo)
 		if err != nil {
 			return err
 		}

internal/app/crossref/service_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/tae2089/code-context-graph/internal/app/crossref"
 	requestctx "github.com/tae2089/code-context-graph/internal/ctx"
 	"github.com/tae2089/code-context-graph/internal/domain/graph"
+	"github.com/tae2089/code-context-graph/internal/domain/reference"
 )
 
 func setupStore(t *testing.T) *graphgorm.Store {
@@ -60,6 +61,67 @@ func syncNamespace(t *testing.T, svc *crossref.Service, namespace string) {
 	}
 }
 
+// countingStore counts resolve round-trips so tests can assert per-distinct-target batching.
+type countingStore struct {
+	*graphgorm.Store
+	resolveCalls int
+}
+
+func (c *countingStore) ResolveCCGRef(ctx context.Context, ref reference.Ref) (uint, bool, error) {
+	c.resolveCalls++
+	return c.Store.ResolveCCGRef(ctx, ref)
+}
+
+func TestSyncNamespace_ResolvesEachDistinctTargetOnce(t *testing.T) {
+	s := setupStore(t)
+	counting := &countingStore{Store: s}
+	svc := crossref.New(counting)
+
+	seedNode(t, s, "auth-svc", graph.Node{
+		QualifiedName: "auth.ValidateToken", Kind: graph.NodeKindFunction, Name: "ValidateToken",
+		FilePath: "internal/auth/token.go", StartLine: 10, EndLine: 20,
+	})
+	loginID := seedNode(t, s, "web", graph.Node{
+		QualifiedName: "web.Login", Kind: graph.NodeKindFunction, Name: "Login",
+		FilePath: "internal/web/login.go", StartLine: 5, EndLine: 25,
+	})
+	logoutID := seedNode(t, s, "web", graph.Node{
+		QualifiedName: "web.Logout", Kind: graph.NodeKindFunction, Name: "Logout",
+		FilePath: "internal/web/login.go", StartLine: 30, EndLine: 40,
+	})
+	// Two nodes referencing the same target, one of them also via a second identical tag.
+	annotate(t, s, "web", loginID,
+		"ccg://auth-svc/internal/auth/token.go#ValidateToken",
+		"ccg://auth-svc/internal/auth/token.go#ValidateToken",
+	)
+	annotate(t, s, "web", logoutID, "ccg://auth-svc/internal/auth/token.go#ValidateToken")
+
+	syncNamespace(t, svc, "web")
+
+	if counting.resolveCalls != 1 {
+		t.Fatalf("resolve round-trips = %d, want 1 for a single distinct target", counting.resolveCalls)
+	}
+	rows, err := s.ListOutboundCrossRefs(context.Background(), "web")
+	if err != nil {
+		t.Fatalf("list outbound: %v", err)
+	}
+	if len(rows) != 2 {
+		t.Fatalf("outbound rows = %d, want 2 (one per declaring node, dedup of identical tag)", len(rows))
+	}
+	for _, row := range rows {
+		if row.Status != graph.CrossRefStatusResolved || row.ResolvedNodeID == nil {
+			t.Fatalf("row = %+v, want resolved", row)
+		}
+	}
+
+	// Inbound re-resolution of auth-svc: 2 rows, same target — one resolve round-trip.
+	counting.resolveCalls = 0
+	syncNamespace(t, svc, "auth-svc")
+	if counting.resolveCalls != 1 {
+		t.Fatalf("inbound resolve round-trips = %d, want 1 for a single distinct target", counting.resolveCalls)
+	}
+}
+
 func TestSyncNamespace_MaterializesResolvedAndDeadRefs(t *testing.T) {
 	s := setupStore(t)
 	svc := crossref.New(s)