diff --git a/src/downloader/downloader.go b/src/downloader/downloader.go
index 8dc4d65b..dd3cd173 100644
--- a/src/downloader/downloader.go
+++ b/src/downloader/downloader.go
@@ -264,9 +264,15 @@ func (c *DownloadClient) MoveDownload(srcDir, destDir, trackPath string, track *
 	}()
 
 	var dstFile string
-
+	
 	if c.Cfg.PathTemplate != "" {
 		relativePath := buildTrackPath(c.Cfg.PathTemplate, track)
+		track.File = filepath.Base(relativePath)
+		if track.File == "." || track.File == string(filepath.Separator) {
+			track.File = getFilename(track.CleanTitle, track.MainArtist) + filepath.Ext(track.File)
+			relativePath = filepath.Dir(relativePath) + string(filepath.Separator) + track.File
+			slog.Warn(fmt.Sprintf("invalid path template result for track '%s' by '%s', using filename '%s' instead", track.Title, track.Artist, track.File))
+		}
 		dstFile = filepath.Join(destDir, relativePath)
 	} else {
 		if err = os.MkdirAll(destDir, os.ModePerm); err != nil {
diff --git a/src/web/backend/defs.go b/src/web/backend/defs.go
index b5b7b97e..8a22deea 100644
--- a/src/web/backend/defs.go
+++ b/src/web/backend/defs.go
@@ -156,7 +156,7 @@ var allConfigKeys = []string{
 	"ON_REPEAT_SCHEDULE", "ON_REPEAT_FLAGS",
 	"EXPLO_SYSTEM", "SYSTEM_URL", "API_KEY", "LIBRARY_NAME",
 	"SYSTEM_USERNAME", "SYSTEM_PASSWORD", "PLAYLIST_DIR", "SLEEP", "PUBLIC_PLAYLIST",
-	"DOWNLOAD_DIR", "USE_SUBDIRECTORY",
+	"DOWNLOAD_DIR", "USE_SUBDIRECTORY", "PATH_TEMPLATE", "ENRICH_TRACK_METADATA",
 	"DOWNLOAD_SERVICES", "YOUTUBE_API_KEY", "TRACK_EXTENSION", "FILTER_LIST",
 	"SLSKD_URL", "SLSKD_API_KEY",
 	"WIZARD_COMPLETE", "MIGRATE_DOWNLOADS", "EXTENSIONS",
diff --git a/src/web/backend/path_templates.go b/src/web/backend/path_templates.go
new file mode 100644
index 00000000..0617a65b
--- /dev/null
+++ b/src/web/backend/path_templates.go
@@ -0,0 +1,112 @@
+package backend
+
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// PathTemplatePreset is a named folder-structure template saved by the user.
+type PathTemplatePreset struct {
+	Name     string `json:"name"`
+	Template string `json:"template"`
+}
+
+func pathTemplatesFilePath(cfgDir string) string {
+	return filepath.Join(cfgDir, "path-templates.json")
+}
+
+func loadPathTemplates(cfgDir string) []PathTemplatePreset {
+	data, err := os.ReadFile(pathTemplatesFilePath(cfgDir))
+	if err != nil {
+		return nil
+	}
+	var out []PathTemplatePreset
+	if err := json.Unmarshal(data, &out); err != nil {
+		slog.Warn("path-templates: failed to parse", "err", err)
+		return nil
+	}
+	return out
+}
+
+func savePathTemplates(cfgDir string, presets []PathTemplatePreset) error {
+	raw, err := json.MarshalIndent(presets, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(pathTemplatesFilePath(cfgDir), raw, 0644)
+}
+
+// handlePathTemplates handles GET and POST for /api/ui/path-templates.
+func (s *Server) handlePathTemplates(w http.ResponseWriter, r *http.Request) {
+	cfgDir := s.cfg.WebDataDir
+	switch r.Method {
+	case http.MethodGet:
+		presets := loadPathTemplates(cfgDir)
+		if presets == nil {
+			presets = []PathTemplatePreset{}
+		}
+		w.Header().Set("Content-Type", "application/json")
+		if err := json.NewEncoder(w).Encode(presets); err != nil {
+			slog.Error("failed encoding path templates", "err", err.Error())
+		}
+	case http.MethodPost:
+		var body PathTemplatePreset
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			http.Error(w, "invalid JSON: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		if body.Name == "" || body.Template == "" {
+			http.Error(w, "name and template are required", http.StatusBadRequest)
+			return
+		}
+		presets := loadPathTemplates(cfgDir)
+		presets = append(presets, body)
+		if err := savePathTemplates(cfgDir, presets); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		if err := json.NewEncoder(w).Encode(body); err != nil {
+			slog.Error("failed encoding path template", "err", err.Error())
+		}
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+// handleDeletePathTemplate handles DELETE /api/ui/path-templates/{name}.
+func (s *Server) handleDeletePathTemplate(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodDelete {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	raw := strings.TrimPrefix(r.URL.Path, "/api/ui/path-templates/")
+	name, err := url.PathUnescape(raw)
+	if err != nil || name == "" {
+		http.Error(w, "invalid name", http.StatusBadRequest)
+		return
+	}
+	cfgDir := s.cfg.WebDataDir
+	presets := loadPathTemplates(cfgDir)
+	filtered := presets[:0]
+	for _, p := range presets {
+		if p.Name != name {
+			filtered = append(filtered, p)
+		}
+	}
+	if len(filtered) == len(presets) {
+		http.Error(w, "not found", http.StatusNotFound)
+		return
+	}
+	if err := savePathTemplates(cfgDir, filtered); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
diff --git a/src/web/backend/server.go b/src/web/backend/server.go
index 5b808e8c..b00431e2 100644
--- a/src/web/backend/server.go
+++ b/src/web/backend/server.go
@@ -243,6 +243,20 @@ func (s *Server) registerRoutes() {
 	s.mux.Handle("/api/ui/config/raw", s.authStore.RequireAuth(http.HandlerFunc(s.handleGetConfigRaw)))
 	s.mux.Handle("/api/ui/config/reset", s.authStore.RequireAuth(http.HandlerFunc(s.handleResetConfig)))
 	s.mux.Handle("/api/ui/config/schedules", s.authStore.RequireAuth(http.HandlerFunc(s.handleSaveSchedule)))
+	s.mux.Handle("/api/ui/config/path-template", s.authStore.RequireAuth(http.HandlerFunc(s.handleSavePathTemplate)))
+	s.mux.Handle("/api/ui/config/enrich-metadata", s.authStore.RequireAuth(http.HandlerFunc(s.handleSaveEnrichMetadata)))
+
+	// Path template presets: GET list, POST add; DELETE per name under prefix
+	s.mux.HandleFunc("/api/ui/path-templates", func(w http.ResponseWriter, r *http.Request) {
+		s.authStore.RequireAuth(http.HandlerFunc(s.handlePathTemplates)).ServeHTTP(w, r)
+	})
+	s.mux.HandleFunc("/api/ui/path-templates/", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == http.MethodDelete {
+			s.authStore.RequireAuth(http.HandlerFunc(s.handleDeletePathTemplate)).ServeHTTP(w, r)
+			return
+		}
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	})
 
 	// Wizard steps (POST) — require auth
 	s.mux.Handle("/api/ui/wizard/step1", s.authStore.RequireAuth(http.HandlerFunc(s.handleWizardStep1)))
@@ -272,16 +286,19 @@ func (s *Server) registerRoutes() {
 		}
 	})
 	// ID-specific routes: DELETE /api/ui/custom-playlists/{id} and POST .../{id}/refresh
-	s.mux.HandleFunc("/api/ui/custom-playlists/", func(w http.ResponseWriter, r *http.Request) {
-		if r.Method == http.MethodDelete {
-			s.authStore.RequireAuth(http.HandlerFunc(s.handleDeleteCustomPlaylist)).ServeHTTP(w, r)
+	s.mux.HandleFunc("/api/ui/custom-playlists/{id}/refresh", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 			return
 		}
-		if r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/refresh") {
-			s.authStore.RequireAuth(http.HandlerFunc(s.handleRefreshCustomPlaylist)).ServeHTTP(w, r)
+		s.authStore.RequireAuth(http.HandlerFunc(s.handleRefreshCustomPlaylist)).ServeHTTP(w, r)
+	})
+	s.mux.HandleFunc("/api/ui/custom-playlists/{id}", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodDelete {
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 			return
 		}
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		s.authStore.RequireAuth(http.HandlerFunc(s.handleDeleteCustomPlaylist)).ServeHTTP(w, r)
 	})
 
 	s.mux.Handle("/api/ui/logout", s.authStore.RequireAuth(http.HandlerFunc(s.handleLogout)))
@@ -566,6 +583,50 @@ func (s *Server) handleSaveSchedule(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }
 
+// handleSavePathTemplate writes the PATH_TEMPLATE key to the .env file.
+func (s *Server) handleSavePathTemplate(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Template string `json:"template"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		http.Error(w, "invalid JSON: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+	if err := updateEnvKeys(s.cfg.WebEnvPath, map[string]string{"PATH_TEMPLATE": body.Template}, web.SampleEnv); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// handleSaveEnrichMetadata writes ENRICH_METADATA=true/false to the .env file.
+func (s *Server) handleSaveEnrichMetadata(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Enabled bool `json:"enabled"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		http.Error(w, "invalid JSON: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+	val := "false"
+	if body.Enabled {
+		val = "true"
+	}
+	if err := updateEnvKeys(s.cfg.WebEnvPath, map[string]string{"ENRICH_TRACK_METADATA": val}, web.SampleEnv); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
 // updateEnvKeys reads the env file (falling back to fallback if missing), updates the
 // given key=value pairs in-place preserving comments, and writes the result back.
 func updateEnvKeys(path string, updates map[string]string, fallback []byte) error {
diff --git a/src/web/frontend/src/components/Settings.jsx b/src/web/frontend/src/components/Settings.jsx
index 1e803ad1..61c1757f 100644
--- a/src/web/frontend/src/components/Settings.jsx
+++ b/src/web/frontend/src/components/Settings.jsx
@@ -14,7 +14,8 @@ import { useState, useEffect, useCallback, useRef } from 'react'
 import {
   fetchConfig, fetchConfigRaw, saveConfig, resetConfig,
   saveSchedule, startRun, stopRun, fetchRunStatus, fetchLogs,
-  fetchCustomPlaylists, deleteCustomPlaylist,
+  fetchCustomPlaylists, deleteCustomPlaylist, savePathTemplate, saveEnrichMetadata,
+  fetchPathTemplatePresets, addPathTemplatePreset, deletePathTemplatePreset,
 } from '../lib/api'
 import { parseSlogLine, cronToFields, highlightEnv } from '../lib/utils'
 import { fetchPlaylistTracks } from '../lib/listenbrainz'
@@ -23,6 +24,7 @@ import { Toggle } from './ui/Toggle'
 import { Button, SectionLabel, Panel, LogRow } from './ui/common'
 import { PlaylistCard, TracklistDropdown } from './ui/PlaylistCard'
 import { ImportModal } from './ui/ImportModal'
+import { SEED_PRESETS, PathLine, PathTemplateModal } from './ui/PathTemplateModal'
 import { UpdateNotification } from './ui/UpdateNotification'
 
 const tabBtnCls = active =>
@@ -488,6 +490,287 @@ function HomeSection() {
   )
 }
 
+// ── Download Path Tab ─────────────────────────────────────────────────────────
+// Profile-picker for the PATH_TEMPLATE env key. Users select a preset folder
+// structure (or author their own via the modal) and apply it. Pending changes
+// are previewed inline before being written to .env via the confirm bar.
+
+
+function DownloadPathSection() {
+  const [profiles, setProfiles] = useState(() => SEED_PRESETS.map(p => ({ ...p, seed: true })))
+  const [appliedIdx, setAppliedIdx] = useState(null)
+  const [selectedIdx, setSelectedIdx] = useState(null)
+  const [loaded, setLoaded] = useState(false)
+  const [saveStatus, setSaveStatus] = useState('')
+  const [showModal, setShowModal] = useState(false)
+  const [openMenuIdx, setOpenMenuIdx] = useState(null)
+  const [enrichEnabled, setEnrichEnabled] = useState(false)
+  const [templateEnabled, setTemplateEnabled] = useState(false)
+
+  useEffect(() => {
+    Promise.all([
+      fetchConfig(),
+      fetchPathTemplatePresets().catch(() => []),
+    ]).then(([{ values }, jsonPresets]) => {
+      const allProfiles = [
+        ...SEED_PRESETS.map(p => ({ ...p, seed: true })),
+        ...jsonPresets,
+      ]
+      setEnrichEnabled(values.ENRICH_TRACK_METADATA === 'true')
+      const t = values.PATH_TEMPLATE || ''
+      if (t) {
+        setTemplateEnabled(true)
+        const idx = allProfiles.findIndex(p => p.template === t)
+        if (idx >= 0) {
+          setProfiles(allProfiles)
+          setAppliedIdx(idx)
+          setSelectedIdx(idx)
+        } else {
+          const customIdx = allProfiles.length
+          setProfiles([...allProfiles, { name: 'Custom', template: t }])
+          setAppliedIdx(customIdx)
+          setSelectedIdx(customIdx)
+        }
+      } else {
+        setProfiles(allProfiles)
+      }
+      setLoaded(true)
+    })
+  }, [])
+
+  const handleEnrichToggle = async () => {
+    const next = !enrichEnabled
+    setEnrichEnabled(next)
+    try { await saveEnrichMetadata(next) } catch { setEnrichEnabled(!next) }
+  }
+
+  const handleTemplateToggle = async () => {
+    if (templateEnabled) {
+      setTemplateEnabled(false)
+      setAppliedIdx(null)
+      setSelectedIdx(null)
+      try { await savePathTemplate('') } catch { setTemplateEnabled(true) }
+    } else {
+      setTemplateEnabled(true)
+      if (selectedIdx === null) setSelectedIdx(0)
+    }
+  }
+
+  useEffect(() => {
+    if (!showModal) return
+    const handle = e => { e.preventDefault(); e.returnValue = '' }
+    window.addEventListener('beforeunload', handle)
+    return () => window.removeEventListener('beforeunload', handle)
+  }, [showModal])
+
+  useEffect(() => {
+    if (openMenuIdx === null) return
+    const handle = () => setOpenMenuIdx(null)
+    document.addEventListener('click', handle)
+    return () => document.removeEventListener('click', handle)
+  }, [openMenuIdx])
+
+  const dirty = selectedIdx !== appliedIdx
+
+  if (!loaded) return null
+
+  const handleDeleteProfile = async (i) => {
+    const profile = profiles[i]
+    if (!profile.seed) {
+      try { await deletePathTemplatePreset(profile.name) } catch {}
+    }
+    const newApplied = appliedIdx === i ? null : appliedIdx !== null && appliedIdx > i ? appliedIdx - 1 : appliedIdx
+    const newSelected = selectedIdx === i ? newApplied : selectedIdx !== null && selectedIdx > i ? selectedIdx - 1 : selectedIdx
+    setProfiles(prev => prev.filter((_, j) => j !== i))
+    setAppliedIdx(newApplied)
+    setSelectedIdx(newSelected)
+    setOpenMenuIdx(null)
+  }
+  const previewTemplate = selectedIdx !== null
+    ? (profiles[selectedIdx]?.template ?? SEED_PRESETS[0].template)
+    : SEED_PRESETS[0].template
+
+  const handleSave = async () => {
+    const t = selectedIdx !== null ? profiles[selectedIdx].template : ''
+    try {
+      await savePathTemplate(t)
+      setAppliedIdx(selectedIdx)
+      setSaveStatus('Saved.')
+      setTimeout(() => setSaveStatus(''), 2500)
+    } catch {
+      setSaveStatus('Error saving.')
+    }
+  }
+
+  const handleSavePreset = async ({ name, template }) => {
+    try { await addPathTemplatePreset(name, template) } catch {}
+    const newIdx = profiles.length
+    setProfiles(prev => [...prev, { name, template }])
+    setSelectedIdx(newIdx)
+    setShowModal(false)
+  }
+
+  return (
+    <div className="mt-6">
+      <SectionLabel>Folder Structure</SectionLabel>
+      {/* ENRICH_METADATA toggle */}
+      <div className="flex items-start justify-between mt-3 mb-1 gap-4">
+        <div className="flex flex-col gap-0.5">
+          <span className="text-[13px] text-white">Auto-tag songs</span>
+          <span className="text-[11px] text-muted">Looks up track numbers, year, genre & more from MusicBrainz and writes them to downloaded files.</span>
+        </div>
+        <button
+          role="switch"
+          aria-checked={enrichEnabled}
+          onClick={handleEnrichToggle}
+          className={`relative inline-flex h-[22px] w-10 shrink-0 cursor-pointer rounded-full transition-colors duration-200 ${enrichEnabled ? 'bg-accent' : 'bg-[#383838]'}`}
+        >
+          <span className={`inline-block h-[18px] w-[18px] my-[2px] rounded-full bg-white shadow transition-transform duration-200 ${enrichEnabled ? 'translate-x-[20px]' : 'translate-x-[2px]'}`} />
+        </button>
+      </div>
+
+      {/* Organize into folders toggle */}
+      <div className="flex items-start justify-between mt-3 mb-1 gap-4">
+        <div className="flex flex-col gap-0.5">
+          <span className="text-[13px] text-white">Organize into folders</span>
+          <span className="text-[11px] text-muted">Sort downloads into subfolders by artist, album, etc.</span>
+        </div>
+        <button
+          role="switch"
+          aria-checked={templateEnabled}
+          onClick={handleTemplateToggle}
+          className={`relative inline-flex h-[22px] w-10 shrink-0 cursor-pointer rounded-full transition-colors duration-200 ${templateEnabled ? 'bg-accent' : 'bg-[#383838]'}`}
+        >
+          <span className={`inline-block h-[18px] w-[18px] my-[2px] rounded-full bg-white shadow transition-transform duration-200 ${templateEnabled ? 'translate-x-[20px]' : 'translate-x-[2px]'}`} />
+        </button>
+      </div>
+
+      {templateEnabled && (<>
+      {/* Current / pending path readout */}
+      <div className="flex items-baseline gap-2.5 overflow-x-auto py-1 mt-6">
+        <span className={`text-[11px] shrink-0 transition-colors ${dirty ? 'text-accent' : 'text-muted'}`}>
+          {dirty ? 'Preview:' : 'Active:'}
+        </span>
+        <div className="text-[13px] font-medium whitespace-nowrap">
+          <PathLine template={previewTemplate} />
+        </div>
+      </div>
+
+      {/* Profile card grid */}
+      <div className="grid grid-cols-1 min-[520px]:grid-cols-2 min-[720px]:grid-cols-4 gap-3 mt-2">
+        {profiles.map((profile, i) => {
+          const isSelected = i === selectedIdx
+          return (
+            <div
+              key={i}
+              onClick={() => setSelectedIdx(i)}
+              className={`group relative flex flex-col gap-2.5 p-4 bg-transparent rounded-[8px] cursor-pointer select-none transition-all duration-[120ms] border
+                ${isSelected
+                  ? 'border-accent'
+                  : 'border-ui-border hover:border-[#404040] hover:-translate-y-px'}`}
+              style={{ minHeight: 112, ...(isSelected ? { boxShadow: '0 0 0 3px rgba(30,215,96,0.14)' } : {}) }}
+            >
+              <div className="flex items-start justify-between gap-1.5">
+                <span className="text-[14px] font-medium text-white leading-snug">{profile.name}</span>
+                <div className="flex items-center gap-1.5 shrink-0">
+                  {!profile.seed && (
+                    <div className="relative" onClick={e => e.stopPropagation()}>
+                      <button
+                        onClick={e => { e.stopPropagation(); setOpenMenuIdx(openMenuIdx === i ? null : i) }}
+                        className="opacity-0 group-hover:opacity-100 transition-opacity bg-transparent border-none text-muted hover:text-white text-[15px] leading-none cursor-pointer px-1 py-0"
+                        title="Options"
+                      >
+                        ···
+                      </button>
+                      {openMenuIdx === i && (
+                        <div className="absolute right-0 top-full mt-1 bg-well border border-ui-border rounded-[6px] z-10 py-1 min-w-[80px]"
+                          style={{ boxShadow: '0 8px 24px #00000066' }}
+                        >
+                          <button
+                            onClick={() => handleDeleteProfile(i)}
+                            className="w-full text-left px-3 py-1.5 text-[12px] text-danger hover:bg-well transition-colors cursor-pointer bg-transparent border-none whitespace-nowrap"
+                          >
+                            Delete
+                          </button>
+                        </div>
+                      )}
+                    </div>
+                  )}
+                </div>
+              </div>
+              <div className="mt-auto pt-2.5 border-t border-dashed border-ui-border">
+                <div className="text-[11px] leading-relaxed">
+                  <PathLine template={profile.template} />
+                </div>
+              </div>
+            </div>
+          )
+        })}
+
+        {/* New template card */}
+        <div
+          onClick={() => setShowModal(true)}
+          className="flex flex-col items-center justify-center gap-2 p-4 bg-transparent rounded-[8px] border border-dashed border-ui-border cursor-pointer transition-colors text-muted hover:text-accent hover:border-accent"
+          style={{ minHeight: 112 }}
+        >
+          <span className="text-[26px] leading-none">+</span>
+          <span className="text-[13px]">New template</span>
+        </div>
+      </div>
+
+      {/* Confirm bar */}
+      <AnimatePresence>
+        {dirty && (
+          <motion.div
+            key="confirmbar"
+            initial={{ opacity: 0, y: 6 }}
+            animate={{ opacity: 1, y: 0 }}
+            exit={{ opacity: 0, y: 6 }}
+            transition={{ duration: 0.2 }}
+            className="flex items-center gap-4 mt-5"
+          >
+            <span className="mr-auto text-[12px] text-muted">
+              {saveStatus || 'Preview only — not applied yet.'}
+            </span>
+            <button
+              onClick={() => setSelectedIdx(appliedIdx)}
+              className="bg-transparent border-none text-muted text-[13px] cursor-pointer p-0 hover:text-white transition-colors"
+            >
+              Cancel
+            </button>
+            <Button onClick={handleSave}>
+              Save folder structure
+            </Button>
+          </motion.div>
+        )}
+        {!dirty && saveStatus && (
+          <motion.p
+            key="savestatus"
+            initial={{ opacity: 0 }}
+            animate={{ opacity: 1 }}
+            exit={{ opacity: 0 }}
+            className="text-[12px] text-accent mt-4"
+          >
+            {saveStatus}
+          </motion.p>
+        )}
+      </AnimatePresence>
+
+      </>)}
+
+      <AnimatePresence>
+        {showModal && (
+          <PathTemplateModal
+            onClose={() => setShowModal(false)}
+            onSave={handleSavePreset}
+            enrichEnabled={enrichEnabled}
+          />
+        )}
+      </AnimatePresence>
+    </div>
+  )
+}
+
 // ── Config Tab ────────────────────────────────────────────────────────────────
 // Raw .env file viewer/editor, plus wizard re-run and full reset actions.
 // Fetches its own raw config text from the API.
@@ -545,7 +828,7 @@ function ConfigSection({ onWizard }) {
         {!editing ? (
           <pre
             className="bg-well border border-ui-border rounded-[6px] w-full h-[420px] overflow-y-auto p-3.5 font-mono text-[12px] leading-relaxed whitespace-pre break-normal"
-            dangerouslySetInnerHTML={{ __html: highlightEnv(rawConfig) }}
+            dangerouslySetInnerHTML={{ __html: highlightEnv(rawConfig, true) }}
           />
         ) : (
           <textarea
@@ -560,6 +843,8 @@ function ConfigSection({ onWizard }) {
         )}
       </div>
 
+      <DownloadPathSection />
+
       <div className="mt-6">
         <SectionLabel>Setup</SectionLabel>
         <div className="flex flex-col items-start gap-2.5">
diff --git a/src/web/frontend/src/components/ui/PathTemplateModal.jsx b/src/web/frontend/src/components/ui/PathTemplateModal.jsx
new file mode 100644
index 00000000..9693302f
--- /dev/null
+++ b/src/web/frontend/src/components/ui/PathTemplateModal.jsx
@@ -0,0 +1,198 @@
+import { useState, useEffect, useRef } from 'react'
+import { motion, AnimatePresence } from 'motion/react'
+import { Button } from './common'
+
+export const SEED_PRESETS = [
+  { name: 'Artist / Album / Track', template: '{{Artist}}/{{Album}}/{{TrackName}}.{{ext}}' },
+  { name: 'Flat',                   template: '{{Artist}} - {{TrackName}}.{{ext}}' },
+]
+
+// enriched: requires ENRICH_METADATA=true (or a source that provides the field)
+const TEMPLATE_VARS = [
+  { name: 'Artist',      example: 'Radiohead',     enriched: false },
+  { name: 'Album',       example: 'OK Computer',   enriched: false },
+  { name: 'TrackName',   example: 'Karma Police',  enriched: false },
+  { name: 'ext',         example: 'flac',          enriched: false },
+  { name: 'TrackNumber', example: '03',            enriched: true  },
+  { name: 'DiscNumber',  example: '01',            enriched: true  },
+  { name: 'Year',        example: '1997',          enriched: true  },
+  { name: 'File',        example: 'filename',      enriched: false },
+]
+
+const SAMPLE_META = {
+  Artist: 'Radiohead', Album: 'OK Computer', AlbumName: 'OK Computer',
+  TrackName: 'Karma Police', TrackNumber: '03', DiscNumber: '01',
+  Year: '1997', File: 'karma_police', ext: 'flac',
+}
+
+function sanitizeSegment(v) {
+  return String(v).replace(/[/\\:*?"<>|]/g, '')
+}
+
+function resolveTemplate(tpl) {
+  return tpl.replace(/\{\{\s*([A-Za-z]+)\s*\}\}/g, (_, name) => {
+    const key = Object.keys(SAMPLE_META).find(k => k.toLowerCase() === name.toLowerCase())
+    return key ? sanitizeSegment(SAMPLE_META[key]) : `{{${name}}}`
+  })
+}
+
+export function PathLine({ template }) {
+  const parts = resolveTemplate(template).split('/')
+  return parts.map((part, i) => {
+    const isFile = i === parts.length - 1 && part.includes('.')
+    return (
+      <span key={i}>
+        {i > 0 && <span className="text-white px-[3px]" style={{ opacity: 0.25 }}>/</span>}
+        <span className={isFile ? 'text-accent' : 'text-white'}>{part || '·'}</span>
+      </span>
+    )
+  })
+}
+
+// Props:
+//   onClose       — called on cancel / backdrop / Escape
+//   onSave        — called with { name, template } when user saves the preset
+//   enrichEnabled — whether rich metadata is on; gates enriched variable chips
+export function PathTemplateModal({ onClose, onSave, enrichEnabled = false }) {
+  const [name, setName] = useState('')
+  const [template, setTemplate] = useState(SEED_PRESETS[0].template)
+  const nameInputRef = useRef(null)
+  const templateInputRef = useRef(null)
+
+  useEffect(() => {
+    const handle = e => { if (e.key === 'Escape') onClose() }
+    window.addEventListener('keydown', handle)
+    setTimeout(() => nameInputRef.current?.focus(), 60)
+    return () => window.removeEventListener('keydown', handle)
+  }, [onClose])
+
+  const insertVariable = varName => {
+    const input = templateInputRef.current
+    if (!input) return
+    const token = `{{${varName}}}`
+    const start = input.selectionStart ?? template.length
+    const end = input.selectionEnd ?? template.length
+    const next = template.slice(0, start) + token + template.slice(end)
+    setTemplate(next)
+    const pos = start + token.length
+    setTimeout(() => { input.focus(); input.setSelectionRange(pos, pos) }, 0)
+  }
+
+  const handleSave = () => {
+    onSave({ name: name.trim() || 'Custom template', template })
+  }
+
+  return (
+    <motion.div
+      key="modal-overlay"
+      initial={{ opacity: 0 }}
+      animate={{ opacity: 1 }}
+      exit={{ opacity: 0 }}
+      transition={{ duration: 0.16 }}
+      onClick={e => { if (e.target === e.currentTarget) onClose() }}
+      style={{
+        position: 'fixed', inset: 0, zIndex: 50,
+        background: 'rgba(0,0,0,0.72)',
+        backdropFilter: 'blur(6px)',
+        WebkitBackdropFilter: 'blur(6px)',
+        display: 'flex', alignItems: 'center', justifyContent: 'center',
+        padding: 24,
+      }}
+    >
+      <motion.div
+        key="modal-dialog"
+        initial={{ opacity: 0, y: 8 }}
+        animate={{ opacity: 1, y: 0 }}
+        exit={{ opacity: 0, y: 8 }}
+        transition={{ duration: 0.18 }}
+        className="w-full max-w-[540px] border border-ui-border rounded-lg overflow-hidden"
+        style={{
+          background: '#0d0d0df0',
+          backdropFilter: 'blur(8px)',
+          WebkitBackdropFilter: 'blur(8px)',
+          boxShadow: '0 24px 64px #00000099',
+        }}
+      >
+        {/* Header */}
+        <div className="flex items-center justify-between px-5 py-4 border-b border-ui-border">
+          <span className="text-[15px] font-semibold text-white whitespace-nowrap">New folder template</span>
+          <button
+            onClick={onClose}
+            className="text-muted text-[22px] leading-none cursor-pointer bg-transparent border-none px-1 hover:text-white transition-colors"
+          >
+            ×
+          </button>
+        </div>
+
+        {/* Body */}
+        <div className="px-5 pt-5 pb-2">
+          <input
+            ref={nameInputRef}
+            className="w-full bg-transparent border-none text-accent text-[16px] font-semibold outline-none placeholder:text-muted placeholder:font-normal mb-5"
+            placeholder="Template name"
+            value={name}
+            onChange={e => setName(e.target.value)}
+            spellCheck={false}
+          />
+
+          <div className="border-t border-ui-border pt-4 flex flex-col gap-3">
+            <input
+              ref={templateInputRef}
+              className="w-full bg-well border border-ui-border text-white rounded-[6px] px-3 py-2.5 text-[13px] outline-none focus:border-accent transition-colors"
+              value={template}
+              onChange={e => setTemplate(e.target.value)}
+              spellCheck={false}
+              autoComplete="off"
+              autoCorrect="off"
+              autoCapitalize="off"
+            />
+
+            <div className="flex items-baseline gap-2 px-0.5 overflow-x-auto">
+              <span className="text-white shrink-0" style={{ opacity: 0.25 }}>→</span>
+              <div className="text-[13px] font-medium whitespace-nowrap">
+                <PathLine template={template} />
+              </div>
+            </div>
+
+            <div className="flex flex-wrap gap-2 pt-1">
+              {TEMPLATE_VARS.map(({ name: varName, example, enriched }) => {
+                const locked = enriched && !enrichEnabled
+                return (
+                  <button
+                    key={varName}
+                    onClick={() => !locked && insertVariable(varName)}
+                    title={locked ? 'Enable rich metadata in settings to use this variable' : undefined}
+                    className={`flex items-baseline gap-1.5 bg-surface border rounded-[6px] px-2.5 py-1.5 text-[12px] transition-colors
+                      ${locked
+                        ? 'border-ui-border text-muted opacity-40 cursor-not-allowed'
+                        : 'border-ui-border text-white cursor-pointer hover:border-accent hover:text-accent'}`}
+                  >
+                    {varName}
+                    <span className="text-[10px] text-muted">{example}</span>
+                  </button>
+                )
+              })}
+            </div>
+
+            <p className="text-[11px] text-muted mb-3 leading-relaxed">
+              Click a variable to insert it at the cursor. Dimmed variables require <span className="text-white">Auto-tag</span> to be enabled in settings. Illegal path characters are stripped automatically.
+            </p>
+          </div>
+        </div>
+
+        {/* Footer */}
+        <div className="flex items-center justify-end gap-3 px-5 pb-5">
+          <button
+            onClick={onClose}
+            className="bg-transparent border-none text-muted text-[13px] cursor-pointer p-0 hover:text-white transition-colors"
+          >
+            Cancel
+          </button>
+          <Button onClick={handleSave} style={{ background: 'transparent' }}>
+            Save preset
+          </Button>
+        </div>
+      </motion.div>
+    </motion.div>
+  )
+}
diff --git a/src/web/frontend/src/components/ui/common.jsx b/src/web/frontend/src/components/ui/common.jsx
index d155601b..0d90b879 100644
--- a/src/web/frontend/src/components/ui/common.jsx
+++ b/src/web/frontend/src/components/ui/common.jsx
@@ -5,7 +5,7 @@ import { forwardRef } from 'react'
 export function Button({ children, className = '', ...props }) {
   return (
     <button
-      className={`bg-surface border border-ui-border text-white rounded-[6px] px-[18px] py-[7px] text-[13px] cursor-pointer hover:border-accent transition-colors disabled:opacity-40 disabled:cursor-not-allowed ${className}`}
+      className={`bg-transparent border border-ui-border text-white rounded-[6px] px-[18px] py-[7px] text-[13px] cursor-pointer hover:border-accent transition-colors disabled:opacity-40 disabled:cursor-not-allowed ${className}`}
       {...props}
     >
       {children}
diff --git a/src/web/frontend/src/lib/api.js b/src/web/frontend/src/lib/api.js
index dc2eb493..4920bf27 100644
--- a/src/web/frontend/src/lib/api.js
+++ b/src/web/frontend/src/lib/api.js
@@ -192,6 +192,45 @@ export async function refreshCustomPlaylist(id) {
   return res.json()
 }
 
+export async function savePathTemplate(template) {
+  const res = await apiFetch('/api/ui/config/path-template', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ template }),
+  })
+  if (!res.ok) throw new Error(await res.text())
+}
+
+export async function fetchPathTemplatePresets() {
+  const res = await apiFetch('/api/ui/path-templates')
+  if (!res.ok) throw new Error(await res.text())
+  return res.json()
+}
+
+export async function addPathTemplatePreset(name, template) {
+  const res = await apiFetch('/api/ui/path-templates', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name, template }),
+  })
+  if (!res.ok) throw new Error(await res.text())
+  return res.json()
+}
+
+export async function deletePathTemplatePreset(name) {
+  const res = await apiFetch(`/api/ui/path-templates/${encodeURIComponent(name)}`, { method: 'DELETE' })
+  if (!res.ok) throw new Error(await res.text())
+}
+
+export async function saveEnrichMetadata(enabled) {
+  const res = await apiFetch('/api/ui/config/enrich-metadata', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ enabled }),
+  })
+  if (!res.ok) throw new Error(await res.text())
+}
+
 export async function fetchBackgroundArt() {
   try {
     const res = await fetch('/api/ui/background-art')
diff --git a/src/web/frontend/src/lib/utils.js b/src/web/frontend/src/lib/utils.js
index 7d5a429d..56bbd2f1 100644
--- a/src/web/frontend/src/lib/utils.js
+++ b/src/web/frontend/src/lib/utils.js
@@ -2,7 +2,9 @@ function escHtml(s) {
   return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
 }
 
-export function highlightEnv(text) {
+const SENSITIVE_KEY_RE = /password|token|api_key|secret|accesstoken/i
+
+export function highlightEnv(text, masked = false) {
   return text.split('\n').map(line => {
     const trimmed = line.trim()
     if (!trimmed) return ''
@@ -12,7 +14,8 @@ export function highlightEnv(text) {
       const key = line.slice(0, eq)
       const val = line.slice(eq + 1).trim()
       if (!val) return `<span class="env-unset">${escHtml(line)}</span>`
-      return `<span class="env-key">${escHtml(key)}</span><span class="env-eq">=</span><span class="env-val">${escHtml(line.slice(eq + 1))}</span>`
+      const displayVal = (masked && SENSITIVE_KEY_RE.test(key)) ? '••••••••' : escHtml(line.slice(eq + 1))
+      return `<span class="env-key">${escHtml(key)}</span><span class="env-eq">=</span><span class="env-val">${displayVal}</span>`
     }
     return escHtml(line)
   }).join('\n')