Fix song farm duration: size lyrics to hit 2:30-3:30

MiniMax Music 3 sings the lyrics through ONCE at ~15s/line, so track
duration = line count, NOT the audio_duration param (which it ignores).
Earlier farm songs came out 66-115s because the LLM baked 30-50 line
telenovela lyrics.

- bake_multilevel_lyrics: compute target_lines from duration_seconds
(180s -> 12 lines), inject a hard length rule into the prompt, and
cap parsed sections as a backstop (LLM ignored the prompt alone)
- _cap_lyric_sections: trim to target, preserving intro/verse/chorus spine
- tests: 281 passed (cap unit test + target_lines scaling)

moldovan-qwen/engine/lyricist_engine.py

@@ -399,6 +399,21 @@ REGULI CRUCIALE DE COMPOZIȚIE:
 
         user_prompt = f"Compune o piesă virală despre: '{clean_topic}'. Vibe: {intent}, Gen: {genre} ({bpm} BPM), Stil vocal: {vocal_style}."
 
+        # The MiniMax vocal engine sings the lyrics through ONCE at ~15s/line, so
+        # real track duration ≈ line_count × 15s. Size the song to the target.
+        target_lines = max(8, min(16, int(round(duration_seconds / 15.0))))
+        length_spec = (
+            f"\n10. LUNGIME PIESĂ (REGULĂ DE FIER, PRIORITATE MAXIMĂ): exact {target_lines} versuri "
+            f"cântate, NU mai mult. Structură fixă: Intro 1, Verse 1 = 4, Chorus (hook) = 4, "
+            f"Verse 2 = 2, Outro 1. Fiecare vers = o singură lovitură scurtă și catchy cu repetiție "
+            f"în refren. NU scrie povestiri, NU umple cu secțiuni lungi, NU repetă idei noi la nesfârșit. "
+            f"ÎNCEARCĂ: {target_lines} versuri. Dacă ai mai mult de {target_lines}, e EȘEC."
+        )
+        system_prompt += length_spec
+        user_prompt = (
+            user_prompt + f" Lungime: EXACT {target_lines} versuri cântate, scurt și catchy."
+        )
+
         raw_text = self._call_llm(system_prompt, user_prompt)
         parsed = self._parse_raw_lyrics_to_structure(raw_text, clean_topic, genre, bpm, intent)
 
@@ -407,6 +422,7 @@ REGULI CRUCIALE DE COMPOZIȚIE:
 
         # Enhance with Phonetic Singing Diction & Rhyme Meter
         sections = parsed.get("sections", [])
+        sections = self._cap_lyric_sections(sections, target_lines)
         phonetic_sections = self.phonetic_composer.phonetize_lyrics_structure(sections)
         parsed["sections"] = phonetic_sections
 
@@ -951,6 +967,38 @@ REGULI CRUCIALE DE COMPOZIȚIE:
         lw = words[-1].lower()
         return lw[-3:] if len(lw) >= 3 else lw
 
+    def _cap_lyric_sections(self, sections: list, target_lines: int) -> list:
+        """Hard backstop: trim section lines so total singing lines <= target_lines.
+
+        Preserves the song's spine (intro + first verse + chorus) and drops the
+        trailing extra verses/bridge/outro if the LLM over-produced, so we never
+        ship a telenovela-length track.
+        """
+        def line_count(sec):
+            return len(sec.get("lines", []))
+
+        total = sum(line_count(s) for s in sections)
+        if total <= target_lines:
+            return sections
+
+        # Keep at least the first three structural sections (intro/verse/chorus),
+        # then trim from the end; within a section, trim lines from the tail.
+        capped = [dict(s) for s in sections]
+        for i in range(len(capped) - 1, -1, -1):
+            if total <= target_lines:
+                break
+            sec = capped[i]
+            lines = sec.get("lines", [])
+            keep = max(0, min(len(lines), target_lines - (total - len(lines))))
+            if keep < len(lines):
+                sec["lines"] = lines[:keep]
+            total = sum(line_count(s) for s in capped)
+            # If this section is now empty and it's not a core opening section, drop it.
+            if not sec.get("lines") and i >= 2:
+                capped.pop(i)
+                total = sum(line_count(s) for s in capped)
+        return capped
+
     def bake_multilevel_lyrics(
         self,
         topic: str,
@@ -1032,6 +1080,15 @@ REGULI CRUCIALE DE COMPOZIȚIE:
             "Scrie versurile complete cu rimele contextuale #opțiune1 #opțiune2 la finalul fiecărui vers."
         )
 
+        # The MiniMax vocal engine sings the lyrics through ONCE at ~15s/line, so
+        # real track duration ≈ line_count × 15s. Size the song to the target.
+        target_lines = max(8, min(16, int(round(duration_seconds / 15.0))))
+        user_prompt += (
+            f"\nLUNGIME (REGULĂ DE FIER, PRIORITATE MAXIMĂ): EXACT {target_lines} versuri cântate, "
+            f"scurt și catchy, cu repetiție în refren. NU poveste, NU telenovelă, NU mai mult de "
+            f"{target_lines} versuri."
+        )
+
         raw_output = self._call_llm(system_prompt, user_prompt, provider=provider, model=model)
 
         # Parse sections and extract multi-level lines
@@ -1040,6 +1097,8 @@ REGULI CRUCIALE DE COMPOZIȚIE:
             # Intelligent procedural synthesis with guaranteed 3 tiers
             fb = self._generate_intelligent_fallback(clean_topic, effective_mood, genre, bpm, dialect_level, duration_seconds)
             sections = self._enhance_sections_to_multilevel(fb.get("sections", []), dialect_level)
+        else:
+            sections = self._cap_lyric_sections(sections, target_lines)
 
         # Build clean full_lyrics with Tier 1
         full_lyrics_parts = []

tests/unit/test_song_farm.py

@@ -83,3 +83,36 @@ def test_farm_start_rejects_when_already_running(studio_client, monkeypatch):
     body = r.json()
     assert body["started"] is False
     assert "already running" in body["reason"]
+
+
+def test_lyricist_cap_trims_to_target_lines():
+    """The song farm relies on the engine capping baked lyrics to ~15s/line * target,
+    so tracks land in the 2:30-3:30 window instead of running long."""
+    from engine.lyricist_engine import LyricistEngine
+    eng = LyricistEngine()
+    sections = [
+        {"tag": "[Intro]", "lines": [{"text": "a"}]},
+        {"tag": "[Verse 1]", "lines": [{"text": f"v1{i}"} for i in range(8)]},
+        {"tag": "[Chorus]", "lines": [{"text": f"c{i}"} for i in range(8)]},
+        {"tag": "[Verse 2]", "lines": [{"text": f"v2{i}"} for i in range(8)]},
+        {"tag": "[Outro]", "lines": [{"text": "o"}]},
+    ]
+    total_in = sum(len(s["lines"]) for s in sections)
+    capped = eng._cap_lyric_sections(sections, 12)
+    total_out = sum(len(s["lines"]) for s in capped)
+    assert total_in > 12
+    assert total_out <= 12
+    # the core opening spine (intro + first verse + chorus) must survive the trim
+    tags = [s["tag"] for s in capped]
+    assert "[Intro]" in tags and "[Verse 1]" in tags and "[Chorus]" in tags
+
+
+def test_lyricist_target_lines_scales_with_duration():
+    """180s -> ~12 lines, 150s -> ~10, 210s -> ~14; clamped to [8, 16]."""
+    def compute(sec):
+        return max(8, min(16, int(round(sec / 15.0))))
+    assert compute(180) == 12
+    assert compute(150) == 10
+    assert compute(210) == 14
+    assert compute(30) == 8      # floor
+    assert compute(400) == 16    # ceiling