Derived prompt: fuse user intent + measured arc via write_sa3_prompt_blended

app.py

@@ -174,10 +174,17 @@ def _chain_payload(a: Analysis) -> dict:
     }
 
 
-def run_brief(audio_path: str | None, bpm_mode: str, bpm_prior_choice: str, bpm_prior_num: float, model_choice: str, api_key: str = ""):
+def run_brief(audio_path: str | None, bpm_mode: str, bpm_prior_choice: str, bpm_prior_num: float, model_choice: str, api_key: str = "", original_prompt: str = ""):
     """Streaming generator — yields partial outputs as each stage finishes so
     the UI fills in progressively instead of all-at-once after a long wait.
 
+    `original_prompt`: the source SA3 prompt that produced this audio (when
+    the tile came from a Generate-then-Use-for-Analysis flow). When set,
+    the derived SA3 variation prompt is built via the LLM `write_sa3_prompt_blended`
+    call which fuses the user's intent vocabulary with the measured arc —
+    so variants stay in the user's stylistic lane instead of drifting toward
+    whatever the LLM thought it heard. Empty string for uploaded files.
+
     Output tuple (14 slots):
       paragraph, caption, wave, data_tbl, sections_tbl, tags_tbl,
       errors, timings, sa3_var, sa3_match, clip_plan, mix_chain,
@@ -255,8 +262,27 @@ def run_brief(audio_path: str | None, bpm_mode: str, bpm_prior_choice: str, bpm_
                 if fut is fut_brief:
                     paragraph = text
                     safe = text if not text.startswith("(") else ""
-                    sa3_var_final = outputs.sa3_variation_prompt(a, safe)
                     sa3_match_final = outputs.sa3_match_style_prompt(a, safe)
+                    # Derived prompt — fuse user intent + measured arc when
+                    # we have an original prompt (i.e. the user routed in
+                    # via Generate → Use for analysis). Falls back to the
+                    # structural-only template for uploaded files OR if the
+                    # blend call itself fails.
+                    sa3_var_final = outputs.sa3_variation_prompt(a, safe)
+                    if original_prompt and safe:
+                        try:
+                            blended, _ = write_sa3_prompt_blended(
+                                original_prompt=original_prompt,
+                                brief_payload=_brief_payload(a),
+                                brief_text=safe,
+                                model=model_choice,
+                                api_key=api_key,
+                            )
+                            if blended and not blended.startswith("("):
+                                sa3_var_final = blended
+                        except Exception as e:
+                            print(f"[run_brief] blend failed: {type(e).__name__}: {e}",
+                                  file=sys.stderr, flush=True)
                 else:
                     llm_chain = text
                     mix_chain_final = outputs.mix_chain_text(a, llm_chain)
@@ -922,17 +948,20 @@ def _hint_from_prompt(prompt: str) -> tuple[str, str, float]:
 
 
 def send_tile_to_analysis(tile_id: str | None):
-    """Bridge from Generate → Analysis-flow upload box. Returns
-    (audio_path, gen_status_md, bpm_mode, genre, bpm_num) — the trailing
-    three feed the BPM-prior selectors so the analyzer doesn't lock
-    half-tempo on dnb/jungle SA3 gens. See `_hint_from_prompt`."""
+    """Bridge from Generate → Analysis-flow upload box.
+
+    Returns: (audio_path, status_md, bpm_mode, genre, bpm_num, source_prompt)
+    The trailing three selectors feed the BPM-prior so the analyzer doesn't
+    lock half-tempo on dnb/jungle SA3 gens. `source_prompt` is stashed in a
+    gr.State so run_brief can blend it back into the derived SA3 prompt —
+    without this the variants drift away from the user's original intent."""
     if not tile_id:
         return (None, "_❌ Pick a tile from the dropdown first._",
-                gr.update(), gr.update(), gr.update())
+                gr.update(), gr.update(), gr.update(), "")
     tile = crate.get_tile(tile_id)
     if not tile:
         return (None, "_❌ Tile not found — try Refresh._",
-                gr.update(), gr.update(), gr.update())
+                gr.update(), gr.update(), gr.update(), "")
     bpm_mode_v, genre_v, bpm_num_v = _hint_from_prompt(tile.source_prompt)
     hint_note = ""
     if bpm_mode_v == "Manual BPM":
@@ -947,11 +976,16 @@ def send_tile_to_analysis(tile_id: str | None):
         gr.update(value=bpm_mode_v),
         gr.update(value=genre_v),
         gr.update(value=bpm_num_v),
+        tile.source_prompt,
     )
 
 
 def build_ui() -> gr.Blocks:
-    with gr.Blocks(title="audio·brief") as demo:
+    # Theme + CSS must live on the Blocks instance (not on .launch()) so
+    # HF Spaces — which auto-launches `demo` without our launch args —
+    # still picks them up. Gradio v6 supports both call sites; we just
+    # have to pick the one that works in both deploy paths.
+    with gr.Blocks(title="audio·brief", theme=THEME, css=CUSTOM_CSS) as demo:
         # Top bar — brand + pollen pill + avatar. Dynamic on connect via the
         # wallet handlers below (they output to `topbar` to refresh the pill).
         topbar = gr.HTML(_topbar_html())
@@ -976,6 +1010,12 @@ def build_ui() -> gr.Blocks:
         # Cleared on disconnect/connect so each visit starts fresh.
         session_spend_state = gr.State(0.0)
 
+        # The SA3 prompt that produced the currently-analyzed tile. Set by
+        # send_tile_to_analysis from tile.source_prompt; threaded into
+        # run_brief so the LLM can fuse user intent with measured arc.
+        # Empty string for tiles uploaded from disk (no source prompt known).
+        current_source_prompt = gr.State("")
+
         # Shared state — holds the most recent Analysis + payloads so the
         # Compare tab can re-run the same brief through different models.
         last_run = gr.State(None)
@@ -1403,10 +1443,15 @@ def build_ui() -> gr.Blocks:
             # bpm_mode/genre/bpm_num get updated from the tile's source prompt
             # before run_brief reads them — otherwise dnb gens analyze at half
             # tempo (87 instead of 174 with no prior to anchor librosa).
-            outputs=[audio_in, gen_status, bpm_mode, genre, bpm_num],
+            # current_source_prompt carries the tile's source_prompt into
+            # run_brief so the LLM can blend user-intent back into the
+            # derived SA3 prompt.
+            outputs=[audio_in, gen_status, bpm_mode, genre, bpm_num,
+                     current_source_prompt],
         ).then(
             fn=run_brief,
-            inputs=[audio_in, bpm_mode, genre, bpm_num, model_dd, api_key_state],
+            inputs=[audio_in, bpm_mode, genre, bpm_num, model_dd,
+                    api_key_state, current_source_prompt],
             outputs=[
                 paragraph, caption, wave,
                 metrics_html,
@@ -1486,23 +1531,27 @@ def build_ui() -> gr.Blocks:
     return demo
 
 
+# Allow Gradio to serve files from the crate dir. On HF Spaces this MUST be
+# called at module load — Spaces ignores main()/demo.launch() and grabs the
+# module-level `demo` symbol directly, so any allowed_paths passed to
+# .launch() would never be applied. set_static_paths is the global hook.
+gr.set_static_paths([str(crate.CRATE_DIR)])
+
+# Build the UI at module load and expose `demo` so HF can pick it up. The
+# build is fast (a few hundred ms) and only runs once per worker. On HF
+# Spaces, Gradio's auto-launch calls .queue() and .launch() itself.
+demo = build_ui()
+demo.queue(default_concurrency_limit=4)
+
+
 def main() -> int:
+    """Local entrypoint — `python app.py`. On HF Spaces this never runs;
+    Spaces imports the module and launches `demo` directly."""
     import os
-    demo = build_ui()
-    demo.queue(default_concurrency_limit=4)
-    # Honour PORT / GRADIO_SERVER_PORT so the harness's autoPort assignment
-    # actually takes effect (Gradio does NOT read PORT on its own).
     port_env = os.environ.get("GRADIO_SERVER_PORT") or os.environ.get("PORT")
     port = int(port_env) if port_env else None
-    # Allow Gradio to serve audio from the crate dir. Without this, every
-    # gen → audio component returns InvalidPathError because /tmp/audio-brief-crate
-    # is outside cwd and the platform temp dir.
-    demo.launch(
-        theme=THEME,
-        css=CUSTOM_CSS,
-        server_port=port,
-        allowed_paths=[str(crate.CRATE_DIR)],
-    )
+    # Theme + CSS already live on the Blocks instance (set in build_ui).
+    demo.launch(server_port=port)
     return 0