sync PR7 reviewed snapshot

tests/test_app_callbacks.py

@@ -1,6 +1,4 @@
 import app
-import hashlib
-from pathlib import Path
 from nexus_visual_weaver.planner import build_command_center_run
 
 
@@ -45,21 +43,6 @@ def test_checkpoint_seed_uses_only_last_8_chars() -> None:
     assert result == int("11223344", 16) % 1_000_000
 
 
-def test_safe_file_hash_streams_digest_and_size() -> None:
-    payload = b"nexus-visual-weaver" * 1024
-    target = Path("outputs/test-hash-reference.bin")
-    target.parent.mkdir(parents=True, exist_ok=True)
-    target.write_bytes(payload)
-
-    try:
-        digest, size = app._safe_file_hash(str(target))
-
-        assert digest == hashlib.sha256(payload).hexdigest()
-        assert size == len(payload)
-    finally:
-        target.unlink(missing_ok=True)
-
-
 # --- _wardrobe_summary tests ---
 
 def test_wardrobe_summary_returns_string_with_slot_fields() -> None:
@@ -270,6 +253,366 @@ def test_checkpoint_blocks_without_generated_artifact() -> None:
     assert "no generated artifact" in blocked[13]["message"].lower()
 
 
+# --- _safe_file_hash tests ---
+
+def test_safe_file_hash_returns_sha256_and_size_for_valid_file() -> None:
+    import hashlib
+    from pathlib import Path
+
+    path = app.ROOT / "outputs" / "test-hash-target.png"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = b"\x89PNG\r\n\x1a\n" + b"\x00" * 32
+    path.write_bytes(data)
+
+    file_hash, size = app._safe_file_hash(str(path))
+
+    assert file_hash == hashlib.sha256(data).hexdigest()
+    assert size == len(data)
+
+
+def test_safe_file_hash_returns_none_for_none_path() -> None:
+    assert app._safe_file_hash(None) == (None, None)
+
+
+def test_safe_file_hash_returns_none_for_empty_string() -> None:
+    assert app._safe_file_hash("") == (None, None)
+
+
+def test_safe_file_hash_returns_none_for_missing_file() -> None:
+    result = app._safe_file_hash("/nonexistent/path/no-such-file.png")
+    assert result == (None, None)
+
+
+def test_safe_file_hash_hash_is_64_hex_chars() -> None:
+    from pathlib import Path
+
+    path = app.ROOT / "outputs" / "test-hash-hex.png"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x01" * 8)
+
+    file_hash, _ = app._safe_file_hash(str(path))
+
+    assert file_hash is not None
+    assert len(file_hash) == 64
+    assert all(c in "0123456789abcdef" for c in file_hash)
+
+
+# --- _safe_reference_url_metadata tests ---
+
+def test_safe_reference_url_metadata_returns_none_for_falsy() -> None:
+    assert app._safe_reference_url_metadata(None) is None
+    assert app._safe_reference_url_metadata("") is None
+
+
+def test_safe_reference_url_metadata_returns_metadata_for_valid_https_url() -> None:
+    result = app._safe_reference_url_metadata("https://shop.example.test/item/123")
+
+    assert result is not None
+    assert result["status"] == "metadata_only"
+    assert result["domain"] == "shop.example.test"
+    assert "url_hash" in result
+    assert len(result["url_hash"]) == 64
+
+
+def test_safe_reference_url_metadata_returns_metadata_for_valid_http_url() -> None:
+    result = app._safe_reference_url_metadata("http://example.test/path?q=1")
+
+    assert result is not None
+    assert result["status"] == "metadata_only"
+    assert result["domain"] == "example.test"
+
+
+def test_safe_reference_url_metadata_rejects_file_scheme() -> None:
+    result = app._safe_reference_url_metadata("file:///etc/passwd")
+
+    assert result is not None
+    assert result["status"] == "invalid_url"
+
+
+def test_safe_reference_url_metadata_rejects_ftp_scheme() -> None:
+    result = app._safe_reference_url_metadata("ftp://ftp.example.test/file.txt")
+
+    assert result is not None
+    assert result["status"] == "invalid_url"
+
+
+def test_safe_reference_url_metadata_rejects_missing_host() -> None:
+    result = app._safe_reference_url_metadata("http:///no-host")
+
+    assert result is not None
+    assert result["status"] == "invalid_url"
+
+
+def test_safe_reference_url_metadata_domain_is_lowercase() -> None:
+    result = app._safe_reference_url_metadata("https://SHOP.EXAMPLE.TEST/Item/123")
+
+    assert result is not None
+    assert result["domain"] == "shop.example.test"
+
+
+def test_safe_reference_url_metadata_url_hash_is_stable() -> None:
+    url = "https://shop.example.test/stable-hash-test"
+    first = app._safe_reference_url_metadata(url)
+    second = app._safe_reference_url_metadata(url)
+
+    assert first is not None and second is not None
+    assert first["url_hash"] == second["url_hash"]
+
+
+def test_safe_reference_url_metadata_different_urls_produce_different_hashes() -> None:
+    url_a = "https://shop.example.test/item/1"
+    url_b = "https://shop.example.test/item/2"
+
+    result_a = app._safe_reference_url_metadata(url_a)
+    result_b = app._safe_reference_url_metadata(url_b)
+
+    assert result_a is not None and result_b is not None
+    assert result_a["url_hash"] != result_b["url_hash"]
+
+
+# --- _reference_metadata tests ---
+
+def test_reference_metadata_returns_empty_for_no_inputs() -> None:
+    scan = {"status": "pass", "export_gate": "clear"}
+    result = app._reference_metadata(None, None, scan)
+
+    assert result == []
+
+
+def test_reference_metadata_includes_file_record_when_uploaded() -> None:
+    from pathlib import Path
+
+    path = app.ROOT / "outputs" / "test-ref-meta.png"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 16)
+    scan = {"status": "pass", "export_gate": "clear", "magic": "PNG", "extension": ".png"}
+
+    result = app._reference_metadata(str(path), None, scan)
+
+    assert len(result) == 1
+    assert result[0]["source"] == "upload"
+    assert result[0]["basename"] == "test-ref-meta.png"
+    assert result[0]["sha256"] is not None
+    assert result[0]["st3gg_status"] == "pass"
+    assert result[0]["export_gate"] == "clear"
+    assert result[0]["magic"] == "PNG"
+    assert result[0]["extension"] == ".png"
+
+
+def test_reference_metadata_includes_url_record_when_url_given() -> None:
+    scan = {}
+    result = app._reference_metadata(None, "https://shop.example.test/item/99", scan)
+
+    assert len(result) == 1
+    assert result[0]["source"] == "url"
+    assert result[0]["domain"] == "shop.example.test"
+
+
+def test_reference_metadata_includes_both_file_and_url() -> None:
+    from pathlib import Path
+
+    path = app.ROOT / "outputs" / "test-ref-both.png"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIEND\xaeB`\x82")
+    scan = {"status": "pass", "export_gate": "clear"}
+
+    result = app._reference_metadata(str(path), "https://shop.example.test/item/77", scan)
+
+    assert len(result) == 2
+    sources = {r["source"] for r in result}
+    assert sources == {"upload", "url"}
+
+
+def test_reference_metadata_size_bytes_is_integer() -> None:
+    from pathlib import Path
+
+    data = b"\x89PNG\r\n\x1a\n" + b"\x00" * 24
+    path = app.ROOT / "outputs" / "test-ref-size.png"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(data)
+    scan = {}
+
+    result = app._reference_metadata(str(path), None, scan)
+
+    assert result[0]["size_bytes"] == len(data)
+
+
+# --- _creator_controls tests ---
+
+def test_creator_controls_returns_dict_with_wardrobe_and_generation() -> None:
+    result = app._creator_controls("Strict", "Wan2.2 I2V")
+
+    assert "wardrobe" in result
+    assert "generation" in result
+    assert result["reasoning_mode"] == "Strict"
+    assert result["video_preset"] == "Wan2.2 I2V"
+
+
+def test_creator_controls_default_wardrobe_values() -> None:
+    result = app._creator_controls("Strict", "Wan2.2 I2V")
+    wardrobe = result["wardrobe"]
+
+    assert wardrobe["footwear"] == "platform boots"
+    assert wardrobe["outerwear"] == "black patent leather long coat"
+    assert wardrobe["palette"] == "black, crimson, cyan neon"
+
+
+def test_creator_controls_overrides_wardrobe_slots() -> None:
+    result = app._creator_controls(
+        "Frontier",
+        "LTX-2.3",
+        footwear="patent leather heels",
+        outerwear="faux fur collar coat",
+        palette="obsidian, pearl, crimson",
+    )
+    wardrobe = result["wardrobe"]
+
+    assert wardrobe["footwear"] == "patent leather heels"
+    assert wardrobe["outerwear"] == "faux fur collar coat"
+    assert wardrobe["palette"] == "obsidian, pearl, crimson"
+
+
+def test_creator_controls_locked_slots_present() -> None:
+    result = app._creator_controls("Strict", "Wan2.2 I2V")
+    wardrobe = result["wardrobe"]
+
+    assert "locked_slots" in wardrobe
+    assert isinstance(wardrobe["locked_slots"], list)
+    assert "outerwear" in wardrobe["locked_slots"]
+
+
+def test_creator_controls_generation_specifies_flux_primary() -> None:
+    result = app._creator_controls("Strict", "Wan2.2 I2V")
+    generation = result["generation"]
+
+    assert "black-forest-labs/FLUX.2-klein-9B" in generation["flux_primary"]
+    assert "black-forest-labs/FLUX.2-klein-4B" in generation["flux_sidecar"]
+
+
+# --- _prompt_with_controls tests ---
+
+def test_prompt_with_controls_appends_wardrobe_suffix() -> None:
+    controls = app._creator_controls("Strict", "Wan2.2 I2V", footwear="platform boots")
+    result = app._prompt_with_controls("gothic couture portrait", controls)
+
+    assert result.startswith("gothic couture portrait")
+    assert "Wardrobe controls:" in result
+    assert "platform boots" in result
+
+
+def test_prompt_with_controls_returns_prompt_unchanged_when_no_wardrobe() -> None:
+    # A controls dict with no wardrobe key
+    result = app._prompt_with_controls("gothic couture portrait", {})
+
+    assert result == "gothic couture portrait"
+
+
+def test_prompt_with_controls_includes_all_wardrobe_fields() -> None:
+    controls = app._creator_controls(
+        "Strict",
+        "Wan2.2 I2V",
+        silhouette="structured long coat",
+        outerwear="black patent leather long coat",
+        upper_body="Chantilly lace neckline",
+        footwear="platform boots",
+        palette="black, crimson, cyan neon",
+        hardware="crimson hardware",
+    )
+    result = app._prompt_with_controls("brief", controls)
+
+    assert "structured long coat" in result
+    assert "black patent leather long coat" in result
+    assert "Chantilly lace neckline" in result
+    assert "platform boots" in result
+    assert "crimson hardware" in result
+
+
+def test_prompt_with_controls_does_not_duplicate_prompt() -> None:
+    controls = app._creator_controls("Strict", "Wan2.2 I2V")
+    prompt = "gothic couture brief"
+    result = app._prompt_with_controls(prompt, controls)
+
+    assert result.count(prompt) == 1
+
+
+# --- _generated_output_path tests ---
+
+def test_generated_output_path_returns_none_when_no_state() -> None:
+    assert app._generated_output_path(None) is None
+
+
+def test_generated_output_path_returns_none_when_no_generation_key() -> None:
+    assert app._generated_output_path({"provider_state": "idle"}) is None
+
+
+def test_generated_output_path_returns_none_when_no_output_path() -> None:
+    state = {"generation": {"status": "disabled"}}
+    assert app._generated_output_path(state) is None
+
+
+def test_generated_output_path_returns_string_when_present() -> None:
+    state = {"generation": {"output_path": "/data/artifact.png"}}
+    result = app._generated_output_path(state)
+
+    assert result == "/data/artifact.png"
+
+
+def test_generated_output_path_returns_none_for_empty_path() -> None:
+    state = {"generation": {"output_path": ""}}
+    assert app._generated_output_path(state) is None
+
+
+# --- _authoritative_generated_scan tests ---
+
+def test_authoritative_generated_scan_returns_default_for_no_state() -> None:
+    result = app._authoritative_generated_scan(None)
+
+    assert isinstance(result, dict)
+    assert "status" in result
+
+
+def test_authoritative_generated_scan_scans_output_path_when_present() -> None:
+    from pathlib import Path
+
+    path = app.ROOT / "outputs" / "test-auth-scan.png"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIEND\xaeB`\x82")
+    state = {"generation": {"output_path": str(path)}}
+
+    result = app._authoritative_generated_scan(state)
+
+    assert result["status"] in {"pass", "review"}
+    assert "export_gate" in result
+
+
+def test_authoritative_generated_scan_falls_back_to_stored_scan() -> None:
+    stored_scan = {"status": "review", "export_gate": "blocked", "findings": ["trailing data"]}
+    state = {"generated_scan": stored_scan}
+
+    result = app._authoritative_generated_scan(state)
+
+    assert result == stored_scan
+
+
+def test_authoritative_generated_scan_uses_output_path_over_stored_scan() -> None:
+    from pathlib import Path
+
+    path = app.ROOT / "outputs" / "test-auth-scan-prefer.png"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIEND\xaeB`\x82")
+    stale_scan = {"status": "review", "export_gate": "blocked"}
+    state = {
+        "generation": {"output_path": str(path)},
+        "generated_scan": stale_scan,
+    }
+
+    result = app._authoritative_generated_scan(state)
+
+    # Should re-scan from file, not use stored scan
+    assert result["status"] == "pass"
+    assert result["export_gate"] == "clear"
+
+
 def test_export_packet_allows_blocked_st3gg_with_explicit_override(monkeypatch) -> None:
     monkeypatch.setenv("NEXUS_EXPORT_DIR", "outputs/test-exports")
     run = build_command_center_run("gothic patent leather platform boots")

tests/test_command_center.py

@@ -262,14 +262,6 @@ def test_render_trust_strip_pass_scan_shows_clear_export() -> None:
     assert "all checks passed" in html
 
 
-def test_render_trust_strip_clean_empty_findings_shows_no_findings() -> None:
-    scan = {"status": "pass", "export_gate": "clear", "findings": [], "purification_actions": []}
-    html = render_trust_strip(scan=scan)
-
-    assert "No findings." in html
-    assert "No upload selected. Always-on scanner ready." not in html
-
-
 def test_render_trust_strip_review_scan_shows_blocked_export() -> None:
     scan = {"status": "review", "export_gate": "blocked", "findings": ["trailing data after IEND"], "purification_actions": ["truncate PNG"]}
     html = render_trust_strip(scan=scan)
@@ -524,3 +516,278 @@ def test_public_demo_false_models_are_excluded_from_public_filter() -> None:
     )
     models_public, _ = filter_catalog(False)
     assert all(m.public_demo for m in models_public)
+
+
+# --- catalog FLUX.2-klein-4B tests ---
+
+def test_filter_catalog_includes_flux_4b_in_public_mode() -> None:
+    models, _ = filter_catalog(False)
+    repo_ids = {model.repo_id for model in models}
+
+    assert "black-forest-labs/FLUX.2-klein-4B" in repo_ids
+
+
+def test_filter_catalog_includes_flux_4b_in_adult_mode() -> None:
+    models, _ = filter_catalog(True)
+    repo_ids = {model.repo_id for model in models}
+
+    assert "black-forest-labs/FLUX.2-klein-4B" in repo_ids
+
+
+def test_flux_4b_is_not_in_default_active_stack() -> None:
+    stack = active_stack(False)
+    repo_ids = {model.repo_id for model in stack}
+
+    assert "black-forest-labs/FLUX.2-klein-4B" not in repo_ids
+
+
+def test_flux_4b_role_is_tiny_titan_sidecar() -> None:
+    models, _ = filter_catalog(False)
+    flux_4b = next((m for m in models if m.repo_id == "black-forest-labs/FLUX.2-klein-4B"), None)
+
+    assert flux_4b is not None
+    assert "tiny_titan" in flux_4b.role
+
+
+def test_flux_4b_has_apache_license() -> None:
+    models, _ = filter_catalog(False)
+    flux_4b = next((m for m in models if m.repo_id == "black-forest-labs/FLUX.2-klein-4B"), None)
+
+    assert flux_4b is not None
+    assert flux_4b.license == "apache-2.0"
+
+
+# --- parameter_budget over_budget tests ---
+
+def test_parameter_budget_passes_for_default_public_stack() -> None:
+    budget = parameter_budget(active_stack(False))
+
+    assert budget["status"] == "pass"
+    assert budget["active_b"] <= 32.0
+
+
+def test_parameter_budget_over_budget_for_large_stack() -> None:
+    large_stack = [
+        ModelCandidate(
+            repo_id=f"test/model-{i}",
+            role="test",
+            task="text-to-image",
+            params_b=10.0,
+            runtime="local",
+            license="apache-2.0",
+        )
+        for i in range(5)  # 50B total, over the 32B limit
+    ]
+    budget = parameter_budget(large_stack)
+
+    assert budget["status"] == "over_budget"
+    assert budget["active_b"] == 50.0
+    assert budget["remaining_b"] < 0.0
+
+
+def test_parameter_budget_exactly_at_limit() -> None:
+    stack = [
+        ModelCandidate(
+            repo_id="test/model",
+            role="test",
+            task="text-to-image",
+            params_b=32.0,
+            runtime="local",
+            license="apache-2.0",
+        )
+    ]
+    budget = parameter_budget(stack)
+
+    assert budget["status"] == "pass"
+    assert budget["active_b"] == 32.0
+    assert budget["remaining_b"] == 0.0
+
+
+def test_parameter_budget_just_over_limit() -> None:
+    stack = [
+        ModelCandidate(
+            repo_id="test/model",
+            role="test",
+            task="text-to-image",
+            params_b=32.1,
+            runtime="local",
+            license="apache-2.0",
+        )
+    ]
+    budget = parameter_budget(stack)
+
+    assert budget["status"] == "over_budget"
+
+
+def test_catalog_summary_includes_budget_keys() -> None:
+    summary = catalog_summary(False)
+
+    assert "active_b" in summary
+    assert "limit_b" in summary
+    assert "remaining_b" in summary
+    assert "status" in summary
+    assert summary["limit_b"] == 32.0
+
+
+def test_catalog_summary_models_visible_count_matches_filter() -> None:
+    models, adapters = filter_catalog(False)
+    summary = catalog_summary(False)
+
+    assert summary["models_visible"] == len(models)
+    assert summary["adapters_visible"] == len(adapters)
+
+
+# --- catalog MiniCPM-V-4.6 and Nemotron-Parse tests ---
+
+def test_minicpm_v46_in_public_catalog() -> None:
+    models, _ = filter_catalog(False)
+    repo_ids = {model.repo_id for model in models}
+
+    assert "openbmb/MiniCPM-V-4.6" in repo_ids
+
+
+def test_nemotron_parse_in_public_catalog() -> None:
+    models, _ = filter_catalog(False)
+    repo_ids = {model.repo_id for model in models}
+
+    assert "nvidia/NVIDIA-Nemotron-Parse-v1.2" in repo_ids
+
+
+def test_minicpm_v46_role_is_sponsor_visual_judge() -> None:
+    models, _ = filter_catalog(False)
+    minicpm = next((m for m in models if m.repo_id == "openbmb/MiniCPM-V-4.6"), None)
+
+    assert minicpm is not None
+    assert minicpm.role == "sponsor_visual_judge"
+    assert minicpm.params_b == 1.30
+
+
+def test_nemotron_parse_role_is_sponsor_structured_parse() -> None:
+    models, _ = filter_catalog(False)
+    nemotron = next((m for m in models if m.repo_id == "nvidia/NVIDIA-Nemotron-Parse-v1.2"), None)
+
+    assert nemotron is not None
+    assert nemotron.role == "sponsor_structured_parse"
+    assert nemotron.params_b == 0.94
+
+
+# --- adapter catalog changes tests ---
+
+def test_dever_style_lora_compatible_with_9b_and_4b() -> None:
+    from nexus_visual_weaver.catalog import ADAPTER_CATALOG
+
+    dever = next((a for a in ADAPTER_CATALOG if a.repo_id == "DeverStyle/Flux.2-Klein-Loras"), None)
+
+    assert dever is not None
+    assert "black-forest-labs/FLUX.2-klein-9B" in dever.compatible_repo_ids
+    assert "black-forest-labs/FLUX.2-klein-4B" in dever.compatible_repo_ids
+
+
+def test_dever_style_lora_has_trigger_words() -> None:
+    from nexus_visual_weaver.catalog import ADAPTER_CATALOG
+
+    dever = next((a for a in ADAPTER_CATALOG if a.repo_id == "DeverStyle/Flux.2-Klein-Loras"), None)
+
+    assert dever is not None
+    assert len(dever.trigger_words) > 0
+    assert "gothic couture" in dever.trigger_words
+
+
+def test_4b_outpaint_lora_requires_image() -> None:
+    from nexus_visual_weaver.catalog import ADAPTER_CATALOG
+
+    outpaint = next((a for a in ADAPTER_CATALOG if a.repo_id == "fal/flux-2-klein-4B-outpaint-lora"), None)
+
+    assert outpaint is not None
+    assert outpaint.requires_image is True
+    assert "black-forest-labs/FLUX.2-klein-4B" in outpaint.compatible_repo_ids
+
+
+# --- wardrobe controls tests ---
+
+def test_build_outfit_graph_controls_override_outerwear() -> None:
+    outfit = build_outfit_graph(
+        "minimal portrait",
+        controls={"outerwear": "tailored rain slicker"},
+    )
+    outerwear_slot = next((s for s in outfit.slots if s.name == "outerwear"), None)
+
+    assert outerwear_slot is not None
+    assert outerwear_slot.description == "tailored rain slicker"
+
+
+def test_build_outfit_graph_controls_override_footwear() -> None:
+    outfit = build_outfit_graph(
+        "minimal portrait",
+        controls={"footwear": "patent leather heels"},
+    )
+    footwear_slot = next((s for s in outfit.slots if s.name == "footwear"), None)
+
+    assert footwear_slot is not None
+    assert footwear_slot.description == "patent leather heels"
+
+
+def test_build_outfit_graph_controls_override_palette_for_all_slots() -> None:
+    custom_palette = "obsidian, pearl, crimson"
+    outfit = build_outfit_graph(
+        "minimal portrait",
+        controls={"palette": custom_palette},
+    )
+
+    for slot in outfit.slots:
+        assert slot.palette == custom_palette
+
+
+def test_build_outfit_graph_controls_override_hardware() -> None:
+    outfit = build_outfit_graph(
+        "minimal portrait",
+        controls={"hardware": "silver occult buckles"},
+    )
+    jewelry_slot = next((s for s in outfit.slots if s.name == "jewelry"), None)
+
+    assert jewelry_slot is not None
+    assert jewelry_slot.material == "silver occult buckles"
+
+
+def test_build_outfit_graph_locked_slots_control_locks_named_slots() -> None:
+    outfit = build_outfit_graph(
+        "minimal portrait",
+        controls={"locked_slots": ["hair_headwear", "props"]},
+    )
+    hair_slot = next((s for s in outfit.slots if s.name == "hair_headwear"), None)
+    props_slot = next((s for s in outfit.slots if s.name == "props"), None)
+
+    assert hair_slot is not None and hair_slot.locked is True
+    assert props_slot is not None and props_slot.locked is True
+
+
+def test_build_outfit_graph_locate_focus_sets_manual_focus_region() -> None:
+    outfit = build_outfit_graph(
+        "minimal portrait",
+        controls={"locate_focus": ["footwear", "jewelry"]},
+    )
+    footwear_slot = next((s for s in outfit.slots if s.name == "footwear"), None)
+    jewelry_slot = next((s for s in outfit.slots if s.name == "jewelry"), None)
+    hair_slot = next((s for s in outfit.slots if s.name == "hair_headwear"), None)
+
+    assert footwear_slot is not None and footwear_slot.locate_region == "manual-focus"
+    assert jewelry_slot is not None and jewelry_slot.locate_region == "manual-focus"
+    assert hair_slot is not None and hair_slot.locate_region == "auto-map"
+
+
+def test_build_outfit_graph_with_no_controls_uses_defaults() -> None:
+    outfit = build_outfit_graph("gothic couture brief")
+
+    assert len(outfit.slots) == len(outfit.slots)  # All slots present
+    assert outfit.score >= 0.68  # Base score
+
+
+def test_build_outfit_graph_adult_mode_marks_upper_lower_slots() -> None:
+    outfit = build_outfit_graph("gothic brief", adult_mode=True)
+    upper = next((s for s in outfit.slots if s.name == "upper_body"), None)
+    lower = next((s for s in outfit.slots if s.name == "lower_body"), None)
+    outerwear = next((s for s in outfit.slots if s.name == "outerwear"), None)
+
+    assert upper is not None and upper.adult_only is True
+    assert lower is not None and lower.adult_only is True
+    assert outerwear is not None and outerwear.adult_only is False

tests/test_exporter.py

@@ -286,25 +286,6 @@ def test_export_packet_redacts_raw_payload_paths_and_secret_like_values(monkeypa
     assert payload["provider_states"]["minicpm"] == "failed"
 
 
-def test_export_packet_redacts_windows_backslash_paths_on_linux(monkeypatch) -> None:
-    monkeypatch.setenv("NEXUS_EXPORT_DIR", "outputs/test-exports")
-    run = build_command_center_run("redaction brief")
-    scan = {
-        "status": "review",
-        "export_gate": "blocked",
-        "findings": [r"raw hidden bytes at C:\Users\speci.000\Downloads\thing.png"],
-        "purification_actions": [],
-    }
-    state = _make_base_state()
-
-    result = write_export_packet(run=run, scan=scan, operator_state=state, adult_mode=False)
-    payload = json.loads(Path(result["path"]).read_text(encoding="utf-8"))
-    serialized = json.dumps(payload)
-
-    assert r"C:\Users\speci.000\Downloads" not in serialized
-    assert "[local_path]/thing.png" in serialized
-
-
 def test_export_packet_records_st3gg_override_reason(monkeypatch) -> None:
     monkeypatch.setenv("NEXUS_EXPORT_DIR", "outputs/test-exports")
     run = build_command_center_run("gothic patent leather platform boots")
@@ -322,3 +303,376 @@ def test_export_packet_records_st3gg_override_reason(monkeypatch) -> None:
         "used": True,
         "reason": "Operator reviewed the ST3GG findings and is writing an audit packet only.",
     }
+
+
+# --- _is_within tests ---
+
+from nexus_visual_weaver.exporter import (
+    _artifact_name,
+    _is_within,
+    _safe_dict,
+    _safe_export_candidate,
+    _safe_provider,
+    _safe_reference_metadata,
+    _safe_scan,
+    _sanitize_text,
+    REPO_ROOT,
+)
+
+
+def test_is_within_returns_true_for_child_path() -> None:
+    root = Path("/some/root")
+    child = Path("/some/root/subdir/file.txt")
+
+    assert _is_within(child, root) is True
+
+
+def test_is_within_returns_false_for_sibling_path() -> None:
+    root = Path("/some/root")
+    sibling = Path("/some/other/file.txt")
+
+    assert _is_within(sibling, root) is False
+
+
+def test_is_within_returns_false_for_parent_path() -> None:
+    root = Path("/some/root/subdir")
+    parent = Path("/some/root")
+
+    assert _is_within(parent, root) is False
+
+
+def test_is_within_returns_false_for_same_path() -> None:
+    root = Path("/some/root")
+    # Same path is not "within" itself (relative_to with same path succeeds but returns empty Path)
+    # _is_within should return True for same path since relative_to doesn't raise
+    result = _is_within(root, root)
+    # Same path: relative_to returns Path('.') or empty - shouldn't raise, returns True
+    assert result is True
+
+
+# --- _artifact_name tests ---
+
+def test_artifact_name_returns_filename_from_unix_path() -> None:
+    assert _artifact_name("/data/nexus_visual_weaver/artifact.png") == "artifact.png"
+
+
+def test_artifact_name_returns_filename_from_windows_path() -> None:
+    assert _artifact_name(r"C:\Users\user\Downloads\artifact.png") == "artifact.png"
+
+
+def test_artifact_name_returns_none_for_none() -> None:
+    assert _artifact_name(None) is None
+
+
+def test_artifact_name_returns_none_for_empty_string() -> None:
+    assert _artifact_name("") is None
+
+
+def test_artifact_name_returns_filename_for_simple_name() -> None:
+    assert _artifact_name("artifact.png") == "artifact.png"
+
+
+# --- _sanitize_text tests ---
+
+def test_sanitize_text_redacts_hf_token() -> None:
+    fake_token = "hf_" + "abcdefghijklmnopqrstuvwxyz1234567"
+    text = f"token is {fake_token}"
+    result = _sanitize_text(text)
+
+    assert fake_token not in result
+    assert "[redacted_secret]" in result
+
+
+def test_sanitize_text_redacts_bearer_token() -> None:
+    fake_token = "sk-test-" + "abcdefghijklmnopqrstu"
+    text = "Authorization: Bearer " + fake_token
+    result = _sanitize_text(text)
+
+    assert fake_token not in result
+
+
+def test_sanitize_text_redacts_credential_names() -> None:
+    text = "Please set MINICPM_API_KEY and NEMOTRON_API_KEY"
+    result = _sanitize_text(text)
+
+    assert "MINICPM_API_KEY" not in result
+    assert "NEMOTRON_API_KEY" not in result
+    assert "[redacted_credential_name]" in result
+
+
+def test_sanitize_text_redacts_windows_paths() -> None:
+    text = "Found at C:\\Users\\user\\Downloads\\artifact.png"
+    result = _sanitize_text(text)
+
+    assert "C:\\Users\\user\\Downloads" not in result
+    assert "[local_path]/artifact.png" in result
+
+
+def test_sanitize_text_redacts_data_paths() -> None:
+    text = "Output stored at /data/nexus_visual_weaver/artifact.png"
+    result = _sanitize_text(text)
+
+    assert "/data/nexus_visual_weaver" not in result
+    assert "[data]/" in result
+
+
+def test_sanitize_text_truncates_to_1000_chars() -> None:
+    long_text = "safe text " * 200
+    result = _sanitize_text(long_text)
+
+    assert len(result) <= 1000
+    assert result.endswith("...")
+
+
+def test_sanitize_text_does_not_truncate_short_text() -> None:
+    short_text = "safe short text without secrets"
+    result = _sanitize_text(short_text)
+
+    assert result == short_text
+
+
+# --- _safe_dict tests ---
+
+def test_safe_dict_drops_sensitive_keys() -> None:
+    data = {
+        "status": "ok",
+        "token": "hf_secretvalue",
+        "api_key": "sk-secretvalue",
+        "message": "clean",
+    }
+    result = _safe_dict(data)
+
+    assert "status" in result
+    assert "message" in result
+    assert "token" not in result
+    assert "api_key" not in result
+
+
+def test_safe_dict_preserves_safe_keys() -> None:
+    data = {"status": "pass", "export_gate": "clear", "extension": ".png"}
+    result = _safe_dict(data)
+
+    assert result == data
+
+
+def test_safe_dict_handles_nested_dicts() -> None:
+    data = {"outer": {"secret": "hidden", "safe_field": "visible"}}
+    result = _safe_dict(data)
+
+    assert "secret" not in result.get("outer", {})
+    assert result["outer"]["safe_field"] == "visible"
+
+
+def test_safe_dict_limits_lists_to_40() -> None:
+    data = list(range(50))
+    result = _safe_dict(data)
+
+    assert len(result) == 40
+
+
+def test_safe_dict_sanitizes_string_values() -> None:
+    data = {"message": "Error: MINICPM_API_KEY not set"}
+    result = _safe_dict(data)
+
+    assert "MINICPM_API_KEY" not in result.get("message", "")
+
+
+def test_safe_dict_preserves_size_bytes_when_allowed() -> None:
+    data = {"size_bytes": 1024, "token": "hf_" + "secret123456789012345"}
+    result = _safe_dict(data, allow_size_bytes=True)
+
+    assert "size_bytes" in result
+    assert result["size_bytes"] == 1024
+    assert "token" not in result
+
+
+def test_safe_dict_drops_size_bytes_by_default() -> None:
+    # "bytes" matches the sensitive key pattern
+    data = {"size_bytes": 1024, "status": "ok"}
+    result = _safe_dict(data)
+
+    assert "size_bytes" not in result
+
+
+def test_safe_dict_returns_non_dict_non_list_unchanged() -> None:
+    assert _safe_dict(42) == 42
+    assert _safe_dict(3.14) == 3.14
+    assert _safe_dict(True) is True
+    assert _safe_dict(None) is None
+
+
+# --- _safe_scan tests ---
+
+def test_safe_scan_extracts_required_fields() -> None:
+    scan = {
+        "status": "pass",
+        "scanner": "ST3GG v2",
+        "export_gate": "clear",
+        "extension": ".png",
+        "magic": "PNG",
+        "findings": ["no issues"],
+        "purification_actions": ["none needed"],
+        "payload_excerpt": "HIDDEN_SENSITIVE_DATA",
+    }
+    result = _safe_scan(scan)
+
+    assert result["status"] == "pass"
+    assert result["scanner"] == "ST3GG v2"
+    assert result["export_gate"] == "clear"
+    assert result["extension"] == ".png"
+    assert result["magic"] == "PNG"
+    assert "payload_excerpt" not in result
+
+
+def test_safe_scan_handles_empty_scan() -> None:
+    result = _safe_scan({})
+
+    assert "status" in result
+    assert "export_gate" in result
+    assert result["status"] is None
+    assert result["export_gate"] is None
+
+
+def test_safe_scan_sanitizes_findings() -> None:
+    scan = {
+        "findings": ["found MINICPM_API_KEY pattern", "raw bytes at C:\\Users\\data\\file.png"],
+    }
+    result = _safe_scan(scan)
+
+    serialized = json.dumps(result)
+    assert "MINICPM_API_KEY" not in serialized
+    assert "C:\\Users\\data" not in serialized
+
+
+# --- _safe_provider tests ---
+
+def test_safe_provider_extracts_fields() -> None:
+    provider = {
+        "status": "success",
+        "provider_state": "configured",
+        "provider": "OpenBMB",
+        "repo_id": "openbmb/MiniCPM-V-4.6",
+        "model": "MiniCPM-V-4.6",
+        "message": "judge returned evidence",
+        "evidence": {"overall_status": "pass"},
+        "latency_seconds": 1.23,
+    }
+    result = _safe_provider(provider)
+
+    assert result["status"] == "success"
+    assert result["provider"] == "OpenBMB"
+    assert result["repo_id"] == "openbmb/MiniCPM-V-4.6"
+    assert result["latency_seconds"] == 1.23
+    assert result["evidence"]["overall_status"] == "pass"
+
+
+def test_safe_provider_handles_none_input() -> None:
+    result = _safe_provider(None)
+
+    assert isinstance(result, dict)
+    assert "status" in result
+    assert result["status"] is None
+
+
+def test_safe_provider_redacts_secret_values_in_evidence() -> None:
+    provider = {
+        "status": "failed",
+        "evidence": {"token_used": "hf_" + "abcdefghijklmnopqrstuvwx", "raw": "sensitive-data"},
+    }
+    result = _safe_provider(provider)
+
+    assert "token_used" not in result["evidence"]
+    assert "raw" not in result["evidence"]
+
+
+def test_safe_provider_handles_non_dict_evidence() -> None:
+    provider = {"status": "success", "evidence": "plain string evidence"}
+    result = _safe_provider(provider)
+
+    # Non-dict evidence should be treated as empty
+    assert result["evidence"] == {}
+
+
+# --- _safe_reference_metadata tests ---
+
+def test_safe_reference_metadata_returns_empty_for_non_list() -> None:
+    assert _safe_reference_metadata(None) == []
+    assert _safe_reference_metadata("string") == []
+    assert _safe_reference_metadata(42) == []
+
+
+def test_safe_reference_metadata_extracts_fields_from_records() -> None:
+    records = [
+        {
+            "source": "upload",
+            "status": "pass",
+            "basename": "C:/Users/user/Downloads/reference.png",
+            "sha256": "a" * 64,
+            "size_bytes": 1024,
+            "st3gg_status": "pass",
+            "export_gate": "clear",
+            "magic": "PNG",
+            "extension": ".png",
+        }
+    ]
+    result = _safe_reference_metadata(records)
+
+    assert len(result) == 1
+    assert result[0]["source"] == "upload"
+    assert result[0]["basename"] == "reference.png"  # Only filename, not full path
+    assert result[0]["sha256"] == "a" * 64
+    assert result[0]["export_gate"] == "clear"
+
+
+def test_safe_reference_metadata_limits_to_20_records() -> None:
+    records = [{"source": "upload", "sha256": str(i)} for i in range(30)]
+    result = _safe_reference_metadata(records)
+
+    assert len(result) == 20
+
+
+def test_safe_reference_metadata_skips_non_dict_records() -> None:
+    records = [{"source": "upload"}, "not a dict", None, {"source": "url"}]
+    result = _safe_reference_metadata(records)
+
+    assert len(result) == 2
+    assert all(isinstance(r, dict) for r in result)
+
+
+def test_safe_reference_metadata_includes_url_fields() -> None:
+    records = [
+        {
+            "source": "url",
+            "status": "metadata_only",
+            "domain": "shop.example.test",
+            "url_hash": "b" * 64,
+        }
+    ]
+    result = _safe_reference_metadata(records)
+
+    assert result[0]["domain"] == "shop.example.test"
+    assert result[0]["url_hash"] == "b" * 64
+
+
+# --- _safe_export_candidate tests ---
+
+def test_safe_export_candidate_accepts_outputs_dir() -> None:
+    candidate = REPO_ROOT / "outputs" / "exports" / "test-subdir"
+    result = _safe_export_candidate(candidate)
+
+    assert result is not None
+    assert "outputs" in str(result)
+
+
+def test_safe_export_candidate_rejects_src_dir() -> None:
+    candidate = REPO_ROOT / "src" / "nexus_visual_weaver" / "exports"
+    result = _safe_export_candidate(candidate)
+
+    assert result is None
+
+
+def test_safe_export_candidate_rejects_src_root_itself() -> None:
+    candidate = REPO_ROOT / "src"
+    result = _safe_export_candidate(candidate)
+
+    assert result is None

tests/test_hf_runtime.py

@@ -4,6 +4,9 @@ from nexus_visual_weaver.hf_runtime import (
     FLUX_REPO_ID,
     PRIVATE_RESEARCH_FLUX_REPO_ID,
     TINY_TITAN_FLUX_REPO_ID,
+    _adapter_recipe,
+    _repo_candidates,
+    active_flux_repo_id,
     default_lora_repo_id,
     generate_flux_image,
     hf_runtime_enabled,
@@ -54,3 +57,155 @@ def test_artifact_lane_embeds_generated_image() -> None:
     assert "nw-preview-real-image" in html
     assert "data:image/png;base64" in html
     assert "Real FLUX.2 Klein artifact" in html
+
+
+# --- active_flux_repo_id tests ---
+
+def test_active_flux_repo_id_defaults_to_9b(monkeypatch) -> None:
+    monkeypatch.delenv("NEXUS_FLUX_REPO_ID", raising=False)
+    monkeypatch.delenv("NEXUS_TINY_TITAN_MODE", raising=False)
+
+    assert active_flux_repo_id() == FLUX_REPO_ID
+
+
+def test_active_flux_repo_id_returns_tiny_titan_when_mode_set(monkeypatch) -> None:
+    monkeypatch.delenv("NEXUS_FLUX_REPO_ID", raising=False)
+    monkeypatch.setenv("NEXUS_TINY_TITAN_MODE", "1")
+
+    assert active_flux_repo_id() == TINY_TITAN_FLUX_REPO_ID
+
+
+def test_active_flux_repo_id_returns_configured_repo_id(monkeypatch) -> None:
+    monkeypatch.setenv("NEXUS_FLUX_REPO_ID", "custom/flux-model")
+    monkeypatch.delenv("NEXUS_TINY_TITAN_MODE", raising=False)
+
+    assert active_flux_repo_id() == "custom/flux-model"
+
+
+def test_active_flux_repo_id_configured_env_overrides_tiny_titan(monkeypatch) -> None:
+    monkeypatch.setenv("NEXUS_FLUX_REPO_ID", "custom/flux-model")
+    monkeypatch.setenv("NEXUS_TINY_TITAN_MODE", "1")
+
+    # Configured env takes precedence over TINY_TITAN_MODE
+    assert active_flux_repo_id() == "custom/flux-model"
+
+
+# --- _repo_candidates tests ---
+
+def test_repo_candidates_includes_primary_and_tiny_titan_fallback(monkeypatch) -> None:
+    monkeypatch.delenv("NEXUS_DISABLE_TINY_TITAN_FALLBACK", raising=False)
+
+    candidates = _repo_candidates(FLUX_REPO_ID)
+
+    assert candidates[0] == FLUX_REPO_ID
+    assert TINY_TITAN_FLUX_REPO_ID in candidates
+    assert len(candidates) == 2
+
+
+def test_repo_candidates_only_primary_when_tiny_titan_is_primary(monkeypatch) -> None:
+    monkeypatch.delenv("NEXUS_DISABLE_TINY_TITAN_FALLBACK", raising=False)
+
+    candidates = _repo_candidates(TINY_TITAN_FLUX_REPO_ID)
+
+    assert candidates == [TINY_TITAN_FLUX_REPO_ID]
+
+
+def test_repo_candidates_only_primary_when_fallback_disabled(monkeypatch) -> None:
+    monkeypatch.setenv("NEXUS_DISABLE_TINY_TITAN_FALLBACK", "1")
+
+    candidates = _repo_candidates(FLUX_REPO_ID)
+
+    assert candidates == [FLUX_REPO_ID]
+
+
+def test_repo_candidates_first_is_always_primary(monkeypatch) -> None:
+    monkeypatch.delenv("NEXUS_DISABLE_TINY_TITAN_FALLBACK", raising=False)
+
+    for repo_id in [FLUX_REPO_ID, "other/model"]:
+        candidates = _repo_candidates(repo_id)
+        assert candidates[0] == repo_id
+
+
+# --- _adapter_recipe tests ---
+
+def test_adapter_recipe_returns_none_for_none_input() -> None:
+    assert _adapter_recipe(None) is None
+
+
+def test_adapter_recipe_returns_none_for_unknown_repo_id() -> None:
+    assert _adapter_recipe("nonexistent/unknown-repo") is None
+
+
+def test_adapter_recipe_returns_recipe_for_known_repo_id() -> None:
+    result = _adapter_recipe("DeverStyle/Flux.2-Klein-Loras")
+
+    assert result is not None
+    assert result.repo_id == "DeverStyle/Flux.2-Klein-Loras"
+
+
+def test_adapter_recipe_returns_recipe_for_4b_outpaint() -> None:
+    result = _adapter_recipe("fal/flux-2-klein-4B-outpaint-lora")
+
+    assert result is not None
+    assert result.requires_image is True
+
+
+# --- HFGenerationResult disabled path lora fields tests ---
+
+def test_generate_flux_image_disabled_includes_lora_repo_id(monkeypatch) -> None:
+    monkeypatch.setenv("NEXUS_DISABLE_REAL_HF", "1")
+    monkeypatch.delenv("NEXUS_FLUX_REPO_ID", raising=False)
+    monkeypatch.delenv("NEXUS_TINY_TITAN_MODE", raising=False)
+
+    result = generate_flux_image("test prompt")
+
+    assert result.status == "disabled"
+    assert result.lora_status == "disabled"
+    # Default lora_repo_id should be the DeverStyle adapter for the 9B model
+    assert result.lora_repo_id == "DeverStyle/Flux.2-Klein-Loras"
+
+
+def test_generate_flux_image_disabled_includes_fallback_used_false(monkeypatch) -> None:
+    monkeypatch.setenv("NEXUS_DISABLE_REAL_HF", "1")
+
+    result = generate_flux_image("test prompt")
+
+    assert result.fallback_used is False
+    assert result.primary_error is None
+
+
+def test_generate_flux_image_tiny_titan_mode_uses_4b_repo_id(monkeypatch) -> None:
+    monkeypatch.setenv("NEXUS_DISABLE_REAL_HF", "1")
+    monkeypatch.setenv("NEXUS_TINY_TITAN_MODE", "1")
+
+    result = generate_flux_image("test prompt")
+
+    assert result.status == "disabled"
+    assert result.repo_id == TINY_TITAN_FLUX_REPO_ID
+
+
+def test_generate_flux_image_disabled_uses_lora_message() -> None:
+    import os
+    os.environ["NEXUS_DISABLE_REAL_HF"] = "1"
+    try:
+        result = generate_flux_image("test prompt")
+        assert "LoRA loading requires" in result.lora_message
+    finally:
+        del os.environ["NEXUS_DISABLE_REAL_HF"]
+
+
+# --- default_lora_repo_id tests ---
+
+def test_default_lora_repo_id_returns_none_for_unknown_model() -> None:
+    result = default_lora_repo_id("unknown/nonexistent-model")
+    assert result is None
+
+
+def test_default_lora_repo_id_excludes_requires_image_adapters() -> None:
+    # fal/flux-2-klein-4B-outpaint-lora requires_image=True, so it should be excluded
+    result = default_lora_repo_id("black-forest-labs/FLUX.2-klein-4B")
+    # DeverStyle/Flux.2-Klein-Loras is compatible with 4B via compatible_repo_ids
+    assert result is not None
+    recipe_result = _adapter_recipe(result)
+    assert recipe_result is not None
+    assert recipe_result.requires_image is False

tests/test_lora_adapter.py

@@ -1,4 +1,11 @@
-from nexus_visual_weaver.lora_adapter import load_and_apply, unload_all
+from nexus_visual_weaver.lora_adapter import (
+    _short_error,
+    _status,
+    adapter_to_dict,
+    is_compatible,
+    load_and_apply,
+    unload_all,
+)
 from nexus_visual_weaver.schema import AdapterRecipe
 
 
@@ -94,3 +101,277 @@ def test_unload_all_uses_pipeline_unload_hook() -> None:
     unload_all(pipe)
 
     assert pipe.unloaded is True
+
+
+def test_unload_all_handles_pipes_without_unload_method() -> None:
+    # UnsupportedPipe has no unload_lora_weights method, should not raise
+    pipe = UnsupportedPipe()
+    unload_all(pipe)  # Should complete without error
+
+
+def test_unload_all_silences_exceptions() -> None:
+    class RaisingPipe:
+        def unload_lora_weights(self) -> None:
+            raise RuntimeError("unload failed")
+
+    unload_all(RaisingPipe())  # Should not raise
+
+
+# --- _status tests ---
+
+def test_status_returns_dict_with_status_field() -> None:
+    result = _status("disabled")
+
+    assert result["status"] == "disabled"
+    assert result["repo_id"] is None
+    assert result["adapter_for"] is None
+    assert result["weight"] is None
+
+
+def test_status_with_recipe_extracts_recipe_fields() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/style-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        weight=0.6,
+    )
+    result = _status("loaded", recipe)
+
+    assert result["repo_id"] == "example/style-lora"
+    assert result["adapter_for"] == "black-forest-labs/FLUX.2-klein-9B"
+    assert result["weight"] == 0.6
+
+
+def test_status_with_extra_kwargs_included() -> None:
+    result = _status("loaded", message="Adapter applied.", adapter_name="nexus_style")
+
+    assert result["message"] == "Adapter applied."
+    assert result["adapter_name"] == "nexus_style"
+
+
+# --- _short_error tests ---
+
+def test_lora_short_error_includes_class_name() -> None:
+    exc = ValueError("bad input")
+    result = _short_error(exc)
+
+    assert result.startswith("ValueError:")
+    assert "bad input" in result
+
+
+def test_lora_short_error_truncates_at_240() -> None:
+    exc = RuntimeError("x" * 300)
+    result = _short_error(exc)
+
+    # Should be truncated
+    assert len(result) <= len("RuntimeError: ") + 240
+    assert result.endswith("...")
+
+
+def test_lora_short_error_collapses_newlines() -> None:
+    exc = OSError("line one\nline two")
+    result = _short_error(exc)
+
+    assert "\n" not in result
+    assert "line one" in result
+
+
+# --- adapter_to_dict tests ---
+
+def test_adapter_to_dict_returns_complete_dict() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/style-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        weight=0.75,
+        license="apache-2.0",
+    )
+    result = adapter_to_dict(recipe)
+
+    assert result["repo_id"] == "example/style-lora"
+    assert result["adapter_for"] == "black-forest-labs/FLUX.2-klein-9B"
+    assert result["task"] == "style"
+    assert result["weight"] == 0.75
+    assert result["license"] == "apache-2.0"
+    assert isinstance(result, dict)
+
+
+def test_adapter_to_dict_includes_all_fields() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/adult-lora",
+        adapter_for="model/base",
+        task="style",
+        adult_only=True,
+        requires_image=True,
+        runtime_enabled=False,
+    )
+    result = adapter_to_dict(recipe)
+
+    assert result["adult_only"] is True
+    assert result["requires_image"] is True
+    assert result["runtime_enabled"] is False
+
+
+# --- is_compatible tests ---
+
+def test_is_compatible_returns_true_for_matching_adapter() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/style-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+    )
+    pipe = FakeLoraPipe()
+
+    assert is_compatible(pipe, recipe, "black-forest-labs/FLUX.2-klein-9B") is True
+
+
+def test_is_compatible_returns_false_for_runtime_disabled() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/style-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        runtime_enabled=False,
+    )
+    pipe = FakeLoraPipe()
+
+    assert is_compatible(pipe, recipe, "black-forest-labs/FLUX.2-klein-9B") is False
+
+
+def test_is_compatible_returns_false_for_adult_only_without_adult_mode() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/adult-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        adult_only=True,
+    )
+    pipe = FakeLoraPipe()
+
+    assert is_compatible(pipe, recipe, "black-forest-labs/FLUX.2-klein-9B", adult_mode=False) is False
+
+
+def test_is_compatible_returns_true_for_adult_only_with_adult_mode() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/adult-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        adult_only=True,
+    )
+    pipe = FakeLoraPipe()
+
+    assert is_compatible(pipe, recipe, "black-forest-labs/FLUX.2-klein-9B", adult_mode=True) is True
+
+
+def test_is_compatible_returns_false_for_requires_image() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/inpaint-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-4B",
+        task="inpaint",
+        requires_image=True,
+    )
+    pipe = FakeLoraPipe()
+
+    assert is_compatible(pipe, recipe, "black-forest-labs/FLUX.2-klein-4B") is False
+
+
+def test_is_compatible_returns_false_for_pipeline_without_lora_support() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/style-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+    )
+
+    assert is_compatible(UnsupportedPipe(), recipe, "black-forest-labs/FLUX.2-klein-9B") is False
+
+
+def test_is_compatible_returns_false_for_incompatible_target() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/style-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+    )
+    pipe = FakeLoraPipe()
+
+    assert is_compatible(pipe, recipe, "completely/different-model") is False
+
+
+def test_is_compatible_returns_true_for_compatible_repo_ids() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/style-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        compatible_repo_ids=["black-forest-labs/FLUX.2-klein-4B"],
+    )
+    pipe = FakeLoraPipe()
+
+    assert is_compatible(pipe, recipe, "black-forest-labs/FLUX.2-klein-4B") is True
+
+
+# --- load_and_apply with adult_only recipe tests ---
+
+def test_load_and_apply_skips_adult_only_in_non_adult_mode() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/adult-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        adult_only=True,
+    )
+    pipe = FakeLoraPipe()
+
+    result = load_and_apply(pipe, recipe, "black-forest-labs/FLUX.2-klein-9B", adult_mode=False)
+
+    assert result["status"] == "skipped_incompatible"
+    assert "Adult Mode is off" in result["message"]
+
+
+def test_load_and_apply_loads_adult_only_in_adult_mode() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/adult-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        adult_only=True,
+    )
+    pipe = FakeLoraPipe()
+
+    result = load_and_apply(pipe, recipe, "black-forest-labs/FLUX.2-klein-9B", adult_mode=True)
+
+    assert result["status"] == "loaded"
+
+
+def test_load_and_apply_skips_requires_image_adapter() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/inpaint-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-4B",
+        task="inpaint",
+        requires_image=True,
+    )
+    pipe = FakeLoraPipe()
+
+    result = load_and_apply(pipe, recipe, "black-forest-labs/FLUX.2-klein-4B")
+
+    assert result["status"] == "skipped_incompatible"
+    assert "image-conditioning" in result["message"]
+
+
+def test_load_and_apply_uses_weight_name_when_present() -> None:
+    recipe = AdapterRecipe(
+        repo_id="example/weight-lora",
+        adapter_for="black-forest-labs/FLUX.2-klein-9B",
+        task="style",
+        weight_name="style_weights.safetensors",
+    )
+    pipe = FakeLoraPipe()
+
+    load_and_apply(pipe, recipe, "black-forest-labs/FLUX.2-klein-9B")
+
+    assert len(pipe.loaded) == 1
+    _, kwargs = pipe.loaded[0]
+    assert kwargs.get("weight_name") == "style_weights.safetensors"
+
+
+def test_load_and_apply_no_recipe_returns_disabled() -> None:
+    pipe = FakeLoraPipe()
+
+    result = load_and_apply(pipe, None, "any/model")
+
+    assert result["status"] == "disabled"
+    assert result["repo_id"] is None