Full pipeline overhaul: lyrics, poster, meter detection, staged UI

- analyze.py: time-signature estimation (beat-accent grid scoring, 4/4
bias), single-decode fingerprint()
- stems.py: shared in-process HT-Demucs vocal isolation
- transcribe.py: drop torchaudio/torchcodec path and demucs subprocess;
demucs-isolated vocals -> whisper large-v3 long-form (chunked), with a
hallucination filter on the output
- write_lyrics.py: qwen3 thinking mode off, think/scaffold scrubbing,
recommended non-thinking sampling (t=0.7, top_p=0.8, top_k=20)
- poster.py: vinyl-sleeve 1080x1080 poster with two-tone waveform
(original cream / continuation amber), started+finished dates,
key/bpm/meter, "completed by CODA" branding; upload waveform renderer
- app.py: wire the whole pipeline behind one button with a streamed
4-stage progress tracker; mastering+stitch moved off the GPU window;
separate ZeroGPU calls for music (300s) and lyrics (180s); waveform
panel, meter card, lyrics panels, poster output, original-date input;
gradio 6 Image buttons API; flatten group .styler backgrounds
- README: honest scope (instrumental continuation, lyrics as songwriting
aid), model stack table, frontmatter model links, research notes
- test_app_logic.py: 35 offline checks (meter, fingerprint, waveform,
poster, hallucination filter, qwen cleaner, stage tracker)

README.md

@@ -10,16 +10,93 @@ app_file: app.py
 pinned: false
 license: mit
 short_description: Local AI that finishes the songs you quit on.
+models:
+  - facebook/musicgen-large
+  - openai/whisper-large-v3
+  - Qwen/Qwen3-8B
 ---
 
-# CODA
+# CODA — the songs you quit on, finished.
 
-You have an unfinished song. Maybe you ran out of ideas at the bridge, maybe the groove just stops at 0:47. Upload it. CODA listens, figures out what key you're in and where the beat lands, then continues the music from where you stopped — same tempo, same key, same groove. The continuation is instrumental: if your track has vocals, CODA separates them out before prompting (MusicGen can't generate voices — they were stripped from its training data by design) and the band plays on. For the words, Qwen3 drafts lyrics for the new section as a songwriting aid.
+Everyone who's ever made music has one: the song that stops at 0:47. You ran out
+of ideas at the bridge, the voice memo got buried, life happened. CODA takes that
+unfinished clip and continues it into a full song — same tempo, same key, same
+groove — then prints a vinyl-sleeve poster stamped with the date you started it
+and the date it got finished.
 
-Everything runs locally. No audio leaves your machine, no cloud APIs, no subscriptions. The whole stack fits under 13B parameters: MusicGen Large handles the music continuation, Whisper + Demucs pull and transcribe vocals, Qwen3 writes new lyrics that match your style, matchering masters the new audio to match your recording, and librosa does the key/tempo detection without any ML at all.
+*"AI gave me back the song I quit in 2018."*
 
-Upload a WAV, MP3, or FLAC (under 60 seconds). You'll see the detected key, tempo, and duration right away. Hit continue and CODA generates what comes next.
+## How it works
+
+1. **Listen.** librosa detects your key, tempo, and time signature — pure DSP,
+   no ML.
+2. **Separate.** HT-Demucs splits vocals from instrumentals. The instrumental
+   feeds MusicGen (vocal prompts are out-of-distribution for it — its training
+   data was Demucs-separated, so this matches how the model learned); the vocal
+   stem feeds Whisper.
+3. **Continue.** MusicGen Large extends the music from the cutoff point, chained
+   in 12s-context / 18s-new passes inside its trained 30s window. By default
+   there's **no text prompt at all** — classifier-free guidance is off
+   (`guidance_scale=1.0`) and the audio prefix alone steers the generation.
+   Type a description and it switches to text-guided mode at Meta's trained
+   guidance of 3.0.
+4. **Master & stitch.** matchering matches the continuation's loudness and EQ to
+   your recording, then the splice lands inside the codec-aligned overlap with
+   an equal-gain crossfade — no volume bump at the seam, and the track closes
+   with a proper fade-out.
+5. **Write.** Whisper Large v3 transcribes whatever you sang; Qwen3 continues the
+   lyrics in the same voice — your next verse, on paper.
+6. **Press.** A song poster: the full waveform (your part in cream, the
+   continuation in amber), key, BPM, meter, started/finished dates. That's the
+   thing you screenshot.
+
+## The stack — small on purpose
+
+| Model | Size | Job |
+|---|---|---|
+| [MusicGen Large](https://huggingface.co/facebook/musicgen-large) | 3.3B | music continuation, audio-prompted |
+| [Whisper Large v3](https://huggingface.co/openai/whisper-large-v3) | 1.5B | lyric transcription from the vocal stem |
+| [Qwen3 8B](https://huggingface.co/Qwen/Qwen3-8B) | 8.2B | lyric continuation in your style |
+| HT-Demucs | tiny | vocal/instrumental separation, used twice |
+| librosa | 0 params | key, tempo, meter detection |
+
+~13B parameters total — well under the 32B Build Small cap, and every weight
+runs locally. No cloud APIs, no subscriptions, nothing leaves the machine.
+
+## What it won't pretend to do
+
+MusicGen cannot generate vocals — Meta stripped voices from its training data
+twice over, by design. CODA doesn't fake it: the musical continuation is
+instrumental (your original vocals stay untouched up to the seam), and the
+lyric continuation is delivered as **words on the page** — a songwriting aid,
+not a cloned voice. The band plays on; you sing the next verse.
+
+## Using it
+
+Upload a WAV, MP3, or FLAC (a 20–60 second clip works best). You'll see the
+detected key, tempo, and meter plus the waveform immediately. Pick how much new
+music you want (15–120s), optionally describe the sound, optionally tell it when
+you started the song, and hit **Finish this song**. The pipeline streams its
+progress stage by stage; on ZeroGPU the music stage is the long one.
+
+Run it locally:
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Notes for the curious
+
+The continuation settings come out of a deep dive into the transformers MusicGen
+source: `guidance_scale` only amplifies the *text* condition (the audio prompt is
+copied into both CFG branches and cancels out), so cranking "style adherence"
+actually drags generation *away* from your audio and toward stock-music captions.
+Full write-up in [`RESEARCH_music_continuation_2026-06-10.md`](RESEARCH_music_continuation_2026-06-10.md).
+
+Code is MIT. MusicGen weights are CC-BY-NC (non-commercial) — fine here, worth
+knowing if you fork this for production.
 
 ---
 
-Built by Tony Winslow for the Build Small Hackathon 2026. MIT license.
+Built by Tony Winslow — Black Box Analytics — for the Build Small Hackathon 2026.

RESEARCH_music_continuation_2026-06-10.md

@@ -0,0 +1,163 @@
+# CODA Music Continuation — Root-Cause Research & Recommendations
+
+**Date:** 2026-06-10
+**Scope:** Research only — no code changed. Sources: `transformers` source (modeling_musicgen.py, logits_process.py, feature_extraction_encodec.py), MusicGen paper (arXiv 2306.05284), audiocraft repo (model card, musicgen.py, genmodel.py, official demo notebook), facebook/musicgen-large generation_config.json, community issue threads, and June-2026 survey of alternative models.
+
+---
+
+## TL;DR
+
+**The "weird funk pop" output is not a mystery — it's the predictable result of two settings interacting:**
+
+1. **`guidance_scale=7.0` amplifies ONLY the text prompt, never the audio prompt.** Verified in the transformers source: classifier-free guidance duplicates the audio-prompt tokens into *both* the conditional and unconditional branches, so they cancel out of the CFG formula `uncond + scale * (cond - uncond)`. Only the text-encoder states are nulled in the unconditional branch. The "style adherence" slider is therefore a **text-adherence** knob — at 7 it drags generation *away* from what the audio implies and *toward* the text, at more than double Meta's trained value (3.0).
+
+2. **The text prompt is functionally an empty caption, and MusicGen's prior for empty captions IS funk-pop stock music.** Training captions are stock-library metadata ("90s rock song with a guitar riff", genre/BPM/mood tags). A meta-instruction like *"continuation of the same song, identical instruments, identical timbre, same production and mixing, professional studio recording"* describes a *relationship to other audio*, which never appears in training captions — T5 embeds it as near-noise. The training corpus is overwhelmingly ShutterStock/Pond5 production-library music, so a vague caption regresses to generic Western stock instrumental. The per-pass section hints ("chorus, fuller arrangement, more energy") push the same direction.
+
+So the current code cranks a 7× amplifier on a caption that means "generic stock music." That is precisely "weird funk pop bullshit."
+
+**Also fundamental:** MusicGen **cannot continue vocals, ever.** Vocals were stripped from its training data twice (tag filtering, then HT-Demucs separation — stated verbatim in Meta's model card: "Vocals have been removed from the data source… The model is not able to generate realistic vocals"). The README's promise ("Vocals, instruments, lyrics — it picks up all of it") is not deliverable with MusicGen as the backbone.
+
+---
+
+## 1. Is MusicGen capable of what we want?
+
+**Partially. Set expectations correctly:**
+
+| Goal | Achievable? |
+|---|---|
+| Continue tempo, key, groove, rough genre | **Yes** — this is what the autoregressive token prefix carries |
+| Same instrumentation, broadly ("a rock band stays a rock band") | **Mostly**, with correct settings (below) |
+| *Identical* timbre/production ("same recording, same take") | **No.** Hard ceiling: everything passes through EnCodec at 2.2 kbps (4 codebooks × 11 bits × 50 Hz), 32 kHz mono. Real guitar/drums come back with smeared cymbals, softened transients, and the "AI sheen" before the LM even contributes |
+| Continue vocals | **Never.** Vocal-free training data, by design |
+
+Continuation was never a trained or paper-evaluated task — it's an emergent property of the autoregressive LM that audiocraft exposes as `generate_continuation()`. Meta's own demos prompt with only **0.5–2 seconds** of audio. The paper's limitations section concedes: "Our simple generation method does not allow us to have fine-grained control over adherence of the generation to the conditioning."
+
+**Verdict:** with the fixes below, MusicGen-large can deliver "plausibly the same band keeps playing" for *instrumental* material. It cannot deliver "the same song with the same instruments" to a discerning ear, and it cannot touch vocals.
+
+---
+
+## 2. How audio conditioning actually works (verified in transformers source)
+
+Trace through `MusicgenForConditionalGeneration.generate()` (modeling_musicgen.py):
+
+1. `input_values` (the waveform from the processor) → `_prepare_audio_encoder_kwargs_for_generation()` → `audio_encoder.encode()` → EnCodec RVQ codes → reshaped into `decoder_input_ids` (lines ~1744–1818). The audio prompt becomes a **frozen decoder token prefix** via `build_delay_pattern_mask`; generation only fills the empty slots after it.
+2. **The output of `generate()` includes the prompt**, re-decoded through EnCodec (lossy). There is no slicing of the prefix. The current CODA code already accounts for this correctly (crossfading inside the overlap region) — keep that.
+3. **CFG mechanics — the smoking gun.** `_prepare_text_encoder_kwargs_for_generation` (lines ~1732–1738): the unconditional branch is built by concatenating `torch.zeros_like(last_hidden_state)` — *text states only*. `prepare_inputs_for_generation` (lines ~1626–1631): `decoder_input_ids = decoder_input_ids.repeat((2, 1))` — *audio prompt copied into both branches*. `ClassifierFreeGuidanceLogitsProcessor`: `scores = uncond + (cond - uncond) * guidance_scale`. Since the audio prefix conditions both branches identically, **`guidance_scale` is purely a text knob. There is no knob in this implementation that increases audio-prompt fidelity.** Faithfulness to the audio comes from the prefix alone, and is *diluted* by strong text guidance.
+4. **Defaults from facebook/musicgen-large `generation_config.json`:** `guidance_scale: 3.0`, `max_length: 1500` (= 30.0 s at 50 tokens/s), `do_sample: true`.
+5. **Window math:** total sequence = prompt tokens + `max_new_tokens`. Nothing enforces the 1500-token (30 s) trained window when `max_new_tokens` is set — sinusoidal positional embeddings silently extrapolate with degraded output past it. Current CODA math (20 s prompt + 10 s new = exactly 1500) sits at the edge; correct, no headroom.
+6. **Resampling:** the EnCodec feature extractor does **no resampling**; it hard-errors if `sampling_rate != 32000` is passed (good — CODA passes it) and silently produces pitch-shifted garbage if omitted. CODA's librosa resample-to-32k + `sampling_rate=MUSICGEN_SR` is correct.
+7. **Shapes/padding:** mono 1-D float32 is the canonical input (a `(1, N)` array raises). `padding=True` with a single clip adds zero padding — safe. (Batching unequal-length prompts would inject silence tokens into the conditioning — avoid, but CODA doesn't batch.)
+8. **fp32:** correct and necessary. The precision-sensitive part is EnCodec encode/decode and the T5 conditioning; community/literature confirm fp16 there produces the degraded "bitcrushed" output — this was the 8-bit failure mode, and the current fp32 fix is right. (LM-only bf16 would be a safe future speed optimization; full-fp16 is not.)
+
+---
+
+## 3. What's wrong with the current `continue_music.py` — specifically
+
+| # | Problem | Where | Severity |
+|---|---|---|---|
+| 1 | `guidance_scale=7.0` default — 2.3× Meta's trained value, amplifies text only, actively fights audio fidelity, and degrades audio quality (documented HF caveat) | `continue_track()` signature; `app.py` slider (min 3 / default 7 / max 10) | **Critical — primary cause of "funk pop"** |
+| 2 | Meta-instruction text prompt ("identical instruments, identical timbre…") is out-of-distribution → behaves as a vague caption → stock-music prior | `base` string in `continue_track()` | **Critical — the other half of the same bug** |
+| 3 | Per-pass section hints ("chorus, fuller arrangement, more energy", "big chorus, peak energy") are genre-generic captions injected at guidance 7 — each chained pass gets pulled further toward stock pop | `SECTION_ARC` / `_section_plan()` | **High** |
+| 4 | The "style adherence" slider label is inverted from reality: raising it makes output *more generic*, not more faithful | `app.py` | High (UX/diagnosis trap) |
+| 5 | 6 chained passes for 60 s (10 s new per pass) — each pass re-encodes generated audio and re-rolls the dice; drift compounds per pass. audiocraft's own extend loop uses `extend_stride=18` (12 s context, 18 s new) = ~3 passes for 60 s | `per_pass` math in `continue_track()` | Medium |
+| 6 | Vocal input goes straight into the prompt. MusicGen has never seen a voice; it will drop, garble, or replace it | `_load_tail()` / pipeline design | **Critical for any vocal demo** |
+| 7 | No timbre/EQ post-matching — generated 32 kHz-band-limited mono is spliced against a 44.1 kHz master with only an RMS gain match, so even a good continuation reads as "different record" | `stitch_with_crossfade()` | Medium |
+
+What's already **correct** (don't touch): fp32 + TF32, librosa resample to 32 kHz with `sampling_rate=` passed, mono 1-D float32 input, crossfade inside the codec-roundtripped overlap, equal-gain seam for correlated material, resampling generated audio *up* to the original's rate, window math 20 s + 10 s = 1500 tokens.
+
+---
+
+## 4. The fix — exact changes
+
+### Fix 1 (do first): guidance + text — `continue_music.py`
+
+**Two supported modes; implement (a) as default, (b) as the option:**
+
+**(a) Pure continuation — no text, no CFG.** This is the canonical mode: Meta's MusicGen-Style page describes continuation as "given the conditioning, MusicGen continues it **without any textual description**", and audiocraft's `generate_continuation(descriptions=None)` is the reference implementation. Training used 20% condition dropout, so unconditional is in-distribution.
+
+```python
+# default path: audio prompt only
+inputs = processor(
+    audio=prompt_audio,
+    sampling_rate=MUSICGEN_SR,
+    return_tensors="pt",
+).to(model.device)
+# merge in null text conditioning so the seq2seq generate path is well-formed
+uncond = model.get_unconditional_inputs(num_samples=1)
+output = model.generate(
+    **inputs,
+    encoder_outputs=None,  # see note below
+    do_sample=True,
+    guidance_scale=1.0,    # CFG off — nothing for it to amplify anyway
+    temperature=1.0,
+    top_k=250,             # audiocraft defaults
+    max_new_tokens=max_new_tokens,
+)
+```
+(Implementation note: the clean way in transformers is `model.generate(input_values=inputs.input_values, padding_mask=inputs.padding_mask, **vars-from-get_unconditional_inputs-minus-duplicates, guidance_scale=1.0, ...)` — or simply keep passing `text=[""]` through the processor with `guidance_scale=1.0`, which is equivalent in effect since CFG is off. Verify both on a test clip; keep whichever is stable on the installed transformers version. **Pin transformers < 4.57** if you ever touch the melody variant — melody conditioning silently broke after 4.48, GitHub issue #45647.)
+
+**(b) Described continuation — user-supplied caption, guidance 3.0.** If the user types a real description ("garage rock, distorted electric guitar, live drums, male vocals removed, 120 bpm, E minor"), that caption is in-distribution and CFG at Meta's trained value 3.0 helps hold the genre. Auto-append detected key/BPM as now. **Never auto-generate meta-instructions.**
+
+- Change `continue_track()` default `guidance_scale=7.0` → `1.0`; treat >1 as only valid when a user caption exists.
+- Delete the `base` meta-instruction string.
+- **Delete `SECTION_ARC` and `_section_plan()`** (or reduce to a single final-pass "outro, song ending" hint *only* in described mode). The audio chaining carries continuity; the hints only inject stock-pop pull.
+
+### Fix 2: UI — `app.py`
+
+- Replace the "style adherence" slider (currently min 3, so even its minimum is text-amplifying) with:
+  - a free-text **"describe your song (optional)"** box → mode (b) when filled, mode (a) when empty;
+  - if a guidance slider is kept at all: range 1.0–5.0, default 1.0 (no text) / 3.0 (with text), labeled **"text influence"**.
+
+### Fix 3: vocals — Demucs gate (Demucs is already in requirements.txt)
+
+Before building the prompt: run HT-Demucs on the tail, measure vocal-stem energy. If vocals are present:
+1. Continue **the instrumental mix only** (this matches how the training data itself was prepared — HT-Demucs-separated instrumentals are exactly in-distribution).
+2. Keep the user's original (with vocals) untouched up to the seam; the continuation is instrumental.
+3. Update the README honestly: lyrics from Qwen3 are a *songwriting aid* deliverable, not synthesized vocals. (No open model on a ZeroGPU budget will clone-and-continue the user's voice well — YuE-extend is the closest and it's slow and finicky.)
+
+### Fix 4: chaining — match audiocraft's reference loop
+
+Keep first-pass prompt at 15–20 s (community sweet spot for fidelity). For subsequent passes use **12 s of context / 18 s new** (audiocraft's `extend_stride=18` default): 60 s of new audio in 3 passes instead of 6 — half the drift opportunities, half the GPU time. Keep total tokens ≤ 1500 per pass.
+
+### Fix 5: post-match the seam — matchering
+
+Add [`matchering`](https://github.com/sergree/matchering) (pure-Python, lightweight): REFERENCE = the original clip, TARGET = the generated continuation, before `stitch_with_crossfade()`. It matches RMS, spectral envelope, and peak — this is the single cheapest improvement to "sounds like the same record," and it's exactly what an audio engineer would do at a session splice: match the master, then crossfade on a musical boundary. (Optional polish: use the detected BPM to snap the seam to a downbeat.) Note it cannot invent content above 16 kHz — the 32 kHz EnCodec ceiling stands.
+
+### Expected outcome after Fixes 1–5
+
+Tempo/key/groove continuity, broadly matching instrumentation, no genre teleport, production glued by EQ-match. Still mono-derived, still slightly "AI-sheened," still instrumental-only. That is MusicGen's ceiling.
+
+---
+
+## 5. If the ceiling isn't good enough: the 2026 alternatives
+
+Ranked for CODA's use case (faithful extension of arbitrary user audio, single ZeroGPU slice):
+
+1. **ACE-Step 1.5** (Jan 2026; Apache/MIT-style, 8–16 GB VRAM) — the only open model where "**extend** my actual audio, keep timbre" is a designed first-class feature (`extend`, `repaint`, `audio_cover_strength`), **with vocal support in 50+ languages**. Best single-model replacement candidate; chain repaints for arbitrary length. Caveat: limited independent benchmarking yet.
+2. **Stable Audio 3 Medium** (May 2026; 1.4B, ~6 GB, Stability Community License) — documented causal continuation/inpainting mode, 44.1 kHz **stereo** (fixes the mono+bandwidth ceiling). Unproven on vocals. Worth an A/B against ACE-Step on instrumental material.
+3. **YuE-extend** — true continuation with voice cloning from separated stems; best vocal continuity in open weights, but slow (minutes/song) and ≤30 s prompt practical limit.
+4. **MusicGen-Style** (facebook/musicgen-style) — conditions on a 1.5–4.5 s excerpt for timbre/style match; combining it with a continuation prefix is theoretically possible in audiocraft but undocumented/unvalidated. Research-grade only.
+5. **Per-stem MusicGen continuation: don't.** Isolated stems are out-of-distribution for MusicGen (literature: models "produce nonsensical outputs when fed isolated vocals" — SingSong); only stem-native models (MusicGen-Stem, StemGen) do this, and their weights are research releases.
+
+**License flag:** MusicGen weights are **CC-BY-NC** (non-commercial). Fine for the hackathon; a problem if CODA ever ships commercially. ACE-Step and Stable Audio 3 (under $1M revenue) are both more permissive.
+
+**Recommended path:** ship the hackathon on MusicGen with Fixes 1–5 (small, low-risk diffs), and prototype ACE-Step 1.5 `extend` as CODA v2's backbone — it is designed to do exactly what CODA promises, including vocals.
+
+---
+
+## 6. Failure modes — explained
+
+| Symptom | Cause | Status |
+|---|---|---|
+| 8-bit / chiptune output | fp16 EnCodec/T5 path (precision-sensitive); confirmed pattern in community + literature (TinyMusician keeps EnCodec fp32 for this reason) | **Fixed** by the fp32 change — keep it |
+| Random new instruments | Text guidance pulling toward caption prior + per-pass re-rolls in 6-pass chaining | Fixes 1, 4 |
+| Generic MusicGen-default sound | Vague/meta caption → stock-library prior (training data literally is stock music) | Fixes 1, 2 |
+| "Weird funk pop" | guidance 7 × meaningless caption × "more energy" section hints = maximum pull toward the stock-pop prior | Fixes 1, 2 (delete SECTION_ARC) |
+| ~14 s output | Deployment issue, already fixed | — |
+| Vocals garbled/vanish | Vocal-free training data — model-level impossibility | Fix 3 (Demucs gate) |
+
+---
+
+## 7. What a professional audio engineer would say
+
+A session engineer asked to "extend this demo" would: comp from the same takes, or re-amp/re-track matching the original chain, then **match the master** (EQ/loudness/width to the reference) and **edit on the grid** (splice at a downbeat, short crossfade). The transferable lessons for CODA: (1) never expect a different "performer" (the model) to nail the take — minimize how much it has to invent (longer audio context, no contradicting text); (2) the *master-matching* step is half of what makes a splice invisible — that's the matchering pass; (3) cut on musical boundaries — use the BPM grid CODA already detects to place the seam on a downbeat; (4) when a part can't be reproduced (vocals), you don't fake it — you arrange around it (instrumental continuation).

analyze.py

@@ -1,6 +1,7 @@
+"""key / tempo / meter detection. pure librosa dsp — no ML."""
 import librosa
 import numpy as np
-
+import soundfile as sf
 
 # krumhansl-schmuckler key profiles
 # major and minor correlation vectors for pitch class distribution
@@ -13,12 +14,12 @@ MINOR_PROFILE = np.array([6.33, 2.68, 3.52, 5.38, 2.60, 3.53,
 PITCH_CLASSES = ['C', 'C#', 'D', 'D#', 'E', 'F',
                  'F#', 'G', 'G#', 'A', 'A#', 'B']
 
+# all the analysis here works on envelopes and chroma; 22k mono is plenty
+ANALYSIS_SR = 22050
 
-def find_key(path):
-    """chroma-based key detection using krumhansl-schmuckler profiles"""
-    track, sr = librosa.load(path, sr=None)
 
-    # pull chroma energy, average across time
+def _key_from_audio(track, sr):
+    """chroma-based key detection using krumhansl-schmuckler profiles"""
     chroma = librosa.feature.chroma_cqt(y=track, sr=sr)
     pitch_dist = np.mean(chroma, axis=1)
 
@@ -48,40 +49,83 @@ def find_key(path):
     return best_key
 
 
-def get_tempo(path):
-    track, sr = librosa.load(path, sr=None)
-    tempo, _ = librosa.beat.beat_track(y=track, sr=sr)
+def _scalar_tempo(tempo):
     # librosa sometimes returns an array
     if hasattr(tempo, '__len__'):
         return float(tempo[0])
     return float(tempo)
 
 
+def _time_signature_from_beats(onset_env, beats):
+    """
+    estimate the meter from where the accents land: take the onset strength
+    at each tracked beat and score how well a "downbeat every N beats" grid
+    lines up with the loud ones, for N = 3 and 4. waltz time has to win
+    clearly — ambiguous material is called 4/4, like most music.
+    """
+    if len(beats) < 12:
+        return "4/4"
+
+    strengths = onset_env[beats].astype(float)
+    spread = strengths.std()
+    if spread < 1e-8:
+        return "4/4"
+    strengths = (strengths - strengths.mean()) / spread
+
+    def accent_score(meter):
+        # best phase alignment of the downbeat grid
+        return max(float(np.mean(strengths[offset::meter]))
+                   for offset in range(meter))
+
+    three, four = accent_score(3), accent_score(4)
+    if three > 0 and three > four * 1.25:
+        return "3/4"
+    return "4/4"
+
+
+def find_key(path):
+    track, sr = librosa.load(path, sr=ANALYSIS_SR, mono=True)
+    return _key_from_audio(track, sr)
+
+
+def get_tempo(path):
+    track, sr = librosa.load(path, sr=ANALYSIS_SR, mono=True)
+    tempo, _ = librosa.beat.beat_track(y=track, sr=sr)
+    return _scalar_tempo(tempo)
+
+
+def get_time_signature(path):
+    track, sr = librosa.load(path, sr=ANALYSIS_SR, mono=True)
+    onset_env = librosa.onset.onset_strength(y=track, sr=sr)
+    _, beats = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr)
+    return _time_signature_from_beats(onset_env, beats)
+
+
 def get_duration(path):
     return librosa.get_duration(path=path)
 
 
 def fingerprint(path):
-    track, sr = librosa.load(path, sr=None, mono=False)
-
-    channels = 1 if track.ndim == 1 else track.shape[0]
+    """one-stop analysis: key, bpm, meter, duration — single decode pass."""
+    track, sr = librosa.load(path, sr=ANALYSIS_SR, mono=True)
 
-    # reload mono for analysis
-    if channels > 1:
-        mono = librosa.to_mono(track)
-    else:
-        mono = track
+    onset_env = librosa.onset.onset_strength(y=track, sr=sr)
+    tempo, beats = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr)
 
-    key_sig = find_key(path)
-    bpm = get_tempo(path)
-    length = librosa.get_duration(y=mono, sr=sr)
+    # source-file metadata without a second full decode
+    try:
+        meta = sf.info(path)
+        native_sr, channels = meta.samplerate, meta.channels
+    except Exception:
+        native_sr, channels = sr, 1
 
     return {
-        'key': key_sig,
-        'bpm': round(bpm, 1),
-        'duration': round(length, 2),
-        'sample_rate': sr,
-        'channels': channels
+        'key': _key_from_audio(track, sr),
+        'bpm': round(_scalar_tempo(tempo), 1),
+        'time_signature': _time_signature_from_beats(onset_env, beats),
+        'duration': round(len(track) / sr, 2),
+        'sample_rate': native_sr,
+        'channels': channels,
     }
 
 
@@ -94,6 +138,7 @@ if __name__ == '__main__':
     info = fingerprint(sys.argv[1])
     print(f"key: {info['key']}")
     print(f"bpm: {info['bpm']}")
+    print(f"time signature: {info['time_signature']} (estimated)")
     print(f"duration: {info['duration']}s")
     print(f"sample rate: {info['sample_rate']}Hz")
     print(f"channels: {info['channels']}")

app.py

@@ -1,9 +1,12 @@
-import gradio as gr
 import os
 import tempfile
-import numpy as np
+from pathlib import Path
+
+import gradio as gr
 import soundfile as sf
-from analyze import fingerprint, find_key, get_tempo, get_duration
+
+from analyze import fingerprint
+from poster import make_poster, render_waveform_png
 
 try:
     import spaces
@@ -69,6 +72,14 @@ html, body, gradio-app, .gradio-container {
 }
 
 /* ---- panels ---- */
+/* gradio 6 wraps group children in a .styler div with a zinc background;
+   flatten it (and row blocks / forms) so the panel surface reads as one */
+.gradio-container .styler,
+.gradio-container .row .block,
+.gradio-container .form {
+    background: transparent !important;
+    border: none !important;
+}
 .upload-panel, .results-panel, .continue-panel {
     background: var(--coda-surface) !important;
     border: 1px solid var(--coda-border) !important;
@@ -136,6 +147,59 @@ html, body, gradio-app, .gradio-container {
     line-height: 1.1 !important;
 }
 
+/* ---- waveform & poster images ---- */
+.waveform-img { margin-top: 14px; }
+.waveform-img img { border-radius: 12px; width: 100%; }
+.poster-img img { border-radius: 12px; }
+.gradio-container .image-container {
+    background: var(--coda-surface-2) !important;
+    border-color: var(--coda-border) !important;
+}
+
+/* ---- stage tracker ---- */
+.stage-list {
+    display: flex;
+    flex-direction: column;
+    gap: 9px;
+    padding: 14px 4px 4px 4px;
+}
+.stage {
+    display: flex;
+    align-items: center;
+    gap: 11px;
+    color: var(--coda-muted) !important;
+    font-size: 0.88em;
+    letter-spacing: 0.01em;
+}
+.stage span { color: inherit !important; }
+.stage .dot {
+    width: 9px; height: 9px;
+    border-radius: 50%;
+    background: #3a4150;
+    flex: none;
+    transition: background 0.2s ease;
+}
+.stage.active { color: var(--coda-text) !important; }
+.stage.active .dot {
+    background: var(--coda-accent);
+    animation: coda-pulse 1.2s ease-in-out infinite;
+}
+.stage.done .dot { background: var(--coda-accent); }
+.stage.skip { opacity: 0.55; }
+.stage.error { color: #e07a6a !important; }
+.stage.error .dot { background: #e07a6a; }
+@keyframes coda-pulse {
+    0%, 100% { box-shadow: 0 0 0 0 rgba(226,168,92,0.45); }
+    50% { box-shadow: 0 0 0 6px rgba(226,168,92,0); }
+}
+.stage-note {
+    color: var(--coda-muted) !important;
+    font-size: 0.8em;
+    padding: 10px 4px 0 4px;
+    line-height: 1.5;
+}
+.stage-note span { color: inherit !important; }
+
 /* ---- buttons ---- */
 .gradio-container button.primary {
     background: var(--coda-accent) !important;
@@ -221,26 +285,26 @@ def make_stat_html(label, value):
     )
 
 
-def analyze_track(audio):
-    if audio is None:
-        return (
-            make_stat_html("key", "---"),
-            make_stat_html("tempo", "---"),
-            make_stat_html("duration", "---"),
-            gr.update(visible=False),
-            None,
-            None
-        )
+PIPELINE_STAGES = (
+    "separate & continue the music",
+    "master & stitch the seam",
+    "transcribe & extend the lyrics",
+    "press the poster",
+)
 
-    try:
-        info = fingerprint(audio)
-        key_html = make_stat_html("key", info["key"])
-        bpm_html = make_stat_html("tempo", str(info["bpm"]) + " bpm")
-        dur_html = make_stat_html("duration", str(info["duration"]) + "s")
-        return (key_html, bpm_html, dur_html, gr.update(visible=True), audio, info)
-    except Exception as e:
-        err = make_stat_html("error", str(e)[:50])
-        return (err, make_stat_html("tempo", "---"), make_stat_html("duration", "---"), gr.update(visible=False), None, None)
+
+def stages_html(states, note="", labels=None):
+    """render the pipeline progress tracker. states are per-stage:
+    pending | active | done | skip | error."""
+    labels = labels or PIPELINE_STAGES
+    rows = []
+    for label, state in zip(labels, states):
+        rows.append(
+            f'<div class="stage {state}"><span class="dot"></span>'
+            f'<span>{label}</span></div>'
+        )
+    note_html = f'<div class="stage-note">{note}</div>' if note else ""
+    return f'<div class="stage-list">{"".join(rows)}</div>{note_html}'
 
 
 def _output_subtype(audio_path):
@@ -258,59 +322,195 @@ def _output_subtype(audio_path):
 
 
 @spaces.GPU(duration=300)
-def run_continuation(audio_path, info, gen_seconds, fade_seconds, caption):
-    if not audio_path:
-        return None, "upload a track first."
+def generate_continuation(audio_path, key, bpm, gen_seconds, fade_seconds, caption):
+    """gpu stage 1: demucs vocal gate + chained musicgen passes.
+    mastering and stitching are pure cpu work and run outside the gpu window.
+    no caption = pure audio continuation (CFG off at guidance 1.0); a user
+    caption switches to described mode at meta's trained guidance 3.0."""
+    # lazy import so the UI boots fast and torch only loads on demand
+    from continue_music import continue_track
+    return continue_track(
+        audio_path,
+        gen_duration=float(gen_seconds),
+        key=key,
+        bpm=bpm,
+        fade_seconds=float(fade_seconds),
+        caption=caption or "",
+    )
 
-    try:
-        # lazy import so the UI boots fast and torch only loads on demand
-        import librosa
-        from continue_music import (continue_track, master_match,
-                                    stitch_with_crossfade)
-
-        key = info.get("key") if info else None
-        bpm = info.get("bpm") if info else None
-
-        # generate at musicgen's native 32kHz, chaining passes for long
-        # extensions. no caption = pure audio continuation (CFG off); a user
-        # caption switches to described mode at guidance 3.0.
-        extended_tail, prompt_samples, gen_sr = continue_track(
-            audio_path,
-            gen_duration=float(gen_seconds),
-            key=key,
-            bpm=bpm,
-            fade_seconds=float(fade_seconds),
-            caption=caption or "",
-        )
 
-        # keep the original at its native sample rate and channel count —
-        # the generated audio gets resampled up to match, never the reverse
-        original, orig_sr = librosa.load(audio_path, sr=None, mono=False)
+@spaces.GPU(duration=180)
+def generate_lyrics(audio_path, key, bpm):
+    """gpu stage 2: whisper transcribes the demucs-isolated vocals, qwen3
+    writes the next lines. returns (original, continuation) or (None, None)
+    when the clip is instrumental."""
+    from transcribe import transcribe_vocals
+    original = transcribe_vocals(audio_path)
+    if not original:
+        return None, None
+    from write_lyrics import continue_lyrics
+    return original, continue_lyrics(original, key=key, bpm=bpm)
+
+
+def master_and_stitch(audio_path, extended_tail, prompt_samples, fade_seconds):
+    """cpu stage: matchering mastering pass + native-rate splice + file write."""
+    import librosa
+    from continue_music import master_match, stitch_with_crossfade
+
+    # keep the original at its native sample rate and channel count —
+    # the generated audio gets resampled up to match, never the reverse
+    original, orig_sr = librosa.load(audio_path, sr=None, mono=False)
+
+    # mastering pass: match the generation's loudness and eq to the
+    # original before splicing so both halves read as the same record
+    extended_tail = master_match(extended_tail, original, orig_sr)
+
+    full = stitch_with_crossfade(
+        original, extended_tail, prompt_samples, orig_sr,
+        fade_seconds=float(fade_seconds),
+    )
+
+    out_path = os.path.join(tempfile.mkdtemp(), "coda_continuation.wav")
+    # soundfile expects (samples, channels)
+    sf.write(out_path, full.T if full.ndim == 2 else full, orig_sr,
+             subtype=_output_subtype(audio_path))
+
+    added = (full.shape[-1] - original.shape[-1]) / orig_sr
+    msg = (
+        f"added {added:.1f}s of new audio at {orig_sr} hz "
+        f"({_output_subtype(audio_path).replace('_', ' ').lower()}). "
+        f"blend completes at {original.shape[-1] / orig_sr:.1f}s, "
+        f"outro fades to silence."
+    )
+    return out_path, msg
+
 
-        # mastering pass: match the generation's loudness and eq to the
-        # original before splicing so both halves read as the same record
-        extended_tail = master_match(extended_tail, original, orig_sr)
+def analyze_track(audio):
+    hide = gr.update(visible=False)
+    blank = (
+        make_stat_html("key", "---"),
+        make_stat_html("tempo", "---"),
+        make_stat_html("meter", "---"),
+        make_stat_html("length", "---"),
+        hide,        # waveform
+        hide,        # continue section
+        None, None,  # states
+        gr.update(value="", visible=False),  # status tracker
+        hide, hide, hide,  # result audio / lyrics / poster panels
+    )
+    if audio is None:
+        return blank
 
-        full = stitch_with_crossfade(
-            original, extended_tail, prompt_samples, orig_sr,
-            fade_seconds=float(fade_seconds),
+    try:
+        info = fingerprint(audio)
+        wave_png = render_waveform_png(audio)
+        return (
+            make_stat_html("key", info["key"]),
+            make_stat_html("tempo", str(info["bpm"]) + " bpm"),
+            make_stat_html("meter", info["time_signature"]),
+            make_stat_html("length", str(info["duration"]) + "s"),
+            gr.update(value=wave_png, visible=True),
+            gr.update(visible=True),
+            audio, info,
+            gr.update(value="", visible=False),
+            hide, hide, hide,
         )
+    except Exception as e:
+        out = list(blank)
+        out[0] = make_stat_html("error", str(e)[:50])
+        return tuple(out)
+
+
+def run_pipeline(audio_path, info, gen_seconds, fade_seconds, caption,
+                 original_date):
+    """generator: walks the four pipeline stages, streaming tracker updates
+    and revealing each result as it lands. outputs:
+    (status, audio_panel, audio, lyrics_panel, lyrics_orig, lyrics_cont,
+     poster_panel, poster)"""
+    skip = gr.skip()
+
+    def frame(states, note="", labels=None, audio_vis=skip, audio=skip,
+              lyrics_vis=skip, lyr_o=skip, lyr_c=skip, poster_vis=skip,
+              poster=skip):
+        return (gr.update(value=stages_html(states, note, labels), visible=True),
+                audio_vis, audio, lyrics_vis, lyr_o, lyr_c, poster_vis, poster)
+
+    states = ["pending"] * len(PIPELINE_STAGES)
+    labels = list(PIPELINE_STAGES)
+
+    if not audio_path or not info:
+        states[0] = "error"
+        yield frame(states, "upload a track first.")
+        return
+
+    states[0] = "active"
+    yield frame(states,
+                "musicgen large is listening to your track and continuing it "
+                "— this is the long stage.",
+                audio_vis=gr.update(visible=False),
+                lyrics_vis=gr.update(visible=False),
+                poster_vis=gr.update(visible=False))
+
+    try:
+        extended_tail, prompt_samples, _ = generate_continuation(
+            audio_path, info.get("key"), info.get("bpm"),
+            gen_seconds, fade_seconds, caption)
+        states[0] = "done"
+        states[1] = "active"
+        yield frame(states, "matching loudness and eq to your recording, "
+                            "then splicing at the seam.")
+        out_path, stitch_msg = master_and_stitch(
+            audio_path, extended_tail, prompt_samples, fade_seconds)
+        states[1] = "done"
+    except Exception as e:
+        states[states.index("active")] = "error"
+        yield frame(states, f"continuation failed: {str(e)[:200]}")
+        return
 
-        out_path = os.path.join(tempfile.mkdtemp(), "coda_continuation.wav")
-        # soundfile expects (samples, channels)
-        sf.write(out_path, full.T if full.ndim == 2 else full, orig_sr,
-                 subtype=_output_subtype(audio_path))
-
-        added = (full.shape[-1] - original.shape[-1]) / orig_sr
-        seam_at = original.shape[-1] / orig_sr - float(fade_seconds)
-        return out_path, (
-            f"added {added:.1f}s of new audio at {orig_sr} hz "
-            f"({_output_subtype(audio_path).replace('_', ' ').lower()}). "
-            f"one unified track: blend completes at {seam_at + float(fade_seconds):.1f}s, "
-            f"outro fades to silence."
+    states[2] = "active"
+    yield frame(states, stitch_msg,
+                audio_vis=gr.update(visible=True),
+                audio=gr.update(value=out_path))
+
+    lyr_o = lyr_c = None
+    try:
+        lyr_o, lyr_c = generate_lyrics(
+            audio_path, info.get("key"), info.get("bpm"))
+    except Exception as e:
+        print(f"[coda] lyric stage failed: {e}", flush=True)
+
+    if lyr_o:
+        states[2] = "done"
+        yield frame(states, stitch_msg,
+                    lyrics_vis=gr.update(visible=True),
+                    lyr_o=lyr_o, lyr_c=lyr_c or "")
+    else:
+        states[2] = "skip"
+        labels[2] = "transcribe & extend the lyrics — no vocals found, skipped"
+        yield frame(states, stitch_msg, labels=labels)
+
+    states[3] = "active"
+    yield frame(states, stitch_msg, labels=labels)
+    try:
+        title = Path(audio_path).stem.replace("_", " ").replace("-", " ").strip()
+        poster_path = make_poster(
+            out_path,
+            title=title or "untitled",
+            key_sig=info.get("key", "?"),
+            bpm=info.get("bpm", 0) or 0,
+            time_sig=info.get("time_signature", "4/4"),
+            split_seconds=float(info.get("duration", 0) or 0),
+            original_date=original_date or "",
         )
+        states[3] = "done"
+        yield frame(states,
+                    "done. your song is finished — save the poster.",
+                    labels=labels,
+                    poster_vis=gr.update(visible=True),
+                    poster=gr.update(value=poster_path))
     except Exception as e:
-        return None, f"continuation failed: {str(e)[:200]}"
+        states[3] = "error"
+        yield frame(states, f"poster failed: {str(e)[:160]}", labels=labels)
 
 
 HEADER_HTML = (
@@ -349,7 +549,12 @@ with gr.Blocks(title="CODA") as app:
         with gr.Row():
             key_display = gr.HTML(make_stat_html("key", "---"))
             bpm_display = gr.HTML(make_stat_html("tempo", "---"))
-            dur_display = gr.HTML(make_stat_html("duration", "---"))
+            sig_display = gr.HTML(make_stat_html("meter", "---"))
+            dur_display = gr.HTML(make_stat_html("length", "---"))
+        waveform_display = gr.Image(
+            visible=False, show_label=False, container=False,
+            interactive=False, buttons=[], elem_classes="waveform-img",
+        )
 
     with gr.Group(elem_classes="continue-panel", visible=False) as continue_section:
         gr.HTML('<div class="section-label">Continue</div>')
@@ -369,20 +574,49 @@ with gr.Blocks(title="CODA") as app:
             placeholder="leave empty to continue from the audio alone — or e.g. \"garage rock, distorted electric guitar, live drums\"",
             lines=1,
         )
-        continue_btn = gr.Button("Continue this track", variant="primary")
-        result_audio = gr.Audio(label="finished track", type="filepath", interactive=False)
-        continue_output = gr.Textbox(label="status", interactive=False, lines=2)
+        date_box = gr.Textbox(
+            label="when did you start this song? (optional)",
+            placeholder="e.g. \"2018\" or \"march 2019\" — printed on the poster",
+            lines=1,
+        )
+        continue_btn = gr.Button("Finish this song", variant="primary")
+        status_html = gr.HTML(visible=False)
+
+    with gr.Group(elem_classes="results-panel", visible=False) as result_section:
+        gr.HTML('<div class="section-label">The finished song</div>')
+        result_audio = gr.Audio(label="finished track", type="filepath",
+                                interactive=False)
+
+    with gr.Group(elem_classes="results-panel", visible=False) as lyrics_section:
+        gr.HTML('<div class="section-label">Lyrics</div>')
+        with gr.Row():
+            lyrics_orig = gr.Textbox(label="what you had", lines=8,
+                                     interactive=False)
+            lyrics_cont = gr.Textbox(label="where it goes next", lines=8,
+                                     interactive=False)
+
+    with gr.Group(elem_classes="results-panel", visible=False) as poster_section:
+        gr.HTML('<div class="section-label">Song poster</div>')
+        poster_img = gr.Image(label="poster", type="filepath",
+                              interactive=False, show_label=False,
+                              buttons=["download", "fullscreen"],
+                              elem_classes="poster-img")
 
     audio_input.change(
         fn=analyze_track,
         inputs=[audio_input],
-        outputs=[key_display, bpm_display, dur_display, continue_section, current_track, track_info]
+        outputs=[key_display, bpm_display, sig_display, dur_display,
+                 waveform_display, continue_section, current_track, track_info,
+                 status_html, result_section, lyrics_section, poster_section],
     )
 
     continue_btn.click(
-        fn=run_continuation,
-        inputs=[current_track, track_info, gen_length, fade_length, caption_box],
-        outputs=[result_audio, continue_output]
+        fn=run_pipeline,
+        inputs=[current_track, track_info, gen_length, fade_length,
+                caption_box, date_box],
+        outputs=[status_html, result_section, result_audio,
+                 lyrics_section, lyrics_orig, lyrics_cont,
+                 poster_section, poster_img],
     )
 
     gr.HTML(FOOTER_HTML)
@@ -390,4 +624,3 @@ with gr.Blocks(title="CODA") as app:
 
 if __name__ == "__main__":
     app.launch(theme=gr.themes.Base(), css=CUSTOM_CSS)
-

poster.py

@@ -1,79 +1,176 @@
-from PIL import Image, ImageDraw, ImageFont
+"""song poster + waveform rendering. pure pillow — no ML.
+
+the poster is the shareable artifact: a vinyl-sleeve card carrying the full
+song's waveform (original in cream, AI continuation in amber), the date the
+song was started and the date coda finished it, and the detected
+key / tempo / meter.
+"""
 import os
+import tempfile
+from datetime import date
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
 
-# warm palette matching the app
-BG_COLOR = (26, 23, 20)
-AMBER = (200, 149, 108)
-CREAM = (240, 236, 228)
-DARK_ACCENT = (60, 50, 40)
+# palette mirrors the app css
+BG = (11, 12, 15)
+SURFACE = (20, 22, 27)
+SURFACE_2 = (26, 29, 36)
+BORDER = (38, 42, 51)
+GROOVE = (30, 33, 40)
+TEXT = (237, 238, 242)
+MUTED = (138, 144, 156)
+AMBER = (226, 168, 92)
+
+# debian (hf spaces) ships dejavu; windows dev boxes get georgia/arial
+_FONT_PATHS = {
+    "serif": ["/usr/share/fonts/truetype/dejavu/DejaVuSerif.ttf",
+              "C:/Windows/Fonts/georgia.ttf",
+              "C:/Windows/Fonts/times.ttf"],
+    "serif_italic": ["/usr/share/fonts/truetype/dejavu/DejaVuSerif-Italic.ttf",
+                     "C:/Windows/Fonts/georgiai.ttf",
+                     "C:/Windows/Fonts/timesi.ttf"],
+    "sans": ["/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+             "C:/Windows/Fonts/arial.ttf"],
+    "sans_bold": ["/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+                  "C:/Windows/Fonts/arialbd.ttf"],
+}
+
+
+def _font(kind, size):
+    for path in _FONT_PATHS[kind]:
+        try:
+            return ImageFont.truetype(path, size)
+        except OSError:
+            continue
+    try:
+        return ImageFont.load_default(size)
+    except TypeError:  # older pillow without size kwarg
+        return ImageFont.load_default()
 
 
-def make_poster(title, key_sig, bpm, duration, out_path='poster.png'):
+def _center_text(draw, text, cx, top, font, fill):
+    bbox = draw.textbbox((0, 0), text, font=font)
+    draw.text((cx - (bbox[2] - bbox[0]) / 2, top), text, font=font, fill=fill)
+
+
+def _envelope(samples, columns):
+    """peak amplitude per column, normalized to [0, 1]."""
+    if len(samples) == 0:
+        return np.zeros(columns)
+    chunks = np.array_split(np.abs(samples), columns)
+    env = np.array([float(c.max()) if len(c) else 0.0 for c in chunks])
+    peak = env.max()
+    return env / peak if peak > 0 else env
+
+
+def _draw_waveform(draw, samples, box, color_a, color_b=None,
+                   split_frac=None, bar=4, gap=3):
     """
-    generates a simple album-art-style card for the analyzed track.
-    no ML here, just pillow.
+    bar-style waveform inside box=(x0, y0, x1, y1). columns left of
+    `split_frac` (fraction of the timeline) use color_a, the rest color_b —
+    that's how the poster shows where the original ends and coda begins.
     """
-    w, h = 800, 800
-    img = Image.new('RGB', (w, h), BG_COLOR)
+    x0, y0, x1, y1 = box
+    step = bar + gap
+    columns = max(1, (x1 - x0) // step)
+    env = _envelope(samples, columns)
+    mid = (y0 + y1) / 2
+    half = (y1 - y0) / 2 - 1
+    split_col = columns + 1 if split_frac is None else int(columns * split_frac)
+    for i, e in enumerate(env):
+        h = max(2.0, e * half)
+        x = x0 + i * step
+        color = color_a if i < split_col else (color_b or color_a)
+        draw.rounded_rectangle([x, mid - h, x + bar, mid + h],
+                               radius=bar / 2, fill=color)
+
+
+def render_waveform_png(audio_path, out_path=None, width=1280, height=200):
+    """standalone waveform card for the ui, shown right after upload."""
+    import librosa
+    samples, _ = librosa.load(audio_path, sr=8000, mono=True)
+    img = Image.new("RGB", (width, height), SURFACE)
     draw = ImageDraw.Draw(img)
+    _draw_waveform(draw, samples, (24, 22, width - 24, height - 22), AMBER)
+    if out_path is None:
+        out_path = os.path.join(tempfile.mkdtemp(), "waveform.png")
+    img.save(out_path)
+    return out_path
+
+
+def make_poster(audio_path, title, key_sig, bpm, time_sig, split_seconds,
+                original_date="", completed=None, out_path=None):
+    """
+    1080x1080 vinyl-sleeve poster for the finished song.
+
+    audio_path:     the FULL stitched song
+    split_seconds:  where the original ends and the continuation begins
+    original_date:  free text from the user ("2018", "march 2019", ...)
+    """
+    import librosa
+    samples, sr = librosa.load(audio_path, sr=8000, mono=True)
+    total = len(samples) / sr if len(samples) else 1.0
+    split_frac = min(1.0, max(0.0, float(split_seconds) / total))
+
+    w = h = 1080
+    img = Image.new("RGB", (w, h), BG)
+    draw = ImageDraw.Draw(img)
+
+    # sleeve frame
+    draw.rectangle([24, 24, w - 25, h - 25], outline=BORDER, width=2)
 
-    # big warm circle as a vinyl record silhouette
-    cx, cy = w // 2, h // 2 - 40
-    radius = 240
-    draw.ellipse(
-        [cx - radius, cy - radius, cx + radius, cy + radius],
-        fill=DARK_ACCENT,
-        outline=AMBER,
-        width=3
-    )
-
-    # inner circle (label area)
-    inner_r = 80
-    draw.ellipse(
-        [cx - inner_r, cy - inner_r, cx + inner_r, cy + inner_r],
-        fill=BG_COLOR,
-        outline=AMBER,
-        width=2
-    )
-
-    # spindle dot
+    # --- vinyl ---
+    cx, cy, radius = w // 2, 360, 250
+    draw.ellipse([cx - radius, cy - radius, cx + radius, cy + radius],
+                 fill=SURFACE_2, outline=AMBER, width=3)
+    for r in range(112, radius - 12, 13):
+        draw.ellipse([cx - r, cy - r, cx + r, cy + r], outline=GROOVE, width=1)
+    label_r = 94
+    draw.ellipse([cx - label_r, cy - label_r, cx + label_r, cy + label_r],
+                 fill=BG, outline=AMBER, width=2)
+    _center_text(draw, "CODA", cx, cy - 58, _font("sans_bold", 28), AMBER)
     draw.ellipse([cx - 6, cy - 6, cx + 6, cy + 6], fill=AMBER)
+    _center_text(draw, "SIDE B", cx, cy + 32, _font("sans", 17), MUTED)
 
-    # grooves (concentric rings)
-    for r in range(inner_r + 20, radius, 16):
-        draw.ellipse(
-            [cx - r, cy - r, cx + r, cy + r],
-            outline=(50, 42, 34),
-            width=1
-        )
+    # --- title ---
+    title = (title or "untitled").strip()
+    if len(title) > 32:
+        title = title[:29] + "..."
+    _center_text(draw, title, cx, 650, _font("serif", 58), TEXT)
 
-    # text below the record
-    try:
-        title_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 32)
-        detail_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 22)
-        small_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 16)
-    except OSError:
-        title_font = ImageFont.load_default()
-        detail_font = title_font
-        small_font = title_font
-
-    # track title
-    title_text = title if len(title) < 40 else title[:37] + '...'
-    bbox = draw.textbbox((0, 0), title_text, font=title_font)
-    tw = bbox[2] - bbox[0]
-    draw.text(((w - tw) // 2, h - 200), title_text, fill=CREAM, font=title_font)
-
-    # key + bpm line
-    info_text = f"{key_sig}  ·  {bpm} BPM  ·  {duration:.1f}s"
-    bbox = draw.textbbox((0, 0), info_text, font=detail_font)
-    tw = bbox[2] - bbox[0]
-    draw.text(((w - tw) // 2, h - 150), info_text, fill=AMBER, font=detail_font)
-
-    # coda branding
-    brand = "CODA"
-    bbox = draw.textbbox((0, 0), brand, font=small_font)
-    tw = bbox[2] - bbox[0]
-    draw.text(((w - tw) // 2, h - 60), brand, fill=(100, 85, 70), font=small_font)
+    # --- key / tempo / meter ---
+    info_line = f"{key_sig}   ·   {round(float(bpm))} bpm   ·   {time_sig}"
+    _center_text(draw, info_line, cx, 738, _font("sans", 27), AMBER)
+
+    # --- waveform: original (cream) vs continuation (amber) ---
+    _draw_waveform(draw, samples, (100, 798, 980, 902), TEXT, AMBER, split_frac)
+
+    # legend
+    leg_font = _font("sans", 19)
+    items = [("original", TEXT), ("continuation", AMBER)]
+    widths = [16 + 8 + draw.textbbox((0, 0), t, font=leg_font)[2] for t, _ in items]
+    lx = cx - (sum(widths) + 36) / 2
+    for (label, color), iw in zip(items, widths):
+        draw.rounded_rectangle([lx, 928, lx + 16, 944], radius=4, fill=color)
+        draw.text((lx + 24, 924), label, font=leg_font, fill=MUTED)
+        lx += iw + 36
+
+    # --- dates ---
+    completed = completed or date.today()
+    completed_text = f"{completed:%B} {completed.day}, {completed.year}"
+    original_date = (original_date or "").strip()
+    if original_date:
+        dates = f"started {original_date}   —   finished {completed_text}"
+    else:
+        dates = f"finished {completed_text}"
+    _center_text(draw, dates, cx, 974, _font("serif_italic", 25), MUTED)
+
+    # --- branding ---
+    _center_text(draw, "C O M P L E T E D   B Y   C O D A", cx, 1024,
+                 _font("sans_bold", 17), AMBER)
 
+    if out_path is None:
+        out_path = os.path.join(tempfile.mkdtemp(), "coda_poster.png")
     img.save(out_path)
     return out_path

stems.py

@@ -0,0 +1,65 @@
+"""shared HT-Demucs stem separation.
+
+the pipeline separates vocals twice with the same model: continue_music's
+vocal gate prompts musicgen with the instrumental (vocal prompts are
+out-of-distribution — musicgen's training data was demucs-separated), and
+transcribe.py feeds the isolated vocal stem to whisper so it doesn't
+hallucinate on drums and guitars.
+"""
+import librosa
+import numpy as np
+
+_demucs = None
+
+
+def _load_demucs():
+    global _demucs
+    if _demucs is None:
+        from demucs.pretrained import get_model
+        _demucs = get_model("htdemucs")
+        _demucs.eval()
+    return _demucs
+
+
+def isolate_vocals(path, max_seconds=None):
+    """
+    separate `path` into stems and return the vocal stem.
+
+    returns (vocals, sr, vocal_ratio):
+      vocals       float32 (2, N) at the demucs sample rate
+      sr           demucs sample rate (44100)
+      vocal_ratio  vocal-stem rms / mix rms — how vocal the clip is
+    or (None, None, 0.0) when demucs isn't available.
+    """
+    try:
+        import torch
+        from demucs.apply import apply_model
+        model = _load_demucs()
+    except Exception as e:
+        print(f"[coda] demucs unavailable ({e})", flush=True)
+        return None, None, 0.0
+
+    sr = model.samplerate
+    wav, _ = librosa.load(path, sr=sr, mono=False)
+    if wav.ndim == 1:
+        wav = np.stack([wav, wav])
+    if max_seconds:
+        wav = wav[:, -int(max_seconds * sr):]
+    wav = wav.astype(np.float32)
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    mix = torch.from_numpy(np.ascontiguousarray(wav))
+    # demucs expects the mix standardized (same as its own separate.py)
+    ref = mix.mean(0)
+    std = float(ref.std()) + 1e-8
+    with torch.no_grad():
+        sources = apply_model(
+            model.to(device), ((mix - ref.mean()) / std)[None].to(device),
+            device=device, split=True, overlap=0.25, progress=False,
+        )[0]
+    sources = sources.cpu() * std + ref.mean()
+    vocals = sources[model.sources.index("vocals")].numpy().astype(np.float32)
+
+    vocal_rms = float(np.sqrt(np.mean(vocals ** 2)))
+    mix_rms = float(np.sqrt(np.mean(wav ** 2)) + 1e-9)
+    return vocals, sr, vocal_rms / mix_rms

test_app_logic.py

@@ -0,0 +1,137 @@
+"""offline tests for the non-GPU pipeline pieces: analysis (key/tempo/meter),
+waveform + poster rendering, whisper hallucination filter, qwen output
+cleaner, and the ui stage tracker. no torch required."""
+import os
+import sys
+import tempfile
+from datetime import date
+
+import numpy as np
+import soundfile as sf
+
+FAILURES = []
+
+
+def check(name, cond, detail=""):
+    status = "PASS" if cond else "FAIL"
+    print(f"[{status}] {name} {detail}")
+    if not cond:
+        FAILURES.append(name)
+
+
+def click_track(meter, bpm=120, bars=16, sr=22050):
+    """synthetic drum-machine loop: an accented hit on beat 1 of every bar."""
+    beat_len = int(sr * 60 / bpm)
+    total = beat_len * meter * bars
+    y = np.zeros(total, dtype=np.float32)
+    rng = np.random.default_rng(7)
+    burst = (rng.standard_normal(600) * np.exp(-np.linspace(0, 8, 600))).astype(np.float32)
+    for b in range(meter * bars):
+        amp = 1.0 if b % meter == 0 else 0.3
+        start = b * beat_len
+        y[start:start + 600] += amp * burst
+    return y, sr
+
+
+def write_tmp(y, sr):
+    path = os.path.join(tempfile.mkdtemp(), "t.wav")
+    sf.write(path, y, sr)
+    return path
+
+
+# ---- 1. time signature estimation ----
+from analyze import fingerprint, get_time_signature
+
+y4, sr = click_track(4)
+y3, _ = click_track(3)
+check("4/4 click track detected as 4/4", get_time_signature(write_tmp(y4, sr)) == "4/4")
+check("3/4 click track detected as 3/4", get_time_signature(write_tmp(y3, sr)) == "3/4")
+
+# too short / ambiguous material falls back to 4/4, never crashes
+y_short, _ = click_track(4, bars=1)
+check("short clip falls back to 4/4", get_time_signature(write_tmp(y_short, sr)) == "4/4")
+
+# ---- 2. fingerprint: one call, all fields ----
+info = fingerprint(write_tmp(y4, sr))
+for field in ("key", "bpm", "time_signature", "duration", "sample_rate", "channels"):
+    check(f"fingerprint has {field}", field in info)
+check("fingerprint bpm ~120", 110 <= info["bpm"] <= 130, f"bpm={info['bpm']}")
+check("fingerprint meter 4/4", info["time_signature"] == "4/4")
+
+# ---- 3. waveform render ----
+from poster import render_waveform_png, make_poster, _envelope
+
+t = np.linspace(0, 5, 5 * 22050).astype(np.float32)
+tone = (0.5 * np.sin(2 * np.pi * 220 * t) * np.linspace(0, 1, len(t))).astype(np.float32)
+tone_path = write_tmp(tone, 22050)
+
+wave_png = render_waveform_png(tone_path)
+check("waveform png written", os.path.exists(wave_png) and os.path.getsize(wave_png) > 1000)
+
+env = _envelope(tone, 100)
+check("envelope normalized to [0,1]", 0.99 <= env.max() <= 1.0 and env.min() >= 0)
+check("ramped tone envelope rises", env[-10:].mean() > env[:10].mean())
+check("empty audio envelope is safe", np.all(_envelope(np.array([]), 50) == 0))
+
+# ---- 4. poster ----
+poster_path = make_poster(
+    tone_path, title="garage demo final FINAL v2 (real one this time)",
+    key_sig="F# minor", bpm=124.0, time_sig="4/4", split_seconds=2.5,
+    original_date="2018", completed=date(2026, 6, 12),
+)
+check("poster png written", os.path.exists(poster_path) and os.path.getsize(poster_path) > 5000)
+from PIL import Image
+pimg = Image.open(poster_path)
+check("poster is 1080x1080", pimg.size == (1080, 1080), f"size={pimg.size}")
+
+# poster without an original date still renders
+p2 = make_poster(tone_path, title="x", key_sig="C major", bpm=90,
+                 time_sig="3/4", split_seconds=0.0)
+check("poster works without original date", os.path.exists(p2))
+
+# ---- 5. whisper hallucination filter ----
+from transcribe import looks_like_lyrics
+
+check("real lyrics pass", looks_like_lyrics("I left my heart out on the wire\nwaiting for a sign"))
+check("'thank you.' rejected", not looks_like_lyrics("Thank you."))
+check("'thanks for watching' rejected", not looks_like_lyrics("Thanks for watching!"))
+check("empty rejected", not looks_like_lyrics(""))
+check("None rejected", not looks_like_lyrics(None))
+check("two-word loop rejected", not looks_like_lyrics("la la la la la la la la la"))
+check("short fragment rejected", not looks_like_lyrics("oh yeah"))
+
+# ---- 6. qwen output cleaner ----
+from write_lyrics import _clean
+
+raw = """<think>
+The user wants lyrics matching the tone...
+</think>
+Here are the lyrics:
+the ashes settle where we used to stand
+I trace the smoke back to your hand
+Existing line here
+and every echo learns my name
+"""
+cleaned = _clean(raw, existing_lines={"Existing line here"}, num_lines=8)
+check("think block stripped", "<think>" not in cleaned and "tone" not in cleaned)
+check("scaffold line dropped", "Here are the lyrics" not in cleaned)
+check("existing line not repeated", "Existing line here" not in cleaned)
+check("real lines kept", cleaned.startswith("the ashes settle"), f"{cleaned!r}")
+check("line cap respected", len(_clean("a\nb\nc\nd\ne", set(), 3).split("\n")) == 3)
+
+# ---- 7. stage tracker html ----
+from app import stages_html, PIPELINE_STAGES, make_stat_html
+
+html = stages_html(["done", "active", "pending", "pending"], note="working")
+check("tracker renders all stages", all(s in html for s in PIPELINE_STAGES))
+check("tracker carries states", 'stage done' in html and 'stage active' in html)
+check("tracker note rendered", 'working' in html)
+custom = stages_html(["skip"] * 4, labels=["a", "b", "c", "d"])
+check("tracker custom labels", ">a<" in custom and 'stage skip' in custom)
+check("stat card renders", 'stat-value' in make_stat_html("key", "F# minor"))
+
+print()
+if FAILURES:
+    print(f"{len(FAILURES)} FAILURES: {FAILURES}")
+    sys.exit(1)
+print("all checks passed")

transcribe.py

@@ -1,73 +1,99 @@
-import torch
-import torchaudio
-from transformers import WhisperProcessor, WhisperForConditionalGeneration
-
-
-_processor = None
-_model = None
-
-
-def _load_whisper():
-    global _processor, _model
-    if _model is None:
-        _processor = WhisperProcessor.from_pretrained("openai/whisper-large-v3")
-        _model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v3")
-    return _processor, _model
-
-
-def isolate_vocals(path):
+"""lyric extraction: demucs-isolated vocals -> whisper large-v3.
+
+vocals are pulled out with HT-Demucs before transcription for two reasons:
+whisper hallucinates on full mixes (drums decode to "thanks for watching"),
+and it keeps this stage consistent with continue_music's vocal gate — both
+agree on what counts as a vocal.
+
+torchaudio.load is deliberately avoided here: torchaudio 2.9+ delegates
+decoding to torchcodec, which isn't installed on the Space. librosa's
+soundfile backend handles everything we accept.
+"""
+import numpy as np
+
+WHISPER_ID = "openai/whisper-large-v3"
+WHISPER_SR = 16000
+# same bar as continue_music's vocal gate
+VOCAL_RMS_THRESHOLD = 0.1
+
+_asr = None
+
+
+def _load_asr():
+    global _asr
+    if _asr is None:
+        import torch
+        from transformers import pipeline
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        _asr = pipeline(
+            "automatic-speech-recognition",
+            model=WHISPER_ID,
+            torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+            device=device,
+            chunk_length_s=30,  # long-form: clips aren't capped at whisper's 30s window
+        )
+    return _asr
+
+
+# whisper's classic non-speech hallucinations — silence and instrument bleed
+# decode to these with high confidence
+_HALLUCINATION_LINES = {
+    "you", "thank you", "thanks for watching", "thank you for watching",
+    "bye", "music", "[music]", "(music)", "subscribe",
+    "please subscribe", "see you next time",
+}
+
+
+def looks_like_lyrics(text):
+    """filter whisper output that is clearly hallucinated, not sung words."""
+    text = (text or "").strip()
+    if not text:
+        return False
+    words = text.split()
+    if len(words) < 3:
+        return False
+    if text.lower().strip(" .!?") in _HALLUCINATION_LINES:
+        return False
+    # one short phrase looped over and over is the other hallucination shape
+    unique = {w.lower().strip(",.!?") for w in words}
+    if len(words) >= 8 and len(unique) <= 2:
+        return False
+    return True
+
+
+def transcribe_vocals(path):
     """
-    run demucs to split stems, return path to vocals.
-    expects demucs CLI installed via pip.
+    isolate vocals and transcribe them. returns the lyric text, or None when
+    the clip is instrumental (or separation finds no real vocal energy).
     """
-    import subprocess
-    import os
-
-    out_dir = os.path.join(os.path.dirname(path), '_stems')
-    cmd = ['python', '-m', 'demucs', '--two-stems', 'vocals',
-           '-o', out_dir, path]
-    subprocess.run(cmd, check=True, capture_output=True)
-
-    # demucs outputs to out_dir/htdemucs/<trackname>/vocals.wav
-    track_name = os.path.splitext(os.path.basename(path))[0]
-    vocals_path = os.path.join(out_dir, 'htdemucs', track_name, 'vocals.wav')
-
-    if not os.path.exists(vocals_path):
-        raise FileNotFoundError(f"demucs didn't produce vocals at {vocals_path}")
-
-    return vocals_path
-
-
-def transcribe(path, isolate=True):
-    """
-    extract lyrics from audio.
-    if isolate=True, runs demucs first to pull vocals.
-    """
-    if isolate:
-        try:
-            vocal_path = isolate_vocals(path)
-        except Exception:
-            # fall back to raw audio if stem separation fails
-            vocal_path = path
-    else:
-        vocal_path = path
-
-    processor, model = _load_whisper()
-
-    track, sr = torchaudio.load(vocal_path)
-
-    # whisper wants 16kHz mono
-    if sr != 16000:
-        track = torchaudio.transforms.Resample(sr, 16000)(track)
-    if track.shape[0] > 1:
-        track = track.mean(dim=0, keepdim=True)
-
-    track = track.squeeze()
-
-    inputs = processor(track.numpy(), sampling_rate=16000, return_tensors="pt")
-
-    with torch.no_grad():
-        predicted_ids = model.generate(inputs.input_features)
-
-    lyrics = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
-    return lyrics.strip()
+    import librosa
+    from stems import isolate_vocals
+
+    vocals, sep_sr, ratio = isolate_vocals(path)
+    if vocals is None:
+        print("[coda] transcribe: demucs unavailable, skipping lyrics", flush=True)
+        return None
+    if ratio < VOCAL_RMS_THRESHOLD:
+        print(f"[coda] transcribe: instrumental clip "
+              f"(vocal/mix rms {ratio:.3f}), no lyrics to pull", flush=True)
+        return None
+
+    mono = vocals.mean(axis=0) if vocals.ndim == 2 else vocals
+    wav = librosa.resample(mono.astype(np.float32), orig_sr=sep_sr,
+                           target_sr=WHISPER_SR, res_type="soxr_hq")
+
+    asr = _load_asr()
+    out = asr(
+        {"array": wav, "sampling_rate": WHISPER_SR},
+        return_timestamps=True,  # required for inputs longer than 30s
+        generate_kwargs={"task": "transcribe"},
+    )
+    text = (out.get("text") or "").strip()
+
+    if not looks_like_lyrics(text):
+        print(f"[coda] transcribe: discarding likely hallucination {text!r}",
+              flush=True)
+        return None
+    print(f"[coda] transcribe: pulled {len(text.split())} words of lyrics",
+          flush=True)
+    return text

write_lyrics.py

@@ -1,5 +1,12 @@
-from transformers import AutoModelForCausalLM, AutoTokenizer
+"""lyric continuation with qwen3-8b.
 
+this is a songwriting aid, not vocal synthesis: musicgen can't generate
+voices (vocals were stripped from its training data by design), so coda
+hands you the words for the new section instead of pretending to sing them.
+"""
+import re
+
+MODEL_ID = "Qwen/Qwen3-8B"
 
 _model = None
 _tokenizer = None
@@ -8,59 +15,85 @@ _tokenizer = None
 def _load_qwen():
     global _model, _tokenizer
     if _model is None:
-        model_id = "Qwen/Qwen3-8B"
-        _tokenizer = AutoTokenizer.from_pretrained(model_id)
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        _tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
         _model = AutoModelForCausalLM.from_pretrained(
-            model_id,
-            torch_dtype="auto",
-            device_map="auto"
+            MODEL_ID,
+            torch_dtype=torch.bfloat16 if torch.cuda.is_available() else "auto",
+            device_map="auto",
         )
     return _model, _tokenizer
 
 
-def continue_lyrics(existing_lyrics, key=None, bpm=None, style_hint=None, num_lines=8):
-    """
-    takes existing lyrics and writes more in the same style.
-    key/bpm/style_hint give the model musical context.
-    """
+def _clean(result, existing_lines, num_lines):
+    # qwen3 occasionally leaks reasoning even with thinking disabled
+    result = re.sub(r"<think>.*?</think>", "", result, flags=re.S)
+    result = result.replace("<think>", "").replace("</think>", "")
+
+    lines = []
+    for line in result.strip().split("\n"):
+        line = line.strip().strip('"')
+        if not line:
+            continue
+        # drop scaffolding the model sometimes adds despite instructions
+        if line.lower().rstrip(":") in (
+                "continuation", "lyrics", "new lyrics", "here are the lyrics",
+                "here is the continuation"):
+            continue
+        if line in existing_lines:
+            continue
+        lines.append(line)
+    return "\n".join(lines[:num_lines])
+
+
+def continue_lyrics(existing_lyrics, key=None, bpm=None, style_hint=None,
+                    num_lines=8):
+    """write `num_lines` new lines in the same voice as `existing_lyrics`."""
+    import torch
     model, tokenizer = _load_qwen()
 
     context_parts = []
     if key:
-        context_parts.append(f"The song is in {key}")
+        context_parts.append(f"the song is in {key}")
     if bpm:
-        context_parts.append(f"at {bpm} BPM")
+        context_parts.append(f"at {round(float(bpm))} BPM")
     if style_hint:
         context_parts.append(f"with a {style_hint} feel")
+    context = ("Musical context: " + ", ".join(context_parts) + "."
+               if context_parts else "")
 
-    context = ", ".join(context_parts) + "." if context_parts else ""
-
-    prompt = f"""You are a songwriter. Continue the following lyrics naturally,
-matching the tone, rhythm, and imagery. Write exactly {num_lines} new lines.
-Do not repeat existing lines. Do not add commentary or explanations.
+    prompt = f"""You are a songwriter finishing a song that was abandoned mid-write.
+Continue these lyrics naturally — match the tone, vocabulary, rhyme feel, and imagery.
+Write exactly {num_lines} new lines. Output only the lyric lines: no titles,
+no section labels, no commentary, and do not repeat existing lines.
 {context}
 
 Existing lyrics:
-{existing_lyrics}
-
-Continuation:"""
+{existing_lyrics}"""
 
     messages = [{"role": "user", "content": prompt}]
-    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-
+    text = tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True,
+        # hybrid thinking off — we want lyric lines, not <think> blocks
+        enable_thinking=False,
+    )
     inputs = tokenizer([text], return_tensors="pt").to(model.device)
 
-    output = model.generate(
-        **inputs,
-        max_new_tokens=256,
-        temperature=0.8,
-        top_p=0.9,
-        do_sample=True
-    )
+    with torch.no_grad():
+        output = model.generate(
+            **inputs,
+            max_new_tokens=320,
+            do_sample=True,
+            # qwen3's recommended non-thinking sampling
+            temperature=0.7,
+            top_p=0.8,
+            top_k=20,
+            pad_token_id=tokenizer.eos_token_id,
+        )
 
     generated = output[0][inputs.input_ids.shape[1]:]
     result = tokenizer.decode(generated, skip_special_tokens=True)
 
-    # trim to requested line count
-    lines = [l for l in result.strip().split('\n') if l.strip()]
-    return '\n'.join(lines[:num_lines])
+    existing = {l.strip() for l in existing_lyrics.split("\n")}
+    return _clean(result, existing, num_lines)