chore: migrate to v3, Doppler secrets, clean up legacy code

- Remove all pre-v3 code: scraper, ui-v2, backend v1, ios v1+v2, legacy CI workflows
- Flatten v3/ contents to repo root
- Add Doppler secrets management (project=libnovel, config=prd)
- Add justfile with doppler run wrappers for all docker compose commands
- Strip hardcoded env fallbacks from docker-compose.yml
- Add minimal README.md
- Clean up .gitignore

backend/cmd/backend/main.go

@@ -2,7 +2,7 @@
 //
 // It exposes all endpoints consumed by the SvelteKit UI: book/chapter reads,
 // scrape-task creation, presigned MinIO URLs, audio-task creation, reading
-// progress, live novelfire.net browse/search, and Kokoro voice list.
+// progress, live novelfire.net search, and Kokoro voice list.
 //
 // All heavy lifting (scraping, TTS generation) is delegated to the runner
 // binary via PocketBase task records. The backend never scrapes directly.
@@ -19,10 +19,13 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
+	"time"
 
+	"github.com/getsentry/sentry-go"
 	"github.com/libnovel/backend/internal/backend"
 	"github.com/libnovel/backend/internal/config"
 	"github.com/libnovel/backend/internal/kokoro"
+	"github.com/libnovel/backend/internal/meili"
 	"github.com/libnovel/backend/internal/storage"
 )
 
@@ -42,6 +45,19 @@ func main() {
 func run() error {
 	cfg := config.Load()
 
+	// ── Sentry / GlitchTip error tracking ────────────────────────────────────
+	if dsn := os.Getenv("GLITCHTIP_DSN"); dsn != "" {
+		if err := sentry.Init(sentry.ClientOptions{
+			Dsn:              dsn,
+			Release:          version + "@" + commit,
+			TracesSampleRate: 0.1,
+		}); err != nil {
+			fmt.Fprintf(os.Stderr, "backend: sentry init warning: %v\n", err)
+		} else {
+			defer sentry.Flush(2 * time.Second)
+		}
+	}
+
 	// ── Logger ───────────────────────────────────────────────────────────────
 	log := buildLogger(cfg.LogLevel)
 	log.Info("backend starting",
@@ -70,6 +86,16 @@ func run() error {
 		kokoroClient = &noopKokoro{}
 	}
 
+	// ── Meilisearch (search reads only; indexing is the runner's job) ────────
+	var searchIndex meili.Client
+	if cfg.Meilisearch.URL != "" {
+		searchIndex = meili.New(cfg.Meilisearch.URL, cfg.Meilisearch.APIKey)
+		log.Info("meilisearch search enabled", "url", cfg.Meilisearch.URL)
+	} else {
+		log.Info("MEILI_URL not set — search will use PocketBase substring fallback")
+		searchIndex = meili.NoopClient{}
+	}
+
 	// ── Backend server ───────────────────────────────────────────────────────
 	srv := backend.New(
 		backend.Config{
@@ -84,9 +110,10 @@ func run() error {
 			AudioStore:    store,
 			PresignStore:  store,
 			ProgressStore: store,
-			BrowseStore:   store,
+			CoverStore:    store,
 			Producer:      store,
 			TaskReader:    store,
+			SearchIndex:   searchIndex,
 			Kokoro:        kokoroClient,
 			Log:           log,
 		},

backend/cmd/runner/main.go

@@ -19,9 +19,11 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/getsentry/sentry-go"
 	"github.com/libnovel/backend/internal/browser"
 	"github.com/libnovel/backend/internal/config"
 	"github.com/libnovel/backend/internal/kokoro"
+	"github.com/libnovel/backend/internal/meili"
 	"github.com/libnovel/backend/internal/novelfire"
 	"github.com/libnovel/backend/internal/runner"
 	"github.com/libnovel/backend/internal/storage"
@@ -43,6 +45,19 @@ func main() {
 func run() error {
 	cfg := config.Load()
 
+	// ── Sentry / GlitchTip error tracking ────────────────────────────────────
+	if dsn := os.Getenv("GLITCHTIP_DSN"); dsn != "" {
+		if err := sentry.Init(sentry.ClientOptions{
+			Dsn:              dsn,
+			Release:          version + "@" + commit,
+			TracesSampleRate: 0.1,
+		}); err != nil {
+			fmt.Fprintf(os.Stderr, "runner: sentry init warning: %v\n", err)
+		} else {
+			defer sentry.Flush(2 * time.Second)
+		}
+	}
+
 	// ── Logger ──────────────────────────────────────────────────────────────
 	log := buildLogger(cfg.LogLevel)
 	log.Info("runner starting",
@@ -74,7 +89,6 @@ func run() error {
 	browserClient := browser.NewDirectClient(browser.Config{
 		MaxConcurrent: workers,
 		Timeout:       timeout,
-		ProxyURL:      cfg.Runner.ProxyURL,
 	})
 	novel := novelfire.New(browserClient, log)
 
@@ -88,20 +102,39 @@ func run() error {
 		kokoroClient = &noopKokoro{}
 	}
 
+	// ── Meilisearch ─────────────────────────────────────────────────────────
+	var searchIndex meili.Client
+	if cfg.Meilisearch.URL != "" {
+		if err := meili.Configure(cfg.Meilisearch.URL, cfg.Meilisearch.APIKey); err != nil {
+			log.Warn("meilisearch configure failed — search indexing disabled", "err", err)
+			searchIndex = meili.NoopClient{}
+		} else {
+			searchIndex = meili.New(cfg.Meilisearch.URL, cfg.Meilisearch.APIKey)
+			log.Info("meilisearch enabled", "url", cfg.Meilisearch.URL)
+		}
+	} else {
+		log.Info("MEILI_URL not set — search indexing disabled")
+		searchIndex = meili.NoopClient{}
+	}
+
 	// ── Runner ──────────────────────────────────────────────────────────────
 	rCfg := runner.Config{
-		WorkerID:            cfg.Runner.WorkerID,
-		PollInterval:        cfg.Runner.PollInterval,
-		MaxConcurrentScrape: cfg.Runner.MaxConcurrentScrape,
-		MaxConcurrentAudio:  cfg.Runner.MaxConcurrentAudio,
-		OrchestratorWorkers: workers,
+		WorkerID:                    cfg.Runner.WorkerID,
+		PollInterval:                cfg.Runner.PollInterval,
+		MaxConcurrentScrape:         cfg.Runner.MaxConcurrentScrape,
+		MaxConcurrentAudio:          cfg.Runner.MaxConcurrentAudio,
+		OrchestratorWorkers:         workers,
+		MetricsAddr:                 cfg.Runner.MetricsAddr,
+		CatalogueRefreshInterval:    cfg.Runner.CatalogueRefreshInterval,
+		SkipInitialCatalogueRefresh: cfg.Runner.SkipInitialCatalogueRefresh,
 	}
 	deps := runner.Dependencies{
 		Consumer:    store,
 		BookWriter:  store,
 		BookReader:  store,
 		AudioStore:  store,
-		BrowseStore: store,
+		CoverStore:  store,
+		SearchIndex: searchIndex,
 		Novel:       novel,
 		Kokoro:      kokoroClient,
 		Log:         log,

backend/go.mod

@@ -8,19 +8,27 @@ require (
 )
 
 require (
+	github.com/andybalholm/brotli v1.1.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/getsentry/sentry-go v0.43.0 // indirect
 	github.com/go-ini/ini v1.67.0 // indirect
+	github.com/golang-jwt/jwt/v5 v5.3.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/klauspost/compress v1.18.2 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.11 // indirect
 	github.com/klauspost/crc32 v1.3.0 // indirect
+	github.com/meilisearch/meilisearch-go v0.36.1 // indirect
 	github.com/minio/crc64nvme v1.1.1 // indirect
 	github.com/minio/md5-simd v1.1.2 // indirect
 	github.com/philhofer/fwd v1.2.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/redis/go-redis/v9 v9.18.0 // indirect
 	github.com/rs/xid v1.6.0 // indirect
 	github.com/tinylib/msgp v1.6.1 // indirect
+	go.uber.org/atomic v1.11.0 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/crypto v0.48.0 // indirect
 	golang.org/x/sys v0.41.0 // indirect

backend/go.sum

@@ -1,9 +1,19 @@
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/getsentry/sentry-go v0.43.0 h1:XbXLpFicpo8HmBDaInk7dum18G9KSLcjZiyUKS+hLW4=
+github.com/getsentry/sentry-go v0.43.0/go.mod h1:XDotiNZbgf5U8bPDUAfvcFmOnMQQceESxyKaObSssW0=
 github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
 github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
+github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
+github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
@@ -13,6 +23,8 @@ github.com/klauspost/cpuid/v2 v2.2.11 h1:0OwqZRYI2rFrjS4kvkDnqJkKHdHaRnCm68/DY4O
 github.com/klauspost/cpuid/v2 v2.2.11/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/klauspost/crc32 v1.3.0 h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM=
 github.com/klauspost/crc32 v1.3.0/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw=
+github.com/meilisearch/meilisearch-go v0.36.1 h1:mJTCJE5g7tRvaqKco6DfqOuJEjX+rRltDEnkEC02Y0M=
+github.com/meilisearch/meilisearch-go v0.36.1/go.mod h1:hWcR0MuWLSzHfbz9GGzIr3s9rnXLm1jqkmHkJPbUSvM=
 github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI=
 github.com/minio/crc64nvme v1.1.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg=
 github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
@@ -23,12 +35,18 @@ github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM=
 github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/redis/go-redis/v9 v9.18.0 h1:pMkxYPkEbMPwRdenAzUNyFNrDgHx9U+DrBabWNfSRQs=
+github.com/redis/go-redis/v9 v9.18.0/go.mod h1:k3ufPphLU5YXwNTUcCRXGxUoF1fqxnhFQmscfkCoDA0=
 github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
 github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/tinylib/msgp v1.6.1 h1:ESRv8eL3u+DNHUoSAAQRE50Hm162zqAnBoGv9PzScPY=
 github.com/tinylib/msgp v1.6.1/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
@@ -41,5 +59,6 @@ golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
 golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

backend/internal/backend/handlers.go

@@ -7,8 +7,7 @@ package backend
 //   handleScrapeStatus, handleScrapeTasks
 //   handleBrowse, handleSearch
 //   handleGetRanking, handleGetCover
-//   handleBookPreview, handleChapterText, handleReindex
-//   handleChapterText, handleReindex
+//   handleBookPreview, handleChapterText, handleChapterTextPreview, handleChapterMarkdown, handleReindex
 //   handleAudioGenerate, handleAudioStatus, handleAudioProxy
 //   handleVoices
 //   handlePresignChapter, handlePresignAudio, handlePresignVoiceSample
@@ -29,6 +28,8 @@ package backend
 //     by the runner after each catalogue scrape).
 //   - GET /api/book-preview returns stored data when in library, or enqueues a
 //     scrape task and returns 202 when not. The backend never scrapes directly.
+//   - GET /api/chapter-text-preview scrapes a chapter live from novelfire.net
+//     directly (no runner task, no store writes). Used for unscraped books.
 
 import (
 	"context"
@@ -44,6 +45,9 @@ import (
 
 	"github.com/libnovel/backend/internal/domain"
 	"github.com/libnovel/backend/internal/kokoro"
+	"github.com/libnovel/backend/internal/meili"
+	"github.com/libnovel/backend/internal/novelfire/htmlutil"
+	"github.com/libnovel/backend/internal/scraper"
 )
 
 const (
@@ -172,82 +176,11 @@ type NovelListing struct {
 	URL      string `json:"url"`
 }
 
-// handleBrowse handles GET /api/browse.
-// Fetches novelfire.net live (no MinIO cache in the new backend).
-// Query params: page (default 1), genre (default "all"), sort (default "popular"),
-// status (default "all"), type (default "all-novel")
-func (s *Server) handleBrowse(w http.ResponseWriter, r *http.Request) {
-	q := r.URL.Query()
-	page := q.Get("page")
-	if page == "" {
-		page = "1"
-	}
-	genre := q.Get("genre")
-	if genre == "" {
-		genre = "all"
-	}
-	sortBy := q.Get("sort")
-	if sortBy == "" {
-		sortBy = "popular"
-	}
-	status := q.Get("status")
-	if status == "" {
-		status = "all"
-	}
-	novelType := q.Get("type")
-	if novelType == "" {
-		novelType = "all-novel"
-	}
-
-	pageNum, _ := strconv.Atoi(page)
-	if pageNum <= 0 {
-		pageNum = 1
-	}
-
-	// ── Try MinIO cache first ─────────────────────────────────────────────
-	// Only page 1 is cached; higher pages fall through to live fetch.
-	if pageNum == 1 && s.deps.BrowseStore != nil {
-		if data, ok, err := s.deps.BrowseStore.GetBrowsePage(r.Context(), genre, sortBy, status, novelType, 1); err == nil && ok {
-			w.Header().Set("Content-Type", "application/json")
-			w.Header().Set("Cache-Control", "public, max-age=300")
-			_, _ = w.Write(data)
-			return
-		}
-	}
-
-	// ── Fall back to live novelfire.net fetch ──────────────────────────────
-	ctx, cancel := context.WithTimeout(r.Context(), 45*time.Second)
-	defer cancel()
-
-	targetURL := fmt.Sprintf("%s/genre-%s/sort-%s/status-%s/%s?page=%d",
-		novelFireBase, genre, sortBy, status, novelType, pageNum)
-
-	novels, hasNext, err := s.fetchBrowsePage(ctx, targetURL)
-	if err != nil {
-		// Live fetch also failed — return empty list with cached=false flag so
-		// the UI can show a "not ready yet" state instead of a hard error.
-		s.deps.Log.Error("handleBrowse: fetch failed (no cache)", "url", targetURL, "err", err)
-		w.Header().Set("Cache-Control", "no-store")
-		writeJSON(w, 0, map[string]any{
-			"novels":  []any{},
-			"page":    pageNum,
-			"hasNext": false,
-			"cached":  false,
-		})
-		return
-	}
-
-	w.Header().Set("Cache-Control", "public, max-age=300")
-	writeJSON(w, 0, map[string]any{
-		"novels":  novels,
-		"page":    pageNum,
-		"hasNext": hasNext,
-		"cached":  false,
-	})
-}
-
 // handleSearch handles GET /api/search.
 // Query params: q (min 2 chars), source ("local"|"remote"|"all", default "all")
+//
+// Local search is powered by Meilisearch when configured; falls back to a
+// substring match against PocketBase book records otherwise.
 func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
 	q := r.URL.Query().Get("q")
 	if len([]rune(q)) < 2 {
@@ -265,22 +198,35 @@ func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
 
 	var localResults, remoteResults []NovelListing
 
-	// Local search (PocketBase books)
+	// Local search: Meilisearch → PocketBase substring fallback
 	if source == "local" || source == "all" {
-		books, err := s.deps.BookReader.ListBooks(ctx)
-		if err != nil {
-			s.deps.Log.Warn("search: ListBooks failed", "err", err)
+		meiliBooks, meiliErr := s.deps.SearchIndex.Search(ctx, q, 50)
+		if meiliErr == nil && len(meiliBooks) > 0 {
+			for _, b := range meiliBooks {
+				localResults = append(localResults, NovelListing{
+					Slug:  b.Slug,
+					Title: b.Title,
+					Cover: b.Cover,
+					URL:   b.SourceURL,
+				})
+			}
 		} else {
-			qLower := strings.ToLower(q)
-			for _, b := range books {
-				if strings.Contains(strings.ToLower(b.Title), qLower) ||
-					strings.Contains(strings.ToLower(b.Author), qLower) {
-					localResults = append(localResults, NovelListing{
-						Slug:  b.Slug,
-						Title: b.Title,
-						Cover: b.Cover,
-						URL:   b.SourceURL,
-					})
+			// Fallback: substring match against PocketBase
+			books, err := s.deps.BookReader.ListBooks(ctx)
+			if err != nil {
+				s.deps.Log.Warn("search: ListBooks failed", "err", err)
+			} else {
+				qLower := strings.ToLower(q)
+				for _, b := range books {
+					if strings.Contains(strings.ToLower(b.Title), qLower) ||
+						strings.Contains(strings.ToLower(b.Author), qLower) {
+						localResults = append(localResults, NovelListing{
+							Slug:  b.Slug,
+							Title: b.Title,
+							Cover: b.Cover,
+							URL:   b.SourceURL,
+						})
+					}
 				}
 			}
 		}
@@ -341,18 +287,34 @@ func (s *Server) handleGetRanking(w http.ResponseWriter, r *http.Request) {
 }
 
 // handleGetCover handles GET /api/cover/{domain}/{slug}.
-// The new backend does not cache covers in MinIO. Instead it redirects the
-// client to the novelfire.net source URL. The domain path segment is kept for
-// API compatibility with the old scraper.
+// Serves the cover image directly from MinIO when available; falls back to a
+// redirect to the novelfire CDN when the cover has not yet been downloaded.
 func (s *Server) handleGetCover(w http.ResponseWriter, r *http.Request) {
 	slug := r.PathValue("slug")
 	if slug == "" {
 		http.Error(w, "missing slug", http.StatusBadRequest)
 		return
 	}
-	// Redirect to the standard novelfire cover CDN URL. If the caller has the
-	// actual cover URL stored in metadata they should use it directly; this
-	// endpoint is a best-effort fallback.
+
+	// Fast path: serve from MinIO if the cover has been downloaded.
+	if s.deps.CoverStore != nil {
+		data, ct, ok, err := s.deps.CoverStore.GetCover(r.Context(), slug)
+		if err != nil {
+			s.deps.Log.Warn("handleGetCover: GetCover error", "slug", slug, "err", err)
+		}
+		if ok && len(data) > 0 {
+			if ct == "" {
+				ct = "image/jpeg"
+			}
+			w.Header().Set("Content-Type", ct)
+			w.Header().Set("Cache-Control", "public, max-age=86400")
+			_, _ = w.Write(data)
+			return
+		}
+	}
+
+	// Fallback: redirect to the CDN. The caller sees a working image; the
+	// cover will be populated on the next catalogue refresh run.
 	coverURL := fmt.Sprintf("https://cdn.novelfire.net/covers/%s.jpg", slug)
 	http.Redirect(w, r, coverURL, http.StatusFound)
 }
@@ -469,6 +431,117 @@ func (s *Server) handleChapterMarkdown(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprint(w, raw)
 }
 
+// handleChapterTextPreview handles GET /api/chapter-text-preview/{slug}/{n}.
+//
+// Fetches a chapter live from novelfire.net and returns its plain text without
+// writing anything to PocketBase or MinIO. This is the preview path used when
+// a chapter has not yet been scraped into the library.
+//
+// Optional query params:
+//
+//	chapter_url — the canonical chapter URL (preferred over constructing one)
+//	title       — hint for the chapter title (used when the page title is empty)
+//
+// Response: {"slug":string,"number":int,"title":string,"text":string,"url":string}
+func (s *Server) handleChapterTextPreview(w http.ResponseWriter, r *http.Request) {
+	slug := r.PathValue("slug")
+	n, err := strconv.Atoi(r.PathValue("n"))
+	if err != nil || n < 1 || slug == "" {
+		jsonError(w, http.StatusBadRequest, "invalid slug or chapter number")
+		return
+	}
+
+	// Determine the chapter URL to fetch.
+	chapterURL := r.URL.Query().Get("chapter_url")
+	if chapterURL == "" {
+		// Best-effort: novelfire chapter URLs follow /book/{slug}/chapter-{n}
+		chapterURL = fmt.Sprintf("%s/book/%s/chapter-%d", novelFireBase, slug, n)
+	}
+
+	titleHint := r.URL.Query().Get("title")
+
+	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
+	defer cancel()
+
+	// Fetch the chapter page.
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, chapterURL, nil)
+	if err != nil {
+		s.deps.Log.Error("chapter-text-preview: build request failed", "url", chapterURL, "err", err)
+		jsonError(w, http.StatusInternalServerError, "failed to build request")
+		return
+	}
+	req.Header.Set("User-Agent", "Mozilla/5.0 (compatible; libnovel-backend/2)")
+	req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		s.deps.Log.Warn("chapter-text-preview: fetch failed", "url", chapterURL, "err", err)
+		jsonError(w, http.StatusBadGateway, "failed to fetch chapter")
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusNotFound {
+		jsonError(w, http.StatusNotFound, "chapter not found")
+		return
+	}
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
+		s.deps.Log.Warn("chapter-text-preview: upstream error",
+			"url", chapterURL, "status", resp.StatusCode, "body_snippet", string(body))
+		jsonError(w, http.StatusBadGateway, fmt.Sprintf("upstream returned %d", resp.StatusCode))
+		return
+	}
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		s.deps.Log.Error("chapter-text-preview: read body failed", "err", err)
+		jsonError(w, http.StatusInternalServerError, "failed to read response")
+		return
+	}
+
+	// Parse HTML and extract the #content node.
+	root, err := htmlutil.ParseHTML(string(bodyBytes))
+	if err != nil {
+		s.deps.Log.Error("chapter-text-preview: html parse failed", "err", err)
+		jsonError(w, http.StatusInternalServerError, "failed to parse chapter HTML")
+		return
+	}
+
+	container := htmlutil.FindFirst(root, scraper.Selector{ID: "content"})
+	if container == nil {
+		s.deps.Log.Warn("chapter-text-preview: #content not found", "url", chapterURL)
+		jsonError(w, http.StatusNotFound, "chapter content not found on page")
+		return
+	}
+
+	markdownText := htmlutil.NodeToMarkdown(container)
+	plainText := stripMarkdown(markdownText)
+
+	// Extract the chapter title from the page <title> or <h1> if not hinted.
+	chapterTitle := titleHint
+	if chapterTitle == "" {
+		// Try <h1 class="chapter-title"> first, then <h2 class="chapter-title">
+		for _, tag := range []string{"h1", "h2", "h3"} {
+			if node := htmlutil.FindFirst(root, scraper.Selector{Tag: tag, Class: "chapter-title"}); node != nil {
+				chapterTitle = strings.TrimSpace(htmlutil.TextContent(node))
+				break
+			}
+		}
+	}
+	if chapterTitle == "" {
+		chapterTitle = fmt.Sprintf("Chapter %d", n)
+	}
+
+	writeJSON(w, 0, map[string]any{
+		"slug":   slug,
+		"number": n,
+		"title":  chapterTitle,
+		"text":   plainText,
+		"url":    chapterURL,
+	})
+}
+
 // handleReindex handles POST /api/reindex/{slug}.
 // Rebuilds the chapters_idx PocketBase collection for a book from MinIO objects.
 func (s *Server) handleReindex(w http.ResponseWriter, r *http.Request) {
@@ -685,7 +758,13 @@ func (s *Server) handlePresignAudio(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, 0, map[string]string{"url": u})
 }
 
+// voiceSampleText is the phrase synthesised for every voice sample.
+const voiceSampleText = "Hello! This is a preview of what I sound like. I hope you enjoy listening to your stories with my voice."
+
 // handlePresignVoiceSample handles GET /api/presign/voice-sample/{voice}.
+// If the sample has not been generated yet it synthesises it on the fly via
+// Kokoro, stores the result in MinIO, and returns the presigned URL — so the
+// caller always gets a playable URL in a single request.
 func (s *Server) handlePresignVoiceSample(w http.ResponseWriter, r *http.Request) {
 	voice := r.PathValue("voice")
 	if voice == "" {
@@ -694,9 +773,21 @@ func (s *Server) handlePresignVoiceSample(w http.ResponseWriter, r *http.Request
 	}
 
 	key := kokoro.VoiceSampleKey(voice)
+
+	// Generate sample on demand when it is not in MinIO yet.
 	if !s.deps.AudioStore.AudioExists(r.Context(), key) {
-		http.NotFound(w, r)
-		return
+		s.deps.Log.Info("generating voice sample on demand", "voice", voice)
+		mp3, err := s.deps.Kokoro.GenerateAudio(r.Context(), voiceSampleText, voice)
+		if err != nil {
+			s.deps.Log.Error("voice sample generation failed", "voice", voice, "err", err)
+			jsonError(w, http.StatusInternalServerError, "voice sample generation failed")
+			return
+		}
+		if err := s.deps.AudioStore.PutAudio(r.Context(), key, mp3); err != nil {
+			s.deps.Log.Error("voice sample upload failed", "voice", voice, "err", err)
+			jsonError(w, http.StatusInternalServerError, "voice sample upload failed")
+			return
+		}
 	}
 
 	u, err := s.deps.PresignStore.PresignAudio(r.Context(), key, 1*time.Hour)
@@ -708,6 +799,59 @@ func (s *Server) handlePresignVoiceSample(w http.ResponseWriter, r *http.Request
 	writeJSON(w, 0, map[string]string{"url": u})
 }
 
+// handleAvatarUpload handles PUT /api/avatar-upload/{userId}.
+// The request body must be the raw image bytes; Content-Type must be
+// image/jpeg, image/png, or image/webp.
+//
+// This endpoint is called by the SvelteKit server (not the browser directly),
+// so MinIO credentials and internal networking are not a concern.
+//
+// Returns: { "key": "<objectKey>" }
+func (s *Server) handleAvatarUpload(w http.ResponseWriter, r *http.Request) {
+	userID := r.PathValue("userId")
+	if userID == "" {
+		jsonError(w, http.StatusBadRequest, "missing userId")
+		return
+	}
+
+	ct := r.Header.Get("Content-Type")
+	var ext string
+	switch {
+	case strings.HasPrefix(ct, "image/jpeg"):
+		ext = "jpg"
+	case strings.HasPrefix(ct, "image/png"):
+		ext = "png"
+	case strings.HasPrefix(ct, "image/webp"):
+		ext = "webp"
+	default:
+		jsonError(w, http.StatusBadRequest, "unsupported content-type; use image/jpeg, image/png, or image/webp")
+		return
+	}
+
+	const maxSize = 5 << 20 // 5 MiB
+	data, err := io.ReadAll(io.LimitReader(r.Body, maxSize+1))
+	if err != nil {
+		jsonError(w, http.StatusBadRequest, "failed to read body")
+		return
+	}
+	if len(data) > maxSize {
+		jsonError(w, http.StatusRequestEntityTooLarge, "image too large (max 5 MiB)")
+		return
+	}
+	if len(data) == 0 {
+		jsonError(w, http.StatusBadRequest, "empty body")
+		return
+	}
+
+	key, err := s.deps.PresignStore.PutAvatar(r.Context(), userID, ext, ct, data)
+	if err != nil {
+		s.deps.Log.Error("avatar upload failed", "userId", userID, "err", err)
+		jsonError(w, http.StatusInternalServerError, "upload failed")
+		return
+	}
+	writeJSON(w, 0, map[string]string{"key": key})
+}
+
 // handlePresignAvatarUpload handles GET /api/presign/avatar-upload/{userId}.
 // Query params: ext (jpg|png|webp, defaults to jpg)
 func (s *Server) handlePresignAvatarUpload(w http.ResponseWriter, r *http.Request) {
@@ -826,6 +970,82 @@ func (s *Server) handleDeleteProgress(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, 0, map[string]string{})
 }
 
+// ── Catalogue (Meilisearch-backed browse + search) ────────────────────────────
+
+// handleCatalogue handles GET /api/catalogue.
+//
+// Provides unified browse + search over the locally-indexed book catalogue
+// via Meilisearch. Unlike /api/browse this never fetches novelfire.net live —
+// it is entirely served from the Meilisearch index populated by the runner.
+//
+// Query params:
+//
+//	q      — full-text search query (optional)
+//	genre  — genre filter, e.g. "fantasy" or "all" (default "all")
+//	status — status filter: "ongoing", "completed", or "all" (default "all")
+//	sort   — "popular" (default) | "new" | "top-rated" | "rank"
+//	page   — 1-indexed page number (default 1)
+//	limit  — items per page (default 20, max 100)
+func (s *Server) handleCatalogue(w http.ResponseWriter, r *http.Request) {
+	q := r.URL.Query()
+
+	genre := q.Get("genre")
+	if genre == "" {
+		genre = "all"
+	}
+	status := q.Get("status")
+	if status == "" {
+		status = "all"
+	}
+	sort := q.Get("sort")
+	if sort == "" {
+		sort = "popular"
+	}
+
+	page, _ := strconv.Atoi(q.Get("page"))
+	if page <= 0 {
+		page = 1
+	}
+	limit, _ := strconv.Atoi(q.Get("limit"))
+	if limit <= 0 {
+		limit = 20
+	}
+	if limit > 100 {
+		limit = 100
+	}
+
+	cq := meili.CatalogueQuery{
+		Q:      q.Get("q"),
+		Genre:  genre,
+		Status: status,
+		Sort:   sort,
+		Page:   page,
+		Limit:  limit,
+	}
+
+	books, total, facets, err := s.deps.SearchIndex.Catalogue(r.Context(), cq)
+	if err != nil {
+		s.deps.Log.Error("handleCatalogue: Catalogue query failed", "err", err)
+		jsonError(w, http.StatusInternalServerError, "search failed")
+		return
+	}
+
+	hasNext := int64(page*limit) < total
+
+	w.Header().Set("Cache-Control", "public, max-age=60")
+	writeJSON(w, 0, map[string]any{
+		"books":    books,
+		"page":     page,
+		"limit":    limit,
+		"total":    total,
+		"has_next": hasNext,
+		"facets": map[string]any{
+			"genres":   facets.Genres,
+			"statuses": facets.Statuses,
+		},
+	})
+}
+
 // ── Browse page parsing helpers ────────────────────────────────────────────────
 
 // fetchBrowsePage fetches pageURL and parses NovelListings from the HTML.

backend/internal/backend/server.go

@@ -6,7 +6,7 @@
 //     picks up and executes those tasks asynchronously
 //   - Presigned MinIO URLs for media playback/upload
 //   - Session-scoped reading progress
-//   - Live novelfire.net browse/search (no scraper interface needed; direct HTTP)
+//   - Live novelfire.net search (no scraper interface needed; direct HTTP)
 //   - Kokoro voice list
 //
 // The backend never scrapes directly. All scraping (metadata, chapter list,
@@ -28,8 +28,10 @@ import (
 	"sync"
 	"time"
 
+	sentryhttp "github.com/getsentry/sentry-go/http"
 	"github.com/libnovel/backend/internal/bookstore"
 	"github.com/libnovel/backend/internal/kokoro"
+	"github.com/libnovel/backend/internal/meili"
 	"github.com/libnovel/backend/internal/taskqueue"
 )
 
@@ -46,12 +48,16 @@ type Dependencies struct {
 	PresignStore bookstore.PresignStore
 	// ProgressStore reads/writes per-session reading progress.
 	ProgressStore bookstore.ProgressStore
-	// BrowseStore reads cached browse page snapshots from MinIO.
-	BrowseStore bookstore.BrowseStore
+	// CoverStore reads and writes book cover images from MinIO.
+	// If nil, the cover endpoint falls back to a CDN redirect.
+	CoverStore bookstore.CoverStore
 	// Producer creates scrape/audio tasks in PocketBase.
 	Producer taskqueue.Producer
 	// TaskReader reads scrape/audio task records from PocketBase.
 	TaskReader taskqueue.Reader
+	// SearchIndex provides full-text book search via Meilisearch.
+	// If nil, the local-only fallback search is used.
+	SearchIndex meili.Client
 	// Kokoro is the TTS client (used for voice list only in the backend;
 	// audio generation is done by the runner).
 	Kokoro kokoro.Client
@@ -88,6 +94,9 @@ func New(cfg Config, deps Dependencies) *Server {
 	if deps.Log == nil {
 		deps.Log = slog.Default()
 	}
+	if deps.SearchIndex == nil {
+		deps.SearchIndex = meili.NoopClient{}
+	}
 	return &Server{cfg: cfg, deps: deps}
 }
 
@@ -112,10 +121,12 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
 	// Cancel a pending task (scrape or audio)
 	mux.HandleFunc("POST /api/cancel-task/{id}", s.handleCancelTask)
 
-	// Browse & search (live novelfire.net)
-	mux.HandleFunc("GET /api/browse", s.handleBrowse)
+	// Browse & search
 	mux.HandleFunc("GET /api/search", s.handleSearch)
 
+	// Catalogue (Meilisearch-backed browse + search — preferred path for UI)
+	mux.HandleFunc("GET /api/catalogue", s.handleCatalogue)
+
 	// Ranking (from PocketBase)
 	mux.HandleFunc("GET /api/ranking", s.handleGetRanking)
 
@@ -131,6 +142,10 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
 	// Use this instead of presign+fetch to avoid SvelteKit→MinIO network path.
 	mux.HandleFunc("GET /api/chapter-markdown/{slug}/{n}", s.handleChapterMarkdown)
 
+	// Chapter text preview — live scrape from novelfire.net, no store writes.
+	// Used when the chapter is not yet in the library (preview mode).
+	mux.HandleFunc("GET /api/chapter-text-preview/{slug}/{n}", s.handleChapterTextPreview)
+
 	// Reindex chapters_idx from MinIO
 	mux.HandleFunc("POST /api/reindex/{slug}", s.handleReindex)
 
@@ -148,6 +163,7 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
 	mux.HandleFunc("GET /api/presign/voice-sample/{voice}", s.handlePresignVoiceSample)
 	mux.HandleFunc("GET /api/presign/avatar-upload/{userId}", s.handlePresignAvatarUpload)
 	mux.HandleFunc("GET /api/presign/avatar/{userId}", s.handlePresignAvatar)
+	mux.HandleFunc("PUT /api/avatar-upload/{userId}", s.handleAvatarUpload)
 
 	// Reading progress
 	mux.HandleFunc("GET /api/progress", s.handleGetProgress)
@@ -156,7 +172,7 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
 
 	srv := &http.Server{
 		Addr:         s.cfg.Addr,
-		Handler:      mux,
+		Handler:      sentryhttp.New(sentryhttp.Options{Repanic: true}).Handle(mux),
 		ReadTimeout:  15 * time.Second,
 		WriteTimeout: 60 * time.Second,
 		IdleTimeout:  60 * time.Second,

backend/internal/bookstore/bookstore.go

@@ -105,6 +105,10 @@ type PresignStore interface {
 	// Returns ("", false, nil) when no avatar exists.
 	PresignAvatarURL(ctx context.Context, userID string) (string, bool, error)
 
+	// PutAvatar stores raw image bytes for a user avatar directly in MinIO.
+	// ext should be "jpg", "png", or "webp". Returns the object key.
+	PutAvatar(ctx context.Context, userID, ext, contentType string, data []byte) (key string, err error)
+
 	// DeleteAvatar removes all avatar objects for a user.
 	DeleteAvatar(ctx context.Context, userID string) error
 }
@@ -124,14 +128,16 @@ type ProgressStore interface {
 	DeleteProgress(ctx context.Context, sessionID, slug string) error
 }
 
-// BrowseStore covers browse page snapshot storage.
-// The runner writes snapshots; the backend reads them.
-type BrowseStore interface {
-	// PutBrowsePage stores a raw JSON snapshot for a browse page.
-	// genre, sort, status, novelType and page identify the page.
-	PutBrowsePage(ctx context.Context, genre, sort, status, novelType string, page int, data []byte) error
+// CoverStore covers book cover image storage in MinIO.
+// The runner writes covers during catalogue refresh; the backend reads them.
+type CoverStore interface {
+	// PutCover stores a raw cover image for a book identified by slug.
+	PutCover(ctx context.Context, slug string, data []byte, contentType string) error
 
-	// GetBrowsePage retrieves a raw JSON snapshot. Returns (nil, false, nil)
-	// when no snapshot exists for the given parameters.
-	GetBrowsePage(ctx context.Context, genre, sort, status, novelType string, page int) ([]byte, bool, error)
+	// GetCover retrieves the cover image for a book. Returns (nil, false, nil)
+	// when no cover exists for the given slug.
+	GetCover(ctx context.Context, slug string) ([]byte, string, bool, error)
+
+	// CoverExists returns true when a cover image is stored for slug.
+	CoverExists(ctx context.Context, slug string) bool
 }

backend/internal/bookstore/bookstore_test.go

@@ -68,6 +68,9 @@ func (m *mockStore) PresignAvatarUpload(_ context.Context, _, _ string) (string,
 func (m *mockStore) PresignAvatarURL(_ context.Context, _ string) (string, bool, error) {
 	return "", false, nil
 }
+func (m *mockStore) PutAvatar(_ context.Context, _, _, _ string, _ []byte) (string, error) {
+	return "", nil
+}
 func (m *mockStore) DeleteAvatar(_ context.Context, _ string) error { return nil }
 
 // ProgressStore

backend/internal/browser/browser.go

@@ -1,7 +1,4 @@
 // Package browser provides a rate-limited HTTP client for web scraping.
-// The Client interface is the only thing the rest of the codebase depends on;
-// the concrete DirectClient can be swapped for any other implementation
-// (e.g. a Browserless-backed client) without touching callers.
 package browser
 
 import (
@@ -10,7 +7,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"strconv"
 	"sync"
 	"time"
@@ -51,9 +47,6 @@ type Config struct {
 	MaxConcurrent int
 	// Timeout is the per-request deadline. Defaults to 90s when 0.
 	Timeout time.Duration
-	// ProxyURL is an optional outbound proxy, e.g. "http://user:pass@host:3128".
-	// Falls back to HTTP_PROXY / HTTPS_PROXY environment variables when empty.
-	ProxyURL string
 }
 
 // DirectClient is a plain net/http-based Client with a concurrency semaphore.
@@ -75,14 +68,6 @@ func NewDirectClient(cfg Config) *DirectClient {
 		MaxIdleConnsPerHost: cfg.MaxConcurrent * 2,
 		DisableCompression:  false,
 	}
-	if cfg.ProxyURL != "" {
-		proxyParsed, err := url.Parse(cfg.ProxyURL)
-		if err == nil {
-			transport.Proxy = http.ProxyURL(proxyParsed)
-		}
-	} else {
-		transport.Proxy = http.ProxyFromEnvironment
-	}
 
 	return &DirectClient{
 		http: &http.Client{

backend/internal/config/config.go

@@ -63,6 +63,22 @@ type HTTP struct {
 	Addr string
 }
 
+// Meilisearch holds connection settings for the Meilisearch full-text search service.
+type Meilisearch struct {
+	// URL is the base URL of the Meilisearch instance, e.g. http://localhost:7700
+	// An empty string disables Meilisearch indexing and search.
+	URL string
+	// APIKey is the Meilisearch master/search API key.
+	APIKey string
+}
+
+// Valkey holds connection settings for the Valkey/Redis presign URL cache.
+type Valkey struct {
+	// Addr is the host:port of the Valkey instance, e.g. localhost:6379
+	// An empty string disables the Valkey cache (falls through to MinIO directly).
+	Addr string
+}
+
 // Runner holds settings specific to the runner/worker binary.
 type Runner struct {
 	// PollInterval is how often the runner checks PocketBase for pending tasks.
@@ -78,17 +94,29 @@ type Runner struct {
 	Workers int
 	// Timeout is the per-request HTTP timeout for scraping.
 	Timeout time.Duration
-	// ProxyURL is an optional outbound proxy for scraper HTTP requests.
-	ProxyURL string
+	// MetricsAddr is the listen address for the runner /metrics HTTP endpoint.
+	// Defaults to ":9091". Set to "" to disable.
+	MetricsAddr string
+	// CatalogueRefreshInterval is how often the runner walks the full catalogue,
+	// scrapes per-book metadata, downloads covers, and re-indexes in Meilisearch.
+	// Defaults to 24h. Set to 0 to use the default.
+	CatalogueRefreshInterval time.Duration
+	// SkipInitialCatalogueRefresh prevents the runner from running a full
+	// catalogue walk on startup. Useful for quick restarts where the catalogue
+	// is already indexed and a 24h walk would be wasteful.
+	// Controlled by RUNNER_SKIP_INITIAL_CATALOGUE_REFRESH=true.
+	SkipInitialCatalogueRefresh bool
 }
 
 // Config is the top-level configuration struct consumed by both binaries.
 type Config struct {
-	PocketBase PocketBase
-	MinIO      MinIO
-	Kokoro     Kokoro
-	HTTP       HTTP
-	Runner     Runner
+	PocketBase  PocketBase
+	MinIO       MinIO
+	Kokoro      Kokoro
+	HTTP        HTTP
+	Runner      Runner
+	Meilisearch Meilisearch
+	Valkey      Valkey
 	// LogLevel is one of "debug", "info", "warn", "error".
 	LogLevel string
 }
@@ -117,10 +145,10 @@ func Load() Config {
 			SecretKey:      envOr("MINIO_SECRET_KEY", "changeme123"),
 			UseSSL:         envBool("MINIO_USE_SSL", false),
 			PublicUseSSL:   envBool("MINIO_PUBLIC_USE_SSL", true),
-			BucketChapters: envOr("MINIO_BUCKET_CHAPTERS", "libnovel-chapters"),
-			BucketAudio:    envOr("MINIO_BUCKET_AUDIO", "libnovel-audio"),
-			BucketAvatars:  envOr("MINIO_BUCKET_AVATARS", "libnovel-avatars"),
-			BucketBrowse:   envOr("MINIO_BUCKET_BROWSE", "libnovel-browse"),
+			BucketChapters: envOr("MINIO_BUCKET_CHAPTERS", "chapters"),
+			BucketAudio:    envOr("MINIO_BUCKET_AUDIO", "audio"),
+			BucketAvatars:  envOr("MINIO_BUCKET_AVATARS", "avatars"),
+			BucketBrowse:   envOr("MINIO_BUCKET_BROWSE", "catalogue"),
 		},
 
 		Kokoro: Kokoro{
@@ -133,13 +161,24 @@ func Load() Config {
 		},
 
 		Runner: Runner{
-			PollInterval:        envDuration("RUNNER_POLL_INTERVAL", 30*time.Second),
-			MaxConcurrentScrape: envInt("RUNNER_MAX_CONCURRENT_SCRAPE", 1),
-			MaxConcurrentAudio:  envInt("RUNNER_MAX_CONCURRENT_AUDIO", 1),
-			WorkerID:            envOr("RUNNER_WORKER_ID", workerID),
-			Workers:             envInt("RUNNER_WORKERS", 0), // 0 → runtime.NumCPU()
-			Timeout:             envDuration("RUNNER_TIMEOUT", 90*time.Second),
-			ProxyURL:            envOr("SCRAPER_PROXY", ""),
+			PollInterval:                envDuration("RUNNER_POLL_INTERVAL", 30*time.Second),
+			MaxConcurrentScrape:         envInt("RUNNER_MAX_CONCURRENT_SCRAPE", 1),
+			MaxConcurrentAudio:          envInt("RUNNER_MAX_CONCURRENT_AUDIO", 1),
+			WorkerID:                    envOr("RUNNER_WORKER_ID", workerID),
+			Workers:                     envInt("RUNNER_WORKERS", 0), // 0 → runtime.NumCPU()
+			Timeout:                     envDuration("RUNNER_TIMEOUT", 90*time.Second),
+			MetricsAddr:                 envOr("RUNNER_METRICS_ADDR", ":9091"),
+			CatalogueRefreshInterval:    envDuration("RUNNER_CATALOGUE_REFRESH_INTERVAL", 0),
+			SkipInitialCatalogueRefresh: envBool("RUNNER_SKIP_INITIAL_CATALOGUE_REFRESH", false),
+		},
+
+		Meilisearch: Meilisearch{
+			URL:    envOr("MEILI_URL", ""),
+			APIKey: envOr("MEILI_API_KEY", ""),
+		},
+
+		Valkey: Valkey{
+			Addr: envOr("VALKEY_ADDR", ""),
 		},
 	}
 }

backend/internal/config/config_test.go

@@ -19,7 +19,7 @@ func TestLoad_Defaults(t *testing.T) {
 		"KOKORO_URL", "KOKORO_VOICE",
 		"BACKEND_HTTP_ADDR",
 		"RUNNER_POLL_INTERVAL", "RUNNER_MAX_CONCURRENT_SCRAPE", "RUNNER_MAX_CONCURRENT_AUDIO",
-		"RUNNER_WORKER_ID", "RUNNER_WORKERS", "RUNNER_TIMEOUT", "SCRAPER_PROXY",
+		"RUNNER_WORKER_ID", "RUNNER_WORKERS", "RUNNER_TIMEOUT",
 	}
 	for _, k := range unset {
 		t.Setenv(k, "")
@@ -33,8 +33,8 @@ func TestLoad_Defaults(t *testing.T) {
 	if cfg.PocketBase.URL != "http://localhost:8090" {
 		t.Errorf("PocketBase.URL: want http://localhost:8090, got %q", cfg.PocketBase.URL)
 	}
-	if cfg.MinIO.BucketChapters != "libnovel-chapters" {
-		t.Errorf("MinIO.BucketChapters: want libnovel-chapters, got %q", cfg.MinIO.BucketChapters)
+	if cfg.MinIO.BucketChapters != "chapters" {
+		t.Errorf("MinIO.BucketChapters: want chapters, got %q", cfg.MinIO.BucketChapters)
 	}
 	if cfg.MinIO.UseSSL != false {
 		t.Errorf("MinIO.UseSSL: want false, got %v", cfg.MinIO.UseSSL)

backend/internal/domain/domain.go

@@ -19,10 +19,16 @@ type BookMeta struct {
 	TotalChapters int      `json:"total_chapters,omitempty"`
 	SourceURL     string   `json:"source_url"`
 	Ranking       int      `json:"ranking,omitempty"`
+	Rating        float64  `json:"rating,omitempty"`
+	// MetaUpdated is the Unix timestamp (seconds) when the book record was last
+	// updated in PocketBase. Populated on read; not sent on write (PocketBase
+	// manages its own updated field).
+	MetaUpdated int64 `json:"meta_updated,omitempty"`
 }
 
 // CatalogueEntry is a lightweight book reference returned by catalogue pages.
 type CatalogueEntry struct {
+	Slug  string `json:"slug"`
 	Title string `json:"title"`
 	URL   string `json:"url"`
 }

backend/internal/meili/client.go

@@ -0,0 +1,327 @@
+// Package meili provides a thin Meilisearch client for indexing and searching
+// locally scraped books.
+//
+// Index:
+//   - Name: "books"
+//   - Primary key: "slug"
+//   - Searchable attributes: title, author, genres, summary
+//   - Filterable attributes: status, genres
+//   - Sortable attributes: rank, rating, total_chapters, meta_updated
+//
+// The client is intentionally simple: UpsertBook and Search only. All
+// Meilisearch-specific details (index management, attribute configuration)
+// are handled once in Configure(), called at startup.
+package meili
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/libnovel/backend/internal/domain"
+	"github.com/meilisearch/meilisearch-go"
+)
+
+const indexName = "books"
+
+// Client is the interface for Meilisearch operations used by runner and backend.
+type Client interface {
+	// UpsertBook adds or updates a book document in the search index.
+	UpsertBook(ctx context.Context, book domain.BookMeta) error
+	// BookExists reports whether a book with the given slug is already in the
+	// index. Used by the catalogue refresh to skip re-indexing known books.
+	BookExists(ctx context.Context, slug string) bool
+	// Search returns up to limit books matching query.
+	Search(ctx context.Context, query string, limit int) ([]domain.BookMeta, error)
+	// Catalogue queries books with optional filters, sort, and pagination.
+	// Returns books, the total hit count for pagination, and a FacetResult
+	// with available genre and status values from the index.
+	Catalogue(ctx context.Context, q CatalogueQuery) ([]domain.BookMeta, int64, FacetResult, error)
+}
+
+// CatalogueQuery holds parameters for the /api/catalogue endpoint.
+type CatalogueQuery struct {
+	Q      string // full-text query (may be empty for browse)
+	Genre  string // genre filter, e.g. "fantasy" or "all"
+	Status string // status filter, e.g. "ongoing", "completed", or "all"
+	Sort   string // sort field: "popular", "new", "update", "top-rated", "rank", ""
+	Page   int    // 1-indexed
+	Limit  int    // items per page, default 20
+}
+
+// FacetResult holds the available filter values discovered from the index.
+// Values are sorted alphabetically and include only those present in the index.
+type FacetResult struct {
+	Genres   []string // distinct genre values
+	Statuses []string // distinct status values
+}
+
+// MeiliClient wraps the meilisearch-go SDK.
+type MeiliClient struct {
+	idx meilisearch.IndexManager
+}
+
+// New creates a MeiliClient. Call Configure() once at startup to ensure the
+// index exists and has the correct attribute settings.
+func New(host, apiKey string) *MeiliClient {
+	cli := meilisearch.New(host, meilisearch.WithAPIKey(apiKey))
+	return &MeiliClient{idx: cli.Index(indexName)}
+}
+
+// Configure creates the index if absent and sets searchable/filterable
+// attributes. It is idempotent — safe to call on every startup.
+func Configure(host, apiKey string) error {
+	cli := meilisearch.New(host, meilisearch.WithAPIKey(apiKey))
+
+	// Create index with primary key. Returns 202 if exists — ignore.
+	task, err := cli.CreateIndex(&meilisearch.IndexConfig{
+		Uid:        indexName,
+		PrimaryKey: "slug",
+	})
+	if err != nil {
+		// 400 "index_already_exists" is not an error here; the SDK returns
+		// an error with Code "index_already_exists" which we can ignore.
+		// Any other error is fatal.
+		if apiErr, ok := err.(*meilisearch.Error); ok && apiErr.MeilisearchApiError.Code == "index_already_exists" {
+			// already exists — continue
+		} else {
+			return fmt.Errorf("meili: create index: %w", err)
+		}
+	} else {
+		_ = task // task is async; we don't wait for it
+	}
+
+	idx := cli.Index(indexName)
+
+	searchable := []string{"title", "author", "genres", "summary"}
+	if _, err := idx.UpdateSearchableAttributes(&searchable); err != nil {
+		return fmt.Errorf("meili: update searchable attributes: %w", err)
+	}
+
+	filterable := []interface{}{"status", "genres"}
+	if _, err := idx.UpdateFilterableAttributes(&filterable); err != nil {
+		return fmt.Errorf("meili: update filterable attributes: %w", err)
+	}
+
+	sortable := []string{"rank", "rating", "total_chapters", "meta_updated"}
+	if _, err := idx.UpdateSortableAttributes(&sortable); err != nil {
+		return fmt.Errorf("meili: update sortable attributes: %w", err)
+	}
+
+	return nil
+}
+
+// bookDoc is the Meilisearch document shape for a book.
+type bookDoc struct {
+	Slug          string   `json:"slug"`
+	Title         string   `json:"title"`
+	Author        string   `json:"author"`
+	Cover         string   `json:"cover"`
+	Status        string   `json:"status"`
+	Genres        []string `json:"genres"`
+	Summary       string   `json:"summary"`
+	TotalChapters int      `json:"total_chapters"`
+	SourceURL     string   `json:"source_url"`
+	Rank          int      `json:"rank"`
+	Rating        float64  `json:"rating"`
+	// MetaUpdated is the Unix timestamp (seconds) of the last PocketBase update.
+	// Used for sort=update ("recently updated" ordering).
+	MetaUpdated int64 `json:"meta_updated"`
+}
+
+func toDoc(b domain.BookMeta) bookDoc {
+	return bookDoc{
+		Slug:          b.Slug,
+		Title:         b.Title,
+		Author:        b.Author,
+		Cover:         b.Cover,
+		Status:        b.Status,
+		Genres:        b.Genres,
+		Summary:       b.Summary,
+		TotalChapters: b.TotalChapters,
+		SourceURL:     b.SourceURL,
+		Rank:          b.Ranking,
+		Rating:        b.Rating,
+		MetaUpdated:   b.MetaUpdated,
+	}
+}
+
+func fromDoc(d bookDoc) domain.BookMeta {
+	return domain.BookMeta{
+		Slug:          d.Slug,
+		Title:         d.Title,
+		Author:        d.Author,
+		Cover:         d.Cover,
+		Status:        d.Status,
+		Genres:        d.Genres,
+		Summary:       d.Summary,
+		TotalChapters: d.TotalChapters,
+		SourceURL:     d.SourceURL,
+		Ranking:       d.Rank,
+		Rating:        d.Rating,
+		MetaUpdated:   d.MetaUpdated,
+	}
+}
+
+// UpsertBook adds or replaces the book document in Meilisearch. The operation
+// is fire-and-forget (Meilisearch processes tasks asynchronously).
+func (c *MeiliClient) UpsertBook(_ context.Context, book domain.BookMeta) error {
+	docs := []bookDoc{toDoc(book)}
+	pk := "slug"
+	if _, err := c.idx.AddDocuments(docs, &meilisearch.DocumentOptions{PrimaryKey: &pk}); err != nil {
+		return fmt.Errorf("meili: upsert book %q: %w", book.Slug, err)
+	}
+	return nil
+}
+
+// BookExists reports whether the slug is already present in the index.
+// It fetches the document by primary key; a 404 or any error is treated as
+// "not present" (safe default: re-index rather than silently skip).
+func (c *MeiliClient) BookExists(_ context.Context, slug string) bool {
+	var doc bookDoc
+	err := c.idx.GetDocument(slug, nil, &doc)
+	return err == nil && doc.Slug != ""
+}
+
+// Search returns books matching query, up to limit results.
+func (c *MeiliClient) Search(_ context.Context, query string, limit int) ([]domain.BookMeta, error) {
+	if limit <= 0 {
+		limit = 20
+	}
+	res, err := c.idx.Search(query, &meilisearch.SearchRequest{
+		Limit: int64(limit),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("meili: search %q: %w", query, err)
+	}
+
+	books := make([]domain.BookMeta, 0, len(res.Hits))
+	for _, hit := range res.Hits {
+		// Hit is map[string]json.RawMessage — unmarshal directly into bookDoc.
+		var doc bookDoc
+		raw, err := json.Marshal(hit)
+		if err != nil {
+			continue
+		}
+		if err := json.Unmarshal(raw, &doc); err != nil {
+			continue
+		}
+		books = append(books, fromDoc(doc))
+	}
+	return books, nil
+}
+
+// Catalogue queries books with optional full-text search, genre/status filters,
+// sort order, and pagination. Returns matching books, the total estimate, and
+// a FacetResult containing available genre and status values from the index.
+func (c *MeiliClient) Catalogue(_ context.Context, q CatalogueQuery) ([]domain.BookMeta, int64, FacetResult, error) {
+	if q.Limit <= 0 {
+		q.Limit = 20
+	}
+	if q.Page <= 0 {
+		q.Page = 1
+	}
+
+	req := &meilisearch.SearchRequest{
+		Limit:  int64(q.Limit),
+		Offset: int64((q.Page - 1) * q.Limit),
+		// Request facet distribution so the UI can build filter options
+		// dynamically without hardcoding genre/status lists.
+		Facets: []string{"genres", "status"},
+	}
+
+	// Build filter
+	var filters []string
+	if q.Genre != "" && q.Genre != "all" {
+		filters = append(filters, fmt.Sprintf("genres = %q", q.Genre))
+	}
+	if q.Status != "" && q.Status != "all" {
+		filters = append(filters, fmt.Sprintf("status = %q", q.Status))
+	}
+	if len(filters) > 0 {
+		req.Filter = strings.Join(filters, " AND ")
+	}
+
+	// Map UI sort tokens to Meilisearch sort expressions.
+	switch q.Sort {
+	case "rank":
+		req.Sort = []string{"rank:asc"}
+	case "top-rated":
+		req.Sort = []string{"rating:desc"}
+	case "new":
+		req.Sort = []string{"total_chapters:desc"}
+	case "update":
+		req.Sort = []string{"meta_updated:desc"}
+		// "popular" and "" → relevance (no explicit sort)
+	}
+
+	res, err := c.idx.Search(q.Q, req)
+	if err != nil {
+		return nil, 0, FacetResult{}, fmt.Errorf("meili: catalogue query: %w", err)
+	}
+
+	books := make([]domain.BookMeta, 0, len(res.Hits))
+	for _, hit := range res.Hits {
+		var doc bookDoc
+		raw, err := json.Marshal(hit)
+		if err != nil {
+			continue
+		}
+		if err := json.Unmarshal(raw, &doc); err != nil {
+			continue
+		}
+		books = append(books, fromDoc(doc))
+	}
+
+	facets := parseFacets(res.FacetDistribution)
+	return books, res.EstimatedTotalHits, facets, nil
+}
+
+// parseFacets extracts sorted genre and status slices from a Meilisearch
+// facetDistribution raw JSON value.
+// The JSON shape is: {"genres":{"fantasy":12,"action":5},"status":{"ongoing":7}}
+func parseFacets(raw json.RawMessage) FacetResult {
+	var result FacetResult
+	if len(raw) == 0 {
+		return result
+	}
+	var dist map[string]map[string]int64
+	if err := json.Unmarshal(raw, &dist); err != nil {
+		return result
+	}
+	if m, ok := dist["genres"]; ok {
+		for k := range m {
+			result.Genres = append(result.Genres, k)
+		}
+		sortStrings(result.Genres)
+	}
+	if m, ok := dist["status"]; ok {
+		for k := range m {
+			result.Statuses = append(result.Statuses, k)
+		}
+		sortStrings(result.Statuses)
+	}
+	return result
+}
+
+// sortStrings sorts a slice of strings in place.
+func sortStrings(s []string) {
+	for i := 1; i < len(s); i++ {
+		for j := i; j > 0 && s[j] < s[j-1]; j-- {
+			s[j], s[j-1] = s[j-1], s[j]
+		}
+	}
+}
+
+// NoopClient is a no-op Client used when Meilisearch is not configured.
+type NoopClient struct{}
+
+func (NoopClient) UpsertBook(_ context.Context, _ domain.BookMeta) error { return nil }
+func (NoopClient) BookExists(_ context.Context, _ string) bool           { return false }
+func (NoopClient) Search(_ context.Context, _ string, _ int) ([]domain.BookMeta, error) {
+	return nil, nil
+}
+func (NoopClient) Catalogue(_ context.Context, _ CatalogueQuery) ([]domain.BookMeta, int64, FacetResult, error) {
+	return nil, 0, FacetResult{}, nil
+}

backend/internal/novelfire/scraper.go

@@ -111,7 +111,7 @@ func (s *Scraper) ScrapeCatalogue(ctx context.Context) (<-chan domain.CatalogueE
 				select {
 				case <-ctx.Done():
 					return
-				case entries <- domain.CatalogueEntry{Title: title, URL: bookURL}:
+				case entries <- domain.CatalogueEntry{Slug: slugFromURL(bookURL), Title: title, URL: bookURL}:
 				}
 			}
 
@@ -194,8 +194,12 @@ func (s *Scraper) ScrapeMetadata(ctx context.Context, bookURL string) (domain.Bo
 
 // ── ChapterListProvider ───────────────────────────────────────────────────────
 
-// ScrapeChapterList returns all chapter references for a book, ordered ascending.
-func (s *Scraper) ScrapeChapterList(ctx context.Context, bookURL string) ([]domain.ChapterRef, error) {
+// ScrapeChapterList returns chapter references for a book, ordered ascending.
+// upTo > 0 stops pagination as soon as at least upTo chapter numbers have been
+// collected — use this for range scrapes so we don't paginate 100 pages just
+// to discover refs we'll never scrape. upTo == 0 fetches all pages.
+// Each page fetch uses retryGet with 429-aware exponential backoff.
+func (s *Scraper) ScrapeChapterList(ctx context.Context, bookURL string, upTo int) ([]domain.ChapterRef, error) {
 	var refs []domain.ChapterRef
 	baseChapterURL := strings.TrimRight(bookURL, "/") + "/chapters"
 	page := 1
@@ -210,7 +214,7 @@ func (s *Scraper) ScrapeChapterList(ctx context.Context, bookURL string) ([]doma
 		pageURL := fmt.Sprintf("%s?page=%d", baseChapterURL, page)
 		s.log.Info("scraping chapter list", "page", page, "url", pageURL)
 
-		raw, err := s.client.GetContent(ctx, pageURL)
+		raw, err := retryGet(ctx, s.log, s.client, pageURL, 9, 6*time.Second)
 		if err != nil {
 			return refs, fmt.Errorf("chapter list page %d: %w", page, err)
 		}
@@ -255,6 +259,13 @@ func (s *Scraper) ScrapeChapterList(ctx context.Context, bookURL string) ([]doma
 			})
 		}
 
+		// Early-stop: if we have seen at least upTo chapter numbers, we have
+		// enough refs to cover the requested range — no need to paginate further.
+		if upTo > 0 && len(refs) > 0 && refs[len(refs)-1].Number >= upTo {
+			s.log.Debug("chapter list early-stop reached", "upTo", upTo, "collected", len(refs))
+			break
+		}
+
 		page++
 	}
 

backend/internal/orchestrator/orchestrator.go

@@ -5,6 +5,8 @@
 //   - RunBook scrapes one book (metadata + chapter list + chapter texts) end-to-end.
 //   - N worker goroutines pull chapter refs from a shared queue and call ScrapeChapterText.
 //   - The caller (runner poll loop) owns the outer task-claim / finish cycle.
+//   - An optional PostMetadata hook (set in Config) is called after WriteMetadata
+//     succeeds. The runner uses this to upsert books into Meilisearch.
 package orchestrator
 
 import (
@@ -25,14 +27,19 @@ type Config struct {
 	// Workers is the number of goroutines used to scrape chapters in parallel.
 	// Defaults to runtime.NumCPU() when 0.
 	Workers int
+	// PostMetadata is an optional hook called with the scraped BookMeta after
+	// WriteMetadata succeeds. Errors from the hook are logged but not fatal.
+	// Used by the runner to index books in Meilisearch.
+	PostMetadata func(ctx context.Context, meta domain.BookMeta)
 }
 
 // Orchestrator runs a single-book scrape pipeline.
 type Orchestrator struct {
-	novel   scraper.NovelScraper
-	store   bookstore.BookWriter
-	log     *slog.Logger
-	workers int
+	novel        scraper.NovelScraper
+	store        bookstore.BookWriter
+	log          *slog.Logger
+	workers      int
+	postMetadata func(ctx context.Context, meta domain.BookMeta)
 }
 
 // New returns a new Orchestrator.
@@ -44,7 +51,13 @@ func New(cfg Config, novel scraper.NovelScraper, store bookstore.BookWriter, log
 	if workers <= 0 {
 		workers = runtime.NumCPU()
 	}
-	return &Orchestrator{novel: novel, store: store, log: log, workers: workers}
+	return &Orchestrator{
+		novel:        novel,
+		store:        store,
+		log:          log,
+		workers:      workers,
+		postMetadata: cfg.PostMetadata,
+	}
 }
 
 // RunBook scrapes a single book described by task. It handles:
@@ -84,12 +97,16 @@ func (o *Orchestrator) RunBook(ctx context.Context, task domain.ScrapeTask) doma
 		result.Errors++
 	} else {
 		result.BooksFound = 1
+		// Fire optional post-metadata hook (e.g. Meilisearch indexing).
+		if o.postMetadata != nil {
+			o.postMetadata(ctx, meta)
+		}
 	}
 
 	o.log.Info("metadata saved", "slug", meta.Slug, "title", meta.Title)
 
 	// ── Step 2: Chapter list ──────────────────────────────────────────────────
-	refs, err := o.novel.ScrapeChapterList(ctx, task.TargetURL)
+	refs, err := o.novel.ScrapeChapterList(ctx, task.TargetURL, task.ToChapter)
 	if err != nil {
 		o.log.Error("chapter list scrape failed", "slug", meta.Slug, "err", err)
 		result.ErrorMessage = fmt.Sprintf("chapter list: %v", err)

backend/internal/orchestrator/orchestrator_test.go

@@ -34,7 +34,7 @@ func (s *stubScraper) ScrapeMetadata(_ context.Context, _ string) (domain.BookMe
 	return s.meta, s.metaErr
 }
 
-func (s *stubScraper) ScrapeChapterList(_ context.Context, _ string) ([]domain.ChapterRef, error) {
+func (s *stubScraper) ScrapeChapterList(_ context.Context, _ string, _ int) ([]domain.ChapterRef, error) {
 	return s.refs, s.refsErr
 }
 

backend/internal/presigncache/cache.go

@@ -0,0 +1,96 @@
+// Package presigncache provides a Valkey (Redis-compatible) backed cache for
+// MinIO presigned URLs. The backend generates presigned URLs and stores them
+// here with a TTL; subsequent requests for the same key return the cached URL
+// without re-contacting MinIO.
+//
+// Design:
+//   - Cache is intentionally best-effort: Get returns ("", false, nil) on any
+//     Valkey error, so callers always have a fallback path to regenerate.
+//   - Set silently drops errors — a miss on the next request is acceptable.
+//   - TTL should be set shorter than the actual presigned URL lifetime so that
+//     cached URLs are always valid when served. Recommended: 55 minutes for a
+//     1-hour presigned URL.
+package presigncache
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+)
+
+// Cache is the interface for presign URL caching.
+// Implementations must be safe for concurrent use.
+type Cache interface {
+	// Get returns the cached URL for key. ok is false on cache miss or error.
+	Get(ctx context.Context, key string) (url string, ok bool, err error)
+	// Set stores url under key with the given TTL.
+	Set(ctx context.Context, key, url string, ttl time.Duration) error
+	// Delete removes key from the cache.
+	Delete(ctx context.Context, key string) error
+}
+
+// ValkeyCache is a Cache backed by Valkey / Redis via go-redis.
+type ValkeyCache struct {
+	rdb *redis.Client
+}
+
+// New creates a ValkeyCache connecting to addr (e.g. "valkey:6379").
+// The connection is not established until the first command; use Ping to
+// verify connectivity at startup.
+func New(addr string) *ValkeyCache {
+	rdb := redis.NewClient(&redis.Options{
+		Addr:         addr,
+		DialTimeout:  2 * time.Second,
+		ReadTimeout:  1 * time.Second,
+		WriteTimeout: 1 * time.Second,
+	})
+	return &ValkeyCache{rdb: rdb}
+}
+
+// Ping checks connectivity. Call once at startup.
+func (c *ValkeyCache) Ping(ctx context.Context) error {
+	if err := c.rdb.Ping(ctx).Err(); err != nil {
+		return fmt.Errorf("presigncache: ping valkey: %w", err)
+	}
+	return nil
+}
+
+// Get returns (url, true, nil) on hit, ("", false, nil) on miss, and
+// ("", false, err) only on unexpected errors (not redis.Nil).
+func (c *ValkeyCache) Get(ctx context.Context, key string) (string, bool, error) {
+	val, err := c.rdb.Get(ctx, key).Result()
+	if err == redis.Nil {
+		return "", false, nil
+	}
+	if err != nil {
+		return "", false, fmt.Errorf("presigncache: get %q: %w", key, err)
+	}
+	return val, true, nil
+}
+
+// Set stores url under key with ttl. Errors are returned but are non-fatal
+// for callers — a Set failure means the next request will miss and regenerate.
+func (c *ValkeyCache) Set(ctx context.Context, key, url string, ttl time.Duration) error {
+	if err := c.rdb.Set(ctx, key, url, ttl).Err(); err != nil {
+		return fmt.Errorf("presigncache: set %q: %w", key, err)
+	}
+	return nil
+}
+
+// Delete removes key from the cache. It is not an error if the key does not exist.
+func (c *ValkeyCache) Delete(ctx context.Context, key string) error {
+	if err := c.rdb.Del(ctx, key).Err(); err != nil {
+		return fmt.Errorf("presigncache: delete %q: %w", key, err)
+	}
+	return nil
+}
+
+// NoopCache is a no-op Cache that always returns a miss. Used when Valkey is
+// not configured (e.g. local development without Docker).
+type NoopCache struct{}
+
+func (NoopCache) Get(_ context.Context, _ string) (string, bool, error)     { return "", false, nil }
+func (NoopCache) Set(_ context.Context, _, _ string, _ time.Duration) error { return nil }
+func (NoopCache) Delete(_ context.Context, _ string) error                  { return nil }

backend/internal/runner/browse_refresh.go

@@ -1,176 +0,0 @@
-package runner
-
-// browse_refresh.go — independent 6-hour loop that fetches novelfire.net
-// browse page snapshots and stores them in MinIO.
-//
-// Design:
-//   - Runs on its own ticker (BrowseRefreshInterval, default 6h) inside Run().
-//   - Fetches page 1 for each combination of the standard genre/sort/status
-//     filter values and stores the parsed JSON blob in MinIO via BrowseStore.
-//   - The backend's handleBrowse then serves from MinIO instead of calling
-//     novelfire.net live, which avoids IP-based rate-limiting on the server.
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"regexp"
-	"strings"
-	"time"
-)
-
-// browseNovelListing mirrors backend.NovelListing for JSON serialisation.
-type browseNovelListing struct {
-	Slug  string `json:"slug"`
-	Title string `json:"title"`
-	Cover string `json:"cover"`
-	URL   string `json:"url"`
-}
-
-// browseSnapshot is the JSON structure stored in MinIO.
-type browseSnapshot struct {
-	Novels  []browseNovelListing `json:"novels"`
-	Page    int                  `json:"page"`
-	HasNext bool                 `json:"hasNext"`
-	// CachedAt is the UTC time the snapshot was written (ISO 8601).
-	CachedAt string `json:"cachedAt"`
-}
-
-// browseCombos lists the filter combinations to pre-fetch.
-// Each entry is (genre, sort, status, novelType).
-var browseCombos = []struct{ genre, sort, status, novelType string }{
-	{"all", "popular", "all", "all-novel"},
-	{"all", "popular", "ongoing", "all-novel"},
-	{"all", "popular", "completed", "all-novel"},
-	{"all", "new", "all", "all-novel"},
-	{"all", "new", "ongoing", "all-novel"},
-	{"all", "new", "completed", "all-novel"},
-	{"all", "top-rated", "all", "all-novel"},
-	{"all", "top-rated", "ongoing", "all-novel"},
-	{"all", "top-rated", "completed", "all-novel"},
-}
-
-const novelFireBrowseBase = "https://novelfire.net"
-
-// runBrowseRefresh fetches all browse combos from novelfire.net and stores
-// the results in MinIO. Errors per-combo are logged but do not abort the
-// whole refresh cycle.
-func (r *Runner) runBrowseRefresh(ctx context.Context) {
-	if r.deps.BrowseStore == nil {
-		r.deps.Log.Warn("runner: browse refresh skipped — BrowseStore not configured")
-		return
-	}
-
-	log := r.deps.Log.With("op", "browse_refresh")
-	log.Info("runner: browse refresh starting", "combos", len(browseCombos))
-
-	ok, fail := 0, 0
-	for _, c := range browseCombos {
-		if ctx.Err() != nil {
-			break
-		}
-		novels, hasNext, err := fetchBrowsePage(ctx, c.genre, c.sort, c.status, c.novelType)
-		if err != nil {
-			log.Warn("runner: browse fetch failed",
-				"genre", c.genre, "sort", c.sort, "status", c.status, "err", err)
-			fail++
-			continue
-		}
-
-		snap := browseSnapshot{
-			Novels:   novels,
-			Page:     1,
-			HasNext:  hasNext,
-			CachedAt: time.Now().UTC().Format(time.RFC3339),
-		}
-		data, _ := json.Marshal(snap)
-		if err := r.deps.BrowseStore.PutBrowsePage(ctx, c.genre, c.sort, c.status, c.novelType, 1, data); err != nil {
-			log.Warn("runner: browse put failed",
-				"genre", c.genre, "sort", c.sort, "status", c.status, "err", err)
-			fail++
-			continue
-		}
-		ok++
-	}
-
-	log.Info("runner: browse refresh finished", "ok", ok, "failed", fail)
-}
-
-// fetchBrowsePage calls novelfire.net and returns a list of novel listings
-// plus a hasNext flag. Mirrors the logic in backend/handlers.go.
-func fetchBrowsePage(ctx context.Context, genre, sort, status, novelType string) ([]browseNovelListing, bool, error) {
-	pageURL := fmt.Sprintf("%s/genre-%s/sort-%s/status-%s/%s?page=1",
-		novelFireBrowseBase, genre, sort, status, novelType)
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, pageURL, nil)
-	if err != nil {
-		return nil, false, fmt.Errorf("build request: %w", err)
-	}
-	req.Header.Set("User-Agent", "Mozilla/5.0 (compatible; libnovel-runner/2)")
-	req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
-	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
-
-	httpClient := &http.Client{Timeout: 45 * time.Second}
-	resp, err := httpClient.Do(req)
-	if err != nil {
-		return nil, false, fmt.Errorf("fetch %s: %w", pageURL, err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		_, _ = io.Copy(io.Discard, resp.Body)
-		return nil, false, fmt.Errorf("upstream returned %d for %s", resp.StatusCode, pageURL)
-	}
-
-	return parseBrowseHTML(resp.Body)
-}
-
-// parseBrowseHTML parses a novelfire HTML response body. Mirrors parseBrowsePage
-// in backend/handlers.go — kept separate to avoid coupling packages.
-func parseBrowseHTML(r io.Reader) ([]browseNovelListing, bool, error) {
-	data, err := io.ReadAll(r)
-	if err != nil {
-		return nil, false, err
-	}
-	body := string(data)
-
-	hasNext := strings.Contains(body, `rel="next"`) ||
-		strings.Contains(body, `aria-label="Next"`) ||
-		strings.Contains(body, `class="next"`)
-
-	slugRe := regexp.MustCompile(`href="/book/([^/"]+)"`)
-	titleRe := regexp.MustCompile(`class="novel-title[^"]*"[^>]*>([^<]+)<`)
-	coverRe := regexp.MustCompile(`data-src="(https?://[^"]+)"`)
-
-	slugMatches := slugRe.FindAllStringSubmatch(body, -1)
-	titleMatches := titleRe.FindAllStringSubmatch(body, -1)
-	coverMatches := coverRe.FindAllStringSubmatch(body, -1)
-
-	var novels []browseNovelListing
-	seen := make(map[string]bool)
-	for i, sm := range slugMatches {
-		slug := sm[1]
-		if seen[slug] {
-			continue
-		}
-		seen[slug] = true
-
-		item := browseNovelListing{
-			Slug: slug,
-			URL:  novelFireBrowseBase + "/book/" + slug,
-		}
-		if i < len(titleMatches) {
-			item.Title = strings.TrimSpace(titleMatches[i][1])
-		}
-		if i < len(coverMatches) {
-			item.Cover = coverMatches[i][1]
-		}
-		if item.Title != "" {
-			novels = append(novels, item)
-		}
-	}
-
-	return novels, hasNext, nil
-}

backend/internal/runner/catalogue_refresh.go

@@ -0,0 +1,185 @@
+package runner
+
+// catalogue_refresh.go — independent loop that walks the full novelfire.net
+// catalogue, scrapes per-book metadata, downloads cover images to MinIO, and
+// indexes every book in Meilisearch.
+//
+// Design:
+//   - Runs on its own ticker (CatalogueRefreshInterval, default 24h) inside Run().
+//   - Also fires once on startup.
+//   - ScrapeCatalogue streams CatalogueEntry values over a channel — we iterate
+//     and call ScrapeMetadata for each entry.
+//   - Per-request random jitter (1–3s) prevents hammering novelfire.net.
+//   - Cover images are fetched from the URL embedded in BookMeta.Cover and
+//     stored in MinIO (browse bucket, key: covers/{slug}.jpg).
+//   - WriteMetadata + UpsertBook are called for every successfully scraped book.
+//   - Errors for individual books are logged and skipped; the loop continues.
+//   - The cover URL stored in BookMeta.Cover is rewritten to the internal proxy
+//     path (/api/cover/novelfire.net/{slug}) so the UI always fetches via the
+//     backend, which will serve from MinIO.
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"time"
+)
+
+// runCatalogueRefresh performs one full catalogue walk: scrapes metadata for
+// every book on novelfire.net, downloads covers to MinIO, and upserts to
+// Meilisearch. Errors for individual books are logged and skipped.
+func (r *Runner) runCatalogueRefresh(ctx context.Context) {
+	if r.deps.Novel == nil {
+		r.deps.Log.Warn("runner: catalogue refresh skipped — Novel scraper not configured")
+		return
+	}
+	if r.deps.BookWriter == nil {
+		r.deps.Log.Warn("runner: catalogue refresh skipped — BookWriter not configured")
+		return
+	}
+
+	log := r.deps.Log.With("op", "catalogue_refresh")
+	log.Info("runner: catalogue refresh starting")
+
+	entries, errCh := r.deps.Novel.ScrapeCatalogue(ctx)
+
+	ok, skipped, errCount := 0, 0, 0
+	for entry := range entries {
+		if ctx.Err() != nil {
+			break
+		}
+
+		// Skip books already present in Meilisearch — they were indexed on a
+		// previous run. Re-indexing only happens when a scrape task is
+		// explicitly enqueued (e.g. via the admin UI or API).
+		if r.deps.SearchIndex.BookExists(ctx, entry.Slug) {
+			skipped++
+			continue
+		}
+
+		// Random jitter between books to avoid rate-limiting.
+		jitter := time.Duration(1000+rand.Intn(2000)) * time.Millisecond
+		select {
+		case <-ctx.Done():
+			break
+		case <-time.After(jitter):
+		}
+
+		meta, err := r.deps.Novel.ScrapeMetadata(ctx, entry.URL)
+		if err != nil {
+			log.Warn("runner: catalogue refresh: metadata scrape failed",
+				"url", entry.URL, "err", err)
+			errCount++
+			continue
+		}
+
+		// Rewrite cover URL to backend proxy path so UI never hits CDN directly.
+		originalCover := meta.Cover
+		meta.Cover = fmt.Sprintf("/api/cover/novelfire.net/%s", meta.Slug)
+
+		// Persist to PocketBase.
+		if err := r.deps.BookWriter.WriteMetadata(ctx, meta); err != nil {
+			log.Warn("runner: catalogue refresh: WriteMetadata failed",
+				"slug", meta.Slug, "err", err)
+			errCount++
+			continue
+		}
+
+		// Index in Meilisearch.
+		if err := r.deps.SearchIndex.UpsertBook(ctx, meta); err != nil {
+			log.Warn("runner: catalogue refresh: UpsertBook failed",
+				"slug", meta.Slug, "err", err)
+			// non-fatal — continue
+		}
+
+		// Download and store cover image in MinIO if we have a cover URL
+		// and a CoverStore is wired in.
+		if r.deps.CoverStore != nil && originalCover != "" {
+			if !r.deps.CoverStore.CoverExists(ctx, meta.Slug) {
+				if err := r.downloadCover(ctx, meta.Slug, originalCover); err != nil {
+					log.Warn("runner: catalogue refresh: cover download failed",
+						"slug", meta.Slug, "url", originalCover, "err", err)
+					// non-fatal
+				}
+			}
+		}
+
+		ok++
+		if ok%100 == 0 {
+			log.Info("runner: catalogue refresh progress",
+				"scraped", ok, "errors", errCount)
+		}
+	}
+
+	if err := <-errCh; err != nil {
+		log.Warn("runner: catalogue refresh: catalogue stream error", "err", err)
+	}
+
+	log.Info("runner: catalogue refresh finished",
+		"ok", ok, "skipped", skipped, "errors", errCount)
+}
+
+// downloadCover fetches the cover image from coverURL and stores it in MinIO
+// under covers/{slug}.jpg. It retries up to 3 times with exponential backoff
+// on transient errors (5xx, network failures).
+func (r *Runner) downloadCover(ctx context.Context, slug, coverURL string) error {
+	const maxRetries = 3
+	delay := 2 * time.Second
+
+	var lastErr error
+	for attempt := 0; attempt < maxRetries; attempt++ {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		if attempt > 0 {
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			case <-time.After(delay):
+			}
+			delay *= 2
+		}
+
+		data, err := fetchCoverBytes(ctx, coverURL)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		if err := r.deps.CoverStore.PutCover(ctx, slug, data, ""); err != nil {
+			return fmt.Errorf("put cover: %w", err)
+		}
+		return nil
+	}
+	return fmt.Errorf("download cover after %d retries: %w", maxRetries, lastErr)
+}
+
+// fetchCoverBytes performs a single HTTP GET for coverURL and returns the body.
+func fetchCoverBytes(ctx context.Context, coverURL string) ([]byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, coverURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("build request: %w", err)
+	}
+	req.Header.Set("User-Agent", "Mozilla/5.0 (compatible; libnovel-runner/2)")
+	req.Header.Set("Referer", "https://novelfire.net/")
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("http get: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 500 {
+		_, _ = io.Copy(io.Discard, resp.Body)
+		return nil, fmt.Errorf("upstream %d for %s", resp.StatusCode, coverURL)
+	}
+	if resp.StatusCode != http.StatusOK {
+		_, _ = io.Copy(io.Discard, resp.Body)
+		return nil, fmt.Errorf("unexpected status %d for %s", resp.StatusCode, coverURL)
+	}
+
+	return io.ReadAll(io.LimitReader(resp.Body, 5<<20)) // 5 MiB cap
+}

backend/internal/runner/metrics.go

@@ -0,0 +1,92 @@
+package runner
+
+// metrics.go — lightweight HTTP metrics endpoint for the runner.
+//
+// GET /metrics returns a JSON document with live task counters and uptime.
+// No external dependency (no Prometheus); plain net/http only.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net"
+	"net/http"
+	"time"
+)
+
+// metricsServer serves GET /metrics for the runner process.
+type metricsServer struct {
+	addr string
+	r    *Runner
+	log  *slog.Logger
+}
+
+func newMetricsServer(addr string, r *Runner, log *slog.Logger) *metricsServer {
+	return &metricsServer{addr: addr, r: r, log: log}
+}
+
+// ListenAndServe starts the HTTP server and blocks until ctx is cancelled or
+// a fatal listen error occurs.
+func (ms *metricsServer) ListenAndServe(ctx context.Context) error {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /metrics", ms.handleMetrics)
+	mux.HandleFunc("GET /health", ms.handleHealth)
+
+	srv := &http.Server{
+		Addr:         ms.addr,
+		Handler:      mux,
+		ReadTimeout:  5 * time.Second,
+		WriteTimeout: 5 * time.Second,
+		BaseContext:  func(_ net.Listener) context.Context { return ctx },
+	}
+
+	errCh := make(chan error, 1)
+	go func() {
+		ms.log.Info("runner: metrics server listening", "addr", ms.addr)
+		errCh <- srv.ListenAndServe()
+	}()
+
+	select {
+	case <-ctx.Done():
+		shutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		_ = srv.Shutdown(shutCtx)
+		return nil
+	case err := <-errCh:
+		return fmt.Errorf("runner: metrics server: %w", err)
+	}
+}
+
+// handleMetrics handles GET /metrics.
+// Response shape (JSON):
+//
+//	{
+//	  "tasks_running":   N,
+//	  "tasks_completed": N,
+//	  "tasks_failed":    N,
+//	  "uptime_seconds":  N
+//	}
+func (ms *metricsServer) handleMetrics(w http.ResponseWriter, _ *http.Request) {
+	uptimeSec := int64(time.Since(ms.r.startedAt).Seconds())
+	metricsWriteJSON(w, 0, map[string]int64{
+		"tasks_running":   ms.r.tasksRunning.Load(),
+		"tasks_completed": ms.r.tasksCompleted.Load(),
+		"tasks_failed":    ms.r.tasksFailed.Load(),
+		"uptime_seconds":  uptimeSec,
+	})
+}
+
+// handleHealth handles GET /health — simple liveness probe for the metrics server.
+func (ms *metricsServer) handleHealth(w http.ResponseWriter, _ *http.Request) {
+	metricsWriteJSON(w, 0, map[string]string{"status": "ok"})
+}
+
+// metricsWriteJSON writes v as a JSON response with the given status code.
+func metricsWriteJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	if status != 0 {
+		w.WriteHeader(status)
+	}
+	_ = json.NewEncoder(w).Encode(v)
+}

backend/internal/runner/runner.go

@@ -8,6 +8,9 @@
 //   - Audio tasks fetch chapter text, call Kokoro, upload to MinIO, and report
 //     the result back (up to MaxConcurrentAudio goroutines).
 //   - The runner is stateless between ticks; all state lives in PocketBase.
+//   - Atomic task counters are exposed via /metrics (see metrics.go).
+//   - Books are indexed in Meilisearch via an orchestrator.Config.PostMetadata
+//     hook injected at construction time.
 package runner
 
 import (
@@ -16,11 +19,13 @@ import (
 	"log/slog"
 	"os"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/libnovel/backend/internal/bookstore"
 	"github.com/libnovel/backend/internal/domain"
 	"github.com/libnovel/backend/internal/kokoro"
+	"github.com/libnovel/backend/internal/meili"
 	"github.com/libnovel/backend/internal/orchestrator"
 	"github.com/libnovel/backend/internal/scraper"
 	"github.com/libnovel/backend/internal/taskqueue"
@@ -44,9 +49,18 @@ type Config struct {
 	// 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.
 	StaleTaskThreshold time.Duration
-	// BrowseRefreshInterval is how often the runner pre-fetches browse page
-	// snapshots from novelfire.net and stores them in MinIO. Defaults to 6h.
-	BrowseRefreshInterval time.Duration
+	// CatalogueRefreshInterval is how often the runner walks the full catalogue,
+	// scrapes per-book metadata, downloads covers, and re-indexes everything in
+	// Meilisearch. Defaults to 24h (expensive — full catalogue walk).
+	CatalogueRefreshInterval time.Duration
+	// SkipInitialCatalogueRefresh suppresses the immediate catalogue walk that
+	// otherwise fires at startup. The periodic ticker (CatalogueRefreshInterval)
+	// still fires normally. Set RUNNER_SKIP_INITIAL_CATALOGUE_REFRESH=true for
+	// quick restarts where the catalogue is already up to date.
+	SkipInitialCatalogueRefresh bool
+	// MetricsAddr is the HTTP listen address for the /metrics endpoint.
+	// Defaults to ":9091". Set to "" to disable.
+	MetricsAddr string
 }
 
 // Dependencies are the external services the runner depends on.
@@ -59,8 +73,11 @@ type Dependencies struct {
 	BookReader bookstore.BookReader
 	// AudioStore persists generated audio and checks key existence.
 	AudioStore bookstore.AudioStore
-	// BrowseStore stores browse page snapshots in MinIO.
-	BrowseStore bookstore.BrowseStore
+	// CoverStore stores book cover images in MinIO.
+	CoverStore bookstore.CoverStore
+	// SearchIndex indexes books in Meilisearch after scraping.
+	// If nil a no-op is used.
+	SearchIndex meili.Client
 	// Novel is the scraper implementation.
 	Novel scraper.NovelScraper
 	// Kokoro is the TTS client.
@@ -73,10 +90,16 @@ type Dependencies struct {
 type Runner struct {
 	cfg  Config
 	deps Dependencies
+
+	// Atomic task counters — read by /metrics without locking.
+	tasksRunning   atomic.Int64
+	tasksCompleted atomic.Int64
+	tasksFailed    atomic.Int64
+
+	startedAt time.Time
 }
 
 // New creates a Runner from cfg and deps.
-// Any zero/nil field in deps will cause a panic at construction time to fail fast.
 func New(cfg Config, deps Dependencies) *Runner {
 	if cfg.PollInterval <= 0 {
 		cfg.PollInterval = 30 * time.Second
@@ -96,63 +119,63 @@ func New(cfg Config, deps Dependencies) *Runner {
 	if cfg.StaleTaskThreshold <= 0 {
 		cfg.StaleTaskThreshold = 2 * time.Minute
 	}
-	if cfg.BrowseRefreshInterval <= 0 {
-		cfg.BrowseRefreshInterval = 6 * time.Hour
+	if cfg.CatalogueRefreshInterval <= 0 {
+		cfg.CatalogueRefreshInterval = 24 * time.Hour
+	}
+	if cfg.MetricsAddr == "" {
+		cfg.MetricsAddr = ":9091"
 	}
 	if deps.Log == nil {
 		deps.Log = slog.Default()
 	}
-	return &Runner{cfg: cfg, deps: deps}
-}
-
-// livenessFile is the path written on every successful poll so that the Docker
-// healthcheck (CMD /healthcheck file /tmp/runner.alive <max_age>) can verify
-// the runner is still making progress.
-const livenessFile = "/tmp/runner.alive"
-
-// touchAlive writes the current UTC time to livenessFile. Errors are logged but
-// never fatal — liveness is best-effort and should not crash the runner.
-func (r *Runner) touchAlive() {
-	data := []byte(time.Now().UTC().Format(time.RFC3339))
-	if err := os.WriteFile(livenessFile, data, 0o644); err != nil {
-		r.deps.Log.Warn("runner: failed to write liveness file", "err", err)
+	if deps.SearchIndex == nil {
+		deps.SearchIndex = meili.NoopClient{}
 	}
+	return &Runner{cfg: cfg, deps: deps, startedAt: time.Now()}
 }
 
-// Run starts the poll loop, blocking until ctx is cancelled.
-// On each tick it claims and executes all available pending tasks.
-// Scrape and audio tasks run in separate goroutine pools bounded by
-// MaxConcurrentScrape and MaxConcurrentAudio respectively.
+// Run starts the poll loop and the metrics HTTP server, blocking until ctx is
+// cancelled.
 func (r *Runner) Run(ctx context.Context) error {
 	r.deps.Log.Info("runner: starting",
 		"worker_id", r.cfg.WorkerID,
 		"poll_interval", r.cfg.PollInterval,
 		"max_scrape", r.cfg.MaxConcurrentScrape,
 		"max_audio", r.cfg.MaxConcurrentAudio,
-		"browse_refresh_interval", r.cfg.BrowseRefreshInterval,
+		"catalogue_refresh_interval", r.cfg.CatalogueRefreshInterval,
+		"metrics_addr", r.cfg.MetricsAddr,
 	)
 
+	// Start metrics HTTP server in background if configured.
+	if r.cfg.MetricsAddr != "" {
+		ms := newMetricsServer(r.cfg.MetricsAddr, r, r.deps.Log)
+		go func() {
+			if err := ms.ListenAndServe(ctx); err != nil {
+				r.deps.Log.Error("runner: metrics server error", "err", err)
+			}
+		}()
+	}
+
 	scrapeSem := make(chan struct{}, r.cfg.MaxConcurrentScrape)
 	audioSem := make(chan struct{}, r.cfg.MaxConcurrentAudio)
 	var wg sync.WaitGroup
 
-	// Write liveness file immediately so the first healthcheck passes before
-	// the first poll completes.
-	r.touchAlive()
-
 	tick := time.NewTicker(r.cfg.PollInterval)
 	defer tick.Stop()
 
-	browseTick := time.NewTicker(r.cfg.BrowseRefreshInterval)
-	defer browseTick.Stop()
+	catalogueTick := time.NewTicker(r.cfg.CatalogueRefreshInterval)
+	defer catalogueTick.Stop()
 
-	// Run one browse refresh and one poll immediately on startup.
-	go r.runBrowseRefresh(ctx)
+	// Run one catalogue refresh immediately on startup (unless skipped by flag).
+	if !r.cfg.SkipInitialCatalogueRefresh {
+		go r.runCatalogueRefresh(ctx)
+	} else {
+		r.deps.Log.Info("runner: skipping initial catalogue refresh (RUNNER_SKIP_INITIAL_CATALOGUE_REFRESH=true)")
+	}
 
 	// Run one poll immediately on startup, then on each tick.
 	for {
 		r.poll(ctx, scrapeSem, audioSem, &wg)
-		r.touchAlive()
 
 		select {
 		case <-ctx.Done():
@@ -169,16 +192,24 @@ func (r *Runner) Run(ctx context.Context) error {
 				r.deps.Log.Warn("runner: drain timeout exceeded, forcing exit")
 			}
 			return nil
-		case <-browseTick.C:
-			go r.runBrowseRefresh(ctx)
+		case <-catalogueTick.C:
+			go r.runCatalogueRefresh(ctx)
 		case <-tick.C:
 		}
 	}
 }
 
 // poll claims all available pending tasks and dispatches them to goroutines.
-// It claims tasks in a tight loop until no more are available.
 func (r *Runner) poll(ctx context.Context, scrapeSem, audioSem chan struct{}, wg *sync.WaitGroup) {
+	// ── Heartbeat file ────────────────────────────────────────────────────
+	// Touch /tmp/runner.alive so the Docker health check can confirm the
+	// runner is actively polling. Failure is non-fatal — just log it.
+	if f, err := os.Create("/tmp/runner.alive"); err != nil {
+		r.deps.Log.Warn("runner: could not write heartbeat file", "err", err)
+	} else {
+		f.Close()
+	}
+
 	// ── Reap orphaned tasks ───────────────────────────────────────────────
 	if n, err := r.deps.Consumer.ReapStaleTasks(ctx, r.cfg.StaleTaskThreshold); err != nil {
 		r.deps.Log.Warn("runner: reap stale tasks failed", "err", err)
@@ -197,23 +228,21 @@ func (r *Runner) poll(ctx context.Context, scrapeSem, audioSem chan struct{}, wg
 			break
 		}
 		if !ok {
-			break // queue empty
+			break
 		}
-		// Acquire semaphore (non-blocking when full — leave task running).
 		select {
 		case scrapeSem <- struct{}{}:
 		default:
-			// Too many concurrent scrapes — the task stays claimed but we can't
-			// run it right now. Log and break; the next poll will pick it up if
-			// still running (it won't be re-claimed while status=running).
 			r.deps.Log.Warn("runner: scrape semaphore full, will retry next tick",
 				"task_id", task.ID)
 			break
 		}
+		r.tasksRunning.Add(1)
 		wg.Add(1)
 		go func(t domain.ScrapeTask) {
 			defer wg.Done()
 			defer func() { <-scrapeSem }()
+			defer r.tasksRunning.Add(-1)
 			r.runScrapeTask(ctx, t)
 		}(task)
 	}
@@ -229,7 +258,7 @@ func (r *Runner) poll(ctx context.Context, scrapeSem, audioSem chan struct{}, wg
 			break
 		}
 		if !ok {
-			break // queue empty
+			break
 		}
 		select {
 		case audioSem <- struct{}{}:
@@ -238,22 +267,36 @@ func (r *Runner) poll(ctx context.Context, scrapeSem, audioSem chan struct{}, wg
 				"task_id", task.ID)
 			break
 		}
+		r.tasksRunning.Add(1)
 		wg.Add(1)
 		go func(t domain.AudioTask) {
 			defer wg.Done()
 			defer func() { <-audioSem }()
+			defer r.tasksRunning.Add(-1)
 			r.runAudioTask(ctx, t)
 		}(task)
 	}
 }
 
+// newOrchestrator builds an orchestrator with the Meilisearch post-hook wired in.
+func (r *Runner) newOrchestrator() *orchestrator.Orchestrator {
+	oCfg := orchestrator.Config{
+		Workers: r.cfg.OrchestratorWorkers,
+		PostMetadata: func(ctx context.Context, meta domain.BookMeta) {
+			if err := r.deps.SearchIndex.UpsertBook(ctx, meta); err != nil {
+				r.deps.Log.Warn("runner: meilisearch upsert failed",
+					"slug", meta.Slug, "err", err)
+			}
+		},
+	}
+	return orchestrator.New(oCfg, r.deps.Novel, r.deps.BookWriter, r.deps.Log)
+}
+
 // runScrapeTask executes one scrape task end-to-end and reports the result.
 func (r *Runner) runScrapeTask(ctx context.Context, task domain.ScrapeTask) {
 	log := r.deps.Log.With("task_id", task.ID, "kind", task.Kind, "url", task.TargetURL)
 	log.Info("runner: scrape task starting")
 
-	// Heartbeat goroutine: periodically PATCH heartbeat_at so the reaper knows
-	// this task is still alive. Cancelled when the task finishes.
 	hbCtx, hbCancel := context.WithCancel(ctx)
 	defer hbCancel()
 	go func() {
@@ -271,9 +314,7 @@ func (r *Runner) runScrapeTask(ctx context.Context, task domain.ScrapeTask) {
 		}
 	}()
 
-	oCfg := orchestrator.Config{Workers: r.cfg.OrchestratorWorkers}
-	o := orchestrator.New(oCfg, r.deps.Novel, r.deps.BookWriter, r.deps.Log)
-
+	o := r.newOrchestrator()
 	var result domain.ScrapeResult
 
 	switch task.Kind {
@@ -289,6 +330,13 @@ func (r *Runner) runScrapeTask(ctx context.Context, task domain.ScrapeTask) {
 	if err := r.deps.Consumer.FinishScrapeTask(ctx, task.ID, result); err != nil {
 		log.Error("runner: FinishScrapeTask failed", "err", err)
 	}
+
+	if result.ErrorMessage != "" {
+		r.tasksFailed.Add(1)
+	} else {
+		r.tasksCompleted.Add(1)
+	}
+
 	log.Info("runner: scrape task finished",
 		"scraped", result.ChaptersScraped,
 		"skipped", result.ChaptersSkipped,
@@ -296,8 +344,7 @@ func (r *Runner) runScrapeTask(ctx context.Context, task domain.ScrapeTask) {
 	)
 }
 
-// runCatalogueTask runs a full catalogue scrape by iterating catalogue entries
-// and running a book task for each one.
+// runCatalogueTask runs a full catalogue scrape.
 func (r *Runner) runCatalogueTask(ctx context.Context, task domain.ScrapeTask, o *orchestrator.Orchestrator, log *slog.Logger) domain.ScrapeResult {
 	entries, errCh := r.deps.Novel.ScrapeCatalogue(ctx)
 	var result domain.ScrapeResult
@@ -328,17 +375,11 @@ func (r *Runner) runCatalogueTask(ctx context.Context, task domain.ScrapeTask, o
 	return result
 }
 
-// runAudioTask executes one audio-generation task:
-//  1. Read chapter text from MinIO.
-//  2. Call Kokoro to generate audio.
-//  3. Upload MP3 to MinIO under the standard audio object key.
-//  4. Report result back to PocketBase.
+// runAudioTask executes one audio-generation task.
 func (r *Runner) runAudioTask(ctx context.Context, task domain.AudioTask) {
 	log := r.deps.Log.With("task_id", task.ID, "slug", task.Slug, "chapter", task.Chapter, "voice", task.Voice)
 	log.Info("runner: audio task starting")
 
-	// Heartbeat goroutine: periodically PATCH heartbeat_at so the reaper knows
-	// this task is still alive. Cancelled when the task finishes.
 	hbCtx, hbCancel := context.WithCancel(ctx)
 	defer hbCancel()
 	go func() {
@@ -358,13 +399,13 @@ func (r *Runner) runAudioTask(ctx context.Context, task domain.AudioTask) {
 
 	fail := func(msg string) {
 		log.Error("runner: audio task failed", "reason", msg)
+		r.tasksFailed.Add(1)
 		result := domain.AudioResult{ErrorMessage: msg}
 		if err := r.deps.Consumer.FinishAudioTask(ctx, task.ID, result); err != nil {
 			log.Error("runner: FinishAudioTask failed", "err", err)
 		}
 	}
 
-	// Step 1: read chapter text.
 	raw, err := r.deps.BookReader.ReadChapter(ctx, task.Slug, task.Chapter)
 	if err != nil {
 		fail(fmt.Sprintf("read chapter: %v", err))
@@ -376,7 +417,6 @@ func (r *Runner) runAudioTask(ctx context.Context, task domain.AudioTask) {
 		return
 	}
 
-	// Step 2: generate audio.
 	if r.deps.Kokoro == nil {
 		fail("kokoro client not configured")
 		return
@@ -387,14 +427,13 @@ func (r *Runner) runAudioTask(ctx context.Context, task domain.AudioTask) {
 		return
 	}
 
-	// Step 3: upload to MinIO.
 	key := r.deps.AudioStore.AudioObjectKey(task.Slug, task.Chapter, task.Voice)
 	if err := r.deps.AudioStore.PutAudio(ctx, key, audioData); err != nil {
 		fail(fmt.Sprintf("put audio: %v", err))
 		return
 	}
 
-	// Step 4: report success.
+	r.tasksCompleted.Add(1)
 	result := domain.AudioResult{ObjectKey: key}
 	if err := r.deps.Consumer.FinishAudioTask(ctx, task.ID, result); err != nil {
 		log.Error("runner: FinishAudioTask failed", "err", err)

backend/internal/runner/runner_test.go

@@ -146,7 +146,7 @@ func (s *stubNovelScraper) ScrapeMetadata(_ context.Context, _ string) (domain.B
 	return domain.BookMeta{Slug: "test-book", Title: "Test Book", SourceURL: "https://example.com/book/test-book"}, nil
 }
 
-func (s *stubNovelScraper) ScrapeChapterList(_ context.Context, _ string) ([]domain.ChapterRef, error) {
+func (s *stubNovelScraper) ScrapeChapterList(_ context.Context, _ string, _ int) ([]domain.ChapterRef, error) {
 	return s.chapters, nil
 }
 

backend/internal/scraper/scraper.go

@@ -20,8 +20,10 @@ type MetadataProvider interface {
 }
 
 // ChapterListProvider can enumerate all chapters of a book.
+// upTo > 0 stops pagination once at least upTo chapter numbers have been
+// collected (early-exit optimisation for range scrapes). upTo == 0 fetches all pages.
 type ChapterListProvider interface {
-	ScrapeChapterList(ctx context.Context, bookURL string) ([]domain.ChapterRef, error)
+	ScrapeChapterList(ctx context.Context, bookURL string, upTo int) ([]domain.ChapterRef, error)
 }
 
 // ChapterTextProvider can extract the readable text from a single chapter page.

backend/internal/storage/minio.go

@@ -119,10 +119,10 @@ func AvatarObjectKey(userID, ext string) string {
 	return fmt.Sprintf("%s/%s.%s", userID, ext, ext)
 }
 
-// BrowseObjectKey returns the MinIO object key for a cached browse page snapshot.
-// Format: browse/{genre}/{sort}/{status}/{type}/page-{n}.json
-func BrowseObjectKey(genre, sort, status, novelType string, page int) string {
-	return fmt.Sprintf("browse/%s/%s/%s/%s/page-%d.json", genre, sort, status, novelType, page)
+// CoverObjectKey returns the MinIO object key for a book cover image.
+// Format: covers/{slug}.jpg
+func CoverObjectKey(slug string) string {
+	return fmt.Sprintf("covers/%s.jpg", slug)
 }
 
 // chapterNumberFromKey extracts the chapter number from a MinIO object key.
@@ -201,16 +201,16 @@ func (m *minioClient) listObjectKeys(ctx context.Context, bucket, prefix string)
 	return keys, nil
 }
 
-// ── Browse operations ─────────────────────────────────────────────────────────
+// ── Cover operations ──────────────────────────────────────────────────────────
 
-// putBrowse stores raw JSON bytes for a browse page snapshot.
-func (m *minioClient) putBrowse(ctx context.Context, key string, data []byte) error {
-	return m.putObject(ctx, m.bucketBrowse, key, "application/json", data)
+// putCover stores a raw cover image in the browse bucket under covers/{slug}.jpg.
+func (m *minioClient) putCover(ctx context.Context, key, contentType string, data []byte) error {
+	return m.putObject(ctx, m.bucketBrowse, key, contentType, data)
 }
 
-// getBrowse retrieves a browse page snapshot. Returns (nil, false, nil) when
-// the object does not exist.
-func (m *minioClient) getBrowse(ctx context.Context, key string) ([]byte, bool, error) {
+// getCover retrieves a cover image. Returns (nil, "", false, nil) when the
+// object does not exist.
+func (m *minioClient) getCover(ctx context.Context, key string) ([]byte, bool, error) {
 	if !m.objectExists(ctx, m.bucketBrowse, key) {
 		return nil, false, nil
 	}
@@ -220,3 +220,25 @@ func (m *minioClient) getBrowse(ctx context.Context, key string) ([]byte, bool,
 	}
 	return data, true, nil
 }
+
+// coverExists returns true when the cover image object exists.
+func (m *minioClient) coverExists(ctx context.Context, key string) bool {
+	return m.objectExists(ctx, m.bucketBrowse, key)
+}
+
+// coverContentType inspects the first bytes of data to determine if it is
+// a JPEG or PNG image. Falls back to "image/jpeg".
+func coverContentType(data []byte) string {
+	if len(data) >= 4 {
+		// PNG magic: 0x89 0x50 0x4E 0x47
+		if data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47 {
+			return "image/png"
+		}
+		// WebP: starts with "RIFF" at 0..3 and "WEBP" at 8..11
+		if len(data) >= 12 && data[0] == 'R' && data[1] == 'I' && data[2] == 'F' && data[3] == 'F' &&
+			data[8] == 'W' && data[9] == 'E' && data[10] == 'B' && data[11] == 'P' {
+			return "image/webp"
+		}
+	}
+	return "image/jpeg"
+}

backend/internal/storage/store.go

@@ -50,7 +50,7 @@ var _ bookstore.RankingStore = (*Store)(nil)
 var _ bookstore.AudioStore = (*Store)(nil)
 var _ bookstore.PresignStore = (*Store)(nil)
 var _ bookstore.ProgressStore = (*Store)(nil)
-var _ bookstore.BrowseStore = (*Store)(nil)
+var _ bookstore.CoverStore = (*Store)(nil)
 var _ taskqueue.Producer = (*Store)(nil)
 var _ taskqueue.Consumer = (*Store)(nil)
 var _ taskqueue.Reader = (*Store)(nil)
@@ -69,6 +69,7 @@ func (s *Store) WriteMetadata(ctx context.Context, meta domain.BookMeta) error {
 		"total_chapters": meta.TotalChapters,
 		"source_url":     meta.SourceURL,
 		"ranking":        meta.Ranking,
+		"rating":         meta.Rating,
 	}
 	// Upsert via filter: if exists PATCH, otherwise POST.
 	existing, err := s.getBookBySlug(ctx, meta.Slug)
@@ -138,10 +139,15 @@ type pbBook struct {
 	TotalChapters int      `json:"total_chapters"`
 	SourceURL     string   `json:"source_url"`
 	Ranking       int      `json:"ranking"`
+	Rating        float64  `json:"rating"`
 	Updated       string   `json:"updated"`
 }
 
 func (b pbBook) toDomain() domain.BookMeta {
+	var metaUpdated int64
+	if t, err := time.Parse(time.RFC3339, b.Updated); err == nil {
+		metaUpdated = t.Unix()
+	}
 	return domain.BookMeta{
 		Slug:          b.Slug,
 		Title:         b.Title,
@@ -153,6 +159,8 @@ func (b pbBook) toDomain() domain.BookMeta {
 		TotalChapters: b.TotalChapters,
 		SourceURL:     b.SourceURL,
 		Ranking:       b.Ranking,
+		Rating:        b.Rating,
+		MetaUpdated:   metaUpdated,
 	}
 }
 
@@ -401,6 +409,17 @@ func (s *Store) PresignAvatarURL(ctx context.Context, userID string) (string, bo
 	return "", false, nil
 }
 
+func (s *Store) PutAvatar(ctx context.Context, userID, ext, contentType string, data []byte) (string, error) {
+	// Delete existing avatar objects for this user before writing the new one
+	// so old extensions don't linger (e.g. old .png after uploading a .jpg).
+	_ = s.mc.deleteObjects(ctx, s.mc.bucketAvatars, userID+"/")
+	key := AvatarObjectKey(userID, ext)
+	if err := s.mc.putObject(ctx, s.mc.bucketAvatars, key, contentType, data); err != nil {
+		return "", fmt.Errorf("put avatar: %w", err)
+	}
+	return key, nil
+}
+
 func (s *Store) DeleteAvatar(ctx context.Context, userID string) error {
 	return s.mc.deleteObjects(ctx, s.mc.bucketAvatars, userID+"/")
 }
@@ -770,21 +789,32 @@ func parseAudioTask(raw json.RawMessage) (domain.AudioTask, error) {
 	}, nil
 }
 
-// ── BrowseStore ────────────────────────────────────────────────────────────────
+// ── CoverStore ─────────────────────────────────────────────────────────────────
 
-func (s *Store) PutBrowsePage(ctx context.Context, genre, sort, status, novelType string, page int, data []byte) error {
-	key := BrowseObjectKey(genre, sort, status, novelType, page)
-	if err := s.mc.putBrowse(ctx, key, data); err != nil {
-		return fmt.Errorf("PutBrowsePage: %w", err)
+func (s *Store) PutCover(ctx context.Context, slug string, data []byte, contentType string) error {
+	key := CoverObjectKey(slug)
+	if contentType == "" {
+		contentType = coverContentType(data)
+	}
+	if err := s.mc.putCover(ctx, key, contentType, data); err != nil {
+		return fmt.Errorf("PutCover: %w", err)
 	}
 	return nil
 }
 
-func (s *Store) GetBrowsePage(ctx context.Context, genre, sort, status, novelType string, page int) ([]byte, bool, error) {
-	key := BrowseObjectKey(genre, sort, status, novelType, page)
-	data, ok, err := s.mc.getBrowse(ctx, key)
+func (s *Store) GetCover(ctx context.Context, slug string) ([]byte, string, bool, error) {
+	key := CoverObjectKey(slug)
+	data, ok, err := s.mc.getCover(ctx, key)
 	if err != nil {
-		return nil, false, fmt.Errorf("GetBrowsePage: %w", err)
+		return nil, "", false, fmt.Errorf("GetCover: %w", err)
 	}
-	return data, ok, nil
+	if !ok {
+		return nil, "", false, nil
+	}
+	ct := coverContentType(data)
+	return data, ct, true, nil
+}
+
+func (s *Store) CoverExists(ctx context.Context, slug string) bool {
+	return s.mc.coverExists(ctx, CoverObjectKey(slug))
 }