refactor: use sync.WaitGroup.Go in tests (#26671)

Migrate `wg.Add(1); go func() { defer wg.Done(); ... }()` to
`wg.Go(func() { ... })` in tests.

Where the prior pattern passed the loop variable explicitly via a
closure parameter (`go func(id int) { ... }(i)`), drop the parameter and
reference the loop variable directly. Per-iteration loop variables since
Go 1.22 make this safe.

agent/agentproc/api_test.go

@@ -964,13 +964,11 @@ func TestProcessOutput(t *testing.T) {
 			codes [2]int
 		)
 		for i := range 2 {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
+			wg.Go(func() {
 				w := getOutputWithWait(t, handler, id)
 				codes[i] = w.Code
 				_ = json.NewDecoder(w.Body).Decode(&resps[i])
-			}()
+			})
 		}
 
 		// Signal the process to exit so both waiters unblock.

agent/filefinder/bench_test.go

@@ -300,13 +300,11 @@ func BenchmarkSearch_ConcurrentReads_Throughput(b *testing.B) {
 				perGoroutine = 1
 			}
 			for gi := 0; gi < g; gi++ {
-				wg.Add(1)
-				go func() {
-					defer wg.Done()
+				wg.Go(func() {
 					for j := 0; j < perGoroutine; j++ {
 						_ = filefinder.SearchSnapshotForTest(plan, snap, maxCands)
 					}
-				}()
+				})
 			}
 			wg.Wait()
 			totalOps := float64(g * perGoroutine)

agent/immortalstreams/backedpipe/backed_pipe_test.go

@@ -756,13 +756,11 @@ func TestBackedPipe_DuplicateReconnectionPrevention(t *testing.T) {
 
 	// Start all goroutines
 	for i := 0; i < numConcurrent; i++ {
-		wg.Add(1)
-		go func(idx int) {
-			defer wg.Done()
+		wg.Go(func() {
 			// Wait for the signal to start
-			<-startSignals[idx]
-			errors[idx] = bp.ForceReconnect()
-		}(i)
+			<-startSignals[i]
+			errors[i] = bp.ForceReconnect()
+		})
 	}
 
 	// Start the first ForceReconnect and wait for it to block

agent/immortalstreams/backedpipe/backed_writer_test.go

@@ -883,14 +883,12 @@ func TestBackedWriter_MultipleWritesDuringReconnect(t *testing.T) {
 	writesStarted := make(chan struct{}, numWriters)
 
 	for i := 0; i < numWriters; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
+		wg.Go(func() {
 			// Signal that this write is starting
 			writesStarted <- struct{}{}
-			data := []byte{byte('A' + id)}
-			_, writeResults[id] = bw.Write(data)
-		}(i)
+			data := []byte{byte('A' + i)}
+			_, writeResults[i] = bw.Write(data)
+		})
 	}
 
 	// Wait for all writes to start

agent/unit/graph_test.go

@@ -244,16 +244,14 @@ func TestGraphThreadSafety(t *testing.T) {
 		barrier := make(chan struct{})
 		// Launch writers
 		for i := 0; i < numWriters; i++ {
-			wg.Add(1)
-			go func(writerID int) {
-				defer wg.Done()
+			wg.Go(func() {
 				<-barrier
 				for j := 0; j < operationsPerWriter; j++ {
-					from := &testGraphVertex{Name: fmt.Sprintf("writer-%d-%d", writerID, j)}
-					to := &testGraphVertex{Name: fmt.Sprintf("writer-%d-%d", writerID, j+1)}
+					from := &testGraphVertex{Name: fmt.Sprintf("writer-%d-%d", i, j)}
+					to := &testGraphVertex{Name: fmt.Sprintf("writer-%d-%d", i, j+1)}
 					graph.AddEdge(from, to, testEdgeCompleted)
 				}
-			}(i)
+			})
 		}
 
 		// Launch readers
@@ -263,20 +261,18 @@ func TestGraphThreadSafety(t *testing.T) {
 		}, numReaders)
 
 		for i := 0; i < numReaders; i++ {
-			wg.Add(1)
-			go func(readerID int) {
-				defer wg.Done()
+			wg.Go(func() {
 				<-barrier
 				defer func() {
 					if r := recover(); r != nil {
-						readerResults[readerID].panicked = true
+						readerResults[i].panicked = true
 					}
 				}()
 
 				readCount := 0
 				for j := 0; j < operationsPerReader; j++ {
 					// Create a test vertex and read
-					testUnit := &testGraphVertex{Name: fmt.Sprintf("test-reader-%d-%d", readerID, j)}
+					testUnit := &testGraphVertex{Name: fmt.Sprintf("test-reader-%d-%d", i, j)}
 					forwardEdges := graph.GetForwardAdjacentVertices(testUnit)
 					reverseEdges := graph.GetReverseAdjacentVertices(testUnit)
 
@@ -285,8 +281,8 @@ func TestGraphThreadSafety(t *testing.T) {
 					_ = reverseEdges
 					readCount++
 				}
-				readerResults[readerID].readCount = readCount
-			}(i)
+				readerResults[i].readCount = readCount
+			})
 		}
 
 		close(barrier)
@@ -324,13 +320,11 @@ func TestGraphThreadSafety(t *testing.T) {
 
 		// Launch goroutines trying to add D→A (creates cycle)
 		for i := 0; i < numGoroutines; i++ {
-			wg.Add(1)
-			go func(goroutineID int) {
-				defer wg.Done()
+			wg.Go(func() {
 				<-barrier
 				err := graph.AddEdge(unitD, unitA, testEdgeCompleted)
-				cycleErrors[goroutineID] = err
-			}(i)
+				cycleErrors[i] = err
+			})
 		}
 
 		close(barrier)
@@ -370,28 +364,24 @@ func TestGraphThreadSafety(t *testing.T) {
 		// Launch readers calling ToDOT
 		dotErrors := make([]error, numReaders)
 		for i := 0; i < numReaders; i++ {
-			wg.Add(1)
-			go func(readerID int) {
-				defer wg.Done()
+			wg.Go(func() {
 				<-barrier
-				dot, err := graph.ToDOT(fmt.Sprintf("test-%d", readerID))
-				dotErrors[readerID] = err
+				dot, err := graph.ToDOT(fmt.Sprintf("test-%d", i))
+				dotErrors[i] = err
 				if err == nil {
-					dotResults[readerID] = dot
+					dotResults[i] = dot
 				}
-			}(i)
+			})
 		}
 
 		// Launch writers adding edges
 		for i := 0; i < numWriters; i++ {
-			wg.Add(1)
-			go func(writerID int) {
-				defer wg.Done()
+			wg.Go(func() {
 				<-barrier
-				from := &testGraphVertex{Name: fmt.Sprintf("writer-dot-%d", writerID)}
-				to := &testGraphVertex{Name: fmt.Sprintf("writer-dot-target-%d", writerID)}
+				from := &testGraphVertex{Name: fmt.Sprintf("writer-dot-%d", i)}
+				to := &testGraphVertex{Name: fmt.Sprintf("writer-dot-target-%d", i)}
 				graph.AddEdge(from, to, testEdgeCompleted)
-			}(i)
+			})
 		}
 
 		close(barrier)
@@ -418,9 +408,7 @@ func BenchmarkGraph_ConcurrentMixedOperations(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		// Launch goroutines performing random operations
 		for j := 0; j < numGoroutines; j++ {
-			wg.Add(1)
-			go func(goroutineID int) {
-				defer wg.Done()
+			wg.Go(func() {
 				operationCount := 0
 
 				for operationCount < 50 {
@@ -428,7 +416,7 @@ func BenchmarkGraph_ConcurrentMixedOperations(b *testing.B) {
 
 					if operation < 0.6 { // 60% reads
 						// Read operation
-						testUnit := &testGraphVertex{Name: fmt.Sprintf("bench-read-%d-%d", goroutineID, operationCount)}
+						testUnit := &testGraphVertex{Name: fmt.Sprintf("bench-read-%d-%d", j, operationCount)}
 						forwardEdges := graph.GetForwardAdjacentVertices(testUnit)
 						reverseEdges := graph.GetReverseAdjacentVertices(testUnit)
 
@@ -437,14 +425,14 @@ func BenchmarkGraph_ConcurrentMixedOperations(b *testing.B) {
 						_ = reverseEdges
 					} else { // 40% writes
 						// Write operation
-						from := &testGraphVertex{Name: fmt.Sprintf("bench-write-%d-%d", goroutineID, operationCount)}
-						to := &testGraphVertex{Name: fmt.Sprintf("bench-write-target-%d-%d", goroutineID, operationCount)}
+						from := &testGraphVertex{Name: fmt.Sprintf("bench-write-%d-%d", j, operationCount)}
+						to := &testGraphVertex{Name: fmt.Sprintf("bench-write-target-%d-%d", j, operationCount)}
 						graph.AddEdge(from, to, testEdgeCompleted)
 					}
 
 					operationCount++
 				}
-			}(j)
+			})
 		}
 
 		wg.Wait()