fix(listener): warn on dropped coverage signals instead of ignoring

The listener's 1000-slot signal buffer could overflow under heavy load.
Dropped signals were pushed to an errors channel that was never drained,
so lost coverage was completely invisible to the user.

Replace the dead-letter error channel push with an atomic counter
(sync/atomic.Int64) on the Listener struct. Add DroppedSignals() method
to query the count. In executor.go, check the counter after
CollectSignals and print a WARNING with the test name and drop count
when non-zero. The warning is unconditional (not gated by --verbose)
since lost coverage data always warrants user attention.

Author: pashagolub

internal/database/listener.go

@@ -3,6 +3,7 @@ package database
 import (
 	"context"
 	"fmt"
+	"sync/atomic"
 	"time"
 
 	"github.com/cybertec-postgresql/pgcov/pkg/types"
@@ -13,11 +14,12 @@ import (
 
 // Listener handles PostgreSQL LISTEN/NOTIFY for coverage signals
 type Listener struct {
-	conn    *pgx.Conn
-	channel string
-	signals chan types.CoverageSignal
-	errors  chan error
-	done    chan struct{}
+	conn           *pgx.Conn
+	channel        string
+	signals        chan types.CoverageSignal
+	errors         chan error
+	done           chan struct{}
+	droppedSignals atomic.Int64
 }
 
 // NewListener creates a new LISTEN/NOTIFY listener using the config from a pool.
@@ -105,11 +107,9 @@ func (l *Listener) receiveLoop(ctx context.Context) {
 				select {
 				case l.signals <- signal:
 				default:
-					// Buffer full, log warning but don't block
-					select {
-					case l.errors <- fmt.Errorf("signal buffer full, dropping signal: %s", notification.Payload):
-					default:
-					}
+					// Buffer full — increment counter so the caller can
+					// detect and report lost signals after test execution.
+					l.droppedSignals.Add(1)
 				}
 			}
 		}
@@ -126,6 +126,13 @@ func (l *Listener) Errors() <-chan error {
 	return l.errors
 }
 
+// DroppedSignals returns the number of signals that were dropped because
+// the internal buffer was full.  A non-zero value means coverage data is
+// incomplete.
+func (l *Listener) DroppedSignals() int64 {
+	return l.droppedSignals.Load()
+}
+
 // Close stops the listener and closes the connection
 func (l *Listener) Close(ctx context.Context) error {
 	close(l.done)

internal/runner/executor.go

@@ -261,6 +261,12 @@ func (e *Executor) executeTestWorkflow(ctx context.Context, testRun *TestRun, so
 		fmt.Printf("[DEBUG] Collected %d signals\n", len(signals))
 	}
 
+	// Check for dropped signals — warns about incomplete coverage data
+	if dropped := listener.DroppedSignals(); dropped > 0 {
+		fmt.Printf("[WARNING] %d coverage signal(s) dropped for %s (buffer full) — coverage data is incomplete\n",
+			dropped, testRun.Test.RelativePath)
+	}
+
 	// Append NOTIFY signals to the implicit coverage signals
 	testRun.CoverageSigs = append(testRun.CoverageSigs, signals...)