Upload 8 files

public/2requirements.txt

@@ -0,0 +1,10 @@
+torch==2.1.0
+torchaudio==2.1.0
+audiocraft==0.0.1
+gradio==4.44.0
+gradio_client==1.3.0
+fastapi==0.115.0
+uvicorn==0.30.6
+pydub==0.25.1
+colorama==0.4.6
+numpy==1.26.4

public/example.md

@@ -0,0 +1,46 @@
+# 🎵 GhostAI Music Generator — Examples & Links
+
+**Release:** v0.9.5-rc2
+
+## Quick Start
+- Outputs save to **`./mp3/`**
+- Logs live at **`./logs/ghostai.log`** (single file, auto-truncates at 5 MB)
+- API server auto-starts at **`http://0.0.0.0:8555`**
+- UI runs at **`http://0.0.0.0:9999`**
+
+## Endpoints
+- Health: `GET /health`
+- Status: `GET /status`
+- Config: `GET /config`
+- Render: `POST /render`
+- Style prompts (examples):
+  - Metallica: `GET /set_classic_rock_prompt`
+  - Nirvana: `GET /set_nirvana_grunge_prompt`
+  - Pearl Jam: `GET /set_pearl_jam_grunge_prompt`
+  - Soundgarden: `GET /set_soundgarden_grunge_prompt`
+  - Foo Fighters: `GET /set_foo_fighters_prompt`
+  - RHCP: `GET /set_rhcp_prompt`
+  - Smashing Pumpkins: `GET /set_smashing_pumpkins_prompt`
+  - Radiohead: `GET /set_radiohead_prompt`
+  - Alt Rock: `GET /set_alternative_rock_prompt`
+  - Post-Punk: `GET /set_post_punk_prompt`
+  - Indie Rock: `GET /set_indie_rock_prompt`
+  - Funk Rock: `GET /set_funk_rock_prompt`
+  - Detroit Techno: `GET /set_detroit_techno_prompt`
+  - Deep House: `GET /set_deep_house_prompt`
+  - **Star Opera (Cinematic / “Star-Wars-style”)**: `GET /set_classical_star_opera_prompt`
+
+> Call a style endpoint to get a **fresh, varied prompt** for that genre.  
+> Then pass it into `/render` along with any overrides (BPM, duration, etc).
+
+## Links
+- Main HF repo: https://huggingface.co/ghostai1/GHOSTSONAFB  
+- README: https://huggingface.co/ghostai1/GHOSTSONAFB/blob/main/README.md  
+- MusicGen Large: https://huggingface.co/facebook/musicgen-large  
+- MusicGen Medium: https://huggingface.co/facebook/musicgen-medium  
+
+## Notes
+- Built for 30xx GPUs with **12 GB+ VRAM** (SM80).  
+- **Chunking**: renders in 30-second segments with seamless crossfades.  
+- **DSP chain**: gate → stereo balance → RMS normalize (-23dBFS) → EQ → fades → final SR.  
+- **Bitrates/SR/Bit depth** quick-buttons in UI.  

public/example_page.md

@@ -1,25 +1,22 @@
-<!-- docs/example_page.md -->
-# GhostAI Music Generator — Quick Links
-
-
-<audio controls src="https://cdn-uploads.huggingface.co/production/uploads/6421b1c68adc8881b974a89d/h9EL4d5bvjKFnC0v39386.mpga"></audio>
-
-- **MusicGen Large (Meta):** https://huggingface.co/facebook/musicgen-large  
-- **GhostAI assets & scripts:**  
-  - Repo hub: https://huggingface.co/ghostai1/GHOSTSONAFB  
-  - Stable 12GB build (example): https://huggingface.co/ghostai1/GHOSTSONAFB/blob/main/STABLE12gb3060.py  
-  - 30s large script: https://huggingface.co/ghostai1/GHOSTSONAFB/blob/main/stable12gblg30sec.py
-
-## Notes
-- GPU: CUDA-capable, 12GB+ VRAM recommended.
-- The app exposes an API on `:8555`:
-  - `GET /genres` — list available presets from `prompts.ini`
-  - `GET /prompt/{name}` — generate a prompt string (query params: `bpm`, `drum_beat`, `synthesizer`, `rhythmic_steps`, `bass_style`, `guitar_style`)
-  - **Aliases from INI** (examples):
-    - `/set_classic_rock_prompt` → Metallica
-    - `/set_nirvana_grunge_prompt` → Nirvana
-    - `/set_pearl_jam_grunge_prompt` → Pearl Jam
-    - `/set_soundgarden_grunge_prompt` → Soundgarden
-    - `/set_foo_fighters_prompt` → Foo Fighters
-    - `/set_star_wars_prompt` → Cinematic Star Wars-style orchestral
-  - `POST /render` — render an MP3. Body includes `instrumental_prompt` and optional overrides (duration, temperature, etc.).
+<!-- docs/example_page.md -->
+# GhostAI Music Generator — Quick Links
+
+- **MusicGen Large (Meta):** https://huggingface.co/facebook/musicgen-large  
+- **GhostAI assets & scripts:**  
+  - Repo hub: https://huggingface.co/ghostai1/GHOSTSONAFB  
+  - Stable 12GB build (example): https://huggingface.co/ghostai1/GHOSTSONAFB/blob/main/STABLE12gb3060.py  
+  - 30s large script: https://huggingface.co/ghostai1/GHOSTSONAFB/blob/main/stable12gblg30sec.py
+
+## Notes
+- GPU: CUDA-capable, 12GB+ VRAM recommended.
+- The app exposes an API on `:8555`:
+  - `GET /genres` — list available presets from `prompts.ini`
+  - `GET /prompt/{name}` — generate a prompt string (query params: `bpm`, `drum_beat`, `synthesizer`, `rhythmic_steps`, `bass_style`, `guitar_style`)
+  - **Aliases from INI** (examples):
+    - `/set_classic_rock_prompt` → Metallica
+    - `/set_nirvana_grunge_prompt` → Nirvana
+    - `/set_pearl_jam_grunge_prompt` → Pearl Jam
+    - `/set_soundgarden_grunge_prompt` → Soundgarden
+    - `/set_foo_fighters_prompt` → Foo Fighters
+    - `/set_star_wars_prompt` → Cinematic Star Wars-style orchestral
+  - `POST /render` — render an MP3. Body includes `instrumental_prompt` and optional overrides (duration, temperature, etc.).

public/prompts.ini

@@ -1,18 +1,22 @@
-# prompts.ini
-# Centralized prompt knobs for buttons + API aliases
-# Add/adjust sections; the app auto-loads buttons and endpoints.
+; All styles live here. Buttons + API endpoints are auto-generated from this file.
+; Add/modify sections and restart app to reflect changes.
 
 [metallica]
+label=Metallica (Thrash)
 bpm_min=90
 bpm_max=140
 drum_beat=standard rock,techno kick
 synthesizer=none
 rhythmic_steps=steady steps,complex steps
 bass_style=deep bass,melodic bass
-guitar_style=distorted
+guitar_style=distorted,downpicked,thrash riffing
+mood=aggressive,driving,epic
+structure=intro,verse,chorus,solo,outro
 api_name=/set_classic_rock_prompt
+prompt_template=Instrumental thrash metal by Metallica{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
 
 [nirvana]
+label=Nirvana (Grunge)
 bpm_min=100
 bpm_max=130
 drum_beat=standard rock
@@ -20,9 +24,13 @@ synthesizer=none
 rhythmic_steps=steady steps
 bass_style=deep bass
 guitar_style=distorted,clean
+mood=raw,lo-fi,urgent
+structure=intro,verse,chorus,bridge,outro
 api_name=/set_nirvana_grunge_prompt
+prompt_template=Instrumental grunge by Nirvana{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
 
 [pearl_jam]
+label=Pearl Jam (Grunge)
 bpm_min=100
 bpm_max=140
 drum_beat=standard rock
@@ -30,9 +38,13 @@ synthesizer=none
 rhythmic_steps=steady steps,syncopated steps
 bass_style=melodic bass
 guitar_style=clean,distorted
+mood=emotional,anthemic,nostalgic
+structure=intro,verse,chorus,solo,outro
 api_name=/set_pearl_jam_grunge_prompt
+prompt_template=Instrumental grunge by Pearl Jam{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
 
 [soundgarden]
+label=Soundgarden (Grunge/Alt Metal)
 bpm_min=90
 bpm_max=130
 drum_beat=standard rock
@@ -40,9 +52,13 @@ synthesizer=none
 rhythmic_steps=complex steps
 bass_style=deep bass
 guitar_style=distorted
+mood=heavy,psychedelic,sludgy
+structure=intro,riff,verse,chorus,outro
 api_name=/set_soundgarden_grunge_prompt
+prompt_template=Instrumental grunge with heavy metal influences by Soundgarden{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
 
 [foo_fighters]
+label=Foo Fighters (Alt Rock)
 bpm_min=110
 bpm_max=150
 drum_beat=standard rock
@@ -50,17 +66,147 @@ synthesizer=none
 rhythmic_steps=steady steps
 bass_style=melodic bass
 guitar_style=distorted,clean
+mood=anthemic,energetic,hooky
+structure=intro,verse,pre-chorus,chorus,outro
 api_name=/set_foo_fighters_prompt
+prompt_template=Instrumental alternative rock with post-grunge influences by Foo Fighters{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[red_hot_chili_peppers]
+label=Red Hot Chili Peppers (Funk Rock)
+bpm_min=90
+bpm_max=130
+drum_beat=standard rock,funk groove
+synthesizer=none
+rhythmic_steps=steady steps,syncopated steps
+bass_style=slap bass,melodic bass
+guitar_style=clean,distorted
+mood=funky,playful,energetic
+structure=intro,verse,chorus,breakdown,outro
+api_name=/set_rhcp_prompt
+prompt_template=Instrumental funk rock by Red Hot Chili Peppers{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[smashing_pumpkins]
+label=Smashing Pumpkins (Alt)
+bpm_min=90
+bpm_max=130
+drum_beat=standard rock
+synthesizer=lush synths,analog synth
+rhythmic_steps=steady steps
+bass_style=melodic bass
+guitar_style=dreamy,clean,distorted
+mood=dreamy,layered,melancholic
+structure=intro,verse,chorus,bridge,outro
+api_name=/set_smashing_pumpkins_prompt
+prompt_template=Instrumental alternative rock by Smashing Pumpkins{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[radiohead]
+label=Radiohead (Experimental)
+bpm_min=80
+bpm_max=120
+drum_beat=standard rock
+synthesizer=atmospheric synths,digital pad
+rhythmic_steps=syncopated steps,steady steps
+bass_style=hypnotic bass,melodic bass
+guitar_style=clean,experimental
+mood=moody,atmospheric,introspective
+structure=intro,texture build,groove,release,outro
+api_name=/set_radiohead_prompt
+prompt_template=Instrumental experimental rock by Radiohead{synth}{bass}{drum}{guitar}{rhythm}, {mood} {section} at {bpm} BPM.
 
-# New: Cinematic / Star Wars-inspired classical
-# Optional 'styles' enhances descriptive tags for orchestral color.
-[star_wars_classical]
+[alternative_rock]
+label=Alternative Rock (Pixies)
+bpm_min=100
+bpm_max=140
+drum_beat=standard rock
+synthesizer=none
+rhythmic_steps=steady steps
+bass_style=melodic bass
+guitar_style=distorted,clean
+mood=dynamic,loud-quiet-loud,edgy
+structure=intro,verse,chorus,quiet break,outro
+api_name=/set_alternative_rock_prompt
+prompt_template=Instrumental alternative rock by Pixies{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[post_punk]
+label=Post-Punk (Joy Division)
+bpm_min=90
+bpm_max=130
+drum_beat=precise drums,standard rock
+synthesizer=analog synth
+rhythmic_steps=steady steps
+bass_style=driving bass,melodic bass
+guitar_style=jangle,clean
+mood=dark,minimal,propulsive
+structure=intro,groove,build,climax,outro
+api_name=/set_post_punk_prompt
+prompt_template=Instrumental post-punk by Joy Division{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[indie_rock]
+label=Indie Rock (Arctic Monkeys)
+bpm_min=100
+bpm_max=140
+drum_beat=standard rock
+synthesizer=none
+rhythmic_steps=steady steps,syncopated steps
+bass_style=groovy bass,melodic bass
+guitar_style=jangle,clean,distorted
+mood=swagger,catchy,modern
+structure=intro,verse,chorus,bridge,outro
+api_name=/set_indie_rock_prompt
+prompt_template=Instrumental indie rock by Arctic Monkeys{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[funk_rock]
+label=Funk Rock (RATM)
+bpm_min=90
+bpm_max=120
+drum_beat=heavy drums,funk groove
+synthesizer=none
+rhythmic_steps=syncopated steps
+bass_style=slap bass,deep bass
+guitar_style=funky,distorted
+mood=aggressive,groovy,radical
+structure=intro,riff,verse,drop,chorus,outro
+api_name=/set_funk_rock_prompt
+prompt_template=Instrumental funk rock by Rage Against the Machine{guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[detroit_techno]
+label=Detroit Techno
+bpm_min=120
+bpm_max=135
+drum_beat=four-on-the-floor,techno kick
+synthesizer=pulsing synths,analog synth,arpeggiated synth
+rhythmic_steps=steady steps
+bass_style=driving bass,deep bass
+guitar_style=none
+mood=machine-soul,minimal,hypnotic
+structure=intro,groove,filter rise,peak,ride out
+api_name=/set_detroit_techno_prompt
+prompt_template=Instrumental Detroit techno by Juan Atkins{synth}{bass}{drum}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[deep_house]
+label=Deep House
+bpm_min=118
+bpm_max=125
+drum_beat=steady kick,four-on-the-floor
+synthesizer=warm synths,analog pad
+rhythmic_steps=steady steps
+bass_style=deep bass,subby bass
+guitar_style=none
+mood=warm,late-night,groovy
+structure=intro,groove,breakdown,drop,outro
+api_name=/set_deep_house_prompt
+prompt_template=Instrumental deep house by Larry Heard{synth}{bass}{drum}{rhythm}, {mood} {section} at {bpm} BPM.
+
+[classical_star_wars]
+label=Classical (Star Wars Suite)
 bpm_min=84
-bpm_max=126
-drum_beat=orchestral percussion
+bpm_max=132
+drum_beat=orchestral percussion,tympani
 synthesizer=none
-rhythmic_steps=steady steps,complex steps
-bass_style=contrabass ostinato
+rhythmic_steps=martial march,staccato ostinato,triplet swells
+bass_style=low brass,cellos,double basses
 guitar_style=none
-styles=heroic brass,sweeping strings,soaring horns,timpani rolls,choir pads
-api_name=/set_star_wars_prompt
+mood=heroic,epic,cinematic
+structure=fanfare,motif development,crescendo,reprise,coda
+api_name=/set_classical_star_wars_prompt
+prompt_template=Cinematic orchestral score{drum}{rhythm}, {mood} {section} with brass fanfares, soaring strings, woodwinds and timpani; no vocals; tempo reference {bpm} BPM.

public/publicapi.py

@@ -1,4 +1,3 @@
-# app.py
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
@@ -8,24 +7,25 @@ import gc
 import re
 import json
 import time
-import math
 import mmap
-import torch
+import math
+import tempfile
 import random
 import logging
 import warnings
 import traceback
 import subprocess
-import tempfile
+import configparser
+from typing import Optional, Tuple, Dict, Any, List
+
 import numpy as np
+import torch
 import torchaudio
 import gradio as gr
 import gradio_client.utils
-import configparser
 from pydub import AudioSegment
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Tuple, Dict, Any, List
 from torch.cuda.amp import autocast
 
 from fastapi import FastAPI, HTTPException, Query
@@ -33,10 +33,29 @@ from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import uvicorn
 import threading
-from logging.handlers import RotatingFileHandler
+
+from colorama import init as colorama_init, Fore, Style
+
+# ======================================================================================
+# RELEASE / PATHS
+# ======================================================================================
+
+RELEASE = "v1.7.0"
+APP_TITLE = f"GhostAI Music Generator • {RELEASE}"
+
+BASE_DIR = Path(__file__).parent.resolve()
+LOG_DIR = BASE_DIR / "logs"
+MP3_DIR = BASE_DIR / "mp3"
+CSS_FILE = BASE_DIR / "styles.css"
+PROMPTS_FILE = BASE_DIR / "prompts.ini"
+EXAMPLE_MD = BASE_DIR / "example.md"
+SETTINGS_FILE = BASE_DIR / "settings.json"
+
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+MP3_DIR.mkdir(parents=True, exist_ok=True)
 
 # ======================================================================================
-# RUNTIME, LOGGING, PATCHES
+# PATCHES & RUNTIME SETUP
 # ======================================================================================
 
 _original_get_type = gradio_client.utils.get_type
@@ -51,43 +70,85 @@ os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"
 torch.backends.cudnn.benchmark = False
 torch.backends.cudnn.deterministic = True
 
-LOG_DIR = "logs"
-MP3_DIR = "mp3"
-os.makedirs(LOG_DIR, exist_ok=True)
-os.makedirs(MP3_DIR, exist_ok=True)
+# ======================================================================================
+# LOGGING (SINGLE FILE, MAX 5MB, AUTO-TRIM)
+# ======================================================================================
+
+colorama_init(autoreset=True)
 
-LOG_FILE = os.path.join(LOG_DIR, "ghostai_musicgen.log")
-logger = logging.getLogger("ghostai-musicgen")
-logger.setLevel(logging.DEBUG)
-logger.handlers = []  # prevent duplicate handlers on hot-reload
-
-file_handler = RotatingFileHandler(
-    LOG_FILE,
-    maxBytes=5 * 1024 * 1024,  # 5 MB cap
-    backupCount=0,             # single file only; truncate on rollover
-    encoding="utf-8",
-    delay=True
-)
+LOG_FILE = LOG_DIR / "musicgen.log"
+MAX_LOG_BYTES = 5 * 1024 * 1024  # 5 MB
+
+class TrimmingFileHandler(logging.FileHandler):
+    def emit(self, record):
+        try:
+            super().emit(record)
+            self._trim_if_needed()
+        except Exception:
+            pass
+
+    def _trim_if_needed(self):
+        try:
+            if self.stream:
+                self.stream.flush()
+            size = LOG_FILE.stat().st_size if LOG_FILE.exists() else 0
+            if size <= MAX_LOG_BYTES:
+                return
+            keep = int(1.5 * 1024 * 1024)
+            with open(LOG_FILE, "rb") as f:
+                if size > keep:
+                    f.seek(-keep, 2)
+                    tail = f.read()
+                else:
+                    tail = f.read()
+            with open(LOG_FILE, "wb") as f:
+                f.write(b"[log trimmed]\n")
+                f.write(tail)
+        except Exception:
+            pass
+
+class ColorFormatter(logging.Formatter):
+    COLORS = {
+        "DEBUG": Fore.BLUE,
+        "INFO": Fore.GREEN,
+        "WARNING": Fore.YELLOW,
+        "ERROR": Fore.RED,
+        "CRITICAL": Fore.RED + Style.BRIGHT,
+    }
+    def format(self, record):
+        levelname = record.levelname
+        color = self.COLORS.get(levelname, "")
+        reset = Style.RESET_ALL
+        record.levelname = f"{color}{levelname}{reset}"
+        return super().format(record)
+
+console_handler = logging.StreamHandler(sys.stdout)
+console_handler.setLevel(logging.DEBUG)
+console_handler.setFormatter(ColorFormatter("%(asctime)s [%(levelname)s] %(message)s"))
+
+file_handler = TrimmingFileHandler(LOG_FILE, mode="a", encoding="utf-8", delay=False)
+file_handler.setLevel(logging.DEBUG)
 file_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
-stdout_handler = logging.StreamHandler(sys.stdout)
-stdout_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
-logger.addHandler(file_handler)
-logger.addHandler(stdout_handler)
+
+logging.basicConfig(level=logging.DEBUG, handlers=[console_handler, file_handler])
+logger = logging.getLogger("ghostai-musicgen")
+logger.info(f"Starting GhostAI Music Generator {RELEASE}")
+
+# ======================================================================================
+# DEVICE
+# ======================================================================================
 
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 if DEVICE != "cuda":
-    logger.error("CUDA GPU is required. Exiting.")
+    logger.error("CUDA is required. Exiting.")
     sys.exit(1)
 logger.info(f"GPU: {torch.cuda.get_device_name(0)}")
+logger.info("Precision: fp16 model, fp32 CPU audio ops")
 
 # ======================================================================================
 # SETTINGS PERSISTENCE
 # ======================================================================================
 
-SETTINGS_FILE = "settings.json"
-PROMPTS_INI = "prompts.ini"
-STYLES_CSS = "styles.css"
-
 DEFAULT_SETTINGS: Dict[str, Any] = {
     "cfg_scale": 5.8,
     "top_k": 250,
@@ -109,119 +170,31 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
     "instrumental_prompt": ""
 }
 
-def load_settings() -> Dict[str, Any]:
+def load_settings_from_file() -> Dict[str, Any]:
     try:
-        if os.path.exists(SETTINGS_FILE):
-            with open(SETTINGS_FILE, "r") as f:
+        if SETTINGS_FILE.exists():
+            with open(SETTINGS_FILE, "r", encoding="utf-8") as f:
                 data = json.load(f)
             for k, v in DEFAULT_SETTINGS.items():
                 data.setdefault(k, v)
             logger.info(f"Loaded settings from {SETTINGS_FILE}")
             return data
     except Exception as e:
-        logger.error(f"Settings load failed: {e}")
+        logger.error(f"Failed reading {SETTINGS_FILE}: {e}")
     return DEFAULT_SETTINGS.copy()
 
-def save_settings(s: Dict[str, Any]) -> None:
+def save_settings_to_file(settings: Dict[str, Any]) -> None:
     try:
-        with open(SETTINGS_FILE, "w") as f:
-            json.dump(s, f, indent=2)
+        with open(SETTINGS_FILE, "w", encoding="utf-8") as f:
+            json.dump(settings, f, indent=2)
         logger.info(f"Saved settings to {SETTINGS_FILE}")
     except Exception as e:
-        logger.error(f"Settings save failed: {e}")
-
-SETTINGS = load_settings()
-
-# ======================================================================================
-# PROMPT CONFIG (prompts.ini)
-# ======================================================================================
+        logger.error(f"Failed saving {SETTINGS_FILE}: {e}")
 
-def _csv_list(s: str) -> List[str]:
-    if not s or s.strip().lower() == "none":
-        return []
-    return [x.strip() for x in s.split(",") if x.strip()]
-
-PROMPT_CFG = configparser.ConfigParser()
-if not os.path.exists(PROMPTS_INI):
-    PROMPT_CFG["metallica"] = {
-        "bpm_min": "90", "bpm_max": "140",
-        "drum_beat": "standard rock,techno kick",
-        "synthesizer": "none",
-        "rhythmic_steps": "steady steps,complex steps",
-        "bass_style": "deep bass,melodic bass",
-        "guitar_style": "distorted",
-        "api_name": "/set_classic_rock_prompt"
-    }
-    with open(PROMPTS_INI, "w") as f:
-        PROMPT_CFG.write(f)
-PROMPT_CFG.read(PROMPTS_INI)
-
-def list_genres() -> List[str]:
-    return PROMPT_CFG.sections()
-
-def get_api_aliases() -> Dict[str, str]:
-    out = {}
-    for sec in PROMPT_CFG.sections():
-        api_name = PROMPT_CFG.get(sec, "api_name", fallback="").strip()
-        if api_name:
-            out[api_name] = sec
-    return out
-
-def _humanize(name: str) -> str:
-    return name.replace("_", " ").title()
-
-def build_prompt_from_section(
-    section: str,
-    bpm: Optional[int] = None,
-    drum_beat: Optional[str] = None,
-    synthesizer: Optional[str] = None,
-    rhythmic_steps: Optional[str] = None,
-    bass_style: Optional[str] = None,
-    guitar_style: Optional[str] = None
-) -> str:
-    if section not in PROMPT_CFG:
-        return f"Instrumental track at 120 BPM."
-    cfg = PROMPT_CFG[section]
-    bpm_min = cfg.getint("bpm_min", fallback=100)
-    bpm_max = cfg.getint("bpm_max", fallback=130)
-    bpm = bpm if bpm else random.randint(bpm_min, bpm_max)
-    bpm = max(bpm_min, min(bpm_max, bpm))
-
-    def pick(value: Optional[str], pool_key: str) -> str:
-        pool = _csv_list(cfg.get(pool_key, fallback=""))
-        if not pool:
-            return "" if (not value or value == "none") else f", {value}"
-        if (not value) or value == "none" or value not in pool:
-            choice = random.choice(pool)
-            return "" if choice == "none" else f", {choice}"
-        return f", {value}"
-
-    drum   = pick(drum_beat, "drum_beat")
-    synth  = pick(synthesizer, "synthesizer")
-    steps  = pick(rhythmic_steps, "rhythmic_steps")
-    bass   = pick(bass_style, "bass_style")
-    guitar = pick(guitar_style, "guitar_style")
-
-    styles_csv = cfg.get("styles", fallback="").strip()
-    styles_str = ""
-    if styles_csv:
-        styles = _csv_list(styles_csv)
-        if styles:
-            styles_str = ", " + ", ".join(styles)
-
-    label = _humanize(section)
-    if "star_wars" in section or "classical" in section:
-        return (
-            f"Cinematic orchestral score{styles_str}{drum}{synth}{steps}{bass}{guitar}, "
-            f"space-opera energy, sweeping strings, heroic brass, bold timpani at {bpm} BPM."
-        )
-    return (
-        f"Instrumental {label}{guitar}{bass}{drum}{synth}{steps} at {bpm} BPM, "
-        f"dynamic sections (intro/verse/chorus), cohesive song flow."
-    )
+CURRENT_SETTINGS = load_settings_from_file()
 
 # ======================================================================================
-# VRAM / DISK / CLEANUP
+# VRAM / DISK / MEMORY
 # ======================================================================================
 
 def clean_memory() -> Optional[float]:
@@ -230,9 +203,12 @@ def clean_memory() -> Optional[float]:
         gc.collect()
         torch.cuda.ipc_collect()
         torch.cuda.synchronize()
-        return torch.cuda.memory_allocated() / 1024**2
+        vram_mb = torch.cuda.memory_allocated() / 1024**2
+        logger.debug(f"Memory cleaned. VRAM={vram_mb:.2f} MB")
+        return vram_mb
     except Exception as e:
         logger.error(f"clean_memory failed: {e}")
+        logger.error(traceback.format_exc())
         return None
 
 def check_vram():
@@ -246,6 +222,13 @@ def check_vram():
             used_mb, total_mb = map(int, re.findall(r'\d+', lines[1]))
             free_mb = total_mb - used_mb
             logger.info(f"VRAM: used {used_mb} MiB | free {free_mb} MiB | total {total_mb} MiB")
+            if free_mb < 5000:
+                logger.warning(f"Low free VRAM ({free_mb} MiB). Running processes:")
+                procs = subprocess.run(
+                    ['nvidia-smi', '--query-compute-apps=pid,used_memory', '--format=csv'],
+                    capture_output=True, text=True
+                )
+                logger.info(f"\n{procs.stdout}")
             return free_mb
     except Exception as e:
         logger.error(f"check_vram failed: {e}")
@@ -263,209 +246,336 @@ def check_disk_space(path=".") -> bool:
         return False
 
 # ======================================================================================
-# MODEL LOAD
-# ======================================================================================
-
-try:
-    from audiocraft.models import MusicGen
-except Exception as e:
-    logger.error("audiocraft is required. pip install audiocraft")
-    raise
-
-def load_model():
-    free_vram = check_vram()
-    if free_vram is not None and free_vram < 5000:
-        logger.warning("Low free VRAM; consider closing other GPU apps.")
-    clean_memory()
-    local_model_path = "./models/musicgen-large"
-    if not os.path.exists(local_model_path):
-        logger.error(f"Missing weights at {local_model_path}")
-        sys.exit(1)
-    logger.info("Loading MusicGen (large)...")
-    with autocast(dtype=torch.float16):
-        model = MusicGen.get_pretrained(local_model_path, device=DEVICE)
-    model.set_generation_params(duration=30, two_step_cfg=False)
-    logger.info("MusicGen loaded.")
-    return model
-
-musicgen_model = load_model()
-
-# ======================================================================================
-# AUDIO DSP
+# AUDIO UTILS (CPU)
 # ======================================================================================
 
-def ensure_stereo(seg: AudioSegment, sample_rate=48000, sample_width=2) -> AudioSegment:
+def ensure_stereo(audio_segment: AudioSegment, sample_rate=48000, sample_width=2) -> AudioSegment:
     try:
-        if seg.channels != 2:
-            seg = seg.set_channels(2)
-        if seg.frame_rate != sample_rate:
-            seg = seg.set_frame_rate(sample_rate)
-        return seg
-    except Exception:
-        return seg
+        if audio_segment.channels != 2:
+            audio_segment = audio_segment.set_channels(2)
+        if audio_segment.frame_rate != sample_rate:
+            audio_segment = audio_segment.set_frame_rate(sample_rate)
+        return audio_segment
+    except Exception as e:
+        logger.error(f"ensure_stereo failed: {e}")
+        return audio_segment
 
-def calculate_rms(seg: AudioSegment) -> float:
+def calculate_rms(segment: AudioSegment) -> float:
     try:
-        samples = np.array(seg.get_array_of_samples(), dtype=np.float32)
+        samples = np.array(segment.get_array_of_samples(), dtype=np.float32)
         return float(np.sqrt(np.mean(samples**2)))
-    except Exception:
+    except Exception as e:
+        logger.error(f"calculate_rms failed: {e}")
         return 0.0
 
-def hard_limit(seg: AudioSegment, limit_db=-3.0, sample_rate=48000) -> AudioSegment:
+def hard_limit(audio_segment: AudioSegment, limit_db=-3.0, sample_rate=48000) -> AudioSegment:
     try:
-        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
-        limit = 10 ** (limit_db / 20.0) * (2**23 if seg.sample_width == 3 else 32767)
-        x = np.array(seg.get_array_of_samples(), dtype=np.float32)
-        x = np.clip(x, -limit, limit).astype(np.int32 if seg.sample_width == 3 else np.int16)
-        if len(x) % 2 != 0:
-            x = x[:-1]
-        return AudioSegment(x.tobytes(), frame_rate=sample_rate, sample_width=seg.sample_width, channels=2)
-    except Exception:
-        return seg
+        audio_segment = ensure_stereo(audio_segment, sample_rate, audio_segment.sample_width)
+        limit = 10 ** (limit_db / 20.0) * (2**23 if audio_segment.sample_width == 3 else 32767)
+        samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
+        samples = np.clip(samples, -limit, limit).astype(np.int32 if audio_segment.sample_width == 3 else np.int16)
+        if len(samples) % 2 != 0:
+            samples = samples[:-1]
+        return AudioSegment(
+            samples.tobytes(),
+            frame_rate=sample_rate,
+            sample_width=audio_segment.sample_width,
+            channels=2
+        )
+    except Exception as e:
+        logger.error(f"hard_limit failed: {e}")
+        return audio_segment
 
-def rms_normalize(seg: AudioSegment, target_rms_db=-23.0, peak_limit_db=-3.0, sample_rate=48000) -> AudioSegment:
+def rms_normalize(segment: AudioSegment, target_rms_db=-23.0, peak_limit_db=-3.0, sample_rate=48000) -> AudioSegment:
     try:
-        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
-        target = 10 ** (target_rms_db / 20) * (2**23 if seg.sample_width == 3 else 32767)
-        current = calculate_rms(seg)
-        if current > 0:
-            gain = target / current
-            seg = seg.apply_gain(20 * np.log10(max(gain, 1e-6)))
-        seg = hard_limit(seg, limit_db=peak_limit_db, sample_rate=sample_rate)
-        return seg
-    except Exception:
-        return seg
+        segment = ensure_stereo(segment, sample_rate, segment.sample_width)
+        target_rms = 10 ** (target_rms_db / 20) * (2**23 if segment.sample_width == 3 else 32767)
+        current_rms = calculate_rms(segment)
+        if current_rms > 0:
+            gain_factor = target_rms / current_rms
+            segment = segment.apply_gain(20 * np.log10(max(gain_factor, 1e-6)))
+        segment = hard_limit(segment, limit_db=peak_limit_db, sample_rate=sample_rate)
+        return segment
+    except Exception as e:
+        logger.error(f"rms_normalize failed: {e}")
+        return segment
 
-def balance_stereo(seg: AudioSegment, noise_threshold=-40, sample_rate=48000) -> AudioSegment:
+def balance_stereo(audio_segment: AudioSegment, noise_threshold=-40, sample_rate=48000) -> AudioSegment:
     try:
-        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
-        x = np.array(seg.get_array_of_samples(), dtype=np.float32)
-        stereo = x.reshape(-1, 2)
+        audio_segment = ensure_stereo(audio_segment, sample_rate, audio_segment.sample_width)
+        samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
+        if audio_segment.channels != 2:
+            return audio_segment
+        stereo = samples.reshape(-1, 2)
         db = 20 * np.log10(np.abs(stereo) + 1e-10)
         mask = db > noise_threshold
         stereo = stereo * mask
-        L, R = stereo[:, 0], stereo[:, 1]
-        l_rms = np.sqrt(np.mean(L[L != 0] ** 2)) if np.any(L != 0) else 0
-        r_rms = np.sqrt(np.mean(R[R != 0] ** 2)) if np.any(R != 0) else 0
+        left = stereo[:, 0]
+        right = stereo[:, 1]
+        l_rms = np.sqrt(np.mean(left[left != 0] ** 2)) if np.any(left != 0) else 0
+        r_rms = np.sqrt(np.mean(right[right != 0] ** 2)) if np.any(right != 0) else 0
         if l_rms > 0 and r_rms > 0:
             avg = (l_rms + r_rms) / 2
             stereo[:, 0] *= (avg / l_rms)
             stereo[:, 1] *= (avg / r_rms)
-        out = stereo.flatten().astype(np.int32 if seg.sample_width == 3 else np.int16)
+        out = stereo.flatten().astype(np.int32 if audio_segment.sample_width == 3 else np.int16)
         if len(out) % 2 != 0:
             out = out[:-1]
-        return AudioSegment(out.tobytes(), frame_rate=sample_rate, sample_width=seg.sample_width, channels=2)
-    except Exception:
-        return seg
+        return AudioSegment(
+            out.tobytes(),
+            frame_rate=sample_rate,
+            sample_width=audio_segment.sample_width,
+            channels=2
+        )
+    except Exception as e:
+        logger.error(f"balance_stereo failed: {e}")
+        return audio_segment
 
-def apply_noise_gate(seg: AudioSegment, threshold_db=-80, sample_rate=48000) -> AudioSegment:
+def apply_noise_gate(audio_segment: AudioSegment, threshold_db=-80, sample_rate=48000) -> AudioSegment:
     try:
-        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
-        x = np.array(seg.get_array_of_samples(), dtype=np.float32)
-        stereo = x.reshape(-1, 2)
+        audio_segment = ensure_stereo(audio_segment, sample_rate, audio_segment.sample_width)
+        samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
+        if audio_segment.channels != 2:
+            return audio_segment
+        stereo = samples.reshape(-1, 2)
         for _ in range(2):
             db = 20 * np.log10(np.abs(stereo) + 1e-10)
             mask = db > threshold_db
             stereo = stereo * mask
-        out = stereo.flatten().astype(np.int32 if seg.sample_width == 3 else np.int16)
+        out = stereo.flatten().astype(np.int32 if audio_segment.sample_width == 3 else np.int16)
         if len(out) % 2 != 0:
             out = out[:-1]
-        return AudioSegment(out.tobytes(), frame_rate=sample_rate, sample_width=seg.sample_width, channels=2)
-    except Exception:
-        return seg
+        return AudioSegment(
+            out.tobytes(),
+            frame_rate=sample_rate,
+            sample_width=audio_segment.sample_width,
+            channels=2
+        )
+    except Exception as e:
+        logger.error(f"apply_noise_gate failed: {e}")
+        return audio_segment
 
-def apply_eq(seg: AudioSegment, sample_rate=48000) -> AudioSegment:
+def apply_eq(segment: AudioSegment, sample_rate=48000) -> AudioSegment:
     try:
-        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
-        seg = seg.high_pass_filter(20).low_pass_filter(8000)
-        seg = seg - 3
-        seg = seg - 3
-        seg = seg - 10
-        return seg
-    except Exception:
-        return seg
+        segment = ensure_stereo(segment, sample_rate, segment.sample_width)
+        segment = segment.high_pass_filter(20)
+        segment = segment.low_pass_filter(8000)
+        segment = segment - 3
+        segment = segment - 3
+        segment = segment - 10
+        return segment
+    except Exception as e:
+        logger.error(f"apply_eq failed: {e}")
+        return segment
 
-def apply_fade(seg: AudioSegment, fade_in_ms=500, fade_out_ms=800) -> AudioSegment:
+def apply_fade(segment: AudioSegment, fade_in_duration=500, fade_out_duration=800) -> AudioSegment:
     try:
-        seg = ensure_stereo(seg, seg.frame_rate, seg.sample_width)
-        return seg.fade_in(fade_in_ms).fade_out(fade_out_ms)
-    except Exception:
-        return seg
+        segment = ensure_stereo(segment, segment.frame_rate, segment.sample_width)
+        segment = segment.fade_in(fade_in_duration).fade_out(fade_out_duration)
+        return segment
+    except Exception as e:
+        logger.error(f"apply_fade failed: {e}")
+        return segment
 
-def _export_tensor_to_segment(audio: torch.Tensor, sr: int, bit_depth: int) -> Optional[AudioSegment]:
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-    tmp_path = tmp.name
-    tmp.close()
+# ======================================================================================
+# PROMPTS.INI LOADING / VARIABLE PROMPT BUILDER
+# ======================================================================================
+
+def _csv(v: str) -> List[str]:
+    if not v or v.strip().lower() == "none":
+        return []
+    return [x.strip() for x in v.split(",") if x.strip()]
+
+def load_profiles_from_ini(prompts_file: Path) -> Dict[str, Dict[str, Any]]:
+    if not prompts_file.exists():
+        raise FileNotFoundError(f"Required prompts file missing: {prompts_file}")
+    cfg = configparser.ConfigParser()
+    cfg.read(prompts_file, encoding="utf-8")
+    profiles: Dict[str, Dict[str, Any]] = {}
+    for sect in cfg.sections():
+        s = cfg[sect]
+        profiles[sect] = {
+            "label": s.get("label", sect.replace("_", " ").title()),
+            "bpm_min": s.getint("bpm_min", 100),
+            "bpm_max": s.getint("bpm_max", 140),
+            "drum_beat": _csv(s.get("drum_beat", "none")),
+            "synthesizer": _csv(s.get("synthesizer", "none")),
+            "rhythmic_steps": _csv(s.get("rhythmic_steps", "steady steps")),
+            "bass_style": _csv(s.get("bass_style", "melodic bass")),
+            "guitar_style": _csv(s.get("guitar_style", "clean")),
+            "mood": _csv(s.get("mood", "energetic")),
+            "structure": _csv(s.get("structure", "intro,verse,chorus,outro")),
+            "api_name": s.get("api_name", f"/set_{sect}_prompt"),
+            "prompt_template": s.get(
+                "prompt_template",
+                "Instrumental track {guitar}{bass}{drum}{synth}{rhythm}, {mood} {section} at {bpm} BPM."
+            ),
+        }
+    if not profiles:
+        raise RuntimeError("No profiles found in prompts.ini")
+    return profiles
+
+def rand_choice(lst: List[str], fallback: str = "") -> str:
+    if not lst:
+        return fallback
+    return random.choice(lst)
+
+def assemble_prompt(profiles: Dict[str, Dict[str, Any]], style_key: str, bpm_hint: int, chunk_idx: int) -> str:
+    prof = profiles.get(style_key)
+    if not prof:
+        return "Instrumental track, energetic, intro at 120 BPM."
+    bpm_min, bpm_max = prof["bpm_min"], prof["bpm_max"]
+    bpm = bpm_hint if bpm_hint != 120 else random.randint(bpm_min, bpm_max)
+    drum = rand_choice(prof["drum_beat"])
+    synth = rand_choice(prof["synthesizer"])
+    rhythm = rand_choice(prof["rhythmic_steps"])
+    bass = rand_choice(prof["bass_style"])
+    guitar = rand_choice(prof["guitar_style"])
+    mood = rand_choice(prof["mood"], "dynamic")
+
+    struct = prof["structure"] or ["intro", "verse", "chorus", "outro"]
+    if chunk_idx <= 1:
+        section = struct[0] if struct else "intro"
+    else:
+        section = rand_choice(struct[1:]) if len(struct) > 1 else "chorus"
+
+    def fmt(val, suffix=""):
+        if not val or val == "none":
+            return ""
+        return f", {val}{suffix}"
+
+    template = prof["prompt_template"]
+    prompt = template.format(
+        bpm=bpm,
+        drum=fmt(drum, " drums"),
+        synth=fmt(synth),
+        rhythm=fmt(rhythm),
+        bass=fmt(bass + " bass" if bass and "bass" not in bass else bass),
+        guitar=fmt(guitar + " guitar" if guitar and "guitar" not in guitar else guitar),
+        mood=mood,
+        section=section,
+    )
+    return prompt
+
+# ======================================================================================
+# PRESETS
+# ======================================================================================
+
+PRESETS = {
+    "default":   {"cfg_scale": 5.8, "top_k": 250, "top_p": 0.95, "temperature": 0.90},
+    "rock":      {"cfg_scale": 5.8, "top_k": 250, "top_p": 0.95, "temperature": 0.90},
+    "techno":    {"cfg_scale": 5.2, "top_k": 300, "top_p": 0.96, "temperature": 0.95},
+    "grunge":    {"cfg_scale": 6.2, "top_k": 220, "top_p": 0.94, "temperature": 0.90},
+    "indie":     {"cfg_scale": 5.5, "top_k": 240, "top_p": 0.95, "temperature": 0.92},
+    "funk_rock": {"cfg_scale": 5.8, "top_k": 260, "top_p": 0.96, "temperature": 0.94},
+}
+
+# ======================================================================================
+# MODEL LOAD
+# ======================================================================================
+
+try:
+    from audiocraft.models import MusicGen
+except Exception as e:
+    logger.error("audiocraft is required. pip install audiocraft")
+    raise
+
+def load_model():
+    free_vram = check_vram()
+    if free_vram is not None and free_vram < 5000:
+        logger.warning("Low free VRAM; consider closing other apps.")
+    clean_memory()
+    local_model_path = str(BASE_DIR / "models" / "musicgen-large")
+    if not os.path.exists(local_model_path):
+        logger.error(f"Model path missing: {local_model_path}")
+        sys.exit(1)
+    logger.info("Loading MusicGen (large)...")
+    with autocast(dtype=torch.float16):
+        model = MusicGen.get_pretrained(local_model_path, device=DEVICE)
+    model.set_generation_params(duration=30, two_step_cfg=False)
+    logger.info("MusicGen loaded.")
+    return model
+
+musicgen_model = load_model()
+
+# ======================================================================================
+# GENERATION PIPELINE
+# ======================================================================================
+
+def _export_torch_to_segment(audio_tensor: torch.Tensor, sample_rate: int, bit_depth_int: int) -> Optional[AudioSegment]:
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
+        tmp_path = tmp.name
     try:
-        torchaudio.save(tmp_path, audio, sr, bits_per_sample=bit_depth)
+        torchaudio.save(tmp_path, audio_tensor, sample_rate, bits_per_sample=bit_depth_int)
         with open(tmp_path, "rb") as f:
             mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
             seg = AudioSegment.from_wav(tmp_path)
             mm.close()
         return seg
     except Exception as e:
-        logger.error(f"export tensor -> segment failed: {e}")
+        logger.error(f"_export_torch_to_segment failed: {e}")
+        logger.error(traceback.format_exc())
         return None
     finally:
         try:
-            if os.path.exists(tmp_path): os.unlink(tmp_path)
+            os.remove(tmp_path)
         except OSError:
             pass
 
-def _crossfade(seg_a: AudioSegment, seg_b: AudioSegment, overlap_ms: int, sr: int, bit_depth: int) -> AudioSegment:
+def _crossfade_segments(seg_a: AudioSegment, seg_b: AudioSegment, overlap_ms: int, sample_rate: int, bit_depth_int: int) -> AudioSegment:
     try:
-        seg_a = ensure_stereo(seg_a, sr, seg_a.sample_width)
-        seg_b = ensure_stereo(seg_b, sr, seg_b.sample_width)
+        seg_a = ensure_stereo(seg_a, sample_rate, seg_a.sample_width)
+        seg_b = ensure_stereo(seg_b, sample_rate, seg_b.sample_width)
         if overlap_ms <= 0 or len(seg_a) < overlap_ms or len(seg_b) < overlap_ms:
             return seg_a + seg_b
 
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as a_wav, \
-             tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as b_wav, \
-             tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as cf_wav:
-            a_path = a_wav.name
-            b_path = b_wav.name
-            cf_path = cf_wav.name
-
-        seg_a[-overlap_ms:].export(a_path, format="wav")
-        seg_b[:overlap_ms].export(b_path, format="wav")
-        a, sr_a = torchaudio.load(a_path)
-        b, sr_b = torchaudio.load(b_path)
-        if sr_a != sr:
-            a = torchaudio.functional.resample(a, sr_a, sr, lowpass_filter_width=64)
-        if sr_b != sr:
-            b = torchaudio.functional.resample(b, sr_b, sr, lowpass_filter_width=64)
-        n = min(a.shape[1], b.shape[1])
-        n = n - (n % 2)
-        if n <= 0:
-            for p in (a_path, b_path, cf_path):
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as prev_wav, \
+             tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as curr_wav:
+            prev_path, curr_path = prev_wav.name, curr_wav.name
+
+        try:
+            seg_a[-overlap_ms:].export(prev_path, format="wav")
+            seg_b[:overlap_ms].export(curr_path, format="wav")
+            a_audio, sr_a = torchaudio.load(prev_path)
+            b_audio, sr_b = torchaudio.load(curr_path)
+            if sr_a != sample_rate:
+                a_audio = torchaudio.functional.resample(a_audio, sr_a, sample_rate, lowpass_filter_width=64)
+            if sr_b != sample_rate:
+                b_audio = torchaudio.functional.resample(b_audio, sr_b, sample_rate, lowpass_filter_width=64)
+            n = min(a_audio.shape[1], b_audio.shape[1])
+            n = n - (n % 2)
+            if n <= 0:
+                return seg_a + seg_b
+            a = a_audio[:, :n]
+            b = b_audio[:, :n]
+            hann = torch.hann_window(n, periodic=False)
+            fade_in = hann
+            fade_out = hann.flip(0)
+            blended = (a * fade_out + b * fade_in).to(torch.float32)
+            blended = torch.clamp(blended, -1.0, 1.0)
+
+            scale = (2**23 if bit_depth_int == 24 else 32767)
+            blended_i = (blended * scale).to(torch.int32 if bit_depth_int == 24 else torch.int16)
+
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_x:
+                temp_x = tmp_x.name
+            torchaudio.save(temp_x, blended_i, sample_rate, bits_per_sample=bit_depth_int)
+            blended_seg = AudioSegment.from_wav(temp_x)
+            blended_seg = ensure_stereo(blended_seg, sample_rate, blended_seg.sample_width)
+
+            result = seg_a[:-overlap_ms] + blended_seg + seg_b[overlap_ms:]
+            return result
+        finally:
+            for p in [prev_path, curr_path, locals().get("temp_x", None)]:
                 try:
-                    if os.path.exists(p): os.unlink(p)
+                    if p and os.path.exists(p):
+                        os.remove(p)
                 except OSError:
                     pass
-            return seg_a + seg_b
-        aw = a[:, :n].to(torch.float32)
-        bw = b[:, :n].to(torch.float32)
-        hann = torch.hann_window(n, periodic=False)
-        out = (aw * hann.flip(0) + bw * hann).clamp(-1.0, 1.0)
-        scale = (2**23 if bit_depth == 24 else 32767)
-        out_i = (out * scale).to(torch.int32 if bit_depth == 24 else torch.int16)
-        torchaudio.save(cf_path, out_i, sr, bits_per_sample=bit_depth)
-        blended = AudioSegment.from_wav(cf_path)
-        res = seg_a[:-overlap_ms] + blended + seg_b[overlap_ms:]
-        for p in (a_path, b_path, cf_path):
-            try:
-                if os.path.exists(p): os.unlink(p)
-            except OSError:
-                pass
-        return res
     except Exception as e:
-        logger.error(f"crossfade failed: {e}")
+        logger.error(f"_crossfade_segments failed: {e}")
         return seg_a + seg_b
 
-# ======================================================================================
-# GENERATION (30s chunks -> seamless)
-# ======================================================================================
-
 def generate_music(
     instrumental_prompt: str,
     cfg_scale: float,
@@ -481,178 +591,196 @@ def generate_music(
     guitar_style: str,
     target_volume: float,
     preset: str,
-    max_steps_ignored: str,
+    max_steps: str,
     vram_status_text: str,
     bitrate: str,
     output_sample_rate: str,
     bit_depth: str
 ) -> Tuple[Optional[str], str, str]:
+    global musicgen_model
+
     if not instrumental_prompt or not instrumental_prompt.strip():
-        return None, "⚠️ Enter a valid prompt.", vram_status_text
+        return None, "⚠️ Please enter a valid instrumental prompt!", vram_status_text
 
     try:
-        out_sr = int(output_sample_rate)
-        bit_depth_int = int(bit_depth)
-        sample_width = 3 if bit_depth_int == 24 else 2
-    except Exception:
-        return None, "❌ Invalid output SR or bit depth.", vram_status_text
-
-    if not check_disk_space("."):
-        return None, "⚠️ Low disk space (<1GB).", vram_status_text
-
-    CHUNK = 30
-    total_duration = max(30, min(int(total_duration), 180))
-    chunks = math.ceil(total_duration / CHUNK)
-    PROCESS_SR = 48000
-    OVERLAP = 0.20
-
-    musicgen_model.set_generation_params(
-        duration=CHUNK,
-        use_sampling=True,
-        top_k=int(top_k),
-        top_p=float(top_p),
-        temperature=float(temperature),
-        cfg_coef=float(cfg_scale),
-        two_step_cfg=False,
-    )
+        if preset != "default":
+            p = PRESETS.get(preset, PRESETS["default"])
+            cfg_scale, top_k, top_p, temperature = p["cfg_scale"], p["top_k"], p["top_p"], p["temperature"]
+            logger.info(f"Preset '{preset}' applied: cfg={cfg_scale} top_k={top_k} top_p={top_p} temp={temperature}")
+
+        try:
+            output_sr_int = int(output_sample_rate)
+        except:
+            return None, "❌ Invalid output sampling rate; choose 22050/44100/48000", vram_status_text
+        try:
+            bit_depth_int = int(bit_depth)
+            sample_width = 3 if bit_depth_int == 24 else 2
+        except:
+            return None, "❌ Invalid bit depth; choose 16 or 24", vram_status_text
+
+        if not check_disk_space():
+            return None, "⚠️ Low disk space (<1GB).", vram_status_text
+
+        CHUNK_SEC = 30
+        total_duration = max(30, min(int(total_duration), 120))
+        num_chunks = math.ceil(total_duration / CHUNK_SEC)
+
+        PROCESS_SR = 48000
+        OVERLAP_SEC = 0.20
+
+        seed = random.randint(0, 2**31 - 1)
+        random.seed(seed)
+        torch.manual_seed(seed)
+        np.random.seed(seed)
+        torch.cuda.manual_seed_all(seed)
+
+        musicgen_model.set_generation_params(
+            duration=CHUNK_SEC,
+            use_sampling=True,
+            top_k=int(top_k),
+            top_p=float(top_p),
+            temperature=float(temperature),
+            cfg_coef=float(cfg_scale),
+            two_step_cfg=False,
+        )
 
-    vram_status_text = f"Start VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
-    segments: List[AudioSegment] = []
+        vram_status_text = f"Start VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
 
-    seed = random.randint(0, 2**31 - 1)
-    random.seed(seed); np.random.seed(seed)
-    torch.manual_seed(seed); torch.cuda.manual_seed_all(seed)
+        segments: List[AudioSegment] = []
+        start_time = time.time()
 
-    for i in range(chunks):
-        part = i + 1
-        dur = CHUNK if (i < chunks - 1) else (total_duration - CHUNK * (chunks - 1) or CHUNK)
-        logger.info(f"Generating chunk {part}/{chunks} ({dur}s)")
-        chunk_prompt = instrumental_prompt
+        for idx in range(num_chunks):
+            chunk_idx = idx + 1
+            dur = CHUNK_SEC if (idx < num_chunks - 1) else (total_duration - CHUNK_SEC * (num_chunks - 1) or CHUNK_SEC)
+            logger.info(f"Generating chunk {chunk_idx}/{num_chunks} ({dur}s)")
 
-        try:
-            with torch.no_grad():
-                with autocast(dtype=torch.float16):
-                    clean_memory()
-                    if i == 0:
-                        audio = musicgen_model.generate([chunk_prompt], progress=True)[0].cpu()
-                    else:
-                        prev = segments[-1]
-                        prev = apply_noise_gate(prev, -80, PROCESS_SR)
-                        prev = balance_stereo(prev, -40, PROCESS_SR)
-                        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tprev:
-                            prev_path = tprev.name
-                        prev.export(prev_path, format="wav")
-                        tail, sr_prev = torchaudio.load(prev_path)
-                        if sr_prev != PROCESS_SR:
-                            tail = torchaudio.functional.resample(tail, sr_prev, PROCESS_SR, lowpass_filter_width=64)
-                        if tail.shape[0] != 2:
-                            tail = tail.repeat(2, 1)[:, :tail.shape[1]]
-                        try:
-                            os.unlink(prev_path)
-                        except OSError:
-                            pass
-                        tail = tail.to(DEVICE)[:, -int(PROCESS_SR * OVERLAP):]
-                        audio = musicgen_model.generate_continuation(
-                            prompt=tail,
-                            prompt_sample_rate=PROCESS_SR,
-                            descriptions=[chunk_prompt],
-                            progress=True
-                        )[0].cpu()
-                    clean_memory()
-        except Exception as e:
-            logger.error(f"Chunk {part} generation failed: {e}")
-            return None, f"❌ Failed to generate chunk {part}: {e}", vram_status_text
+            prompt_text = instrumental_prompt  # UI sends fully-assembled prompt (or manual text)
+
+            try:
+                with torch.no_grad():
+                    with autocast(dtype=torch.float16):
+                        clean_memory()
+                        if idx == 0:
+                            audio = musicgen_model.generate([prompt_text], progress=True)[0].cpu()
+                        else:
+                            prev_seg = segments[-1]
+                            prev_seg = apply_noise_gate(prev_seg, threshold_db=-80, sample_rate=PROCESS_SR)
+                            prev_seg = balance_stereo(prev_seg, noise_threshold=-40, sample_rate=PROCESS_SR)
+                            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_prev:
+                                temp_prev = tmp_prev.name
+                            try:
+                                prev_seg.export(temp_prev, format="wav")
+                                prev_audio, prev_sr = torchaudio.load(temp_prev)
+                                if prev_sr != PROCESS_SR:
+                                    prev_audio = torchaudio.functional.resample(prev_audio, prev_sr, PROCESS_SR, lowpass_filter_width=64)
+                                if prev_audio.shape[0] != 2:
+                                    prev_audio = prev_audio.repeat(2, 1)[:, :prev_audio.shape[1]]
+                                prev_audio = prev_audio.to(DEVICE)
+                                tail = prev_audio[:, -int(PROCESS_SR * OVERLAP_SEC):]
+
+                                audio = musicgen_model.generate_continuation(
+                                    prompt=tail,
+                                    prompt_sample_rate=PROCESS_SR,
+                                    descriptions=[prompt_text],
+                                    progress=True
+                                )[0].cpu()
+                                del prev_audio, tail
+                            finally:
+                                try:
+                                    if os.path.exists(temp_prev):
+                                        os.remove(temp_prev)
+                                except OSError:
+                                    pass
+                        clean_memory()
+            except Exception as e:
+                logger.error(f"Chunk {chunk_idx} generation failed: {e}")
+                logger.error(traceback.format_exc())
+                return None, f"❌ Failed to generate chunk {chunk_idx}: {e}", vram_status_text
 
+            try:
+                if audio.shape[0] != 2:
+                    audio = audio.repeat(2, 1)[:, :audio.shape[1]]
+                audio = audio.to(dtype=torch.float32)
+                audio = torchaudio.functional.resample(audio, 32000, PROCESS_SR, lowpass_filter_width=64)
+                seg = _export_torch_to_segment(audio, PROCESS_SR, bit_depth_int)
+                if seg is None:
+                    return None, f"❌ Failed to convert audio for chunk {chunk_idx}", vram_status_text
+                seg = ensure_stereo(seg, PROCESS_SR, sample_width)
+                seg = seg - 15
+                seg = apply_noise_gate(seg, threshold_db=-80, sample_rate=PROCESS_SR)
+                seg = balance_stereo(seg, noise_threshold=-40, sample_rate=PROCESS_SR)
+                seg = rms_normalize(seg, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=PROCESS_SR)
+                seg = apply_eq(seg, sample_rate=PROCESS_SR)
+                seg = seg[:dur * 1000]
+                segments.append(seg)
+                del audio
+                clean_memory()
+                vram_status_text = f"VRAM after chunk {chunk_idx}: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+            except Exception as e:
+                logger.error(f"Post-processing failed (chunk {chunk_idx}): {e}")
+                logger.error(traceback.format_exc())
+                return None, f"❌ Failed to process chunk {chunk_idx}: {e}", vram_status_text
+
+        if not segments:
+            return None, "❌ No audio generated.", vram_status_text
+
+        logger.info("Combining chunks...")
+        final_seg = segments[0]
+        overlap_ms = int(0.20 * 1000)
+        for i in range(1, len(segments)):
+            final_seg = _crossfade_segments(final_seg, segments[i], overlap_ms, PROCESS_SR, bit_depth_int)
+
+        final_seg = final_seg[:total_duration * 1000]
+
+        final_seg = apply_noise_gate(final_seg, threshold_db=-80, sample_rate=PROCESS_SR)
+        final_seg = balance_stereo(final_seg, noise_threshold=-40, sample_rate=PROCESS_SR)
+        final_seg = rms_normalize(final_seg, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=PROCESS_SR)
+        final_seg = apply_eq(final_seg, sample_rate=PROCESS_SR)
+        final_seg = apply_fade(final_seg, 500, 800)
+        final_seg = final_seg - 10
+        final_seg = final_seg.set_frame_rate(output_sr_int)
+
+        mp3_path = MP3_DIR / f"ghostai_music_{int(time.time())}.mp3"
         try:
-            if audio.shape[0] != 2:
-                audio = audio.repeat(2, 1)[:, :audio.shape[1]]
-            audio = audio.to(torch.float32)
-            audio = torchaudio.functional.resample(audio, 32000, PROCESS_SR, lowpass_filter_width=64)
-            seg = _export_tensor_to_segment(audio, PROCESS_SR, bit_depth_int)
-            if seg is None:
-                return None, f"❌ Audio conversion failed (chunk {part}).", vram_status_text
-            seg = ensure_stereo(seg, PROCESS_SR, sample_width)
-            seg = seg - 15
-            seg = apply_noise_gate(seg, -80, PROCESS_SR)
-            seg = balance_stereo(seg, -40, PROCESS_SR)
-            seg = rms_normalize(seg, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=PROCESS_SR)
-            seg = apply_eq(seg, PROCESS_SR)
-            seg = seg[:dur * 1000]
-            segments.append(seg)
-            del audio
-            vram_status_text = f"VRAM after chunk {part}: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+            clean_memory()
+            final_seg.export(str(mp3_path), format="mp3", bitrate=bitrate, tags={"title": "GhostAI Instrumental", "artist": "GhostAI"})
         except Exception as e:
-            logger.error(f"Post-process failed (chunk {part}): {e}")
-            return None, f"❌ Processing error (chunk {part}).", vram_status_text
-
-    if not segments:
-        return None, "❌ No audio generated.", vram_status_text
-
-    logger.info("Combining chunks...")
-    out = segments[0]
-    overlap_ms = int(OVERLAP * 1000)
-    for k in range(1, len(segments)):
-        out = _crossfade(out, segments[k], overlap_ms, PROCESS_SR, bit_depth_int)
-
-    out = out[:total_duration * 1000]
-    out = apply_noise_gate(out, -80, PROCESS_SR)
-    out = balance_stereo(out, -40, PROCESS_SR)
-    out = rms_normalize(out, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=PROCESS_SR)
-    out = apply_eq(out, PROCESS_SR)
-    out = apply_fade(out, 500, 800)
-    out = (out - 10).set_frame_rate(out_sr)
-
-    mp3_path = os.path.join(MP3_DIR, f"ghostai_music_{int(time.time())}.mp3")
-    try:
-        clean_memory()
-        out.export(mp3_path, format="mp3", bitrate=bitrate, tags={"title": "GhostAI Instrumental", "artist": "GhostAI"})
-    except Exception as e:
-        logger.error(f"MP3 export failed: {e}")
-        fb = os.path.join(MP3_DIR, f"ghostai_music_fallback_{int(time.time())}.mp3")
-        try:
-            out.export(fb, format="mp3", bitrate="128k")
-            mp3_path = fb
-        except Exception as ee:
-            return None, f"❌ Export failed: {ee}", vram_status_text
+            logger.error(f"MP3 export failed ({bitrate}): {e}")
+            fb = MP3_DIR / f"ghostai_music_fallback_{int(time.time())}.mp3"
+            try:
+                final_seg.export(str(fb), format="mp3", bitrate="128k")
+                mp3_path = fb
+            except Exception as ee:
+                return None, f"❌ Failed to export MP3: {ee}", vram_status_text
 
-    vram_status_text = f"Final VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
-    return mp3_path, "✅ Done! Seamless unified track rendered.", vram_status_text
+        elapsed = time.time() - start_time
+        vram_status_text = f"Final VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+        logger.info(f"Done in {elapsed:.2f}s -> {mp3_path}")
+        return str(mp3_path), "✅ Done! 30s chunking unified seamlessly. Check output loudness/quality.", vram_status_text
 
-def generate_music_wrapper(*args):
-    try:
-        return generate_music(*args)
+    except Exception as e:
+        logger.error(f"Generation failed: {e}")
+        logger.error(traceback.format_exc())
+        return None, f"❌ Generation failed: {e}", vram_status_text
     finally:
         clean_memory()
 
+def clear_inputs():
+    s = DEFAULT_SETTINGS.copy()
+    return (
+        s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
+        s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
+        s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
+        s["bitrate"], s["output_sample_rate"], s["bit_depth"]
+    )
+
 # ======================================================================================
-# FASTAPI — Status + Settings + Prompts + Render
+# SERVER STATUS (BUSY/IDLE) & RENDER API & STYLE PROMPT API
 # ======================================================================================
 
-class RenderRequest(BaseModel):
-    instrumental_prompt: str
-    cfg_scale: Optional[float] = None
-    top_k: Optional[int] = None
-    top_p: Optional[float] = None
-    temperature: Optional[float] = None
-    total_duration: Optional[int] = None
-    bpm: Optional[int] = None
-    drum_beat: Optional[str] = None
-    synthesizer: Optional[str] = None
-    rhythmic_steps: Optional[str] = None
-    bass_style: Optional[str] = None
-    guitar_style: Optional[str] = None
-    target_volume: Optional[float] = None
-    preset: Optional[str] = None
-    max_steps: Optional[int] = None
-    bitrate: Optional[str] = None
-    output_sample_rate: Optional[str] = None
-    bit_depth: Optional[str] = None
-
-class SettingsUpdate(BaseModel):
-    settings: Dict[str, Any]
-
 BUSY_LOCK = threading.Lock()
 BUSY_FLAG = False
+BUSY_FILE = "/tmp/musicgen_busy.lock"
 CURRENT_JOB: Dict[str, Any] = {"id": None, "start": None}
 
 def set_busy(val: bool, job_id: Optional[str] = None):
@@ -662,9 +790,18 @@ def set_busy(val: bool, job_id: Optional[str] = None):
         if val:
             CURRENT_JOB["id"] = job_id or f"job_{int(time.time())}"
             CURRENT_JOB["start"] = time.time()
+            try:
+                Path(BUSY_FILE).write_text(CURRENT_JOB["id"])
+            except Exception:
+                pass
         else:
             CURRENT_JOB["id"] = None
             CURRENT_JOB["start"] = None
+            try:
+                if os.path.exists(BUSY_FILE):
+                    os.remove(BUSY_FILE)
+            except Exception:
+                pass
 
 def is_busy() -> bool:
     with BUSY_LOCK:
@@ -676,61 +813,89 @@ def job_elapsed() -> float:
             return 0.0
         return time.time() - CURRENT_JOB["start"]
 
-fastapp = FastAPI(title="GhostAI Music Server", version="1.2")
+class RenderRequest(BaseModel):
+    instrumental_prompt: str
+    cfg_scale: Optional[float] = None
+    top_k: Optional[int] = None
+    top_p: Optional[float] = None
+    temperature: Optional[float] = None
+    total_duration: Optional[int] = None
+    bpm: Optional[int] = None
+    drum_beat: Optional[str] = None
+    synthesizer: Optional[str] = None
+    rhythmic_steps: Optional[str] = None
+    bass_style: Optional[str] = None
+    guitar_style: Optional[str] = None
+    target_volume: Optional[float] = None
+    preset: Optional[str] = None
+    max_steps: Optional[int] = None
+    bitrate: Optional[str] = None
+    output_sample_rate: Optional[str] = None
+    bit_depth: Optional[str] = None
+
+class SettingsUpdate(BaseModel):
+    settings: Dict[str, Any]
+
+fastapp = FastAPI(title=f"GhostAI Music Server {RELEASE}", version=RELEASE)
 fastapp.add_middleware(
-    CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"]
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
 )
 
 @fastapp.get("/health")
 def health():
-    return {"ok": True, "ts": int(time.time())}
+    return {"ok": True, "ts": int(time.time()), "release": RELEASE}
 
 @fastapp.get("/status")
 def status():
-    return {"busy": is_busy(), "job_id": CURRENT_JOB["id"], "elapsed": job_elapsed()}
+    busy = is_busy()
+    return {
+        "busy": busy,
+        "job_id": CURRENT_JOB["id"],
+        "since": CURRENT_JOB["start"],
+        "elapsed": job_elapsed(),
+        "lockfile": os.path.exists(BUSY_FILE),
+        "release": RELEASE
+    }
 
 @fastapp.get("/config")
 def get_config():
-    return {"defaults": SETTINGS}
+    return {"defaults": CURRENT_SETTINGS, "release": RELEASE}
 
 @fastapp.post("/settings")
 def set_settings(payload: SettingsUpdate):
     try:
-        s = SETTINGS.copy()
+        s = CURRENT_SETTINGS.copy()
         s.update(payload.settings or {})
-        save_settings(s)
+        save_settings_to_file(s)
         for k, v in s.items():
-            SETTINGS[k] = v
+            CURRENT_SETTINGS[k] = v
         return {"ok": True, "saved": s}
     except Exception as e:
         raise HTTPException(status_code=400, detail=str(e))
 
-@fastapp.get("/genres")
-def api_genres():
-    return {"genres": list_genres()}
+def register_style_endpoints(app: FastAPI, profiles: Dict[str, Dict[str, Any]]):
+    for key, prof in profiles.items():
+        route = prof.get("api_name") or f"/set_{key}_prompt"
+        async def style_endpoint(style_key=key):
+            return {"style": style_key, "prompt": assemble_prompt(profiles, style_key, 120, 1), "release": RELEASE}
+        app.add_api_route(route, style_endpoint, methods=["GET"])
+
+@fastapp.get("/styles")
+def list_styles():
+    return {
+        "styles": [
+            {"key": k, "label": v["label"], "api_name": v["api_name"]}
+            for k, v in PROFILES.items()
+        ],
+        "release": RELEASE
+    }
 
-@fastapp.post("/reload_prompts")
-def api_reload_prompts():
-    try:
-        PROMPT_CFG.read(PROMPTS_INI)
-        return {"ok": True, "genres": list_genres(), "aliases": get_api_aliases()}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@fastapp.get("/prompt/{name}")
-def api_prompt(
-    name: str,
-    bpm: Optional[int] = Query(None),
-    drum_beat: Optional[str] = Query(None),
-    synthesizer: Optional[str] = Query(None),
-    rhythmic_steps: Optional[str] = Query(None),
-    bass_style: Optional[str] = Query(None),
-    guitar_style: Optional[str] = Query(None),
-):
-    if name not in PROMPT_CFG:
-        raise HTTPException(status_code=404, detail=f"Unknown genre '{name}'.")
-    prompt = build_prompt_from_section(name, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style)
-    return {"name": name, "prompt": prompt}
+@fastapp.get("/prompt")
+def get_prompt(style: str = Query(...), bpm: int = Query(120), chunk: int = Query(1)):
+    if style not in PROFILES:
+        raise HTTPException(status_code=404, detail=f"Unknown style '{style}'")
+    return {"style": style, "prompt": assemble_prompt(PROFILES, style, bpm, chunk), "release": RELEASE}
 
 @fastapp.post("/render")
 def render(req: RenderRequest):
@@ -739,7 +904,7 @@ def render(req: RenderRequest):
     job_id = f"render_{int(time.time())}"
     set_busy(True, job_id)
     try:
-        s = SETTINGS.copy()
+        s = CURRENT_SETTINGS.copy()
         for k, v in req.dict().items():
             if v is not None:
                 s[k] = v
@@ -766,223 +931,283 @@ def render(req: RenderRequest):
         )
         if not mp3:
             raise HTTPException(status_code=500, detail=msg)
-        return {"ok": True, "job_id": job_id, "path": mp3, "status": msg, "vram": vram}
+        return {"ok": True, "job_id": job_id, "path": mp3, "status": msg, "vram": vram, "release": RELEASE}
     finally:
         set_busy(False, None)
 
-for path, sec in get_api_aliases().items():
-    def _factory(section_name: str):
-        def _endpoint(
-            bpm: Optional[int] = Query(None),
-            drum_beat: Optional[str] = Query(None),
-            synthesizer: Optional[str] = Query(None),
-            rhythmic_steps: Optional[str] = Query(None),
-            bass_style: Optional[str] = Query(None),
-            guitar_style: Optional[str] = Query(None),
-        ):
-            prompt = build_prompt_from_section(section_name, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style)
-            return {"name": section_name, "prompt": prompt}
-        return _endpoint
-    fastapp.add_api_route(path, _factory(sec), methods=["GET"])
-
 def _start_fastapi():
     uvicorn.run(fastapp, host="0.0.0.0", port=8555, log_level="info")
 
+# Load profiles from prompts.ini (required) and register endpoints
+try:
+    PROFILES = load_profiles_from_ini(PROMPTS_FILE)
+except Exception as e:
+    logger.error(f"Failed to load {PROMPTS_FILE}: {e}")
+    sys.exit(1)
+register_style_endpoints(fastapp, PROFILES)
+
 api_thread = threading.Thread(target=_start_fastapi, daemon=True)
 api_thread.start()
-logger.info("FastAPI server on http://0.0.0.0:8555")
+logger.info(f"FastAPI server started on http://0.0.0.0:8555 ({RELEASE})")
 
 # ======================================================================================
-# GRADIO UI
+# GRADIO UI (TABS + ACCESSIBLE THEME + 4→5-COLUMN GRID FOR BAND BUTTONS)
 # ======================================================================================
 
-def get_latest_log():
+def read_css_text() -> str:
     try:
-        if not os.path.exists(LOG_FILE):
-            return "No log file found."
-        with open(LOG_FILE, "r", encoding="utf-8", errors="ignore") as f:
-            return f.read()
+        return CSS_FILE.read_text(encoding="utf-8")
     except Exception as e:
-        return f"Error reading log file: {e}"
+        logger.warning(f"styles.css not found or unreadable: {e}")
+        return ""  # no fallback CSS hard-coded
 
-css_text = Path(STYLES_CSS).read_text(encoding="utf-8") if os.path.exists(STYLES_CSS) else ""
+def read_example_md() -> str:
+    try:
+        return EXAMPLE_MD.read_text(encoding="utf-8")
+    except Exception as e:
+        logger.warning(f"example.md not found or unreadable: {e}")
+        return "## Info\nProvide an `example.md` to populate this tab."
 
-logger.info("Building Gradio UI...")
-with gr.Blocks(css=css_text, analytics_enabled=False, title="GhostAI Music Generator") as demo:
-    gr.Markdown("# 🎵 GhostAI Music Generator")
-    gr.Markdown("Create instrumental tracks with fixed 30s chunking and seamless merges. Accessibility-first UI.")
+def ui_prompt_from_style(style_key, bpm, *_):
+    return assemble_prompt(PROFILES, style_key, int(bpm), 1)
 
-    with gr.Row():
-        with gr.Column():
+def get_latest_log() -> str:
+    try:
+        return LOG_FILE.read_text(encoding="utf-8") if LOG_FILE.exists() else "No log file yet."
+    except Exception as e:
+        return f"Error reading log: {e}"
+
+def set_bitrate_128(): return "128k"
+def set_bitrate_192(): return "192k"
+def set_bitrate_320(): return "320k"
+def set_sample_rate_22050(): return "22050"
+def set_sample_rate_44100(): return "44100"
+def set_sample_rate_48000(): return "48000"
+def set_bit_depth_16(): return "16"
+def set_bit_depth_24(): return "24"
+
+CSS = read_css_text()
+loaded = CURRENT_SETTINGS
+
+logger.info(f"Building Gradio UI {RELEASE} ...")
+with gr.Blocks(css=CSS, analytics_enabled=False, title=APP_TITLE, theme=gr.themes.Soft()) as demo:
+    with gr.TabItem(f"Generator • {RELEASE}", id="tab-generator"):
+        gr.Markdown(f"""
+        <div class="header" role="banner" aria-label="{APP_TITLE}">
+            <div class="logo" aria-hidden="true">👻</div>
+            <h1>{APP_TITLE}</h1>
+            <p>30/60/90/120s chunking · seamless joins · API + style endpoints</p>
+        </div>
+        """)
+
+        with gr.Column(elem_classes="input-container"):
+            gr.Markdown("### Prompt")
             instrumental_prompt = gr.Textbox(
                 label="Instrumental Prompt",
-                placeholder="Type your prompt or click a Genre button below",
+                placeholder="Type your instrumental prompt or click a style button",
                 lines=4,
-                value=SETTINGS.get("instrumental_prompt", ""),
+                value=loaded.get("instrumental_prompt", ""),
             )
 
-            genre_buttons = []
-            genre_sections = list_genres()
-            with gr.Group():
-                gr.Markdown("### Genres (from prompts.ini)")
-                for i in range(0, len(genre_sections), 4):
-                    with gr.Row():
-                        for sec in genre_sections[i:i+4]:
-                            btn = gr.Button(_humanize(sec))
-                            genre_buttons.append((btn, sec))
-
-            with gr.Group():
-                gr.Markdown("### Generation Settings")
-                cfg_scale = gr.Slider(1.0, 10.0, step=0.1, value=float(SETTINGS.get("cfg_scale", 5.8)), label="CFG Scale")
-                top_k = gr.Slider(10, 500, step=10, value=int(SETTINGS.get("top_k", 250)), label="Top-K")
-                top_p = gr.Slider(0.0, 1.0, step=0.01, value=float(SETTINGS.get("top_p", 0.95)), label="Top-P")
-                temperature = gr.Slider(0.1, 2.0, step=0.01, value=float(SETTINGS.get("temperature", 0.90)), label="Temperature")
-                total_duration = gr.Dropdown(choices=[30, 60, 90, 120, 180], value=int(SETTINGS.get("total_duration", 60)), label="Song Length (seconds)")
-
-                bpm = gr.Slider(60, 180, step=1, value=int(SETTINGS.get("bpm", 120)), label="Tempo (BPM)")
-                drum_beat = gr.Dropdown(choices=["none", "standard rock", "techno kick", "funk groove", "jazz swing", "orchestral percussion"], value=str(SETTINGS.get("drum_beat", "none")), label="Drum Beat")
-                synthesizer = gr.Dropdown(choices=["none", "analog synth", "digital pad", "arpeggiated synth", "strings", "brass", "choir"], value=str(SETTINGS.get("synthesizer", "none")), label="Synthesizer / Section")
-                rhythmic_steps = gr.Dropdown(choices=["none", "steady steps", "syncopated steps", "complex steps"], value=str(SETTINGS.get("rhythmic_steps", "none")), label="Rhythmic Steps")
-                bass_style = gr.Dropdown(choices=["none", "slap bass", "deep bass", "melodic bass", "contrabass ostinato"], value=str(SETTINGS.get("bass_style", "none")), label="Bass Style")
-                guitar_style = gr.Dropdown(choices=["none", "distorted", "clean", "jangle"], value=str(SETTINGS.get("guitar_style", "none")), label="Guitar Style")
-
-                target_volume = gr.Slider(-30.0, -20.0, step=0.5, value=float(SETTINGS.get("target_volume", -23.0)), label="Target Loudness (dBFS RMS)")
-                preset = gr.Dropdown(choices=["default", "rock", "techno", "grunge", "indie", "funk_rock"], value=str(SETTINGS.get("preset", "default")), label="Preset")
-                max_steps = gr.Dropdown(choices=[1000, 1200, 1300, 1500], value=int(SETTINGS.get("max_steps", 1500)), label="Max Steps (info)")
-                bitrate_state = gr.State(value=str(SETTINGS.get("bitrate", "192k")))
-                sample_rate_state = gr.State(value=str(SETTINGS.get("output_sample_rate", "48000")))
-                bit_depth_state = gr.State(value=str(SETTINGS.get("bit_depth", "16")))
+            gr.Markdown("#### Band / Style (auto grid: 4 per row, 5 on wide screens)")
+            style_buttons = {}
+            with gr.Group(elem_id="genre-grid"):
+                # Put all buttons as direct children (no rows) so CSS grid works cleanly
+                for key in PROFILES.keys():
+                    style_buttons[key] = gr.Button(PROFILES[key]["label"], elem_classes=["style-btn"])
+
+        with gr.Column(elem_classes="settings-container"):
+            gr.Markdown("### Settings")
+            with gr.Group(elem_classes="group-container"):
+                cfg_scale = gr.Slider(1.0, 10.0, step=0.1, value=float(loaded.get("cfg_scale", DEFAULT_SETTINGS["cfg_scale"])), label="CFG Scale")
+                top_k = gr.Slider(10, 500, step=10, value=int(loaded.get("top_k", DEFAULT_SETTINGS["top_k"])), label="Top-K")
+                top_p = gr.Slider(0.0, 1.0, step=0.01, value=float(loaded.get("top_p", DEFAULT_SETTINGS["top_p"])), label="Top-P")
+                temperature = gr.Slider(0.1, 2.0, step=0.01, value=float(loaded.get("temperature", DEFAULT_SETTINGS["temperature"])), label="Temperature")
+                total_duration = gr.Dropdown(choices=[30, 60, 90, 120], value=int(loaded.get("total_duration", 60)), label="Song Length (seconds)")
+                bpm = gr.Slider(60, 180, step=1, value=int(loaded.get("bpm", 120)), label="Tempo (BPM)")
+                drum_beat = gr.Dropdown(choices=["none", "standard rock", "funk groove", "techno kick", "jazz swing", "orchestral percussion", "tympani"], value=str(loaded.get("drum_beat", "none")), label="Drum Beat")
+                synthesizer = gr.Dropdown(choices=["none", "analog synth", "digital pad", "arpeggiated synth"], value=str(loaded.get("synthesizer", "none")), label="Synthesizer")
+                rhythmic_steps = gr.Dropdown(choices=["none", "syncopated steps", "steady steps", "complex steps", "martial march", "triplet swells", "staccato ostinato"], value=str(loaded.get("rhythmic_steps", "none")), label="Rhythmic Steps")
+                bass_style = gr.Dropdown(choices=["none", "slap bass", "deep bass", "melodic bass", "low brass", "cellos", "double basses"], value=str(loaded.get("bass_style", "none")), label="Bass / Low End")
+                guitar_style = gr.Dropdown(choices=["none", "distorted", "clean", "jangle", "downpicked", "thrash riffing"], value=str(loaded.get("guitar_style", "none")), label="Guitar Style")
+                target_volume = gr.Slider(-30.0, -20.0, step=0.5, value=float(loaded.get("target_volume", -23.0)), label="Target Loudness (dBFS RMS)")
+                preset = gr.Dropdown(choices=["default", "rock", "techno", "grunge", "indie", "funk_rock"], value=str(loaded.get("preset", "default")), label="Preset")
+                max_steps = gr.Dropdown(choices=[1000, 1200, 1300, 1500], value=int(loaded.get("max_steps", 1500)), label="Max Steps (per chunk hint)")
+
+                bitrate_state = gr.State(value=str(loaded.get("bitrate", "192k")))
+                sample_rate_state = gr.State(value=str(loaded.get("output_sample_rate", "48000")))
+                bit_depth_state = gr.State(value=str(loaded.get("bit_depth", "16")))
 
                 with gr.Row():
-                    br128 = gr.Button("Bitrate 128k")
-                    br192 = gr.Button("Bitrate 192k")
-                    br320 = gr.Button("Bitrate 320k")
+                    bitrate_128_btn = gr.Button("Bitrate 128k")
+                    bitrate_192_btn = gr.Button("Bitrate 192k")
+                    bitrate_320_btn = gr.Button("Bitrate 320k")
                 with gr.Row():
-                    sr22 = gr.Button("SR 22.05k")
-                    sr44 = gr.Button("SR 44.1k")
-                    sr48 = gr.Button("SR 48k")
+                    sample_rate_22050_btn = gr.Button("SR 22.05k")
+                    sample_rate_44100_btn = gr.Button("SR 44.1k")
+                    sample_rate_48000_btn = gr.Button("SR 48k")
                 with gr.Row():
-                    bd16 = gr.Button("16-bit")
-                    bd24 = gr.Button("24-bit")
+                    bit_depth_16_btn = gr.Button("16-bit")
+                    bit_depth_24_btn = gr.Button("24-bit")
 
+            with gr.Row():
                 gen_btn = gr.Button("Generate Music 🚀")
                 clr_btn = gr.Button("Clear 🧹")
                 save_btn = gr.Button("Save Settings 💾")
                 load_btn = gr.Button("Load Settings 📂")
                 reset_btn = gr.Button("Reset Defaults ♻️")
 
-        with gr.Column():
+        with gr.Column(elem_classes="output-container"):
             gr.Markdown("### Output")
-            out_audio = gr.Audio(label="Generated Track (saved in ./mp3)", type="filepath")
+            out_audio = gr.Audio(label="Generated Track", type="filepath")
             status_box = gr.Textbox(label="Status", interactive=False)
             vram_box = gr.Textbox(label="VRAM Usage", interactive=False, value="")
-            log_btn = gr.Button("View Log 📋")
-            log_output = gr.Textbox(label="Log Contents", lines=18, interactive=False)
 
-    def on_genre_click(sec, bpm_v, drum_v, synth_v, steps_v, bass_v, guitar_v):
-        return build_prompt_from_section(sec, bpm_v, drum_v, synth_v, steps_v, bass_v, guitar_v)
+        with gr.Column(elem_classes="logs-container"):
+            gr.Markdown("### Logs")
+            log_output = gr.Textbox(label="Last Log File", lines=16, interactive=False)
+            log_btn = gr.Button("View Last Log")
+
+        # Wire style buttons -> prompt textbox
+        for key, btn in style_buttons.items():
+            btn.click(
+                ui_prompt_from_style,
+                inputs=[gr.State(key), bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style],
+                outputs=instrumental_prompt
+            )
 
-    for btn, sec in genre_buttons:
-        btn.click(
-            on_genre_click,
-            inputs=[gr.State(sec), bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style],
-            outputs=instrumental_prompt
+        # Quick sets
+        bitrate_128_btn.click(set_bitrate_128, outputs=bitrate_state)
+        bitrate_192_btn.click(set_bitrate_192, outputs=bitrate_state)
+        bitrate_320_btn.click(set_bitrate_320, outputs=bitrate_state)
+        sample_rate_22050_btn.click(set_sample_rate_22050, outputs=sample_rate_state)
+        sample_rate_44100_btn.click(set_sample_rate_44100, outputs=sample_rate_state)
+        sample_rate_48000_btn.click(set_sample_rate_48000, outputs=sample_rate_state)
+        bit_depth_16_btn.click(set_bit_depth_16, outputs=bit_depth_state)
+        bit_depth_24_btn.click(set_bit_depth_24, outputs=bit_depth_state)
+
+        # Generate
+        gen_btn.click(
+            generate_music,
+            inputs=[
+                instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+                drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+                preset, max_steps, vram_box, bitrate_state, sample_rate_state, bit_depth_state
+            ],
+            outputs=[out_audio, status_box, vram_box]
         )
 
-    br128.click(lambda: "128k", outputs=bitrate_state)
-    br192.click(lambda: "192k", outputs=bitrate_state)
-    br320.click(lambda: "320k", outputs=bitrate_state)
-    sr22.click(lambda: "22050", outputs=sample_rate_state)
-    sr44.click(lambda: "44100", outputs=sample_rate_state)
-    sr48.click(lambda: "48000", outputs=sample_rate_state)
-    bd16.click(lambda: "16", outputs=bit_depth_state)
-    bd24.click(lambda: "24", outputs=bit_depth_state)
-
-    gen_btn.click(
-        generate_music_wrapper,
-        inputs=[
-            instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
-            drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style,
-            target_volume, preset, max_steps, vram_box, bitrate_state, sample_rate_state, bit_depth_state
-        ],
-        outputs=[out_audio, status_box, vram_box]
-    )
-
-    def clear_inputs():
-        s = DEFAULT_SETTINGS.copy()
-        return (
-            s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
-            s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
-            s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
-            s["bitrate"], s["output_sample_rate"], s["bit_depth"]
+        # Clear
+        clr_btn.click(
+            clear_inputs, outputs=[
+                instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+                drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+                preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state
+            ]
         )
-    clr_btn.click(
-        clear_inputs,
-        outputs=[
-            instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
-            drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
-            preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state
-        ]
-    )
 
-    def _save_action(ip, cs, tk, tp, tt, dur, bpm_v, d, s, rs, b, g, tv, pr, ms, br, sr, bd):
-        data = {
-            "instrumental_prompt": ip, "cfg_scale": float(cs), "top_k": int(tk), "top_p": float(tp),
-            "temperature": float(tt), "total_duration": int(dur), "bpm": int(bpm_v),
-            "drum_beat": str(d), "synthesizer": str(s), "rhythmic_steps": str(rs),
-            "bass_style": str(b), "guitar_style": str(g), "target_volume": float(tv),
-            "preset": str(pr), "max_steps": int(ms), "bitrate": str(br),
-            "output_sample_rate": str(sr), "bit_depth": str(bd)
-        }
-        save_settings(data)
-        for k, v in data.items(): SETTINGS[k] = v
-        return "✅ Settings saved."
-    save_btn.click(
-        _save_action,
-        inputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+        # Save / Load / Reset
+        def _save_action(
+            instrumental_prompt_v, cfg_v, top_k_v, top_p_v, temp_v, dur_v, bpm_v,
+            drum_v, synth_v, steps_v, bass_v, guitar_v, vol_v, preset_v, maxsteps_v, br_v, sr_v, bd_v
+        ):
+            s = {
+                "instrumental_prompt": instrumental_prompt_v,
+                "cfg_scale": float(cfg_v),
+                "top_k": int(top_k_v),
+                "top_p": float(top_p_v),
+                "temperature": float(temp_v),
+                "total_duration": int(dur_v),
+                "bpm": int(bpm_v),
+                "drum_beat": str(drum_v),
+                "synthesizer": str(synth_v),
+                "rhythmic_steps": str(steps_v),
+                "bass_style": str(bass_v),
+                "guitar_style": str(guitar_v),
+                "target_volume": float(vol_v),
+                "preset": str(preset_v),
+                "max_steps": int(maxsteps_v),
+                "bitrate": str(br_v),
+                "output_sample_rate": str(sr_v),
+                "bit_depth": str(bd_v)
+            }
+            save_settings_to_file(s)
+            for k, v in s.items():
+                CURRENT_SETTINGS[k] = v
+            return "✅ Settings saved."
+
+        def _load_action():
+            s = load_settings_from_file()
+            for k, v in s.items():
+                CURRENT_SETTINGS[k] = v
+            return (
+                s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
+                s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
+                s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
+                s["bitrate"], s["output_sample_rate"], s["bit_depth"],
+                "✅ Settings loaded."
+            )
+
+        def _reset_action():
+            s = DEFAULT_SETTINGS.copy()
+            save_settings_to_file(s)
+            for k, v in s.items():
+                CURRENT_SETTINGS[k] = v
+            return (
+                s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
+                s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
+                s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
+                s["bitrate"], s["output_sample_rate"], s["bit_depth"],
+                "✅ Defaults restored."
+            )
+
+        save_btn.click(
+            _save_action,
+            inputs=[
+                instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
                 drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
-                preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state],
-        outputs=status_box
-    )
+                preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state
+            ],
+            outputs=status_box
+        )
 
-    def _load_action():
-        s = load_settings()
-        for k, v in s.items(): SETTINGS[k] = v
-        return (
-            s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
-            s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
-            s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
-            s["bitrate"], s["output_sample_rate"], s["bit_depth"],
-            "✅ Settings loaded."
+        load_btn.click(
+            _load_action,
+            outputs=[
+                instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+                drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+                preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, status_box
+            ]
         )
-    load_btn.click(_load_action,
-        outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
-                 drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
-                 preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, status_box]
-    )
 
-    def _reset_action():
-        s = DEFAULT_SETTINGS.copy()
-        save_settings(s)
-        for k, v in s.items(): SETTINGS[k] = v
-        return (
-            s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
-            s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
-            s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
-            s["bitrate"], s["output_sample_rate"], s["bit_depth"], "✅ Defaults restored."
+        reset_btn.click(
+            _reset_action,
+            outputs=[
+                instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+                drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+                preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, status_box
+            ]
         )
-    reset_btn.click(_reset_action,
-        outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
-                 drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
-                 preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, status_box]
-    )
 
-    log_btn.click(get_latest_log, outputs=log_output)
+        log_btn.click(get_latest_log, outputs=log_output)
 
-logger.info("Launching Gradio UI at http://0.0.0.0:9999 ...")
+    with gr.TabItem("Info", id="tab-info"):
+        gr.Markdown(read_example_md())
+
+# ======================================================================================
+# LAUNCH GRADIO
+# ======================================================================================
+
+logger.info(f"Launching Gradio UI at http://0.0.0.0:9999 ({RELEASE}) ...")
 try:
-    demo.launch(server_name="0.0.0.0", server_port=9999, share=False, inbrowser=False, show_error=True)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=9999,
+        share=False,
+        inbrowser=False,
+        show_error=True
+    )
 except Exception as e:
-    logger.error(f"Gradio launch failed: {e}")
+    logger.error(f"Failed to launch Gradio UI: {e}")
     logger.error(traceback.format_exc())
     sys.exit(1)

public/styles.css

@@ -1,58 +1,79 @@
-/* styles.css */
-/* High-contrast, accessible theme (no inline HTML in Python). ADA-focused: focus rings, large targets, readable contrast. */
+/* =========================
+   FILE: styles.css
+   ========================= */
+:root {
+  color-scheme: dark;
+  --bg:#0B0B0D;
+  --panel:#101114;
+  --elev:#15161B;
 
-:root { color-scheme: dark; }
+  --text:#F3F4F6;
+  --muted:#9CA3AF;
 
-* { box-sizing: border-box; }
-
-body, .gradio-container {
-  background: #0B0B0D !important;
-  color: #FFFFFF !important;
-  font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, "Apple Color Emoji","Segoe UI Emoji";
-  line-height: 1.4;
+  /* Accents use a professional triad rather than heavy blue */
+  --accent:#6EE7B7;   /* mint (primary) */
+  --accent2:#FDE047;  /* warm yellow (secondary) */
+  --accent3:#60A5FA;  /* soft blue (tertiary) */
+  --focus:#22D3EE;    /* cyan outline */
 }
 
-h1, h2, h3, h4, h5, h6, label, p, span {
-  color: #FFFFFF !important;
+body, .gradio-container { background: var(--bg) !important; color: var(--text) !important; }
+* { color: var(--text) !important; }
+.wrap, .block, .tabs, .panel, .form { background: transparent !important; }
+
+.header {
+  text-align:center; padding: 14px 16px;
+  border-bottom: 2px solid var(--accent);
+  background: var(--panel);
 }
+.header h1 { font-size: 28px; margin: 6px 0 0 0; }
+.header .logo { font-size: 44px; }
+.small { font-size: 12px; color: var(--muted) !important; }
 
-.block, .panel, .wrap, .tabs, .tabitem, .form, .group {
-  background: #0B0B0D !important;
+.group {
+  border:1px solid #23242A; border-radius: 12px;
+  padding: 14px; margin-bottom: 14px; background: var(--elev);
 }
 
+label, p, span, h2, h3, h4 { color: var(--text) !important; }
+
 input, textarea, select {
-  background: #15151A !important;
-  color: #FFFFFF !important;
-  border: 1px solid #2B2B33 !important;
-  border-radius: 10px !important;
-  padding: 10px 12px !important;
+  background: #0F1115 !important; color: var(--text) !important;
+  border:1px solid #252833 !important; border-radius: 10px !important;
 }
 
 button {
-  background: #1F6FEB !important;
-  color: #FFFFFF !important;
-  border: 2px solid transparent !important;
-  border-radius: 10px !important;
-  padding: 12px 14px !important;
-  font-weight: 700 !important;
-  min-height: 44px; /* touch target */
+  background: #1F2937 !important; color: var(--text) !important;
+  border: 1px solid #303644 !important; border-radius: 10px !important;
+  padding: 8px 12px !important; font-weight: 700 !important;
+  transition: border-color .15s ease, transform .05s ease;
 }
+button:hover { background: #222D3D !important; border-color: var(--accent3) !important; }
+button:active { transform: translateY(1px); }
+button:focus { outline: 3px solid var(--focus) !important; }
+.slider > input { accent-color: var(--accent3) !important; }
 
-button:hover { background: #2D7BFF !important; }
-button:focus { outline: 3px solid #00C853 !important; outline-offset: 2px; }
-
-.group > * + * { margin-top: 8px; }
-.row { gap: 8px; }
-
-.audio-wrap, .audio-display, .output-html {
-  border: 1px solid #2B2B33 !important;
+/* Compact grid for band/style buttons only */
+#genre-grid {
+  display: grid;
+  grid-template-columns: repeat(5, minmax(140px, 1fr));
+  gap: 8px;
+  padding: 8px;
+  border: 1px solid #23242A;
+  border-radius: 12px;
+  background: var(--elev);
+  max-height: 320px;
+  overflow: auto;
+}
+@media (max-width: 1200px) {
+  #genre-grid { grid-template-columns: repeat(4, minmax(140px, 1fr)); }
+}
+#genre-grid > * { margin: 0 !important; }
+#genre-grid button {
+  padding: 6px 10px !important;
+  font-size: 0.9rem !important;
+  line-height: 1.15 !important;
   border-radius: 10px !important;
+  border-color: #2B3140 !important;
 }
-
-.slider > input[type="range"] { accent-color: #FFD600 !important; }
-
-/* Large labels for readability */
-label { font-size: 16px !important; font-weight: 700 !important; }
-
-/* Subtle card border around control groups */
-.group { border: 1px solid #2B2B33; border-radius: 12px; padding: 12px; }
+#genre-grid button:hover { border-color: var(--accent2) !important; }