feat(queue): replace PocketBase polling with Asynq + Redis

Introduce a Redis-backed Asynq task queue so the runner consumes TTS
jobs pushed by the backend instead of polling PocketBase.

- backend/internal/asynqqueue: Producer and Consumer wrappers
- backend/internal/runner: AsynqRunner mux, per-instance Prometheus
  registry (fixes duplicate-collector panic in tests), redisConnOpt
- backend/internal/config: REDIS_ADDR / REDIS_PASSWORD env vars
- backend/cmd/{backend,runner}/main.go: wire Redis when env set; fall
  back to legacy poll mode when unset
- Caddyfile: caddy-l4 TCP proxy for redis.libnovel.cc:6380 → homelab
- caddy/Dockerfile: add --with github.com/mholt/caddy-l4
- docker-compose.yml: Caddy exposes 6380, backend/runner get Redis env
- homelab/runner/docker-compose.yml: Redis sidecar, runner depends_on
- homelab/otel/grafana: Grafana dashboards (backend, catalogue, runner)
  and alerting rules / contact-points provisioning

backend/internal/runner/runner.go

@@ -34,6 +34,7 @@ import (
 	"github.com/libnovel/backend/internal/pockettts"
 	"github.com/libnovel/backend/internal/scraper"
 	"github.com/libnovel/backend/internal/taskqueue"
+	"github.com/prometheus/client_golang/prometheus"
 )
 
 // Config tunes the runner behaviour.
@@ -41,6 +42,7 @@ type Config struct {
 	// WorkerID uniquely identifies this runner instance in PocketBase records.
 	WorkerID string
 	// PollInterval is how often the runner checks for new tasks.
+	// Only used in PocketBase-polling mode (RedisAddr == "").
 	PollInterval time.Duration
 	// MaxConcurrentScrape limits simultaneous book-scrape goroutines.
 	MaxConcurrentScrape int
@@ -50,9 +52,11 @@ type Config struct {
 	OrchestratorWorkers int
 	// HeartbeatInterval is how often active tasks PATCH their heartbeat_at
 	// timestamp to signal they are still alive. Defaults to 30s when 0.
+	// Only used in PocketBase-polling mode.
 	HeartbeatInterval time.Duration
 	// StaleTaskThreshold is how old a heartbeat must be (or absent) before the
 	// task is considered orphaned and reset to pending. Defaults to 2m when 0.
+	// Only used in PocketBase-polling mode.
 	StaleTaskThreshold time.Duration
 	// CatalogueRefreshInterval is how often the runner walks the full catalogue,
 	// scrapes per-book metadata, downloads covers, and re-indexes everything in
@@ -66,6 +70,15 @@ type Config struct {
 	// MetricsAddr is the HTTP listen address for the /metrics endpoint.
 	// Defaults to ":9091". Set to "" to disable.
 	MetricsAddr string
+	// RedisAddr is the address of the Redis instance used for Asynq task
+	// dispatch. When set the runner switches from PocketBase-polling mode to
+	// Asynq ServeMux mode (immediate task delivery, no polling).
+	// Supports plain "host:port" or a full "rediss://..." URL.
+	// When empty the runner falls back to PocketBase polling.
+	RedisAddr string
+	// RedisPassword is the Redis AUTH password.
+	// Not required when RedisAddr is a full URL that includes credentials.
+	RedisPassword string
 }
 
 // Dependencies are the external services the runner depends on.
@@ -99,6 +112,8 @@ type Runner struct {
 	cfg  Config
 	deps Dependencies
 
+	metricsRegistry *prometheus.Registry
+
 	// Atomic task counters — read by /metrics without locking.
 	tasksRunning   atomic.Int64
 	tasksCompleted atomic.Int64
@@ -139,15 +154,18 @@ func New(cfg Config, deps Dependencies) *Runner {
 	if deps.SearchIndex == nil {
 		deps.SearchIndex = meili.NoopClient{}
 	}
-	return &Runner{cfg: cfg, deps: deps, startedAt: time.Now()}
+	return &Runner{cfg: cfg, deps: deps, startedAt: time.Now(), metricsRegistry: prometheus.NewRegistry()}
 }
 
-// Run starts the poll loop and the metrics HTTP server, blocking until ctx is
-// cancelled.
+// Run starts the worker loop and the metrics HTTP server, blocking until ctx
+// is cancelled.
+//
+// When cfg.RedisAddr is set the runner uses Asynq (immediate task delivery).
+// Otherwise it falls back to PocketBase polling (legacy mode).
 func (r *Runner) Run(ctx context.Context) error {
 	r.deps.Log.Info("runner: starting",
 		"worker_id", r.cfg.WorkerID,
-		"poll_interval", r.cfg.PollInterval,
+		"mode", r.mode(),
 		"max_scrape", r.cfg.MaxConcurrentScrape,
 		"max_audio", r.cfg.MaxConcurrentAudio,
 		"catalogue_refresh_interval", r.cfg.CatalogueRefreshInterval,
@@ -164,6 +182,23 @@ func (r *Runner) Run(ctx context.Context) error {
 		}()
 	}
 
+	if r.cfg.RedisAddr != "" {
+		return r.runAsynq(ctx)
+	}
+	return r.runPoll(ctx)
+}
+
+// mode returns a short string describing the active dispatch mode.
+func (r *Runner) mode() string {
+	if r.cfg.RedisAddr != "" {
+		return "asynq"
+	}
+	return "poll"
+}
+
+// runPoll is the legacy PocketBase-polling dispatch loop.
+// Used when cfg.RedisAddr is empty.
+func (r *Runner) runPoll(ctx context.Context) error {
 	scrapeSem := make(chan struct{}, r.cfg.MaxConcurrentScrape)
 	audioSem := make(chan struct{}, r.cfg.MaxConcurrentAudio)
 	var wg sync.WaitGroup
@@ -181,6 +216,8 @@ func (r *Runner) Run(ctx context.Context) error {
 		r.deps.Log.Info("runner: skipping initial catalogue refresh (RUNNER_SKIP_INITIAL_CATALOGUE_REFRESH=true)")
 	}
 
+	r.deps.Log.Info("runner: poll mode active", "poll_interval", r.cfg.PollInterval)
+
 	// Run one poll immediately on startup, then on each tick.
 	for {
 		r.poll(ctx, scrapeSem, audioSem, &wg)