feat: admin Text Gen tool — chapter names + book description via CF Workers AI

Adds backend handlers and SvelteKit UI for an admin text generation tool.
The tool lets admins propose and apply AI-generated chapter titles and book
descriptions using Cloudflare Workers AI (12 LLM models, model selector shared
across both tabs).

.githooks/pre-commit

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# Auto-recompile paraglide messages when ui/messages/*.json files are staged.
+# Prevents svelte-check / CI failures caused by stale generated JS files.
+
+set -euo pipefail
+
+STAGED=$(git diff --cached --name-only)
+
+if echo "$STAGED" | grep -q '^ui/messages/'; then
+  echo "[pre-commit] ui/messages/*.json changed — recompiling paraglide..."
+  (cd ui && npm run paraglide --silent)
+  git add -f ui/src/lib/paraglide/messages/
+  echo "[pre-commit] paraglide output re-staged."
+fi

backend/cmd/backend/main.go

@@ -133,6 +133,15 @@ func run() error {
 		log.Info("CFAI_ACCOUNT_ID/CFAI_API_TOKEN not set — image generation unavailable")
 	}
 
+	// ── Cloudflare Workers AI Text Generation ─────────────────────────────────
+	var textGenClient cfai.TextGenClient
+	if cfg.CFAI.AccountID != "" && cfg.CFAI.APIToken != "" {
+		textGenClient = cfai.NewTextGen(cfg.CFAI.AccountID, cfg.CFAI.APIToken)
+		log.Info("cloudflare AI text generation enabled")
+	} else {
+		log.Info("CFAI_ACCOUNT_ID/CFAI_API_TOKEN not set — text generation unavailable")
+	}
+
 	// ── Meilisearch (search reads only; indexing is the runner's job) ────────
 	var searchIndex meili.Client
 	if cfg.Meilisearch.URL != "" {
@@ -184,6 +193,8 @@ func run() error {
 			PocketTTS:        pocketTTSClient,
 			CFAI:             cfaiClient,
 			ImageGen:         imageGenClient,
+			TextGen:          textGenClient,
+			BookWriter:       store,
 			Log:              log,
 		},
 	)

backend/internal/backend/handlers_image.go

@@ -195,7 +195,7 @@ func (s *Server) handleAdminImageGen(w http.ResponseWriter, r *http.Request) {
 			// Non-fatal: still return the image
 		} else {
 			saved = true
-			coverURL = fmt.Sprintf("/api/cover/local/%s", req.Slug)
+			coverURL = fmt.Sprintf("/api/cover/novelfire.net/%s", req.Slug)
 			s.deps.Log.Info("admin: generated cover saved", "slug", req.Slug, "bytes", len(imgData))
 		}
 	}
@@ -213,6 +213,62 @@ func (s *Server) handleAdminImageGen(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
+// saveCoverRequest is the JSON body for POST /api/admin/image-gen/save-cover.
+type saveCoverRequest struct {
+	// Slug is the book slug whose cover should be overwritten.
+	Slug string `json:"slug"`
+	// ImageB64 is the base64-encoded image bytes (PNG or JPEG).
+	ImageB64 string `json:"image_b64"`
+}
+
+// handleAdminImageGenSaveCover handles POST /api/admin/image-gen/save-cover.
+//
+// Accepts a pre-generated image as base64 and stores it as the book cover in
+// MinIO, replacing the existing one. Does not call Cloudflare AI at all.
+func (s *Server) handleAdminImageGenSaveCover(w http.ResponseWriter, r *http.Request) {
+	if s.deps.CoverStore == nil {
+		jsonError(w, http.StatusServiceUnavailable, "cover store not configured")
+		return
+	}
+
+	var req saveCoverRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		jsonError(w, http.StatusBadRequest, "parse body: "+err.Error())
+		return
+	}
+	if req.Slug == "" {
+		jsonError(w, http.StatusBadRequest, "slug is required")
+		return
+	}
+	if req.ImageB64 == "" {
+		jsonError(w, http.StatusBadRequest, "image_b64 is required")
+		return
+	}
+
+	imgData, err := base64.StdEncoding.DecodeString(req.ImageB64)
+	if err != nil {
+		imgData, err = base64.RawStdEncoding.DecodeString(req.ImageB64)
+		if err != nil {
+			jsonError(w, http.StatusBadRequest, "decode image_b64: "+err.Error())
+			return
+		}
+	}
+
+	contentType := sniffImageContentType(imgData)
+	if err := s.deps.CoverStore.PutCover(r.Context(), req.Slug, imgData, contentType); err != nil {
+		s.deps.Log.Error("admin: save-cover failed", "slug", req.Slug, "err", err)
+		jsonError(w, http.StatusInternalServerError, "save cover: "+err.Error())
+		return
+	}
+
+	s.deps.Log.Info("admin: cover saved via image-gen", "slug", req.Slug, "bytes", len(imgData))
+	writeJSON(w, 0, map[string]any{
+		"saved":     true,
+		"cover_url": fmt.Sprintf("/api/cover/novelfire.net/%s", req.Slug),
+		"bytes":     len(imgData),
+	})
+}
+
 // sniffImageContentType returns the MIME type of the image bytes.
 func sniffImageContentType(data []byte) string {
 	if len(data) >= 4 {

backend/internal/backend/handlers_textgen.go

@@ -0,0 +1,413 @@
+package backend
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/libnovel/backend/internal/cfai"
+	"github.com/libnovel/backend/internal/domain"
+)
+
+// handleAdminTextGenModels handles GET /api/admin/text-gen/models.
+// Returns the list of supported Cloudflare AI text generation models.
+func (s *Server) handleAdminTextGenModels(w http.ResponseWriter, r *http.Request) {
+	if s.deps.TextGen == nil {
+		jsonError(w, http.StatusServiceUnavailable, "text generation not configured (CFAI_ACCOUNT_ID/CFAI_API_TOKEN missing)")
+		return
+	}
+	models := s.deps.TextGen.Models()
+	writeJSON(w, 0, map[string]any{"models": models})
+}
+
+// ── Chapter names ─────────────────────────────────────────────────────────────
+
+// textGenChapterNamesRequest is the JSON body for POST /api/admin/text-gen/chapter-names.
+type textGenChapterNamesRequest struct {
+	// Slug is the book slug whose chapters to process.
+	Slug string `json:"slug"`
+	// Pattern is a free-text description of the desired naming convention,
+	// e.g. "Chapter {n}: {brief scene description}".
+	Pattern string `json:"pattern"`
+	// Model is the CF Workers AI model ID. Defaults to the recommended model when empty.
+	Model string `json:"model"`
+	// MaxTokens limits response length (0 = model default).
+	MaxTokens int `json:"max_tokens"`
+}
+
+// textGenChapterNamesResponse is the JSON body returned by POST /api/admin/text-gen/chapter-names.
+type textGenChapterNamesResponse struct {
+	// Chapters is the list of proposed chapter titles, indexed by chapter number.
+	Chapters []proposedChapterTitle `json:"chapters"`
+	// Model is the model that was used.
+	Model string `json:"model"`
+	// RawResponse is the raw model output for debugging / manual editing.
+	RawResponse string `json:"raw_response"`
+}
+
+// proposedChapterTitle is a single chapter with its AI-proposed title.
+type proposedChapterTitle struct {
+	Number int `json:"number"`
+	// OldTitle is the current title stored in the database.
+	OldTitle string `json:"old_title"`
+	// NewTitle is the AI-proposed replacement.
+	NewTitle string `json:"new_title"`
+}
+
+// handleAdminTextGenChapterNames handles POST /api/admin/text-gen/chapter-names.
+//
+// Reads all chapter titles for the given slug, sends them to the LLM with the
+// requested naming pattern, and returns proposed replacements. Does NOT persist
+// anything — the frontend shows a diff and the user must confirm via
+// POST /api/admin/text-gen/chapter-names/apply.
+func (s *Server) handleAdminTextGenChapterNames(w http.ResponseWriter, r *http.Request) {
+	if s.deps.TextGen == nil {
+		jsonError(w, http.StatusServiceUnavailable, "text generation not configured (CFAI_ACCOUNT_ID/CFAI_API_TOKEN missing)")
+		return
+	}
+
+	var req textGenChapterNamesRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		jsonError(w, http.StatusBadRequest, "parse body: "+err.Error())
+		return
+	}
+	if strings.TrimSpace(req.Slug) == "" {
+		jsonError(w, http.StatusBadRequest, "slug is required")
+		return
+	}
+	if strings.TrimSpace(req.Pattern) == "" {
+		jsonError(w, http.StatusBadRequest, "pattern is required")
+		return
+	}
+
+	// Load existing chapter list.
+	chapters, err := s.deps.BookReader.ListChapters(r.Context(), req.Slug)
+	if err != nil {
+		jsonError(w, http.StatusInternalServerError, "list chapters: "+err.Error())
+		return
+	}
+	if len(chapters) == 0 {
+		jsonError(w, http.StatusNotFound, fmt.Sprintf("no chapters found for slug %q", req.Slug))
+		return
+	}
+
+	// Build the prompt.
+	var chapterListSB strings.Builder
+	for _, ch := range chapters {
+		chapterListSB.WriteString(fmt.Sprintf("%d: %s\n", ch.Number, ch.Title))
+	}
+
+	systemPrompt := `You are a chapter title editor for a web novel platform. ` +
+		`The user will provide a list of chapter numbers with their current titles, ` +
+		`and a naming pattern. Your task is to produce a renamed version of every chapter ` +
+		`following the pattern exactly. ` +
+		`Respond ONLY with a JSON array — no prose, no markdown fences, no explanation. ` +
+		`Each element must be an object: {"number": <int>, "title": <string>}. ` +
+		`Output every chapter in the input list. Do not skip any.`
+
+	userPrompt := fmt.Sprintf(
+		"Naming pattern: %s\n\nChapters:\n%s",
+		req.Pattern,
+		chapterListSB.String(),
+	)
+
+	model := cfai.TextModel(req.Model)
+	if model == "" {
+		model = cfai.DefaultTextModel
+	}
+
+	s.deps.Log.Info("admin: text-gen chapter-names requested",
+		"slug", req.Slug, "chapters", len(chapters), "model", model)
+
+	raw, genErr := s.deps.TextGen.Generate(r.Context(), cfai.TextRequest{
+		Model: model,
+		Messages: []cfai.TextMessage{
+			{Role: "system", Content: systemPrompt},
+			{Role: "user", Content: userPrompt},
+		},
+		MaxTokens: req.MaxTokens,
+	})
+	if genErr != nil {
+		s.deps.Log.Error("admin: text-gen chapter-names failed", "err", genErr)
+		jsonError(w, http.StatusBadGateway, "text generation failed: "+genErr.Error())
+		return
+	}
+
+	// Parse the JSON array from the model response.
+	proposed := parseChapterTitlesJSON(raw)
+
+	// Build the response: merge proposed titles with old titles.
+	// Index existing chapters by number for O(1) lookup.
+	existing := make(map[int]string, len(chapters))
+	for _, ch := range chapters {
+		existing[ch.Number] = ch.Title
+	}
+
+	result := make([]proposedChapterTitle, 0, len(proposed))
+	for _, p := range proposed {
+		result = append(result, proposedChapterTitle{
+			Number:   p.Number,
+			OldTitle: existing[p.Number],
+			NewTitle: p.Title,
+		})
+	}
+
+	writeJSON(w, 0, textGenChapterNamesResponse{
+		Chapters:    result,
+		Model:       string(model),
+		RawResponse: raw,
+	})
+}
+
+// parseChapterTitlesJSON extracts the JSON array from a model response.
+// It tolerates markdown fences and surrounding prose.
+type rawChapterTitle struct {
+	Number int    `json:"number"`
+	Title  string `json:"title"`
+}
+
+func parseChapterTitlesJSON(raw string) []rawChapterTitle {
+	// Strip markdown fences if present.
+	s := raw
+	if idx := strings.Index(s, "```json"); idx >= 0 {
+		s = s[idx+7:]
+	} else if idx := strings.Index(s, "```"); idx >= 0 {
+		s = s[idx+3:]
+	}
+	if idx := strings.LastIndex(s, "```"); idx >= 0 {
+		s = s[:idx]
+	}
+	// Find the JSON array boundaries.
+	start := strings.Index(s, "[")
+	end := strings.LastIndex(s, "]")
+	if start < 0 || end <= start {
+		return nil
+	}
+	s = s[start : end+1]
+	var out []rawChapterTitle
+	json.Unmarshal([]byte(s), &out) //nolint:errcheck
+	return out
+}
+
+// ── Apply chapter names ───────────────────────────────────────────────────────
+
+// applyChapterNamesRequest is the JSON body for POST /api/admin/text-gen/chapter-names/apply.
+type applyChapterNamesRequest struct {
+	// Slug is the book slug to update.
+	Slug string `json:"slug"`
+	// Chapters is the list of chapters to save (number + new_title pairs).
+	// The UI may modify individual titles before confirming.
+	Chapters []applyChapterEntry `json:"chapters"`
+}
+
+type applyChapterEntry struct {
+	Number int    `json:"number"`
+	Title  string `json:"title"`
+}
+
+// handleAdminTextGenApplyChapterNames handles POST /api/admin/text-gen/chapter-names/apply.
+//
+// Persists the confirmed chapter titles to PocketBase chapters_idx.
+func (s *Server) handleAdminTextGenApplyChapterNames(w http.ResponseWriter, r *http.Request) {
+	if s.deps.BookWriter == nil {
+		jsonError(w, http.StatusServiceUnavailable, "book writer not configured")
+		return
+	}
+
+	var req applyChapterNamesRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		jsonError(w, http.StatusBadRequest, "parse body: "+err.Error())
+		return
+	}
+	if strings.TrimSpace(req.Slug) == "" {
+		jsonError(w, http.StatusBadRequest, "slug is required")
+		return
+	}
+	if len(req.Chapters) == 0 {
+		jsonError(w, http.StatusBadRequest, "chapters is required")
+		return
+	}
+
+	refs := make([]domain.ChapterRef, 0, len(req.Chapters))
+	for _, ch := range req.Chapters {
+		if ch.Number <= 0 {
+			continue
+		}
+		refs = append(refs, domain.ChapterRef{
+			Number: ch.Number,
+			Title:  strings.TrimSpace(ch.Title),
+		})
+	}
+
+	if err := s.deps.BookWriter.WriteChapterRefs(r.Context(), req.Slug, refs); err != nil {
+		s.deps.Log.Error("admin: apply chapter names failed", "slug", req.Slug, "err", err)
+		jsonError(w, http.StatusInternalServerError, "write chapter refs: "+err.Error())
+		return
+	}
+
+	s.deps.Log.Info("admin: chapter names applied", "slug", req.Slug, "count", len(refs))
+	writeJSON(w, 0, map[string]any{"updated": len(refs)})
+}
+
+// ── Book description ──────────────────────────────────────────────────────────
+
+// textGenDescriptionRequest is the JSON body for POST /api/admin/text-gen/description.
+type textGenDescriptionRequest struct {
+	// Slug is the book slug whose description to regenerate.
+	Slug string `json:"slug"`
+	// Instructions is an optional free-text hint for the AI,
+	// e.g. "Write a 3-sentence blurb, avoid spoilers, dramatic tone."
+	Instructions string `json:"instructions"`
+	// Model is the CF Workers AI model ID. Defaults to recommended when empty.
+	Model string `json:"model"`
+	// MaxTokens limits response length (0 = model default).
+	MaxTokens int `json:"max_tokens"`
+}
+
+// textGenDescriptionResponse is the JSON body returned by POST /api/admin/text-gen/description.
+type textGenDescriptionResponse struct {
+	// OldDescription is the current summary stored in the database.
+	OldDescription string `json:"old_description"`
+	// NewDescription is the AI-proposed replacement.
+	NewDescription string `json:"new_description"`
+	// Model is the model that was used.
+	Model string `json:"model"`
+}
+
+// handleAdminTextGenDescription handles POST /api/admin/text-gen/description.
+//
+// Reads the current book metadata, sends it to the LLM, and returns a proposed
+// new description. Does NOT persist anything — the user must confirm via
+// POST /api/admin/text-gen/description/apply.
+func (s *Server) handleAdminTextGenDescription(w http.ResponseWriter, r *http.Request) {
+	if s.deps.TextGen == nil {
+		jsonError(w, http.StatusServiceUnavailable, "text generation not configured (CFAI_ACCOUNT_ID/CFAI_API_TOKEN missing)")
+		return
+	}
+
+	var req textGenDescriptionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		jsonError(w, http.StatusBadRequest, "parse body: "+err.Error())
+		return
+	}
+	if strings.TrimSpace(req.Slug) == "" {
+		jsonError(w, http.StatusBadRequest, "slug is required")
+		return
+	}
+
+	// Load current book metadata.
+	meta, ok, err := s.deps.BookReader.ReadMetadata(r.Context(), req.Slug)
+	if err != nil {
+		jsonError(w, http.StatusInternalServerError, "read metadata: "+err.Error())
+		return
+	}
+	if !ok {
+		jsonError(w, http.StatusNotFound, fmt.Sprintf("book %q not found", req.Slug))
+		return
+	}
+
+	systemPrompt := `You are a book description writer for a web novel platform. ` +
+		`Given a book's title, author, genres, and current description, write an improved ` +
+		`description that accurately captures the story. ` +
+		`Respond with ONLY the new description text — no title, no labels, no markdown, no quotes.`
+
+	instructions := strings.TrimSpace(req.Instructions)
+	if instructions == "" {
+		instructions = "Write a compelling 2–4 sentence description. Keep it spoiler-free and engaging."
+	}
+
+	userPrompt := fmt.Sprintf(
+		"Title: %s\nAuthor: %s\nGenres: %s\nStatus: %s\n\nCurrent description:\n%s\n\nInstructions: %s",
+		meta.Title,
+		meta.Author,
+		strings.Join(meta.Genres, ", "),
+		meta.Status,
+		meta.Summary,
+		instructions,
+	)
+
+	model := cfai.TextModel(req.Model)
+	if model == "" {
+		model = cfai.DefaultTextModel
+	}
+
+	s.deps.Log.Info("admin: text-gen description requested",
+		"slug", req.Slug, "model", model)
+
+	newDesc, genErr := s.deps.TextGen.Generate(r.Context(), cfai.TextRequest{
+		Model: model,
+		Messages: []cfai.TextMessage{
+			{Role: "system", Content: systemPrompt},
+			{Role: "user", Content: userPrompt},
+		},
+		MaxTokens: req.MaxTokens,
+	})
+	if genErr != nil {
+		s.deps.Log.Error("admin: text-gen description failed", "err", genErr)
+		jsonError(w, http.StatusBadGateway, "text generation failed: "+genErr.Error())
+		return
+	}
+
+	writeJSON(w, 0, textGenDescriptionResponse{
+		OldDescription: meta.Summary,
+		NewDescription: strings.TrimSpace(newDesc),
+		Model:          string(model),
+	})
+}
+
+// ── Apply description ─────────────────────────────────────────────────────────
+
+// applyDescriptionRequest is the JSON body for POST /api/admin/text-gen/description/apply.
+type applyDescriptionRequest struct {
+	// Slug is the book slug to update.
+	Slug string `json:"slug"`
+	// Description is the new summary text to persist.
+	Description string `json:"description"`
+}
+
+// handleAdminTextGenApplyDescription handles POST /api/admin/text-gen/description/apply.
+//
+// Updates only the summary field in PocketBase, leaving all other book metadata
+// unchanged.
+func (s *Server) handleAdminTextGenApplyDescription(w http.ResponseWriter, r *http.Request) {
+	if s.deps.BookWriter == nil {
+		jsonError(w, http.StatusServiceUnavailable, "book writer not configured")
+		return
+	}
+
+	var req applyDescriptionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		jsonError(w, http.StatusBadRequest, "parse body: "+err.Error())
+		return
+	}
+	if strings.TrimSpace(req.Slug) == "" {
+		jsonError(w, http.StatusBadRequest, "slug is required")
+		return
+	}
+	if strings.TrimSpace(req.Description) == "" {
+		jsonError(w, http.StatusBadRequest, "description is required")
+		return
+	}
+
+	// Read existing metadata so we can write it back with only summary changed.
+	meta, ok, err := s.deps.BookReader.ReadMetadata(r.Context(), req.Slug)
+	if err != nil {
+		jsonError(w, http.StatusInternalServerError, "read metadata: "+err.Error())
+		return
+	}
+	if !ok {
+		jsonError(w, http.StatusNotFound, fmt.Sprintf("book %q not found", req.Slug))
+		return
+	}
+
+	meta.Summary = strings.TrimSpace(req.Description)
+	if err := s.deps.BookWriter.WriteMetadata(r.Context(), meta); err != nil {
+		s.deps.Log.Error("admin: apply description failed", "slug", req.Slug, "err", err)
+		jsonError(w, http.StatusInternalServerError, "write metadata: "+err.Error())
+		return
+	}
+
+	s.deps.Log.Info("admin: book description applied", "slug", req.Slug)
+	writeJSON(w, 0, map[string]any{"updated": true})
+}

backend/internal/backend/server.go

@@ -76,6 +76,12 @@ type Dependencies struct {
 	// ImageGen is the Cloudflare Workers AI image generation client.
 	// If nil, image generation endpoints return 503.
 	ImageGen cfai.ImageGenClient
+	// TextGen is the Cloudflare Workers AI text generation client.
+	// If nil, text generation endpoints return 503.
+	TextGen cfai.TextGenClient
+	// BookWriter writes book metadata and chapter refs to PocketBase.
+	// Used by admin text-gen apply endpoints.
+	BookWriter bookstore.BookWriter
 	// Log is the structured logger.
 	Log *slog.Logger
 }
@@ -189,6 +195,14 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
 	// Admin image generation endpoints
 	mux.HandleFunc("GET /api/admin/image-gen/models", s.handleAdminImageGenModels)
 	mux.HandleFunc("POST /api/admin/image-gen", s.handleAdminImageGen)
+	mux.HandleFunc("POST /api/admin/image-gen/save-cover", s.handleAdminImageGenSaveCover)
+
+	// Admin text generation endpoints (chapter names + book description)
+	mux.HandleFunc("GET /api/admin/text-gen/models", s.handleAdminTextGenModels)
+	mux.HandleFunc("POST /api/admin/text-gen/chapter-names", s.handleAdminTextGenChapterNames)
+	mux.HandleFunc("POST /api/admin/text-gen/chapter-names/apply", s.handleAdminTextGenApplyChapterNames)
+	mux.HandleFunc("POST /api/admin/text-gen/description", s.handleAdminTextGenDescription)
+	mux.HandleFunc("POST /api/admin/text-gen/description/apply", s.handleAdminTextGenApplyDescription)
 
 	// Voices list
 	mux.HandleFunc("GET /api/voices", s.handleVoices)

backend/internal/cfai/text.go

@@ -0,0 +1,239 @@
+// Text generation via Cloudflare Workers AI LLM models.
+//
+// API reference:
+//
+//	POST https://api.cloudflare.com/client/v4/accounts/{accountID}/ai/run/{model}
+//	Authorization: Bearer {apiToken}
+//	Content-Type:  application/json
+//
+// Request body (all models):
+//
+//	{ "messages": [{"role":"system","content":"..."},{"role":"user","content":"..."}] }
+//
+// Response (wrapped):
+//
+//	{ "result": { "response": "..." }, "success": true }
+package cfai
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+// TextModel identifies a Cloudflare Workers AI text generation model.
+type TextModel string
+
+const (
+	// TextModelGemma4          — Google Gemma 4, 256k context.
+	TextModelGemma4 TextModel = "@cf/google/gemma-4-26b-a4b-it"
+	// TextModelLlama4Scout     — Meta Llama 4 Scout 17B, multimodal.
+	TextModelLlama4Scout TextModel = "@cf/meta/llama-4-scout-17b-16e-instruct"
+	// TextModelLlama33_70B     — Meta Llama 3.3 70B, fast fp8.
+	TextModelLlama33_70B TextModel = "@cf/meta/llama-3.3-70b-instruct-fp8-fast"
+	// TextModelQwen3_30B       — Qwen3 30B MoE, function calling.
+	TextModelQwen3_30B TextModel = "@cf/qwen/qwen3-30b-a3b-fp8"
+	// TextModelMistralSmall    — Mistral Small 3.1 24B, 128k context.
+	TextModelMistralSmall TextModel = "@cf/mistralai/mistral-small-3.1-24b-instruct"
+	// TextModelQwQ32B          — Qwen QwQ 32B reasoning model.
+	TextModelQwQ32B TextModel = "@cf/qwen/qwq-32b"
+	// TextModelDeepSeekR1      — DeepSeek R1 distill Qwen 32B.
+	TextModelDeepSeekR1 TextModel = "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b"
+	// TextModelGemma3_12B      — Google Gemma 3 12B, 80k context.
+	TextModelGemma3_12B TextModel = "@cf/google/gemma-3-12b-it"
+	// TextModelGPTOSS120B      — OpenAI gpt-oss-120b, high reasoning.
+	TextModelGPTOSS120B TextModel = "@cf/openai/gpt-oss-120b"
+	// TextModelGPTOSS20B       — OpenAI gpt-oss-20b, lower latency.
+	TextModelGPTOSS20B TextModel = "@cf/openai/gpt-oss-20b"
+	// TextModelNemotron3       — NVIDIA Nemotron 3 120B, agentic.
+	TextModelNemotron3 TextModel = "@cf/nvidia/nemotron-3-120b-a12b"
+	// TextModelLlama32_3B      — Meta Llama 3.2 3B, lightweight.
+	TextModelLlama32_3B TextModel = "@cf/meta/llama-3.2-3b-instruct"
+
+	// DefaultTextModel is the default model used when none is specified.
+	DefaultTextModel = TextModelLlama4Scout
+)
+
+// TextModelInfo describes a single text generation model.
+type TextModelInfo struct {
+	ID          string `json:"id"`
+	Label       string `json:"label"`
+	Provider    string `json:"provider"`
+	ContextSize int    `json:"context_size"` // max context in tokens
+	Description string `json:"description"`
+}
+
+// AllTextModels returns metadata about every supported text generation model.
+func AllTextModels() []TextModelInfo {
+	return []TextModelInfo{
+		{
+			ID: string(TextModelGemma4), Label: "Gemma 4 26B", Provider: "Google",
+			ContextSize: 256000,
+			Description: "Google's most intelligent open model family. 256k context, function calling.",
+		},
+		{
+			ID: string(TextModelLlama4Scout), Label: "Llama 4 Scout 17B", Provider: "Meta",
+			ContextSize: 131000,
+			Description: "Natively multimodal, 16 experts. Good all-purpose model with function calling.",
+		},
+		{
+			ID: string(TextModelLlama33_70B), Label: "Llama 3.3 70B (fp8 fast)", Provider: "Meta",
+			ContextSize: 24000,
+			Description: "Llama 3.3 70B quantized to fp8 for speed. Excellent instruction following.",
+		},
+		{
+			ID: string(TextModelQwen3_30B), Label: "Qwen3 30B MoE", Provider: "Qwen",
+			ContextSize: 32768,
+			Description: "MoE architecture with strong reasoning and instruction following.",
+		},
+		{
+			ID: string(TextModelMistralSmall), Label: "Mistral Small 3.1 24B", Provider: "MistralAI",
+			ContextSize: 128000,
+			Description: "Strong text performance with 128k context and function calling.",
+		},
+		{
+			ID: string(TextModelQwQ32B), Label: "QwQ 32B (reasoning)", Provider: "Qwen",
+			ContextSize: 24000,
+			Description: "Reasoning model — thinks before answering. Slower but more accurate.",
+		},
+		{
+			ID: string(TextModelDeepSeekR1), Label: "DeepSeek R1 32B", Provider: "DeepSeek",
+			ContextSize: 80000,
+			Description: "R1-distilled reasoning model. Outperforms o1-mini on many benchmarks.",
+		},
+		{
+			ID: string(TextModelGemma3_12B), Label: "Gemma 3 12B", Provider: "Google",
+			ContextSize: 80000,
+			Description: "Multimodal, 128k context, multilingual (140+ languages).",
+		},
+		{
+			ID: string(TextModelGPTOSS120B), Label: "GPT-OSS 120B", Provider: "OpenAI",
+			ContextSize: 128000,
+			Description: "OpenAI open-weight model for production, general purpose, high reasoning.",
+		},
+		{
+			ID: string(TextModelGPTOSS20B), Label: "GPT-OSS 20B", Provider: "OpenAI",
+			ContextSize: 128000,
+			Description: "OpenAI open-weight model for lower latency and specialized use cases.",
+		},
+		{
+			ID: string(TextModelNemotron3), Label: "Nemotron 3 120B", Provider: "NVIDIA",
+			ContextSize: 256000,
+			Description: "Hybrid MoE with leading accuracy for multi-agent applications.",
+		},
+		{
+			ID: string(TextModelLlama32_3B), Label: "Llama 3.2 3B", Provider: "Meta",
+			ContextSize: 80000,
+			Description: "Lightweight model for simple tasks. Fast and cheap.",
+		},
+	}
+}
+
+// TextMessage is a single message in a chat conversation.
+type TextMessage struct {
+	Role    string `json:"role"`    // "system" or "user"
+	Content string `json:"content"` // message text
+}
+
+// TextRequest is the input to Generate.
+type TextRequest struct {
+	// Model is the CF Workers AI model ID. Defaults to DefaultTextModel when empty.
+	Model TextModel
+	// Messages is the conversation history (system + user messages).
+	Messages []TextMessage
+	// MaxTokens limits the output length (0 = model default).
+	MaxTokens int
+}
+
+// TextGenClient generates text via Cloudflare Workers AI LLM models.
+type TextGenClient interface {
+	// Generate sends a chat-style request and returns the model's response text.
+	Generate(ctx context.Context, req TextRequest) (string, error)
+
+	// Models returns metadata about all supported text generation models.
+	Models() []TextModelInfo
+}
+
+// textGenHTTPClient is the concrete CF AI text generation client.
+type textGenHTTPClient struct {
+	accountID string
+	apiToken  string
+	http      *http.Client
+}
+
+// NewTextGen returns a TextGenClient for the given Cloudflare account.
+func NewTextGen(accountID, apiToken string) TextGenClient {
+	return &textGenHTTPClient{
+		accountID: accountID,
+		apiToken:  apiToken,
+		http:      &http.Client{Timeout: 5 * time.Minute},
+	}
+}
+
+// Generate sends messages to the model and returns the response text.
+func (c *textGenHTTPClient) Generate(ctx context.Context, req TextRequest) (string, error) {
+	if req.Model == "" {
+		req.Model = DefaultTextModel
+	}
+
+	body := map[string]any{
+		"messages": req.Messages,
+	}
+	if req.MaxTokens > 0 {
+		body["max_tokens"] = req.MaxTokens
+	}
+
+	encoded, err := json.Marshal(body)
+	if err != nil {
+		return "", fmt.Errorf("cfai/text: marshal: %w", err)
+	}
+
+	url := fmt.Sprintf("https://api.cloudflare.com/client/v4/accounts/%s/ai/run/%s",
+		c.accountID, string(req.Model))
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(encoded))
+	if err != nil {
+		return "", fmt.Errorf("cfai/text: build request: %w", err)
+	}
+	httpReq.Header.Set("Authorization", "Bearer "+c.apiToken)
+	httpReq.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.http.Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("cfai/text: http: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		errBody, _ := io.ReadAll(resp.Body)
+		msg := string(errBody)
+		if len(msg) > 300 {
+			msg = msg[:300]
+		}
+		return "", fmt.Errorf("cfai/text: model %s returned %d: %s", req.Model, resp.StatusCode, msg)
+	}
+
+	// CF AI wraps responses: { "result": { "response": "..." }, "success": true }
+	var wrapper struct {
+		Result struct {
+			Response string `json:"response"`
+		} `json:"result"`
+		Success bool     `json:"success"`
+		Errors  []string `json:"errors"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&wrapper); err != nil {
+		return "", fmt.Errorf("cfai/text: decode response: %w", err)
+	}
+	if !wrapper.Success {
+		return "", fmt.Errorf("cfai/text: model %s error: %v", req.Model, wrapper.Errors)
+	}
+	return wrapper.Result.Response, nil
+}
+
+// Models returns all supported text generation model metadata.
+func (c *textGenHTTPClient) Models() []TextModelInfo {
+	return AllTextModels()
+}

docker-compose.yml

@@ -19,6 +19,9 @@ x-infra-env: &infra-env
   MEILI_API_KEY: "${MEILI_MASTER_KEY}"
   # Valkey
   VALKEY_ADDR: "valkey:6379"
+  # Cloudflare AI (TTS + image generation)
+  CFAI_ACCOUNT_ID: "${CFAI_ACCOUNT_ID}"
+  CFAI_API_TOKEN: "${CFAI_API_TOKEN}"
 
 services:
   # ─── MinIO (object storage: chapters, audio, avatars, browse) ────────────────

justfile

@@ -122,6 +122,13 @@ secrets-env:
 secrets-dashboard:
     doppler open dashboard
 
+# ── Developer setup ───────────────────────────────────────────────────────────
+
+# One-time dev setup: configure git to use committed hooks in .githooks/
+setup:
+    git config core.hooksPath .githooks
+    @echo "Git hooks configured (.githooks/pre-commit active)."
+
 # ── Gitea CI ──────────────────────────────────────────────────────────────────
 
 # Validate workflow files

ui/messages/en.json

@@ -363,6 +363,7 @@
   "admin_nav_translation": "Translation",
   "admin_nav_changelog": "Changelog",
   "admin_nav_image_gen": "Image Gen",
+  "admin_nav_text_gen": "Text Gen",
   "admin_nav_feedback": "Feedback",
   "admin_nav_errors": "Errors",
   "admin_nav_analytics": "Analytics",

ui/messages/fr.json

@@ -363,6 +363,7 @@
   "admin_nav_translation": "Traduction",
   "admin_nav_changelog": "Modifications",
   "admin_nav_image_gen": "Image Gen",
+  "admin_nav_text_gen": "Text Gen",
   "admin_nav_feedback": "Retours",
   "admin_nav_errors": "Erreurs",
   "admin_nav_analytics": "Analytique",

ui/messages/id.json

@@ -363,6 +363,7 @@
   "admin_nav_translation": "Terjemahan",
   "admin_nav_changelog": "Perubahan",
   "admin_nav_image_gen": "Image Gen",
+  "admin_nav_text_gen": "Text Gen",
   "admin_nav_feedback": "Masukan",
   "admin_nav_errors": "Kesalahan",
   "admin_nav_analytics": "Analitik",

ui/messages/pt.json

@@ -363,6 +363,7 @@
   "admin_nav_translation": "Tradução",
   "admin_nav_changelog": "Alterações",
   "admin_nav_image_gen": "Image Gen",
+  "admin_nav_text_gen": "Text Gen",
   "admin_nav_feedback": "Feedback",
   "admin_nav_errors": "Erros",
   "admin_nav_analytics": "Análise",

ui/messages/ru.json

@@ -363,6 +363,7 @@
   "admin_nav_translation": "Перевод",
   "admin_nav_changelog": "Изменения",
   "admin_nav_image_gen": "Image Gen",
+  "admin_nav_text_gen": "Text Gen",
   "admin_nav_feedback": "Отзывы",
   "admin_nav_errors": "Ошибки",
   "admin_nav_analytics": "Аналитика",

ui/src/app.css

@@ -106,12 +106,14 @@ html {
 :root {
 	--reading-font: system-ui, -apple-system, sans-serif;
 	--reading-size: 1.05rem;
+	--reading-line-height: 1.85;
+	--reading-max-width: 72ch;
 }
 
 /* ── Chapter prose ─────────────────────────────────────────────────── */
 .prose-chapter {
-	max-width: 72ch;
-	line-height: 1.85;
+	max-width: var(--reading-max-width, 72ch);
+	line-height: var(--reading-line-height, 1.85);
 	font-family: var(--reading-font);
 	font-size: var(--reading-size);
 	color: var(--color-muted);
@@ -134,6 +136,12 @@ html {
 	margin-bottom: 1.2em;
 }
 
+/* Indented paragraph style — book-like, no gap, indent instead */
+.prose-chapter.para-indented p {
+	text-indent: 2em;
+	margin-bottom: 0.35em;
+}
+
 .prose-chapter em {
 	color: var(--color-muted);
 }
@@ -147,6 +155,31 @@ html {
 	margin: 2em 0;
 }
 
+/* ── Reading progress bar ───────────────────────────────────────────── */
+.reading-progress {
+	position: fixed;
+	top: 0;
+	left: 0;
+	height: 2px;
+	z-index: 100;
+	background: var(--color-brand);
+	pointer-events: none;
+	transition: width 0.1s linear;
+}
+
+/* ── Paginated reader ───────────────────────────────────────────────── */
+.paginated-container {
+	overflow: hidden;
+	cursor: pointer;
+	user-select: none;
+	-webkit-user-select: none;
+}
+
+.paginated-container .prose-chapter {
+	transition: transform 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+	will-change: transform;
+}
+
 /* ── Hide scrollbars (used on horizontal carousels) ────────────────── */
 .scrollbar-none {
 	scrollbar-width: none;       /* Firefox */

ui/src/lib/paraglide/messages/_index.js

@@ -333,6 +333,8 @@ export * from './admin_nav_scrape.js'
 export * from './admin_nav_audio.js'
 export * from './admin_nav_translation.js'
 export * from './admin_nav_changelog.js'
+export * from './admin_nav_image_gen.js'
+export * from './admin_nav_text_gen.js'
 export * from './admin_nav_feedback.js'
 export * from './admin_nav_errors.js'
 export * from './admin_nav_analytics.js'

ui/src/lib/paraglide/messages/admin_nav_image_gen.js

@@ -0,0 +1,44 @@
+/* eslint-disable */
+import { getLocale, experimentalStaticLocale } from '../runtime.js';
+
+/** @typedef {import('../runtime.js').LocalizedString} LocalizedString */
+
+/** @typedef {{}} Admin_Nav_Image_GenInputs */
+
+const en_admin_nav_image_gen = /** @type {(inputs: Admin_Nav_Image_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Image Gen`)
+};
+
+const ru_admin_nav_image_gen = /** @type {(inputs: Admin_Nav_Image_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Image Gen`)
+};
+
+const id_admin_nav_image_gen = /** @type {(inputs: Admin_Nav_Image_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Image Gen`)
+};
+
+const pt_admin_nav_image_gen = /** @type {(inputs: Admin_Nav_Image_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Image Gen`)
+};
+
+const fr_admin_nav_image_gen = /** @type {(inputs: Admin_Nav_Image_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Image Gen`)
+};
+
+/**
+* | output |
+* | --- |
+* | "Image Gen" |
+*
+* @param {Admin_Nav_Image_GenInputs} inputs
+* @param {{ locale?: "en" | "ru" | "id" | "pt" | "fr" }} options
+* @returns {LocalizedString}
+*/
+export const admin_nav_image_gen = /** @type {((inputs?: Admin_Nav_Image_GenInputs, options?: { locale?: "en" | "ru" | "id" | "pt" | "fr" }) => LocalizedString) & import('../runtime.js').MessageMetadata<Admin_Nav_Image_GenInputs, { locale?: "en" | "ru" | "id" | "pt" | "fr" }, {}>} */ ((inputs = {}, options = {}) => {
+	const locale = experimentalStaticLocale ?? options.locale ?? getLocale()
+	if (locale === "en") return en_admin_nav_image_gen(inputs)
+	if (locale === "ru") return ru_admin_nav_image_gen(inputs)
+	if (locale === "id") return id_admin_nav_image_gen(inputs)
+	if (locale === "pt") return pt_admin_nav_image_gen(inputs)
+	return fr_admin_nav_image_gen(inputs)
+});

ui/src/lib/paraglide/messages/admin_nav_text_gen.js

@@ -0,0 +1,44 @@
+/* eslint-disable */
+import { getLocale, experimentalStaticLocale } from '../runtime.js';
+
+/** @typedef {import('../runtime.js').LocalizedString} LocalizedString */
+
+/** @typedef {{}} Admin_Nav_Text_GenInputs */
+
+const en_admin_nav_text_gen = /** @type {(inputs: Admin_Nav_Text_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Text Gen`)
+};
+
+const ru_admin_nav_text_gen = /** @type {(inputs: Admin_Nav_Text_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Text Gen`)
+};
+
+const id_admin_nav_text_gen = /** @type {(inputs: Admin_Nav_Text_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Text Gen`)
+};
+
+const pt_admin_nav_text_gen = /** @type {(inputs: Admin_Nav_Text_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Text Gen`)
+};
+
+const fr_admin_nav_text_gen = /** @type {(inputs: Admin_Nav_Text_GenInputs) => LocalizedString} */ () => {
+	return /** @type {LocalizedString} */ (`Text Gen`)
+};
+
+/**
+* | output |
+* | --- |
+* | "Text Gen" |
+*
+* @param {Admin_Nav_Text_GenInputs} inputs
+* @param {{ locale?: "en" | "ru" | "id" | "pt" | "fr" }} options
+* @returns {LocalizedString}
+*/
+export const admin_nav_text_gen = /** @type {((inputs?: Admin_Nav_Text_GenInputs, options?: { locale?: "en" | "ru" | "id" | "pt" | "fr" }) => LocalizedString) & import('../runtime.js').MessageMetadata<Admin_Nav_Text_GenInputs, { locale?: "en" | "ru" | "id" | "pt" | "fr" }, {}>} */ ((inputs = {}, options = {}) => {
+	const locale = experimentalStaticLocale ?? options.locale ?? getLocale()
+	if (locale === "en") return en_admin_nav_text_gen(inputs)
+	if (locale === "ru") return ru_admin_nav_text_gen(inputs)
+	if (locale === "id") return id_admin_nav_text_gen(inputs)
+	if (locale === "pt") return pt_admin_nav_text_gen(inputs)
+	return fr_admin_nav_text_gen(inputs)
+});

ui/src/routes/admin/+layout.svelte

@@ -7,7 +7,8 @@
 		{ href: '/admin/audio', label: () => m.admin_nav_audio() },
 		{ href: '/admin/translation', label: () => m.admin_nav_translation() },
 		{ href: '/admin/changelog', label: () => m.admin_nav_changelog() },
-		{ href: '/admin/image-gen', label: () => m.admin_nav_image_gen() }
+		{ href: '/admin/image-gen', label: () => m.admin_nav_image_gen() },
+		{ href: '/admin/text-gen', label: () => m.admin_nav_text_gen() }
 	];
 
 	const externalLinks = [

ui/src/routes/admin/image-gen/+page.svelte

@@ -219,28 +219,12 @@
 		saveSuccess = false;
 
 		try {
-			const payload = {
-				prompt: prompt.trim(),
-				model: result.model,
-				type: 'cover',
-				slug: result.slug,
-				num_steps: numSteps,
-				guidance,
-				strength,
-				width,
-				height,
-				save_to_cover: true
-			};
-
-			// Re-generate with save_to_cover=true (backend saves atomically)
-			// Alternatively, we could add a separate save endpoint.
-			// For now we pass the same prompt + model to re-generate and save.
-			// TODO: A lighter approach would be a dedicated save endpoint that accepts
-			// the base64 payload. For now re-gen is acceptable given admin-only usage.
-			const res = await fetch('/api/admin/image-gen', {
+			// Extract the raw base64 from the data URL (data:<mime>;base64,<b64>)
+			const b64 = result.imageSrc.split(',')[1];
+			const res = await fetch('/api/admin/image-gen/save-cover', {
 				method: 'POST',
 				headers: { 'Content-Type': 'application/json' },
-				body: JSON.stringify(payload)
+				body: JSON.stringify({ slug: result.slug, image_b64: b64 })
 			});
 			const body = await res.json().catch(() => ({}));
 			if (!res.ok) {

ui/src/routes/admin/text-gen/+page.server.ts

@@ -0,0 +1,27 @@
+import type { PageServerLoad } from './$types';
+import { backendFetch } from '$lib/server/scraper';
+import { log } from '$lib/server/logger';
+
+export interface TextModelInfo {
+	id: string;
+	label: string;
+	provider: string;
+	context_size: number;
+	description: string;
+}
+
+export const load: PageServerLoad = async () => {
+	// Parent layout already guards admin role.
+	try {
+		const res = await backendFetch('/api/admin/text-gen/models');
+		if (!res.ok) {
+			log.warn('admin/text-gen', 'failed to load models', { status: res.status });
+			return { models: [] as TextModelInfo[] };
+		}
+		const data = await res.json();
+		return { models: (data.models ?? []) as TextModelInfo[] };
+	} catch (e) {
+		log.warn('admin/text-gen', 'backend unreachable', { err: String(e) });
+		return { models: [] as TextModelInfo[] };
+	}
+};

ui/src/routes/admin/text-gen/+page.svelte

@@ -0,0 +1,508 @@
+<script lang="ts">
+	import type { PageData } from './$types';
+	import type { TextModelInfo } from './+page.server';
+
+	let { data }: { data: PageData } = $props();
+
+	const models = data.models as TextModelInfo[];
+
+	// ── Shared ────────────────────────────────────────────────────────────────────
+	type ActiveTab = 'chapters' | 'description';
+	let activeTab = $state<ActiveTab>('chapters');
+	let selectedModel = $state(models[0]?.id ?? '');
+
+	let selectedModelInfo = $derived(models.find((m) => m.id === selectedModel) ?? null);
+
+	function fmtCtx(n: number) {
+		if (n >= 1000) return `${(n / 1000).toFixed(0)}k ctx`;
+		return `${n} ctx`;
+	}
+
+	// ── Chapter names state ───────────────────────────────────────────────────────
+	let chSlug = $state('');
+	let chPattern = $state('Chapter {n}: {scene}');
+	let chGenerating = $state(false);
+	let chError = $state('');
+
+	interface ProposedChapter {
+		number: number;
+		old_title: string;
+		new_title: string;
+		// editable copy
+		edited: string;
+	}
+	let chProposals = $state<ProposedChapter[]>([]);
+	let chRawResponse = $state('');
+	let chUsedModel = $state('');
+	let chShowRaw = $state(false);
+
+	let chApplying = $state(false);
+	let chApplyError = $state('');
+	let chApplySuccess = $state(false);
+
+	let chCanGenerate = $derived(chSlug.trim().length > 0 && chPattern.trim().length > 0 && !chGenerating);
+	let chCanApply = $derived(chProposals.length > 0 && !chApplying);
+
+	async function generateChapterNames() {
+		if (!chCanGenerate) return;
+		chGenerating = true;
+		chError = '';
+		chProposals = [];
+		chApplySuccess = false;
+		chApplyError = '';
+
+		try {
+			const res = await fetch('/api/admin/text-gen/chapter-names', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					slug: chSlug.trim(),
+					pattern: chPattern.trim(),
+					model: selectedModel
+				})
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) {
+				chError = body.error ?? body.message ?? `Error ${res.status}`;
+				return;
+			}
+			chProposals = ((body.chapters ?? []) as { number: number; old_title: string; new_title: string }[]).map(
+				(p) => ({ ...p, edited: p.new_title })
+			);
+			chRawResponse = body.raw_response ?? '';
+			chUsedModel = body.model ?? '';
+		} catch {
+			chError = 'Network error.';
+		} finally {
+			chGenerating = false;
+		}
+	}
+
+	async function applyChapterNames() {
+		if (!chCanApply) return;
+		chApplying = true;
+		chApplyError = '';
+		chApplySuccess = false;
+
+		try {
+			const res = await fetch('/api/admin/text-gen/chapter-names/apply', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					slug: chSlug.trim(),
+					chapters: chProposals.map((p) => ({ number: p.number, title: p.edited.trim() || p.new_title }))
+				})
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) {
+				chApplyError = body.error ?? body.message ?? `Error ${res.status}`;
+				return;
+			}
+			chApplySuccess = true;
+		} catch {
+			chApplyError = 'Network error.';
+		} finally {
+			chApplying = false;
+		}
+	}
+
+	// ── Description state ─────────────────────────────────────────────────────────
+	let dSlug = $state('');
+	let dInstructions = $state('');
+	let dGenerating = $state(false);
+	let dError = $state('');
+
+	let dOldDesc = $state('');
+	let dNewDesc = $state('');
+	let dUsedModel = $state('');
+
+	let dApplying = $state(false);
+	let dApplyError = $state('');
+	let dApplySuccess = $state(false);
+
+	let dCanGenerate = $derived(dSlug.trim().length > 0 && !dGenerating);
+	let dCanApply = $derived(dNewDesc.trim().length > 0 && !dApplying);
+
+	async function generateDescription() {
+		if (!dCanGenerate) return;
+		dGenerating = true;
+		dError = '';
+		dOldDesc = '';
+		dNewDesc = '';
+		dApplySuccess = false;
+		dApplyError = '';
+
+		try {
+			const res = await fetch('/api/admin/text-gen/description', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					slug: dSlug.trim(),
+					instructions: dInstructions.trim(),
+					model: selectedModel
+				})
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) {
+				dError = body.error ?? body.message ?? `Error ${res.status}`;
+				return;
+			}
+			dOldDesc = body.old_description ?? '';
+			dNewDesc = body.new_description ?? '';
+			dUsedModel = body.model ?? '';
+		} catch {
+			dError = 'Network error.';
+		} finally {
+			dGenerating = false;
+		}
+	}
+
+	async function applyDescription() {
+		if (!dCanApply) return;
+		dApplying = true;
+		dApplyError = '';
+		dApplySuccess = false;
+
+		try {
+			const res = await fetch('/api/admin/text-gen/description/apply', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					slug: dSlug.trim(),
+					description: dNewDesc.trim()
+				})
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) {
+				dApplyError = body.error ?? body.message ?? `Error ${res.status}`;
+				return;
+			}
+			dApplySuccess = true;
+		} catch {
+			dApplyError = 'Network error.';
+		} finally {
+			dApplying = false;
+		}
+	}
+</script>
+
+<svelte:head>
+	<title>Text Gen — Admin</title>
+</svelte:head>
+
+<div class="space-y-6 max-w-5xl">
+	<!-- Header -->
+	<div>
+		<h1 class="text-2xl font-bold text-(--color-text)">Text Generation</h1>
+		<p class="text-(--color-muted) text-sm mt-1">
+			Generate chapter titles and book descriptions using Cloudflare Workers AI.
+		</p>
+	</div>
+
+	<!-- Model selector (shared) -->
+	<div class="space-y-1 max-w-md">
+		<label class="text-xs font-medium text-(--color-muted) uppercase tracking-wide" for="model-select">
+			Model
+		</label>
+		<select
+			id="model-select"
+			bind:value={selectedModel}
+			class="w-full bg-(--color-surface-2) border border-(--color-border) rounded-lg px-3 py-2 text-(--color-text) text-sm focus:outline-none focus:ring-2 focus:ring-(--color-brand)"
+		>
+			{#each models as m}
+				<option value={m.id}>{m.label} — {m.provider} ({fmtCtx(m.context_size)})</option>
+			{/each}
+		</select>
+		{#if selectedModelInfo}
+			<p class="text-xs text-(--color-muted)">{selectedModelInfo.description}</p>
+		{/if}
+	</div>
+
+	<!-- Tab toggle -->
+	<div class="flex gap-1 bg-(--color-surface-2) rounded-lg p-1 w-fit border border-(--color-border)">
+		{#each (['chapters', 'description'] as const) as t}
+			<button
+				onclick={() => (activeTab = t)}
+				class="px-4 py-1.5 rounded-md text-sm font-medium transition-colors
+					{activeTab === t
+						? 'bg-(--color-surface-3) text-(--color-text)'
+						: 'text-(--color-muted) hover:text-(--color-text)'}"
+			>
+				{t === 'chapters' ? 'Chapter Names' : 'Description'}
+			</button>
+		{/each}
+	</div>
+
+	<!-- ── Chapter names panel ────────────────────────────────────────────────── -->
+	{#if activeTab === 'chapters'}
+		<div class="grid grid-cols-1 lg:grid-cols-2 gap-6 items-start">
+			<!-- Left: form -->
+			<div class="space-y-4">
+				<div class="space-y-1">
+					<label class="text-xs font-medium text-(--color-muted) uppercase tracking-wide" for="ch-slug">
+						Book slug
+					</label>
+					<input
+						id="ch-slug"
+						type="text"
+						bind:value={chSlug}
+						placeholder="e.g. shadow-slave"
+						class="w-full bg-(--color-surface-2) border border-(--color-border) rounded-lg px-3 py-2 text-(--color-text) text-sm placeholder-zinc-500 focus:outline-none focus:ring-2 focus:ring-(--color-brand)"
+					/>
+				</div>
+
+				<div class="space-y-1">
+					<label class="text-xs font-medium text-(--color-muted) uppercase tracking-wide" for="ch-pattern">
+						Naming pattern
+					</label>
+					<input
+						id="ch-pattern"
+						type="text"
+						bind:value={chPattern}
+						placeholder="e.g. Chapter [n]: [brief scene description]"
+						class="w-full bg-(--color-surface-2) border border-(--color-border) rounded-lg px-3 py-2 text-(--color-text) text-sm placeholder-zinc-500 focus:outline-none focus:ring-2 focus:ring-(--color-brand)"
+					/>
+					<p class="text-xs text-(--color-muted)">
+						Describe the desired chapter title format. The AI will rename every chapter to match.
+					</p>
+				</div>
+
+				<button
+					onclick={generateChapterNames}
+					disabled={!chCanGenerate}
+					class="w-full py-2.5 rounded-lg bg-(--color-brand) text-(--color-surface) font-semibold text-sm
+						hover:bg-(--color-brand-dim) transition-colors disabled:opacity-50 disabled:cursor-not-allowed
+						flex items-center justify-center gap-2"
+				>
+					{#if chGenerating}
+						<svg class="w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24">
+							<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4" />
+							<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z" />
+						</svg>
+						Generating…
+					{:else}
+						Generate proposals
+					{/if}
+				</button>
+
+				{#if chError}
+					<p class="text-sm text-(--color-danger) bg-(--color-danger)/10 rounded-lg px-3 py-2">{chError}</p>
+				{/if}
+			</div>
+
+			<!-- Right: proposals -->
+			<div class="space-y-4">
+				{#if chProposals.length > 0}
+					<div class="space-y-2">
+						<div class="flex items-center justify-between">
+							<p class="text-xs font-semibold text-(--color-muted) uppercase tracking-widest">
+								{chProposals.length} proposals
+								{#if chUsedModel}
+									<span class="normal-case font-normal">· {chUsedModel.split('/').pop()}</span>
+								{/if}
+							</p>
+							<button
+								onclick={() => (chShowRaw = !chShowRaw)}
+								class="text-xs text-(--color-muted) hover:text-(--color-text) transition-colors"
+							>
+								{chShowRaw ? 'Hide raw' : 'Show raw'}
+							</button>
+						</div>
+
+						{#if chShowRaw}
+							<pre class="text-xs bg-(--color-surface-2) border border-(--color-border) rounded-lg p-3 overflow-auto max-h-40 text-(--color-muted)">{chRawResponse}</pre>
+						{/if}
+
+						<div class="max-h-[28rem] overflow-y-auto space-y-2 pr-1">
+							{#each chProposals as proposal}
+								<div class="bg-(--color-surface) border border-(--color-border) rounded-lg p-3 space-y-1.5">
+									<div class="flex items-center gap-2">
+										<span class="text-xs font-mono text-(--color-muted) w-8 shrink-0">#{proposal.number}</span>
+										<p class="text-xs text-(--color-muted) line-through truncate flex-1" title={proposal.old_title}>
+											{proposal.old_title}
+										</p>
+									</div>
+									<input
+										type="text"
+										bind:value={proposal.edited}
+										class="w-full bg-(--color-surface-2) border border-(--color-border) rounded-md px-2.5 py-1.5 text-(--color-text) text-sm focus:outline-none focus:ring-1 focus:ring-(--color-brand)"
+									/>
+								</div>
+							{/each}
+						</div>
+
+						<div class="flex gap-2 pt-1">
+							<button
+								onclick={applyChapterNames}
+								disabled={!chCanApply}
+								class="flex-1 py-2 rounded-lg bg-(--color-brand) text-(--color-surface) font-semibold text-sm
+									hover:bg-(--color-brand-dim) transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+							>
+								{chApplying ? 'Saving…' : chApplySuccess ? 'Saved ✓' : `Apply ${chProposals.length} titles`}
+							</button>
+							<button
+								onclick={() => { chProposals = []; chRawResponse = ''; chApplySuccess = false; }}
+								class="px-4 py-2 rounded-lg bg-(--color-surface-2) text-(--color-muted) text-sm
+									hover:text-(--color-text) transition-colors border border-(--color-border)"
+							>
+								Clear
+							</button>
+						</div>
+
+						{#if chApplyError}
+							<p class="text-sm text-(--color-danger) bg-(--color-danger)/10 rounded-lg px-3 py-2">{chApplyError}</p>
+						{/if}
+						{#if chApplySuccess}
+							<p class="text-sm text-green-400 bg-green-400/10 rounded-lg px-3 py-2">
+								{chProposals.length} chapter titles saved successfully.
+							</p>
+						{/if}
+					</div>
+				{:else if chGenerating}
+					<div class="flex items-center justify-center bg-(--color-surface) border border-(--color-border) rounded-xl h-48">
+						<div class="text-center space-y-3">
+							<svg class="w-8 h-8 animate-spin mx-auto text-(--color-brand)" fill="none" viewBox="0 0 24 24">
+								<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4" />
+								<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z" />
+							</svg>
+							<p class="text-sm text-(--color-muted)">Generating chapter titles…</p>
+						</div>
+					</div>
+				{:else}
+					<div class="flex items-center justify-center bg-(--color-surface) border border-(--color-border) border-dashed rounded-xl h-48">
+						<p class="text-sm text-(--color-muted)">Proposed titles will appear here</p>
+					</div>
+				{/if}
+			</div>
+		</div>
+	{/if}
+
+	<!-- ── Description panel ──────────────────────────────────────────────────── -->
+	{#if activeTab === 'description'}
+		<div class="grid grid-cols-1 lg:grid-cols-2 gap-6 items-start">
+			<!-- Left: form -->
+			<div class="space-y-4">
+				<div class="space-y-1">
+					<label class="text-xs font-medium text-(--color-muted) uppercase tracking-wide" for="d-slug">
+						Book slug
+					</label>
+					<input
+						id="d-slug"
+						type="text"
+						bind:value={dSlug}
+						placeholder="e.g. shadow-slave"
+						class="w-full bg-(--color-surface-2) border border-(--color-border) rounded-lg px-3 py-2 text-(--color-text) text-sm placeholder-zinc-500 focus:outline-none focus:ring-2 focus:ring-(--color-brand)"
+					/>
+				</div>
+
+				<div class="space-y-1">
+					<label class="text-xs font-medium text-(--color-muted) uppercase tracking-wide" for="d-instructions">
+						Instructions <span class="normal-case font-normal text-(--color-muted)">(optional)</span>
+					</label>
+					<textarea
+						id="d-instructions"
+						bind:value={dInstructions}
+						rows="3"
+						placeholder="e.g. Write a 3-sentence blurb, avoid spoilers, dramatic tone."
+						class="w-full bg-(--color-surface-2) border border-(--color-border) rounded-lg px-3 py-2 text-(--color-text) text-sm placeholder-zinc-500 focus:outline-none focus:ring-2 focus:ring-(--color-brand) resize-y"
+					></textarea>
+				</div>
+
+				<button
+					onclick={generateDescription}
+					disabled={!dCanGenerate}
+					class="w-full py-2.5 rounded-lg bg-(--color-brand) text-(--color-surface) font-semibold text-sm
+						hover:bg-(--color-brand-dim) transition-colors disabled:opacity-50 disabled:cursor-not-allowed
+						flex items-center justify-center gap-2"
+				>
+					{#if dGenerating}
+						<svg class="w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24">
+							<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4" />
+							<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z" />
+						</svg>
+						Generating…
+					{:else}
+						Generate description
+					{/if}
+				</button>
+
+				{#if dError}
+					<p class="text-sm text-(--color-danger) bg-(--color-danger)/10 rounded-lg px-3 py-2">{dError}</p>
+				{/if}
+			</div>
+
+			<!-- Right: result -->
+			<div class="space-y-4">
+				{#if dNewDesc || dOldDesc}
+					<div class="space-y-4">
+						{#if dOldDesc}
+							<div class="space-y-1">
+								<p class="text-xs font-semibold text-(--color-muted) uppercase tracking-widest">Current description</p>
+								<div class="bg-(--color-surface) border border-(--color-border) rounded-lg p-3">
+									<p class="text-sm text-(--color-muted) whitespace-pre-wrap">{dOldDesc}</p>
+								</div>
+							</div>
+						{/if}
+
+						{#if dNewDesc}
+							<div class="space-y-1">
+								<div class="flex items-center justify-between">
+									<p class="text-xs font-semibold text-(--color-muted) uppercase tracking-widest">
+										Proposed description
+										{#if dUsedModel}
+											<span class="normal-case font-normal">· {dUsedModel.split('/').pop()}</span>
+										{/if}
+									</p>
+								</div>
+								<textarea
+									bind:value={dNewDesc}
+									rows="6"
+									class="w-full bg-(--color-surface-2) border border-(--color-border) rounded-lg px-3 py-2 text-(--color-text) text-sm focus:outline-none focus:ring-2 focus:ring-(--color-brand) resize-y"
+								></textarea>
+							</div>
+
+							<div class="flex gap-2">
+								<button
+									onclick={applyDescription}
+									disabled={!dCanApply}
+									class="flex-1 py-2 rounded-lg bg-(--color-brand) text-(--color-surface) font-semibold text-sm
+										hover:bg-(--color-brand-dim) transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+								>
+									{dApplying ? 'Saving…' : dApplySuccess ? 'Saved ✓' : 'Apply description'}
+								</button>
+								<button
+									onclick={() => { dNewDesc = ''; dOldDesc = ''; dApplySuccess = false; }}
+									class="px-4 py-2 rounded-lg bg-(--color-surface-2) text-(--color-muted) text-sm
+										hover:text-(--color-text) transition-colors border border-(--color-border)"
+								>
+									Clear
+								</button>
+							</div>
+
+							{#if dApplyError}
+								<p class="text-sm text-(--color-danger) bg-(--color-danger)/10 rounded-lg px-3 py-2">{dApplyError}</p>
+							{/if}
+							{#if dApplySuccess}
+								<p class="text-sm text-green-400 bg-green-400/10 rounded-lg px-3 py-2">Description saved successfully.</p>
+							{/if}
+						{/if}
+					</div>
+				{:else if dGenerating}
+					<div class="flex items-center justify-center bg-(--color-surface) border border-(--color-border) rounded-xl h-48">
+						<div class="text-center space-y-3">
+							<svg class="w-8 h-8 animate-spin mx-auto text-(--color-brand)" fill="none" viewBox="0 0 24 24">
+								<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4" />
+								<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z" />
+							</svg>
+							<p class="text-sm text-(--color-muted)">Generating description…</p>
+						</div>
+					</div>
+				{:else}
+					<div class="flex items-center justify-center bg-(--color-surface) border border-(--color-border) border-dashed rounded-xl h-48">
+						<p class="text-sm text-(--color-muted)">Proposed description will appear here</p>
+					</div>
+				{/if}
+			</div>
+		</div>
+	{/if}
+</div>

ui/src/routes/api/admin/image-gen/save-cover/+server.ts

@@ -0,0 +1,35 @@
+/**
+ * POST /api/admin/image-gen/save-cover
+ *
+ * Admin-only proxy: persists a pre-generated base64 image as a book cover in
+ * MinIO without re-calling Cloudflare AI.
+ *
+ * Body: { slug: string, image_b64: string }
+ */
+
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { log } from '$lib/server/logger';
+import { backendFetch } from '$lib/server/scraper';
+
+export const POST: RequestHandler = async ({ request, locals }) => {
+	if (!locals.user || locals.user.role !== 'admin') {
+		throw error(403, 'Forbidden');
+	}
+
+	const body = await request.text();
+	let res: Response;
+	try {
+		res = await backendFetch('/api/admin/image-gen/save-cover', {
+			method: 'POST',
+			headers: { 'content-type': 'application/json' },
+			body
+		});
+	} catch (e) {
+		log.error('admin/image-gen/save-cover', 'backend proxy error', { err: String(e) });
+		throw error(502, 'Could not reach backend');
+	}
+
+	const data = await res.json().catch(() => ({}));
+	return json(data, { status: res.status });
+};

ui/src/routes/api/admin/text-gen/chapter-names/+server.ts

@@ -0,0 +1,33 @@
+/**
+ * POST /api/admin/text-gen/chapter-names
+ *
+ * Admin-only proxy to the Go backend's chapter-name generation endpoint.
+ * Returns AI-proposed chapter titles; does NOT persist anything.
+ */
+
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { log } from '$lib/server/logger';
+import { backendFetch } from '$lib/server/scraper';
+
+export const POST: RequestHandler = async ({ request, locals }) => {
+	if (!locals.user || locals.user.role !== 'admin') {
+		throw error(403, 'Forbidden');
+	}
+
+	const body = await request.text();
+	let res: Response;
+	try {
+		res = await backendFetch('/api/admin/text-gen/chapter-names', {
+			method: 'POST',
+			headers: { 'content-type': 'application/json' },
+			body
+		});
+	} catch (e) {
+		log.error('admin/text-gen/chapter-names', 'backend proxy error', { err: String(e) });
+		throw error(502, 'Could not reach backend');
+	}
+
+	const data = await res.json().catch(() => ({}));
+	return json(data, { status: res.status });
+};

ui/src/routes/api/admin/text-gen/chapter-names/apply/+server.ts

@@ -0,0 +1,32 @@
+/**
+ * POST /api/admin/text-gen/chapter-names/apply
+ *
+ * Admin-only proxy to persist confirmed chapter titles to PocketBase.
+ */
+
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { log } from '$lib/server/logger';
+import { backendFetch } from '$lib/server/scraper';
+
+export const POST: RequestHandler = async ({ request, locals }) => {
+	if (!locals.user || locals.user.role !== 'admin') {
+		throw error(403, 'Forbidden');
+	}
+
+	const body = await request.text();
+	let res: Response;
+	try {
+		res = await backendFetch('/api/admin/text-gen/chapter-names/apply', {
+			method: 'POST',
+			headers: { 'content-type': 'application/json' },
+			body
+		});
+	} catch (e) {
+		log.error('admin/text-gen/chapter-names/apply', 'backend proxy error', { err: String(e) });
+		throw error(502, 'Could not reach backend');
+	}
+
+	const data = await res.json().catch(() => ({}));
+	return json(data, { status: res.status });
+};

ui/src/routes/api/admin/text-gen/description/+server.ts

@@ -0,0 +1,33 @@
+/**
+ * POST /api/admin/text-gen/description
+ *
+ * Admin-only proxy to the Go backend's book description generation endpoint.
+ * Returns an AI-proposed description; does NOT persist anything.
+ */
+
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { log } from '$lib/server/logger';
+import { backendFetch } from '$lib/server/scraper';
+
+export const POST: RequestHandler = async ({ request, locals }) => {
+	if (!locals.user || locals.user.role !== 'admin') {
+		throw error(403, 'Forbidden');
+	}
+
+	const body = await request.text();
+	let res: Response;
+	try {
+		res = await backendFetch('/api/admin/text-gen/description', {
+			method: 'POST',
+			headers: { 'content-type': 'application/json' },
+			body
+		});
+	} catch (e) {
+		log.error('admin/text-gen/description', 'backend proxy error', { err: String(e) });
+		throw error(502, 'Could not reach backend');
+	}
+
+	const data = await res.json().catch(() => ({}));
+	return json(data, { status: res.status });
+};

ui/src/routes/api/admin/text-gen/description/apply/+server.ts

@@ -0,0 +1,32 @@
+/**
+ * POST /api/admin/text-gen/description/apply
+ *
+ * Admin-only proxy to persist the confirmed book description to PocketBase.
+ */
+
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { log } from '$lib/server/logger';
+import { backendFetch } from '$lib/server/scraper';
+
+export const POST: RequestHandler = async ({ request, locals }) => {
+	if (!locals.user || locals.user.role !== 'admin') {
+		throw error(403, 'Forbidden');
+	}
+
+	const body = await request.text();
+	let res: Response;
+	try {
+		res = await backendFetch('/api/admin/text-gen/description/apply', {
+			method: 'POST',
+			headers: { 'content-type': 'application/json' },
+			body
+		});
+	} catch (e) {
+		log.error('admin/text-gen/description/apply', 'backend proxy error', { err: String(e) });
+		throw error(502, 'Could not reach backend');
+	}
+
+	const data = await res.json().catch(() => ({}));
+	return json(data, { status: res.status });
+};

ui/src/routes/api/admin/text-gen/models/+server.ts

@@ -0,0 +1,17 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { backendFetch } from '$lib/server/scraper';
+
+export const GET: RequestHandler = async ({ locals }) => {
+	if (!locals.user || locals.user.role !== 'admin') {
+		throw error(403, 'Forbidden');
+	}
+	let res: Response;
+	try {
+		res = await backendFetch('/api/admin/text-gen/models');
+	} catch {
+		throw error(502, 'Could not reach backend');
+	}
+	const data = await res.json().catch(() => ({}));
+	return json(data, { status: res.status });
+};

ui/src/routes/books/[slug]/chapters/[n]/+page.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
 	import { onMount, untrack, getContext } from 'svelte';
+	import { browser } from '$app/environment';
 	import { goto } from '$app/navigation';
 	import { page } from '$app/state';
 	import AudioPlayer from '$lib/components/AudioPlayer.svelte';
@@ -56,7 +57,114 @@
 		if (settingsCtx) settingsCtx.fontSize = v;
 	}
 
-	// Translation state
+	// ── Layout / reading-view prefs (localStorage) ──────────────────────────────
+	type ReadMode    = 'scroll' | 'paginated';
+	type LineSpacing = 'compact' | 'normal' | 'relaxed';
+	type ReadWidth   = 'narrow' | 'normal' | 'wide';
+	type ParaStyle   = 'spaced' | 'indented';
+
+	interface LayoutPrefs {
+		readMode:    ReadMode;
+		lineSpacing: LineSpacing;
+		readWidth:   ReadWidth;
+		paraStyle:   ParaStyle;
+		focusMode:   boolean;
+	}
+
+	const LAYOUT_KEY = 'reader_layout_v1';
+	const LINE_HEIGHTS: Record<LineSpacing, number> = { compact: 1.55, normal: 1.85, relaxed: 2.2 };
+	const READ_WIDTHS:  Record<ReadWidth,   string>  = { narrow: '58ch', normal: '72ch', wide: 'min(90ch, 100%)' };
+	const DEFAULT_LAYOUT: LayoutPrefs = { readMode: 'scroll', lineSpacing: 'normal', readWidth: 'normal', paraStyle: 'spaced', focusMode: false };
+
+	function loadLayout(): LayoutPrefs {
+		if (!browser) return DEFAULT_LAYOUT;
+		try {
+			const raw = localStorage.getItem(LAYOUT_KEY);
+			if (raw) return { ...DEFAULT_LAYOUT, ...JSON.parse(raw) as Partial<LayoutPrefs> };
+		} catch { /* ignore */ }
+		return DEFAULT_LAYOUT;
+	}
+
+	let layout = $state<LayoutPrefs>(loadLayout());
+
+	function setLayout<K extends keyof LayoutPrefs>(key: K, value: LayoutPrefs[K]) {
+		layout = { ...layout, [key]: value };
+		if (browser) localStorage.setItem(LAYOUT_KEY, JSON.stringify(layout));
+	}
+
+	// Apply reading CSS vars whenever layout changes
+	$effect(() => {
+		if (!browser) return;
+		document.documentElement.style.setProperty('--reading-line-height', String(LINE_HEIGHTS[layout.lineSpacing]));
+		document.documentElement.style.setProperty('--reading-max-width', READ_WIDTHS[layout.readWidth]);
+	});
+
+	// ── Scroll progress bar ──────────────────────────────────────────────────────
+	let scrollProgress = $state(0);
+
+	$effect(() => {
+		if (!browser || layout.readMode === 'paginated') { scrollProgress = 0; return; }
+		function onScroll() {
+			const el = document.documentElement;
+			const max = el.scrollHeight - el.clientHeight;
+			scrollProgress = max > 0 ? el.scrollTop / max : 0;
+		}
+		window.addEventListener('scroll', onScroll, { passive: true });
+		return () => window.removeEventListener('scroll', onScroll);
+	});
+
+	// ── Paginated mode ───────────────────────────────────────────────────────────
+	let pageIndex = $state(0);
+	let totalPages = $state(1);
+	let paginatedContainerEl = $state<HTMLDivElement | null>(null);
+	let paginatedContentEl   = $state<HTMLDivElement | null>(null);
+	let containerH = $state(0);
+
+	$effect(() => {
+		if (layout.readMode !== 'paginated') { pageIndex = 0; totalPages = 1; return; }
+		// Re-run when html changes or container is bound
+		void html; void paginatedContainerEl; void paginatedContentEl;
+		requestAnimationFrame(() => {
+			if (!paginatedContainerEl || !paginatedContentEl) return;
+			const h = paginatedContainerEl.clientHeight;
+			if (h > 0) {
+				containerH = h;
+				totalPages = Math.max(1, Math.ceil(paginatedContentEl.scrollHeight / h));
+				pageIndex = Math.min(pageIndex, totalPages - 1);
+			}
+		});
+	});
+
+	// Reset page index when chapter changes
+	$effect(() => { void data.chapter.number; pageIndex = 0; });
+
+	function handlePaginatedClick(e: MouseEvent) {
+		const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
+		if (e.clientX - rect.left > rect.width / 2) {
+			if (pageIndex < totalPages - 1) pageIndex++;
+		} else {
+			if (pageIndex > 0) pageIndex--;
+		}
+	}
+
+	// Keyboard nav for paginated mode
+	$effect(() => {
+		if (!browser) return;
+		function onKey(e: KeyboardEvent) {
+			if (layout.readMode !== 'paginated') return;
+			if (e.key === 'ArrowRight' || e.key === 'PageDown' || e.key === ' ') {
+				e.preventDefault();
+				if (pageIndex < totalPages - 1) pageIndex++;
+			} else if (e.key === 'ArrowLeft' || e.key === 'PageUp') {
+				e.preventDefault();
+				if (pageIndex > 0) pageIndex--;
+			}
+		}
+		window.addEventListener('keydown', onKey);
+		return () => window.removeEventListener('keydown', onKey);
+	});
+
+	// ── Translation state
 	const SUPPORTED_LANGS = [
 		{ code: 'ru', label: 'RU' },
 		{ code: 'id', label: 'ID' },
@@ -189,6 +297,11 @@
 	<title>{data.chapter.title || m.reader_chapter_n({ n: String(data.chapter.number) })} — {data.book.title} — libnovel</title>
 </svelte:head>
 
+<!-- Reading progress bar (scroll mode) -->
+{#if layout.readMode === 'scroll'}
+<div class="reading-progress" style="width: {scrollProgress * 100}%"></div>
+{/if}
+
 <!-- Top nav -->
 <div class="flex items-center justify-between mb-6 gap-4">
 	<a
@@ -235,8 +348,8 @@
 	{/if}
 </div>
 
-<!-- Language switcher (not shown for preview chapters) -->
-{#if !data.isPreview}
+<!-- Language switcher (not shown for preview chapters or focus mode) -->
+{#if !data.isPreview && !layout.focusMode}
 <div class="flex items-center gap-2 mb-6 flex-wrap">
 	<span class="text-(--color-muted) text-xs">Read in:</span>
 
@@ -292,8 +405,8 @@
 </div>
 {/if}
 
-<!-- Audio player -->
-{#if !data.isPreview}
+<!-- Audio player (hidden in focus mode) -->
+{#if !data.isPreview && !layout.focusMode}
 {#if !page.data.user}
 	<!-- Unauthenticated: sign-in prompt -->
 	<div class="mb-6 px-4 py-3 rounded-lg bg-(--color-surface-2) border border-(--color-border) flex items-center justify-between gap-4">
@@ -353,13 +466,66 @@
 	<div class="text-(--color-muted) text-center py-16">
 		<p>{fetchError || m.reader_audio_error()}</p>
 	</div>
+{:else if layout.readMode === 'paginated'}
+	<!-- ── Paginated reader ─────────────────────────────────────────────── -->
+	<!-- svelte-ignore a11y_click_events_have_key_events a11y_no_static_element_interactions -->
+	<div
+		bind:this={paginatedContainerEl}
+		class="paginated-container mt-8"
+		style="height: {layout.focusMode ? 'calc(100svh - 8rem)' : 'calc(100svh - 26rem)'};"
+		onclick={handlePaginatedClick}
+	>
+		<div
+			bind:this={paginatedContentEl}
+			class="prose-chapter {layout.paraStyle === 'indented' ? 'para-indented' : ''}"
+			style="transform: translateY({containerH > 0 ? -(pageIndex * containerH) : 0}px);"
+		>
+			{@html html}
+		</div>
+	</div>
+
+	<!-- Page indicator + nav -->
+	<div class="flex items-center justify-between mt-4 select-none">
+		<button
+			type="button"
+			onclick={() => { if (pageIndex > 0) pageIndex--; }}
+			disabled={pageIndex === 0}
+			class="flex items-center gap-1.5 px-3 py-1.5 rounded-lg bg-(--color-surface-2) border border-(--color-border) text-sm text-(--color-muted) hover:text-(--color-text) disabled:opacity-30 transition-colors"
+		>
+			<svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+				<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"/>
+			</svg>
+			Prev
+		</button>
+
+		<span class="text-sm text-(--color-muted) tabular-nums">
+			{pageIndex + 1} <span class="opacity-40">/</span> {totalPages}
+		</span>
+
+		<button
+			type="button"
+			onclick={() => { if (pageIndex < totalPages - 1) pageIndex++; }}
+			disabled={pageIndex === totalPages - 1}
+			class="flex items-center gap-1.5 px-3 py-1.5 rounded-lg bg-(--color-surface-2) border border-(--color-border) text-sm text-(--color-muted) hover:text-(--color-text) disabled:opacity-30 transition-colors"
+		>
+			Next
+			<svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+				<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"/>
+			</svg>
+		</button>
+	</div>
+
+	<!-- Tap hint -->
+	<p class="text-center text-xs text-(--color-muted)/40 mt-2">Tap left/right · Arrow keys · Space</p>
 {:else}
-	<div class="prose-chapter mt-8">
+	<!-- ── Scroll reader ────────────────────────────────────────────────── -->
+	<div class="prose-chapter mt-8 {layout.paraStyle === 'indented' ? 'para-indented' : ''}">
 		{@html html}
 	</div>
 {/if}
 
-<!-- Bottom nav -->
+<!-- Bottom nav + comments (hidden in paginated focus mode) -->
+{#if !(layout.focusMode && layout.readMode === 'paginated')}
 <div class="flex justify-between mt-12 pt-6 border-t border-(--color-border) gap-4">
 	{#if data.prev}
 		<a
@@ -381,7 +547,6 @@
 	{/if}
 </div>
 
-<!-- Chapter comments -->
 <div class="mt-12">
 	<CommentsSection
 		slug={data.book.slug}
@@ -390,6 +555,7 @@
 		currentUserId={page.data.user?.id ?? ''}
 	/>
 </div>
+{/if}
 
 <!-- ── Floating reader settings ─────────────────────────────────────────── -->
 {#if settingsCtx}
@@ -480,6 +646,95 @@
 		</div>
 	</div>
 
+	<!-- Divider -->
+	<div class="border-t border-(--color-border)"></div>
+
+	<!-- Read mode -->
+	<div class="space-y-2">
+		<p class="text-xs text-(--color-muted)">Read mode</p>
+		<div class="flex gap-1.5">
+			{#each ([['scroll', 'Scroll'], ['paginated', 'Pages']] as const) as [mode, label]}
+				<button
+					type="button"
+					onclick={() => setLayout('readMode', mode)}
+					class="flex-1 py-1.5 rounded-lg border text-xs font-medium transition-colors
+						{layout.readMode === mode
+							? 'border-(--color-brand) bg-(--color-brand)/10 text-(--color-brand)'
+							: 'border-(--color-border) bg-(--color-surface-3) text-(--color-muted) hover:border-(--color-brand)/50 hover:text-(--color-text)'}"
+					aria-pressed={layout.readMode === mode}
+				>{label}</button>
+			{/each}
+		</div>
+	</div>
+
+	<!-- Line spacing -->
+	<div class="space-y-2">
+		<p class="text-xs text-(--color-muted)">Line spacing</p>
+		<div class="flex gap-1.5">
+			{#each ([['compact', 'Tight'], ['normal', 'Normal'], ['relaxed', 'Loose']] as const) as [s, label]}
+				<button
+					type="button"
+					onclick={() => setLayout('lineSpacing', s)}
+					class="flex-1 py-1.5 rounded-lg border text-xs font-medium transition-colors
+						{layout.lineSpacing === s
+							? 'border-(--color-brand) bg-(--color-brand)/10 text-(--color-brand)'
+							: 'border-(--color-border) bg-(--color-surface-3) text-(--color-muted) hover:border-(--color-brand)/50 hover:text-(--color-text)'}"
+					aria-pressed={layout.lineSpacing === s}
+				>{label}</button>
+			{/each}
+		</div>
+	</div>
+
+	<!-- Reading width -->
+	<div class="space-y-2">
+		<p class="text-xs text-(--color-muted)">Width</p>
+		<div class="flex gap-1.5">
+			{#each ([['narrow', 'Narrow'], ['normal', 'Normal'], ['wide', 'Wide']] as const) as [w, label]}
+				<button
+					type="button"
+					onclick={() => setLayout('readWidth', w)}
+					class="flex-1 py-1.5 rounded-lg border text-xs font-medium transition-colors
+						{layout.readWidth === w
+							? 'border-(--color-brand) bg-(--color-brand)/10 text-(--color-brand)'
+							: 'border-(--color-border) bg-(--color-surface-3) text-(--color-muted) hover:border-(--color-brand)/50 hover:text-(--color-text)'}"
+					aria-pressed={layout.readWidth === w}
+				>{label}</button>
+			{/each}
+		</div>
+	</div>
+
+	<!-- Paragraph style -->
+	<div class="space-y-2">
+		<p class="text-xs text-(--color-muted)">Paragraphs</p>
+		<div class="flex gap-1.5">
+			{#each ([['spaced', 'Spaced'], ['indented', 'Indented']] as const) as [s, label]}
+				<button
+					type="button"
+					onclick={() => setLayout('paraStyle', s)}
+					class="flex-1 py-1.5 rounded-lg border text-xs font-medium transition-colors
+						{layout.paraStyle === s
+							? 'border-(--color-brand) bg-(--color-brand)/10 text-(--color-brand)'
+							: 'border-(--color-border) bg-(--color-surface-3) text-(--color-muted) hover:border-(--color-brand)/50 hover:text-(--color-text)'}"
+					aria-pressed={layout.paraStyle === s}
+				>{label}</button>
+			{/each}
+		</div>
+	</div>
+
+	<!-- Focus mode -->
+	<button
+		type="button"
+		onclick={() => setLayout('focusMode', !layout.focusMode)}
+		class="w-full flex items-center justify-between py-2 px-3 rounded-lg border text-xs font-medium transition-colors
+			{layout.focusMode
+				? 'border-(--color-brand) bg-(--color-brand)/10 text-(--color-brand)'
+				: 'border-(--color-border) bg-(--color-surface-3) text-(--color-muted) hover:border-(--color-brand)/50 hover:text-(--color-text)'}"
+		aria-pressed={layout.focusMode}
+	>
+		<span>Focus mode</span>
+		<span class="opacity-60 text-xs">{layout.focusMode ? 'On — audio & nav hidden' : 'Off'}</span>
+	</button>
+
 	<p class="text-xs text-(--color-muted)/60 text-center">Changes save automatically</p>
 </div>
 {/if}