fix(core): serialize stderr/process monitoring lifecycle (MCP-770)

StartStderrMonitoring (from connectStdio during a reconcile-driven Connect) and
StopStderrMonitoring (from Disconnect during Manager.ShutdownAll) accessed the
monitoring lifecycle fields — stderrMonitoringCtx/Cancel/WaitGroup and the
process-monitoring equivalents — with no synchronization. When a connect and a
shutdown overlap on the same client, the -race detector flags WG.Add (Start)
vs WG.Wait (Stop). CI caught this on PR #555's ubuntu unit job once the earlier
MCP-770 fixes (atomic Config) + the Windows temp-dir cleanup made the test's
shutdown path actually run concurrently with reconcile.

Add a dedicated monitoringMu that makes the four Start*/Stop*Monitoring methods
mutually exclusive, so Add never overlaps Wait. The mutex is a leaf (monitor
goroutines never acquire it; it is never held across c.mu), so Stop's bounded
WG.Wait under the lock cannot deadlock.

Add TestStderrMonitoring_StartStopRace: hammers Start/Stop concurrently; trips
-race on the unsynchronized fields, green with monitoringMu.

Related: MCP-770, spec 070

Author: Dumbris

internal/upstream/core/client.go

@@ -75,6 +75,14 @@ type Client struct {
 	// Cached tools list from successful immediate call
 	cachedTools []mcp.Tool
 
+	// monitoringMu serializes the stderr/process monitoring lifecycle methods
+	// (Start*/Stop*Monitoring). Connect (StartStderrMonitoring) and Disconnect
+	// (StopStderrMonitoring) can run concurrently on the same client during a
+	// reconcile-vs-shutdown overlap, racing the ctx/cancel/WaitGroup fields
+	// below (notably WG.Add vs WG.Wait). This mutex makes start and stop
+	// mutually exclusive. It is never held across c.mu.
+	monitoringMu sync.Mutex
+
 	// Stderr monitoring
 	stderrMonitoringCtx    context.Context
 	stderrMonitoringCancel context.CancelFunc

internal/upstream/core/monitoring.go

@@ -24,6 +24,9 @@ const (
 
 // StartStderrMonitoring starts monitoring stderr output and logging it
 func (c *Client) StartStderrMonitoring() {
+	c.monitoringMu.Lock()
+	defer c.monitoringMu.Unlock()
+
 	if c.stderr == nil || c.transportType != transportStdio {
 		return
 	}
@@ -43,6 +46,9 @@ func (c *Client) StartStderrMonitoring() {
 
 // StopStderrMonitoring stops stderr monitoring
 func (c *Client) StopStderrMonitoring() {
+	c.monitoringMu.Lock()
+	defer c.monitoringMu.Unlock()
+
 	if c.stderrMonitoringCancel != nil {
 		c.stderrMonitoringCancel()
 
@@ -66,6 +72,9 @@ func (c *Client) StopStderrMonitoring() {
 
 // StartProcessMonitoring starts monitoring the underlying process
 func (c *Client) StartProcessMonitoring() {
+	c.monitoringMu.Lock()
+	defer c.monitoringMu.Unlock()
+
 	// Start monitoring even if processCmd is nil for Docker containers
 	if c.processCmd == nil && !c.isDockerCommand {
 		return
@@ -94,6 +103,9 @@ func (c *Client) StartProcessMonitoring() {
 
 // StopProcessMonitoring stops process monitoring
 func (c *Client) StopProcessMonitoring() {
+	c.monitoringMu.Lock()
+	defer c.monitoringMu.Unlock()
+
 	if c.processMonitorCancel != nil {
 		c.processMonitorCancel()
 

internal/upstream/core/monitoring_race_test.go

@@ -0,0 +1,48 @@
+package core
+
+import (
+	"strings"
+	"sync"
+	"testing"
+
+	"go.uber.org/zap"
+
+	"github.com/smart-mcp-proxy/mcpproxy-go/internal/config"
+)
+
+// TestStderrMonitoring_StartStopRace reproduces the Connect-vs-Disconnect race
+// on the stderr-monitoring lifecycle fields (stderrMonitoringCtx/Cancel/WG).
+// StartStderrMonitoring runs from connectStdio during a reconcile-driven Connect
+// while StopStderrMonitoring runs from Disconnect during Manager.ShutdownAll, with
+// no synchronization on those fields — the -race detector flags WG.Add (Start)
+// vs WG.Wait (Stop). Run under `go test -race`: trips without monitoringMu, green
+// with it. A reused empty stderr reader returns EOF immediately so monitorStderr
+// exits at once and the loop stays fast.
+func TestStderrMonitoring_StartStopRace(t *testing.T) {
+	c := &Client{
+		transportType: transportStdio,
+		stderr:        strings.NewReader(""),
+		logger:        zap.NewNop(),
+		config:        &config.ServerConfig{Name: "race"},
+	}
+
+	const iterations = 500
+	var wg sync.WaitGroup
+	wg.Add(2)
+
+	go func() {
+		defer wg.Done()
+		for i := 0; i < iterations; i++ {
+			c.StartStderrMonitoring()
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		for i := 0; i < iterations; i++ {
+			c.StopStderrMonitoring()
+		}
+	}()
+
+	wg.Wait()
+	c.StopStderrMonitoring()
+}