feat(lora): add single-lora stack apply + disable

lora_stack.py

@@ -20,10 +20,13 @@ function can be extended without changing the wrapper's call sites.
 from __future__ import annotations
 
 import json
+import logging
 import struct
 from dataclasses import dataclass
 from pathlib import Path
 
+_log = logging.getLogger("ams.lora")
+
 # Expected DiT module suffixes for ACE-Step 1.5 XL SFT.
 # Match against `*.to_q.lora_A.weight`, etc.
 _EXPECTED_MODULES = {"to_q", "to_k", "to_v", "to_out.0", "ff.net.0.proj", "ff.net.2"}
@@ -149,3 +152,33 @@ def download_preset(name: str) -> Path:
                     f"Could not download preset {name!r} from {p['hf_id']!r}: {e}"
                 ) from e
     raise LoRAValidationError(f"Unknown preset: {name}")
+
+
+def apply_stack(pipe, stack: list[dict]) -> None:
+    """Activate the given LoRA stack on the pipeline's DiT handler.
+
+    Apple-Silicon fork supports only one active LoRA at a time
+    (see module docstring). Behaviour:
+
+    - ``stack == []``: disable + unload the current LoRA.
+    - ``len(stack) == 1``: load + set scale + enable.
+    - ``len(stack) >= 2``: load the first, warn that the rest is ignored.
+    """
+    dit = pipe._dit  # internal AceStepHandler reference
+    if not stack:
+        dit.unload_lora()
+        dit.set_use_lora(False)
+        return
+
+    if len(stack) > 1:
+        _log.warning(
+            "apply_stack received %d LoRAs but only one is supported by "
+            "the apple-silicon ACE-Step fork; activating %r and ignoring the rest.",
+            len(stack),
+            stack[0]["name"],
+        )
+
+    first = stack[0]
+    dit.load_lora(first["path"])
+    dit.set_lora_scale(float(first["scale"]))
+    dit.set_use_lora(True)

tests/test_lora_stack.py

@@ -1,10 +1,12 @@
-"""L1 tests for LoRA header sniffing — no torch, no pipeline."""
+"""L1 tests for LoRA header sniffing + apply_stack — no torch, no pipeline."""
 
 from __future__ import annotations
 
 import json
+import logging
 import struct
 from pathlib import Path
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -63,3 +65,41 @@ def test_sniff_rejects_oversize(tmp_path):
     p.write_bytes(b"\0" * (600 * 1024 * 1024))
     with pytest.raises(ls.LoRAValidationError, match="too large"):
         ls.sniff(p)
+
+
+def test_apply_stack_empty_disables_lora():
+    pipe = MagicMock()
+    pipe._dit = MagicMock()
+    ls.apply_stack(pipe, [])
+    pipe._dit.unload_lora.assert_called_once()
+    pipe._dit.set_use_lora.assert_called_with(False)
+
+
+def test_apply_stack_single_lora_loads_and_enables(tmp_path):
+    pipe = MagicMock()
+    pipe._dit = MagicMock()
+    fake_path = tmp_path / "psy.safetensors"
+    fake_path.write_bytes(b"\0")
+    stack = [{"name": "psytrance_v2", "scale": 0.95, "path": str(fake_path), "sha256": "a" * 64}]
+    ls.apply_stack(pipe, stack)
+    pipe._dit.load_lora.assert_called_once_with(str(fake_path))
+    pipe._dit.set_lora_scale.assert_called_once_with(0.95)
+    pipe._dit.set_use_lora.assert_called_with(True)
+
+
+def test_apply_stack_multi_lora_uses_first_and_warns(tmp_path, caplog):
+    pipe = MagicMock()
+    pipe._dit = MagicMock()
+    a = tmp_path / "a.safetensors"
+    a.write_bytes(b"\0")
+    b = tmp_path / "b.safetensors"
+    b.write_bytes(b"\0")
+    stack = [
+        {"name": "a", "scale": 0.85, "path": str(a), "sha256": "1" * 64},
+        {"name": "b", "scale": 0.95, "path": str(b), "sha256": "2" * 64},
+    ]
+    with caplog.at_level(logging.WARNING):
+        ls.apply_stack(pipe, stack)
+    pipe._dit.load_lora.assert_called_once_with(str(a))
+    pipe._dit.set_lora_scale.assert_called_once_with(0.85)
+    assert any("only one" in r.message.lower() or "single" in r.message.lower() for r in caplog.records)