diff --git a/CHANGELOG.md b/CHANGELOG.md
index 19b3d8d0..67cd8ad4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   "fret" no longer reads as an arbitrary number. Tests:
   `tests/anchor_authoring.test.js` (full-set promotion on click + on add-new,
   undo-restores-fallback, idempotent-when-authored).
+- **Create a song from audio alone — "New…" no longer forces a Guitar Pro / EOF
+  file.** The create modal labelled its Guitar Pro and EOF XML inputs *optional*
+  but hard-disabled the Create button unless one was picked, and its
+  blank-chart options (initial arrangement + drum tab) were never wired up — so
+  an audio-only feedpak could only be made through a second, separate "New
+  Sloppak" dialog. The modal now leads with an explicit **Blank / Guitar Pro /
+  EOF XML** mode picker (Blank is the default): Blank shows the initial-
+  arrangement toggle (Lead / Rhythm / Bass) + a drum-tab option and enables
+  Create on audio + title + artist, routing to the existing `create_sloppak`
+  backend and opening the new feedpak straight in the editor; the GP and EOF
+  modes keep their import flows. The "New" chooser's entries now open this one
+  unified modal (in Blank / GP mode) instead of a parallel dialog, and the
+  toolbar's **Build Song** button is renamed **Build feedpak**. Tests:
+  `tests/create_gate.test.js` (per-mode Create-button enable logic). Keys /
+  Drums-as-arrangement and extended tunings still need `create_sloppak` backend
+  work (tracked separately); the now-unreferenced standalone New-Sloppak dialog
+  can be removed in a follow-up.
 
 ### Changed
 - **The audio lane now draws a real waveform.** It previously showed a
diff --git a/routes.py b/routes.py
index 15aa9d93..8ad2e022 100644
--- a/routes.py
+++ b/routes.py
@@ -1315,6 +1315,58 @@ def _guide_tones_wire(tones):
             if isinstance(v, int) and not isinstance(v, bool) and 0 <= v <= 11]
 
 
+def _extended_manifest_meta(src) -> dict:
+    """Normalize the spec-complete optional manifest fields (album_artist, track,
+    disc, genres, isrc, mbid, language, authors) from a create/import request
+    into the shapes `_write_sloppak_pak` expects — so a Guitar Pro / EOF import
+    persists the same metadata the blank-create path does (these fields are shown
+    for every create flow but were previously written only for blank projects).
+    Lenient: a malformed field is skipped, not an error (secondary to the import).
+    """
+    if not isinstance(src, dict):
+        return {}
+    out: dict = {}
+
+    def _s(name):
+        v = src.get(name)
+        return v.strip() if isinstance(v, str) else ""
+
+    for _k in ("album_artist", "language"):
+        if _s(_k):
+            out[_k] = _s(_k)
+    if _s("mbid"):
+        out["mbid"] = _s("mbid").lower()
+    if _s("isrc"):
+        out["isrc"] = re.sub(r"[\s-]", "", _s("isrc")).upper()
+    for _k in ("track", "disc"):
+        v = src.get(_k)
+        if isinstance(v, bool):
+            continue
+        if isinstance(v, int):
+            out[_k] = v
+        elif isinstance(v, str) and v.strip().lstrip("-").isdigit():
+            out[_k] = int(v.strip())
+
+    def _list(name):
+        v = src.get(name)
+        if isinstance(v, str):
+            v = re.split(r"[,\n]", v)
+        items, seen = [], set()
+        if isinstance(v, list):
+            for it in v:
+                s = str(it).strip() if it is not None else ""
+                if s and s not in seen:
+                    seen.add(s)
+                    items.append(s)
+        return items
+
+    for _k in ("genres", "authors"):
+        vals = _list(_k)
+        if vals:
+            out[_k] = vals
+    return out
+
+
 def _safe_float(v, default=0.0):
     """Best-effort float coercion; returns `default` for bad input."""
     if v is None:
@@ -2761,6 +2813,54 @@ def _name_meta(full: Path) -> tuple:
         files.sort(key=lambda x: x["filename"])
         return files
 
+    @app.post("/api/plugins/editor/browse")
+    async def browse_dlc(data: dict):
+        """List ONE directory level inside the DLC/song-library folder so the
+        Load dialog can act as a file browser rooted at the library. `path` is a
+        DLC-relative POSIX subpath ("" = the library root). Returns the absolute
+        root (for display), the current relative path + its parent, the
+        subfolders, and the loadable feedpak/sloppak files at this level."""
+        dlc_dir = get_dlc_dir()
+        if not dlc_dir or not dlc_dir.exists():
+            return JSONResponse({"error": "DLC folder not configured"}, 400)
+        root = dlc_dir.resolve()
+        rel = str((data or {}).get("path") or "").strip().replace("\\", "/").strip("/")
+        target = (root / rel).resolve() if rel else root
+        # Containment — never list outside the library.
+        try:
+            target.relative_to(root)
+        except ValueError:
+            return JSONResponse({"error": "forbidden"}, 403)
+        if not target.is_dir():
+            target, rel = root, ""
+        _FORMATS = {".feedpak": "sloppak", ".sloppak": "sloppak"}
+        dirs: list = []
+        files: list = []
+        try:
+            entries = sorted(target.iterdir(), key=lambda p: p.name.lower())
+        except OSError:
+            entries = []
+        for entry in entries:
+            ext = entry.suffix.lower()
+            try:
+                erel = entry.relative_to(root).as_posix()
+            except ValueError:
+                continue
+            if entry.is_dir():
+                if ext in (".feedpak", ".sloppak"):
+                    # Authoring-form package dir — a loadable "file", not a folder.
+                    files.append({"filename": erel, "name": entry.name, "format": "sloppak"})
+                else:
+                    dirs.append({"name": entry.name, "path": erel})
+            elif entry.is_file() and ext in _FORMATS:
+                files.append({"filename": erel, "name": entry.name, "format": _FORMATS[ext]})
+        parent = None
+        if rel:
+            p = Path(rel).parent.as_posix()
+            parent = "" if p == "." else p
+        return {"root": str(root), "cwd": rel, "parent": parent,
+                "dirs": dirs, "files": files}
+
     # ── Load a custom song for editing ──────────────────────────────────────────
 
     @app.post("/api/plugins/editor/load")
@@ -3698,8 +3798,10 @@ async def create_sloppak(
         if audio_url is not None and not isinstance(audio_url, str):
             return JSONResponse({"error": "audio_url must be a string"}, 400)
         audio_url = (audio_url or "").strip()
-        if audio is None and not audio_url:
-            return JSONResponse({"error": "audio file or audio_url required"}, 400)
+        # Draft-now, audio-later: audio is OPTIONAL. With neither an upload nor a
+        # pre-uploaded audio_url we still create a work-in-progress pack (empty
+        # `stems: []`); the author supplies real audio later via Replace Audio.
+        has_audio = audio is not None or bool(audio_url)
 
         # Optional album art, passed as a storage path returned by
         # /upload-art. Validate containment under STORAGE_DIR before
@@ -3738,72 +3840,99 @@ def _str_field(name: str, default: str = "") -> str | None:
             return JSONResponse({"error": "artist must be a string"}, 400)
         if not title:
             return JSONResponse({"error": "title required"}, 400)
-        if not artist:
-            return JSONResponse({"error": "artist required"}, 400)
-
-        arr_name = _str_field("initial_arrangement", "Lead")
-        if arr_name is None:
+        # Artist is OPTIONAL for a draft — only the title is required to create a
+        # work-in-progress pack. `artist` may be "" here (written through as-is).
+
+        # Optional "Authored by" credit(s) -> manifest `authors:` (feedpak is an
+        # open format; credit whoever makes the file, don't gate on it). Accept a
+        # single string (the modal's one text field; users comma/newline-separate
+        # names) OR a list. Normalize to a de-duped list of trimmed strings.
+        authors_in = meta_in.get("authors")
+        if isinstance(authors_in, str):
+            authors_in = re.split(r"[,\n]", authors_in)
+        authors: list[str] = []
+        if isinstance(authors_in, list):
+            _seen_auth: set[str] = set()
+            for _a in authors_in:
+                if isinstance(_a, str) and _a.strip() and _a.strip() not in _seen_auth:
+                    _seen_auth.add(_a.strip())
+                    authors.append(_a.strip())
+        elif authors_in is not None:
             return JSONResponse(
-                {"error": "initial_arrangement must be a string"}, 400,
+                {"error": "authors must be a string or a list of strings"}, 400,
             )
-        if not arr_name:
-            arr_name = "Lead"
-        if arr_name not in ("Lead", "Rhythm", "Bass"):
-            return JSONResponse(
-                {"error": "initial_arrangement must be Lead, Rhythm, or Bass"},
-                400,
-            )
-
-        # Strict length per chosen arrangement. Bass = 4 strings, the
-        # rest = 6. Reject anything else (1, 7, 20, …) so a malformed
-        # client can't accidentally request an extended-range or
-        # truncated arrangement through this entry point. (Extended-
-        # range support exists via the save-as-sloppak path, not here.)
-        expected_strings = 4 if arr_name == "Bass" else 6
-        tuning_in = meta_in.get("tuning")
 
         def _is_int(v) -> bool:
-            # bool is a subclass of int in Python; treat True/False as
-            # invalid here so a `True → 1` doesn't slip past.
+            # bool is a subclass of int in Python; treat True/False as invalid
+            # so a `True → 1` doesn't slip past int fields (track/disc).
             return isinstance(v, int) and not isinstance(v, bool)
 
-        if tuning_in is None:
-            tuning = [0] * expected_strings
-        elif isinstance(tuning_in, list) and len(tuning_in) == expected_strings:
-            if not all(_is_int(t) for t in tuning_in):
+        # Roster of arrangements to seed ("What are you arranging?"). The modal
+        # sends `arrangements`: the list of canonical role names the user dragged
+        # in. Back-compat: a single `initial_arrangement` string is still
+        # accepted. Roles map to editor modes by NAME — Lead/Rhythm/Bass →
+        # fretted, Keys → piano-roll (type:piano), Drums → drum_tab. Vocals is
+        # NOT an arrangement (feedpak models it as side-files); it seeds an empty
+        # lyrics track and needs at least one instrument alongside it, since the
+        # spec requires a non-empty arrangements list. String counts are NOT
+        # chosen here — fretted roles get a default standard tuning (Bass 4,
+        # guitar 6) and the editor extends the range (up to 9-string guitar /
+        # 6-string bass) after creation.
+        _FRETTED = ("Lead", "Rhythm", "Bass")
+        _INSTRUMENTS = _FRETTED + ("Keys", "Drums")
+        _ALL_ROLES = _INSTRUMENTS + ("Vocals",)
+        _ROLE_ALIASES = {
+            "Lead Guitar": "Lead", "Rhythm Guitar": "Rhythm",
+            "Bass Guitar": "Bass", "Piano": "Keys", "Keyboard": "Keys",
+            "Vocal": "Vocals", "Voice": "Vocals",
+        }
+
+        roster_in = meta_in.get("arrangements")
+        if roster_in is None:
+            # Legacy shape: `initial_arrangement` (single role) + `init_drum_tab`
+            # (bool, default True). Translate both into the roster so an older
+            # client still gets its requested drum tab — in the new model a
+            # "Drums" role IS the drum tab (see init_drums below).
+            single = _str_field("initial_arrangement", "Lead") or "Lead"
+            roster_in = [single]
+            legacy_drums = meta_in.get("init_drum_tab", True)
+            if not isinstance(legacy_drums, bool):
+                return JSONResponse({"error": "init_drum_tab must be a boolean"}, 400)
+            if legacy_drums:
+                roster_in.append("Drums")
+        if not isinstance(roster_in, list) or not roster_in:
+            return JSONResponse(
+                {"error": "arrangements must be a non-empty list of roles"}, 400,
+            )
+        roster: list[str] = []
+        for _r in roster_in:
+            if not isinstance(_r, str):
                 return JSONResponse(
-                    {"error": "tuning entries must be integers (no floats or booleans)"},
+                    {"error": "each arrangement role must be a string"}, 400,
+                )
+            _r = _ROLE_ALIASES.get(_r.strip(), _r.strip())
+            if _r not in _ALL_ROLES:
+                return JSONResponse(
+                    {"error": (
+                        f"unknown arrangement role '{_r}' — expected one of "
+                        f"{', '.join(_ALL_ROLES)}"
+                    )},
                     400,
                 )
-            tuning = list(tuning_in)
-        else:
+            if _r not in roster:
+                roster.append(_r)
+        want_vocals = "Vocals" in roster
+        instrument_roster = [r for r in roster if r in _INSTRUMENTS]
+        if not instrument_roster:
             return JSONResponse(
                 {"error": (
-                    f"tuning must be a list of {expected_strings} ints "
-                    f"for an initial '{arr_name}' arrangement"
+                    "select at least one instrument to chart "
+                    "(Lead, Rhythm, Bass, Keys, or Drums)"
                 )},
                 400,
             )
-
-        capo_raw = meta_in.get("capo", 0)
-        if not _is_int(capo_raw):
-            return JSONResponse(
-                {"error": "capo must be an integer"}, 400,
-            )
-        if capo_raw < 0:
-            return JSONResponse(
-                {"error": "capo must be non-negative"}, 400,
-            )
-        capo = capo_raw
-
-        # Strict bool check — client JSON-derived; the string "false"
-        # would otherwise become truthy and silently enable drum_tab.
-        init_drums_raw = meta_in.get("init_drum_tab", True)
-        if not isinstance(init_drums_raw, bool):
-            return JSONResponse(
-                {"error": "init_drum_tab must be a boolean"}, 400,
-            )
-        init_drums = init_drums_raw
+        # A Drums arrangement IS its drum tab — seed one iff Drums is selected.
+        init_drums = "Drums" in instrument_roster
 
         dlc_dir = get_dlc_dir()
         if not dlc_dir:
@@ -3825,12 +3954,14 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
         safe_a = _truncate_utf8(
             re.sub(r'[<>:"/\\|?*]', "_", artist), _MAX_FILENAME_PART_BYTES,
         ).rstrip(". ")
-        if not safe_t or not safe_a:
+        if not safe_t:
             return JSONResponse(
-                {"error": "title and artist must contain non-blank characters"},
+                {"error": "title must contain non-blank characters"},
                 400,
             )
-        new_filename = f"{safe_t}_{safe_a}.feedpak"
+        # Artist may be blank on a draft (or sanitise to empty) — fall back to a
+        # title-only filename rather than an ugly trailing-underscore name.
+        new_filename = f"{safe_t}_{safe_a}.feedpak" if safe_a else f"{safe_t}.feedpak"
         output_path = (dlc_dir / new_filename).resolve()
         # Containment check — the sanitiser above strips path separators,
         # but defend against a `.. .. ..` -style title that somehow
@@ -3879,6 +4010,9 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                 ".mp3", ".wav", ".flac", ".m4a", ".ogg", ".opus",
                 ".aac", ".aiff", ".wma",
             }
+            # Stays None when no audio is supplied (draft-now): the encode block
+            # below is guarded on it and `ogg_path` stays None.
+            in_ext = None
             if audio is not None:
                 _raw_ext = Path(audio.filename or "audio").suffix.lower()
                 in_ext = _raw_ext if _raw_ext in _KNOWN_AUDIO_EXTS else ".bin"
@@ -3893,7 +4027,7 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                         if not chunk:
                             break
                         dst.write(chunk)
-            else:
+            elif audio_url:
                 # Pre-uploaded audio: resolve the storage URL to a local
                 # file (validates containment) and copy it into the temp
                 # dir so the re-encode path below is identical to the
@@ -3908,61 +4042,78 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                 in_path = upload_dir / f"upload{in_ext}"
                 shutil.copy2(resolved_audio, in_path)
 
-            ogg_path = upload_dir / "audio.ogg"
-            if in_ext == ".ogg":
-                # Rename instead of copy — both paths live in the same
-                # upload_dir (deleted at the end), so duplicating the
-                # bytes just doubles peak temp disk for nothing.
-                in_path.rename(ogg_path)
-                # Same min-size sanity check the re-encode branch
-                # enforces — a 0-byte / truncated .ogg would otherwise
-                # produce a sloppak that fails on first open.
-                if (not ogg_path.exists()
-                        or ogg_path.stat().st_size < 100):
-                    return JSONResponse(
-                        {"error": "uploaded .ogg is empty or too small to play"},
-                        400,
-                    )
-            else:
-                from lib.audio import _ffmpeg_cmd, _ffmpeg_wav_to_ogg
-                ffmpeg = _ffmpeg_cmd()
-                if not ffmpeg:
-                    return JSONResponse(
-                        {"error": "ffmpeg not available — can't re-encode audio"},
-                        500,
-                    )
-                try:
-                    r = await asyncio.get_event_loop().run_in_executor(
-                        None, _ffmpeg_wav_to_ogg, ffmpeg, in_path, ogg_path,
-                    )
-                except Exception:
-                    # str(e) on subprocess / OSError commonly embeds the
-                    # ffmpeg cmd line and absolute paths — log it
-                    # server-side and return a generic message.
-                    import logging as _log
-                    _log.getLogger("slopsmith.plugin.editor").exception(
-                        "create_sloppak: ffmpeg re-encode raised",
-                    )
-                    return JSONResponse(
-                        {"error": "audio re-encode failed — see server logs"},
-                        400,
-                    )
-                if (r.returncode != 0 or not ogg_path.exists()
-                        or ogg_path.stat().st_size < 100):
-                    return JSONResponse(
-                        {"error": "ffmpeg failed to decode the uploaded audio"},
-                        400,
-                    )
+            # None → no audio supplied: skip encode, leave ogg_path None so the
+            # write emits an empty `stems: []` draft.
+            ogg_path = None
+            if in_ext is not None:
+                ogg_path = upload_dir / "audio.ogg"
+                if in_ext == ".ogg":
+                    # Rename instead of copy — both paths live in the same
+                    # upload_dir (deleted at the end), so duplicating the
+                    # bytes just doubles peak temp disk for nothing.
+                    in_path.rename(ogg_path)
+                    # Same min-size sanity check the re-encode branch
+                    # enforces — a 0-byte / truncated .ogg would otherwise
+                    # produce a sloppak that fails on first open.
+                    if (not ogg_path.exists()
+                            or ogg_path.stat().st_size < 100):
+                        return JSONResponse(
+                            {"error": "uploaded .ogg is empty or too small to play"},
+                            400,
+                        )
+                else:
+                    from lib.audio import _ffmpeg_cmd, _ffmpeg_wav_to_ogg
+                    ffmpeg = _ffmpeg_cmd()
+                    if not ffmpeg:
+                        return JSONResponse(
+                            {"error": "ffmpeg not available — can't re-encode audio"},
+                            500,
+                        )
+                    try:
+                        r = await asyncio.get_event_loop().run_in_executor(
+                            None, _ffmpeg_wav_to_ogg, ffmpeg, in_path, ogg_path,
+                        )
+                    except Exception:
+                        # str(e) on subprocess / OSError commonly embeds the
+                        # ffmpeg cmd line and absolute paths — log it
+                        # server-side and return a generic message.
+                        import logging as _log
+                        _log.getLogger("slopsmith.plugin.editor").exception(
+                            "create_sloppak: ffmpeg re-encode raised",
+                        )
+                        return JSONResponse(
+                            {"error": "audio re-encode failed — see server logs"},
+                            400,
+                        )
+                    if (r.returncode != 0 or not ogg_path.exists()
+                            or ogg_path.stat().st_size < 100):
+                        return JSONResponse(
+                            {"error": "ffmpeg failed to decode the uploaded audio"},
+                            400,
+                        )
 
-            # Build the minimal in-memory shapes _write_sloppak_pak expects.
-            arrangements_data = [{
-                "name": arr_name,
-                "tuning": tuning,
-                "capo": capo,
-                "notes": [],
-                "chords": [],
-                "chord_templates": [],
-            }]
+            # Build one in-memory arrangement per instrument role in the roster.
+            # Fretted roles carry a default standard tuning (Bass 4 strings,
+            # guitar 6 — the editor extends the count after creation); Keys
+            # carries the spec `type: piano`; Drums opens the drum lane by name.
+            # Each opens in the right editor mode by NAME (KEYS_PATTERN / ^drums).
+            def _default_tuning(role: str) -> list:
+                if role in _FRETTED:
+                    return [0] * (4 if role == "Bass" else 6)
+                return []
+            arrangements_data = []
+            for _role in instrument_roster:
+                _arr = {
+                    "name": _role,
+                    "tuning": _default_tuning(_role),
+                    "capo": 0,
+                    "notes": [],
+                    "chords": [],
+                    "chord_templates": [],
+                }
+                if _role == "Keys":
+                    _arr["type"] = "piano"
+                arrangements_data.append(_arr)
             # Seed a minimal one-measure 4/4 @ 120 BPM grid (downbeat +
             # three sub-beats + next downbeat = 5 beats). The Tempo Map
             # editor bails when beats.length < 2 ("No beat grid…"), so
@@ -4001,12 +4152,78 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                 return JSONResponse(
                     {"error": "year must be a number or string"}, 400,
                 )
+            # ── Spec-complete manifest metadata (feedpak §5.1) ──
+            # Every field is OPTIONAL and written through only when present.
+            def _opt_str(name):
+                v = meta_in.get(name)
+                if v is None:
+                    return ""
+                if not isinstance(v, str):
+                    raise ValueError(f"{name} must be a string")
+                return v.strip()
+
+            def _opt_int(name):
+                v = meta_in.get(name)
+                if v in (None, ""):
+                    return None
+                if isinstance(v, str) and v.strip().lstrip("-").isdigit():
+                    return int(v.strip())
+                if _is_int(v):
+                    return v
+                raise ValueError(f"{name} must be an integer")
+
+            try:
+                album_artist = _opt_str("album_artist")
+                language = _opt_str("language")
+                mbid = _opt_str("mbid").lower()
+                # ISRC: the bare 12-char code — strip the display hyphens/spaces
+                # and upper-case (feedpak §5.1). Not hard-rejected on length so a
+                # partial draft entry is tolerated.
+                isrc = re.sub(r"[\s-]", "", _opt_str("isrc")).upper()
+                track_no = _opt_int("track")
+                disc_no = _opt_int("disc")
+            except ValueError as _e:
+                return JSONResponse({"error": str(_e)}, 400)
+
+            # genres: accept a list OR a comma/newline string; normalise to a
+            # de-duped list of trimmed strings (most-specific first).
+            genres_in = meta_in.get("genres")
+            if isinstance(genres_in, str):
+                genres_in = re.split(r"[,\n]", genres_in)
+            genres: list[str] = []
+            if isinstance(genres_in, list):
+                _seen_g: set[str] = set()
+                for _g in genres_in:
+                    if isinstance(_g, str) and _g.strip() and _g.strip() not in _seen_g:
+                        _seen_g.add(_g.strip())
+                        genres.append(_g.strip())
+            elif genres_in is not None:
+                return JSONResponse(
+                    {"error": "genres must be a string or a list of strings"}, 400,
+                )
+
             meta_out = {
                 "title": title,
                 "artist": artist,
                 "album": album_raw,
                 "year": year_raw,
             }
+            if authors:
+                meta_out["authors"] = authors
+            if album_artist:
+                meta_out["album_artist"] = album_artist
+            if track_no is not None:
+                meta_out["track"] = track_no
+            if disc_no is not None:
+                meta_out["disc"] = disc_no
+            if genres:
+                meta_out["genres"] = genres
+            if mbid:
+                meta_out["mbid"] = mbid
+            if isrc:
+                meta_out["isrc"] = isrc
+            if language:
+                meta_out["language"] = language
 
             drum_tab: dict | None = None
             if init_drums:
@@ -4018,6 +4235,11 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                     "hits": [],
                 }
 
+            # Vocals in the roster seeds an EMPTY lyrics track (feedpak models
+            # vocals as side-files, not an arrangement). An empty list is a valid
+            # lyrics.json — the author fills syllables in later.
+            lyrics_seed: list | None = [] if want_vocals else None
+
             # Probe the actual audio duration so the sloppak's
             # manifest.duration reflects the song, not the 2-second
             # placeholder beat grid. Best-effort: if the probe fails
@@ -4029,7 +4251,7 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                 ffprobe = _bundled_or_path("ffprobe") or shutil.which("ffprobe")
             except Exception:
                 ffprobe = shutil.which("ffprobe")
-            if ffprobe:
+            if ffprobe and ogg_path is not None:
                 try:
                     pr = await asyncio.get_event_loop().run_in_executor(
                         None,
@@ -4049,8 +4271,15 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                     audio_duration = None
 
             def _do_write():
+                # Auto-generate the hover-to-listen preview from the master audio
+                # (no manual upload) — best-effort; absent for audio-less drafts.
+                preview_clip = ""
+                if ogg_path is not None:
+                    _pv = _make_preview_clip(Path(ogg_path), upload_dir)
+                    if _pv:
+                        preview_clip = str(_pv)
                 return _write_sloppak_pak(
-                    audio_file=str(ogg_path),
+                    audio_file=(str(ogg_path) if ogg_path is not None else ""),
                     art_path=art_path,
                     arrangements_data=arrangements_data,
                     beats=beats,
@@ -4058,6 +4287,8 @@ def _do_write():
                     meta=meta_out,
                     output_path=output_path,
                     drum_tab=drum_tab,
+                    lyrics=lyrics_seed,
+                    preview_path=preview_clip,
                     fail_if_exists=True,
                     duration_override=audio_duration,
                 )
@@ -4115,6 +4346,130 @@ async def upload_art(file: UploadFile = File(...)):
         dest.write_bytes(content)
         return {"art_path": str(dest)}
 
+    # ── Cover Art Archive — album-art picker from a MusicBrainz release ─────
+    # Cover art lives in the Cover Art Archive (CAA), keyed by RELEASE MBID —
+    # which the create modal's MusicBrainz "Match" already carries (a candidate's
+    # `release_id`). Fetched server-side (dodges browser CORS + gives us the
+    # bytes to bake into the pack) and cached under STORAGE_DIR.
+    _CAA_ID_RE = re.compile(r"^[0-9a-fA-F-]{1,64}$")
+    _CAA_MAX_BYTES = 10 * 1024 * 1024
+    _CAA_UA = "feedBack-editor/1.0 ( https://github.com/got-feedback/feedBack )"
+
+    _CAA_SECONDARY_SKIP = {"live", "compilation", "remix", "dj-mix",
+                           "mixtape/street", "demo", "interview", "audiobook",
+                           "spokenword"}
+
+    def _caa_fetch_front(cover_id: str, size: int = 500, kind: str = "release"):
+        """Front cover (size px) for a MusicBrainz `kind` ('release' or
+        'release-group') from coverartarchive.org, or None when there's no art /
+        on any error. `cover_id` is regex-validated by callers before the URL."""
+        import urllib.request
+        url = f"https://coverartarchive.org/{kind}/{cover_id}/front-{size}"
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": _CAA_UA})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                if getattr(resp, "status", 200) != 200:
+                    return None
+                data = resp.read(_CAA_MAX_BYTES + 1)
+        except Exception:
+            return None
+        if not data or len(data) > _CAA_MAX_BYTES or len(data) < 100:
+            return None
+        return data
+
+    async def _caa_cached(cover_id: str, kind: str = "release"):
+        """Cached cover file (fetch + cache on first use), or None when no art."""
+        tag = "rg_" if kind == "release-group" else ""
+        dest = STORAGE_DIR / f"caa_{tag}{cover_id}.jpg"
+        if dest.exists() and dest.stat().st_size > 100:
+            return dest
+        data = await asyncio.get_event_loop().run_in_executor(
+            None, _caa_fetch_front, cover_id, 500, kind)
+        if data is None:
+            return None
+        dest.write_bytes(data)
+        return dest
+
+    @app.get("/api/plugins/editor/caa-cover/{cover_id}")
+    async def caa_cover(cover_id: str, group: int = 0):
+        """Serve the CAA front cover for a release (or release-group when
+        ?group=1), cached. 404 when there's no art — the picker hides the tile.
+        Same-origin so it loads under the app's CSP without an external host."""
+        if not _CAA_ID_RE.match(cover_id or ""):
+            return JSONResponse({"error": "invalid id"}, 400)
+        dest = await _caa_cached(cover_id, "release-group" if group else "release")
+        if dest is None:
+            return JSONResponse({"error": "no cover art"}, 404)
+        return FileResponse(dest, media_type="image/jpeg")
+
+    @app.post("/api/plugins/editor/use-caa-cover")
+    async def use_caa_cover(data: dict):
+        """Pick a CAA cover as the pack's album art: fetch/cache it and return an
+        art_path under STORAGE_DIR that create_sloppak bakes in like an upload."""
+        cover_id = str((data or {}).get("release_id") or "")
+        kind = "release-group" if (data or {}).get("group") else "release"
+        if not _CAA_ID_RE.match(cover_id):
+            return JSONResponse({"error": "invalid id"}, 400)
+        dest = await _caa_cached(cover_id, kind)
+        if dest is None:
+            return JSONResponse({"error": "no cover art"}, 404)
+        return {"art_path": str(dest)}
+
+    # Album-centric cover search. MusicBrainz RELEASE-GROUPS carry reliable Album
+    # vs Live/Compilation typing (unlike recording releases), so searching them by
+    # artist + album/title and preferring the studio album surfaces the CANONICAL
+    # cover first — the fix for "art search shows random comp covers". Works
+    # art-first for title-tracks; for other songs, fill the Album (or run Match).
+    def _mb_release_group_covers(artist: str, query: str) -> list:
+        """Release-group search → [{id, title, year, studio}] studio-albums first."""
+        import urllib.request
+        import urllib.parse
+
+        def _phrase(s):
+            return s.replace("\\", "\\\\").replace('"', '\\"')
+
+        parts = []
+        if query:
+            parts.append('releasegroup:"%s"' % _phrase(query))
+        if artist:
+            parts.append('artist:"%s"' % _phrase(artist))
+        if not parts:
+            return []
+        url = ("https://musicbrainz.org/ws/2/release-group?"
+               + urllib.parse.urlencode(
+                   {"query": " AND ".join(parts), "fmt": "json", "limit": 15}))
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": _CAA_UA})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                body = json.loads(resp.read().decode("utf-8", "replace"))
+        except Exception:
+            return []
+        out = []
+        for rg in (body.get("release-groups") or []):
+            if not isinstance(rg, dict) or not rg.get("id"):
+                continue
+            secs = {str(s).lower() for s in (rg.get("secondary-types") or [])}
+            studio = (str(rg.get("primary-type", "")).lower() == "album"
+                      and not (secs & _CAA_SECONDARY_SKIP))
+            out.append({
+                "id": str(rg["id"]),
+                "title": str(rg.get("title", "") or ""),
+                "year": str(rg.get("first-release-date", "") or "")[:4],
+                "studio": studio,
+            })
+        out.sort(key=lambda g: (0 if g["studio"] else 1, g["year"] or "9999"))
+        return out
+
+    @app.get("/api/plugins/editor/cover-search")
+    async def cover_search(artist: str = "", query: str = ""):
+        """Album-centric cover candidates (release-groups) for the art picker.
+        `query` is the ALBUM (best) or the song title. Studio album first."""
+        if not (artist.strip() or query.strip()):
+            return {"covers": []}
+        covers = await asyncio.get_event_loop().run_in_executor(
+            None, _mb_release_group_covers, artist.strip(), query.strip())
+        return {"covers": covers}
+
     # ── Upload hover-preview clip ──────────────────────────────────────
     @app.post("/api/plugins/editor/upload-preview")
     async def upload_preview(file: UploadFile = File(...)):
@@ -4154,11 +4509,17 @@ async def upload_audio(file: UploadFile = File(...)):
             dest = STORAGE_DIR / f"editor_audio_{audio_id}{out_path.suffix.lower()}"
             shutil.copy2(out_path, dest)
             shutil.rmtree(out_path.parent, ignore_errors=True)
-            return {"audio_url": f"{STORAGE_URL}/{dest.name}"}
+            _dur = await asyncio.get_event_loop().run_in_executor(
+                None, _probe_audio_duration, dest)
+            return {"audio_url": f"{STORAGE_URL}/{dest.name}", "duration": _dur}
 
         dest = STORAGE_DIR / f"editor_audio_{audio_id}{ext}"
         dest.write_bytes(content)
-        return {"audio_url": f"{STORAGE_URL}/editor_audio_{audio_id}{ext}"}
+        # Duration lets the create modal's MusicBrainz "Match" rank candidates by
+        # how close their length is to this master audio (the studio-vs-live tell).
+        _dur = await asyncio.get_event_loop().run_in_executor(
+            None, _probe_audio_duration, dest)
+        return {"audio_url": f"{STORAGE_URL}/editor_audio_{audio_id}{ext}", "duration": _dur}
 
     # ── Download audio from YouTube ──────────────────────────────────
 
@@ -4285,6 +4646,11 @@ async def replace_audio(data: dict):
                 manifest = dict(session["sloppak_state"].get("manifest") or {})
                 rel = f"stems/{dest.name}"
                 manifest["stems"] = [{"id": "full", "file": rel}]
+                # Regenerate the auto preview from the new master audio so a draft
+                # that had no audio at create (and thus no preview) gets one now.
+                _pv = _make_preview_clip(dest, source_dir)
+                if _pv and _pv.exists():
+                    manifest["preview"] = _pv.name
                 (source_dir / "manifest.yaml").write_text(
                     yaml.safe_dump(manifest, sort_keys=False, allow_unicode=True),
                     encoding="utf-8",
@@ -4360,9 +4726,30 @@ def _detect_embedded():
             None, _detect_embedded
         )
 
+        # Song metadata for non-destructive autofill of the create modal's
+        # Title / Artist / Album fields (convert-gp reads those same fields, so
+        # this just saves retyping). Best-effort — a parse failure returns blanks
+        # and the modal simply falls back to the filename-derived title.
+        def _gp_song_meta():
+            try:
+                import guitarpro
+                song = guitarpro.parse(gp_path)
+                return {
+                    "title": (getattr(song, "title", "") or "").strip(),
+                    "artist": (getattr(song, "artist", "") or "").strip(),
+                    "album": (getattr(song, "album", "") or "").strip(),
+                }
+            except Exception:
+                return {"title": "", "artist": "", "album": ""}
+
+        song_meta = await asyncio.get_event_loop().run_in_executor(
+            None, _gp_song_meta
+        )
+
         return {"gp_path": gp_path, "tracks": tracks,
                 "has_embedded_audio": has_audio,
-                "sync_point_count": sync_count}
+                "sync_point_count": sync_count,
+                "song": song_meta}
 
 
 
@@ -4887,6 +5274,9 @@ def _convert():
             "metadata": {
                 "title": title, "artist": artist,
                 "album": album, "year": year,
+                # Spec-complete metadata typed in the create modal is merged into
+                # the session so /build persists it too (not just blank projects).
+                **_extended_manifest_meta(data),
             },
             "last_touched": time.time(),
         }
@@ -4970,6 +5360,7 @@ async def import_xml_project(
         artist: str = Form(""),
         album: str = Form(""),
         year: str = Form(""),
+        extended_meta: str = Form(""),
     ):
         """Import EOF (Editor on Fire) arrangement XML into a create session.
 
@@ -4985,6 +5376,13 @@ async def import_xml_project(
         """
         from lib.song import load_song as _load_arrangement_dir
 
+        # Spec-complete metadata arrives as one JSON form field so we don't need
+        # eight more Form() params; a malformed blob is tolerated (just ignored).
+        try:
+            _ext_meta = json.loads(extended_meta) if extended_meta.strip() else {}
+        except (ValueError, TypeError):
+            _ext_meta = {}
+
         tmp = tempfile.mkdtemp(prefix="slopsmith_xmlproj_")
         try:
             xml_count = 0
@@ -5082,6 +5480,10 @@ def _load():
                 "metadata": {
                     "title": song.title, "artist": song.artist,
                     "album": song.album, "year": song.year,
+                    # Spec-complete metadata from the create modal (a JSON blob
+                    # form field) is merged so /build persists it, matching the
+                    # blank-create and GP-import paths.
+                    **_extended_manifest_meta(_ext_meta),
                 },
                 "last_touched": time.time(),
             }
@@ -5897,10 +6299,77 @@ def _build_sloppak():
 
     # ── Helpers ──────────────────────────────────────────────────────────
 
+    def _probe_audio_duration(path) -> "float | None":
+        """Best-effort audio duration in seconds via ffprobe (None on failure)."""
+        try:
+            from lib.audio import _bundled_or_path
+            ffprobe = _bundled_or_path("ffprobe") or shutil.which("ffprobe")
+        except Exception:
+            ffprobe = shutil.which("ffprobe")
+        if not ffprobe:
+            return None
+        try:
+            pr = subprocess.run(
+                [ffprobe, "-v", "error", "-show_entries", "format=duration",
+                 "-of", "csv=p=0", str(path)],
+                capture_output=True, timeout=15,
+            )
+            if pr.returncode == 0:
+                return round(float(pr.stdout.strip()), 3)
+        except Exception:
+            pass
+        return None
+
+    def _make_preview_clip(src: "Path", out_dir: "Path",
+                           clip_seconds: float = 28.0) -> "Path | None":
+        """Auto-generate a short hover-to-listen preview from the master audio —
+        an OGG snippet starting ~20% into the song (past most intros). Best-effort:
+        returns None if ffmpeg is unavailable or the source is missing/too short.
+        Replaces the old manual "Preview Clip" upload."""
+        try:
+            from lib.audio import _ffmpeg_cmd
+            ffmpeg = _ffmpeg_cmd()
+        except Exception:
+            ffmpeg = None
+        if not ffmpeg or not src or not Path(src).exists():
+            return None
+        start, dur = 0.0, None
+        try:
+            from lib.audio import _bundled_or_path
+            ffprobe = _bundled_or_path("ffprobe") or shutil.which("ffprobe")
+        except Exception:
+            ffprobe = shutil.which("ffprobe")
+        if ffprobe:
+            try:
+                pr = subprocess.run(
+                    [ffprobe, "-v", "error", "-show_entries", "format=duration",
+                     "-of", "csv=p=0", str(src)],
+                    capture_output=True, timeout=15,
+                )
+                if pr.returncode == 0:
+                    dur = float(pr.stdout.strip())
+            except Exception:
+                dur = None
+        if dur and dur > clip_seconds + 2:
+            start = max(0.0, min(dur * 0.2, dur - clip_seconds))
+        out = out_dir / "preview.ogg"
+        try:
+            subprocess.run(
+                [ffmpeg, "-y", "-ss", str(round(start, 3)), "-t", str(clip_seconds),
+                 "-i", str(src), "-vn", "-c:a", "libvorbis", "-q:a", "4", str(out)],
+                capture_output=True, timeout=60,
+            )
+        except Exception:
+            return None
+        if out.exists() and out.stat().st_size > 100:
+            return out
+        return None
+
     def _write_sloppak_pak(*, audio_file: str, art_path: str,
                           arrangements_data: list, beats: list, sections: list,
                           meta: dict, output_path: Path,
                           drum_tab: dict | None = None,
+                          lyrics: list | None = None,
                           preview_path: str = "",
                           fail_if_exists: bool = False,
                           duration_override: float | None = None) -> str:
@@ -5918,7 +6387,11 @@ def _write_sloppak_pak(*, audio_file: str, art_path: str,
         path writes drum_tab via its own staging logic, not through
         this helper.
         """
-        if not audio_file or not Path(audio_file).exists():
+        # Draft-now packs carry no audio (audio_file == ""): emit an empty
+        # `stems: []` the author fills in later via Replace Audio. A NON-empty
+        # audio_file that doesn't resolve is still a real error.
+        _has_audio = bool(audio_file)
+        if _has_audio and not Path(audio_file).exists():
             raise RuntimeError("No audio file available for sloppak write")
         # Sloppak supports a packed-zip form (foo.sloppak file) and an
         # authoring directory form (foo.sloppak/ tree). Replacing a
@@ -5952,35 +6425,38 @@ def _write_sloppak_pak(*, audio_file: str, art_path: str,
             # it `audio.ogg` here meant those consumers couldn't find the mix.
             # Transcode to OGG when the source isn't already OGG so playback
             # works regardless of the uploaded audio format.
-            audio_ext = Path(audio_file).suffix.lower()
-            if audio_ext == ".ogg":
-                stem_filename = "full.ogg"
-                shutil.copy2(audio_file, stems_dir / stem_filename)
-            else:
-                # Try to transcode to the conventional `full.ogg` so on-create
-                # stem separation can find the source mix.
-                try:
-                    from lib.audio import _ffmpeg_cmd, _ffmpeg_wav_to_ogg
-                    _ff = _ffmpeg_cmd()
-                except Exception:
-                    _ff = None
-                _ogg_dest = stems_dir / "full.ogg"
-                _ok = False
-                if _ff:
-                    _r = _ffmpeg_wav_to_ogg(_ff, Path(audio_file), _ogg_dest)
-                    _ok = (_r.returncode == 0 and _ogg_dest.exists()
-                           and _ogg_dest.stat().st_size >= 100)
-                if _ok:
+            # No audio (draft): stem_filename stays None -> manifest `stems: []`.
+            stem_filename = None
+            if _has_audio:
+                audio_ext = Path(audio_file).suffix.lower()
+                if audio_ext == ".ogg":
                     stem_filename = "full.ogg"
-                else:
-                    # ffmpeg unavailable or transcode failed — keep the source
-                    # under its REAL extension (and point the manifest at it)
-                    # rather than writing mislabeled bytes to a `.ogg` name,
-                    # which would break decode/playback. Stem-split (which keys
-                    # on full.ogg) is best-effort and simply won't run here.
-                    _ogg_dest.unlink(missing_ok=True)
-                    stem_filename = f"full{audio_ext}"
                     shutil.copy2(audio_file, stems_dir / stem_filename)
+                else:
+                    # Try to transcode to the conventional `full.ogg` so on-create
+                    # stem separation can find the source mix.
+                    try:
+                        from lib.audio import _ffmpeg_cmd, _ffmpeg_wav_to_ogg
+                        _ff = _ffmpeg_cmd()
+                    except Exception:
+                        _ff = None
+                    _ogg_dest = stems_dir / "full.ogg"
+                    _ok = False
+                    if _ff:
+                        _r = _ffmpeg_wav_to_ogg(_ff, Path(audio_file), _ogg_dest)
+                        _ok = (_r.returncode == 0 and _ogg_dest.exists()
+                               and _ogg_dest.stat().st_size >= 100)
+                    if _ok:
+                        stem_filename = "full.ogg"
+                    else:
+                        # ffmpeg unavailable or transcode failed — keep the source
+                        # under its REAL extension (and point the manifest at it)
+                        # rather than writing mislabeled bytes to a `.ogg` name,
+                        # which would break decode/playback. Stem-split (which keys
+                        # on full.ogg) is best-effort and simply won't run here.
+                        _ogg_dest.unlink(missing_ok=True)
+                        stem_filename = f"full{audio_ext}"
+                        shutil.copy2(audio_file, stems_dir / stem_filename)
 
             used_ids: set[str] = set()
             manifest_arrangements = []
@@ -6083,13 +6559,41 @@ def _write_sloppak_pak(*, audio_file: str, art_path: str,
                 # `id: "full"` matches the convention the editor's load
                 # path and replace-audio path already use; sloppak
                 # readers prefer that id when picking the default stem.
-                "stems": [
-                    {"id": "full", "file": f"stems/{stem_filename}"},
-                ],
+                # Draft packs (no audio yet) carry an empty stems list — the
+                # loader tolerates it (audio_url resolves to null) and Replace
+                # Audio fills it in later.
+                "stems": (
+                    [{"id": "full", "file": f"stems/{stem_filename}"}]
+                    if stem_filename else []
+                ),
                 "arrangements": manifest_arrangements,
             }
             if year:
                 manifest["year"] = year
+            # Optional author credits (feedpak `authors:` array). Written only
+            # when non-empty so packs without credits stay byte-identical.
+            _authors = meta.get("authors")
+            if isinstance(_authors, list):
+                _authors = [str(a).strip() for a in _authors if str(a).strip()]
+                if _authors:
+                    manifest["authors"] = _authors
+
+            # Spec-complete optional metadata (feedpak §5.1) — written only when
+            # present so packs without them stay minimal. String scalars,
+            # int scalars (track/disc), and the genres list.
+            for _mk in ("album_artist", "mbid", "isrc", "language"):
+                _mv = meta.get(_mk)
+                if isinstance(_mv, str) and _mv.strip():
+                    manifest[_mk] = _mv.strip()
+            for _mk in ("track", "disc"):
+                _mv = meta.get(_mk)
+                if isinstance(_mv, int) and not isinstance(_mv, bool):
+                    manifest[_mk] = _mv
+            _genres = meta.get("genres")
+            if isinstance(_genres, list):
+                _genres = [str(g).strip() for g in _genres if str(g).strip()]
+                if _genres:
+                    manifest["genres"] = _genres
 
             if art_path and Path(art_path).exists():
                 cover_ext = Path(art_path).suffix.lower() or ".jpg"
@@ -6126,6 +6630,17 @@ def _write_sloppak_pak(*, audio_file: str, art_path: str,
                 )
                 manifest["drum_tab"] = "drum_tab.json"
 
+            # Vocals seed: an empty (or authored) lyrics track. feedpak §7.1
+            # lyrics.json is a flat array of syllables — an empty array is a
+            # valid, empty track the author fills in later.
+            if isinstance(lyrics, list):
+                (staging / "lyrics.json").write_text(
+                    json.dumps(lyrics, separators=(",", ":")),
+                    encoding="utf-8",
+                )
+                manifest["lyrics"] = "lyrics.json"
+                manifest["lyrics_source"] = "authored"
+
             _write_song_timeline_sidecar(staging, manifest, beats, sections)
 
             (staging / "manifest.yaml").write_text(
diff --git a/screen.html b/screen.html
index d9d63f4a..7569dde9 100644
--- a/screen.html
+++ b/screen.html
@@ -23,7 +23,7 @@
         <button id="editor-create-btn" onclick="editorShowCreateModal()" class="px-3 py-1 bg-green-800 hover:bg-green-700 rounded text-xs font-medium" title="Start a new song">New…</button>
         <button id="editor-save-btn" onclick="editorSave()" class="px-3 py-1 bg-accent hover:bg-accent-light rounded text-xs font-medium" disabled>Save</button>
         <button id="editor-replace-audio-btn" onclick="editorShowReplaceAudioModal()" class="px-3 py-1 bg-dark-600 hover:bg-dark-500 rounded text-xs font-medium hidden" title="Replace the audio track">Replace Audio</button>
-        <button id="editor-build-btn" onclick="editorBuild()" class="px-3 py-1 bg-purple-800 hover:bg-purple-700 rounded text-xs font-medium hidden">Build Song</button>
+        <button id="editor-build-btn" onclick="editorBuild()" class="px-3 py-1 bg-purple-800 hover:bg-purple-700 rounded text-xs font-medium hidden" title="Assemble the finished .feedpak package">Build feedpak</button>
         <button id="editor-add-drums-btn" onclick="editorShowAddDrumsModal()" class="px-3 py-1 bg-red-900 hover:bg-red-800 rounded text-xs font-medium hidden">+ Drums</button>
         <button id="editor-add-keys-btn" onclick="editorShowAddKeysModal()" class="px-3 py-1 bg-indigo-900 hover:bg-indigo-800 rounded text-xs font-medium hidden">+ Keys</button>
         <button id="editor-import-guitar-btn" onclick="editorShowImportGuitarModal()" class="px-3 py-1 bg-blue-900 hover:bg-blue-800 rounded text-xs font-medium hidden" title="Import a guitar or bass track from a Guitar Pro file — add it or replace an existing arrangement">+ Guitar/Bass</button>
@@ -180,17 +180,21 @@
 
 <!-- Load modal -->
 <div id="editor-load-modal" class="hidden absolute inset-0 z-50 flex items-center justify-center" style="background:rgba(0,0,0,0.7)">
-    <div class="bg-dark-700 rounded-xl border border-gray-700 w-full max-w-md max-h-[70vh] flex flex-col">
+    <div class="bg-dark-700 rounded-xl border border-gray-700 w-full max-w-lg max-h-[75vh] flex flex-col">
         <div class="flex items-center justify-between px-4 py-3 border-b border-gray-700">
-            <span class="text-sm font-medium">Load custom song</span>
+            <span class="text-sm font-medium">Load a feedpak</span>
             <button onclick="editorHideLoadModal()" class="text-gray-500 hover:text-white">&times;</button>
         </div>
+        <div class="px-4 pt-3 pb-1">
+            <div class="text-[11px] text-gray-500 mb-1">Song library folder</div>
+            <div id="editor-load-path" title="" class="text-xs text-gray-400 bg-dark-800 border border-gray-700 rounded px-2 py-1 truncate">—</div>
+        </div>
         <div class="px-4 py-2">
-            <input id="editor-load-search" type="text" placeholder="Search by song, artist, or filename..." oninput="editorFilterSongs(this.value)"
+            <input id="editor-load-search" type="text" placeholder="Search all folders by song, artist, or filename…" oninput="editorFilterSongs(this.value)"
                 class="w-full bg-dark-800 border border-gray-700 rounded px-3 py-1.5 text-sm text-gray-300 outline-none focus:border-accent/50">
         </div>
         <div id="editor-load-list" class="flex-1 overflow-y-auto px-2 pb-2">
-            <div class="text-xs text-gray-500 p-2">Loading...</div>
+            <div class="text-xs text-gray-500 p-2">Loading…</div>
         </div>
     </div>
 </div>
@@ -213,50 +217,68 @@
 
 <!-- Create custom song modal -->
 <div id="editor-create-modal" class="hidden absolute inset-0 z-50 flex items-center justify-center" style="background:rgba(0,0,0,0.7)">
-    <div class="bg-dark-700 rounded-xl border border-gray-700 w-full max-w-lg max-h-[85vh] flex flex-col overflow-y-auto">
+    <div class="bg-dark-700 rounded-xl border border-gray-700 w-full max-w-4xl max-h-[85vh] flex flex-col overflow-y-auto">
         <div class="flex items-center justify-between px-4 py-3 border-b border-gray-700 shrink-0">
-            <span class="text-sm font-medium">Create New custom song</span>
+            <span class="text-sm font-medium">Create New Arrangement</span>
             <button onclick="editorHideCreateModal()" class="text-gray-500 hover:text-white">&times;</button>
         </div>
-        <div class="p-4 space-y-4">
+        <div class="p-4">
+
+            <!-- One menu: pick a roster ("What are you arranging?"), optionally
+                 import a chart/audio, fill in details. editorDoCreate() routes on
+                 what you give it. Only a title + one instrument are required. -->
+            <p class="text-[11px] text-gray-500">
+                Pick what you're arranging and give it a <span class="text-gray-300">title</span> — everything else is optional.
+                Import a chart or audio to start from, or build from scratch and add content later.
+            </p>
 
-            <!-- Step 1: Guitar Pro file -->
-            <div>
-                <label class="text-xs font-medium text-gray-400 mb-1 block">Guitar Pro File <span id="editor-create-gp-opt" class="text-gray-600">(.gp3/.gp4/.gp5/.gpx/.gp — optional)</span></label>
-                <input type="file" id="editor-create-gp" accept=".gp3,.gp4,.gp5,.gpx,.gp"
-                    onchange="editorGPFileSelected(this)"
-                    class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
+            <!-- Two columns so the modal is wide, not tall: LEFT = where the chart
+                 comes from, RIGHT = audio + song details. Full-width Create below. -->
+            <div class="grid grid-cols-2 gap-4 mt-4 items-start">
+
+              <!-- ===== LEFT: chart source ===== -->
+              <div class="space-y-4">
+
+            <!-- What are you arranging? — click to add a role, drag chips to
+                 reorder. No string counts here (set in the editor: 6-string
+                 covers up to 9-string guitar, 4-string bass up to 6). -->
+            <div class="space-y-2 rounded-lg border border-gray-800 p-3">
+                <div class="text-xs font-semibold text-gray-300">What are you arranging?</div>
+                <p class="text-[11px] text-gray-600">Click to add. Drag the chips below to reorder.</p>
+                <div id="editor-create-roster-palette" class="flex flex-wrap gap-1"></div>
+                <div class="text-[11px] text-gray-500 pt-1">Your arrangements <span class="text-gray-600">(drag to reorder)</span>:</div>
+                <div id="editor-create-roster-selected" style="min-height:40px" class="flex flex-wrap gap-1 bg-dark-800 rounded p-2"></div>
+                <p id="editor-create-roster-hint" class="text-[11px] text-gray-600"></p>
             </div>
 
-            <!-- Step 1 (alt): import EOF (Editor on Fire) arrangement XML -->
-            <div>
-                <label class="text-xs font-medium text-gray-400 mb-1 block">EOF Arrangement XML <span class="text-gray-600">(.xml — one or more; optional)</span></label>
-                <input type="file" id="editor-create-eof" accept=".xml" multiple
-                    onchange="editorEofFilesSelected(this)"
-                    class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
-                <p class="text-[11px] text-gray-600 mt-1">Select the EOF arrangement file(s), then set the audio, art, preview and details below and click Import.</p>
+            <!-- Content Import — one browse for every format feedBack reads. -->
+            <div class="space-y-2 rounded-lg border border-gray-800 p-3">
+                <div class="text-xs font-semibold text-gray-300">Content Import <span class="text-gray-600 font-normal">— optional</span></div>
+                <p class="text-[11px] text-gray-600">Add a master audio track and/or a chart to start from — you can add both. feedBack accepts <span class="text-gray-400">audio</span> (MP3/WAV/FLAC/OGG/M4A), <span class="text-gray-400">Guitar Pro</span> (.gp3–.gp8), <span class="text-gray-400">MIDI</span> (.mid), and <span class="text-gray-400">EOF/RS arrangement XML</span>. PowerTab &amp; MusicXML are coming.</p>
+                <!-- Staged files (rendered by renderStaged): the honesty surface -->
+                <div id="editor-create-staged" class="space-y-1"></div>
+                <!-- Hidden multi-file input, driven by the styled "+ Add file" label -->
+                <label for="editor-create-import"
+                    class="inline-block cursor-pointer px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500">+ Add file(s)</label>
+                <input type="file" id="editor-create-import" multiple class="hidden"
+                    accept=".mp3,.wav,.flac,.ogg,.m4a,.opus,.aac,.wem,.gp3,.gp4,.gp5,.gpx,.gp,.mid,.midi,.xml"
+                    onchange="editorContentImportSelected(this)">
+                <div class="flex items-center gap-2">
+                    <span class="text-[11px] text-gray-600 shrink-0">or paste a YouTube URL</span>
+                    <input type="text" id="editor-create-yt-url" placeholder="https://youtube.com/watch?v=..."
+                        oninput="editorYtUrlInput()"
+                        class="flex-1 bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none focus:border-accent/50">
+                </div>
+                <div id="editor-create-import-status" class="text-[11px] text-gray-500"></div>
             </div>
 
-            <!-- Track selection (shown after GP upload) -->
+            <!-- Track selection (shown after a Guitar Pro import) -->
             <div id="editor-create-tracks" class="hidden">
                 <label class="text-xs font-medium text-gray-400 mb-1 block">Select Tracks</label>
                 <div id="editor-create-track-list" class="space-y-1 max-h-32 overflow-y-auto bg-dark-800 rounded p-2">
                 </div>
             </div>
 
-            <!-- Blank-chart options (Sloppak with no Guitar Pro file) -->
-            <div id="editor-create-blank-opts" class="hidden space-y-2">
-                <div>
-                    <label class="text-xs font-medium text-gray-400 mb-1 block">Initial Arrangement</label>
-                    <div id="editor-create-arr-buttons" class="flex gap-1"></div>
-                    <p class="text-[11px] text-gray-600 mt-1">Default tuning is E standard (Bass: 4 strings). Adjust later from the editor toolbar.</p>
-                </div>
-                <label class="flex items-center gap-2 cursor-pointer">
-                    <input type="checkbox" id="editor-create-drum-tab" checked class="cursor-pointer">
-                    <span class="text-sm">Also start an empty drum tab</span>
-                </label>
-            </div>
-
             <!-- GP8 embedded audio banner (shown only when GP8 file has embedded audio) -->
             <div id="editor-gp8-audio-banner" class="hidden rounded-lg border border-accent/30 bg-accent/5 p-3">
                 <div class="flex items-start gap-2">
@@ -296,73 +318,129 @@
                 </div>
             </div>
 
-            <!-- Step 2: Audio source -->
-            <div>
-                <label class="text-xs font-medium text-gray-400 mb-1 block">Audio Source</label>
-                <div class="aud-seg-wrap" role="tablist" aria-label="Audio source">
-                    <button onclick="editorSetAudioMode('file')" id="editor-audio-mode-file"
-                        class="aud-seg is-active">Upload File</button>
-                    <button onclick="editorSetAudioMode('youtube')" id="editor-audio-mode-yt"
-                        class="aud-seg">YouTube URL</button>
-                </div>
-                <!-- File upload -->
-                <div id="editor-audio-file-input">
-                    <input type="file" id="editor-create-audio" accept=".wem,.ogg,.flac,.mp3,.wav,.m4a,.opus"
-                        class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
-                </div>
-                <!-- YouTube URL -->
-                <div id="editor-audio-yt-input" class="hidden">
-                    <input type="text" id="editor-create-yt-url" placeholder="https://youtube.com/watch?v=..."
-                        class="w-full bg-dark-800 border border-gray-700 rounded px-3 py-1.5 text-sm text-gray-300 outline-none focus:border-accent/50">
+              </div><!-- /LEFT column -->
+
+              <!-- ===== RIGHT: album art + song details ===== -->
+              <div class="space-y-4">
+
+            <!-- Album Art — upload a file OR pick a cover from the Cover Art Archive. -->
+            <div class="rounded-lg border border-gray-800 p-3">
+                <div class="text-xs font-semibold text-gray-300 mb-2">Album Art <span class="text-gray-600 font-normal">— optional</span></div>
+                <div class="flex items-center gap-3">
+                    <div id="editor-create-art-preview" style="width:5.5rem;height:5.5rem;background-size:cover;background-position:center"
+                        class="rounded bg-dark-800 border border-gray-700 flex items-center justify-center text-gray-600 text-[10px] text-center shrink-0 overflow-hidden">No art yet</div>
+                    <div class="flex-1 min-w-0">
+                        <div class="flex items-center gap-2">
+                            <input type="file" id="editor-create-art" accept=".png,.jpg,.jpeg,.dds"
+                                onchange="editorCreateArtSelected(this)"
+                                class="flex-1 min-w-0 text-xs text-gray-400 file:mr-2 file:py-1 file:px-2 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
+                            <button type="button" onclick="editorArtSearch()"
+                                class="px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 shrink-0">Find cover…</button>
+                        </div>
+                        <p class="text-[11px] text-gray-600 mt-1">Upload a file, or find a cover from MusicBrainz.</p>
+                    </div>
                 </div>
-                <div id="editor-audio-status" class="text-xs text-gray-500 mt-1"></div>
             </div>
 
-            <!-- Step 3: Metadata -->
-            <div class="grid grid-cols-2 gap-3">
-                <div>
-                    <label class="text-xs text-gray-500">Title</label>
-                    <input type="text" id="editor-create-title" placeholder="Song Title"
-                        class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
-                </div>
-                <div>
-                    <label class="text-xs text-gray-500">Artist</label>
-                    <input type="text" id="editor-create-artist" placeholder="Artist Name"
-                        class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
-                </div>
-                <div>
-                    <label class="text-xs text-gray-500">Album</label>
-                    <input type="text" id="editor-create-album" placeholder="Album"
-                        class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+            <!-- Song details — the manifest metadata the feedpak spec models (§5.1). -->
+            <div class="rounded-lg border border-gray-800 p-3 space-y-2">
+                <div class="text-xs font-semibold text-gray-300">Song details</div>
+                <div id="editor-create-autofill-note" class="text-[11px] text-accent"></div>
+                <div class="grid grid-cols-2 gap-2">
+                    <div>
+                        <label class="text-xs text-gray-500">Title <span class="text-gray-600">(required)</span></label>
+                        <input type="text" id="editor-create-title" placeholder="Song title"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Artist</label>
+                        <input type="text" id="editor-create-artist" placeholder="Performing artist"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Album</label>
+                        <input type="text" id="editor-create-album" placeholder="Album"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Album artist</label>
+                        <input type="text" id="editor-create-album-artist" placeholder="For compilations"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Year</label>
+                        <input type="text" id="editor-create-year" placeholder="2024" inputmode="numeric"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div class="grid grid-cols-2 gap-2">
+                        <div>
+                            <label class="text-xs text-gray-500">Track #</label>
+                            <input type="text" id="editor-create-track" placeholder="1" inputmode="numeric"
+                                class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                        </div>
+                        <div>
+                            <label class="text-xs text-gray-500">Disc #</label>
+                            <input type="text" id="editor-create-disc" placeholder="1" inputmode="numeric"
+                                class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                        </div>
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Genre(s)</label>
+                        <input type="text" id="editor-create-genre" placeholder="Rock, Metal"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Language</label>
+                        <input type="text" id="editor-create-language" placeholder="en"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">ISRC</label>
+                        <input type="text" id="editor-create-isrc" placeholder="USABC2400001"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">MusicBrainz ID</label>
+                        <input type="text" id="editor-create-mbid" placeholder="recording MBID"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
                 </div>
                 <div>
-                    <label class="text-xs text-gray-500">Year</label>
-                    <input type="text" id="editor-create-year" placeholder="2024"
+                    <label class="text-xs text-gray-500">Chart author(s)</label>
+                    <input type="text" id="editor-create-authors" placeholder="Who charted this — separate names with commas"
                         class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    <p class="text-[11px] text-gray-600 mt-1">Credited in the feedpak (spec <span class="text-gray-500">authors</span>) — distinct from the performing artist.</p>
                 </div>
             </div>
 
-            <!-- Album art -->
-            <div>
-                <label class="text-xs text-gray-500">Album Art (optional)</label>
-                <input type="file" id="editor-create-art" accept=".png,.jpg,.jpeg,.dds"
-                    class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
+            <!-- MusicBrainz match — scan-first: uses the Title/Artist already on
+                 the form; the popup lets you refine the query + pick a record. -->
+            <div class="rounded-lg border border-gray-800 p-3">
+                <div class="flex items-center justify-between gap-2">
+                    <div>
+                        <div class="text-xs font-semibold text-gray-300">Match metadata</div>
+                        <p class="text-[11px] text-gray-600">Look this song up on MusicBrainz, or identify the exact recording from your audio.</p>
+                    </div>
+                    <div class="flex items-center gap-1.5 shrink-0">
+                        <button type="button" id="editor-create-identify-btn" onclick="editorIdentifyAudio()" disabled
+                            title="Identify the exact recording by fingerprinting your master audio"
+                            class="px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 disabled:opacity-50 disabled:cursor-not-allowed">Identify from audio…</button>
+                        <button type="button" id="editor-create-mb-btn" onclick="editorMbMatch()"
+                            class="px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 disabled:opacity-50 disabled:cursor-not-allowed">Match…</button>
+                    </div>
+                </div>
+                <div id="editor-create-mb-hint" class="text-[11px] text-gray-600 mt-1"></div>
             </div>
 
-            <!-- Preview clip -->
-            <div>
-                <label class="text-xs text-gray-500">Preview Clip (optional)</label>
-                <input type="file" id="editor-create-preview" accept=".wem,.ogg,.flac,.mp3,.wav,.m4a,.opus"
-                    class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
-                <p class="text-[11px] text-gray-600 mt-1">Baked into the .sloppak when you Build. Plays on hover in the library only if the Song Preview plugin is installed.</p>
-            </div>
+            <!-- Create button — works for import (GP/EOF) and from-scratch alike -->
+              </div><!-- /RIGHT column -->
+            </div><!-- /two-column grid -->
 
-            <!-- Import button -->
             <button onclick="editorDoCreate()" id="editor-create-go"
-                class="w-full px-4 py-2 bg-green-700 hover:bg-green-600 rounded-lg text-sm font-medium disabled:opacity-50 disabled:cursor-not-allowed" disabled>
-                Import & Open in Editor
+                class="w-full px-4 py-2 bg-green-700 hover:bg-green-600 rounded-lg text-sm font-medium disabled:opacity-50 disabled:cursor-not-allowed mt-4" disabled>
+                Create &amp; Open in Editor
             </button>
-            <div id="editor-create-status" class="text-xs text-gray-500"></div>
+            <div id="editor-create-status" class="text-xs text-gray-500 mt-2"></div>
         </div>
     </div>
 </div>
diff --git a/screen.js b/screen.js
index 0a5d0bc2..d4c54398 100644
--- a/screen.js
+++ b/screen.js
@@ -4936,8 +4936,12 @@ function updateArrangementSelector() {
 async function showLoadModal() {
     const modal = document.getElementById('editor-load-modal');
     modal.classList.remove('hidden');
-    document.getElementById('editor-load-search').value = '';
+    const search = document.getElementById('editor-load-search');
+    if (search) search.value = '';
 
+    // Preload the flat list ONCE for recursive search (best-effort). The default
+    // view is the folder browser below; typing in the search box searches across
+    // every folder using this list.
     if (!S.songsList) {
         try {
             S.songsList = await fetch('/api/plugins/editor/songs').then(r => r.json());
@@ -4945,14 +4949,81 @@ async function showLoadModal() {
             S.songsList = [];
         }
     }
-    // Don't dump the whole library on open — it can be thousands of rows.
-    // Show a prompt and populate results as the user types (see filterSongs).
-    // If the library is empty / the fetch failed, fall through to the
-    // existing "No custom song files found" empty state instead of telling the user
-    // to search for something that isn't there.
-    if (S.songsList && S.songsList.length) renderSongPrompt();
-    else renderSongList(S.songsList || []);
-    document.getElementById('editor-load-search').focus();
+    // Open as a file browser rooted at the DLC / song-library folder.
+    await _editorBrowse('');
+    if (search) search.focus();
+}
+
+// Fetch + render one directory level of the library. `path` is a DLC-relative
+// POSIX subpath ("" = the library root).
+async function _editorBrowse(path) {
+    S.loadCwd = path || '';
+    const list = document.getElementById('editor-load-list');
+    let data;
+    try {
+        data = await fetch('/api/plugins/editor/browse', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path: S.loadCwd }),
+        }).then(r => r.json());
+    } catch {
+        data = { error: 'Could not read the library folder' };
+    }
+    if (!data || data.error) {
+        if (list) list.innerHTML = '<div class="text-xs text-gray-500 p-2">'
+            + _editorEscHtml((data && data.error) || 'Error') + '</div>';
+        return;
+    }
+    S.loadCwd = data.cwd || '';
+    S.loadParent = data.parent;
+    _editorSetLoadPath(data.root, data.cwd);
+    renderBrowse(data);
+}
+
+// Show the absolute folder path (root + current subpath), using whichever
+// separator the OS root hints at so it reads like a real path on Windows/*nix.
+function _editorSetLoadPath(root, cwd) {
+    const el = document.getElementById('editor-load-path');
+    if (!el) return;
+    const sep = String(root).includes('\\') ? '\\' : '/';
+    const full = cwd
+        ? String(root).replace(/[\\/]+$/, '') + sep + String(cwd).replace(/\//g, sep)
+        : String(root);
+    el.textContent = full;
+    el.title = full;
+}
+
+// Render an up-row (when not at root) + subfolders + loadable feedpaks.
+function renderBrowse(data) {
+    const list = document.getElementById('editor-load-list');
+    if (!list) return;
+    list.replaceChildren();
+    const row = (icon, text, onClick, badge) => {
+        const b = document.createElement('button');
+        b.className = 'w-full text-left px-3 py-1.5 text-xs text-gray-300 hover:bg-dark-500 rounded flex items-center gap-2';
+        const ic = document.createElement('span'); ic.className = 'shrink-0'; ic.textContent = icon;
+        const lb = document.createElement('span'); lb.className = 'flex-1 truncate'; lb.textContent = text;
+        b.appendChild(ic); b.appendChild(lb);
+        if (badge) {
+            const bd = document.createElement('span');
+            bd.className = 'px-1.5 py-0.5 rounded text-[10px] uppercase tracking-wide bg-green-900/40 text-green-300';
+            bd.textContent = badge;
+            b.appendChild(bd);
+        }
+        b.addEventListener('click', onClick);
+        list.appendChild(b);
+    };
+    if (data.cwd) row('⬆', '.. (up one folder)', () => _editorBrowse(data.parent || ''));
+    for (const d of (data.dirs || [])) row('📁', d.name, () => _editorBrowse(d.path));
+    for (const f of (data.files || [])) row('🎵', f.name, () => editorLoadFile(f.filename), f.format);
+    if (!(data.dirs || []).length && !(data.files || []).length) {
+        const empty = document.createElement('div');
+        empty.className = 'text-xs text-gray-500 p-2';
+        empty.textContent = data.cwd
+            ? 'This folder is empty.'
+            : 'No feedpaks in your library folder yet — use New… to create one.';
+        list.appendChild(empty);
+    }
 }
 
 // Empty/initial state for the load list: prompt to search rather than
@@ -5060,11 +5131,10 @@ function renderSongList(files) {
 }
 
 function filterSongs(q) {
-    if (!S.songsList) return;
     const query = (q || '').trim().toLowerCase();
-    // Empty query → show the prompt (or the empty state if there's nothing
-    // to search) instead of the entire library.
-    if (!query) { if (S.songsList.length) renderSongPrompt(); else renderSongList([]); return; }
+    // Empty query → back to the folder browser (rooted where the user last was).
+    if (!query) { _editorBrowse(S.loadCwd || ''); return; }
+    if (!S.songsList) return;
     const list = _normalizeSongList(S.songsList);
     // Match song name, artist, OR raw filename so users can search either way.
     const filtered = list.filter(f =>
@@ -6882,16 +6952,16 @@ window.editorShowNewFormatPicker = () => {
         return b;
     };
     inner.appendChild(mkBtn(
-        '🎵  Sloppak',
-        'Audio + chart with drum tab and stems available from the start. '
-        + 'Best for new songs.',
-        () => window.editorShowCreateSloppakModal(),
+        '🎵  Blank — start from audio',
+        'Audio + an empty arrangement (drum tab optional). Chart it yourself '
+        + 'in the editor. No Guitar Pro / XML needed.',
+        () => { window.editorShowCreateModal(); window.editorSetCreateMode('blank'); },
     ));
     inner.appendChild(mkBtn(
         '🎸  Import from Guitar Pro',
-        'Build a chart from a Guitar Pro file (.gp3–.gp8). Audio and '
-        + 'arrangements are imported and saved as a native .sloppak.',
-        () => window.editorShowCreateModal(),
+        'Build a chart from a Guitar Pro file (.gp3–.gp8), saved as a native '
+        + '.feedpak.',
+        () => { window.editorShowCreateModal(); window.editorSetCreateMode('gp'); },
     ));
 
     const cancel = document.createElement('div');
@@ -6916,47 +6986,109 @@ window.editorShowNewFormatPicker = () => {
     inner.querySelector('button')?.focus();
 };
 
+// ════════════════════════════════════════════════════════════════════
+// Entry landing — shown when you open the Song Editor with nothing loaded:
+// Load an existing feedpak, or Create New. (The toolbar Load / New… buttons
+// remain for use once you're already inside.)
+// ════════════════════════════════════════════════════════════════════
+window.editorShowStartLanding = () => {
+    document.getElementById('editor-start-landing')?.remove();
+    const modal = document.createElement('div');
+    modal.id = 'editor-start-landing';
+    modal.className = 'fixed inset-0 bg-black/70 z-50 flex items-center justify-center';
+    const inner = document.createElement('div');
+    inner.className = 'bg-dark-800 border border-gray-700 rounded-xl p-6 max-w-md w-full mx-4';
+    const h = document.createElement('h3');
+    h.className = 'text-lg font-semibold mb-1';
+    h.textContent = 'Song Editor';
+    const sub = document.createElement('p');
+    sub.className = 'text-xs text-gray-400 mb-4';
+    sub.textContent = 'Open an existing feedpak to edit, or start a new arrangement.';
+    inner.appendChild(h); inner.appendChild(sub);
+    const mk = (label, blurb, onClick) => {
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.className = 'w-full text-left p-3 mb-2 bg-dark-700 hover:bg-dark-600 rounded border border-gray-700';
+        const t = document.createElement('div'); t.className = 'font-medium text-sm'; t.textContent = label;
+        const p = document.createElement('div'); p.className = 'text-xs text-gray-400 mt-1'; p.textContent = blurb;
+        b.appendChild(t); b.appendChild(p);
+        b.onclick = () => { modal.remove(); onClick(); };
+        return b;
+    };
+    inner.appendChild(mk('📂  Load…',
+        'Browse your song library and open a feedpak to edit.',
+        () => window.editorShowLoadModal()));
+    inner.appendChild(mk('✨  Create New',
+        'Pick what you’re arranging, import a chart or audio, add details.',
+        () => window.editorShowCreateModal()));
+    const cancel = document.createElement('div'); cancel.className = 'flex justify-end mt-2';
+    const cb = document.createElement('button');
+    cb.type = 'button';
+    cb.className = 'px-3 py-1 bg-dark-700 hover:bg-dark-600 rounded text-xs text-gray-400';
+    cb.textContent = 'Not now';
+    cb.onclick = () => modal.remove();
+    cancel.appendChild(cb); inner.appendChild(cancel);
+    modal.appendChild(inner);
+    if (typeof _installModalKeyboard === 'function') {
+        _installModalKeyboard(modal, inner, () => modal.remove());
+    }
+    document.body.appendChild(modal);
+    inner.querySelector('button')?.focus();
+};
+
+// Show the landing only on a genuinely empty editor — nothing loaded, no
+// create session, and no create/load modal already open.
+function _editorMaybeShowStartLanding() {
+    const loaded = !!(typeof S !== 'undefined' && S && (S.filename || S.sessionId
+        || (Array.isArray(S.arrangements) && S.arrangements.length)));
+    if (loaded) return;
+    if (document.getElementById('editor-start-landing')) return;
+    const createHidden = document.getElementById('editor-create-modal')?.classList.contains('hidden');
+    const loadHidden = document.getElementById('editor-load-modal')?.classList.contains('hidden');
+    if (createHidden === false || loadHidden === false) return;   // a modal is open
+    window.editorShowStartLanding();
+}
+
 window.editorShowCreateModal = () => {
-    // Include the GP-audio-sync fields so a prior import session's
-    // gp8AudioMode / autoSyncAudioUrl / lastSync can't leak into this one
-    // (which would apply the previous song's audio/offset to a new import).
+    // Fresh state each open so a prior session (roster / audio / gp8AudioMode /
+    // autoSyncAudioUrl / lastSync) can't leak in. Default roster: one Lead
+    // Guitar arrangement, so the modal is immediately creatable with a title.
     createState = {
-        gpPath: null, tracks: null, audioUrl: null, audioMode: 'file', artPath: null,
-        previewPath: null, eofFiles: null,
-        initialArrangement: 'Lead', initDrumTab: true,
-        gp8AudioMode: 'none', autoSyncAudioUrl: null, lastSync: null,
+        mode: 'blank',
+        roster: ['Lead'],
+        gpPath: null, tracks: null, gpName: null, gpHasEmbedded: false, gpSyncCount: 0,
+        eofFiles: null, eofName: null,
+        audioUrl: null, audioName: null, audioDuration: null, audioFile: null, midiInfo: null,
+        artPath: null, previewPath: null,
+        gp8AudioMode: 'none', autoSyncAudioUrl: null, lastSync: null, autoSyncCoupled: false,
     };
-    document.getElementById('editor-create-modal').classList.remove('hidden');
-    document.getElementById('editor-create-tracks').classList.add('hidden');
-    document.getElementById('editor-create-go').disabled = true;
-    document.getElementById('editor-create-status').textContent = '';
-    document.getElementById('editor-audio-status').textContent = '';
-    document.getElementById('editor-create-gp').value = '';
-    document.getElementById('editor-create-audio').value = '';
-    document.getElementById('editor-create-yt-url').value = '';
-    const _eofIn = document.getElementById('editor-create-eof'); if (_eofIn) _eofIn.value = '';
-    const _pvIn = document.getElementById('editor-create-preview'); if (_pvIn) _pvIn.value = '';
-    document.getElementById('editor-create-title').value = '';
-    document.getElementById('editor-create-artist').value = '';
-    document.getElementById('editor-create-album').value = '';
-    document.getElementById('editor-create-year').value = '';
-    const _drumTab = document.getElementById('editor-create-drum-tab');
-    if (_drumTab) _drumTab.checked = true;
-    const _goBtn = document.getElementById('editor-create-go');
-    if (_goBtn) _goBtn.textContent = 'Import & Open in Editor';
-    // Reset the GP8/auto-sync UI so stale banner/section/refine state from a
-    // previous session isn't shown before a file is chosen.
-    document.getElementById('editor-gp8-audio-banner')?.classList.add('hidden');
-    document.getElementById('editor-autosync-section')?.classList.add('hidden');
-    document.getElementById('editor-refine-row')?.classList.add('hidden');
-    const _gas = document.getElementById('editor-autosync-status');
-    if (_gas) _gas.textContent = '';
-    const _refineStatus = document.getElementById('editor-refine-status');
-    if (_refineStatus) _refineStatus.textContent = '';
-    _renderCreateArrangementButtons();
-    _refreshCreateBlankOptions();
-    editorSetAudioMode('file');
+    const setVal = (id) => { const el = document.getElementById(id); if (el) el.value = ''; };
+    const setTxt = (id) => { const el = document.getElementById(id); if (el) el.textContent = ''; };
+    const hide = (id) => document.getElementById(id)?.classList.add('hidden');
+    document.getElementById('editor-create-modal')?.classList.remove('hidden');
+    hide('editor-create-tracks');
+    const go = document.getElementById('editor-create-go'); if (go) go.disabled = true;
+    setTxt('editor-create-status');
+    setTxt('editor-create-import-status');
+    setTxt('editor-create-roster-hint');
+    [
+        'editor-create-import', 'editor-create-yt-url', 'editor-create-art',
+        'editor-create-title', 'editor-create-artist', 'editor-create-album', 'editor-create-album-artist',
+        'editor-create-year', 'editor-create-track', 'editor-create-disc', 'editor-create-genre',
+        'editor-create-language', 'editor-create-isrc', 'editor-create-mbid', 'editor-create-authors',
+    ].forEach(setVal);
+    const artPrev = document.getElementById('editor-create-art-preview');
+    if (artPrev) { artPrev.style.backgroundImage = ''; artPrev.textContent = 'No art yet'; }
+    // Reset the GP8/auto-sync UI so stale banner/section/refine state isn't shown.
+    hide('editor-gp8-audio-banner'); hide('editor-autosync-section'); hide('editor-refine-row');
+    setTxt('editor-autosync-status'); setTxt('editor-refine-status');
+    setTxt('editor-create-autofill-note');
+    _populateRosterPalette();
+    _renderRosterSelected();
+    renderStaged();
+    _syncYtFieldState();
     updateCreateButton();
+    _updateIdentifyButton();   // disabled until a master track is staged
 };
 
 window.editorHideCreateModal = () => {
@@ -7249,94 +7381,131 @@ window.editorShowCreateSloppakModal = () => {
     titleInput.focus();
 };
 
-window.editorSetAudioMode = (mode) => {
-    createState.audioMode = mode;
-    document.getElementById('editor-audio-file-input').classList.toggle('hidden', mode !== 'file');
-    document.getElementById('editor-audio-yt-input').classList.toggle('hidden', mode !== 'youtube');
-    document.getElementById('editor-audio-mode-file').classList.toggle('is-active', mode === 'file');
-    document.getElementById('editor-audio-mode-yt').classList.toggle('is-active', mode === 'youtube');
-};
-
-window.editorGPFileSelected = async (input) => {
-    if (!input.files.length) return;
-    const file = input.files[0];
-    const status = document.getElementById('editor-create-status');
-    status.textContent = 'Uploading Guitar Pro file...';
-
+// Retired: the Upload File / YouTube toggle was removed — audio now arrives via
+// the single Content Import browse (or the YouTube field beside it). Kept as a
+// harmless no-op so any stray caller can't throw.
+window.editorSetAudioMode = () => {};
+
+// Upload + stage ONE Guitar Pro file into the single chart slot. Does NOT touch
+// the master-audio slot — the two are independent now (fixes the "audio falls
+// off" bug). Autofills Title/Artist/Album from the chart's own metadata.
+async function _stageGpFile(file) {
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = 'Reading Guitar Pro file…';
     const form = new FormData();
     form.append('file', file);
-
     try {
         const resp = await fetch('/api/plugins/editor/import-gp', { method: 'POST', body: form });
         const data = await resp.json();
-        if (data.error) { status.textContent = 'Error: ' + data.error; return; }
-
+        if (data.error) { if (iStatus) iStatus.textContent = 'Error: ' + data.error; return; }
         createState.gpPath = data.gp_path;
         createState.tracks = data.tracks;
+        createState.gpName = file.name;
+        createState.gpHasEmbedded = !!data.has_embedded_audio;
+        createState.gpSyncCount = data.sync_point_count || 0;
+        createState.mode = 'gp';
+        // Chart slot is exclusive — a GP replaces any EOF pick. Audio untouched.
+        createState.eofFiles = null;
 
-        // Show track list
         const listEl = document.getElementById('editor-create-track-list');
-        listEl.innerHTML = data.tracks.map(t => {
+        if (listEl) listEl.innerHTML = data.tracks.map(t => {
             const isDrums = !!(t.is_drums || t.is_percussion);
-            const badge = isDrums ? ' (drums)'
-                : t.is_piano ? ' (keys)'
-                : '';
+            // Role tag (not a warning): drums used to render red, which read as
+            // an error. Each row now self-labels with a coloured role pill —
+            // amber Drums / indigo Keys / sky Bass / muted Guitar — so no legend
+            // is needed. Inline styles: core Tailwind lacks the /opacity variants.
+            const role = isDrums ? { t: 'Drums', s: 'background:rgba(245,158,11,0.16);color:#fcd34d' }
+                : t.is_piano ? { t: 'Keys', s: 'background:rgba(129,140,248,0.18);color:#c7d2fe' }
+                : t.is_bass ? { t: 'Bass', s: 'background:rgba(56,189,248,0.16);color:#7dd3fc' }
+                : { t: 'Guitar', s: 'background:#2c3040;color:#9aa0ad' };
             const disabled = t.notes === 0;
             const safeName = _editorEscHtml(t.name);
-            return `<label class="flex items-center gap-2 text-xs text-gray-300 py-0.5">
+            return `<label class="flex items-center gap-2 text-xs py-0.5">
                 <input type="checkbox" value="${t.index}" checked
                     class="accent-accent" ${disabled ? 'disabled' : ''}>
-                <span class="${isDrums ? 'text-red-300' : t.is_piano ? 'text-indigo-300' : ''}">${safeName}</span>
-                <span class="text-gray-600">${Number(t.strings) || 0}str, ${Number(t.notes) || 0} notes${badge}</span>
+                <span class="text-gray-300 flex-1" style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${safeName}</span>
+                <span class="px-1.5 py-0.5 rounded text-[10px] font-medium" style="${role.s}">${role.t}</span>
+                <span class="text-gray-600 shrink-0">${Number(t.strings) || 0}str · ${Number(t.notes) || 0} notes</span>
             </label>`;
         }).join('');
-        document.getElementById('editor-create-tracks').classList.remove('hidden');
+        document.getElementById('editor-create-tracks')?.classList.remove('hidden');
 
-        // Auto-fill title from filename
-        const stem = file.name.replace(/\.(gp[345x]?|gpx)$/i, '');
-        if (!document.getElementById('editor-create-title').value) {
-            document.getElementById('editor-create-title').value = stem;
-        }
-
-        // Show/hide GP8 embedded audio banner and auto-sync section
-        const _banner = document.getElementById('editor-gp8-audio-banner');
-        const _syncSec = document.getElementById('editor-autosync-section');
-        createState.gp8AudioMode = 'none';
-        createState.autoSyncAudioUrl = null;
-        // Clear any sync result from a previously-selected GP file in this same
-        // modal, so editorDoCreate() doesn't seed a stale audio_offset (from the
-        // old file) into the conversion of this new one. Also hide the refine
-        // row, which only applies to a live sync result.
+        // Reset any prior sync result, then derive the GP audio UI + autofill.
         createState.lastSync = null;
-        const _refineRow = document.getElementById('editor-refine-row');
-        if (_refineRow) _refineRow.classList.add('hidden');
-        // Also reset the auto-sync UI: clear the status text (so it doesn't
-        // still read "ready" against empty state) and the file input value (so
-        // re-selecting the same audio file fires a fresh change event).
+        document.getElementById('editor-refine-row')?.classList.add('hidden');
         const _asStatus = document.getElementById('editor-autosync-status');
         if (_asStatus) _asStatus.textContent = '';
         const _asInput = document.getElementById('editor-autosync-audio');
         if (_asInput) _asInput.value = '';
-        if (data.has_embedded_audio) {
-            document.getElementById('editor-gp8-sync-count').textContent = data.sync_point_count || 0;
-            if (_banner) _banner.classList.remove('hidden');
-            if (_syncSec) _syncSec.classList.add('hidden');
-            editorSetGP8AudioMode('embedded');
-        } else {
-            if (_banner) _banner.classList.add('hidden');
-            // Show auto-sync section for ALL GP formats — gp_autosync works on GP3-GP8
-            if (_syncSec) _syncSec.classList.remove('hidden');
-            createState.gp8AudioMode = 'none';
-        }
-
-        status.textContent = `Parsed: ${data.tracks.length} tracks found`;
-        _refreshCreateBlankOptions();
+        const _syncCount = document.getElementById('editor-gp8-sync-count');
+        if (_syncCount) _syncCount.textContent = createState.gpSyncCount;
+        _refreshGpAudioUI();
+        _applyGpAutofill(data.song);
+        if (iStatus) iStatus.textContent = `Guitar Pro chart added — ${data.tracks.length} tracks.`;
         updateCreateButton();
     } catch (e) {
-        status.textContent = 'Upload failed: ' + e.message;
+        if (iStatus) iStatus.textContent = 'Upload failed: ' + e.message;
     }
+}
+
+// Back-compat wrapper (accepts the input element).
+window.editorGPFileSelected = async (input) => {
+    const f = input && input.files && input.files[0];
+    if (f) await _stageGpFile(f);
 };
 
+// Derive the GP audio UI from (chart present, master audio present, embedded).
+// FORK A: a staged master audio, when present, IS the auto-sync source — so we
+// hide the redundant embedded banner + manual autosync section and align the
+// chart to that audio at Create.
+function _refreshGpAudioUI() {
+    const banner = document.getElementById('editor-gp8-audio-banner');
+    const syncSec = document.getElementById('editor-autosync-section');
+    if (!createState.gpPath) {
+        banner?.classList.add('hidden'); syncSec?.classList.add('hidden');
+        return;
+    }
+    if (createState.audioUrl) {
+        // Coupled: the staged master audio is the alignment source (Fork A) — one
+        // click at Create runs the sync + convert with no separate audio step.
+        createState.gp8AudioMode = 'autosync';
+        createState.autoSyncAudioUrl = createState.audioUrl;
+        createState.autoSyncCoupled = true;
+        createState.lastSync = null;
+        banner?.classList.add('hidden'); syncSec?.classList.add('hidden');
+    } else if (createState.gpHasEmbedded) {
+        createState.autoSyncCoupled = false;
+        if (banner) banner.classList.remove('hidden');
+        editorSetGP8AudioMode('embedded');   // sets mode + button styles + hides syncSec
+        createState.autoSyncAudioUrl = null;
+    } else {
+        createState.autoSyncCoupled = false;
+        createState.gp8AudioMode = 'none';
+        createState.autoSyncAudioUrl = null;
+        banner?.classList.add('hidden');
+        syncSec?.classList.remove('hidden');
+    }
+}
+
+// Non-destructive autofill of Title/Artist/Album from an imported chart's own
+// metadata — fills only EMPTY fields, with a one-time note. Editing any of them
+// dismisses the note (see the input listener).
+function _applyGpAutofill(song) {
+    if (!song) return;
+    const filled = [];
+    const fill = (id, val, label) => {
+        const el = document.getElementById(id);
+        if (val && el && !el.value.trim()) { el.value = val; filled.push(label); }
+    };
+    fill('editor-create-title', song.title, 'Title');
+    fill('editor-create-artist', song.artist, 'Artist');
+    fill('editor-create-album', song.album, 'Album');
+    const note = document.getElementById('editor-create-autofill-note');
+    if (note) note.textContent = filled.length
+        ? 'Filled ' + filled.join(', ') + ' from the imported chart — edit anything.' : '';
+    updateCreateButton();
+}
+
 // Shared upload helper for the Create modal and the Replace Audio modal.
 // Returns the new audio URL on success or null on missing input / failure.
 // The caller is responsible for any "missing input" UX (the helper returns
@@ -7381,93 +7550,977 @@ async function _uploadAudioForMode({ mode, ytInputId, fileInputId, statusEl }) {
 }
 
 async function uploadCreateAudio() {
+    // Audio FILES upload on selection (Content Import → createState.audioUrl).
+    // Here we only resolve a pasted YouTube URL when no file audio is set yet.
+    if (createState.audioUrl) return true;
+    const yt = ((document.getElementById('editor-create-yt-url')?.value) || '').trim();
+    if (!yt) return false;
     const url = await _uploadAudioForMode({
-        mode: createState.audioMode,
+        mode: 'youtube',
         ytInputId: 'editor-create-yt-url',
-        fileInputId: 'editor-create-audio',
-        statusEl: document.getElementById('editor-audio-status'),
+        fileInputId: 'editor-create-import',
+        statusEl: document.getElementById('editor-create-import-status')
+            || document.getElementById('editor-create-status'),
     });
     if (!url) return false;
     createState.audioUrl = url;
     return true;
 }
 
+// Pure gate — INPUT-DRIVEN so it can be unit-tested (tests/create_gate.test.js).
+// A picked Guitar Pro file wins, then EOF XML arrangement(s). Otherwise it's a
+// from-scratch create, which needs a title AND at least one instrument in the
+// roster (Vocals alone can't stand — the spec requires a non-empty arrangements
+// list). Audio + artist stay optional (draft-now, audio-later).
+function _createGateOpen(state, flags) {
+    if (!state || !flags) return false;
+    if (state.gpPath) return true;
+    if (state.eofFiles && state.eofFiles.length) return true;
+    var instruments = ['Lead', 'Rhythm', 'Keys', 'Bass', 'Drums'];
+    var hasInstrument = !!(state.roster && state.roster.some(function (r) {
+        return instruments.indexOf(r) >= 0;
+    }));
+    return !!(flags.hasTitle && hasInstrument);
+}
+
 function _createHasAudioInput() {
-    if (createState.audioMode === 'youtube') {
-        return !!document.getElementById('editor-create-yt-url')?.value.trim();
+    if (createState.audioUrl) return true;
+    return !!((document.getElementById('editor-create-yt-url')?.value) || '').trim();
+}
+
+// The spec-complete metadata typed in the create modal, so a Guitar Pro / EOF
+// import carries the same fields the blank-create path sends (the backend
+// normalizes + persists them at Build). Values are raw strings; the server
+// coerces track/disc to ints and genres/authors to lists.
+function _createExtendedMeta() {
+    const v = (id) => ((document.getElementById(id)?.value) || '').trim();
+    return {
+        album_artist: v('editor-create-album-artist'),
+        track: v('editor-create-track'),
+        disc: v('editor-create-disc'),
+        genres: v('editor-create-genre'),
+        language: v('editor-create-language'),
+        isrc: v('editor-create-isrc'),
+        mbid: v('editor-create-mbid'),
+        authors: v('editor-create-authors'),
+    };
+}
+
+function updateCreateButton() {
+    const open = _createGateOpen(createState, {
+        hasTitle: !!((document.getElementById('editor-create-title')?.value) || '').trim(),
+        hasArtist: !!((document.getElementById('editor-create-artist')?.value) || '').trim(),
+        hasAudio: _createHasAudioInput(),
+    });
+    const btn = document.getElementById('editor-create-go');
+    if (btn) btn.disabled = !open;
+    if (typeof _updateMbButton === 'function') _updateMbButton();
+}
+
+// Populate the Blank-mode "Initial Arrangement" toggle. Lead / Rhythm / Bass are
+// the arrangements the create_sloppak backend accepts today; Keys/Drums-as-arr
+// + extended tunings need backend work (tracked separately). The drum-tab
+// checkbox beside it covers a drum chart.
+// Fretted roles carry a string count + tuning; Keys (piano-roll) and Drums
+// (drum tab) don't. The editor opens each in the right mode by the arrangement
+// NAME (KEYS_PATTERN / ^drums), which the create route sets from initialArr.
+const _FRETTED_ROLES = ['Lead', 'Rhythm', 'Bass'];
+function _isFrettedRole(role) { return _FRETTED_ROLES.includes(role); }
+
+// String-count options per role — feedpak-spec §5.2 allows tuning length 4-8.
+// Guitar roles offer 6/7/8; Bass offers 4/5/6.
+function _createRoleStringOptions(role) {
+    return role === 'Bass' ? [4, 5, 6] : [6, 7, 8];
+}
+function _createRoleDefaultStrings(role) {
+    return role === 'Bass' ? 4 : 6;
+}
+
+// ════════════════════════════════════════════════════════════════════
+// Roster — "What are you arranging?" Click a palette chip to add a role;
+// drag the selected chips to reorder. Backend canonical names: Vocals,
+// Lead, Rhythm, Keys, Bass, Drums (create_sloppak maps display labels too).
+// ════════════════════════════════════════════════════════════════════
+const _CREATE_ROSTER = [
+    { id: 'Vocals', label: 'Vocals' },
+    { id: 'Lead', label: 'Lead Guitar' },
+    { id: 'Rhythm', label: 'Rhythm Guitar' },
+    { id: 'Keys', label: 'Keys' },
+    { id: 'Bass', label: 'Bass Guitar' },
+    { id: 'Drums', label: 'Drums' },
+];
+const _CREATE_INSTRUMENTS = ['Lead', 'Rhythm', 'Keys', 'Bass', 'Drums'];
+function _rosterLabel(id) {
+    const r = _CREATE_ROSTER.find((x) => x.id === id);
+    return r ? r.label : id;
+}
+
+function _populateRosterPalette() {
+    const wrap = document.getElementById('editor-create-roster-palette');
+    if (!wrap) return;
+    wrap.replaceChildren();
+    for (const r of _CREATE_ROSTER) {
+        const inSel = createState.roster.includes(r.id);
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.textContent = (inSel ? '✓ ' : '+ ') + r.label;
+        b.className = 'px-2 py-1 rounded text-xs font-medium '
+            + (inSel ? 'bg-accent text-white' : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
+        b.onclick = () => _toggleRosterRole(r.id);
+        wrap.appendChild(b);
     }
-    return !!(document.getElementById('editor-create-audio')?.files || []).length;
 }
 
-/* @pure:create-gate:start */
-function _createGateOpenPure(state, ctx) {
-    const hasGP = !!state.gpPath;
-    const hasEof = !!(state.eofFiles && state.eofFiles.length);
-    if (hasGP || hasEof) return true;
-    return !!(ctx && ctx.hasAudio && ctx.title && ctx.artist);
+function _toggleRosterRole(id) {
+    const i = createState.roster.indexOf(id);
+    if (i >= 0) createState.roster.splice(i, 1);
+    else createState.roster.push(id);
+    _populateRosterPalette();
+    _renderRosterSelected();
+    updateCreateButton();
 }
-/* @pure:create-gate:end */
 
-function _renderCreateArrangementButtons() {
-    const wrap = document.getElementById('editor-create-arr-buttons');
+let _rosterDragFrom = null;
+function _renderRosterSelected() {
+    const wrap = document.getElementById('editor-create-roster-selected');
     if (!wrap) return;
-    const choices = ['Lead', 'Rhythm', 'Bass'];
-    if (!choices.includes(createState.initialArrangement)) {
-        createState.initialArrangement = 'Lead';
+    wrap.replaceChildren();
+    if (!createState.roster.length) {
+        const p = document.createElement('span');
+        p.className = 'text-[11px] text-gray-600';
+        p.textContent = 'Nothing yet — click an instrument above.';
+        wrap.appendChild(p);
+    }
+    createState.roster.forEach((id, idx) => {
+        const chip = document.createElement('span');
+        chip.draggable = true;
+        chip.className = 'inline-flex items-center gap-1 px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-200 cursor-move';
+        const name = document.createElement('span');
+        name.textContent = _rosterLabel(id);
+        chip.appendChild(name);
+        const x = document.createElement('button');
+        x.type = 'button';
+        x.textContent = '✕';
+        x.className = 'text-gray-500 hover:text-white';
+        x.onclick = (e) => { e.stopPropagation(); _toggleRosterRole(id); };
+        chip.appendChild(x);
+        chip.addEventListener('dragstart', () => { _rosterDragFrom = idx; });
+        chip.addEventListener('dragover', (e) => e.preventDefault());
+        chip.addEventListener('drop', (e) => {
+            e.preventDefault();
+            if (_rosterDragFrom === null || _rosterDragFrom === idx) return;
+            const arr = createState.roster;
+            const [moved] = arr.splice(_rosterDragFrom, 1);
+            arr.splice(idx, 0, moved);
+            _rosterDragFrom = null;
+            _renderRosterSelected();
+        });
+        wrap.appendChild(chip);
+    });
+    const hint = document.getElementById('editor-create-roster-hint');
+    if (hint) {
+        const hasInstrument = createState.roster.some((r) => _CREATE_INSTRUMENTS.includes(r));
+        const hasVocals = createState.roster.includes('Vocals');
+        hint.textContent = (hasVocals && !hasInstrument)
+            ? 'Vocals adds a lyrics track — add at least one instrument to chart against.'
+            : (hasVocals ? 'Vocals seeds an empty lyrics track (a full vocals editor is coming).' : '');
+    }
+}
+
+// Single "Content Import" browse — route by extension to the right importer.
+// Single "Content Import" browse — now MULTI-file and role-routed. Each file is
+// staged into its role slot (1 master audio, 1 chart, MIDI as an info row)
+// WITHOUT clearing the other role. That's the whole fix for "the audio falls off
+// when I then add a Guitar Pro file."
+const _IMPORT_AUDIO = ['.mp3', '.wav', '.flac', '.ogg', '.m4a', '.opus', '.aac', '.wem'];
+const _IMPORT_GP = ['.gp3', '.gp4', '.gp5', '.gpx', '.gp'];
+const _extOf = (f) => (f.name.match(/\.[^.]+$/) || [''])[0].toLowerCase();
+
+window.editorContentImportSelected = async (input) => {
+    const files = [...(input.files || [])];
+    if (!files.length) return;
+    const status = document.getElementById('editor-create-import-status');
+    const audioFiles = files.filter((f) => _IMPORT_AUDIO.includes(_extOf(f)));
+    const gpFiles = files.filter((f) => _IMPORT_GP.includes(_extOf(f)));
+    const xmlFiles = files.filter((f) => _extOf(f) === '.xml');
+    const midiFiles = files.filter((f) => ['.mid', '.midi'].includes(_extOf(f)));
+    const unknown = files.filter((f) => ![..._IMPORT_AUDIO, ..._IMPORT_GP, '.xml', '.mid', '.midi'].includes(_extOf(f)));
+
+    // Chart slot (exclusive): a Guitar Pro file wins over RS/EOF XML if both are
+    // added together. Stage the chart BEFORE the audio so the coupling sees it.
+    if (gpFiles.length) {
+        await _stageGpFile(gpFiles[0]);
+        if (xmlFiles.length && status) status.textContent += ' (RS XML ignored — one chart source per song.)';
+    } else if (xmlFiles.length) {
+        _stageEofFiles(xmlFiles);
+    }
+    // Master-audio slot (one master track for now; stems later).
+    if (audioFiles.length) {
+        await _stageAudio(audioFiles[0]);
+        if (audioFiles.length > 1 && status) {
+            status.textContent = 'One master track for now — used "' + audioFiles[0].name
+                + '". (Multiple stems are coming.)';
+        }
+    }
+    if (midiFiles.length) _stageMidi(midiFiles);
+    if (unknown.length && status) {
+        status.textContent = 'Skipped unsupported: ' + unknown.map((f) => f.name).join(', ')
+            + ' (PowerTab & MusicXML are coming).';
+    }
+    // The staged list is now the source of truth — clear the input so re-adding
+    // the same file fires a fresh change and the input never "shows" one file.
+    input.value = '';
+    renderStaged();
+    updateCreateButton();
+};
+
+// Upload + stage the master audio track. Never touches the chart slot; couples
+// into GP auto-sync (via _refreshGpAudioUI) when a chart is present.
+async function _stageAudio(file) {
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = 'Uploading audio…';
+    createState.audioUrl = null;
+    createState.audioName = null;
+    createState.audioDuration = null;
+    createState.audioFile = null;
+    const form = new FormData();
+    form.append('file', file);
+    let url = null, dur = null;
+    try {
+        const resp = await fetch('/api/plugins/editor/upload-audio', { method: 'POST', body: form });
+        const data = await resp.json();
+        if (data && data.audio_url) { url = data.audio_url; dur = data.duration; }
+        else if (data && data.error && iStatus) iStatus.textContent = 'Error: ' + data.error;
+    } catch (e) {
+        if (iStatus) iStatus.textContent = 'Upload failed: ' + e.message;
+    }
+    if (url) {
+        createState.audioUrl = url;
+        createState.audioName = file.name;
+        createState.audioDuration = (Number(dur) > 0) ? Number(dur) : null;
+        // Keep the File itself so "Identify from audio" can re-POST the raw bytes
+        // to core /identify (cross-plugin: the core can't read our stored copy).
+        createState.audioFile = file;
+        const titleEl = document.getElementById('editor-create-title');
+        if (titleEl && !titleEl.value.trim()) titleEl.value = file.name.replace(/\.[^.]+$/, '');
+        if (iStatus) iStatus.textContent = 'Master audio added.';
     }
+    _refreshGpAudioUI();       // couple into GP auto-sync if a chart is present
+    _syncYtFieldState();
+    _updateIdentifyButton();
+}
+
+function _stageEofFiles(xmls) {
+    createState.eofFiles = xmls.length ? xmls : null;
+    createState.eofName = xmls.length === 1 ? xmls[0].name : (xmls.length + ' XML files');
+    createState.mode = 'eof';
+    // Chart slot is exclusive — EOF replaces GP. Audio untouched.
+    createState.gpPath = null; createState.tracks = null; createState.gpName = null;
+    document.getElementById('editor-create-tracks')?.classList.add('hidden');
+    _refreshGpAudioUI();       // no gpPath → hides GP audio UI
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = createState.eofName + ' added as the chart.';
+}
+
+function _stageMidi(files) {
+    createState.midiInfo = files.length === 1 ? files[0].name : (files.length + ' MIDI files');
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = 'MIDI added — after Create, add Keys / Drums from it in the editor (+Keys / +Drums).';
+}
+
+// Grey the YouTube field while a master-audio FILE is staged (file wins).
+function _syncYtFieldState() {
+    const yt = document.getElementById('editor-create-yt-url');
+    if (!yt) return;
+    const hasFileAudio = !!(createState.audioUrl && createState.audioName);
+    yt.disabled = hasFileAudio;
+    yt.style.opacity = hasFileAudio ? '0.5' : '';
+    yt.title = hasFileAudio ? 'Using the audio file you added — remove it to use a URL instead' : '';
+}
+
+// Render the staged file rows (audio master / chart / MIDI info), each with a
+// role chip + remove ✕. This is the honesty surface.
+function renderStaged() {
+    const wrap = document.getElementById('editor-create-staged');
+    if (!wrap) return;
     wrap.replaceChildren();
-    for (const name of choices) {
-        const btn = document.createElement('button');
-        btn.type = 'button';
-        btn.textContent = name;
-        btn.className = 'px-2 py-1 rounded text-xs font-medium '
-            + (name === createState.initialArrangement
-                ? 'bg-accent text-white'
-                : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
-        btn.onclick = () => {
-            createState.initialArrangement = name;
-            _renderCreateArrangementButtons();
-            updateCreateButton();
-        };
-        wrap.appendChild(btn);
+    const ytVal = ((document.getElementById('editor-create-yt-url')?.value) || '').trim();
+    const rows = [];
+    if (createState.audioUrl && createState.audioName) {
+        rows.push({ role: 'audio', chip: 'Master audio', chipStyle: 'background:rgba(64,128,224,0.18);color:#8fbaff',
+            name: createState.audioName, detail: createState.gpPath ? 'aligns the chart' : '' });
+    } else if (ytVal) {
+        rows.push({ role: 'yt', chip: 'Master audio · YouTube', chipStyle: 'background:rgba(64,128,224,0.18);color:#8fbaff',
+            name: ytVal, detail: createState.gpPath ? 'aligns the chart' : '' });
+    }
+    if (createState.gpPath) {
+        rows.push({ role: 'chart', chip: 'Chart · Guitar Pro', chipStyle: 'background:rgba(129,140,248,0.20);color:#c7d2fe',
+            name: createState.gpName || 'Guitar Pro file', detail: createState.tracks ? (createState.tracks.length + ' tracks') : '' });
+    } else if (createState.eofFiles && createState.eofFiles.length) {
+        rows.push({ role: 'chart', chip: 'Chart · RS XML', chipStyle: 'background:rgba(129,140,248,0.20);color:#c7d2fe',
+            name: createState.eofName || 'RS/EOF XML', detail: '' });
+    }
+    if (createState.midiInfo) {
+        rows.push({ role: 'midi', chip: 'MIDI · adds after create', chipCls: 'bg-dark-600 text-gray-400',
+            name: createState.midiInfo, detail: '' });
+    }
+    if (!rows.length) {
+        const hint = document.createElement('div');
+        hint.className = 'text-[11px] text-gray-600';
+        hint.textContent = 'Nothing added yet — audio and/or a chart are optional.';
+        wrap.appendChild(hint);
+        return;
+    }
+    for (const r of rows) {
+        const row = document.createElement('div');
+        row.className = 'flex items-center gap-2 bg-dark-800 rounded px-2 py-1 text-xs';
+        const chip = document.createElement('span');
+        chip.className = 'px-1.5 py-0.5 rounded text-[10px] font-medium shrink-0 ' + (r.chipCls || '');
+        if (r.chipStyle) chip.style.cssText = r.chipStyle;
+        chip.textContent = r.chip;
+        row.appendChild(chip);
+        const name = document.createElement('span');
+        name.className = 'text-gray-300 flex-1';
+        name.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap';
+        name.textContent = r.name;
+        row.appendChild(name);
+        if (r.detail) {
+            const d = document.createElement('span');
+            d.className = 'text-gray-600 shrink-0';
+            d.textContent = r.detail;
+            row.appendChild(d);
+        }
+        const x = document.createElement('button');
+        x.type = 'button';
+        x.className = 'text-gray-500 hover:text-white shrink-0';
+        x.textContent = '✕';
+        x.title = 'Remove';
+        x.onclick = () => editorStagedRemove(r.role);
+        row.appendChild(x);
+        wrap.appendChild(row);
+    }
+    // Honest one-liner: the preview clip is auto-made from the master audio (no
+    // upload). Shown only when there IS a master audio to make it from.
+    const hasMaster = !!(createState.audioUrl && createState.audioName)
+        || !!((document.getElementById('editor-create-yt-url')?.value) || '').trim();
+    if (hasMaster) {
+        const pv = document.createElement('div');
+        pv.className = 'text-[11px] text-gray-600';
+        pv.textContent = 'Preview clip: auto-made from your master audio.';
+        wrap.appendChild(pv);
+    }
+}
+
+window.editorStagedRemove = (role) => {
+    if (role === 'audio') {
+        createState.audioUrl = null; createState.audioName = null; createState.audioDuration = null;
+        createState.audioFile = null;
+        _refreshGpAudioUI();        // un-couple: restore embedded/manual GP audio UI
+        _syncYtFieldState();
+        _updateIdentifyButton();
+    } else if (role === 'yt') {
+        const yt = document.getElementById('editor-create-yt-url'); if (yt) yt.value = '';
+        _syncYtFieldState();
+    } else if (role === 'chart') {
+        createState.gpPath = null; createState.tracks = null; createState.eofFiles = null;
+        createState.gpName = null; createState.eofName = null; createState.gpHasEmbedded = false;
+        createState.lastSync = null; createState.autoSyncAudioUrl = null;
+        document.getElementById('editor-create-tracks')?.classList.add('hidden');
+        _refreshGpAudioUI();        // no gpPath → hides GP audio UI
+    } else if (role === 'midi') {
+        createState.midiInfo = null;
+    }
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = '';
+    renderStaged();
+    updateCreateButton();
+};
+
+window.editorYtUrlInput = () => {
+    // A YouTube URL is an alternative audio source (resolved at Create). It
+    // doesn't gate the button (audio is optional) but should show in the list.
+    _syncYtFieldState();
+    renderStaged();
+    updateCreateButton();
+};
+
+// ════════════════════════════════════════════════════════════════════
+// MusicBrainz "Match…" — scan-first: uses the Title/Artist already on the form,
+// opens a popup with an editable query + candidate list, and fills the details
+// on pick. Reuses core's same-origin, rate-limited GET /api/enrichment/search.
+// ════════════════════════════════════════════════════════════════════
+function _cval(id) { return ((document.getElementById(id)?.value) || '').trim(); }
+
+function _updateMbButton() {
+    const btn = document.getElementById('editor-create-mb-btn');
+    const hint = document.getElementById('editor-create-mb-hint');
+    if (!btn) return;
+    const has = !!(_cval('editor-create-title') || _cval('editor-create-artist'));
+    btn.disabled = !has;
+    if (hint) hint.textContent = has ? '' : 'Add a title or artist to match.';
+}
+
+window.editorMbMatch = () => {
+    _editorMbOpenPopup(_cval('editor-create-title'), _cval('editor-create-artist'));
+};
+
+// "Identify from audio" is enabled once a master track is staged — it fingerprints
+// THAT file, so it doesn't need a title/artist (that's the whole point: it's the
+// reliable path when you don't know the metadata yet).
+function _updateIdentifyButton() {
+    const btn = document.getElementById('editor-create-identify-btn');
+    if (!btn) return;
+    const has = !!createState.audioFile;
+    btn.disabled = !has;
+    btn.title = has
+        ? 'Identify the exact recording by fingerprinting your master audio'
+        : 'Add master audio first to identify by fingerprint';
+}
+
+// Fingerprint the staged master audio → the EXACT MusicBrainz recording (AcoustID).
+// Reliable where text search can't be (comp/live takes tie in MusicBrainz). The
+// endpoint returns candidates in the SAME shape as /search, so the popup reuses
+// the MB row + apply renderers.
+window.editorIdentifyAudio = async () => {
+    if (!createState.audioFile) return;
+    document.getElementById('editor-mb-popup')?.remove();
+    const modal = document.createElement('div');
+    modal.id = 'editor-mb-popup';
+    modal.className = 'fixed inset-0 bg-black/70 z-50 flex items-center justify-center';
+    const inner = document.createElement('div');
+    inner.className = 'bg-dark-800 border border-gray-700 rounded-xl w-full max-w-md mx-4 flex flex-col';
+    inner.style.maxHeight = '75vh';
+    const head = document.createElement('div');
+    head.className = 'flex items-center justify-between px-4 py-3 border-b border-gray-700';
+    const h = document.createElement('span'); h.className = 'text-sm font-medium'; h.textContent = 'Identify from audio';
+    const close = document.createElement('button'); close.type = 'button'; close.className = 'text-gray-500 hover:text-white'; close.textContent = '×';
+    close.onclick = () => modal.remove();
+    head.appendChild(h); head.appendChild(close); inner.appendChild(head);
+    const results = document.createElement('div');
+    results.id = 'editor-mb-results';
+    results.className = 'flex-1 overflow-y-auto p-2 space-y-1';
+    inner.appendChild(results);
+    modal.appendChild(inner);
+    if (typeof _installModalKeyboard === 'function') _installModalKeyboard(modal, inner, () => modal.remove());
+    document.body.appendChild(modal);
+    _mbMsg(results, 'Fingerprinting your audio…');
+    const form = new FormData();
+    form.append('file', createState.audioFile);
+    let data = null, status = 0;
+    try {
+        const resp = await fetch('/api/enrichment/identify', { method: 'POST', body: form });
+        status = resp.status;
+        data = await resp.json().catch(() => null);
+    } catch (_) { data = null; }
+    results.replaceChildren();
+    // 412 = not set up (opt-in off / no key). Expand an inline enable + key form
+    // right here (self-serve) — never fake a hit, and no separate settings trip.
+    if (status === 412 || (data && data.needs_setup)) {
+        _editorRenderAcoustidSetup(results);
+        return;
+    }
+    if (status === 503) {
+        // 503 here is usually a rejected key (AcoustID 400) or a transient
+        // outage. Either way, let the user re-enter the key — don't dead-end.
+        results.replaceChildren();
+        const wrap = document.createElement('div'); wrap.className = 'p-3 space-y-2';
+        const m = document.createElement('p'); m.className = 'text-xs text-gray-400';
+        m.textContent = "Couldn't identify — the AcoustID key was rejected, or the service is "
+            + "unreachable. Check the key (use your application's API key, not your account key), "
+            + "or try again.";
+        const change = document.createElement('button');
+        change.type = 'button';
+        change.className = 'px-3 py-1.5 rounded text-xs font-medium bg-dark-600 text-gray-200 hover:bg-dark-500';
+        change.textContent = 'Change AcoustID key';
+        change.onclick = () => _editorRenderAcoustidSetup(results);
+        wrap.appendChild(m); wrap.appendChild(change); results.appendChild(wrap);
+        return;
     }
+    if (status === 429) { _mbMsg(results, 'AcoustID is busy — try again in a moment.'); return; }
+    if (!data || data.error) { _mbMsg(results, "Couldn't identify this audio — try the text Match instead."); return; }
+    const cands = data.candidates || [];
+    if (!cands.length) { _mbMsg(results, 'No fingerprint match found — try the text Match instead.'); return; }
+    // A fingerprint hit IS this recording, so flag the top row as matching the
+    // audio and focus it; the user confirms by clicking.
+    cands.forEach((c, i) => results.appendChild(_editorMbRow(c, i === 0, i === 0)));
+};
+
+// Inline "turn on audio identification" form, shown in the Identify popup when
+// AcoustID is off / keyless (the 412 needs_setup state). Saves the user's own
+// free key to core settings, then re-runs the fingerprint — self-serve, no
+// separate settings screen (that UI is part of the library-metadata work).
+function _editorRenderAcoustidSetup(el) {
+    el.replaceChildren();
+    const wrap = document.createElement('div'); wrap.className = 'p-3 space-y-2';
+    const msg = document.createElement('p'); msg.className = 'text-xs text-gray-400';
+    msg.textContent = 'Audio identification reads the recording itself — far more reliable than text '
+        + 'search for picking the exact version. It needs your own free AcoustID key (one-time).';
+    const link = document.createElement('a');
+    link.href = 'https://acoustid.org/new-application'; link.target = '_blank'; link.rel = 'noopener';
+    link.className = 'text-xs text-blue-400 hover:underline block';
+    link.textContent = 'Register an application for a free key →';
+    const hint = document.createElement('p'); hint.className = 'text-[11px] text-gray-600';
+    hint.textContent = "Use the application's API key (from acoustid.org/my-applications) — not your account's user key.";
+    const key = document.createElement('input');
+    key.type = 'text'; key.placeholder = 'Paste your AcoustID API key';
+    key.className = 'w-full bg-dark-900 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none focus:border-accent/50';
+    const err = document.createElement('div'); err.className = 'text-[11px] text-red-400';
+    const go = document.createElement('button');
+    go.type = 'button'; go.className = 'px-3 py-1.5 rounded text-xs font-medium text-white';
+    go.style.background = '#2563eb'; go.textContent = 'Enable & identify';
+    const submit = async () => {
+        const k = key.value.trim();
+        if (!k) { err.textContent = 'Paste your key first.'; return; }
+        go.disabled = true; err.textContent = ''; go.textContent = 'Saving…';
+        let ok = false;
+        try {
+            const r = await fetch('/api/settings', {
+                method: 'POST', headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ acoustid_enabled: true, acoustid_api_key: k }),
+            });
+            const d = await r.json().catch(() => null);
+            ok = r.ok && !(d && d.error);
+            if (!ok && d && d.error) err.textContent = d.error;
+        } catch (_) {}
+        if (ok) { window.editorIdentifyAudio(); }   // re-open + run the fingerprint
+        else { go.disabled = false; go.textContent = 'Enable & identify'; if (!err.textContent) err.textContent = "Couldn't save the key."; }
+    };
+    go.onclick = submit;
+    key.addEventListener('keydown', (e) => { if (e.key === 'Enter') { e.preventDefault(); submit(); } });
+    wrap.appendChild(msg); wrap.appendChild(link); wrap.appendChild(hint); wrap.appendChild(key); wrap.appendChild(err); wrap.appendChild(go);
+    el.appendChild(wrap);
+    setTimeout(() => { try { key.focus(); } catch (_) {} }, 0);
 }
 
-function _refreshCreateBlankOptions() {
-    const blankOpts = document.getElementById('editor-create-blank-opts');
-    if (!blankOpts) return;
-    blankOpts.classList.toggle('hidden', !!createState.gpPath || !!(createState.eofFiles && createState.eofFiles.length));
+function _editorMbOpenPopup(title, artist) {
+    document.getElementById('editor-mb-popup')?.remove();
+    const modal = document.createElement('div');
+    modal.id = 'editor-mb-popup';
+    modal.className = 'fixed inset-0 bg-black/70 z-50 flex items-center justify-center';
+    const inner = document.createElement('div');
+    inner.className = 'bg-dark-800 border border-gray-700 rounded-xl w-full max-w-md mx-4 flex flex-col';
+    inner.style.maxHeight = '75vh';
+    const head = document.createElement('div');
+    head.className = 'flex items-center justify-between px-4 py-3 border-b border-gray-700';
+    const h = document.createElement('span'); h.className = 'text-sm font-medium'; h.textContent = 'Match on MusicBrainz';
+    const close = document.createElement('button'); close.type = 'button'; close.className = 'text-gray-500 hover:text-white'; close.textContent = '×';
+    close.onclick = () => modal.remove();
+    head.appendChild(h); head.appendChild(close); inner.appendChild(head);
+    // STRUCTURED Artist + Title fields — MusicBrainz's recording search is built
+    // for these; cramming both into one fuzzy field returns junk (or nothing).
+    const qrow = document.createElement('div');
+    qrow.className = 'flex items-center gap-2 px-4 py-2 border-b border-gray-700';
+    const mk = (ph, val) => {
+        const i = document.createElement('input');
+        i.type = 'text'; i.placeholder = ph; i.value = val || '';
+        i.className = 'flex-1 min-w-0 bg-dark-900 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none focus:border-accent/50';
+        return i;
+    };
+    const aIn = mk('Artist', artist);
+    const tIn = mk('Title', title);
+    const go = document.createElement('button');
+    go.type = 'button'; go.className = 'px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 shrink-0';
+    go.textContent = 'Search';
+    qrow.appendChild(aIn); qrow.appendChild(tIn); qrow.appendChild(go); inner.appendChild(qrow);
+    const results = document.createElement('div');
+    results.id = 'editor-mb-results';
+    results.className = 'flex-1 overflow-y-auto p-2 space-y-1';
+    inner.appendChild(results);
+    modal.appendChild(inner);
+    if (typeof _installModalKeyboard === 'function') _installModalKeyboard(modal, inner, () => modal.remove());
+    document.body.appendChild(modal);
+    const run = () => _editorMbRunSearch(aIn.value.trim(), tIn.value.trim(), results);
+    go.onclick = run;
+    const onEnter = (e) => { if (e.key === 'Enter') { e.preventDefault(); run(); } };
+    aIn.addEventListener('keydown', onEnter); tIn.addEventListener('keydown', onEnter);
+    run();
+}
+
+// Blend our match score with a duration-to-staged-audio bonus. The master audio
+// IS the version the user wants to chart, so a length match is a strong signal
+// that separates the studio take from live/extended cuts.
+function _mbRankKey(c, dur) {
+    let k = Number(c.score) || 0;
+    if (dur > 0 && Number(c.duration)) {
+        const diff = Math.abs(Number(c.duration) - dur);
+        if (diff <= 4) k += 0.5;
+        else if (diff <= 12) k += 0.2;
+        else k -= Math.min(diff, 120) / 400;
+    }
+    return k;
+}
+
+async function _editorMbRunSearch(artist, title, resultsEl) {
+    if (!resultsEl) return;
+    resultsEl.replaceChildren();
+    if (!artist && !title) { _mbMsg(resultsEl, 'Enter an artist or title to search.'); return; }
+    _mbMsg(resultsEl, 'Searching MusicBrainz…');
+    const params = new URLSearchParams();
+    if (artist) params.set('artist', artist);
+    if (title) params.set('title', title);
+    // Fetch the max (25): a non-title-track studio recording can sit well down
+    // MusicBrainz's flat list (dozens of comp/reissue takes score identically),
+    // so a small limit drops it entirely and the duration re-rank has nothing to
+    // promote. Verified: Judas Priest "Living After Midnight" — the 1980 British
+    // Steel take is absent at 15 but present (and #1 after duration) at 25.
+    params.set('limit', '25');
+    // Pass the staged master audio's length so the server can corroborate too
+    // (harmless if the core doesn't consume it; the client re-rank below is the
+    // load-bearing path today).
+    if (Number(createState.audioDuration) > 0) params.set('duration', String(Math.round(createState.audioDuration)));
+    let data = null, status = 0;
+    try {
+        const resp = await fetch('/api/enrichment/search?' + params.toString());
+        status = resp.status;
+        data = await resp.json().catch(() => null);
+    } catch (_) { data = null; }
+    resultsEl.replaceChildren();
+    if (status === 429) { _mbMsg(resultsEl, 'MusicBrainz is busy — try again in a moment.'); return; }
+    if (status === 503 || (data && data.error)) { _mbMsg(resultsEl, "Couldn't reach MusicBrainz. Enter details manually."); return; }
+    let cands = (data && data.candidates) || [];
+    if (!cands.length) { _mbMsg(resultsEl, 'No matches — refine the artist/title and try again.'); return; }
+    // #2 — re-rank by closeness of each candidate's length to the staged audio.
+    const dur = Number(createState.audioDuration) || 0;
+    let bestIdx = -1;
+    if (dur > 0) {
+        cands = cands.slice().sort((a, b) => _mbRankKey(b, dur) - _mbRankKey(a, dur));
+        let bestDiff = Infinity;
+        cands.forEach((c, i) => {
+            const d = Math.abs((Number(c.duration) || 1e9) - dur);
+            if (d <= 4 && d < bestDiff) { bestDiff = d; bestIdx = i; }
+        });
+    }
+    cands.forEach((c, i) => resultsEl.appendChild(_editorMbRow(c, i === 0, i === bestIdx)));
+}
+
+function _mbMsg(el, text) {
+    const d = document.createElement('div'); d.className = 'text-xs text-gray-500 p-2'; d.textContent = text; el.appendChild(d);
+}
+
+function _mbDur(sec) {
+    const s = Number(sec); if (!s || s <= 0) return '';
+    const m = Math.floor(s / 60), r = Math.round(s % 60);
+    return m + ':' + String(r).padStart(2, '0');
+}
+
+function _editorMbRow(c, focus, matchesAudio) {
+    const b = document.createElement('button');
+    b.type = 'button';
+    b.className = 'w-full text-left px-2 py-1.5 rounded hover:bg-dark-600 flex items-center gap-2';
+    const col = document.createElement('span'); col.className = 'flex-1'; col.style.minWidth = '0';
+    const t = document.createElement('span'); t.className = 'text-xs text-gray-200 block';
+    t.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap'; t.textContent = c.title || '(untitled)';
+    const sub = document.createElement('span'); sub.className = 'text-[11px] text-gray-500 block';
+    sub.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap';
+    sub.textContent = [c.artist, c.album, c.year, _mbDur(c.duration)].filter(Boolean).join(' · ');
+    col.appendChild(t); col.appendChild(sub); b.appendChild(col);
+    // "≈ your audio" tag — this candidate's length matches the staged master.
+    if (matchesAudio) {
+        const m = document.createElement('span');
+        m.className = 'px-1.5 py-0.5 rounded text-[10px] font-medium shrink-0';
+        m.style.cssText = 'background:rgba(64,128,224,0.18);color:#8fbaff';
+        m.textContent = '≈ your audio';
+        b.appendChild(m);
+    }
+    // Confidence pill — green only when earned.
+    let score = Number(c.mb_score) || 0; if (score <= 1) score = Math.round(score * 100);
+    const pill = document.createElement('span');
+    pill.className = 'px-1.5 py-0.5 rounded text-[10px] font-medium shrink-0';
+    if (score >= 90) { pill.textContent = 'High'; pill.style.cssText = 'background:rgba(22,163,74,0.22);color:#86efac'; }
+    else if (score >= 60) { pill.textContent = 'Good'; pill.style.cssText = 'background:rgba(245,158,11,0.16);color:#fcd34d'; }
+    else { pill.textContent = 'Low'; pill.style.cssText = 'background:#2c3040;color:#9aa0ad'; }
+    b.appendChild(pill);
+    b.onclick = () => _editorMbApply(c);
+    if (focus) setTimeout(() => { try { b.focus(); } catch (_) {} }, 0);
+    return b;
+}
+
+function _editorMbApply(c) {
+    // Explicit pick = overwrite (deferring to a stale filename-title would be
+    // wrong). Only set fields MB actually has; leave the rest untouched.
+    const set = (id, v) => { const el = document.getElementById(id); if (el && v != null && String(v).trim() !== '') el.value = String(v).trim(); };
+    set('editor-create-title', c.title);
+    set('editor-create-artist', c.artist);
+    set('editor-create-album', c.album);
+    set('editor-create-year', c.year);
+    set('editor-create-isrc', c.isrc);
+    set('editor-create-mbid', c.recording_id);
+    if (Array.isArray(c.genres) && c.genres.length) set('editor-create-genre', c.genres.join(', '));
+    const note = document.getElementById('editor-create-autofill-note');
+    if (note) note.textContent = (c.source === 'acoustid')
+        ? 'Filled from an audio fingerprint (AcoustID) — edit anything.'
+        : 'Filled from MusicBrainz — edit anything.';
+    document.getElementById('editor-mb-popup')?.remove();
+    _updateMbButton();
+    updateCreateButton();
 }
 
-function updateCreateButton() {
-    const title = !!document.getElementById('editor-create-title')?.value.trim();
-    const artist = !!document.getElementById('editor-create-artist')?.value.trim();
-    const canCreate = _createGateOpenPure(createState, {
-        hasAudio: _createHasAudioInput(),
-        title,
-        artist,
-    });
-    document.getElementById('editor-create-go').disabled = !canCreate;
+// Album art: preview locally + upload to get an art_path baked into create.
+window.editorCreateArtSelected = async (input) => {
+    const file = input.files && input.files[0];
+    const prev = document.getElementById('editor-create-art-preview');
+    if (!file) {
+        createState.artPath = null;
+        if (prev) { prev.style.backgroundImage = ''; prev.textContent = 'No art yet'; }
+        return;
+    }
+    try {
+        const rd = new FileReader();
+        rd.onload = () => { if (prev) { prev.style.backgroundImage = 'url("' + rd.result + '")'; prev.textContent = ''; } };
+        rd.readAsDataURL(file);
+    } catch (_) { /* preview is best-effort */ }
+    const form = new FormData();
+    form.append('file', file);
+    try {
+        const resp = await fetch('/api/plugins/editor/upload-art', { method: 'POST', body: form });
+        const data = await resp.json();
+        if (data && data.art_path) createState.artPath = data.art_path;
+    } catch (_) { /* art just won't be baked if the upload fails */ }
+};
+
+// ════════════════════════════════════════════════════════════════════
+// Album-art picker — a Plex-style grid of covers from the Cover Art Archive.
+// Reuses the MusicBrainz search to get candidate release MBIDs, then shows one
+// tile per release's CAA front cover (served same-origin via the editor plugin,
+// so it loads under the app's CSP). Pick one → baked as the pack's art.
+// ════════════════════════════════════════════════════════════════════
+window.editorArtSearch = () => {
+    // Art is an ALBUM property, so search by the album when we know it (filled by
+    // a MusicBrainz Match, or typed) — falling back to the title. This is why
+    // Match-first works: it fills the album, which pins the canonical cover.
+    const album = _cval('editor-create-album');
+    const title = _cval('editor-create-title');
+    _editorArtOpenPopup(_cval('editor-create-artist'), album || title);
+};
+
+function _editorArtOpenPopup(artist, query) {
+    document.getElementById('editor-art-popup')?.remove();
+    const modal = document.createElement('div');
+    modal.id = 'editor-art-popup';
+    modal.className = 'fixed inset-0 bg-black/70 z-50 flex items-center justify-center';
+    const inner = document.createElement('div');
+    inner.className = 'bg-dark-800 border border-gray-700 rounded-xl w-full max-w-lg mx-4 flex flex-col';
+    inner.style.maxHeight = '80vh';
+    const head = document.createElement('div');
+    head.className = 'flex items-center justify-between px-4 py-3 border-b border-gray-700';
+    const h = document.createElement('span'); h.className = 'text-sm font-medium'; h.textContent = 'Choose album art';
+    const close = document.createElement('button'); close.type = 'button'; close.className = 'text-gray-500 hover:text-white'; close.textContent = '×';
+    close.onclick = () => modal.remove();
+    head.appendChild(h); head.appendChild(close); inner.appendChild(head);
+    const qrow = document.createElement('div');
+    qrow.className = 'flex items-center gap-2 px-4 py-2 border-b border-gray-700';
+    const mk = (ph, val) => {
+        const i = document.createElement('input');
+        i.type = 'text'; i.placeholder = ph; i.value = val || '';
+        i.className = 'flex-1 min-w-0 bg-dark-900 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none focus:border-accent/50';
+        return i;
+    };
+    const aIn = mk('Artist', artist);
+    const tIn = mk('Album (or song)', query);
+    const go = document.createElement('button');
+    go.type = 'button'; go.className = 'px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 shrink-0';
+    go.textContent = 'Search';
+    qrow.appendChild(aIn); qrow.appendChild(tIn); qrow.appendChild(go); inner.appendChild(qrow);
+    const grid = document.createElement('div');
+    grid.id = 'editor-art-grid';
+    grid.className = 'flex-1 overflow-y-auto p-3';
+    grid.style.cssText = 'display:grid;grid-template-columns:repeat(3,1fr);gap:8px;';
+    inner.appendChild(grid);
+    modal.appendChild(inner);
+    if (typeof _installModalKeyboard === 'function') _installModalKeyboard(modal, inner, () => modal.remove());
+    document.body.appendChild(modal);
+    const run = () => _editorArtRunSearch(aIn.value.trim(), tIn.value.trim(), grid);
+    go.onclick = run;
+    const onEnter = (e) => { if (e.key === 'Enter') { e.preventDefault(); run(); } };
+    aIn.addEventListener('keydown', onEnter); tIn.addEventListener('keydown', onEnter);
+    run();
+}
+
+function _editorArtMsg(grid, text) {
+    const d = document.createElement('div');
+    d.className = 'text-xs text-gray-500 p-2';
+    d.style.gridColumn = '1 / -1';
+    d.textContent = text;
+    grid.appendChild(d);
+}
+
+async function _editorArtRunSearch(artist, query, grid) {
+    grid.replaceChildren();
+    if (!artist && !query) { _editorArtMsg(grid, 'Enter an artist and album (or song).'); return; }
+    _editorArtMsg(grid, 'Searching for covers…');
+    // ALBUM-centric: MusicBrainz release-groups reliably tell studio Album from
+    // Live/Compilation, so the canonical album cover comes first.
+    let tiles = [];
+    try {
+        const p = new URLSearchParams();
+        if (artist) p.set('artist', artist);
+        if (query) p.set('query', query);
+        const r = await fetch('/api/plugins/editor/cover-search?' + p.toString());
+        const d = await r.json().catch(() => null);
+        tiles = ((d && d.covers) || []).map(c => ({
+            id: c.id, group: true, studio: c.studio,
+            label: c.year ? (c.title + ' (' + c.year + ')') : c.title,
+        }));
+    } catch (_) { /* fall through to the recording-based fallback */ }
+    // Fallback (e.g. a non-title-track searched art-first with no album): the
+    // recording search's per-release covers — less canonical, but something.
+    if (!tiles.length) {
+        try {
+            const p2 = new URLSearchParams();
+            if (artist) p2.set('artist', artist);
+            if (query) p2.set('title', query);
+            p2.set('limit', '15');
+            const r2 = await fetch('/api/enrichment/search?' + p2.toString());
+            const d2 = await r2.json().catch(() => null);
+            const seen = new Set();
+            for (const c of ((d2 && d2.candidates) || [])) {
+                const rid = c && c.release_id;
+                if (rid && !seen.has(rid)) { seen.add(rid); tiles.push({ id: rid, group: false, label: c.album || c.title || '' }); }
+            }
+        } catch (_) { /* nothing else to try */ }
+    }
+    grid.replaceChildren();
+    if (!tiles.length) { _editorArtMsg(grid, 'No covers found — add the album name, or run Match first.'); return; }
+    const hint = document.createElement('div');
+    hint.className = 'text-[11px] text-gray-600 pb-1'; hint.style.gridColumn = '1 / -1';
+    hint.textContent = 'Studio album first · covers with no art are hidden · click to use.';
+    grid.appendChild(hint);
+    for (const t of tiles) grid.appendChild(_editorArtTile(t));
+}
+
+function _editorArtTile(t) {
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = 'rounded overflow-hidden border border-gray-700 hover:border-accent bg-dark-900 text-left';
+    btn.style.cssText = 'display:flex;flex-direction:column;';
+    const q = t.group ? '?group=1' : '';
+    const img = document.createElement('img');
+    img.src = '/api/plugins/editor/caa-cover/' + encodeURIComponent(t.id) + q;
+    img.alt = t.label;
+    img.loading = 'lazy';
+    img.style.cssText = 'width:100%;aspect-ratio:1/1;object-fit:cover;display:block;background:#15161c;';
+    // 404 (no art for this release) → hide the whole tile.
+    img.onerror = () => { btn.style.display = 'none'; };
+    const cap = document.createElement('span');
+    cap.className = 'text-[10px] text-gray-400 px-1 py-0.5';
+    cap.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap;';
+    cap.textContent = t.label;
+    btn.appendChild(img); btn.appendChild(cap);
+    btn.onclick = () => _editorPickCaaCover(t.id, t.group);
+    return btn;
+}
+
+async function _editorPickCaaCover(id, group) {
+    const q = group ? '?group=1' : '';
+    try {
+        const resp = await fetch('/api/plugins/editor/use-caa-cover', {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ release_id: id, group: !!group }),
+        });
+        const data = await resp.json().catch(() => null);
+        if (!resp.ok || !data || !data.art_path) return;
+        createState.artPath = data.art_path;
+        const prev = document.getElementById('editor-create-art-preview');
+        if (prev) {
+            prev.style.backgroundImage = 'url("/api/plugins/editor/caa-cover/' + encodeURIComponent(id) + q + '")';
+            prev.textContent = '';
+        }
+    } catch (_) { /* leave art unset on failure */ }
+    document.getElementById('editor-art-popup')?.remove();
+}
+
+function _populateCreateArrButtons() {
+    const wrap = document.getElementById('editor-create-arr-buttons');
+    if (!wrap) return;
+    wrap.replaceChildren();
+    // Functional roster + Vocals shown-but-disabled: the editor has no vocals
+    // edit mode yet, so offering it would create a pack you can't edit — an
+    // honest "coming" rung rather than a false one.
+    const roster = [
+        { name: 'Lead' }, { name: 'Rhythm' }, { name: 'Bass' },
+        { name: 'Keys' }, { name: 'Drums' },
+        { name: 'Vocals', disabled: true,
+          title: 'Vocals editing is coming — the editor has no vocals mode yet.' },
+    ];
+    const enabled = roster.filter(r => !r.disabled).map(r => r.name);
+    if (!enabled.includes(createState.initialArr)) createState.initialArr = 'Lead';
+    for (const r of roster) {
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.dataset.arr = r.name;
+        b.textContent = r.name;
+        if (r.title) b.title = r.title;
+        if (r.disabled) {
+            b.disabled = true;
+            b.className = 'px-2 py-1 rounded text-xs font-medium bg-dark-700 text-gray-600 cursor-not-allowed';
+        } else {
+            b.className = 'px-2 py-1 rounded text-xs font-medium '
+                + (r.name === createState.initialArr
+                    ? 'bg-accent text-white'
+                    : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
+            b.onclick = () => {
+                createState.initialArr = r.name;
+                // Reset to the role's DEFAULT string count for a fresh fretted
+                // pick (Bass 4, guitar 6); Keys/Drums have none.
+                if (_isFrettedRole(r.name)) {
+                    createState.stringCount = _createRoleDefaultStrings(r.name);
+                }
+                _populateCreateArrButtons();
+                _populateStringCountButtons();
+            };
+        }
+        wrap.appendChild(b);
+    }
 }
 
+function _populateStringCountButtons() {
+    const row = document.getElementById('editor-create-strings-row');
+    const wrap = document.getElementById('editor-create-strings-buttons');
+    // Hide the whole Strings row for Keys/Drums (no strings).
+    if (row) row.classList.toggle('hidden', !_isFrettedRole(createState.initialArr));
+    if (!wrap) return;
+    wrap.replaceChildren();
+    if (!_isFrettedRole(createState.initialArr)) return;
+    const opts = _createRoleStringOptions(createState.initialArr);
+    if (!opts.includes(createState.stringCount)) createState.stringCount = opts[0];
+    for (const n of opts) {
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.textContent = n + '-string';
+        b.className = 'px-2 py-1 rounded text-xs font-medium '
+            + (n === createState.stringCount
+                ? 'bg-accent text-white'
+                : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
+        b.onclick = () => { createState.stringCount = n; _populateStringCountButtons(); };
+        wrap.appendChild(b);
+    }
+}
+
+// The Blank/Guitar Pro/EOF segmented toggle was removed — the create modal is
+// now one menu with every option visible, and editorDoCreate() routes on what
+// the user provided. `createState.mode` is still tracked (derived from file
+// selection in editorGPFileSelected / editorEofFilesSelected) for any callers
+// that pass an explicit mode; this setter just records it and re-gates. It no
+// longer hides sections or re-labels the button.
+window.editorSetCreateMode = (mode) => {
+    if (!['blank', 'gp', 'eof'].includes(mode)) mode = 'blank';
+    createState.mode = mode;
+    updateCreateButton();
+};
+
 // Wire up input change events for enabling the create button. Changing the
 // Step 2 audio inputs also invalidates a cached upload URL — otherwise
 // editorDoCreate() skips re-upload (it only uploads when audioUrl is unset)
 // and reuses the previously-selected file/URL.
-document.addEventListener('change', (e) => {
-    if (e.target.id === 'editor-create-audio') {
-        createState.audioUrl = null;
-        updateCreateButton();
-    } else if (e.target.id === 'editor-create-drum-tab') {
-        createState.initDrumTab = !!e.target.checked;
-    }
-});
 document.addEventListener('input', (e) => {
-    if (e.target.id === 'editor-create-yt-url') {
-        createState.audioUrl = null;
-        updateCreateButton();
-    } else if (e.target.id === 'editor-create-title' || e.target.id === 'editor-create-artist') {
-        updateCreateButton();
+    const id = e.target && e.target.id;
+    // The from-scratch gate depends on the title; the Match button on title OR
+    // artist. updateCreateButton re-checks both (it calls _updateMbButton).
+    if (id === 'editor-create-title' || id === 'editor-create-artist') updateCreateButton();
+    // Editing an autofilled field dismisses the one-time autofill note.
+    if (id === 'editor-create-title' || id === 'editor-create-artist' || id === 'editor-create-album') {
+        const note = document.getElementById('editor-create-autofill-note');
+        if (note) note.textContent = '';
     }
 });
 
@@ -7544,14 +8597,83 @@ window.editorRefineSync = async () => {
     }
 };
 
-window.editorDoCreate = async () => {
-    // EOF arrangement-XML import takes priority when XML files are selected.
-    if (createState.eofFiles && createState.eofFiles.length) {
-        await _editorDoEofCreate();
+// Blank-mode create: no Guitar Pro / EOF chart — just audio + metadata + an
+// empty initial arrangement (Lead/Rhythm/Bass) and an optional drum tab. POSTs
+// to create_sloppak (which already accepts an audio_url + blank arrangement)
+// and opens the freshly-written feedpak via the normal load path.
+async function _editorDoBlankCreate() {
+    const status = document.getElementById('editor-create-status');
+    const btn = document.getElementById('editor-create-go');
+    const val = (id) => ((document.getElementById(id)?.value) || '').trim();
+    const title = val('editor-create-title');
+    if (!title) {
+        if (status) status.textContent = 'A title is required.';
+        if (btn) btn.disabled = false;
         return;
     }
+    const roster = (createState.roster || []).slice();
+    if (!roster.some((r) => _CREATE_INSTRUMENTS.includes(r))) {
+        if (status) status.textContent = 'Add at least one instrument to arrange (Lead, Rhythm, Bass, Keys, or Drums).';
+        return;
+    }
+    if (btn) btn.disabled = true;
+    // Audio is optional (draft-now, audio-later): only resolve a pasted YouTube
+    // URL here — file audio uploaded already on selection. With none, we create
+    // an audio-less draft and the author adds audio later via Replace Audio.
+    if (!createState.audioUrl && _createHasAudioInput()) {
+        if (status) status.textContent = 'Uploading audio…';
+        const ok = await uploadCreateAudio();
+        if (!ok) { if (btn) btn.disabled = false; return; }
+    }
+    const meta = {
+        title,
+        artist: val('editor-create-artist'),
+        album: val('editor-create-album'),
+        album_artist: val('editor-create-album-artist'),
+        year: val('editor-create-year'),
+        track: val('editor-create-track'),
+        disc: val('editor-create-disc'),
+        genres: val('editor-create-genre'),
+        language: val('editor-create-language'),
+        isrc: val('editor-create-isrc'),
+        mbid: val('editor-create-mbid'),
+        // Open-format author credit -> manifest authors[]. Blank is fine.
+        authors: val('editor-create-authors'),
+        // Roster of arrangements the user dragged in ("What are you arranging?").
+        arrangements: roster,
+        audio_url: createState.audioUrl,
+    };
+    if (createState.artPath) meta.art_path = createState.artPath;
+    const fd = new FormData();
+    fd.append('metadata', JSON.stringify(meta));
+    if (status) status.textContent = 'Building feedpak…';
+    try {
+        const resp = await fetch('/api/plugins/editor/create_sloppak', { method: 'POST', body: fd });
+        const data = await resp.json();
+        if (!resp.ok || !data.success) {
+            if (status) status.textContent = 'Error: ' + (data.error || resp.statusText);
+            if (btn) btn.disabled = false;
+            return;
+        }
+        editorHideCreateModal();
+        if (typeof _kickLibraryRescan === 'function') _kickLibraryRescan();
+        await loadCDLC(data.filename);
+    } catch (e) {
+        if (status) status.textContent = 'Failed: ' + e.message;
+        if (btn) btn.disabled = false;
+    }
+}
+
+window.editorDoCreate = async () => {
+    // One menu, no mode toggle — route on what was provided: a Guitar Pro file
+    // wins, then EOF XML arrangement(s), else a from-scratch (draft) create
+    // (only a title is required; audio + artist are optional).
     if (!createState.gpPath) {
-        await _editorDoBlankCreate();
+        if (createState.eofFiles && createState.eofFiles.length) {
+            await _editorDoEofCreate();
+        } else {
+            await _editorDoBlankCreate();
+        }
         return;
     }
     const status = document.getElementById('editor-create-status');
@@ -7562,7 +8684,7 @@ window.editorDoCreate = async () => {
     // manual-audio path — the auto-sync uploader provides createState
     // .autoSyncAudioUrl for both. Normalise so the offset/audio_url/skip logic
     // below doesn't treat a not-yet-flipped 'upload' as a no-audio import.
-    const _gpAudioMode = (createState.gp8AudioMode === 'upload')
+    let _gpAudioMode = (createState.gp8AudioMode === 'upload')
         ? 'autosync' : (createState.gp8AudioMode || 'none');
 
     // Upload/download the Step-2 audio first — but only in modes where it's the
@@ -7571,13 +8693,20 @@ window.editorDoCreate = async () => {
     // stale/invalid Step-2 value must not block (or be downloaded for) the
     // import.
     if (_gpAudioMode !== 'embedded' && _gpAudioMode !== 'autosync') {
-        const hasAudioInput = createState.audioMode === 'youtube'
-            ? !!document.getElementById('editor-create-yt-url').value.trim()
-            : !!(document.getElementById('editor-create-audio').files || []).length;
-
-        if (hasAudioInput && !createState.audioUrl) {
+        // Audio (a Content Import file already uploaded, or a pasted YouTube URL)
+        // is optional for a GP import; attach it when present.
+        if (_createHasAudioInput() && !createState.audioUrl) {
             const ok = await uploadCreateAudio();
             if (!ok) { btn.disabled = false; return; }
+            // A pasted YouTube URL is master audio just like a staged file — but
+            // file audio couples into autosync on selection (via
+            // _refreshGpAudioUI), while a URL only resolves here at Create. Now
+            // that it's resolved, re-derive the GP audio UI so the chart
+            // auto-syncs to it, and recompute the mode so the autosync path
+            // below runs — otherwise the audio is attached UNALIGNED.
+            _refreshGpAudioUI();
+            _gpAudioMode = (createState.gp8AudioMode === 'upload')
+                ? 'autosync' : (createState.gp8AudioMode || 'none');
         }
     }
 
@@ -7616,22 +8745,25 @@ window.editorDoCreate = async () => {
             if (syncData.ok) {
                 _autoSyncOffset = syncData.audio_offset;
                 createState.lastSync = syncData;
-                // Show refine row and pause — let user optionally refine
-                // before clicking Import again to proceed to conversion.
-                const _refineRow = document.getElementById('editor-refine-row');
-                if (_refineRow) _refineRow.classList.remove('hidden');
-                const _goBtn = document.getElementById('editor-create-go');
-                if (_goBtn) _goBtn.textContent = 'Import & Open in Editor';
-                status.textContent = `✓ Synced: ${syncData.sync_point_count} points, offset ${(_autoSyncOffset ?? 0).toFixed(3)}s — optionally refine below, then click Import.`;
-                // Re-enable Import button so user can click again to convert
-                if (_goBtn) {
-                    _goBtn.disabled = false;
-                    _goBtn.removeAttribute('aria-disabled');
-                    _goBtn.focus();
-                }
-                // Store offset and return — user clicks Import again to convert
                 createState.lastSync.audio_offset = _autoSyncOffset;
-                return;
+                if (!createState.autoSyncCoupled) {
+                    // MANUAL autosync: show refine row and pause for a second
+                    // click. The COUPLED master-audio flow (Fork A) skips this
+                    // and falls straight through to convert — one click.
+                    const _refineRow = document.getElementById('editor-refine-row');
+                    if (_refineRow) _refineRow.classList.remove('hidden');
+                    const _goBtn = document.getElementById('editor-create-go');
+                    if (_goBtn) _goBtn.textContent = 'Import & Open in Editor';
+                    status.textContent = `✓ Synced: ${syncData.sync_point_count} points, offset ${(_autoSyncOffset ?? 0).toFixed(3)}s — optionally refine below, then click Import.`;
+                    if (_goBtn) {
+                        _goBtn.disabled = false;
+                        _goBtn.removeAttribute('aria-disabled');
+                        _goBtn.focus();
+                    }
+                    return;
+                }
+                status.textContent = `✓ Aligned to your audio (offset ${(_autoSyncOffset ?? 0).toFixed(3)}s) — building…`;
+                // fall through to convert
             } else {
                 // Explicit auto-sync was requested but failed — don't silently
                 // import a misaligned chart at offset 0. Stop and let the user
@@ -7685,6 +8817,8 @@ window.editorDoCreate = async () => {
                 artist: document.getElementById('editor-create-artist').value || 'Unknown',
                 album: document.getElementById('editor-create-album').value || '',
                 year: document.getElementById('editor-create-year').value || '',
+                // Spec-complete metadata → persisted into the session for Build.
+                ..._createExtendedMeta(),
             }),
         });
         const data = await resp.json();
@@ -7843,7 +8977,7 @@ window.editorApplyCreateResult = async (data) => {
 
     if (data.audio_url) await loadAudio(data.audio_url);
     draw();
-    setStatus('Imported — edit notes then click Build Song');
+    setStatus('Imported — edit notes then click Build feedpak');
 };
 
 // EOF arrangement XML(s) selected — just record them. The shared "Import & Open"
@@ -7851,11 +8985,21 @@ window.editorApplyCreateResult = async (data) => {
 window.editorEofFilesSelected = (input) => {
     const xmls = [...(input.files || [])].filter(f => /\.xml$/i.test(f.name));
     createState.eofFiles = xmls.length ? xmls : null;
-    _refreshCreateBlankOptions();
+    if (xmls.length) {
+        createState.mode = 'eof';
+        // One import source at a time: picking EOF XML clears any GP pick.
+        createState.gpPath = null;
+        createState.tracks = null;
+        const _gpInput = document.getElementById('editor-create-gp');
+        if (_gpInput) _gpInput.value = '';
+        document.getElementById('editor-create-tracks')?.classList.add('hidden');
+    } else if (!createState.gpPath) {
+        createState.mode = 'blank';
+    }
     updateCreateButton();
     const st = document.getElementById('editor-create-status');
     if (st) st.textContent = xmls.length
-        ? `${xmls.length} EOF arrangement file(s) selected — set audio/art/preview, then Import.`
+        ? `${xmls.length} EOF arrangement file(s) selected — set audio/details, then Create.`
         : '';
 };
 
@@ -7869,10 +9013,7 @@ async function _editorDoEofCreate() {
     try {
         // Audio is optional for EOF (the chart opens regardless), but upload it
         // when supplied so the editor can play in sync.
-        const hasAudioFile = !!(document.getElementById('editor-create-audio').files || []).length;
-        const hasYt = createState.audioMode === 'youtube'
-            && !!document.getElementById('editor-create-yt-url').value.trim();
-        if (!createState.audioUrl && (hasAudioFile || hasYt)) {
+        if (!createState.audioUrl && _createHasAudioInput()) {
             status.textContent = 'Uploading audio…';
             await uploadCreateAudio();   // sets createState.audioUrl on success
         }
@@ -7885,6 +9026,8 @@ async function _editorDoEofCreate() {
         form.append('artist', document.getElementById('editor-create-artist').value || '');
         form.append('album', document.getElementById('editor-create-album').value || '');
         form.append('year', document.getElementById('editor-create-year').value || '');
+        // Spec-complete metadata as one JSON blob → persisted into the session.
+        form.append('extended_meta', JSON.stringify(_createExtendedMeta()));
 
         const resp = await fetch('/api/plugins/editor/import-xml-project',
             { method: 'POST', body: form });
@@ -7988,17 +9131,8 @@ window.editorBuild = async () => {
         } catch (_) {}
     }
 
-    // Upload preview clip if selected (baked into the .sloppak as preview.<ext>)
-    const previewInput = document.getElementById('editor-create-preview');
-    if (previewInput && previewInput.files && previewInput.files.length && !createState.previewPath) {
-        const form = new FormData();
-        form.append('file', previewInput.files[0]);
-        try {
-            const r = await fetch('/api/plugins/editor/upload-preview', { method: 'POST', body: form });
-            const d = await r.json();
-            if (d.preview_path) createState.previewPath = d.preview_path;
-        } catch (_) {}
-    }
+    // Preview clips are now auto-generated server-side from the master audio —
+    // no manual upload. (See _make_preview_clip in routes.py.)
 
     try {
         const resp = await fetch('/api/plugins/editor/build', {
@@ -8140,7 +9274,7 @@ window.editorApplyReplaceAudio = async () => {
         const HINTS = {
             none:    'Audio replaced',
             save:    'Audio replaced (Save to persist to .sloppak)',
-            build:   'Audio replaced (will persist on next Build Song)',
+            build:   'Audio replaced (will persist on next Build feedpak)',
             rebuild: "Audio replaced (playback only — archive won't be repacked)",
         };
         editorHideReplaceAudioModal();
@@ -8250,15 +9384,21 @@ function init() {
     resizeCanvas();
     window.addEventListener('resize', resizeCanvas);
 
-    // Observe screen visibility for resize
+    // Observe screen visibility for resize + the entry landing.
     const obs = new MutationObserver(() => {
         const screen = document.getElementById('plugin-editor');
         if (screen && screen.classList.contains('active')) {
             setTimeout(resizeCanvas, 50);
+            // Entering the Song Editor with nothing loaded → offer Load / Create.
+            setTimeout(_editorMaybeShowStartLanding, 80);
         }
     });
     const screen = document.getElementById('plugin-editor');
     if (screen) obs.observe(screen, { attributes: true, attributeFilter: ['class'] });
+    // Also cover the case where the editor screen is already active at init().
+    if (screen && screen.classList.contains('active')) {
+        setTimeout(_editorMaybeShowStartLanding, 120);
+    }
 
     draw();
 }
@@ -8405,9 +9545,10 @@ window.editorDrumsFileSelected = async (input) => {
             const safeName = _editorEscHtml(t.name);
             const checked = i === 0 ? 'checked' : '';
             return `<label class="flex items-center gap-2 text-xs text-gray-300 py-0.5">
-                <input type="radio" name="drums-track" value="${Number.isFinite(Number(t.index)) ? Number(t.index) : 0}" ${checked} class="accent-red-500">
-                <span class="text-red-300">${safeName}</span>
-                <span class="text-gray-600">${Number(t.notes) || 0} notes</span>
+                <input type="radio" name="drums-track" value="${Number.isFinite(Number(t.index)) ? Number(t.index) : 0}" ${checked} class="accent-accent">
+                <span class="text-gray-300 flex-1">${safeName}</span>
+                <span class="px-1.5 py-0.5 rounded text-[10px] font-medium shrink-0" style="background:rgba(245,158,11,0.16);color:#fcd34d">Drums</span>
+                <span class="text-gray-600 shrink-0">${Number(t.notes) || 0} notes</span>
             </label>`;
         }).join('');
         document.getElementById('editor-add-drums-tracks').classList.remove('hidden');
diff --git a/tests/create_gate.test.js b/tests/create_gate.test.js
index a6bf3dd2..ff819121 100644
--- a/tests/create_gate.test.js
+++ b/tests/create_gate.test.js
@@ -1,56 +1,63 @@
 'use strict';
 /*
- * Create-modal gate helper tests for screen.js.
+ * Create-modal gate — the Create button enable logic. The modal is now ONE menu
+ * with no Blank/Guitar Pro/EOF mode toggle: the gate is INPUT-DRIVEN. A picked
+ * Guitar Pro file enables it, then EOF XML arrangement(s); otherwise it's a
+ * from-scratch DRAFT create, which needs only a title (audio + artist optional —
+ * draft-now, audio-later). Brace-extracts the real pure gate from screen.js (a
+ * single browser IIFE) so there's no drift.
  *
  * Run: node tests/create_gate.test.js
  */
 const fs = require('fs');
 const path = require('path');
 const assert = require('assert');
-
 const src = fs.readFileSync(path.join(__dirname, '..', 'screen.js'), 'utf8');
-const m = src.match(/\/\* @pure:create-gate:start \*\/[\s\S]*?\/\* @pure:create-gate:end \*\//);
-if (!m) {
-    console.error('FAIL: @pure:create-gate block not found in screen.js');
-    process.exit(1);
-}
 
-const api = new Function(
-    '"use strict";' + m[0] + '\nreturn { _createGateOpenPure };'
-)();
+function extractFn(name) {
+    const start = src.indexOf('function ' + name + '(');
+    if (start < 0) throw new Error('not found: ' + name);
+    const open = src.indexOf('{', start);
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        if (src[i] === '{') depth++;
+        else if (src[i] === '}') { depth--; if (depth === 0) return src.slice(start, i + 1); }
+    }
+    throw new Error('unbalanced: ' + name);
+}
+const _createGateOpen = new Function(
+    '"use strict";' + extractFn('_createGateOpen') + '\nreturn _createGateOpen;')();
 
-let pass = 0;
-let fail = 0;
+let pass = 0, fail = 0;
 function t(name, fn) {
     try { fn(); pass++; console.log('  ok   ' + name); }
     catch (e) { fail++; console.error('  FAIL ' + name + ': ' + e.message); }
 }
+const inp = (o = {}) => ({ hasTitle: false, hasArtist: false, hasAudio: false, ...o });
 
-t('gp import enables create immediately', () => {
-    assert.strictEqual(api._createGateOpenPure({ gpPath: '/tmp/song.gp5', eofFiles: null }, {
-        hasAudio: false, title: false, artist: false,
-    }), true);
+t('from-scratch: needs a title AND at least one instrument in the roster', () => {
+    assert.strictEqual(_createGateOpen({ roster: ['Lead'] }, inp({ hasTitle: true })), true);
+    assert.strictEqual(_createGateOpen({ roster: ['Lead'] }, inp()), false);                        // no title
+    assert.strictEqual(_createGateOpen({ roster: [] }, inp({ hasTitle: true })), false);            // no instrument
+    assert.strictEqual(_createGateOpen({ roster: ['Vocals'] }, inp({ hasTitle: true })), false);    // Vocals alone
+    assert.strictEqual(_createGateOpen({ roster: ['Vocals', 'Keys'] }, inp({ hasTitle: true })), true);
+    assert.strictEqual(_createGateOpen({ roster: ['Drums'] }, inp({ hasTitle: true })), true);
 });
 
-t('eof import enables create immediately', () => {
-    assert.strictEqual(api._createGateOpenPure({ gpPath: null, eofFiles: [{}] }, {
-        hasAudio: false, title: false, artist: false,
-    }), true);
+t('gp file wins regardless of roster/title', () => {
+    assert.strictEqual(_createGateOpen({ gpPath: '/song.gp', roster: [] }, inp()), true);
+    assert.strictEqual(_createGateOpen({ gpPath: null, roster: [] }, inp({ hasTitle: true })), false);
 });
 
-t('audio-only create requires audio, title, and artist', () => {
-    assert.strictEqual(api._createGateOpenPure({ gpPath: null, eofFiles: null }, {
-        hasAudio: true, title: true, artist: true,
-    }), true);
+t('eof file(s) win regardless of roster/title', () => {
+    assert.strictEqual(_createGateOpen({ eofFiles: [{}], roster: [] }, inp()), true);
+    assert.strictEqual(_createGateOpen({ eofFiles: [], roster: ['Lead'] }, inp({ hasTitle: true })), true); // empty list -> roster+title
+    assert.strictEqual(_createGateOpen({ eofFiles: null, roster: [] }, inp()), false);
 });
 
-t('audio-only create stays disabled when metadata is incomplete', () => {
-    assert.strictEqual(api._createGateOpenPure({ gpPath: null, eofFiles: null }, {
-        hasAudio: true, title: true, artist: false,
-    }), false);
-    assert.strictEqual(api._createGateOpenPure({ gpPath: null, eofFiles: null }, {
-        hasAudio: false, title: true, artist: true,
-    }), false);
+t('defensive: null state / null flags -> disabled', () => {
+    assert.strictEqual(_createGateOpen(null, inp({ hasTitle: true })), false);
+    assert.strictEqual(_createGateOpen({ roster: ['Lead'] }, null), false);
 });
 
 console.log(`\n${pass} passed, ${fail} failed`);
diff --git a/tests/test_arr_to_data.py b/tests/test_arr_to_data.py
index d5907cf7..1a2c9148 100644
--- a/tests/test_arr_to_data.py
+++ b/tests/test_arr_to_data.py
@@ -6,7 +6,12 @@
 """
 from types import SimpleNamespace
 
-from routes import _NOTE_TECH_BOOL_FIELDS, _NOTE_TECH_FIELDS, _arr_to_data
+from routes import (
+    _NOTE_TECH_BOOL_FIELDS,
+    _NOTE_TECH_FIELDS,
+    _arr_to_data,
+    _extended_manifest_meta,
+)
 
 
 def _tech_defaults(**kw):
@@ -41,6 +46,33 @@ def _tech_defaults(**kw):
     return base
 
 
+def test_extended_manifest_meta_normalizes_import_fields():
+    """The GP/EOF import paths run the modal's spec-complete fields through this
+    into exactly the shapes `_write_sloppak_pak` writes, so a chart import keeps
+    the same metadata a blank project does."""
+    out = _extended_manifest_meta({
+        "album_artist": "  Various Artists ",
+        "track": "3", "disc": 2,
+        "genres": "Rock, Metal, Rock",       # string + dup
+        "isrc": "us-abc-24-00001",           # hyphenated / lower
+        "mbid": "ABC-DEF",                   # upper
+        "language": "en",
+        "authors": "me, you, me",            # string + dup
+    })
+    assert out == {
+        "album_artist": "Various Artists",
+        "track": 3, "disc": 2,
+        "genres": ["Rock", "Metal"],
+        "isrc": "USABC2400001",
+        "mbid": "abc-def",
+        "language": "en",
+        "authors": ["me", "you"],
+    }
+    # Lenient: malformed / empty fields are dropped, never an error.
+    assert _extended_manifest_meta({"track": "x", "genres": "", "disc": True}) == {}
+    assert _extended_manifest_meta(None) == {}
+
+
 def _note(**kw):
     base = dict(time=1.23456, string=0, fret=5, sustain=0.5)
     base.update(_tech_defaults())