feat(ui): wire cover/extend/edit tabs into the sidebar layout (m3 e3+e4)

Replaces the three placeholder Markdowns in pane_cover / pane_extend /
pane_edit with full form builders mirroring the Generate tab's
structure (2-column row, LoRA accordion, output panel).

Each tab carries mode-specific inputs:
- Cover: reference audio + audio_cover_strength slider
- Extend: seed audio + extra_duration + experimental repaint params
- Edit: source audio + sub_mode pills (repaint/flow_edit) +
segment_start_s/segment_end_s + experimental flow-morph params

Shared chrome (LoRA accordion + Output/Metadata panels) factored
into _build_lora_accordion / _build_output_panel helpers so future
mode additions don't duplicate the same 30-line block.

Fields not yet wired to GenerationParams (repaint_mode,
repaint_strength, chunk_mask_mode, latent_crossfade_frames,
wav_crossfade_s, flow_source_caption, flow_n_*, cover_noise_strength)
are surfaced under "(experimental)" accordions with inline notes
explaining they're captured but no-ops until ACE-Step adds the
fields upstream. The plumbing already passes them through
backend.dispatch -> ACEStepStudio.generate -> internal params dict.

Verified at 360 px (mobile) and 1440 px (desktop) via Playwright;
each new tab's form + output panel render without regression vs the
Generate tab's Brutalist Mono baseline.

app.py

@@ -191,6 +191,121 @@ def on_generate_click(
     return out_path, meta
 
 
+def on_cover_click(
+    ref_audio,
+    prompt: str,
+    lyrics: str,
+    duration_s: float,
+    audio_cover_strength: float,
+    lora_state,
+    progress=gr.Progress(track_tqdm=True),  # noqa: B008
+):
+    """Cover-mode click. ref_audio is a filepath from gr.Audio(type='filepath')."""
+    loras = [lora_state] if lora_state else []
+    try:
+        return modes.cover(
+            get_backend(),
+            params={
+                "ref_audio": ref_audio,
+                "prompt": prompt,
+                "lyrics": lyrics,
+                "duration_s": int(duration_s),
+                "audio_cover_strength": float(audio_cover_strength),
+                "seed": random.randint(1, 2_147_483_647),
+                "loras": loras,
+                "advanced": {},
+                "lm": {},
+                "dcw": {},
+            },
+        )
+    except ValueError as e:
+        raise gr.Error(str(e)) from e
+
+
+def on_extend_click(
+    seed_audio,
+    extra_prompt: str,
+    extension_lyrics: str,
+    extra_duration_s: float,
+    wav_crossfade_s: float,
+    repaint_mode: str,
+    repaint_strength: float,
+    latent_crossfade_frames: float,
+    chunk_mask_mode: str,
+    lora_state,
+    progress=gr.Progress(track_tqdm=True),  # noqa: B008
+):
+    """Extend-mode click. seed_audio is a filepath from gr.Audio(type='filepath')."""
+    loras = [lora_state] if lora_state else []
+    try:
+        return modes.extend(
+            get_backend(),
+            params={
+                "seed_audio": seed_audio,
+                "extra_prompt": extra_prompt,
+                "extension_lyrics": extension_lyrics,
+                "extra_duration_s": int(extra_duration_s),
+                "wav_crossfade_s": float(wav_crossfade_s),
+                "repaint_mode": repaint_mode,
+                "repaint_strength": float(repaint_strength),
+                "latent_crossfade_frames": int(latent_crossfade_frames),
+                "chunk_mask_mode": chunk_mask_mode,
+                "seed": random.randint(1, 2_147_483_647),
+                "loras": loras,
+                "advanced": {},
+                "lm": {},
+                "dcw": {},
+            },
+        )
+    except ValueError as e:
+        raise gr.Error(str(e)) from e
+
+
+def on_edit_click(
+    source_audio,
+    sub_mode: str,
+    source_lyrics: str,
+    target_lyrics: str,
+    segment_start_s: float,
+    segment_end_s: float,
+    repaint_strength: float,
+    repaint_mode: str,
+    flow_source_caption: str,
+    flow_n_min: float,
+    flow_n_max: float,
+    flow_n_avg: float,
+    lora_state,
+    progress=gr.Progress(track_tqdm=True),  # noqa: B008
+):
+    """Edit-mode click. source_audio is a filepath from gr.Audio(type='filepath')."""
+    loras = [lora_state] if lora_state else []
+    try:
+        return modes.edit(
+            get_backend(),
+            params={
+                "source_audio": source_audio,
+                "sub_mode": sub_mode,
+                "source_lyrics": source_lyrics,
+                "target_lyrics": target_lyrics,
+                "segment_start_s": float(segment_start_s),
+                "segment_end_s": float(segment_end_s),
+                "repaint_strength": float(repaint_strength),
+                "repaint_mode": repaint_mode,
+                "flow_source_caption": flow_source_caption,
+                "flow_n_min": float(flow_n_min),
+                "flow_n_max": float(flow_n_max),
+                "flow_n_avg": int(flow_n_avg),
+                "seed": random.randint(1, 2_147_483_647),
+                "loras": loras,
+                "advanced": {},
+                "lm": {},
+                "dcw": {},
+            },
+        )
+    except ValueError as e:
+        raise gr.Error(str(e)) from e
+
+
 HEADER_HTML = """
 <div class="ams-header">
   <div>
@@ -300,11 +415,103 @@ def build_app() -> gr.Blocks:
                         outputs=[g["output_audio"], g["output_meta"]],
                     )
                 with gr.Group(visible=False, elem_classes=["ams-tab-pane"]) as pane_cover:
-                    gr.Markdown("### 🎤 Cover\n\nPlaceholder — implemented in M3.")
+                    c = ui.build_cover_tab()
+                    c["lora_preset"].change(
+                        fn=on_lora_preset_change,
+                        inputs=[c["lora_preset"], c["lora_strength"]],
+                        outputs=[c["lora_state"], c["lora_active"], c["lora_upload"]],
+                    )
+                    c["lora_upload"].change(
+                        fn=on_lora_upload,
+                        inputs=[c["lora_upload"], c["lora_strength"]],
+                        outputs=[c["lora_state"], c["lora_active"], c["lora_preset"]],
+                    )
+                    c["lora_strength"].change(
+                        fn=on_lora_strength_change,
+                        inputs=[c["lora_state"], c["lora_strength"]],
+                        outputs=[c["lora_state"], c["lora_active"]],
+                    )
+                    c["generate_btn"].click(
+                        fn=on_cover_click,
+                        inputs=[
+                            c["ref_audio"],
+                            c["prompt"],
+                            c["lyrics"],
+                            c["duration_s"],
+                            c["audio_cover_strength"],
+                            c["lora_state"],
+                        ],
+                        outputs=[c["output_audio"], c["output_meta"]],
+                    )
                 with gr.Group(visible=False, elem_classes=["ams-tab-pane"]) as pane_extend:
-                    gr.Markdown("### ⏩ Extend\n\nPlaceholder — implemented in M3.")
+                    x = ui.build_extend_tab()
+                    x["lora_preset"].change(
+                        fn=on_lora_preset_change,
+                        inputs=[x["lora_preset"], x["lora_strength"]],
+                        outputs=[x["lora_state"], x["lora_active"], x["lora_upload"]],
+                    )
+                    x["lora_upload"].change(
+                        fn=on_lora_upload,
+                        inputs=[x["lora_upload"], x["lora_strength"]],
+                        outputs=[x["lora_state"], x["lora_active"], x["lora_preset"]],
+                    )
+                    x["lora_strength"].change(
+                        fn=on_lora_strength_change,
+                        inputs=[x["lora_state"], x["lora_strength"]],
+                        outputs=[x["lora_state"], x["lora_active"]],
+                    )
+                    x["generate_btn"].click(
+                        fn=on_extend_click,
+                        inputs=[
+                            x["seed_audio"],
+                            x["extra_prompt"],
+                            x["extension_lyrics"],
+                            x["extra_duration_s"],
+                            x["wav_crossfade_s"],
+                            x["repaint_mode"],
+                            x["repaint_strength"],
+                            x["latent_crossfade_frames"],
+                            x["chunk_mask_mode"],
+                            x["lora_state"],
+                        ],
+                        outputs=[x["output_audio"], x["output_meta"]],
+                    )
                 with gr.Group(visible=False, elem_classes=["ams-tab-pane"]) as pane_edit:
-                    gr.Markdown("### ✏️ Edit\n\nPlaceholder — implemented in M3.")
+                    e = ui.build_edit_tab()
+                    e["lora_preset"].change(
+                        fn=on_lora_preset_change,
+                        inputs=[e["lora_preset"], e["lora_strength"]],
+                        outputs=[e["lora_state"], e["lora_active"], e["lora_upload"]],
+                    )
+                    e["lora_upload"].change(
+                        fn=on_lora_upload,
+                        inputs=[e["lora_upload"], e["lora_strength"]],
+                        outputs=[e["lora_state"], e["lora_active"], e["lora_preset"]],
+                    )
+                    e["lora_strength"].change(
+                        fn=on_lora_strength_change,
+                        inputs=[e["lora_state"], e["lora_strength"]],
+                        outputs=[e["lora_state"], e["lora_active"]],
+                    )
+                    e["generate_btn"].click(
+                        fn=on_edit_click,
+                        inputs=[
+                            e["source_audio"],
+                            e["sub_mode"],
+                            e["source_lyrics"],
+                            e["target_lyrics"],
+                            e["segment_start_s"],
+                            e["segment_end_s"],
+                            e["repaint_strength"],
+                            e["repaint_mode"],
+                            e["flow_source_caption"],
+                            e["flow_n_min"],
+                            e["flow_n_max"],
+                            e["flow_n_avg"],
+                            e["lora_state"],
+                        ],
+                        outputs=[e["output_audio"], e["output_meta"]],
+                    )
                 with gr.Group(visible=False, elem_classes=["ams-tab-pane"]) as pane_lyrics:
                     gr.Markdown("### ✍️ Lyrics\n\nPlaceholder — implemented in M4.")
 

theme.py

@@ -786,6 +786,81 @@ main, .contain {{
   }}
 }}
 
+/* ============================================================
+ * Audio upload widget (Cover / Extend / Edit reference inputs)
+ * Tagged with ``ams-input-audio`` via elem_classes. Match the dark
+ * input chrome so it sits next to the textboxes without contrast
+ * jumps; the gr.Audio drop-button gets the same dashed outline as
+ * the LoRA upload so users recognise it as a drop-zone.
+ * ============================================================ */
+.ams-content .ams-input-audio {{
+  background:{SURFACE_STRONG} !important;
+  border:1px solid {BORDER} !important;
+  border-radius:3px !important;
+  padding:8px !important;
+  margin-bottom:4px !important;
+}}
+.ams-content .ams-input-audio .empty,
+.ams-content .ams-input-audio [class*="empty"] {{
+  min-height:90px !important;
+}}
+.ams-content .ams-input-audio button {{
+  background:#000 !important;
+  border:1px dashed {BORDER_STRONG} !important;
+  border-radius:3px !important;
+  color:{INK_MUTED} !important;
+  font-family: {FONT_MONO} !important;
+  font-size:10px !important;
+  letter-spacing:0.04em !important;
+}}
+.ams-content .ams-input-audio button:hover {{
+  border-color:{PRIMARY} !important;
+  color:{INK} !important;
+}}
+.ams-content .ams-input-audio svg {{
+  color:{INK_MUTED} !important;
+  opacity:0.7 !important;
+}}
+
+/* ============================================================
+ * Experimental accordion (Extend / Edit)
+ * Reuse the LoRA accordion's visual chrome so the bordered section
+ * shape is consistent across all accordions, but visually demote
+ * the summary so users can tell these knobs aren't fully wired.
+ * ============================================================ */
+.ams-content .ams-experimental {{
+  border:1px solid {BORDER} !important;
+  border-radius:3px !important;
+  background:{SURFACE_STRONG} !important;
+  margin-top:10px !important;
+  padding:0 !important;
+}}
+.ams-content .ams-experimental > .label-wrap,
+.ams-content .ams-experimental summary,
+.ams-content .ams-experimental > button {{
+  font-family: {FONT_MONO} !important;
+  font-size:10px !important;
+  letter-spacing:0.08em !important;
+  text-transform:uppercase !important;
+  color:{INK_MUTED} !important;
+  padding:10px 12px !important;
+  background:transparent !important;
+  border:none !important;
+  opacity:0.7 !important;
+}}
+.ams-content .ams-experimental > .label-wrap span,
+.ams-content .ams-experimental summary span,
+.ams-content .ams-experimental > button span {{
+  color:{INK_MUTED} !important;
+  font-family: {FONT_MONO} !important;
+  font-size:10px !important;
+  letter-spacing:0.08em !important;
+  text-transform:uppercase !important;
+}}
+.ams-content .ams-experimental > div:not(.label-wrap):not(summary) {{
+  padding:0 12px 12px 12px !important;
+}}
+
 /* Hide Gradio footer + the floating "Use via API" / settings panel */
 footer {{ display:none !important; }}
 .show-api {{ display:none !important; }}

ui.py

@@ -16,15 +16,91 @@ import lora_stack
 import tooltips
 
 
+def _build_lora_accordion(components: dict[str, gr.components.Component]) -> None:
+    """LoRA accordion with single-LoRA semantics. Mutates ``components``.
+
+    Each song mode (generate / cover / extend / edit) calls this so the
+    form has a consistent LoRA picker. Apple-Silicon ACE-Step fork's
+    AceStepHandler can only hold one active adapter at a time (see
+    ``lora_stack.apply_stack``), so the UI surfaces a single slot — a
+    preset radio OR a custom upload — and a strength slider, with a
+    Markdown "active LoRA" display.
+    """
+    with gr.Accordion(
+        label="LoRA",
+        open=False,
+        elem_classes=["ams-lora", "ams-lora-accordion"],
+    ):
+        gr.Markdown(
+            "_Only one LoRA at a time on this build. "
+            "Picking a preset or uploading a custom file "
+            "replaces the active LoRA._",
+            elem_classes=["ams-lora-note"],
+        )
+        # Preset choices are read from presets/manifest.json so the
+        # radio stays in sync with whatever official ACE-Step LoRAs
+        # are actually published on HuggingFace.
+        _preset_names = ["None"] + [p["name"] for p in lora_stack.load_presets()]
+        components["lora_preset"] = gr.Radio(
+            choices=_preset_names,
+            value="None",
+            label="Preset",
+            elem_classes=["ams-lora-preset"],
+            interactive=True,
+        )
+        components["lora_upload"] = gr.File(
+            label="Custom LoRA (.safetensors)",
+            file_types=[".safetensors"],
+            file_count="single",
+            elem_classes=["ams-lora-file"],
+        )
+        components["lora_strength"] = gr.Slider(
+            minimum=0.0,
+            maximum=1.5,
+            step=0.05,
+            value=0.95,
+            label="Strength",
+            elem_classes=["ams-lora-strength"],
+        )
+        components["lora_active"] = gr.Markdown(
+            "_No LoRA active_",
+            elem_classes=["ams-lora-active"],
+        )
+        # Hidden state holding the resolved active LoRA dict
+        # ``{name, scale, path, sha256}`` so the click handler can pass
+        # it straight to backend.dispatch.
+        components["lora_state"] = gr.State(None)
+
+
+def _build_output_panel(components: dict[str, gr.components.Component]) -> None:
+    """Shared OUTPUT (gr.Audio) + METADATA (gr.JSON) bordered panels.
+
+    elem_classes on each output component give CSS hooks for the
+    Brutalist Mono treatment (uppercase mono labels + bordered
+    empty-state panels). Without these we'd need to target
+    svelte-hashed classes which can change across Gradio versions.
+
+    gr.JSON renders a dict directly as a syntax-highlighted, expandable
+    tree. gr.Code(language="json") refuses dicts — it requires a
+    pre-stringified blob — and crashes with "'dict' has no .strip()".
+    """
+    components["output_audio"] = gr.Audio(
+        label="Output",
+        type="filepath",
+        interactive=False,
+        elem_classes=["ams-out", "ams-out-audio"],
+    )
+    components["output_meta"] = gr.JSON(
+        label="Metadata",
+        elem_classes=["ams-out", "ams-out-meta"],
+    )
+
+
 def build_generate_tab() -> dict[str, gr.components.Component]:
     """Generate tab body: 2-column row (form left, output right).
 
     Includes a single-LoRA picker in a collapsed accordion between the
-    duration/vocal-mode row and the Generate button. The Apple-Silicon
-    ACE-Step fork's AceStepHandler only supports one active LoRA at a
-    time (see ``lora_stack.apply_stack`` for the gory details), so the
-    UI surfaces a single slot — a preset radio OR a custom upload — and
-    a strength slider, with a Markdown "active LoRA" display.
+    duration/vocal-mode row and the Generate button.
 
     Advanced / LM-planner / DCW accordions are deferred to M2-M4 and
     will be added by extending this builder.
@@ -62,78 +138,283 @@ def build_generate_tab() -> dict[str, gr.components.Component]:
                     info=tooltips.GENERATE_VOCAL,
                 )
 
-            # --- LoRA accordion (collapsed by default) ---
-            # Single-LoRA-slot UI: the apple-silicon fork's AceStepHandler
-            # can only hold one active adapter, so multi-row stacks are
-            # deferred until upstream lands multi-adapter support.
+            _build_lora_accordion(components)
+
+            components["generate_btn"] = gr.Button(
+                "▶ Generate",
+                variant="primary",
+            )
+
+        # --- OUTPUT column (right, ~40% width) ---
+        with gr.Column(scale=10):
+            _build_output_panel(components)
+
+    return components
+
+
+def build_cover_tab() -> dict[str, gr.components.Component]:
+    """Cover tab body: reference audio + new lyrics -> cover in that style.
+
+    Maps to ACE-Step's ``task_type="cover"`` with the uploaded reference
+    feeding ``reference_audio`` and the strength slider controlling
+    ``audio_cover_strength``. Higher strength clings to the reference;
+    lower lets the new prompt/lyrics drift the timbre.
+    """
+    components: dict[str, gr.components.Component] = {}
+    with gr.Row():
+        with gr.Column(scale=13):
+            components["ref_audio"] = gr.Audio(
+                label="Reference audio",
+                type="filepath",
+                sources=["upload"],
+                elem_classes=["ams-input-audio"],
+            )
+            components["prompt"] = gr.Textbox(
+                label="New style prompt (optional)",
+                placeholder="faster, more aggressive leads",
+                lines=2,
+            )
+            components["lyrics"] = gr.Textbox(
+                label="New lyrics",
+                placeholder="[verse] new lyrics over the reference style",
+                lines=5,
+            )
+            with gr.Row():
+                components["duration_s"] = gr.Slider(
+                    minimum=5,
+                    maximum=240,
+                    step=5,
+                    value=30,
+                    label="Duration (s)",
+                )
+                components["audio_cover_strength"] = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.01,
+                    value=0.93,
+                    label="Cover strength",
+                    info="Higher = closer to reference. Lower = more drift.",
+                )
+
+            _build_lora_accordion(components)
+
+            components["generate_btn"] = gr.Button(
+                "▶ Generate cover",
+                variant="primary",
+            )
+
+        with gr.Column(scale=10):
+            _build_output_panel(components)
+
+    return components
+
+
+def build_extend_tab() -> dict[str, gr.components.Component]:
+    """Extend tab body: seed audio + extension prompt -> continued song.
+
+    Maps to ACE-Step's ``task_type="repaint"`` with ``src_audio`` set to
+    the uploaded seed and the repaint window pointing past the end of
+    the seed so the model paints new audio after it.
+
+    The repaint params (``repaint_mode``, ``repaint_strength``,
+    ``latent_crossfade_frames``, ``chunk_mask_mode``, ``wav_crossfade_s``)
+    are surfaced in an experimental accordion because the installed
+    ACE-Step ``GenerationParams`` dataclass doesn't expose them yet — the
+    UI captures them so they're ready to plumb through once upstream
+    adds the fields.
+    """
+    components: dict[str, gr.components.Component] = {}
+    with gr.Row():
+        with gr.Column(scale=13):
+            components["seed_audio"] = gr.Audio(
+                label="Seed audio",
+                type="filepath",
+                sources=["upload"],
+                elem_classes=["ams-input-audio"],
+            )
+            components["extra_prompt"] = gr.Textbox(
+                label="Extension prompt",
+                placeholder="build to climax, layered acid leads",
+                lines=2,
+            )
+            components["extension_lyrics"] = gr.Textbox(
+                label="Extension lyrics (optional)",
+                placeholder="[bridge] the drop is coming...",
+                lines=4,
+            )
+            with gr.Row():
+                components["extra_duration_s"] = gr.Slider(
+                    minimum=5,
+                    maximum=120,
+                    step=5,
+                    value=60,
+                    label="Extra duration (s)",
+                )
+                components["wav_crossfade_s"] = gr.Slider(
+                    minimum=0.0,
+                    maximum=5.0,
+                    step=0.1,
+                    value=2.0,
+                    label="WAV crossfade (s)",
+                    info="Experimental — not yet wired in this acestep build.",
+                )
+
             with gr.Accordion(
-                label="LoRA",
+                "Repaint params (experimental)",
                 open=False,
-                elem_classes=["ams-lora", "ams-lora-accordion"],
+                elem_classes=["ams-experimental"],
             ):
                 gr.Markdown(
-                    "_Only one LoRA at a time on this build. "
-                    "Picking a preset or uploading a custom file "
-                    "replaces the active LoRA._",
+                    "_These knobs are captured in the request but the installed "
+                    "ACE-Step dataclass doesn't expose them yet._",
                     elem_classes=["ams-lora-note"],
                 )
-                # Preset choices are read from presets/manifest.json so the
-                # radio stays in sync with whatever official ACE-Step LoRAs
-                # are actually published on HuggingFace.
-                _preset_names = ["None"] + [p["name"] for p in lora_stack.load_presets()]
-                components["lora_preset"] = gr.Radio(
-                    choices=_preset_names,
-                    value="None",
-                    label="Preset",
-                    elem_classes=["ams-lora-preset"],
-                    interactive=True,
-                )
-                components["lora_upload"] = gr.File(
-                    label="Custom LoRA (.safetensors)",
-                    file_types=[".safetensors"],
-                    file_count="single",
-                    elem_classes=["ams-lora-file"],
-                )
-                components["lora_strength"] = gr.Slider(
+                components["repaint_mode"] = gr.Dropdown(
+                    choices=["balanced", "left", "right"],
+                    value="balanced",
+                    label="Repaint mode",
+                )
+                components["repaint_strength"] = gr.Slider(
                     minimum=0.0,
-                    maximum=1.5,
+                    maximum=1.0,
                     step=0.05,
-                    value=0.95,
-                    label="Strength",
-                    elem_classes=["ams-lora-strength"],
+                    value=0.5,
+                    label="Repaint strength",
+                )
+                components["latent_crossfade_frames"] = gr.Slider(
+                    minimum=0,
+                    maximum=30,
+                    step=1,
+                    value=10,
+                    label="Latent crossfade frames",
                 )
-                components["lora_active"] = gr.Markdown(
-                    "_No LoRA active_",
-                    elem_classes=["ams-lora-active"],
+                components["chunk_mask_mode"] = gr.Dropdown(
+                    choices=["auto", "manual"],
+                    value="auto",
+                    label="Chunk mask",
                 )
-                # Hidden state holding the resolved active LoRA dict
-                # ``{name, scale, path, sha256}`` so on_generate_click
-                # can pass it straight to backend.dispatch.
-                components["lora_state"] = gr.State(None)
+
+            _build_lora_accordion(components)
 
             components["generate_btn"] = gr.Button(
-                "▶ Generate",
+                "▶ Extend",
                 variant="primary",
             )
 
-        # --- OUTPUT column (right, ~40% width) ---
-        # elem_classes on each output component give CSS hooks for the
-        # Brutalist Mono treatment (uppercase mono labels + bordered
-        # empty-state panels). Without these we'd need to target
-        # svelte-hashed classes which can change across Gradio versions.
         with gr.Column(scale=10):
-            components["output_audio"] = gr.Audio(
-                label="Output",
+            _build_output_panel(components)
+
+    return components
+
+
+def build_edit_tab() -> dict[str, gr.components.Component]:
+    """Edit tab body: source audio + segment + target lyrics -> repaint/morph.
+
+    Two sub-modes:
+
+    - ``repaint`` (default): paint over [segment_start_s, segment_end_s]
+      using ACE-Step's repaint task_type. ``segment_start_s`` and
+      ``segment_end_s`` are wired through the params dict to
+      ``repainting_start`` / ``repainting_end`` on the pipeline side.
+    - ``flow_edit``: caption-to-caption morph. The installed ACE-Step
+      ``GenerationParams`` has no ``flow_edit_*`` fields, so this
+      sub-mode falls back to a repaint pass with lower
+      ``audio_cover_strength``. The flow knobs are still captured so
+      they're ready once upstream adds native support.
+    """
+    components: dict[str, gr.components.Component] = {}
+    with gr.Row():
+        with gr.Column(scale=13):
+            components["source_audio"] = gr.Audio(
+                label="Source audio",
                 type="filepath",
-                interactive=False,
-                elem_classes=["ams-out", "ams-out-audio"],
+                sources=["upload"],
+                elem_classes=["ams-input-audio"],
+            )
+            components["sub_mode"] = gr.Radio(
+                choices=["repaint", "flow_edit"],
+                value="repaint",
+                label="Edit sub-mode",
+                info=(
+                    "repaint: regenerate the segment from new lyrics. "
+                    "flow_edit: morph caption-to-caption (experimental)."
+                ),
+            )
+            components["source_lyrics"] = gr.Textbox(
+                label="Source lyrics",
+                lines=3,
+            )
+            components["target_lyrics"] = gr.Textbox(
+                label="Target lyrics",
+                placeholder="[chorus] new chorus replaces the old",
+                lines=3,
             )
-            # gr.JSON renders a dict directly as a syntax-highlighted, expandable
-            # tree. gr.Code(language="json") refuses dicts — it requires a
-            # pre-stringified blob — and crashes with "'dict' has no .strip()".
-            components["output_meta"] = gr.JSON(
-                label="Metadata",
-                elem_classes=["ams-out", "ams-out-meta"],
+            with gr.Row():
+                components["segment_start_s"] = gr.Number(
+                    value=0.0,
+                    label="Segment start (s)",
+                    precision=1,
+                )
+                components["segment_end_s"] = gr.Number(
+                    value=30.0,
+                    label="Segment end (s)",
+                    precision=1,
+                )
+
+            with gr.Accordion(
+                "Repaint options (experimental)",
+                open=False,
+                elem_classes=["ams-experimental"],
+            ):
+                gr.Markdown(
+                    "_These knobs are captured in the request but the installed "
+                    "ACE-Step dataclass doesn't expose them yet._",
+                    elem_classes=["ams-lora-note"],
+                )
+                components["repaint_strength"] = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.05,
+                    value=0.5,
+                    label="Repaint strength",
+                )
+                components["repaint_mode"] = gr.Dropdown(
+                    choices=["balanced", "left", "right"],
+                    value="balanced",
+                    label="Repaint mode",
+                )
+
+            with gr.Accordion(
+                "Flow-morph options (experimental)",
+                open=False,
+                elem_classes=["ams-experimental"],
+            ):
+                gr.Markdown(
+                    "_flow_edit sub-mode currently falls back to a repaint pass with "
+                    "lower audio_cover_strength. flow-specific params are captured "
+                    "but not yet wired._",
+                    elem_classes=["ams-lora-note"],
+                )
+                components["flow_source_caption"] = gr.Textbox(
+                    label="Source caption",
+                    placeholder="acoustic ballad, gentle piano",
+                )
+                components["flow_n_min"] = gr.Slider(
+                    minimum=0.0, maximum=1.0, value=0.0, step=0.05, label="n_min"
+                )
+                components["flow_n_max"] = gr.Slider(
+                    minimum=0.0, maximum=1.0, value=1.0, step=0.05, label="n_max"
+                )
+                components["flow_n_avg"] = gr.Slider(minimum=1, maximum=5, value=1, step=1, label="n_avg")
+
+            _build_lora_accordion(components)
+
+            components["generate_btn"] = gr.Button(
+                "▶ Apply edit",
+                variant="primary",
             )
 
+        with gr.Column(scale=10):
+            _build_output_panel(components)
+
     return components