Add files using upload-large-folder tool

.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.pyc
+
+# runtime logs, regenerated on every ComfyUI restart
+comfyui_restart_log.txt
+comfyui_restart_log.txt.err
+*.log
+
+# regenerable local cache
+dolphin_tags_cache.json
+
+# personal/local Claude Code settings (machine-specific)
+.claude/settings.local.json
+
+# isolated musubi-tuner training env (nested git repo + venv, not part of this repo)
+dataset_builder/train/venv/
+dataset_builder/train/musubi_tuner/
+dataset_builder/train/cache/
+dataset_builder/train/output/
+
+# downloadable model weights (YOLO detector for dataset_builder/detect.py, etc.)
+*.pt

HANDOFF.md

@@ -0,0 +1,192 @@
+# Dolphin ComfyUI 노드 프로젝트 — 인수인계
+
+## 프로젝트 목적
+ComfyUI에서 **이미지 1장(또는 텍스트 서사) + 로라 + 필수동작**을 넣으면
+**4개의 연속된 5초 비디오 클립(총 20초)** 을 만드는 커스텀 노드 세트.
+
+비디오 체인은 WAN 2.2 Lightning 기반: `First`(clip1) + `Extend`×3(clip2~4 이어붙이기),
+각 클립마다 TripleKSampler(base/high/low 3스테이지)로 샘플링.
+
+---
+
+## 현재 쓰는 파일 (7개 노드 + 워크플로우)
+
+### 노드 코드 (커스텀 노드 폴더에 넣기)
+1. **`__init__.py`** — 아래 5개 노드를 등록. 각 등록은 개별 try/except.
+2. **`wan_resizer.py`** — `WanNativeResize_Dolphin`. 이미지를 WAN 해상도(480/720/1080P)로 비율 유지 리사이즈 + 정렬(16배수). (원본 그대로, 수정 안 함)
+3. **`promp_logic_v32_story.py`** — `DolphinMultiActionPromptNode_V32`. 텍스트 서사 → LLM이 4샷 프롬프트로 분배. JSON 강제 + 폴백. 모델 프리셋 드롭다운 있음.
+4. **`arch_logic_v16.py`** — `DolphinArchitectV16`. 클립별 LoRA를 model에만 적용(CLIP 로라 연산 제거로 속도↑) → TripleKSampler 공급. 트리거 통합 1출력. 해시 캐싱.
+5. **`dolphin_director.py`** — `DolphinCinematicDirector`. ⚠️ **사실상 고장난 죽은 코드** (2026-07-03 확인). `_llm_split()`는 아무것도 반환하지 않고 호출되지도 않음, `direct()`는 `mode`/LLM 호출을 무시하고 `clips = [master_story] * 4`로 하드코딩, 로라도 전혀 적용 안 함. `__init__.py`엔 등록돼 있지만 실사용 금지 — 쓰려면 사실상 재작성 필요.
+6. **`dolphin_vision_director.py`** — `DolphinVisionDirector`. **최신 주력 노드**. 이미지 직접 인식(VLM) + 필수동작 N샷 분배(`num_clips`) + 클립당 로라 4개(개별 웨이트, on/off 토글) + 트리거 자동 추출/주입.
+7. **`dolphin_prompt_director.py`** — `DolphinPromptDirector` (2026-07-21 신설). `DolphinVisionDirector`와 **완전히 같은 비전+LLM 프롬프트 엔진**을 쓰되 `MODEL`/로라 관련을 전부 제거하고 프롬프트 문자열(`c1~c4_prompt`)만 뽑는 버전. 로직 중복을 피하려고 `DolphinVisionDirector`를 내부에서 인스턴스화해 `_vision_analyze`/`_plan_shots`/`_local_split`/`_build_final` 등 로라를 안 건드리는 순수 메서드만 위임 호출 — 프롬프트 정책(연속성 규칙 등)을 고치면 `dolphin_vision_director.py` 한 곳만 고치면 이 노드에도 자동 반영됨. 로라/모델 적용은 `DolphinArchitectV16` 같은 별도 노드에서 처리한다는 전제.
+
+### 워크플로우 JSON
+- **`0705_vision2.json`** — **현재 실사용 중인 최신 워크플로우** (2026-07-03 기준). VisionDirector + JoyCaption(`JC` 노드) 로컬 캡션 우선 사용, `Model Loader`(f9a6f9ae 서브그래프)에서 lightx2v rank256 + SVI_v2_PRO rank128 사전 적용 → DolphinVisionDirector에서 클립별 PENISLORA(rank32) 패치 → ModelSamplingSD3 → NAG → TripleKSamplerWan22LightningAdvanced(First/Extend). 61개 노드, 서브그래프 16개.
+- `0705_vision.json` — vision2 이전 버전.
+- `0705_director.json` — CinematicDirector(텍스트) 버전. 위 5번 참고 — 노드 자체가 고장나 있어 이 워크플로우도 실동작 안 함.
+- `0705_optimized.json` — V32 + Architect V16 분리형 버전.
+(원본은 사용자가 처음 올린 `0705.json`. API 키는 vision/director/optimized 등 배포용 JSON에선 비워두는 게 원칙이나, `0705_vision2.json`은 사용자 로컬 작업본이라 실키가 들어있음 — 아래 "미해결" 참고.)
+
+---
+
+## DolphinVisionDirector 상세 (주력 노드)
+
+### 입력
+- `image` (IMAGE) — WanNativeResize 출력에서
+- `model_base / model_high / model_low` (MODEL) — Model Loader에서
+- `essential_actions` — **필수 동작만** 콤마로. LLM이 이걸 N샷으로 분배.
+- `num_clips` (2026-07-03 추가) — `"4 (20s)"`/`"3 (15s)"`/`"2 (10s)"`, 기본 4. 실제 렌더링/저장될 클립 수를 여기서 단일 결정 (아래 "클립 개수 중앙 제어" 참고).
+- `character_name` (AUTO면 LLM이 작명), `artistic_vibe`, `pacing`, `detail_level`
+- `inject_triggers`(토글), `use_vision`(토글)
+- `openrouter_api_key`
+- `vlm_preset` + `vlm_model` — 비전 모델 (기본 Qwen2.5-VL 72B)
+- `llm_preset` + `llm_model` — 텍스트 분배 모델 (기본 DeepSeek V3.2)
+- `creativity`, `seed`
+- 로라: **`c{1..4}_lora_{1..3}`** (드롭다운) + **`c{1..4}_w_{1..3}`** (웨이트 문자열 `"base, high, low"`)
+- `manual_triggers`
+
+### 출력 (23개, 2026-07-03 기준)
+- `c1_base, c1_high, c1_low, c1_prompt` × 4클립 (16개) — `num_clips`보다 큰 클립은 base/high/low가 `ExecutionBlocker(None)`
+- `triggers` — 사용된 모든 로라 트리거 통합
+- `scene_analysis` — VLM이 이미지에서 읽은 앵커
+- `debug_info`
+- `c1_is_final, c2_is_final, c3_is_final, c4_is_final` (2026-07-03 추가) — `c == num_clips`인 클립만 True. 각 단계별 VideoCombine의 `save_output` 입력에 연결해서 선택한 길이만 저장되게 함.
+
+### 로라 웨이트 규칙 (스크린샷의 Triple Lora Matrix 방식 채택)
+- 로라당 웨이트를 `"base, high, low"` 한 줄로. 예: `0.3, 0.8, 0.0`
+- 값 부족 시 마지막 값으로 채움 (`1.0`→전부 1.0, `0.5, 0.7`→base 0.5/high·low 0.7)
+- **스테이지 분리 로라 지원**: WAN 2.2에서 HIGH 로라는 `0.3, 0.8, 0.0`(low=0), LOW 로라는 `0.0, 0.0, 0.4`(base·high=0)로 나눠 씀. 검증 완료.
+- 웨이트 0인 스테이지는 그 로라를 안 붙임.
+
+### 프롬프트 설계 (사용자 요구 반영 완료)
+- **동작 순서 보존**: essential_actions는 시간순. 뒤 동작은 clip3 후반~clip4에만 (front-loading 금지).
+- **묘사 배제**: 환경/조명/의상/분위기 다 빼고 **동작(신체 움직임)만**.
+- **타임코드 제거**: `[0-1s]` 방식은 WAN I2V에서 노이즈라 뺌.
+- **슬로우모션 방지**: (1) 5초를 연속 동작으로 채움 (2) 속도 어휘(swiftly/rapidly/explosively) (3) "real-time speed, no slow motion, no freeze" 명시.
+- master_scene은 비움(묘사 안 함).
+- 비전 역할은 "묘사"가 아니라 "앵커(캐릭터 상태/자세/환경) 추출"로 좁혀 장황함 억제.
+
+---
+
+## 모델 프리셋 (OpenRouter, NSFW/무삭제 대응)
+
+### 텍스트 LLM (4샷 분배용)
+- `deepseek/deepseek-v3.2` (기본, 무삭제+JSON안정+한국어 좋음) ← 추천
+- `deepseek/deepseek-chat-v3-0324`
+- `anthracite-org/magnum-v4-72b` (표현 자연스러움)
+- `thedrummer/cydonia-24b-v4.1` (경량)
+- `cognitivecomputations/dolphin-mistral-24b-venice-edition:free` (무료)
+- custom 선택 시 텍스트 필드값 사용
+
+### 비전 VLM (이미지 인식용)
+- `qwen/qwen2.5-vl-72b-instruct` (기본, 특수상황 강함) ← 추천
+- `qwen/qwen2.5-vl-32b-instruct` (+ `:free` 무료)
+- `mistralai/mistral-small-3.1-24b-instruct` (Pixtral)
+- `google/gemma-3-27b-it`
+
+이미지 전송: ComfyUI IMAGE 텐서 → JPEG base64 data URI → OpenRouter `image_url` content block. (PIL 필요, ComfyUI 기본 포함)
+
+---
+
+## 미해결 / 다음에 할 수 있는 것
+
+### 다음 세션 최우선 확인 사항 (2026-07-03 세션 종료 시점)
+1. **`lightning_steps` 8→4 수정 실사용 검증** — 슬로우모션 증상의 유력 원인으로 지목하고 고쳤지만(아래 3번 상세), 아직 실제 렌더로 개선 확인 안 함. ComfyUI는 이미 재시작됨(코드 변경 반영 완료), 워크플로우만 새로고침해서 한 번 돌려볼 것.
+2. **`num_clips`/`Extend range` 관계 숙지** — `num_clips`가 이제 유일한 클립 개수 컨트롤. "Extend range"(Fast Groups Bypasser) 토글은 **절대 건드리지 말 것**(구 방식과 충돌).
+3. ~~`openrouter_api_key` 평문 제거~~ **완료(2026-07-21)** — 아래 6번 참고.
+4. **git 저장소 신설(2026-07-21)** — `dolphin_nodes`에 로컬 git 초기화 + 현재 상태 전체(코드/워크플로우/`old/`/`.bak_*`) 첫 커밋 완료. 앞으로 파일 수정 전 `.bak_*`/`_v조` 파일 복사하는 습관은 그만두고 `git commit`으로 대체할 것. `old/` 폴더와 17개 `.bak_*` 파일은 이제 git 히스토리로도 안전하게 보존돼 있으니, 폴더 정리(삭제)는 다음 세션에서 사용자 확인 후 진행 가능.
+
+1. **NSFW 비전 모델 (해결)** — `0705_vision2.json`은 로컬 JoyCaption(`JC` 노드, `vision_caption` 입력)으로 OpenRouter VLM을 우회 중. `use_vision` 위젯은 **재확인 결과 이미 `true`(ON)로 켜져 있음** — JoyCaption이 성공하면 `vision_caption`을 우선 쓰고 VLM 호출 자체가 안 일어나지만, JoyCaption이 실패/빈 응답이면 이제 안전망으로 OpenRouter VLM 폴백이 작동함. 실행 로그(`debug_info`)에서도 `vlm=vision ok (local caption node)`로 정상 확인됨.
+   - 클라우드 무삭제+이미지 동시지원 모델은 여전히 드묾(Qwen2.5-VL이 그나마 관대). 완전 로컬 VLM 전환은 대안 B로 남아있음(현재는 JoyCaption 로컬 캡션으로 사실상 우회 중이라 급하지 않음).
+
+2. **로라 드롭다운 검색/필터** — 노드 코드로 불가. ComfyUI 프론트엔드 기능이라 ComfyUI 업데이트로 해결하거나 rgthree-comfy 설치 필요.
+
+3. **슬로우모션/연기 일관성**:
+   - **클립 "안"의 슬로우모션 (2026-07-03 원인 특정, 수정 적용함 — 실사용 검증 아직)**: 로라 파일명(`Wan_2_2_I2V_A14B_HIGH/LOW_lightx2v_4step_lora_...`, 그 외 D:/sd/models/loras의 다른 Lightning 로라들도 전부 "4step/4steps")이 전부 **총 4스텝 증류**를 명시하는데, 워크플로우의 TripleKSampler 4개(clip1~4, node 532/484/480/1077) 전부 `lightning_steps=8`(HIGH 4 + LOW 4, 50% 지점 분할)로 설정돼 있었음 — 증류 스텝의 **정확히 2배**. 증류된 Lightning 모델에 계산보다 많은 스텝을 쓰면 스케줄을 벗어나서 동작이 억눌리고 뭉개지는(슬로우모션처럼 보이는) 현상이 흔함. **`lightning_steps`를 4개 노드 전부 8→4로 변경 완료**(��업: `0705_vision2.json.bak_20260703_before_lightningsteps`). 나머지 값(sigma_shift=5, switch_strategy="50% of steps" 등)은 그대로 — 2 HIGH + 2 LOW로 재분배됨. **다음 세션에서 실제 렌더로 개선 여부 확인 필요**.
+     - 참고로 조사 중 "외부 ModelSamplingSD3 서브그래프(shift=5) + TripleKSampler 자체 내부 sigma_shift=5 이중 적용" 가설도 검토했으나, `comfy/model_sampling.py`의 `set_parameters()`가 매번 새 model_sampling 객체로 완전히 덮어쓰는 방식이라 **이중 적용해도 누적 안 됨**(같은 값으로 두 번 걸면 한 번 건 것과 동일) — 이건 범인 아님, 낭비적이지만 무해한 중복이라 안 건드림.
+   - **클립 "사이" 연속성(2026-07-03 해결)**: `_plan_shots` 시스템 프롬프트에 rule 3 "INTER-CLIP CONTINUITY" 추가 — clip_N이 clip_(N-1) 끝난 자세/모멘텀에서 이어서 시작하도록 명시. I2V 프레임 체인(마지막 프레임 그대로 다음 클립 시작)은 원래도 있었지만, 텍스트 프롬프트가 그 연속성을 언급 안 해서 "따로 노는 동작"처럼 보일 수 있었던 gap을 메움. 실사용 검증은 아직 안 함 — 다음 세션에서 4클립 이어보고 확인 필요.
+
+4. **동일 로라 중복 로딩** — 4클립 같은 로라면 4번 패치(클립별 유연성 위한 의도적 트레이드오프). 캐싱 최적화 가능하나 미적용.
+
+5. `dolphin_director.py`(텍스트 버전) — 위 "현재 쓰는 파일" 참고, 로라 방식 통일 이전에 **노드 자체가 동작하지 않음**. 재작성하거나 `__init__.py`에서 등록 제거할지 결정 필요.
+
+6. **`0705_vision2.json` 워크플로우 정리 항목 (2026-07-03 감사)**:
+   - ~~`use_vision` OFF → ON 권장~~ **재확인 결과 이미 `true`로 바뀌어 있었음** (핸드오프 기록이 낡았던 것, 실제 위젯값 재확인 완료).
+   - ~~죽은 `StringConcatenate` 노드(id 1062)~~ **이미 삭제돼 있음** (재확인 완료).
+   - ~~`openrouter_api_key` 위젯에 여전히 실키가 평문 저장돼 있음~~ **해결됨(2026-07-21)**: 키를 Windows User 환경변수 `OPENROUTER_API_KEY`로 옮기고, `0705_vision2.json` + 모든 `.bak_*` + `v30.json` + 중복본(`0705_vision2 (1).json`)에서 키 문자열 전부 제거 후 git 커밋(그래서 git 히스토리에도 안 들어감). `resolve_api_key()`가 위젯 비어있으면 자동으로 env var 사용. ComfyUI도 새 env var 반영을 위해 재시작함 — **다음 세션에서 debug_info가 `vlm=no api key`로 뜨진 않는지만 확인하면 끝**.
+   - `triggers` 출력 포트 미연결(디버깅용, 급하지 않음).
+
+7. **검증 완료 (2026-07-03) — 더 이상 의심 안 해도 됨**:
+   - **로라 인젝션 체인 전수 확인**: `Model Loader`(553) → `DolphinVisionDirector`(1086) → `ModelSamplingSD3` → `NAG` → `TripleKSamplerWan22LightningAdvanced`(First/Extend) 까지 4클립 전부 끊김/교차배선 없이 연결됨. 파일 경로 전부 실재, weight 0/None 오류 없음. 실행 로그(`comfyui_restart_log.txt`)에도 트리거워드 `PENISLORA` 주입 확인됨.
+   - **lightx2v는 이미 rank256으로 적용 중** (HIGH/LOW 둘 다, weight 1.0), SVI_v2_PRO rank128과 스택. `model_base`(stage1)엔 lightx2v 미적용(의도된 설계 — stage1은 non-lightning 풀스텝), `model_high`/`model_low`(stage2/3)에만 적용.
+   - PENISLORA HIGH(e320)/LOW(e496)는 rank32 (안전텐서 텐서 shape로 직접 확인).
+
+---
+
+## 최근 수정 이력 (dolphin_vision_director.py)
+
+### 2026-07-03 세션
+- **`_plan_shots` 에러 삼킴 버그 수정**: LLM 4샷 분배 API 호출 실패 시 실제 원인(HTTP 코드/본문, 예외 타입, 불완전 JSON)이 `last` 변수에만 담기고 버려져서 `debug_info`엔 항상 "⚠️ plan failed"만 찍혔음. 이제 원인이 그대로 `debug_info`/콘솔에 남음.
+- **API 키 환경변수 폴백 추가**: `resolve_api_key()` 함수 — `openrouter_api_key` 위젯이 비어있으면 `OPENROUTER_API_KEY` 환경변수 사용. 기존 위젯에 키가 있으면 동작 그대로(하위호환), 워크플로우 JSON에 실키를 안 박아둬도 되게 하려는 목적.
+- **클립 간 물리적 연속성 규칙 추가** (`_plan_shots` 시스템 프롬프트): 새 rule 3 "INTER-CLIP CONTINUITY" — clip_N은 clip_(N-1)이 끝난 정확한 신체 위치/모멘텀에서 이어서 시작(단, "continuing from" 같은 연결 문구를 텍스트에 직접 쓰는 건 금지 — 물리적 일관성만 지키고 "동작만 쓴다" 규칙과 안 부딪히게). 기존 rule 2(clip_1은 이미지 속 자세에서 시작)는 clip_1에만 적용됐던 걸 clip_2~4로 확장한 셈. 규칙 번호 3~8이 4~9로 밀림(내부 상호참조도 전부 갱신됨).
+- **미사용 데드코드 제거**: `_fallback_name_deterministic` (호출부 없음, 주석에도 "미사용"이라 표시돼 있었음).
+- **백업**: 위 변경 전 버전을 `old/dolphin_vision_director_pre_continuity_20260702.py`에 저장.
+- **`0705_vision2.json` 전수 감사** + **���라 인젝션 체인 전수 검증** — 상세는 위 "미해결" 6번/7번 항목 참고.
+- **ComfyUI 재시작 완료**: 기존 프로세스(PID 5452) 종료 후 동일 실행 옵션(`--enable-dynamic-vram --use-sage-attention --output-directory D:\sd\output`)으로 재기동, `dolphin_nodes` 에러 없이 로드 확인, `DolphinVisionDirector` API 등록 확인. 재시작 로그는 `comfyui_restart_log.txt`(stdout) / `comfyui_restart_log.txt.err`(stderr, 진행상황 대부분 여기).
+- 문법 컴파일(`py_compile`) 확인 완료. **아직 실제 4클립 생성 재실행으로 rule 3 효과는 검증 안 함** — 다음 세션 우선 확인 사항.
+
+### 2026-07-03 세션 (이어서) — 메모리 정리 / 클립 개수 중앙 제어 / 속도 실험
+
+**1. VRAM 정리 자동화 (해결)**
+- 증상: 워크플로우 실행 후 VRAM이 절반쯤 계속 점유된 채 안 비워짐. 원인은 버그가 아니라 ComfyUI의 정상 캐싱 동작(다음 실행 빠르게 하려고 마지막 쓴 모델을 VRAM에 남겨둠) — 다만 이걸 강제로 비워주는 노드가 그래프에 없었음.
+- 이미 설치돼 있던 `comfyui_memory_cleanup` 커스텀 노드(`VRAMCleanup`, 표시명 "🎈VRAM-Cleanup")를 최종 저장 노드(`VHS_VideoCombine` id 487)의 출력에 연결(node 1092, `offload_model=True, offload_cache=True`) → 렌더 끝나면 자동으로 `unload_all_models()` + `soft_empty_cache()` 실행됨. 위치는 First-I2V bypass 그룹 박스 안에 잘못 들어갔던 걸 나중에 밖으로 재배치함(그룹 좌표 [3450, -509]로 이동, 어떤 그룹에도 안 걸리게).
+- 트레이드오프: 다음 생성 시작 시 모델을 디스크에서 다시 로드해야 해서 첫 스텝 전 로딩 시간이 늘어남.
+
+**2. 클립 개수(10s/15s/20s) 중앙 제어 — `DolphinVisionDirector`가 단일 컨트롤 포인트 (해결)**
+- 처음엔 워크플로우에 이미 있던 "Extend range"(rgthree `Fast Groups Bypasser`, node 332) 토글로 clip3/4 렌더를 스킵하는 방식을 검토했으나, 이 노드는 **순수 프론트엔드 전용**(백엔드 미등록, `RgthreeBaseVirtualNode`)이라 다른 노드가 프로그래밍적으로 제어 불가 + `num_clips`와 별도로 수동 동기화해야 하는 문제가 있어서 폐기.
+- 대신 `DolphinVisionDirector`에 `num_clips` 위젯(`"4 (20s)"`/`"3 (15s)"`/`"2 (10s)"`, 기본 4, 하위호환) 추가. `_split_actions_to_clips`/`_plan_shots`(LLM 시스템 프롬프트+JSON 스키마)/`_local_split`(폴백) 전부 클립 개수에 맞춰 동적으로 동작하도록 일반화(마지막 동작=마지막 클립 규칙, 연속성 규칙 모두 N클립 대응). num_clips보다 큰 클립 인덱스는 essential_actions 배분에서 제외되고, 마지막 실사용 클립 내용을 반복해서 채움(안전장치).
+- **실제 렌더 스킵은 ComfyUI 네이티브 `ExecutionBlocker`로 구현** (`from comfy_execution.graph_utils import ExecutionBlocker`): `num_clips`보다 큰 클립의 `c{N}_base/high/low` 출력에 `ExecutionBlocker(None)`을 반환 → 그 아래 `ModelSamplingSD3→NAG→TripleKSampler→해당 클립 VideoCombine` 체인 전체가 연산 없이 자동 스킵됨(서브그래프 내부는 안 건드림 — DolphinVisionDirector가 top-level에서 서브그래프 인스턴스로 모델을 넘기는 구조라 출력 쪽만 바꾸면 됨).
+- **정확한 길이만 저장**: 새 BOOLEAN 출력 4개 `c1_is_final~c4_is_final`(RETURN_TYPES/NAMES 19→23개로 확장, `direct()`가 `c == n_clips`로 계산) 추가 → 각 단계별 `VHS_VideoCombine`(1091=5s/456=10s/464=15s/487=20s)의 `save_output` 위젯을 입력으로 변환(convert widget to input, `frame_rate`가 이미 이렇게 돼있던 패턴 재사용)해서 연결. 실행되지만 최종이 아닌 중간 클립은 미리보기로만 남고, `num_clips`가 선택한 길이 딱 하나만 디스크에 저장됨. 각 VideoCombine 파일명도 `_5s/_10s/_15s/_20s` 접미사로 구분해둠(예전엔 `Wan2`라는 구분 안 되는 접두사였음).
+- "Extend range" 노드는 이제 완전히 불필요 — **토글을 절대 건드리지 말 것**(건드리면 옛날 bypass 방식과 새 ExecutionBlocker 로직이 충돌해서 혼란스러운 결과 가능). 삭제할지는 미결정, 일단 놔둠.
+- 백업 다수: `0705_vision2.json.bak_20260703_before_vramcleanup`, `..._before_torchcompile`, `..._before_numclips`, `..._before_isfinal_wiring`, `..._before_torchcompile_revert`, `..._before_lightningsteps`.
+
+**3. 속도 실험 — 둘 다 실익 없어서 원복/포기**
+- **torch.compile**: `TorchCompileModel` 노드 3개(base/high/low, 클립당 1회만 컴파일되게 Model Loader 출력 쪽에 배치)로 테스트 → 실행 로그에 `torch._dynamo hit config.recompile_limit (8)` 반복(원인: `attention_sage`와 WAN 모델 forward의 `tensor_shape` 속성 접근이 dynamo가 추적하기 어려운 커스텀 텐서 서브클래스라 매번 재컴파일 필요 → 8회 만에 조용히 eager 폴백). 컴파일 이득 0, 오히려 실패 컴파일 시도로 시간 낭비 ��� **노드 3개 제거, 원래 직결 배선 복원함**.
+- **SageAttention 3 (Blackwell/RTX5090 전용, FP4 텐서코어, 논문상 RTX5090 5x/비디오모델 end-to-end 약 3x)**: 소스 빌드 시도했으나 순서대로 3개 문제 부딪힘 — ① PyTorch(cu130)와 시스템 nvcc(12.8) 메이저 버전 불일치(→ `torch.utils.cpp_extension._check_cuda_version` 몽키패치로 우회 성공) ② Windows `MAX_PATH`(260자) 초과로 CUTLASS 헤더를 못 찾음(→ `C:\sage3build`처럼 짧은 경로로 재클론해서 해결) ③ **CUTLASS 템플릿(`BlockScaledConfig::LayoutSF`/`SfAtom`)에서 MSVC C2061 컴파일 에러** — CUTLASS 버전을 sageattn3 코드 작성 시점(2026-01-14 커밋)까지 맞춰봐도 동일 에러 재현, 패키지 PyPI 분류자도 `"Operating System :: Unix"`라 애초에 Linux/GCC 전용 개발로 보임 → **MSVC 템플릿 2단계 name lookup 호환성 문제로 결론, 빌드 포기**. 빌드 흔적(`C:\sage3build`, 스크래치 클론) 삭제 완료, `sageattn3`은 site-packages에 설치 안 됨(ComfyUI 환경 무변경).
+  - 참고: KJNodes(`comfyui-kjnodes`)의 `PathchSageAttentionKJ` 노드(`KJNodes/experimental` 카테고리)가 `sageattn3` 모드를 이미 지원하므로, 나중에 WSL2 등 Linux 환경에서 별도로 빌드에 성공하면 **ComfyUI 코어를 안 건드리고** 이 노드만 워크플로우에 추가해서 바로 쓸 수 있음(다만 WSL에서 빌드한 건 Windows 네이티브 Python엔 못 씀 — ComfyUI 자체를 WSL로 옮기는 게 아니라면 의미 없음, 별도의 큰 결정 필요).
+  - 현재 상태: 기존 `sageattention` v2.2.0(cu130torch2.9.0 빌드) 그대로 유지, `--use-sage-attention` 플래그로 정상 작동 중. RTX 5090(sm_120) 전용 커널은 없지만(v2는 sm80/89/90까지) 크래시 없이 잘 돎.
+
+### 3대 버그 수정
+- **① 캐릭터 이름 AUTO로 샘**: 비전 앵커로 동양/서양 판단해 작명하도록 프롬프트 강화 + `_fallback_name()` 안전장치(LLM이 AUTO/빈값 반환 시 앵커 키워드로 이름 선택).
+- **② 마지막 동작을 처음부터 함**: `_split_actions_to_clips()`가 동작을 코드에서 클립별로 미리 배정(마지막 동작은 반드시 clip4), LLM엔 배정표를 못박아 전달. 순서 위반이 최우선 금지 규칙.
+- **③ 트리거워드 안 들어감**: `triggers` 출력 부활 + 클립별 로라 트리거 디버그(`_last_trig_dbg`) 콘솔 출력.
+
+### 비전 진단 강화 (사용자가 "비전 작동 의심" 제기 후)
+- `tensor_to_base64`: PIL/None/인코딩 실패를 명확한 콘솔 에러로. 성공 시 이미지 크기 로그.
+- `_vision_analyze`: VLM 응답 원문/HTTP 에러/빈 응답을 콘솔에 출력.
+- `direct` STEP1: use_vision OFF / no key / no image / encode fail 각각 구체적 debug_v 메시지.
+- **debug_info 출력만 봐도 비전 실패 원인 파악 가능**:
+  - `vlm=no api key` → 키 미입력 (사용자 증상의 유력 원인)
+  - `vlm=vision OFF` → 토글 꺼짐
+  - `vlm=no image` → IMAGE 미연결
+  - `vlm=vision HTTP 400` → VLM 거부(슬러그 오타/NSFW 거부)
+  - `vlm=vision empty response` → 빈 응답
+  - `vlm=vision ok` → 정상
+
+### 진단 결론
+"씬 묘사 없음 + AUTO + 바로 동작" 증상 = 비전+LLM 실패 후 로컬 폴백. **가장 유력한 원인은 openrouter_api_key 미입력**(워크플로우에서 보안상 비워둠). 다음 실행 시 debug_info 확인 필요.
+
+### 프롬프트 정책 (확정)
+- 타임코드([0-1s]) 제거 (WAN 노이즈). 대신 연속동작+속도어휘로 슬로우모션 방지.
+- 묘사(환경/조명/의상) 배제, 동작만. master_scene 비움.
+- 동작 순서 보존, 마지막 동작은 clip4.
+
+---
+
+## 중요 참고
+- **git 저장소 있음 (2026-07-21부터)**: `dolphin_nodes` 자체가 로컬 git 저장소(`git init` 완료, 원격 없음/로컬 전용). 상위 ComfyUI 저장소의 `.gitignore`가 `custom_nodes/`를 통째로 무시해서 이 폴더는 별도 독립 저장소로 관리. `.gitignore`는 `__pycache__/`, 런타임 로그, `dolphin_tags_cache.json`, `.claude/settings.local.json` 제외. 커밋 전 `git status`/`git diff`로 확인 습관화, 새 `.bak_*` 파일 만드는 대신 `git commit` 사용.
+- **위젯 이름이 바뀌면** 기존 저장 워크플로우의 로라 설정이 초기화될 수 있음. VisionDirector는 최근 `_h_clip` 헤더 제거 + `c{c}_lora_{n}` 이름으로 변경됨.
+- 모든 노드: `INPUT_TYPES`의 required 순서 = 함수 시그니처 순서 (ComfyUI 규칙). 수정 시 AST로 일치 검증할 것.
+- 워크플로우 편집 후엔 항상 무결성 체크: dangling_in / backref_mismatch / slot_oob 전부 0이어야 함. (단, `outputs[].links`에 참조된 링크 id가 top-level `links`에도 서브그래프 `definitions.subgraphs[].links`에도 없는 "유령 출력링크"는 정상적으로 존재할 수 있음 — 과거 편집 잔재로, ComfyUI가 로드시 무시하는 것으로 보임. `0705_vision2.json`의 negative prompt 노드(817)/서브그래프(553)에 ~1700개 있었���데 실행엔 지장 없었음.)
+- 원본 `0705.json`의 UUID 노드들은 subgraph (First/Extend/Encode 등). `definitions.subgraphs[]`에 정의가 있고, 인스턴스 노드의 `type` 필드가 그 서브그래프의 `id`(UUID)와 일치.
+- **`0705_vision2.json` LoRA/모델 체인 구조** (디버깅 시 참고): `Model Loader`(553, "f9a6f9ae..." 서브그래프)에서 GGUF 베이스 로드 + lightx2v(rank256) + SVI_v2_PRO(rank128)를 미리 적용해 `MODEL`(slot0, =model_high, lightx2v 있음)/`MODEL_1`(slot1, =model_low, lightx2v 있음)/`MODEL_2`(slot4, =model_base, lightx2v **없음** — stage1은 non-lightning 풀스텝이라 SVI만 적용) 3종을 출력 → `DolphinVisionDirector`가 클립별 캐릭터 로라를 추가 패치 → 클립마다 `ModelSamplingSD3` 서브그래프 → `NAG`(WanVideoNAG) 서브그래프 → `First`/`Extend` 서브그래프 내부 `TripleKSamplerWan22LightningAdvanced`로 도달. 클립1=786/787/453(First), 클립2=791/792/462(Extend), 클립3=793/794/463(Extend), 클립4=1070/1071/1080(Extend) — 각각 ModelSamplingSD3/NAG/샘플러 순. (444는 별개의 "Encode" 서브그래프로 이미지→latent 변환만 담당, 이 모델 체인과 무관.)

_archive/nodes_unregistered/old/__init__.py

@@ -0,0 +1,53 @@
+import traceback
+
+NODE_CLASS_MAPPINGS = {}
+NODE_DISPLAY_NAME_MAPPINGS = {}
+
+# 🔥 KeyError를 물리적으로 불가능하게 만드는 동시 등록 함수
+def register_node(class_name, node_class, display_name):
+    NODE_CLASS_MAPPINGS[class_name] = node_class
+    NODE_DISPLAY_NAME_MAPPINGS[class_name] = display_name
+
+# 1. 리사이즈 노드
+try:
+    from .wan_resizer import WanNativeResize_Dolphin
+    register_node("WanNativeResize_Dolphin", WanNativeResize_Dolphin, "🐬 Wan Native Resize (Dolphin)")
+except Exception as e:
+    print(f"\n❌ [Dolphin] Wan Resizer 로드 실패: {e}")
+
+# 2. 아키텍트 노드 (에러의 주범!)
+try:
+    from .arch_logic import DolphinArchitectV15
+    register_node("DolphinArchitectV15", DolphinArchitectV15, "🐬 Dolphin Architect (V15 - 울트라 슬림 4:4)")
+except Exception as e:
+    print(f"\n❌ [Dolphin] Architect 로드 실패 (arch_logic.py 확인 필요):\n{traceback.format_exc()}")
+
+# 3. V25 오토 시퀀서 노드
+try:
+    from .promp_auto_sequence import DolphinAutoSequencerNode
+    register_node("DolphinAutoSequencerNode", DolphinAutoSequencerNode, "🐬 Dolphin Sequencer (V25 - 무한 타임라인)")
+except Exception as e:
+    print(f"\n❌ [Dolphin] Auto Sequencer 로드 실패: {e}")
+
+# 4. V28 스티칭 노드
+try:
+    from .promp_logic_v28_stitch import DolphinMultiActionPromptNode_V28
+    register_node("DolphinMultiActionPromptNode_V28", DolphinMultiActionPromptNode_V28, "🐬 Dolphin Prompter (V28 - 5초 개별 클립 x 4단 이어붙이기)")
+except Exception as e:
+    print(f"\n❌ [Dolphin] V28 Prompter 로드 실패: {e}")
+
+# 5. [신규] V30 스토리 스플리터 노드
+try:
+    from .promp_logic_v30_story import DolphinMultiActionPromptNode_V30
+    register_node("DolphinMultiActionPromptNode_V30", DolphinMultiActionPromptNode_V30, "🐬 Dolphin Prompter (V30 - 단일 시나리오 분할)")
+except Exception as e:
+    print(f"\n❌ [Dolphin] V30 Prompter 로드 실패: {e}")
+
+# 6. [신규] V31 비전 마스터 노드
+try:
+    from .promp_logic_v31_vision import DolphinMultiActionPromptNode_V31
+    register_node("DolphinMultiActionPromptNode_V31", DolphinMultiActionPromptNode_V31, "🐬 Dolphin Prompter (V31 - Vision Direct / 눈 달린 AI)")
+except Exception as e:
+    print(f"\n❌ [Dolphin] V31 Vision Prompter 로드 실패: {e}")
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

_archive/nodes_unregistered/old/arch_logic.py

@@ -0,0 +1,141 @@
+import os
+import json
+import folder_paths
+import comfy.sd
+import comfy.utils
+from safetensors import safe_open
+import hashlib
+import urllib.request
+
+CACHE_FILE = os.path.join(os.path.dirname(__file__), "dolphin_tags_cache.json")
+
+def load_dolphin_cache():
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except: return {}
+    return {}
+
+def save_dolphin_cache(cache_data):
+    try:
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(cache_data, f, indent=4)
+    except: pass
+
+class DolphinArchitectV15:
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + folder_paths.get_filename_list("loras")
+        
+        res = {
+            "required": {
+                "global_switch": ("BOOLEAN", {"default": True, "label_on": "GLOBAL ON", "label_off": "GLOBAL OFF (SKIP)"}),
+                "model_base": ("MODEL",), "clip_base": ("CLIP",),
+                "model_high": ("MODEL",), "clip_high": ("CLIP",),
+                "model_low": ("MODEL",), "clip_low": ("CLIP",),
+            },
+            "optional": {}
+        }
+
+        # [다이어트 완료] 오직 이름과 웨이트만 남겨서 가장 얇은 UI를 만듭니다.
+        res["optional"]["header_master"] = ("STRING", {"default": "─── [ MASTER: B+H ] ───", "multiline": False})
+        for i in range(1, 5): 
+            res["optional"][f"master_l_{i}"] = (loras, {"default": "None"})
+            res["optional"][f"master_b_w_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01})
+            res["optional"][f"master_h_w_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01})
+            
+        res["optional"]["header_low"] = ("STRING", {"default": "─── [ LOW ONLY ] ───", "multiline": False})
+        for i in range(1, 5): 
+            res["optional"][f"low_l_{i}"] = (loras, {"default": "None"})
+            res["optional"][f"low_w_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01})
+
+        res["optional"]["manual_triggers"] = ("STRING", {"default": "", "multiline": True})
+        return res
+
+    RETURN_TYPES = ("MODEL", "CLIP", "MODEL", "CLIP", "MODEL", "CLIP", "STRING")
+    RETURN_NAMES = ("M_BASE", "C_BASE", "M_HIGH", "C_HIGH", "M_LOW", "C_LOW", "triggers")
+    FUNCTION = "exec"
+    CATEGORY = "Dolphin"
+
+    def get_trig(self, lora_name):
+        if lora_name == "None": return []
+        path = folder_paths.get_full_path("loras", lora_name)
+        if not path or not os.path.exists(path): return []
+        
+        triggers = []
+        try:
+            with safe_open(path, framework="pt", device="cpu") as f:
+                m = f.metadata()
+                if m and "modelspec.trigger_words" in m:
+                    tw = json.loads(m["modelspec.trigger_words"])
+                    if isinstance(tw, list): triggers.extend(tw)
+                    elif isinstance(tw, str): triggers.append(tw)
+        except: pass
+        if triggers: return triggers 
+
+        cache = load_dolphin_cache()
+        if lora_name in cache and cache[lora_name]: return cache[lora_name]
+
+        try:
+            sha256_hash = hashlib.sha256()
+            with open(path, "rb") as f:
+                for byte_block in iter(lambda: f.read(4096 * 1024), b""):
+                    sha256_hash.update(byte_block)
+            
+            url = f"https://civitai.com/api/v1/model-versions/by-hash/{sha256_hash.hexdigest()}"
+            req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+            with urllib.request.urlopen(req, timeout=5) as response:
+                data = json.loads(response.read().decode('utf-8'))
+                api_triggers = data.get("trainedWords", [])
+                if api_triggers:
+                    cache[lora_name] = api_triggers
+                    save_dolphin_cache(cache)
+                    return api_triggers
+        except: pass
+        return triggers
+
+    def exec(self, global_switch, model_base, clip_base, model_high, clip_high, model_low, clip_low, manual_triggers="", **kwargs):
+        mb, cb = model_base, clip_base
+        mh, ch = model_high, clip_high
+        ml, cl = model_low, clip_low
+        
+        if not global_switch:
+            trigs = [t.strip() for t in manual_triggers.split(',') if t.strip()]
+            ut = ", ".join(list(dict.fromkeys(trigs)))
+            return (mb, cb, mh, ch, ml, cl, ut)
+
+        applied_names = []
+
+        for i in range(1, 5): 
+            n = kwargs.get(f"master_l_{i}", "None")
+            w_b = kwargs.get(f"master_b_w_{i}", 1.0)
+            w_h = kwargs.get(f"master_h_w_{i}", 1.0)
+            
+            # [최적화] None이 아니면서, 웨이트가 0.0이 아닐 때만 적용 (0.0이면 스위치 OFF 효과)
+            if n != "None" and (w_b != 0.0 or w_h != 0.0):
+                applied_names.append(n)
+                lora_data = comfy.utils.load_torch_file(folder_paths.get_full_path("loras", n))
+                mb, cb = comfy.sd.load_lora_for_models(mb, cb, lora_data, w_b, w_b)
+                mh, ch = comfy.sd.load_lora_for_models(mh, ch, lora_data, w_h, w_h)
+
+        for i in range(1, 5): 
+            n = kwargs.get(f"low_l_{i}", "None")
+            w = kwargs.get(f"low_w_{i}", 1.0)
+            
+            if n != "None" and w != 0.0:
+                applied_names.append(n)
+                lora_data = comfy.utils.load_torch_file(folder_paths.get_full_path("loras", n))
+                ml, cl = comfy.sd.load_lora_for_models(ml, cl, lora_data, w, w)
+
+        trigs = []
+        for n in set(applied_names):
+            trigs.extend(self.get_trig(n))
+            
+        if manual_triggers.strip():
+            manual_list = [t.strip() for t in manual_triggers.split(',') if t.strip()]
+            trigs.extend(manual_list)
+        
+        unique_trigs = ", ".join(list(dict.fromkeys(trigs)))
+        
+        return (mb, cb, mh, ch, ml, cl, unique_trigs)

_archive/nodes_unregistered/old/dolphin_vision_director_pre_continuity_20260702.py

@@ -0,0 +1,778 @@
+import os
+import re
+import io
+import json
+import base64
+import hashlib
+import sqlite3
+import urllib.request
+import urllib.error
+
+import numpy as np
+import folder_paths
+import comfy.sd
+import comfy.lora
+import comfy.utils
+from safetensors import safe_open
+
+try:
+    from PIL import Image
+    _HAS_PIL = True
+except Exception:
+    _HAS_PIL = False
+
+CACHE_FILE = os.path.join(os.path.dirname(__file__), "dolphin_tags_cache.json")
+
+
+# ======================================================================
+#  모델 프리셋 (텍스트 LLM = 4샷 분배 / 비전 VLM = 이미지 인식)
+# ======================================================================
+LLM_PRESETS = {
+    "🔞 DeepSeek V3.2 (무삭제·JSON안정·추천)": "deepseek/deepseek-v3.2",
+    "🔞 Magnum v4 72B (표현 자연스러움)": "anthracite-org/magnum-v4-72b",
+    "🔞 Cydonia 24B v4.1 (경량·빠름)": "thedrummer/cydonia-24b-v4.1",
+    "🔞 Dolphin Mistral Venice (무료)": "cognitivecomputations/dolphin-mistral-24b-venice-edition:free",
+    "⚙️ custom (아래 텍스트 사용)": "__custom__",
+}
+LLM_PRESET_LABELS = list(LLM_PRESETS.keys())
+
+# 비전 모델: 특수 상황 이해 + 다국어. Qwen2.5-VL 계열이 포즈/맥락 파악에 강함.
+VLM_PRESETS = {
+    "👁 Qwen2.5-VL 72B (특수상황·추천)": "qwen/qwen2.5-vl-72b-instruct",
+    "👁 Qwen2.5-VL 32B (균형)": "qwen/qwen2.5-vl-32b-instruct",
+    "👁 Qwen2.5-VL 32B (무료)": "qwen/qwen2.5-vl-32b-instruct:free",
+    "👁 Mistral Small 3.1 24B (Pixtral)": "mistralai/mistral-small-3.1-24b-instruct",
+    "👁 Gemma 3 27B (경량)": "google/gemma-3-27b-it",
+    "⚙️ custom (아래 텍스트 사용)": "__custom__",
+}
+VLM_PRESET_LABELS = list(VLM_PRESETS.keys())
+
+
+def resolve_slug(table, label, custom_text, default):
+    slug = table.get(label, "__custom__")
+    if slug == "__custom__":
+        return custom_text.strip() or default
+    return slug
+
+
+def resolve_api_key(widget_value):
+    """위젯에 키가 있으면 그대로 사용. 비어있으면 OPENROUTER_API_KEY 환경변수로 폴백.
+    -> 워크플로우 JSON(공유/백업 시 유출 위험)에 실키를 박아둘 필요가 없어짐."""
+    key = (widget_value or "").strip()
+    if key:
+        return key
+    return os.environ.get("OPENROUTER_API_KEY", "").strip()
+
+
+# ======================================================================
+#  캐시 & 트리거 (검증된 로직 재사용)
+# ======================================================================
+def _load_cache():
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def _save_cache(cache):
+    try:
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(cache, f, indent=4, ensure_ascii=False)
+    except OSError:
+        pass
+
+
+def _file_sig(path):
+    st = os.stat(path)
+    return f"{os.path.basename(path)}::{st.st_size}::{int(st.st_mtime)}"
+
+
+def _sha256(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(4096 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+# CivitAI 및 미러(civitaired) 해시 조회 엔드포인트. 앞에서부터 순서대로 시도.
+TRIGGER_HASH_APIS = [
+    "https://civitai.com/api/v1/model-versions/by-hash/{h}",
+    "https://civitaired.com/api/v1/model-versions/by-hash/{h}",
+]
+
+# LoRA Manager(comfyui-lora-manager)가 스캔 시 만들어두는 로컬 SQLite 캐시.
+# sha256으로 trained_words를 즉시 조회 가능 -> 네트워크 호출 없이 트리거워드 확보.
+LORA_MANAGER_DB = os.path.join(
+    os.environ.get("LOCALAPPDATA", ""), "ComfyUI-LoRA-Manager", "cache", "model", "comfyui.sqlite")
+
+
+def _query_lora_manager_db(digest):
+    """LoRA Manager SQLite 캐시에서 sha256으로 trained_words 조회. 실패/미발견 시 None."""
+    if not digest or not os.path.exists(LORA_MANAGER_DB):
+        return None
+    try:
+        uri = f"file:{LORA_MANAGER_DB}?mode=ro"
+        con = sqlite3.connect(uri, uri=True, timeout=3)
+        try:
+            cur = con.cursor()
+            cur.execute(
+                "SELECT trained_words FROM models WHERE model_type='lora' AND sha256=? LIMIT 1",
+                (digest,))
+            row = cur.fetchone()
+        finally:
+            con.close()
+        if not row or not row[0]:
+            return None
+        tw = json.loads(row[0])
+        return tw if isinstance(tw, list) else None
+    except (sqlite3.Error, OSError, ValueError, json.JSONDecodeError) as e:
+        print(f"⚠️ [Director] LoRA Manager DB 조회 실패: {type(e).__name__}: {e}")
+        return None
+
+
+def _query_trigger_api(url):
+    """단일 해시 조회 엔드포인트에서 trainedWords 리스트를 반환. 실패 시 ([], 사유)."""
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req, timeout=8) as r:
+            data = json.loads(r.read().decode('utf-8'))
+            return (data.get("trainedWords", []) or []), None
+    except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError,
+            OSError, ValueError, json.JSONDecodeError) as e:
+        return [], f"{type(e).__name__}: {e}"
+
+
+def get_triggers(lora_name, cache):
+    if lora_name == "None":
+        return []
+    path = folder_paths.get_full_path("loras", lora_name)
+    if not path or not os.path.exists(path):
+        return []
+    try:
+        with safe_open(path, framework="pt", device="cpu") as f:
+            m = f.metadata()
+            if m and "modelspec.trigger_words" in m:
+                tw = json.loads(m["modelspec.trigger_words"])
+                if isinstance(tw, list):
+                    return tw
+                if isinstance(tw, str):
+                    return [tw]
+    except (OSError, ValueError, json.JSONDecodeError):
+        pass
+    try:
+        sig = _file_sig(path)
+    except OSError:
+        sig = lora_name
+    # 캐시에 '비어있지 않은' 결과가 있을 때만 신뢰. 과거에 실패로 저장된 빈 값은
+    # 무시하고 재조회한다 (빈 값 영구화 회귀 방지).
+    cached = cache.get(sig)
+    if cached:
+        return cached
+
+    # 해시는 1회만 계산해서 LoRA Manager DB -> CivitAI -> civitaired 순으로 조회.
+    result, base = [], os.path.basename(path)
+    try:
+        digest = _sha256(path)
+    except OSError as e:
+        print(f"⚠️ [Director] 해시 계산 실패({base}): {e}")
+        digest = None
+    if digest:
+        found = _query_lora_manager_db(digest)
+        if found:
+            print(f"✅ [Director] 트리거 조회 성공({base}) @ LoRA Manager DB: {found}")
+            result = found
+    if digest and not result:
+        for tmpl in TRIGGER_HASH_APIS:
+            host = tmpl.split('/')[2]
+            found, err = _query_trigger_api(tmpl.format(h=digest))
+            if found:
+                print(f"✅ [Director] 트리거 조회 성공({base}) @ {host}: {found}")
+                result = found
+                break
+            print(f"⚠️ [Director] 트리거 조회 실패({base}) @ {host}: {err or 'no trainedWords'}")
+
+    # 성공(비어있지 않음)일 때만 캐싱. 빈 결과는 저장하지 않아 다음 실행에서 재시도됨.
+    if result:
+        cache[sig] = result
+        _save_cache(cache)
+    return result
+
+
+def apply_model_lora(model, lora_data, weight):
+    try:
+        return comfy.sd.load_lora_for_models(model, None, lora_data, weight, 0)[0]
+    except (AttributeError, TypeError):
+        new_model = model.clone()
+        key_map = comfy.lora.model_lora_keys_unet(new_model.model)
+        loaded = comfy.lora.load_lora(lora_data, key_map)
+        new_model.add_patches(loaded, weight)
+        return new_model
+
+
+def tensor_to_base64(image_tensor, max_side=1024):
+    """ComfyUI IMAGE 텐서(B,H,W,C, 0~1 float) 첫 프레임을 JPEG base64 data URI로."""
+    if not _HAS_PIL:
+        print("❌ [Director] PIL(Pillow) 없음 - 비전 불가. `pip install Pillow` 필요.")
+        return None
+    if image_tensor is None:
+        print("❌ [Director] image 입력이 None - IMAGE 연결 확인.")
+        return None
+    try:
+        img = image_tensor
+        if hasattr(img, "cpu"):
+            img = img.cpu().numpy()
+        img = np.asarray(img)
+        if img.ndim == 4:
+            img = img[0]
+        arr = np.clip(img * 255.0, 0, 255).astype(np.uint8)
+        pil = Image.fromarray(arr)
+        w, h = pil.size
+        if max(w, h) > max_side:
+            scale = max_side / float(max(w, h))
+            pil = pil.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
+        buf = io.BytesIO()
+        pil.convert("RGB").save(buf, format="JPEG", quality=90)
+        b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+        print(f"🖼 [Director] image encoded ok: {w}x{h} -> {pil.size}, {len(b64)//1024}KB base64")
+        return f"data:image/jpeg;base64,{b64}"
+    except Exception as e:
+        print(f"❌ [Director] image encode failed: {type(e).__name__}: {e}")
+        return None
+
+
+# ======================================================================
+#  Vision Director: 이미지 인식 + 필수동작 실행 + 클립당 3로라
+# ======================================================================
+class DolphinVisionDirector:
+    """
+    이미지 하나와 '필수 동작'과 로라만 넣으면 4개 연속 클립이 완성되는 올인원 노드.
+
+      1) IMAGE -> 비전 VLM 이 상황(캐릭터 상태/자세/환경)만 앵커로 파악
+      2) 그 맥락 위에서 '내가 준 필수 동작(essential_actions)'만 4샷으로 분배
+      3) 클립마다 로라 3개씩 개별 적용(웨이트도 개별) + 트리거 자동 주입
+
+    핵심: VLM 은 '묘사'가 아니라 '앵커 추출' 역할로 좁혀서 장황함을 억제한다.
+    로라: c{클립}_lora_{n} (c=1..4, n=1..3), 각 슬롯 웨이트는 "base, high, low" 문자열.
+    트리거워드는 사용된 로라에서 자동 추출되어 각 클립 프롬프트에 주입 + triggers 출력으로도 제공.
+    """
+
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + folder_paths.get_filename_list("loras")
+        req = {
+            "image": ("IMAGE",),
+            "model_base": ("MODEL",),
+            "model_high": ("MODEL",),
+            "model_low": ("MODEL",),
+            "essential_actions": ("STRING", {"multiline": True,
+                "default": ("돌진한다, 검을 휘둘러 적을 쓰러뜨린다, 총알을 튕겨낸다, 숨통을 끊는다")}),
+            "character_name": ("STRING", {"default": "AUTO"}),
+            "artistic_vibe": ("STRING", {"multiline": True,
+                                         "default": "cinematic lighting, dynamic motion"}),
+            "pacing": (["auto", "slow-burn (1 beat)", "balanced (multi beat)", "rapid (4 distinct)"],
+                       {"default": "auto"}),
+            "detail_level": (["짧게(간결)", "필수+앵커만", "상세"], {"default": "필수+앵커만"}),
+            "inject_triggers": ("BOOLEAN", {"default": True,
+                                            "label_on": "TRIGGERS ON", "label_off": "TRIGGERS OFF"}),
+            "use_vision": ("BOOLEAN", {"default": True,
+                                       "label_on": "VISION ON", "label_off": "VISION OFF (text only)"}),
+            "openrouter_api_key": ("STRING", {"default": ""}),
+            "vlm_preset": (VLM_PRESET_LABELS, {"default": "👁 Qwen2.5-VL 72B (특수상황·추천)"}),
+            "vlm_model": ("STRING", {"default": "qwen/qwen2.5-vl-72b-instruct"}),
+            "llm_preset": (LLM_PRESET_LABELS, {"default": "🔞 DeepSeek V3.2 (무삭제·JSON안정·추천)"}),
+            "llm_model": ("STRING", {"default": "deepseek/deepseek-v3.2"}),
+            "creativity": ("FLOAT", {"default": 0.7, "min": 0.1, "max": 1.5, "step": 0.05}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+        }
+        opt = {}
+        # 클립당 로라 3개. 헤더 위젯 제거(편집칸이라 혼란). 이름을 명확히:
+        #   c{클립}_lora_{n} (드롭다운) + c{클립}_w_{n} ("base, high, low")
+        for c in range(1, 5):
+            for n in range(1, 4):
+                opt[f"c{c}_lora_{n}"] = (loras, {"default": "None"})
+                opt[f"c{c}_w_{n}"] = ("STRING", {"default": "1.0, 1.0, 1.0", "multiline": False})
+        opt["manual_triggers"] = ("STRING", {"default": "", "multiline": True})
+        # 로컬 캡션 노드(JoyCaption 등)의 STRING 출력을 여기 연결하면 그걸 앵커로 사용하고
+        # OpenRouter VLM 호출을 완전히 건너뛴다 (429/거부 문제 회피). 비워두면 기존
+        # OpenRouter VLM 경로로 자동 폴백 (하위 호환).
+        opt["vision_caption"] = ("STRING", {"multiline": True, "default": "",
+                                            "forceInput": True})
+        return {"required": req, "optional": opt}
+
+    RETURN_TYPES = (
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "STRING", "STRING", "STRING",
+    )
+    RETURN_NAMES = (
+        "c1_base", "c1_high", "c1_low", "c1_prompt",
+        "c2_base", "c2_high", "c2_low", "c2_prompt",
+        "c3_base", "c3_high", "c3_low", "c3_prompt",
+        "c4_base", "c4_high", "c4_low", "c4_prompt",
+        "triggers", "scene_analysis", "debug_info",
+    )
+    FUNCTION = "direct"
+    CATEGORY = "Dolphin"
+
+    # ------------------------------------------------------------------ helpers
+    def _build_final(self, action, master_scene, name, trigger_str):
+        head = ", ".join([p for p in [name, trigger_str] if p])
+        body = " ".join([p for p in [master_scene.strip().strip(",. "), action.strip()] if p])
+        if head and body:
+            return f"{head}\n{body}"
+        return head or body
+
+    def _pacing_hint(self, p):
+        return {
+            "auto": "Decide pacing yourself based on how many distinct beats the actions contain.",
+            "slow-burn (1 beat)": "One climactic beat: clips 1-3 build tension, clip 4 detonates.",
+            "balanced (multi beat)": "Early clips build, later clips deliver; keep motion continuous.",
+            "rapid (4 distinct)": "Four distinct consecutive actions, one per clip, each kinetic.",
+        }.get(p, "Decide pacing yourself.")
+
+    def _detail_hint(self, d):
+        return {
+            "짧게(간결)": "Keep each clip to a short punchy motion phrase. Pure movement verbs only.",
+            "필수+앵커만": "Each clip is one concise continuous motion. No description, only movement.",
+            "상세": "Motion may be described in more detail, but ONLY body movement — no scenery.",
+        }.get(d, "Motion only, no description.")
+
+    def _extract_json(self, text):
+        if not text:
+            return None
+        text = re.sub(r'```(?:json)?', '', text).strip()
+        a, b = text.find('{'), text.rfind('}')
+        if a == -1 or b <= a:
+            return None
+        blob = text[a:b + 1]
+        try:
+            return json.loads(blob)
+        except json.JSONDecodeError:
+            try:
+                return json.loads(re.sub(r',\s*([}\]])', r'\1', blob))
+            except json.JSONDecodeError:
+                return None
+
+    def _call_or(self, messages, model, key, temp, timeout=120, force_json=False):
+        payload = {"model": model.strip(), "messages": messages, "temperature": temp}
+        if force_json:
+            payload["response_format"] = {"type": "json_object"}
+        req = urllib.request.Request(
+            "https://openrouter.ai/api/v1/chat/completions",
+            data=json.dumps(payload).encode('utf-8'),
+            headers={'Authorization': f'Bearer {key}', 'Content-Type': 'application/json'})
+        raw = json.loads(urllib.request.urlopen(req, timeout=timeout).read().decode('utf-8'))
+        # OpenRouter는 실패해도 HTTP 200 + {"error": {...}} 를 줄 때가 있음.
+        # 그 경우 'choices' KeyError로 뭉개지 말고 진짜 원인을 드러낸다.
+        if "choices" not in raw:
+            err = raw.get("error") or raw
+            msg = err.get("message") if isinstance(err, dict) else str(err)
+            code = err.get("code") if isinstance(err, dict) else "?"
+            raise ValueError(f"API error (code={code}): {msg}")
+        return raw['choices'][0]['message']['content'].strip()
+
+
+    # ---- STEP 1: 비전으로 이미지 앵커 추출 ----
+    def _vision_analyze(self, data_uri, vlm_model, key, temp):
+        sys = ("You are a visual scene analyst for a video pipeline. "
+               "Look at the image and extract ONLY concrete anchors, no storytelling. "
+               "Report exactly these lines:\n"
+               "(1) character appearance & clothing.\n"
+               "(2) current pose/posture (sitting, crouched, standing, balance, limb positions).\n"
+               "(3) SUPPORT & CONTACT: what the character is on top of, sitting on, holding, "
+               "leaning against, or touching (e.g. 'seated balanced on a yoga ball', "
+               "'gripping a sword', 'kneeling on the floor'). This is critical for physics — "
+               "state it explicitly even if obvious.\n"
+               "(4) environment & lighting (brief).\n"
+               "Be terse, one short line each. English only. "
+               "Do not invent actions or narrative. If content is mature, describe it plainly and factually.")
+        messages = [
+            {"role": "system", "content": sys},
+            {"role": "user", "content": [
+                {"type": "text", "text": "Extract the anchors from this image."},
+                {"type": "image_url", "image_url": {"url": data_uri}},
+            ]},
+        ]
+        import time
+        last_err = "vision error"
+        for attempt in range(1, 4):  # 429/일시 오류 대비 재시도 + 백오프
+            try:
+                resp = self._call_or(messages, vlm_model, key, temp, timeout=90).strip()
+                if not resp:
+                    print(f"⚠️ [Director] VLM({vlm_model}) 응답이 비었음 (거부 or 빈 반환)")
+                    return "", "vision empty response"
+                print(f"👁 [Director] VLM({vlm_model}) anchors (attempt {attempt}):\n{resp[:300]}")
+                return resp, None
+            except urllib.error.HTTPError as e:
+                body = ""
+                try:
+                    body = e.read().decode('utf-8')[:200]
+                except Exception:
+                    pass
+                print(f"❌ [Director] VLM HTTP {e.code} (attempt {attempt}): {body}")
+                last_err = f"vision HTTP {e.code}"
+                # 429(레이트리밋)/503(과부하)만 재시도. 그 외는 즉시 포기.
+                if e.code in (429, 503) and attempt < 3:
+                    wait = 2 ** attempt  # 2s, 4s
+                    print(f"⏳ [Director] rate limited, {wait}s 후 재시도...")
+                    time.sleep(wait)
+                    continue
+                return "", last_err
+            except (urllib.error.URLError, TimeoutError, KeyError, ValueError) as e:
+                print(f"❌ [Director] VLM error (attempt {attempt}): {type(e).__name__}: {e}")
+                last_err = f"vision error: {e}"
+                if attempt < 3:
+                    time.sleep(2 ** attempt)
+                    continue
+                return "", last_err
+        return "", last_err
+
+    # ---- STEP 2: 앵커 + 필수동작 -> 4샷 JSON ----
+    def _fallback_name(self, anchors):
+        """LLM이 이름을 안 줬을 때 앵커 텍스트의 민족/설정 단서로 이름 선택."""
+        import random
+        a = (anchors or "").lower()
+        east = ["asian", "east asian", "japanese", "korean", "chinese", "anime",
+                "kimono", "hanbok", "qipao", "oriental"]
+        western = ["western", "european", "caucasian", "american", "blonde", "redhead"]
+        east_names = ["Yuna", "Kaede", "Jin", "Mei", "Haruka", "Rin", "Sora", "Aoi"]
+        west_names = ["Elena", "Ryan", "Ava", "Lucas", "Mila", "Ethan", "Nora", "Leo"]
+        if any(k in a for k in east):
+            pool = east_names
+        elif any(k in a for k in western):
+            pool = west_names
+        else:
+            pool = east_names + west_names  # 단서 없으면 혼합
+        return random.choice(pool)
+
+    def _split_actions_to_clips(self, actions):
+        """동작을 파싱해 4클립에 순서대로 배정. 마지막 동작은 반드시 clip4.
+        반환: {1:[동작...], 2:[...], 3:[...], 4:[...]}"""
+        parts = re.split(r'(?<=[.!?。])\s+|[,、]|\n+', actions)
+        parts = [p.strip() for p in parts if len(p.strip()) > 1]
+        if not parts:
+            parts = [actions.strip()]
+        n = len(parts)
+        assign = {1: [], 2: [], 3: [], 4: []}
+        if n == 1:
+            # 단일 동작: 1~3 준비/전개, 4 완결
+            assign[1] = [f"(build-up toward) {parts[0]}"]
+            assign[2] = [f"(begin) {parts[0]}"]
+            assign[3] = [f"(escalate) {parts[0]}"]
+            assign[4] = [parts[0]]
+        elif n <= 4:
+            # 마지막 동작 -> clip4 고정, 나머지를 앞에서부터
+            assign[4] = [parts[-1]]
+            head = parts[:-1]
+            for i, ph in enumerate(head):
+                assign[min(i + 1, 3)].append(ph)
+            # 빈 앞클립은 다음 동작 빌드업
+            for c in range(1, 4):
+                if not assign[c]:
+                    nxt = parts[min(c, n - 1)]
+                    assign[c] = [f"(move toward) {nxt}"]
+        else:
+            # 5개+ : 마지막은 clip4 단독, 나머지 앞 3클립 균등
+            assign[4] = [parts[-1]]
+            rest = parts[:-1]
+            k, m = divmod(len(rest), 3)
+            idx = 0
+            for c in range(1, 4):
+                end = idx + k + (1 if (c - 1) < m else 0)
+                assign[c] = rest[idx:end]
+                idx = end
+        return assign
+
+    def _plan_shots(self, anchors, actions, name, vibe, pacing, detail, llm_model, key, temp, seed):
+        # 코드가 동작을 클립별로 미리 배정 -> LLM 지시에 못박음 (순서 강제)
+        assign = self._split_actions_to_clips(actions)
+        assign_block = "\n".join(
+            f"  clip_{c}: {', '.join(assign[c]) if assign[c] else '(continue previous motion)'}"
+            for c in range(1, 5))
+
+        sys = (
+            "You are an elite fight/action choreographer for a 20-second video made of "
+            "four consecutive 5-second clips. You are given SCENE ANCHORS (the character's "
+            "starting look/pose/place from an image) and a STRICT per-clip action assignment.\n"
+            "\n"
+            "ABSOLUTE RULES:\n"
+            "1) FOLLOW THE ASSIGNMENT EXACTLY. Each clip animates ONLY the action(s) assigned "
+            "to it below. You MUST NOT move a later clip's action into an earlier clip. "
+            "clip_1 must NOT contain clip_4's action. The final action happens ONLY in clip_4. "
+            "This is the most important rule - violating the order is a failure. "
+            "(ONE exception: clip_1 may prepend a brief transition OUT of the starting physics from "
+            "rule 2 — e.g. leaving the yoga ball — before its assigned action. This is not borrowing "
+            "a later action; it is grounding the first one.)\n"
+            "2) STARTING PHYSICS (use the anchors here). Read the character's CURRENT pose AND "
+            "what they are supported by / in contact with from the SCENE ANCHORS (e.g. seated on a "
+            "yoga ball, kneeling, gripping a weapon, leaning on a wall). clip_1 MUST begin the first "
+            "action FROM that exact physical situation and honor its constraints. If the support is "
+            "unstable or unusual (a yoga ball, a ledge, a moving surface), the motion MUST account "
+            "for it — e.g. anchor 'seated balanced on a yoga ball' -> clip_1 = 'pushing off the "
+            "wobbling ball and rising to their feet as it rolls away' BEFORE any further action. "
+            "Never ignore or contradict the starting support (do not stand if seated on the ball "
+            "without first leaving it; do not assume a weapon is drawn if the anchor shows it "
+            "sheathed). This makes the motion physically continuous with the input image. Reference "
+            "the support ONLY to ground how the motion STARTS — do NOT describe its appearance, "
+            "color, or the wider environment.\n"
+            "3) ACTION ONLY. Write physical body movement. NO scenery, NO lighting, NO clothing, "
+            "NO mood, NO camera talk. If a word is not a movement or body part, delete it. "
+            "(Referring to the starting pose in clip_1 per rule 2 is allowed since it describes "
+            "how the body moves.)\n"
+            "4) FILL 5 SECONDS. Expand the assigned action into a single continuous flow of motion "
+            "that occupies the whole clip (use 'then', 'immediately', 'without pausing'). "
+            "Do not borrow the next action to fill time - elaborate the CURRENT action instead.\n"
+            "5) ANTI-SLOW-MOTION: real-time speed, kinetic adverbs (swiftly, rapidly, explosively, "
+            "in a split second). NO slow motion, NO freeze, NO holding a pose.\n"
+            "6) CHARACTER NAME: study the SCENE ANCHORS. Judge the character's apparent ethnicity/"
+            "setting (East Asian, Western, etc.) and INVENT a specific fitting first name that "
+            "matches it (e.g. East Asian -> 'Yuna','Kaede','Jin'; Western -> 'Elena','Ryan'). "
+            "NEVER output 'AUTO' or an empty name. If a NAME is given below (not 'AUTO'), use it.\n"
+            f"7) {detail}\n"
+            "8) MOTION ENERGY: a MOTION STYLE cue is given below (e.g. 'cinematic lighting, dynamic "
+            "motion'). Use it ONLY to calibrate how forceful/graceful/frantic the movement FEELS "
+            "(word choice, verb intensity). Do NOT quote it and do NOT let any scenery/lighting/mood "
+            "words from it leak into the output — rule 3 still applies.\n"
+            "\n"
+            "master_scene: leave it EMPTY.\n"
+            "\n"
+            'OUTPUT ONLY JSON: {"character":"<a real name, never AUTO>","master_scene":"",'
+            '"clip_1":"<only clip_1 action, continuous & fast>",'
+            '"clip_2":"<only clip_2 action>","clip_3":"<only clip_3 action>",'
+            '"clip_4":"<only clip_4 action, the finisher>"}'
+        )
+        usr = (f"NAME: {name}\nPACING: {self._pacing_hint(pacing)}\n\n"
+               f"MOTION STYLE (kinetic energy cue only, per rule 8 — do not describe scenery/"
+               f"lighting/mood from this): {vibe.strip() or '(none)'}\n\n"
+               f"SCENE ANCHORS (use the POSE to start clip_1's motion per rule 2; "
+               f"use overall look only for naming — do NOT copy look into the clips):\n"
+               f"{anchors or '(none — assume a neutral ready stance)'}\n\n"
+               f"STRICT PER-CLIP ACTION ASSIGNMENT (animate ONLY what is listed per clip, "
+               f"in this order, finisher in clip_4):\n{assign_block}\n")
+        messages = [{"role": "system", "content": sys}, {"role": "user", "content": usr}]
+        t = temp
+        last = "⚠️ plan failed (no attempts ran)"
+        for attempt in (1, 2):
+            try:
+                content = self._call_or(messages, llm_model, key, t, force_json=True)
+                parsed = self._extract_json(content)
+                if parsed and all(parsed.get(f"clip_{i}") for i in range(1, 5)):
+                    return parsed, f"✅ plan ok (attempt {attempt})"
+                last = f"⚠️ incomplete JSON (attempt {attempt}): {content[:150]!r}"
+                print(f"⚠️ [Director] plan attempt {attempt} returned incomplete JSON: {content[:300]}")
+            except urllib.error.HTTPError as e:
+                body = ""
+                try:
+                    body = e.read().decode('utf-8')[:200]
+                except Exception:
+                    pass
+                last = f"❌ plan HTTP {e.code} (attempt {attempt}): {body}"
+                print(f"❌ [Director] plan {last}")
+            except (urllib.error.URLError, TimeoutError, KeyError, ValueError) as e:
+                last = f"❌ plan error (attempt {attempt}): {type(e).__name__}: {e}"
+                print(f"❌ [Director] {last}")
+            t = min(temp, 0.4)
+        return None, last
+
+    def _local_split(self, actions):
+        """LLM 폴백: 동작 순서 유지, 마지막 동작은 뒤 클립(3후반/4)에. 타임코드 없이
+        연속 동작 + 실시간 속도 어휘로 슬로우모션을 억제한다."""
+        parts = re.split(r'(?<=[.!?。])\s+|[,、]|\n+', actions)
+        parts = [p.strip() for p in parts if len(p.strip()) > 1]
+        if not parts:
+            parts = [actions.strip()]
+        n = len(parts)
+
+        def fast(phrase, lead="swiftly"):
+            p = phrase.strip()
+            return f"{lead} {p}, continuous real-time motion, no slow motion" if p else ""
+
+        if n == 1:
+            a = parts[0]
+            out = [
+                f"rapidly moves into position toward {a}, no pause",
+                f"immediately begins {a}, brisk continuous motion, no slow motion",
+                f"presses {a} without stopping, fast decisive movement",
+                f"explosively completes {a} at real-time speed, no slow motion, no freeze",
+            ]
+        elif n <= 4:
+            out = ["", "", "", ""]
+            out[3] = fast(parts[-1], "explosively")
+            head = parts[:-1]
+            for i, ph in enumerate(head):
+                s = min(i, 2)
+                out[s] = (out[s] + ", then " + fast(ph)).strip(", ") if out[s] else fast(ph)
+            for i in range(3):
+                if not out[i]:
+                    key = parts[min(i, n - 1)]
+                    out[i] = f"rapidly moves toward {key}, brisk continuous motion, no slow motion"
+        else:
+            k, m = divmod(n - 1, 3)
+            idx, chunks = 0, []
+            for i in range(3):
+                end = idx + k + (1 if i < m else 0)
+                seg = parts[idx:end]
+                idx = end
+                chunks.append(", then ".join(fast(p) for p in seg) if seg else "")
+            out = chunks + [fast(parts[-1], "explosively")]
+        return out[:4]
+
+    # ---- lora ----
+    def _load(self, name):
+        return comfy.utils.load_torch_file(folder_paths.get_full_path("loras", name))
+
+    @staticmethod
+    def _parse_weights(text):
+        """'base, high, low' 문자열 -> (b, h, l) float. 값이 모자라면 마지막 값으로 채움.
+        한 개만 주면 세 스테이지 모두 동일. 빈 문자열/파싱 실패는 (1,1,1)."""
+        try:
+            nums = [float(x) for x in re.split(r'[,\s]+', text.strip()) if x != ""]
+        except (ValueError, AttributeError):
+            nums = []
+        if not nums:
+            return 1.0, 1.0, 1.0
+        if len(nums) == 1:
+            return nums[0], nums[0], nums[0]
+        if len(nums) == 2:
+            return nums[0], nums[1], nums[1]
+        return nums[0], nums[1], nums[2]
+
+    def _patch_clip(self, mb, mh, ml, slots, cache, inject):
+        """slots: [(lora_name, weights_str), ...]. weights_str='base,high,low'.
+        트리거는 inject 여부와 무관하게 항상 조회한다(triggers 출력 포트용). inject는
+        각 클립 프롬프트 텍스트에 트리거를 넣을지만 결정한다."""
+        cb, ch, cl = mb, mh, ml
+        used = []
+        for (name, w_str) in slots:
+            if name == "None":
+                continue
+            w_b, w_h, w_l = self._parse_weights(w_str)
+            if w_b == 0.0 and w_h == 0.0 and w_l == 0.0:
+                continue
+            data = self._load(name)
+            if w_b != 0.0:
+                cb = apply_model_lora(cb, data, w_b)
+            if w_h != 0.0:
+                ch = apply_model_lora(ch, data, w_h)
+            if w_l != 0.0:
+                cl = apply_model_lora(cl, data, w_l)
+            used.append(name)
+        trig = []
+        trig_dbg = []
+        # 조회는 항상 수행 (used 로라 기준). 회귀 원인이던 inject 게이팅 제거.
+        for n in dict.fromkeys(used):
+            found = get_triggers(n, cache)
+            trig.extend(found)
+            trig_dbg.append(f"{os.path.basename(n)}:{len(found)}")
+        self._last_trig_dbg = trig_dbg  # 콘솔 디버그용
+        trig_str = ", ".join(dict.fromkeys(t for t in trig if t))
+        # inject가 꺼져 있으면 프롬프트 텍스트에는 넣지 않지만, 조회 결과(trig_str)는
+        # 항상 반환해 triggers 출력 포트로 나가게 한다.
+        prompt_trig = trig_str if inject else ""
+        return cb, ch, cl, prompt_trig, trig_str
+
+    # ------------------------------------------------------------------ main
+    def direct(self, image, model_base, model_high, model_low, essential_actions,
+               character_name, artistic_vibe, pacing, detail_level, inject_triggers,
+               use_vision, openrouter_api_key, vlm_preset, vlm_model, llm_preset, llm_model,
+               creativity, seed, **kw):
+
+        vlm = resolve_slug(VLM_PRESETS, vlm_preset, vlm_model, "qwen/qwen2.5-vl-72b-instruct")
+        llm = resolve_slug(LLM_PRESETS, llm_preset, llm_model, "deepseek/deepseek-v3.2")
+        user_name = "" if character_name.strip().upper() in ["AUTO", ""] else character_name.strip()
+        key = resolve_api_key(openrouter_api_key)
+
+        # ---- STEP 1: 비전 ----
+        # 우선순위: 1) vision_caption 입력(JoyCaption 등 로컬 노드 STRING) 있으면 그걸 그대로
+        #           앵커로 사용 - OpenRouter VLM 호출 자체를 건너뛴다 (429/거부 회피).
+        #           2) 없으면 기존 OpenRouter VLM 경로로 폴백 (하위 호환).
+        vision_caption = str(kw.get("vision_caption", "") or "").strip()
+        anchors, dbg_v = "", ""
+        if vision_caption:
+            anchors = vision_caption
+            dbg_v = "vision ok (local caption node)"
+            print(f"👁 [Director] 로컬 캡션 입력 사용 (JoyCaption 등):\n{anchors[:300]}")
+        elif not use_vision:
+            dbg_v = "vision OFF (토글 확인)"
+            print("ℹ️ [Director] use_vision=OFF - 비전 건너뜀")
+        elif not key:
+            dbg_v = "no api key"
+            print("❌ [Director] openrouter_api_key 비어있음 (위젯도, OPENROUTER_API_KEY 환경변수도 없음) - 비전/LLM 불가")
+        elif image is None:
+            dbg_v = "no image"
+            print("❌ [Director] image 입력 없음 - IMAGE 연결 확인")
+        else:
+            data_uri = tensor_to_base64(image)
+            if data_uri:
+                anchors, err = self._vision_analyze(data_uri, vlm, key, min(creativity, 0.5))
+                dbg_v = err or "vision ok"
+            else:
+                dbg_v = "image encode failed / PIL missing"
+        if not vision_caption and use_vision and key and image is not None and not anchors:
+            print(f"⚠️ [Director] 비전 앵커가 비었음 -> 이름/씬 근거 없음. 원인: {dbg_v}")
+
+        # ---- STEP 2: 4샷 분배 ----
+        if key:
+            parsed, dbg_p = self._plan_shots(anchors, essential_actions, character_name,
+                                             artistic_vibe, pacing, self._detail_hint(detail_level),
+                                             llm, key, creativity, seed)
+            if parsed:
+                clips = [str(parsed[f"clip_{i}"]).strip() for i in range(1, 5)]
+                master = str(parsed.get("master_scene", "")).strip()
+                cand = str(parsed.get("character", "")).strip()
+                # LLM 이 AUTO/빈값 반환 시 앵커 기반 폴백 작명
+                if not cand or cand.upper() == "AUTO":
+                    cand = self._fallback_name(anchors)
+                final_name = user_name or cand
+            else:
+                clips = self._local_split(essential_actions)
+                master = anchors.replace("\n", " ")[:160]
+                final_name = user_name or self._fallback_name(anchors)
+        else:
+            parsed, dbg_p = None, "no api key"
+            clips = self._local_split(essential_actions)
+            master = anchors.replace("\n", " ")[:160]
+            final_name = user_name
+
+        # ---- STEP 3: 클립별 로라 3개 패치 + 트리거 주입 ----
+        cache = _load_cache()
+        manual_list = [t.strip() for t in kw.get("manual_triggers", "").split(',') if t.strip()]
+        outs = []
+        all_trigs_collected = []   # 전 클립 트리거 통합 (triggers 출력용)
+        for c in range(1, 5):
+            slots = [(kw.get(f"c{c}_lora_{n}", "None"),
+                      kw.get(f"c{c}_w_{n}", "1.0, 1.0, 1.0")) for n in range(1, 4)]
+            cb, ch, cl, prompt_trig, always_trig = self._patch_clip(
+                model_base, model_high, model_low, slots, cache, inject_triggers)
+            # 프롬프트에 넣는 트리거: inject ON일 때만 (+manual)
+            all_trig = ", ".join(dict.fromkeys(
+                ([prompt_trig] if prompt_trig else []) + manual_list)) \
+                if (prompt_trig or manual_list) else ""
+            # triggers 출력 포트: inject 무관하게 항상 수집
+            if always_trig:
+                all_trigs_collected.extend(t.strip() for t in always_trig.split(',') if t.strip())
+            prompt = self._build_final(clips[c - 1], master, final_name, all_trig)
+            outs.extend([cb, ch, cl, prompt])
+            print(f"  [clip{c}] loras/triggers: {getattr(self, '_last_trig_dbg', [])} "
+                  f"inject={inject_triggers}")
+
+        # 통합 트리거 출력 (클립별 로라 트리거 + manual, 중복 제거)
+        triggers_out = ", ".join(dict.fromkeys(
+            [t for t in all_trigs_collected if t] + manual_list))
+
+        debug = f"vlm={dbg_v} | plan={dbg_p} | char={final_name}"
+        print(f"\n🎬 [Dolphin Vision Director] {debug}\nANCHORS: {anchors[:120]}")
+        for i in range(4):
+            print(f"  CLIP {i+1}: {outs[i*4+3][:90]}")
+
+        return tuple(outs) + (triggers_out, anchors, debug)
+
+
+NODE_CLASS_MAPPINGS = {"DolphinVisionDirector": DolphinVisionDirector}
+NODE_DISPLAY_NAME_MAPPINGS = {"DolphinVisionDirector": "🎬👁 Dolphin Vision Director (Image→4Clips)"}

_archive/nodes_unregistered/old/promp_auto_sequence.py

@@ -0,0 +1,101 @@
+import os
+import random
+import re
+import json
+import urllib.request
+
+class DolphinAutoSequencerNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mode": (["🤖 Auto LLM (Timeline)", "✍️ Manual Override (수동)"], {"default": "🤖 Auto LLM (Timeline)"}),
+                "character_name": ("STRING", {"multiline": False, "default": "AUTO"}),
+                "tagger_context": ("STRING", {"multiline": True, "forceInput": True, "default": ""}),
+                "artistic_vibe": ("STRING", {"multiline": True, "default": "cinematic lighting, dynamic motion"}),
+                
+                # 🔥 [핵심] 시간 입력 없이 엔터키로만 액션을 나열합니다. 3줄이든 10줄이든 무한정 쓸 수 있습니다!
+                "action_sequence": ("STRING", {
+                    "multiline": True, 
+                    "default": "방문을 열고 조심스럽게 들어온다.\n갑자기 나타난 적을 보고 놀라 뒷걸음질 친다.\n재빠르게 허리에서 권총을 뽑아 든다.\n적을 향해 두 발을 발사한다."
+                }),
+                
+                # ⏱️ 한 줄당 몇 초를 배정할지, 영상의 프레임레이트는 몇인지 세팅합니다.
+                "seconds_per_line": ("INT", {"default": 5, "min": 1, "max": 30, "step": 1}),
+                "video_fps": ("INT", {"default": 24, "min": 8, "max": 120, "step": 1}),
+                
+                "openrouter_api_key": ("STRING", {"multiline": False, "default": ""}),
+                "openrouter_model": ("STRING", {"multiline": False, "default": "meta-llama/llama-3.3-70b-instruct"}),
+                "creativity": ("FLOAT", {"default": 0.85, "min": 0.1, "max": 1.5, "step": 0.05}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            },
+        }
+
+    # 📤 [출력] FizzNodes 등 스케줄러 노드에 바로 꽂을 수 있는 단일 문자열 1개와 확인용 텍스트를 내보냅니다.
+    RETURN_TYPES = ("STRING", "STRING")
+    RETURN_NAMES = ("Keyframe_Dict (스케줄러용)", "Raw_Text (로그 확인용)")
+    FUNCTION = "generate_timeline"
+    CATEGORY = "Dolphin"
+
+    def generate_timeline(self, mode, character_name, tagger_context, artistic_vibe, action_sequence, seconds_per_line, video_fps, openrouter_api_key, openrouter_model, creativity, seed):
+        
+        # 1. 입력받은 시퀀스를 '엔터키(\n)' 기준으로 쪼개고, 몇 줄인지 계산합니다.
+        raw_lines = [line.strip() for line in action_sequence.split('\n') if line.strip()]
+        num_actions = len(raw_lines)
+
+        if num_actions == 0:
+            return ("\"0\": \"\"", "입력된 액션이 없습니다.")
+
+        user_defined_name = "" if character_name.upper() in ["AUTO", ""] else character_name.strip()
+
+        def build_final(action, raw_tags, master_scene, name):
+            parts = []
+            if name: parts.append(name) 
+            if raw_tags.strip(): parts.append(raw_tags.strip().strip(",. "))
+            if master_scene.strip(): parts.append(master_scene.strip().strip(",. "))
+            prefix = ", ".join(parts)
+            return f"{prefix}, {action.strip()}" if action.strip() else prefix
+
+        # 🟢 [수동 모드] LLM을 거치지 않고 바로 프레임 계산 후 송출
+        if mode == "✍️ Manual Override (수동)":
+            keyframe_out, raw_out = [], []
+            for idx, line in enumerate(raw_lines):
+                frame_num = idx * seconds_per_line * video_fps
+                final_prompt = build_final(line, tagger_context, "", user_defined_name)
+                keyframe_out.append(f'"{frame_num}": "{final_prompt}"')
+                raw_out.append(f"[{frame_num} Frame] {final_prompt}")
+            return (",\n".join(keyframe_out), "\n".join(raw_out))
+
+        # 🔵 [자동 LLM 모드]
+        random.seed(seed)
+        
+        # LLM에게 보낼 번호 매기기 (내부적으로만 처리)
+        actions_formatted = "\n".join([f"ACTION {i+1}: {line}" for i, line in enumerate(raw_lines)])
+
+        # 유저가 쓴 줄 개수(num_actions)만큼 동적으로 파트(PART)를 쪼개라고 LLM에게 명령
+        sys_prompt = (
+            f"You are an Elite Cinematic Action Choreographer.\n"
+            f"1. CHARACTER: If NAME is 'AUTO', assign a culturally appropriate name based on TAGS. If '{user_defined_name}', use it.\n"
+            f"2. INITIAL POSTURE: Analyze TAGS for starting physical state. 1 short sentence.\n"
+            f"3. MASTER SCENE: 1-sentence environment description based on TAGS and VIBE.\n"
+            f"4. CHOREOGRAPHY: You will receive {num_actions} basic actions. EXPAND each into highly detailed, physical, kinetic choreography. Maintain logical flow. No abstract emotions.\n"
+            f"Format EXACTLY like this:\nCHARACTER: [Name]\nINITIAL POSTURE: [State]\nMASTER SCENE: [Description]\n"
+        )
+        for i in range(num_actions):
+            sys_prompt += f"PART {i+1}: [Action]\n"
+
+        usr_prompt = f"NAME: {character_name}\nTAGS: {tagger_context}\nVIBE: {artistic_vibe}\n{actions_formatted}"
+
+        url = "https://openrouter.ai/api/v1/chat/completions"
+        payload = {"model": openrouter_model.strip(), "messages": [{"role": "system", "content": sys_prompt}, {"role": "user", "content": usr_prompt}], "temperature": creativity}
+        
+        llm_prompt = ""
+        try:
+            req = urllib.request.Request(url, data=json.dumps(payload).encode('utf-8'), headers={'Authorization': f'Bearer {openrouter_api_key}', 'Content-Type': 'application/json'})
+            response = urllib.request.urlopen(req, timeout=120)
+            llm_prompt = json.loads(response.read().decode('utf-8'))['choices'][0]['message']['content'].strip()
+            print(f"\n✅ [Dolphin Auto-Sequencer]\n{llm_prompt}\n")
+        except Exception as e:
+            print(f"❌ [에러] {e}")
+
+        final_char_name = user_defined_

_archive/nodes_unregistered/old/promp_logic_v30_story.py

@@ -0,0 +1,176 @@
+import os
+import random
+import re
+import json
+import urllib.request
+import urllib.error
+
+class DolphinMultiActionPromptNode_V30:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mode": (["🤖 Auto LLM (Story Splitter)", "✍️ Manual Override (수동)"], {"default": "🤖 Auto LLM (Story Splitter)"}),
+                "character_name": ("STRING", {"multiline": False, "default": "AUTO"}),
+                "tagger_context": ("STRING", {"multiline": True, "default": ""}),
+                "artistic_vibe": ("STRING", {"multiline": True, "default": "cinematic lighting, dynamic motion"}),
+                
+                "master_story": ("STRING", {
+                    "multiline": True, 
+                    "default": "어두운 골목길. 갑자기 나타난 적들을 향해 돌진한다, 화려하게 검을 휘둘러 적을 쓰러뜨린다, 날아오는 총알을 튕겨낸다, 적에게 다가가 숨통을 끊는다."
+                }),
+                
+                "openrouter_api_key": ("STRING", {"multiline": False, "default": ""}),
+                "openrouter_model": ("STRING", {"multiline": False, "default": "meta-llama/llama-3.3-70b-instruct"}),
+                "creativity": ("FLOAT", {"default": 0.85, "min": 0.1, "max": 1.5, "step": 0.05}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING")
+    RETURN_NAMES = ("prompt_1 (Clip 1: 0-5s)", "prompt_2 (Clip 2: 0-5s)", "prompt_3 (Clip 3: 0-5s)", "prompt_4 (Clip 4: 0-5s)")
+    FUNCTION = "generate_sequence"
+    CATEGORY = "Dolphin"
+
+    def generate_sequence(self, mode, character_name, tagger_context, artistic_vibe, master_story, openrouter_api_key, openrouter_model, creativity, seed):
+        
+        user_defined_name = "" if character_name.upper() in ["AUTO", ""] else character_name.strip()
+
+        def build_final(action, raw_tags, master_scene, name):
+            tags_list = []
+            if name: tags_list.append(name) 
+            if raw_tags.strip(): tags_list.append(raw_tags.strip().strip(",. "))
+            tag_block = ", ".join(tags_list)
+            
+            sentence_list = []
+            if master_scene.strip(): sentence_list.append(master_scene.strip().strip(",. "))
+            if action.strip(): sentence_list.append(action.strip())
+            sentence_block = " ".join(sentence_list)
+            
+            if tag_block and sentence_block:
+                return f"{tag_block}\n{sentence_block}"
+            elif tag_block:
+                return tag_block
+            else:
+                return sentence_block
+
+        if mode == "✍️ Manual Override (수동)":
+            return (
+                build_final(master_story, tagger_context, "", user_defined_name),
+                build_final(master_story, tagger_context, "", user_defined_name),
+                build_final(master_story, tagger_context, "", user_defined_name),
+                build_final(master_story, tagger_context, "", user_defined_name)
+            )
+
+        random.seed(seed)
+        
+        # 1차: 마침표, 쉼표, 느낌표, 줄바꿈 기준으로 확실하게 쪼갬
+        clean_story = re.sub(r'([.!?,\n])', r'\1|', master_story)
+        raw_sentences = clean_story.split('|')
+        sentences = [s.strip() for s in raw_sentences if len(s.strip()) > 1]
+        
+        # 🔥 [핵심 로직] 문장 개수에 따른 '시네마틱 호흡(Pacing)' 자동 설계
+        
+        if len(sentences) == 1:
+            # 단 1개의 문장: 1~3번은 분위기 빌드업, 4번에 폭발!
+            chunk_1 = f"Atmospheric Build-up: Focus STRICTLY on the environment, lighting, and vibe. Character is mostly still. DO NOT execute the main action yet. (Upcoming target: {sentences[0]})"
+            chunk_2 = f"Rising Tension: Subtle character movements or camera panning. Anticipation builds. DO NOT execute the main action yet. (Upcoming target: {sentences[0]})"
+            chunk_3 = f"Pre-action Wind-up: Extreme tension right before the strike. Character prepares to move. DO NOT execute yet. (Upcoming target: {sentences[0]})"
+            chunk_4 = f"CLIMAX: Explosively and swiftly execute this exact action -> {sentences[0]}"
+            
+        elif len(sentences) == 2:
+            # 2개의 문장: 1번 빌드업 -> 2번 첫 액션 -> 3번 호흡 고르기 -> 4번 피니시
+            chunk_1 = f"Atmospheric Build-up: Focus strictly on the environment and tension. DO NOT execute the action yet. (Upcoming target: {sentences[0]})"
+            chunk_2 = f"Phase 1 Action: Execute this action -> {sentences[0]}"
+            chunk_3 = f"Tension / Transition: Character prepares for the final blow. (Upcoming target: {sentences[1]})"
+            chunk_4 = f"CLIMAX Action: Explosively execute this action -> {sentences[1]}"
+            
+        elif len(sentences) == 3:
+            # 3개의 문장: 첫 문장을 10초(1,2번 파트)에 걸쳐 부드럽게 배분
+            chunk_1 = f"Phase 1: Start this action slowly -> {sentences[0]}"
+            chunk_2 = f"Phase 2: Complete this action -> {sentences[0]}"
+            chunk_3 = sentences[1]
+            chunk_4 = sentences[2]
+            
+        else:
+            # 4개 이상: 기존의 수학적 4등분 배분
+            k, m = divmod(len(sentences), 4)
+            chunks = []
+            start = 0
+            for i in range(4):
+                end = start + k + (1 if i < m else 0)
+                chunks.append(" ".join(sentences[start:end]))
+                start = end
+            chunk_1, chunk_2, chunk_3, chunk_4 = chunks
+
+        sys_prompt = (
+            "You are an Elite Cinematic Action Choreographer.\n"
+            f"1. CHARACTER: If NAME is 'AUTO', assign a culturally appropriate name based on TAGS. If '{user_defined_name}', use it.\n"
+            "2. INITIAL POSTURE: Analyze TAGS for the character's starting physical state. State it in 1 short sentence.\n"
+            "3. MASTER SCENE: A vivid 1-sentence environment description based on TAGS and VIBE.\n"
+            "4. STRICT CHOREOGRAPHY ISOLATION (CRITICAL):\n"
+            "   - You will receive 4 explicit target events. You MUST translate them into English cinematic actions.\n"
+            "   - FATAL ERROR PREVENTION: You MUST rigidly confine the actions. DO NOT animate Part 2, 3, or 4's event in Part 1. Keep them completely isolated in time.\n"
+            "   - 🔥 OUTPUT RULE: DO NOT quote the original Korean text. ONLY output the English descriptions.\n"
+            "   - 🔥 ANTI-SLOW MOTION RULE: Inject aggressive kinetic adverbs (swiftly, suddenly, explosively) into EVERY action description.\n"
+            "   - Each Part MUST reset timestamps to [0-1s], [2-3s], [4-5s].\n"
+            "Format EXACTLY:\nCHARACTER: [Name]\nINITIAL POSTURE: [State]\nMASTER SCENE: [Description]\n"
+            "PART 1: [0-1s] [Action A] [2-3s] [Action B] [4-5s] [Action C]\n"
+            "PART 2: [0-1s] [Action D] [2-3s] [Action E] [4-5s] [Action F]\n"
+            "PART 3: [0-1s] [Action G] [2-3s] [Action H] [4-5s] [Action I]\n"
+            "PART 4: [0-1s] [Action J] [2-3s] [Action K] [4-5s] [Action L]"
+        )
+        
+        usr_prompt = (
+            f"NAME: {character_name}\nTAGS: {tagger_context}\nVIBE: {artistic_vibe}\n\n"
+            "=== ACTION ISOLATION SCRIPT ===\n"
+            f"▶ For PART 1 (0-5s), you MUST ONLY animate this specific event: \"{chunk_1}\"\n"
+            f"▶ For PART 2 (5-10s), you MUST ONLY animate this specific event: \"{chunk_2}\"\n"
+            f"▶ For PART 3 (10-15s), you MUST ONLY animate this specific event: \"{chunk_3}\"\n"
+            f"▶ For PART 4 (15-20s), you MUST ONLY animate this specific event: \"{chunk_4}\"\n"
+            "CRITICAL REMINDER: Do NOT allow any actions from Part 2, 3, or 4 to bleed into Part 1!"
+        )
+
+        url = "https://openrouter.ai/api/v1/chat/completions"
+        payload = {"model": openrouter_model.strip(), "messages": [{"role": "system", "content": sys_prompt}, {"role": "user", "content": usr_prompt}], "temperature": creativity}
+        
+        try:
+            req = urllib.request.Request(url, data=json.dumps(payload).encode('utf-8'), headers={'Authorization': f'Bearer {openrouter_api_key}', 'Content-Type': 'application/json'})
+            response = urllib.request.urlopen(req, timeout=120)
+            llm_prompt = json.loads(response.read().decode('utf-8'))['choices'][0]['message']['content'].strip()
+            print(f"\n✅ [Dolphin V30 - Cinematic Pacing Applied]\n{llm_prompt}\n")
+        except Exception as e:
+            print(f"❌ [에러] {e}")
+            llm_prompt = ""
+
+        final_char_name = user_defined_name
+        r_master, p1, p2, p3, p4 = "", "", "", "", ""
+
+        if llm_prompt and "[removed]" not in llm_prompt:
+            cl = re.sub(r'[*#]', '', llm_prompt)
+            m_char = re.search(r'CHARACTER:\s*(.*?)(?=INITIAL POSTURE|$)', cl, re.I | re.S)
+            m_master = re.search(r'MASTER SCENE:\s*(.*?)(?=PART 1|$)', cl, re.I | re.S)
+            
+            m1 = re.search(r'PART 1:\s*(.*?)(?=PART 2|$)', cl, re.I | re.S)
+            m2 = re.search(r'PART 2:\s*(.*?)(?=PART 3|$)', cl, re.I | re.S)
+            m3 = re.search(r'PART 3:\s*(.*?)(?=PART 4|$)', cl, re.I | re.S)
+            m4 = re.search(r'PART 4:\s*(.*?)(?=\n\n|===|Note:|$)', cl, re.I | re.S)
+
+            if not user_defined_name and m_char:
+                final_char_name = m_char.group(1).strip()
+            
+            r_master = m_master.group(1).strip() if m_master else ""
+            
+            p1 = m1.group(1).strip() if m1 else "⚠️ Formatting Error: Part 1"
+            p2 = m2.group(1).strip() if m2 else "⚠️ Formatting Error: Part 2"
+            p3 = m3.group(1).strip() if m3 else "⚠️ Formatting Error: Part 3"
+            p4 = m4.group(1).strip() if m4 else "⚠️ Formatting Error: Part 4"
+        else:
+            p1 = p2 = p3 = p4 = "⚠️ API Error: LLM request failed."
+
+        return (
+            build_final(p1, tagger_context, r_master, final_char_name),
+            build_final(p2, tagger_context, r_master, final_char_name),
+            build_final(p3, tagger_context, r_master, final_char_name),
+            build_final(p4, tagger_context, r_master, final_char_name)
+        )

_archive/nodes_unregistered/old/promp_logic_v31_vision.py

@@ -0,0 +1,191 @@
+import os
+import random
+import re
+import json
+import urllib.request
+import urllib.error
+import base64
+import io
+import numpy as np
+from PIL import Image
+import torch
+
+class DolphinMultiActionPromptNode_V31:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mode": (["🤖 Auto Vision+LLM", "✍️ Manual Override"], {"default": "🤖 Auto Vision+LLM"}),
+                "character_name": ("STRING", {"multiline": False, "default": "AUTO"}),
+                "artistic_vibe": ("STRING", {"multiline": True, "default": "cinematic lighting, high-speed action, dark fantasy"}),
+                
+                "master_story": ("STRING", {
+                    "multiline": True, 
+                    "default": "어두운 골목길. 갑자기 나타난 적들을 향해 돌진한다, 화려하게 검을 휘둘러 적을 쓰러뜨린다, 날아오는 총알을 튕겨낸다, 적에게 다가가 숨통을 끊는다."
+                }),
+                
+                "openrouter_api_key": ("STRING", {"multiline": False, "default": ""}),
+                "openrouter_model": ("STRING", {"multiline": False, "default": "qwen/qwen-2-vl-72b-instruct"}),
+                "creativity": ("FLOAT", {"default": 0.85, "min": 0.1, "max": 1.5, "step": 0.05}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING")
+    RETURN_NAMES = ("prompt_1 (Clip 1: 0-5s)", "prompt_2 (Clip 2: 0-5s)", "prompt_3 (Clip 3: 0-5s)", "prompt_4 (Clip 4: 0-5s)")
+    FUNCTION = "generate_sequence"
+    CATEGORY = "Dolphin"
+
+    def generate_sequence(self, image, mode, character_name, artistic_vibe, master_story, openrouter_api_key, openrouter_model, creativity, seed):
+        
+        user_defined_name = "" if character_name.upper() in ["AUTO", ""] else character_name.strip()
+
+        def build_final(action, master_scene, name):
+            tags_list = []
+            if name: tags_list.append(name) 
+            tag_block = ", ".join(tags_list)
+            
+            sentence_list = []
+            if master_scene.strip(): sentence_list.append(master_scene.strip().strip(",. "))
+            if action.strip(): sentence_list.append(action.strip())
+            sentence_block = " ".join(sentence_list)
+            
+            if tag_block and sentence_block:
+                return f"{tag_block}\n{sentence_block}"
+            elif tag_block:
+                return tag_block
+            else:
+                return sentence_block
+
+        if mode == "✍️ Manual Override":
+            return (
+                build_final(master_story, "", user_defined_name),
+                build_final(master_story, "", user_defined_name),
+                build_final(master_story, "", user_defined_name),
+                build_final(master_story, "", user_defined_name)
+            )
+
+        random.seed(seed)
+        
+        img_tensor = image[0]
+        i = 255. * img_tensor.cpu().numpy()
+        img_pil = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+        buffered = io.BytesIO()
+        img_pil.save(buffered, format="JPEG")
+        base64_image = f"data:image/jpeg;base64,{base64.b64encode(buffered.getvalue()).decode('utf-8')}"
+
+        clean_story = re.sub(r'([.!?,\n])', r'\1|', master_story)
+        raw_sentences = clean_story.split('|')
+        sentences = [s.strip() for s in raw_sentences if len(s.strip()) > 1]
+        
+        # 🔥 '가만히 있기(still)'를 금지하고, 1문장이라도 시작부터 빠르게 움직이도록 전면 수정
+        if len(sentences) == 1:
+            chunk_1 = f"Phase 1: Rapid approach and high-speed dynamic movement. DO NOT stand still. (Target: {sentences[0]})"
+            chunk_2 = f"Phase 2: Swift, explosive execution of the action. (Target: {sentences[0]})"
+            chunk_3 = f"Phase 3: The climax at full 1x real-time speed. Lightning fast! (Target: {sentences[0]})"
+            chunk_4 = f"Phase 4: Fast-paced completion and quick recovery. (Target: {sentences[0]})"
+        elif len(sentences) == 2:
+            chunk_1 = f"Phase 1: High-speed buildup and rapid preparation. (Target: {sentences[0]})"
+            chunk_2 = f"Phase 2: Explosively execute -> {sentences[0]}"
+            chunk_3 = f"Phase 3: Rapid transition, sprinting or moving quickly. (Target: {sentences[1]})"
+            chunk_4 = f"Phase 4: Lightning-fast execution -> {sentences[1]}"
+        elif len(sentences) == 3:
+            chunk_1 = f"Phase 1: Start this action rapidly -> {sentences[0]}"
+            chunk_2 = f"Phase 2: Explosively complete -> {sentences[0]}"
+            chunk_3 = sentences[1]
+            chunk_4 = sentences[2]
+        else:
+            k, m = divmod(len(sentences), 4)
+            chunks = []
+            start = 0
+            for i in range(4):
+                end = start + k + (1 if i < m else 0)
+                chunks.append(" ".join(sentences[start:end]))
+                start = end
+            chunk_1, chunk_2, chunk_3, chunk_4 = chunks
+
+        # 🔥 슬로우 모션 발작 단어(micro-expression 등) 완전 삭제 및 매크로 스피드 강조
+        sys_prompt = (
+            "You are an Elite Action Director prioritizing RAW SPEED and KINETIC ENERGY.\n"
+            f"1. CHARACTER: If NAME is 'AUTO', assign a name. If '{user_defined_name}', use it.\n"
+            "2. VISUAL ANALYSIS: You MUST base your descriptions EXACTLY on the character's clothing and weapons in the attached IMAGE.\n"
+            "3. MASTER SCENE: Write a 1-sentence environment description (lighting, weather).\n"
+            "4. SPEED-FOCUSED CHOREOGRAPHY (CRITICAL):\n"
+            "   - 🚫 BAN SLOW-MOTION TRIGGERS: NEVER use words like 'micro-expressions', 'muscle tension', 'slowly turning', 'floating', or 'gradually'. These cause AI video models to render in slow-motion.\n"
+            "   - ✅ FORCE 1x REAL-TIME SPEED: Describe large, sweeping, high-velocity movements. Use aggressive verbs (dashing, sprinting, whipping, snapping).\n"
+            "   - ✅ KINETIC ADVERBS: Inject phrases like 'in a flash', 'at lightning speed', 'with explosive real-time velocity' into EVERY part.\n"
+            "   - Example: 'suddenly dashes forward at full speed and delivers a lightning-fast horizontal strike, moving so quickly the rain splatters'.\n"
+            "   - Strictly confine the actions. DO NOT animate future events early.\n"
+            "   - 🔥 OUTPUT RULE: DO NOT quote the Korean text. Only output English.\n"
+            "Format EXACTLY:\nCHARACTER: [Name]\nMASTER SCENE: [Description]\n"
+            "PART 1: [0-1s] [Action A] [2-3s] [Action B] [4-5s] [Action C]\n"
+            "PART 2: [0-1s] [Action D] [2-3s] [Action E] [4-5s] [Action F]\n"
+            "PART 3: [0-1s] [Action G] [2-3s] [Action H] [4-5s] [Action I]\n"
+            "PART 4: [0-1s] [Action J] [2-3s] [Action K] [4-5s] [Action L]"
+        )
+        
+        usr_text = (
+            f"NAME: {character_name}\n"
+            f"VIBE: {artistic_vibe}\n\n"
+            "=== HIGH-SPEED ACTION SCRIPT ===\n"
+            f"▶ For PART 1 (0-5s), ONLY animate this: \"{chunk_1}\"\n"
+            f"▶ For PART 2 (5-10s), ONLY animate this: \"{chunk_2}\"\n"
+            f"▶ For PART 3 (10-15s), ONLY animate this: \"{chunk_3}\"\n"
+            f"▶ For PART 4 (15-20s), ONLY animate this: \"{chunk_4}\"\n"
+            "CRITICAL: Keep the action moving FAST. Avoid still poses or micro-details that look like slow-mo!"
+        )
+
+        url = "https://openrouter.ai/api/v1/chat/completions"
+        payload = {
+            "model": openrouter_model.strip(),
+            "messages": [
+                {"role": "system", "content": sys_prompt},
+                {"role": "user", "content": [
+                    {"type": "text", "text": usr_text},
+                    {"type": "image_url", "image_url": {"url": base64_image}}
+                ]}
+            ],
+            "temperature": creativity
+        }
+        
+        try:
+            req = urllib.request.Request(url, data=json.dumps(payload).encode('utf-8'), headers={'Authorization': f'Bearer {openrouter_api_key}', 'Content-Type': 'application/json'})
+            response = urllib.request.urlopen(req, timeout=120)
+            llm_prompt = json.loads(response.read().decode('utf-8'))['choices'][0]['message']['content'].strip()
+            print(f"\n✅ [Dolphin V31 - Action Speed Optimized]\n{llm_prompt}\n")
+        except Exception as e:
+            print(f"❌ [에러] API 호출 실패: {e}")
+            llm_prompt = ""
+
+        final_char_name = user_defined_name
+        r_master, p1, p2, p3, p4 = "", "", "", "", ""
+
+        if llm_prompt and "[removed]" not in llm_prompt:
+            cl = re.sub(r'[*#]', '', llm_prompt)
+            m_char = re.search(r'CHARACTER:\s*(.*?)(?=MASTER SCENE|$)', cl, re.I | re.S)
+            m_master = re.search(r'MASTER SCENE:\s*(.*?)(?=PART 1|$)', cl, re.I | re.S)
+            
+            m1 = re.search(r'PART 1:\s*(.*?)(?=PART 2|$)', cl, re.I | re.S)
+            m2 = re.search(r'PART 2:\s*(.*?)(?=PART 3|$)', cl, re.I | re.S)
+            m3 = re.search(r'PART 3:\s*(.*?)(?=PART 4|$)', cl, re.I | re.S)
+            m4 = re.search(r'PART 4:\s*(.*?)(?=\n\n|===|Note:|$)', cl, re.I | re.S)
+
+            if not user_defined_name and m_char:
+                final_char_name = m_char.group(1).strip()
+            
+            r_master = m_master.group(1).strip() if m_master else ""
+            
+            p1 = m1.group(1).strip() if m1 else "⚠️ Formatting Error: Part 1"
+            p2 = m2.group(1).strip() if m2 else "⚠️ Formatting Error: Part 2"
+            p3 = m3.group(1).strip() if m3 else "⚠️ Formatting Error: Part 3"
+            p4 = m4.group(1).strip() if m4 else "⚠️ Formatting Error: Part 4"
+        else:
+            p1 = p2 = p3 = p4 = "⚠️ API Error: Vision LLM request failed."
+
+        return (
+            build_final(p1, r_master, final_char_name),
+            build_final(p2, r_master, final_char_name),
+            build_final(p3, r_master, final_char_name),
+            build_final(p4, r_master, final_char_name)
+        )

_archive/nodes_unregistered/old/promp_logic_v32_vision.py

@@ -0,0 +1,247 @@
+import os
+import random
+import re
+import json
+import urllib.request
+import urllib.error
+import base64
+import io
+import time
+import numpy as np
+from PIL import Image
+import torch
+
+
+class DolphinMultiActionPromptNode_V32:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mode": (["🤖 Auto Vision+LLM", "✍️ Manual Override"], {"default": "🤖 Auto Vision+LLM"}),
+                "character_name": ("STRING", {"multiline": False, "default": "AUTO"}),
+                "artistic_vibe": ("STRING", {"multiline": True, "default": "cinematic lighting, high-speed action, dark fantasy"}),
+
+                "master_story": ("STRING", {
+                    "multiline": True,
+                    "default": "어두운 골목길. 갑자기 나타난 적들을 향해 돌진한다, 화려하게 검을 휘둘러 적을 쓰러뜨린다, 날아오는 총알을 튕겨낸다, 적에게 다가가 숨통을 끊는다."
+                }),
+
+                "openrouter_api_key": ("STRING", {"multiline": False, "default": ""}),
+                "openrouter_model": ("STRING", {"multiline": False, "default": "qwen/qwen-2-vl-72b-instruct"}),
+                "creativity": ("FLOAT", {"default": 0.85, "min": 0.1, "max": 1.5, "step": 0.05}),
+                "max_tokens": ("INT", {"default": 1500, "min": 256, "max": 8192, "step": 64}),
+                "retries": ("INT", {"default": 2, "min": 0, "max": 5}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING", "STRING")
+    RETURN_NAMES = (
+        "prompt_1 (Clip 1: 0-5s)",
+        "prompt_2 (Clip 2: 0-5s)",
+        "prompt_3 (Clip 3: 0-5s)",
+        "prompt_4 (Clip 4: 0-5s)",
+        "raw_llm_output",
+    )
+    FUNCTION = "generate_sequence"
+    CATEGORY = "Dolphin"
+
+    # -----------------------------------------------------------------
+    def _encode_image(self, image):
+        img_tensor = image[0]
+        i = 255. * img_tensor.cpu().numpy()
+        img_pil = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+        if img_pil.mode != "RGB":
+            img_pil = img_pil.convert("RGB")
+        buffered = io.BytesIO()
+        img_pil.save(buffered, format="JPEG", quality=90)
+        b64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
+        return f"data:image/jpeg;base64,{b64}"
+
+    def _split_sentences(self, master_story):
+        clean_story = re.sub(r'([.!?,\n])', r'\1|', master_story)
+        raw_sentences = clean_story.split('|')
+        return [s.strip() for s in raw_sentences if len(s.strip()) > 1]
+
+    def _build_chunks(self, sentences):
+        n = len(sentences)
+        if n == 0:
+            base = "dynamic high-speed action"
+            return (base, base, base, base)
+        if n == 1:
+            s = sentences[0]
+            return (
+                f"Phase 1: Rapid approach and high-speed dynamic movement. DO NOT stand still. (Target: {s})",
+                f"Phase 2: Swift, explosive execution of the action. (Target: {s})",
+                f"Phase 3: The climax at full 1x real-time speed. Lightning fast! (Target: {s})",
+                f"Phase 4: Fast-paced completion and quick recovery. (Target: {s})",
+            )
+        if n == 2:
+            return (
+                f"Phase 1: High-speed buildup and rapid preparation. (Target: {sentences[0]})",
+                f"Phase 2: Explosively execute -> {sentences[0]}",
+                f"Phase 3: Rapid transition, sprinting or moving quickly. (Target: {sentences[1]})",
+                f"Phase 4: Lightning-fast execution -> {sentences[1]}",
+            )
+        if n == 3:
+            return (
+                f"Phase 1: Start this action rapidly -> {sentences[0]}",
+                f"Phase 2: Explosively complete -> {sentences[0]}",
+                sentences[1],
+                sentences[2],
+            )
+        # n >= 4: 균등 분배
+        k, m = divmod(n, 4)
+        chunks = []
+        start = 0
+        for idx in range(4):
+            end = start + k + (1 if idx < m else 0)
+            chunks.append(" ".join(sentences[start:end]))
+            start = end
+        return tuple(chunks)
+
+    def _call_llm(self, url, payload, api_key, retries, timeout=120):
+        last_err = None
+        for attempt in range(retries + 1):
+            try:
+                req = urllib.request.Request(
+                    url,
+                    data=json.dumps(payload).encode('utf-8'),
+                    headers={'Authorization': f'Bearer {api_key}', 'Content-Type': 'application/json'}
+                )
+                response = urllib.request.urlopen(req, timeout=timeout)
+                body = json.loads(response.read().decode('utf-8'))
+                return body['choices'][0]['message']['content'].strip(), None
+            except Exception as e:
+                last_err = e
+                if attempt < retries:
+                    time.sleep(1.5 * (attempt + 1))
+        return None, last_err
+
+    # -----------------------------------------------------------------
+    def generate_sequence(self, image, mode, character_name, artistic_vibe, master_story,
+                          openrouter_api_key, openrouter_model, creativity, max_tokens, retries, seed):
+
+        user_defined_name = "" if character_name.upper() in ["AUTO", ""] else character_name.strip()
+
+        def build_final(action, master_scene, name):
+            tags_list = []
+            if name:
+                tags_list.append(name)
+            tag_block = ", ".join(tags_list)
+
+            sentence_list = []
+            if master_scene.strip():
+                sentence_list.append(master_scene.strip().strip(",. "))
+            if action.strip():
+                sentence_list.append(action.strip())
+            sentence_block = " ".join(sentence_list)
+
+            if tag_block and sentence_block:
+                return f"{tag_block}\n{sentence_block}"
+            elif tag_block:
+                return tag_block
+            return sentence_block
+
+        # ---- Manual Override ----
+        if mode == "✍️ Manual Override":
+            fp = build_final(master_story, "", user_defined_name)
+            return (fp, fp, fp, fp, "[Manual Override]")
+
+        random.seed(seed)
+
+        base64_image = self._encode_image(image)
+        sentences = self._split_sentences(master_story)
+        chunk_1, chunk_2, chunk_3, chunk_4 = self._build_chunks(sentences)
+
+        sys_prompt = (
+            "You are an Elite Action Director prioritizing RAW SPEED and KINETIC ENERGY.\n"
+            f"1. CHARACTER: If NAME is 'AUTO', assign a name. If '{user_defined_name}', use it.\n"
+            "2. VISUAL ANALYSIS: You MUST base your descriptions EXACTLY on the character's clothing and weapons in the attached IMAGE.\n"
+            "3. MASTER SCENE: Write a 1-sentence environment description (lighting, weather).\n"
+            "4. SPEED-FOCUSED CHOREOGRAPHY (CRITICAL):\n"
+            "   - 🚫 BAN SLOW-MOTION TRIGGERS: NEVER use words like 'micro-expressions', 'muscle tension', 'slowly turning', 'floating', or 'gradually'. These cause AI video models to render in slow-motion.\n"
+            "   - ✅ FORCE 1x REAL-TIME SPEED: Describe large, sweeping, high-velocity movements. Use aggressive verbs (dashing, sprinting, whipping, snapping).\n"
+            "   - ✅ KINETIC ADVERBS: Inject phrases like 'in a flash', 'at lightning speed', 'with explosive real-time velocity' into EVERY part.\n"
+            "   - Example: 'suddenly dashes forward at full speed and delivers a lightning-fast horizontal strike, moving so quickly the rain splatters'.\n"
+            "   - Strictly confine the actions. DO NOT animate future events early.\n"
+            "   - 🔥 OUTPUT RULE: DO NOT quote the Korean text. Only output English.\n"
+            "Format EXACTLY:\nCHARACTER: [Name]\nMASTER SCENE: [Description]\n"
+            "PART 1: [0-1s] [Action A] [2-3s] [Action B] [4-5s] [Action C]\n"
+            "PART 2: [0-1s] [Action D] [2-3s] [Action E] [4-5s] [Action F]\n"
+            "PART 3: [0-1s] [Action G] [2-3s] [Action H] [4-5s] [Action I]\n"
+            "PART 4: [0-1s] [Action J] [2-3s] [Action K] [4-5s] [Action L]"
+        )
+
+        usr_text = (
+            f"NAME: {character_name}\n"
+            f"VIBE: {artistic_vibe}\n\n"
+            "=== HIGH-SPEED ACTION SCRIPT ===\n"
+            f"▶ For PART 1 (0-5s), ONLY animate this: \"{chunk_1}\"\n"
+            f"▶ For PART 2 (5-10s), ONLY animate this: \"{chunk_2}\"\n"
+            f"▶ For PART 3 (10-15s), ONLY animate this: \"{chunk_3}\"\n"
+            f"▶ For PART 4 (15-20s), ONLY animate this: \"{chunk_4}\"\n"
+            "CRITICAL: Keep the action moving FAST. Avoid still poses or micro-details that look like slow-mo!"
+        )
+
+        url = "https://openrouter.ai/api/v1/chat/completions"
+        payload = {
+            "model": openrouter_model.strip(),
+            "messages": [
+                {"role": "system", "content": sys_prompt},
+                {"role": "user", "content": [
+                    {"type": "text", "text": usr_text},
+                    {"type": "image_url", "image_url": {"url": base64_image}}
+                ]}
+            ],
+            "temperature": creativity,
+            "max_tokens": max_tokens,
+        }
+
+        if not openrouter_api_key.strip():
+            err_msg = "⚠️ API Error: OpenRouter API key is empty."
+            return (err_msg, err_msg, err_msg, err_msg, err_msg)
+
+        llm_prompt, err = self._call_llm(url, payload, openrouter_api_key, retries)
+        if llm_prompt:
+            print(f"\n✅ [Dolphin V32 - Action Speed Optimized]\n{llm_prompt}\n")
+        else:
+            print(f"❌ [에러] API 호출 실패: {err}")
+            llm_prompt = ""
+
+        final_char_name = user_defined_name
+        r_master = ""
+        p1 = p2 = p3 = p4 = ""
+
+        if llm_prompt and "[removed]" not in llm_prompt:
+            cl = re.sub(r'[*#]', '', llm_prompt)
+            m_char = re.search(r'CHARACTER:\s*(.*?)(?=MASTER SCENE|$)', cl, re.I | re.S)
+            m_master = re.search(r'MASTER SCENE:\s*(.*?)(?=PART 1|$)', cl, re.I | re.S)
+
+            m1 = re.search(r'PART 1:\s*(.*?)(?=PART 2|$)', cl, re.I | re.S)
+            m2 = re.search(r'PART 2:\s*(.*?)(?=PART 3|$)', cl, re.I | re.S)
+            m3 = re.search(r'PART 3:\s*(.*?)(?=PART 4|$)', cl, re.I | re.S)
+            m4 = re.search(r'PART 4:\s*(.*?)(?=\n\n|===|Note:|$)', cl, re.I | re.S)
+
+            if not user_defined_name and m_char:
+                final_char_name = m_char.group(1).strip()
+
+            r_master = m_master.group(1).strip() if m_master else ""
+
+            # 파싱 실패 시 해당 청크(영문 지시문)를 폴백으로 사용해 비디오 프롬프트가 비지 않도록 함
+            p1 = m1.group(1).strip() if m1 else chunk_1
+            p2 = m2.group(1).strip() if m2 else chunk_2
+            p3 = m3.group(1).strip() if m3 else chunk_3
+            p4 = m4.group(1).strip() if m4 else chunk_4
+        else:
+            # API 실패 시에도 스크립트 청크를 폴백으로 반환 (완전 실패보다 유용)
+            p1, p2, p3, p4 = chunk_1, chunk_2, chunk_3, chunk_4
+
+        return (
+            build_final(p1, r_master, final_char_name),
+            build_final(p2, r_master, final_char_name),
+            build_final(p3, r_master, final_char_name),
+            build_final(p4, r_master, final_char_name),
+            llm_prompt if llm_prompt else "⚠️ API Error / empty response",
+        )

_archive/workflows/dolphin_tags_cache.json

@@ -0,0 +1,254 @@
+{
+    "wan22.r3v3rs3_c0wg1rl-14b-Low-i2v_e70.safetensors": [
+        "r3v3rs3_c0wg1rl",
+        "c0wg1rl",
+        "straddling  him in the reverse cowgirl position"
+    ],
+    "DR34ML4Y_I2V_14B_LOW_V2.safetensors": [
+        "m15510n4ry",
+        "bl0wj0b",
+        "d0gg1e",
+        "c0wg1rl",
+        "d0ubl3_bj"
+    ],
+    "wan22.r3v3rs3_c0wg1rl-14b-High-i2v_e70.safetensors": [
+        "r3v3rs3_c0wg1rl",
+        "c0wg1rl",
+        "straddling  him in the reverse cowgirl position"
+    ],
+    "DR34ML4Y_I2V_14B_HIGH_V2.safetensors": [
+        "m15510n4ry",
+        "bl0wj0b",
+        "c0wg1rl",
+        "d0gg1e",
+        "d0ubl3_bj"
+    ],
+    "erect_penis_epoch_80.safetensors": [
+        "penis"
+    ],
+    "PENISLORA_22_i2v_HIGH_e320.safetensors": [
+        "PENISLORA"
+    ],
+    "PENISLORA_22_i2v_LOW_e496.safetensors": [
+        "PENISLORA"
+    ],
+    "genitals_helper_v1.0_e219.safetensors": [
+        "Innie vagina",
+        "Outie vagina"
+    ],
+    "wan2.1-i2v-480p-penis-arousal-v1.0.safetensors": [
+        "penis becomes erect"
+    ],
+    "pusfix-e5-21.safetensors": [
+        "pusfix"
+    ],
+    "wan22-cunilingus-I2V-72epoc-low.safetensors": [
+        "cunn1l1ngu5"
+    ],
+    "wan22-cunilingus-I2V-106epoc-high.safetensors": [
+        "cunn1l1ngu5"
+    ],
+    "smoll-pp.high.wan2.2.t2v.safetensors": [
+        "small penis",
+        "she is stroking her small penis between two fingers",
+        "flaccid penis"
+    ],
+    "smoll-pp.low.wan2.2.t2v.safetensors": [
+        "small penis",
+        "she is stroking her small penis between two fingers",
+        "flaccid penis"
+    ],
+    "masturbation_cumshot_v1.1_e310.safetensors": [
+        "which lands on her {thighs|pelvis|stomach|face|breasts}",
+        "She moves her hand rapidly up and down the shaft of her penis and she ejaculates white sticky liquid from her penis"
+    ],
+    "wan2.1-i2v-480p-flaccid-v1.0.safetensors": [
+        "penis",
+        "bounce",
+        "swing"
+    ],
+    "wan2.2_i2v_highnoise_petplay_v2.0.safetensors": [
+        "The woman moves into in a paw pose with her fists raised, looking at the viewer.",
+        "She very slowly flicks her wrists, alternating between them back and forth in a cute begging motion. She is acting like a sexy pet.",
+        "She begins panting with her tongue out like a dog."
+    ],
+    "wan2.2_i2v_lownoise_petplay_v2.0.safetensors": [
+        "The woman moves into in a paw pose with her fists raised, looking at the viewer.",
+        "She very slowly flicks her wrists, alternating between them back and forth in a cute begging motion. She is acting like a sexy pet.",
+        "She begins panting with her tongue out like a dog."
+    ],
+    "wan22_i2v_futa_cowgirl_high_noise.safetensors": [
+        "a transgender woman having anal sex in cowgirl position"
+    ],
+    "wan22_i2v_futa_cowgirl_low_noise.safetensors": [
+        "a transgender woman having anal sex in cowgirl position"
+    ],
+    "anal_insertion_HIGH_V01.safetensors": [
+        "Anal insertion.",
+        "The video depicts a man slowly inserting his dick into a woman's anus",
+        "while she is lying on a couch.",
+        "The video depicts a sexual encounter between two animated characters, with one character being penetrated by the other.",
+        "The video depicts two animated characters engaging in sexual activity, with one character being penetrated by the other's erect penis.",
+        "close-up"
+    ],
+    "anal_insertion_LOW_V01.safetensors": [
+        "Anal insertion.",
+        "The video depicts a man slowly inserting his dick into a woman's anus",
+        "while she is lying on a couch.",
+        "The video depicts a sexual encounter between two animated characters, with one character being penetrated by the other.",
+        "The video depicts two animated characters engaging in sexual activity, with one character being penetrated by the other's erect penis."
+    ],
+    "wan22_t2v_penis_pen15_HIGH.safetensors": [
+        "pen15",
+        "penis"
+    ],
+    "wan22_t2v_penis_pen15_LOW.safetensors": [
+        "pen15",
+        "penis"
+    ],
+    "wan22_i2v_futa_missionary_low_noise.safetensors": [
+        "futa missionary"
+    ],
+    "wan22_i2v_futa_missionary_high_noise.safetensors": [
+        "futa missionary"
+    ],
+    "shemale anal missionary_high_noise.safetensors": [
+        "A transsexual woman is lying on her back while she gets fucked anally by a man's penis. The man's penis is penetrating her anus rapidly."
+    ],
+    "shemale anal missionary_low_noise.safetensors": [
+        "A transsexual woman is lying on her back while she gets fucked anally by a man's penis. The man's penis is penetrating her anus rapidly."
+    ],
+    "hardcore-gay_high_noise.safetensors": [
+        "hardc0re-gay"
+    ],
+    "hardcore-gay_low_noise.safetensors": [
+        "hardc0re-gay"
+    ],
+    "Blowbang_high_noise.safetensors": [
+        "A woman is surrounded by multiple penises, she is in the middle of the frame performing oral sex, men's torsos are around her, they all have huge penises which the woman is grabbing and putting inside her mouth."
+    ],
+    "xPenisGlanx_wan22_050626_low_noise_15k.safetensors": [
+        "Penis"
+    ],
+    "xPenisGlanx_wan22_050626_high_noise_15k.safetensors": [
+        "Penis"
+    ],
+    "wan_dildo_closeup_i2vA14B_HIGHNOISE_v20.safetensors": [
+        "piston_dildo_style"
+    ],
+    "wan_dildo_closeup_i2vA14B_LOWNOISE_v20.safetensors": [
+        "piston_dildo_style"
+    ],
+    "i2v-anus-squirt_high_noise.safetensors": [
+        "returnthis4nussqu1rt"
+    ],
+    "i2v-anus-squirt_low_noise.safetensors": [
+        "returnthis4nussqu1rt"
+    ],
+    "wan_2.2_i2v_slap_low_v2.0.safetensors": [
+        "she slaps herself in the face",
+        "she is slapped in the face"
+    ],
+    "wan_2.2_i2v_slap_high_v2.0.safetensors": [
+        "she slaps herself in the face",
+        "she is slapped in the face"
+    ],
+    "Twerking_I2V_high_noise.safetensors": [
+        "A woman is twerking and shaking her ass."
+    ],
+    "Twerking_I2V_low_noise.safetensors": [
+        "A woman is twerking and shaking her ass."
+    ],
+    "FistingHigh.safetensors": [
+        "Male fist is moving in and out of female vagina.",
+        "vaginal fisting",
+        "anal fisting"
+    ],
+    "FistingLow.safetensors": [
+        "Male fist is moving in and out of female vagina",
+        "vaginal fisting",
+        "anal fisting"
+    ],
+    "all-tied-up-wan22-HN-e50-az420.safetensors": [
+        "tied pose",
+        "rope",
+        "cuffs",
+        "spread-eagle"
+    ],
+    "all-tied-up-wan22-LN-e128-az420.safetensors": [
+        "tied",
+        "cuffs",
+        "rope",
+        "spread-eagle"
+    ],
+    "wan22_penis_coachbate_v2_high_noise.safetensors": [
+        "p3n15"
+    ],
+    "wan22_penis_coachbate_v2_low_noise.safetensors": [
+        "p3n15"
+    ],
+    "P00TSARA_v1_low_noise.safetensors": [
+        "uncut flaccid penis",
+        "P00TSARA"
+    ],
+    "P00TSARA_v1_high_noise.safetensors": [
+        "Uncut flaccid penis",
+        "P00TSARA"
+    ],
+    "wan2.1-i2v-480p-flaccid-v1.0.safetensors::359305272::1753134483": [
+        "penis",
+        "bounce",
+        "swing"
+    ],
+    "PENISLORA_22_i2v_HIGH_e320.safetensors::306807976::1759901296": [
+        "PENISLORA"
+    ],
+    "PENISLORA_22_i2v_LOW_e496.safetensors::306807976::1759901312": [
+        "PENISLORA"
+    ],
+    "masturbation_cumshot_v1.1_e310.safetensors::359257680::1747718457": [
+        "which lands on her {thighs|pelvis|stomach|face|breasts}",
+        "She moves her hand rapidly up and down the shaft of her penis and she ejaculates white sticky liquid from her penis"
+    ],
+    "DR34ML4Y_I2V_14B_HIGH_V2.safetensors::306807976::1767355819": [
+        "m15510n4ry",
+        "bl0wj0b",
+        "c0wg1rl",
+        "d0gg1e",
+        "d0ubl3_bj"
+    ],
+    "DR34ML4Y_I2V_14B_LOW_V2.safetensors::306807976::1767355809": [
+        "m15510n4ry",
+        "bl0wj0b",
+        "d0gg1e",
+        "c0wg1rl",
+        "d0ubl3_bj"
+    ],
+    "flaccid_penis_epoch_100.safetensors::306807976::1745233662": [
+        "penis"
+    ],
+    "erect_penis_epoch_80.safetensors::306807976::1744443760": [
+        "penis"
+    ],
+    "shemale anal missionary_high_noise.safetensors::306808400::1757087872": [
+        "A transsexual woman is lying on her back while she gets fucked anally by a man's penis. The man's penis is penetrating her anus rapidly."
+    ],
+    "shemale anal missionary_low_noise.safetensors::306808384::1757087881": [
+        "A transsexual woman is lying on her back while she gets fucked anally by a man's penis. The man's penis is penetrating her anus rapidly."
+    ],
+    "shemale doggy from behind_high_noise.safetensors::306808392::1757027152": [
+        "A transsexual woman is getting fucked doggystyle from behind by a man, the man is penetrating her anally as his penis is going inside her asshole, the man is moving his hips as he penetrates her and the woman is moving her body, she is looking back at the camera and at the man."
+    ],
+    "shemale doggy from behind_low_noise.safetensors::306808392::1766479090": [
+        "A transsexual woman is getting fucked doggystyle from behind by a man, the man is penetrating her anally as his penis is going inside her asshole, the man is moving his hips as he penetrates her and the woman is moving her body, she is looking back at the camera and at the man."
+    ],
+    "wan2.1-i2v-480p-penis-arousal-v1.0.safetensors::359305272::1754578081": [
+        "penis becomes erect"
+    ],
+    "TwerkReverse_WAN2.2_I2V_000002000_high_noise.safetensors::306808456::1764647417": [
+        "Twerk Reverse. A woman twerking moving her hips with a dynamic camera, she have an orgasm"
+    ],
+    "TwerkReverse_WAN2.2_I2V_000002000_low_noise.safetensors::306808456::1764647428": [
+        "Twerk Reverse. A nude woman twerking moving her hips with a dynamic camera, she have an orgasm"
+    ]
+}

_archive/workflows/i2vt2v.json

@@ -0,0 +1,2074 @@
+{
+  "id": "7cfb83ab-3b5c-4b57-8d01-aaf470a0dc04",
+  "revision": 0,
+  "last_node_id": 48,
+  "last_link_id": 170,
+  "nodes": [
+    {
+      "id": 19,
+      "type": "VAEDecode",
+      "pos": [
+        29307.375,
+        2498.96484375
+      ],
+      "size": [
+        210,
+        46
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 28
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 29
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "slot_index": 0,
+          "links": [
+            150,
+            168
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "VAEDecode",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 4,
+      "type": "VAELoader",
+      "pos": [
+        28419.005859375,
+        1797.971923828125
+      ],
+      "size": [
+        270,
+        58
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            13,
+            29,
+            154,
+            167
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.48",
+        "Node name for S&R": "VAELoader",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "vae_name": true
+          },
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "wan_2.1_vae.safetensors"
+      ]
+    },
+    {
+      "id": 9,
+      "type": "ModelPatchTorchSettings",
+      "pos": [
+        27743.802734375,
+        1795.334716796875
+      ],
+      "size": [
+        307.443359375,
+        58
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            42
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "87d0cf42db7d59992daba4d58a83655b5b359f44",
+        "Node name for S&R": "ModelPatchTorchSettings",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "enable_fp16_accumulation": true
+          },
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        true
+      ]
+    },
+    {
+      "id": 10,
+      "type": "ModelPatchTorchSettings",
+      "pos": [
+        27742.720703125,
+        1903.4395751953125
+      ],
+      "size": [
+        307.443359375,
+        58
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            43
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "87d0cf42db7d59992daba4d58a83655b5b359f44",
+        "Node name for S&R": "ModelPatchTorchSettings",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "enable_fp16_accumulation": true
+          },
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        true
+      ]
+    },
+    {
+      "id": 23,
+      "type": "ModelSamplingSD3",
+      "pos": [
+        28923.224609375,
+        1769.3892822265625
+      ],
+      "size": [
+        315,
+        58
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 44
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "slot_index": 0,
+          "links": [
+            45,
+            158
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "ModelSamplingSD3",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        5
+      ]
+    },
+    {
+      "id": 24,
+      "type": "ModelSamplingSD3",
+      "pos": [
+        29255.103515625,
+        1772.6326904296875
+      ],
+      "size": [
+        315,
+        58
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 46
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "slot_index": 0,
+          "links": [
+            47,
+            162
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "ModelSamplingSD3",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        5
+      ]
+    },
+    {
+      "id": 7,
+      "type": "PathchSageAttentionKJ",
+      "pos": [
+        27451.584398913365,
+        1777.1170290388295
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 144
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            3
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "87d0cf42db7d59992daba4d58a83655b5b359f44",
+        "Node name for S&R": "PathchSageAttentionKJ",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "sage_attention": true,
+            "allow_compile": true
+          },
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "auto",
+        false
+      ]
+    },
+    {
+      "id": 8,
+      "type": "PathchSageAttentionKJ",
+      "pos": [
+        27455.173828125,
+        1905.6007080078125
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 145
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            4
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "87d0cf42db7d59992daba4d58a83655b5b359f44",
+        "Node name for S&R": "PathchSageAttentionKJ",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "sage_attention": true,
+            "allow_compile": true
+          },
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "auto",
+        false
+      ]
+    },
+    {
+      "id": 15,
+      "type": "KSamplerAdvanced",
+      "pos": [
+        28958.892578125,
+        1905.600830078125
+      ],
+      "size": [
+        252.353515625,
+        546
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 45
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 16
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 17
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 18
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            52
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "KSamplerAdvanced",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "enable",
+        241347010900230,
+        "randomize",
+        8,
+        1,
+        "euler",
+        "simple",
+        0,
+        4,
+        "enable"
+      ]
+    },
+    {
+      "id": 18,
+      "type": "KSamplerAdvanced",
+      "pos": [
+        29270.234375,
+        1901.2767333984375
+      ],
+      "size": [
+        252.353515625,
+        546
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 47
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 26
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 27
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 52
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            28
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "KSamplerAdvanced",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "disable",
+        298951344552271,
+        "randomize",
+        8,
+        1,
+        "euler",
+        "simple",
+        4,
+        8,
+        "disable"
+      ]
+    },
+    {
+      "id": 20,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        29575.575678414556,
+        1907.1888648963077
+      ],
+      "size": [
+        705.6669921875,
+        1383.497090242347
+      ],
+      "flags": {},
+      "order": 28,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 170
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-videohelpersuite",
+        "ver": "1.7.2",
+        "Node name for S&R": "VHS_VideoCombine",
+        "aux_id": "Kosinkadink/ComfyUI-VideoHelperSuite",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": {
+        "frame_rate": 16,
+        "loop_count": 0,
+        "filename_prefix": "%date:yyyy-MM-dd%/wan2.2/video",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": true,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "video_00001.mp4",
+            "subfolder": "2026-07-09\\wan2.2",
+            "type": "output",
+            "format": "video/h264-mp4",
+            "frame_rate": 16,
+            "workflow": "video_00001.png",
+            "fullpath": "D:\\sd\\output\\2026-07-09\\wan2.2\\video_00001.mp4"
+          },
+          "muted": false
+        }
+      }
+    },
+    {
+      "id": 39,
+      "type": "UnetLoaderGGUF",
+      "pos": [
+        27085.405708029,
+        1493.6196103755808
+      ],
+      "size": [
+        270,
+        58
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            144
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-gguf",
+        "ver": "1.1.10",
+        "Node name for S&R": "UnetLoaderGGUF",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+      ]
+    },
+    {
+      "id": 40,
+      "type": "UnetLoaderGGUF",
+      "pos": [
+        27085.875545789593,
+        1609.6105258602975
+      ],
+      "size": [
+        270,
+        58
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            145
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-gguf",
+        "ver": "1.1.10",
+        "Node name for S&R": "UnetLoaderGGUF",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+      ]
+    },
+    {
+      "id": 25,
+      "type": "CLIPLoader",
+      "pos": [
+        27085.492869738202,
+        2050.0593519193803
+      ],
+      "size": [
+        270,
+        106
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            48,
+            49
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.48",
+        "Node name for S&R": "CLIPLoader",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "clip_name": true,
+            "type": true,
+            "device": true
+          },
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+        "wan",
+        "default"
+      ]
+    },
+    {
+      "id": 5,
+      "type": "Power Lora Loader (rgthree)",
+      "pos": [
+        27455.154296875,
+        2013.7054443359375
+      ],
+      "size": [
+        496.79267373832045,
+        275.3138892438692
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "dir": 3,
+          "name": "model",
+          "type": "MODEL",
+          "link": 42
+        },
+        {
+          "dir": 3,
+          "name": "clip",
+          "type": "CLIP",
+          "link": 48
+        }
+      ],
+      "outputs": [
+        {
+          "dir": 4,
+          "name": "MODEL",
+          "shape": 3,
+          "type": "MODEL",
+          "links": [
+            44
+          ]
+        },
+        {
+          "dir": 4,
+          "name": "CLIP",
+          "shape": 3,
+          "type": "CLIP",
+          "links": [
+            10,
+            78,
+            151
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "rgthree-comfy",
+        "ver": "c5ffa43de4ddb17244626a65a30700a05dd6b67d",
+        "Show Strengths": "Single Strength",
+        "Match": "",
+        "aux_id": "rgthree/rgthree-comfy",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        {},
+        {
+          "type": "PowerLoraLoaderHeaderWidget"
+        },
+        {
+          "on": true,
+          "lora": "Wan_2_2_I2V_A14B_HIGH_lightx2v_4step_lora_v1030_rank_64_bf16.safetensors",
+          "strength": 1,
+          "strengthTwo": null
+        },
+        {
+          "on": true,
+          "lora": "scene_change_nsfw_v2.0_high_noise.safetensors",
+          "strength": 0.7,
+          "strengthTwo": null
+        },
+        {
+          "on": true,
+          "lora": "mql_doggy_b_v1_high_noise.safetensors",
+          "strength": 0.7,
+          "strengthTwo": null
+        },
+        {
+          "on": false,
+          "lora": "wan\\penis_detail_test3_000000300_high_noise.safetensors",
+          "strength": 1,
+          "strengthTwo": null
+        },
+        {
+          "on": false,
+          "lora": "wan\\penis_texture_test_2_000000300_high_noise.safetensors",
+          "strength": 2.8,
+          "strengthTwo": null
+        },
+        {
+          "on": false,
+          "lora": "wan\\penis_test_high_noise.safetensors",
+          "strength": 1,
+          "strengthTwo": null
+        },
+        {},
+        ""
+      ]
+    },
+    {
+      "id": 6,
+      "type": "Power Lora Loader (rgthree)",
+      "pos": [
+        27450.704005508218,
+        2346.34927377847
+      ],
+      "size": [
+        585.5521610911674,
+        264.77373397977635
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "dir": 3,
+          "name": "model",
+          "type": "MODEL",
+          "link": 43
+        },
+        {
+          "dir": 3,
+          "name": "clip",
+          "type": "CLIP",
+          "link": 49
+        }
+      ],
+      "outputs": [
+        {
+          "dir": 4,
+          "name": "MODEL",
+          "shape": 3,
+          "type": "MODEL",
+          "links": [
+            46
+          ]
+        },
+        {
+          "dir": 4,
+          "name": "CLIP",
+          "shape": 3,
+          "type": "CLIP",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "rgthree-comfy",
+        "ver": "c5ffa43de4ddb17244626a65a30700a05dd6b67d",
+        "Show Strengths": "Single Strength",
+        "Match": "",
+        "aux_id": "rgthree/rgthree-comfy",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        {},
+        {
+          "type": "PowerLoraLoaderHeaderWidget"
+        },
+        {
+          "on": true,
+          "lora": "wan2.2_i2v_A14b_low_noise_lora_rank64_lightx2v_4step_1022.safetensors",
+          "strength": 1,
+          "strengthTwo": null
+        },
+        {
+          "on": false,
+          "lora": "wan\\scene_change_v2_mw_low_noise.safetensors",
+          "strength": 1,
+          "strengthTwo": null
+        },
+        {
+          "on": true,
+          "lora": "mql_doggy_a_wan22_t2v_v1_low_noise.safetensors",
+          "strength": 0.6,
+          "strengthTwo": null
+        },
+        {
+          "on": true,
+          "lora": "DR34ML4Y_I2V_14B_LOW_V2.safetensors",
+          "strength": 1,
+          "strengthTwo": null
+        },
+        {
+          "on": false,
+          "lora": "wan\\penis_texture_test_2_000000300_low_noise.safetensors",
+          "strength": 1,
+          "strengthTwo": null
+        },
+        {
+          "on": false,
+          "lora": "wan\\penis_test_low_noise.safetensors",
+          "strength": 1,
+          "strengthTwo": null
+        },
+        {},
+        ""
+      ]
+    },
+    {
+      "id": 12,
+      "type": "CLIPTextEncode",
+      "pos": [
+        27932.95597879707,
+        2771.850316163266
+      ],
+      "size": [
+        492.141357421875,
+        127.27951049804688
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 10
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "slot_index": 0,
+          "links": [
+            128,
+            153
+          ]
+        }
+      ],
+      "title": "CLIP Text Encode (Negative Prompt)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "CLIPTextEncode",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        ""
+      ],
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 11,
+      "type": "CLIPTextEncode",
+      "pos": [
+        27921.20592312598,
+        2478.051712480355
+      ],
+      "size": [
+        489.7083740234375,
+        231.58657836914062
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 78
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "slot_index": 0,
+          "links": [
+            143
+          ]
+        }
+      ],
+      "title": "CLIP Text Encode (Positive Prompt)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "CLIPTextEncode",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "mqldgy_b. A woman and a man sex scene. The woman is standing. The woman gets down on all fours on ground. The man kneels behind the woman, thrusts his penis back and forth in her vagina. This video is a first-person perspective video from the man's point of view, from above. The man's body-mounted camera. Viewer's crotch visible. Viewer's face invisible. The woman looks at viewer."
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 14,
+      "type": "LoadImage",
+      "pos": [
+        28453.30464535701,
+        2423.844580226772
+      ],
+      "size": [
+        488.76470947265625,
+        523.6205444335938
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "slot_index": 0,
+          "links": [
+            146
+          ]
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "slot_index": 1,
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "LoadImage",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "ComfyUI_00993_.png",
+        "image"
+      ]
+    },
+    {
+      "id": 41,
+      "type": "WanNativeResize_Dolphin",
+      "pos": [
+        28077.456746430405,
+        2003.5213822441738
+      ],
+      "size": [
+        310.2759765625,
+        146
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 146
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            147
+          ]
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            148,
+            156
+          ]
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            149,
+            157
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "WanNativeResize_Dolphin",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "720P (1280x720)",
+        "lanczos",
+        16
+      ]
+    },
+    {
+      "id": 13,
+      "type": "WanImageToVideo",
+      "pos": [
+        28417.96484375,
+        1912.74853515625
+      ],
+      "size": [
+        492.7348327636719,
+        210
+      ],
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 143
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 128
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 13
+        },
+        {
+          "name": "clip_vision_output",
+          "shape": 7,
+          "type": "CLIP_VISION_OUTPUT",
+          "link": null
+        },
+        {
+          "name": "start_image",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": 147
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "widget": {
+            "name": "width"
+          },
+          "link": 148
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "widget": {
+            "name": "height"
+          },
+          "link": 149
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "slot_index": 0,
+          "links": [
+            16,
+            26
+          ]
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "slot_index": 1,
+          "links": [
+            17,
+            27
+          ]
+        },
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "slot_index": 2,
+          "links": [
+            18
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "WanImageToVideo",
+        "ue_properties": {
+          "version": "7.8",
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        768,
+        768,
+        81,
+        1
+      ]
+    },
+    {
+      "id": 42,
+      "type": "ImageFromBatch",
+      "pos": [
+        29900,
+        2500
+      ],
+      "size": [
+        270,
+        106
+      ],
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 150
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            155
+          ]
+        }
+      ],
+      "title": "Get Last Frame of Clip A",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "ImageFromBatch"
+      },
+      "widgets_values": [
+        -1,
+        1
+      ]
+    },
+    {
+      "id": 43,
+      "type": "CLIPTextEncode",
+      "pos": [
+        29900,
+        2700
+      ],
+      "size": [
+        489.708,
+        231.586
+      ],
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 151
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "slot_index": 0,
+          "links": [
+            152
+          ]
+        }
+      ],
+      "title": "CLIP Text Encode (Scene 2 / Scene Change Prompt)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        ""
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 44,
+      "type": "WanImageToVideo",
+      "pos": [
+        30300,
+        2500
+      ],
+      "size": [
+        492.735,
+        210
+      ],
+      "flags": {},
+      "order": 23,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 152
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 153
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 154
+        },
+        {
+          "name": "clip_vision_output",
+          "shape": 7,
+          "type": "CLIP_VISION_OUTPUT",
+          "link": null
+        },
+        {
+          "name": "start_image",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": 155
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "widget": {
+            "name": "width"
+          },
+          "link": 156
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "widget": {
+            "name": "height"
+          },
+          "link": 157
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "slot_index": 0,
+          "links": [
+            159,
+            163
+          ]
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "slot_index": 1,
+          "links": [
+            160,
+            164
+          ]
+        },
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "slot_index": 2,
+          "links": [
+            161
+          ]
+        }
+      ],
+      "title": "Wan Image To Video (Clip B / Scene Change)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "WanImageToVideo"
+      },
+      "widgets_values": [
+        768,
+        768,
+        81,
+        1
+      ]
+    },
+    {
+      "id": 45,
+      "type": "KSamplerAdvanced",
+      "pos": [
+        30850,
+        1900
+      ],
+      "size": [
+        252.353,
+        546
+      ],
+      "flags": {},
+      "order": 24,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 158
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 159
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 160
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 161
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            165
+          ]
+        }
+      ],
+      "title": "KSampler (Clip B, High Noise Model)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "KSamplerAdvanced"
+      },
+      "widgets_values": [
+        "enable",
+        123456789012345,
+        "randomize",
+        8,
+        1,
+        "euler",
+        "simple",
+        0,
+        4,
+        "enable"
+      ]
+    },
+    {
+      "id": 46,
+      "type": "KSamplerAdvanced",
+      "pos": [
+        31150,
+        1900
+      ],
+      "size": [
+        252.353,
+        546
+      ],
+      "flags": {},
+      "order": 25,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 162
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 163
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 164
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 165
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            166
+          ]
+        }
+      ],
+      "title": "KSampler (Clip B, Low Noise Model)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "KSamplerAdvanced"
+      },
+      "widgets_values": [
+        "disable",
+        298951344552399,
+        "randomize",
+        8,
+        1,
+        "euler",
+        "simple",
+        4,
+        8,
+        "disable"
+      ]
+    },
+    {
+      "id": 47,
+      "type": "VAEDecode",
+      "pos": [
+        31450,
+        2500
+      ],
+      "size": [
+        210,
+        46
+      ],
+      "flags": {},
+      "order": 26,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 166
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 167
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "slot_index": 0,
+          "links": [
+            169
+          ]
+        }
+      ],
+      "title": "VAE Decode (Clip B)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "VAEDecode"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 48,
+      "type": "ImageBatch",
+      "pos": [
+        31450,
+        2700
+      ],
+      "size": [
+        210,
+        80
+      ],
+      "flags": {},
+      "order": 27,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image1",
+          "type": "IMAGE",
+          "link": 168
+        },
+        {
+          "name": "image2",
+          "type": "IMAGE",
+          "link": 169
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            170
+          ]
+        }
+      ],
+      "title": "Concatenate Clip A + Clip B Frames",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.47",
+        "Node name for S&R": "ImageBatch"
+      },
+      "widgets_values": []
+    }
+  ],
+  "links": [
+    [
+      3,
+      7,
+      0,
+      9,
+      0,
+      "MODEL"
+    ],
+    [
+      4,
+      8,
+      0,
+      10,
+      0,
+      "MODEL"
+    ],
+    [
+      10,
+      5,
+      1,
+      12,
+      0,
+      "CLIP"
+    ],
+    [
+      13,
+      4,
+      0,
+      13,
+      2,
+      "VAE"
+    ],
+    [
+      16,
+      13,
+      0,
+      15,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      17,
+      13,
+      1,
+      15,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      18,
+      13,
+      2,
+      15,
+      3,
+      "LATENT"
+    ],
+    [
+      26,
+      13,
+      0,
+      18,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      27,
+      13,
+      1,
+      18,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      28,
+      18,
+      0,
+      19,
+      0,
+      "LATENT"
+    ],
+    [
+      29,
+      4,
+      0,
+      19,
+      1,
+      "VAE"
+    ],
+    [
+      42,
+      9,
+      0,
+      5,
+      0,
+      "MODEL"
+    ],
+    [
+      43,
+      10,
+      0,
+      6,
+      0,
+      "MODEL"
+    ],
+    [
+      44,
+      5,
+      0,
+      23,
+      0,
+      "MODEL"
+    ],
+    [
+      45,
+      23,
+      0,
+      15,
+      0,
+      "MODEL"
+    ],
+    [
+      46,
+      6,
+      0,
+      24,
+      0,
+      "MODEL"
+    ],
+    [
+      47,
+      24,
+      0,
+      18,
+      0,
+      "MODEL"
+    ],
+    [
+      48,
+      25,
+      0,
+      5,
+      1,
+      "CLIP"
+    ],
+    [
+      49,
+      25,
+      0,
+      6,
+      1,
+      "CLIP"
+    ],
+    [
+      51,
+      19,
+      0,
+      20,
+      0,
+      "IMAGE"
+    ],
+    [
+      52,
+      15,
+      0,
+      18,
+      3,
+      "LATENT"
+    ],
+    [
+      78,
+      5,
+      1,
+      11,
+      0,
+      "CLIP"
+    ],
+    [
+      128,
+      12,
+      0,
+      13,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      143,
+      11,
+      0,
+      13,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      144,
+      39,
+      0,
+      7,
+      0,
+      "MODEL"
+    ],
+    [
+      145,
+      40,
+      0,
+      8,
+      0,
+      "MODEL"
+    ],
+    [
+      146,
+      14,
+      0,
+      41,
+      0,
+      "IMAGE"
+    ],
+    [
+      147,
+      41,
+      0,
+      13,
+      4,
+      "IMAGE"
+    ],
+    [
+      148,
+      41,
+      1,
+      13,
+      5,
+      "INT"
+    ],
+    [
+      149,
+      41,
+      2,
+      13,
+      6,
+      "INT"
+    ],
+    [
+      150,
+      19,
+      0,
+      42,
+      0,
+      "IMAGE"
+    ],
+    [
+      151,
+      5,
+      1,
+      43,
+      0,
+      "CLIP"
+    ],
+    [
+      152,
+      43,
+      0,
+      44,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      153,
+      12,
+      0,
+      44,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      154,
+      4,
+      0,
+      44,
+      2,
+      "VAE"
+    ],
+    [
+      155,
+      42,
+      0,
+      44,
+      4,
+      "IMAGE"
+    ],
+    [
+      156,
+      41,
+      1,
+      44,
+      5,
+      "INT"
+    ],
+    [
+      157,
+      41,
+      2,
+      44,
+      6,
+      "INT"
+    ],
+    [
+      158,
+      23,
+      0,
+      45,
+      0,
+      "MODEL"
+    ],
+    [
+      159,
+      44,
+      0,
+      45,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      160,
+      44,
+      1,
+      45,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      161,
+      44,
+      2,
+      45,
+      3,
+      "LATENT"
+    ],
+    [
+      162,
+      24,
+      0,
+      46,
+      0,
+      "MODEL"
+    ],
+    [
+      163,
+      44,
+      0,
+      46,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      164,
+      44,
+      1,
+      46,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      165,
+      45,
+      0,
+      46,
+      3,
+      "LATENT"
+    ],
+    [
+      166,
+      46,
+      0,
+      47,
+      0,
+      "LATENT"
+    ],
+    [
+      167,
+      4,
+      0,
+      47,
+      1,
+      "VAE"
+    ],
+    [
+      168,
+      19,
+      0,
+      48,
+      0,
+      "IMAGE"
+    ],
+    [
+      169,
+      47,
+      0,
+      48,
+      1,
+      "IMAGE"
+    ],
+    [
+      170,
+      48,
+      0,
+      20,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.5559917313492576,
+      "offset": [
+        -26186.496366607487,
+        -1194.6780790078822
+      ]
+    },
+    "workflowRendererVersion": "LG",
+    "ue_links": [],
+    "links_added_by_ue": [],
+    "frontendVersion": "1.45.20",
+    "VHS_latentpreview": false,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": false,
+    "VHS_KeepIntermediate": true,
+    "anomalous_hashes": {}
+  },
+  "version": 0.4
+}

_archive/workflows/krea2 inpaint.json

@@ -0,0 +1,1510 @@
+{
+  "id": "94d9ce78-c6d4-45b5-b65f-7f7cdda98616",
+  "revision": 0,
+  "last_node_id": 49,
+  "last_link_id": 87,
+  "nodes": [
+    {
+      "id": 25,
+      "type": "Label (rgthree)",
+      "pos": [
+        502.89126314973754,
+        568.6440437433788
+      ],
+      "size": [
+        547.05810546875,
+        25
+      ],
+      "flags": {
+        "allow_interaction": true
+      },
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "And choose Open in Mask Editor | Image Canvas",
+      "properties": {
+        "fontSize": 25,
+        "fontFamily": "Arial",
+        "fontColor": "#ffffff",
+        "textAlign": "left",
+        "backgroundColor": "transparent",
+        "padding": 0,
+        "borderRadius": 0,
+        "angle": 0,
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        }
+      },
+      "color": "#fff0",
+      "bgcolor": "#fff0"
+    },
+    {
+      "id": 26,
+      "type": "Label (rgthree)",
+      "pos": [
+        557.4292270417669,
+        521.8881876346229
+      ],
+      "size": [
+        408.50830078125,
+        25
+      ],
+      "flags": {
+        "allow_interaction": true
+      },
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "To inpaint mask, right click on mouse",
+      "properties": {
+        "fontSize": 25,
+        "fontFamily": "Arial",
+        "fontColor": "#ffffff",
+        "textAlign": "left",
+        "backgroundColor": "transparent",
+        "padding": 0,
+        "borderRadius": 0,
+        "angle": 0,
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        }
+      },
+      "color": "#fff0",
+      "bgcolor": "#fff0"
+    },
+    {
+      "id": 32,
+      "type": "Label (rgthree)",
+      "pos": [
+        -1027.309220513278,
+        -587.2079374535729
+      ],
+      "size": [
+        730.810546875,
+        50
+      ],
+      "flags": {
+        "allow_interaction": true
+      },
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Notes (Recomend it for a review)",
+      "properties": {
+        "fontSize": 50,
+        "fontFamily": "Arial",
+        "fontColor": "#ffffff",
+        "textAlign": "left",
+        "backgroundColor": "transparent",
+        "padding": 0,
+        "borderRadius": 0,
+        "angle": 0,
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "color": "#fff0",
+      "bgcolor": "#fff0"
+    },
+    {
+      "id": 35,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        228.5066115955086,
+        -565.064232779069
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 40
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            41
+          ]
+        }
+      ],
+      "title": "Turbo Lora",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.26.0",
+        "Node name for S&R": "LoraLoaderModelOnly",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "krea2\\krea2_turbo_lora_rank_64_bf16.safetensors",
+        1
+      ]
+    },
+    {
+      "id": 36,
+      "type": "PathchSageAttentionKJ",
+      "pos": [
+        1340.6725366844717,
+        356.52514598362905
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 42
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            44
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "1.4.7",
+        "Node name for S&R": "PathchSageAttentionKJ",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "auto",
+        false
+      ]
+    },
+    {
+      "id": 37,
+      "type": "Fast Groups Bypasser (rgthree)",
+      "pos": [
+        223.1305491471883,
+        -314.79010528541266
+      ],
+      "size": [
+        397.4609463381595,
+        100.1651829564488
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "OPT_CONNECTION",
+          "type": "*",
+          "links": null
+        }
+      ],
+      "properties": {
+        "matchColors": "",
+        "matchTitle": "",
+        "showNav": true,
+        "showAllGraphs": true,
+        "sort": "position",
+        "customSortAlphabet": "",
+        "toggleRestriction": "default",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      }
+    },
+    {
+      "id": 24,
+      "type": "Label (rgthree)",
+      "pos": [
+        1013.1815196156713,
+        -901.8562984252738
+      ],
+      "size": [
+        867.2607421875,
+        150
+      ],
+      "flags": {
+        "allow_interaction": true
+      },
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "krea2 Inpaint",
+      "properties": {
+        "fontSize": 150,
+        "fontFamily": "Arial",
+        "fontColor": "#ffd000",
+        "textAlign": "left",
+        "backgroundColor": "transparent",
+        "padding": 0,
+        "borderRadius": 0,
+        "angle": 0,
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "color": "#fff0",
+      "bgcolor": "#fff0"
+    },
+    {
+      "id": 33,
+      "type": "Note",
+      "pos": [
+        -1146.177246566986,
+        -451.25718147677554
+      ],
+      "size": [
+        885.1822916666667,
+        509.9479166666667
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Models and .whl files",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "Required models for Krea2 Workflow:\n\nKrea2 (Raw or Turbo): https://huggingface.co/Comfy-Org/Krea-2/tree/main/diffusion_models\nText Encoder: https://huggingface.co/Comfy-Org/Krea-2/tree/main/text_encoders\nVAE: https://huggingface.co/Comfy-Org/Krea-2/tree/main/vae\n\nAlso I recommend download uncendored encoder for nsfw and danbooru prompting https://huggingface.co/ahmed22xa/Huihui-Qwen3-VL-4B-Instruct-abliterated-comfy/resolve/main/Huihui-Qwen3-VL-4B-Instruct-abliterated.safetensors\n\nAlso recomend using VAE Wan 2.1 for better result https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/vae/wan_2.1_vae.safetensors\n\nTurbo Lora (if you use Raw model): https://huggingface.co/Comfy-Org/Krea-2/blob/main/loras/krea2_turbo_lora_rank_64_bf16.safetensors\n\n\nFile save location\n\nComfyUI/\n├───📂 models/\n│   ├───📂 diffusion_models/\n│   │   ├─── krea2_turbo_bf16.safetensors\n│   ├───📂 loras/\n│   │   ├─── krea2_turbo_lora_rank_64_bf16.safetensors\n│   │   ├─── Any loras if you want\n│   ├───📂 text_encoders/\n│   │   └─── qwen3vl_4b_bf16.safetensors\n│   └───📂 vae/\n│       └── qwen_image_vae.safetensors\n\n\n\n\n\n\n\n"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 7,
+      "type": "VAELoader",
+      "pos": [
+        -101.17303068778611,
+        -161.27559798417792
+      ],
+      "size": [
+        270,
+        58
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            17,
+            53
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "VAELoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        }
+      },
+      "widgets_values": [
+        "krea2RealVae_v10.safetensors"
+      ]
+    },
+    {
+      "id": 31,
+      "type": "CLIPLoader",
+      "pos": [
+        -114.65834305333588,
+        -343.0687626475736
+      ],
+      "size": [
+        270,
+        106
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            39
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.18.1",
+        "Node name for S&R": "CLIPLoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "qwen3vl_4b_bf16.safetensors",
+        "krea2",
+        "default"
+      ]
+    },
+    {
+      "id": 28,
+      "type": "Lora Loader (LoraManager)",
+      "pos": [
+        670.7284687869626,
+        -573.0369690519098
+      ],
+      "size": [
+        568.1487855001747,
+        366.0932833710507
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 41
+        },
+        {
+          "name": "clip",
+          "shape": 7,
+          "type": "CLIP",
+          "link": 39
+        },
+        {
+          "name": "lora_stack",
+          "shape": 7,
+          "type": "LORA_STACK",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            42
+          ]
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            31,
+            37
+          ]
+        },
+        {
+          "name": "trigger_words",
+          "type": "STRING",
+          "links": [
+            30
+          ]
+        },
+        {
+          "name": "loaded_loras",
+          "type": "STRING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-lora-manager",
+        "ver": "0.9.11",
+        "Node name for S&R": "Lora Loader (LoraManager)",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        },
+        "__lm_widget_ids": [
+          "__lm_autocomplete_meta_text",
+          "text",
+          "loras"
+        ]
+      },
+      "widgets_values": [
+        {
+          "version": 1,
+          "textWidgetName": "text"
+        },
+        "",
+        []
+      ],
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 27,
+      "type": "TriggerWord Toggle (LoraManager)",
+      "pos": [
+        1369.622929842321,
+        -802.2472095519896
+      ],
+      "size": [
+        333.8873046875,
+        284
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "trigger_words",
+          "shape": 7,
+          "type": "string",
+          "link": 30
+        }
+      ],
+      "outputs": [
+        {
+          "name": "filtered_trigger_words",
+          "type": "STRING",
+          "links": [
+            32
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-lora-manager",
+        "ver": "0.9.11",
+        "Node name for S&R": "TriggerWord Toggle (LoraManager)",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        }
+      },
+      "widgets_values": [
+        true,
+        true,
+        false,
+        [],
+        ""
+      ],
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 9,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1372.03106655687,
+        -102.39676636158624
+      ],
+      "size": [
+        400,
+        200
+      ],
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 37
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            46
+          ]
+        }
+      ],
+      "title": "Negative Prompt",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.44",
+        "Node name for S&R": "CLIPTextEncode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "pale tones, blurry, flat colors, poor anatomy, dull lighting, text, watermark, messy composition, low contrast, white background, black background, skirt, pose, wrong proportion, black hand, suite, bag, breast"
+      ],
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 39,
+      "type": "JWImageResizeByLongerSide",
+      "pos": [
+        817.3239958429691,
+        -110.63714541080098
+      ],
+      "size": [
+        291.593359375,
+        82
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 50
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            52,
+            78
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-various",
+        "ver": "5bd85aaf7616878471469c4ec7e11bbd0cef3bf2",
+        "Node name for S&R": "JWImageResizeByLongerSide",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        1472,
+        "bicubic"
+      ]
+    },
+    {
+      "id": 1,
+      "type": "LoadImage",
+      "pos": [
+        -90.56216073008177,
+        46.14239606345017
+      ],
+      "size": [
+        282.798828125,
+        314
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            50
+          ]
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            55,
+            79
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "LoadImage",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        },
+        "image": "clipspace/clipspace-painted-masked-1784191942701.png [input]"
+      },
+      "widgets_values": [
+        "clipspace/clipspace-painted-masked-1784191942701.png [input]",
+        "image"
+      ]
+    },
+    {
+      "id": 30,
+      "type": "UNETLoader",
+      "pos": [
+        -121.66298929390322,
+        -630.6289599251239
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            40
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.18.1",
+        "Node name for S&R": "UNETLoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "krea2TurboOfficialComfy_krea2TurboNvfp4.safetensors",
+        "default"
+      ]
+    },
+    {
+      "id": 29,
+      "type": "Prompt (LoraManager)",
+      "pos": [
+        1383.7331523126124,
+        -405.5066756515228
+      ],
+      "size": [
+        407.86960005322544,
+        233.17855783027926
+      ],
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 31
+        },
+        {
+          "name": "seed",
+          "shape": 7,
+          "type": "INT",
+          "link": null
+        },
+        {
+          "name": "trigger_words1",
+          "shape": 7,
+          "type": "STRING",
+          "link": 32
+        },
+        {
+          "name": "trigger_words2",
+          "type": "STRING",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            45
+          ]
+        },
+        {
+          "name": "PROMPT",
+          "type": "STRING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-lora-manager",
+        "ver": "4fcf641d5780e5cf140a54f1c23fd31117ddb7e2",
+        "Node name for S&R": "Prompt (LoraManager)",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        },
+        "__lm_widget_ids": [
+          "__lm_autocomplete_meta_text",
+          "text"
+        ]
+      },
+      "widgets_values": [
+        {
+          "version": 1,
+          "textWidgetName": "text",
+          "lastAccepted": {
+            "start": 0,
+            "end": 9,
+            "insertedText": "12beat13,",
+            "textSnapshot": "12beat13,"
+          }
+        },
+        "korean girl"
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 14,
+      "type": "SaveImage",
+      "pos": [
+        321.27544781116023,
+        211.9154535777168
+      ],
+      "size": [
+        805.0496647217428,
+        1203.507734814826
+      ],
+      "flags": {},
+      "order": 24,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 62
+        }
+      ],
+      "outputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "SaveImage",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        }
+      },
+      "widgets_values": [
+        "ComfyUI"
+      ]
+    },
+    {
+      "id": 12,
+      "type": "VAEDecode",
+      "pos": [
+        1854.727483188264,
+        -298.49849528544695
+      ],
+      "size": [
+        140,
+        46
+      ],
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 48
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 17
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            80,
+            85
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "VAEDecode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        }
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 40,
+      "type": "VAEEncode",
+      "pos": [
+        1286.2014157680758,
+        31.86479772775502
+      ],
+      "size": [
+        210,
+        46
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "pixels",
+          "type": "IMAGE",
+          "link": 52
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 53
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            54
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "VAEEncode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 41,
+      "type": "SetLatentNoiseMask",
+      "pos": [
+        1546.2014157680758,
+        31.86479772775502
+      ],
+      "size": [
+        210,
+        46
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 54
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 55
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            56
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "SetLatentNoiseMask",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 43,
+      "type": "LanPaint_MaskBlend",
+      "pos": [
+        2388.816702727679,
+        -146.92603208283066
+      ],
+      "size": [
+        270,
+        110
+      ],
+      "flags": {},
+      "order": 23,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image1",
+          "type": "IMAGE",
+          "link": 82
+        },
+        {
+          "name": "image2",
+          "type": "IMAGE",
+          "link": 87
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 83
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            62
+          ]
+        }
+      ],
+      "title": "Blend Seam with Original",
+      "properties": {
+        "cnr_id": "lanpaint",
+        "ver": "1.5.5",
+        "Node name for S&R": "LanPaint_MaskBlend",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        51
+      ]
+    },
+    {
+      "id": 48,
+      "type": "MatchImageAndMaskSize_Dolphin",
+      "pos": [
+        1286.2014157680758,
+        151.86479772775502
+      ],
+      "size": [
+        270,
+        130
+      ],
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image_to_resize",
+          "type": "IMAGE",
+          "link": 78
+        },
+        {
+          "name": "mask_to_resize",
+          "type": "MASK",
+          "link": 79
+        },
+        {
+          "name": "reference_image",
+          "type": "IMAGE",
+          "link": 80
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            82,
+            84
+          ]
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "links": [
+            83,
+            86
+          ]
+        }
+      ],
+      "title": "Match Original to Output Size",
+      "properties": {
+        "Node name for S&R": "MatchImageAndMaskSize_Dolphin",
+        "cnr_id": "dolphin_nodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 49,
+      "type": "MaskRegionColorMatch_Dolphin",
+      "pos": [
+        2165.4644495383623,
+        -332.50977690725466
+      ],
+      "size": [
+        270,
+        170
+      ],
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "original_image",
+          "type": "IMAGE",
+          "link": 84
+        },
+        {
+          "name": "generated_image",
+          "type": "IMAGE",
+          "link": 85
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 86
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            87
+          ]
+        }
+      ],
+      "title": "Color Match (Mask Region Only)",
+      "properties": {
+        "Node name for S&R": "MaskRegionColorMatch_Dolphin",
+        "cnr_id": "dolphin_nodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "reinhard",
+        0.5,
+        150,
+        40
+      ]
+    },
+    {
+      "id": 38,
+      "type": "LanPaint_KSamplerAdvanced",
+      "pos": [
+        1920.0939764613263,
+        -141.16323281521963
+      ],
+      "size": [
+        383.1676476648677,
+        950
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 44
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 45
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 46
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 56
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            48
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "lanpaint",
+        "ver": "1.5.5",
+        "Node name for S&R": "LanPaint_KSamplerAdvanced",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "enable",
+        198527596812840,
+        "randomize",
+        8,
+        1,
+        "euler",
+        "simple",
+        0,
+        10000,
+        "disable",
+        3,
+        10.0,
+        0.1,
+        0.5,
+        10.0,
+        "Image First",
+        2,
+        "LanPaint KSampler Adv.",
+        "🖼️ Image Inpainting",
+        0.0,
+        1,
+        "lanpaint_star_button"
+      ]
+    }
+  ],
+  "links": [
+    [
+      17,
+      7,
+      0,
+      12,
+      1,
+      "VAE"
+    ],
+    [
+      30,
+      28,
+      2,
+      27,
+      0,
+      "string"
+    ],
+    [
+      31,
+      28,
+      1,
+      29,
+      0,
+      "CLIP"
+    ],
+    [
+      32,
+      27,
+      0,
+      29,
+      2,
+      "STRING"
+    ],
+    [
+      37,
+      28,
+      1,
+      9,
+      0,
+      "CLIP"
+    ],
+    [
+      39,
+      31,
+      0,
+      28,
+      1,
+      "CLIP"
+    ],
+    [
+      40,
+      30,
+      0,
+      35,
+      0,
+      "MODEL"
+    ],
+    [
+      41,
+      35,
+      0,
+      28,
+      0,
+      "MODEL"
+    ],
+    [
+      42,
+      28,
+      0,
+      36,
+      0,
+      "MODEL"
+    ],
+    [
+      44,
+      36,
+      0,
+      38,
+      0,
+      "MODEL"
+    ],
+    [
+      45,
+      29,
+      0,
+      38,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      46,
+      9,
+      0,
+      38,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      48,
+      38,
+      0,
+      12,
+      0,
+      "LATENT"
+    ],
+    [
+      50,
+      1,
+      0,
+      39,
+      0,
+      "IMAGE"
+    ],
+    [
+      52,
+      39,
+      0,
+      40,
+      0,
+      "IMAGE"
+    ],
+    [
+      53,
+      7,
+      0,
+      40,
+      1,
+      "VAE"
+    ],
+    [
+      54,
+      40,
+      0,
+      41,
+      0,
+      "LATENT"
+    ],
+    [
+      55,
+      1,
+      1,
+      41,
+      1,
+      "MASK"
+    ],
+    [
+      56,
+      41,
+      0,
+      38,
+      3,
+      "LATENT"
+    ],
+    [
+      62,
+      43,
+      0,
+      14,
+      0,
+      "IMAGE"
+    ],
+    [
+      78,
+      39,
+      0,
+      48,
+      0,
+      "IMAGE"
+    ],
+    [
+      79,
+      1,
+      1,
+      48,
+      1,
+      "MASK"
+    ],
+    [
+      80,
+      12,
+      0,
+      48,
+      2,
+      "IMAGE"
+    ],
+    [
+      82,
+      48,
+      0,
+      43,
+      0,
+      "IMAGE"
+    ],
+    [
+      83,
+      48,
+      1,
+      43,
+      2,
+      "MASK"
+    ],
+    [
+      84,
+      48,
+      0,
+      49,
+      0,
+      "IMAGE"
+    ],
+    [
+      85,
+      12,
+      0,
+      49,
+      1,
+      "IMAGE"
+    ],
+    [
+      86,
+      48,
+      1,
+      49,
+      2,
+      "MASK"
+    ],
+    [
+      87,
+      49,
+      0,
+      43,
+      1,
+      "IMAGE"
+    ]
+  ],
+  "groups": [
+    {
+      "id": 1,
+      "title": "Turbo Lora",
+      "bounding": [
+        217.02048263467339,
+        -648.7621951869007,
+        299.2239373235054,
+        191.911637393992
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 2,
+      "title": "Sageattention",
+      "bounding": [
+        1316.448516061584,
+        300.1227252083272,
+        317.4210206114476,
+        152.78808325362013
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {
+    "workflowRendererVersion": "LG",
+    "ue_links": [],
+    "ds": {
+      "scale": 0.6934334949441378,
+      "offset": [
+        -328.05025247996747,
+        878.3799578784656
+      ]
+    },
+    "links_added_by_ue": [],
+    "frontendVersion": "1.45.20",
+    "VHS_latentpreview": false,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": false,
+    "VHS_KeepIntermediate": true
+  },
+  "version": 0.4
+}

_archive/workflows/krea2 inpaint_2.json

@@ -0,0 +1,1500 @@
+{
+  "id": "94d9ce78-c6d4-45b5-b65f-7f7cdda98616",
+  "revision": 0,
+  "last_node_id": 49,
+  "last_link_id": 87,
+  "nodes": [
+    {
+      "id": 25,
+      "type": "Label (rgthree)",
+      "pos": [
+        502.89126314973754,
+        568.6440437433788
+      ],
+      "size": [
+        547.05810546875,
+        25
+      ],
+      "flags": {
+        "allow_interaction": true
+      },
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "And choose Open in Mask Editor | Image Canvas",
+      "properties": {
+        "fontSize": 25,
+        "fontFamily": "Arial",
+        "fontColor": "#ffffff",
+        "textAlign": "left",
+        "backgroundColor": "transparent",
+        "padding": 0,
+        "borderRadius": 0,
+        "angle": 0,
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        }
+      },
+      "color": "#fff0",
+      "bgcolor": "#fff0"
+    },
+    {
+      "id": 26,
+      "type": "Label (rgthree)",
+      "pos": [
+        557.4292270417669,
+        521.8881876346229
+      ],
+      "size": [
+        408.50830078125,
+        25
+      ],
+      "flags": {
+        "allow_interaction": true
+      },
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "To inpaint mask, right click on mouse",
+      "properties": {
+        "fontSize": 25,
+        "fontFamily": "Arial",
+        "fontColor": "#ffffff",
+        "textAlign": "left",
+        "backgroundColor": "transparent",
+        "padding": 0,
+        "borderRadius": 0,
+        "angle": 0,
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        }
+      },
+      "color": "#fff0",
+      "bgcolor": "#fff0"
+    },
+    {
+      "id": 32,
+      "type": "Label (rgthree)",
+      "pos": [
+        -1027.309220513278,
+        -587.2079374535729
+      ],
+      "size": [
+        730.810546875,
+        50
+      ],
+      "flags": {
+        "allow_interaction": true
+      },
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Notes (Recomend it for a review)",
+      "properties": {
+        "fontSize": 50,
+        "fontFamily": "Arial",
+        "fontColor": "#ffffff",
+        "textAlign": "left",
+        "backgroundColor": "transparent",
+        "padding": 0,
+        "borderRadius": 0,
+        "angle": 0,
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "color": "#fff0",
+      "bgcolor": "#fff0"
+    },
+    {
+      "id": 35,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        228.5066115955086,
+        -565.064232779069
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 40
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            41
+          ]
+        }
+      ],
+      "title": "Turbo Lora",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.26.0",
+        "Node name for S&R": "LoraLoaderModelOnly",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "krea2\\krea2_turbo_lora_rank_64_bf16.safetensors",
+        1
+      ]
+    },
+    {
+      "id": 36,
+      "type": "PathchSageAttentionKJ",
+      "pos": [
+        1340.6725366844717,
+        356.52514598362905
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 42
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            44
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "1.4.7",
+        "Node name for S&R": "PathchSageAttentionKJ",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "auto",
+        false
+      ]
+    },
+    {
+      "id": 37,
+      "type": "Fast Groups Bypasser (rgthree)",
+      "pos": [
+        223.1305491471883,
+        -314.79010528541266
+      ],
+      "size": [
+        397.4609463381595,
+        100.1651829564488
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "OPT_CONNECTION",
+          "type": "*",
+          "links": null
+        }
+      ],
+      "properties": {
+        "matchColors": "",
+        "matchTitle": "",
+        "showNav": true,
+        "showAllGraphs": true,
+        "sort": "position",
+        "customSortAlphabet": "",
+        "toggleRestriction": "default",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      }
+    },
+    {
+      "id": 24,
+      "type": "Label (rgthree)",
+      "pos": [
+        1013.1815196156713,
+        -901.8562984252738
+      ],
+      "size": [
+        867.2607421875,
+        150
+      ],
+      "flags": {
+        "allow_interaction": true
+      },
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "krea2 Inpaint",
+      "properties": {
+        "fontSize": 150,
+        "fontFamily": "Arial",
+        "fontColor": "#ffd000",
+        "textAlign": "left",
+        "backgroundColor": "transparent",
+        "padding": 0,
+        "borderRadius": 0,
+        "angle": 0,
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "color": "#fff0",
+      "bgcolor": "#fff0"
+    },
+    {
+      "id": 33,
+      "type": "Note",
+      "pos": [
+        -1146.177246566986,
+        -451.25718147677554
+      ],
+      "size": [
+        885.1822916666667,
+        509.9479166666667
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Models and .whl files",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "Required models for Krea2 Workflow:\n\nKrea2 (Raw or Turbo): https://huggingface.co/Comfy-Org/Krea-2/tree/main/diffusion_models\nText Encoder: https://huggingface.co/Comfy-Org/Krea-2/tree/main/text_encoders\nVAE: https://huggingface.co/Comfy-Org/Krea-2/tree/main/vae\n\nAlso I recommend download uncendored encoder for nsfw and danbooru prompting https://huggingface.co/ahmed22xa/Huihui-Qwen3-VL-4B-Instruct-abliterated-comfy/resolve/main/Huihui-Qwen3-VL-4B-Instruct-abliterated.safetensors\n\nAlso recomend using VAE Wan 2.1 for better result https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/vae/wan_2.1_vae.safetensors\n\nTurbo Lora (if you use Raw model): https://huggingface.co/Comfy-Org/Krea-2/blob/main/loras/krea2_turbo_lora_rank_64_bf16.safetensors\n\n\nFile save location\n\nComfyUI/\n├───📂 models/\n│   ├───📂 diffusion_models/\n│   │   ├─── krea2_turbo_bf16.safetensors\n│   ├───📂 loras/\n│   │   ├─── krea2_turbo_lora_rank_64_bf16.safetensors\n│   │   ├─── Any loras if you want\n│   ├───📂 text_encoders/\n│   │   └─── qwen3vl_4b_bf16.safetensors\n│   └───📂 vae/\n│       └── qwen_image_vae.safetensors\n\n\n\n\n\n\n\n"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 7,
+      "type": "VAELoader",
+      "pos": [
+        -101.17303068778611,
+        -161.27559798417792
+      ],
+      "size": [
+        270,
+        58
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            17,
+            53
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "VAELoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        }
+      },
+      "widgets_values": [
+        "krea2RealVae_v10.safetensors"
+      ]
+    },
+    {
+      "id": 31,
+      "type": "CLIPLoader",
+      "pos": [
+        -114.65834305333588,
+        -343.0687626475736
+      ],
+      "size": [
+        270,
+        106
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            39
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.18.1",
+        "Node name for S&R": "CLIPLoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "qwen3vl_4b_bf16.safetensors",
+        "krea2",
+        "default"
+      ]
+    },
+    {
+      "id": 28,
+      "type": "Lora Loader (LoraManager)",
+      "pos": [
+        670.7284687869626,
+        -573.0369690519098
+      ],
+      "size": [
+        568.1487855001747,
+        366.0932833710507
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 41
+        },
+        {
+          "name": "clip",
+          "shape": 7,
+          "type": "CLIP",
+          "link": 39
+        },
+        {
+          "name": "lora_stack",
+          "shape": 7,
+          "type": "LORA_STACK",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            42
+          ]
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            31,
+            37
+          ]
+        },
+        {
+          "name": "trigger_words",
+          "type": "STRING",
+          "links": [
+            30
+          ]
+        },
+        {
+          "name": "loaded_loras",
+          "type": "STRING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-lora-manager",
+        "ver": "0.9.11",
+        "Node name for S&R": "Lora Loader (LoraManager)",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        },
+        "__lm_widget_ids": [
+          "__lm_autocomplete_meta_text",
+          "text",
+          "loras"
+        ]
+      },
+      "widgets_values": [
+        {
+          "version": 1,
+          "textWidgetName": "text"
+        },
+        "",
+        []
+      ],
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 27,
+      "type": "TriggerWord Toggle (LoraManager)",
+      "pos": [
+        1369.622929842321,
+        -802.2472095519896
+      ],
+      "size": [
+        333.8873046875,
+        284
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "trigger_words",
+          "shape": 7,
+          "type": "string",
+          "link": 30
+        }
+      ],
+      "outputs": [
+        {
+          "name": "filtered_trigger_words",
+          "type": "STRING",
+          "links": [
+            32
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-lora-manager",
+        "ver": "0.9.11",
+        "Node name for S&R": "TriggerWord Toggle (LoraManager)",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        }
+      },
+      "widgets_values": [
+        true,
+        true,
+        false,
+        [],
+        ""
+      ],
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 9,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1372.03106655687,
+        -102.39676636158624
+      ],
+      "size": [
+        400,
+        200
+      ],
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 37
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            46
+          ]
+        }
+      ],
+      "title": "Negative Prompt",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.3.44",
+        "Node name for S&R": "CLIPTextEncode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "pale tones, blurry, flat colors, poor anatomy, dull lighting, text, watermark, messy composition, low contrast, white background, black background, skirt, pose, wrong proportion, black hand, suite, bag, breast"
+      ],
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 39,
+      "type": "JWImageResizeByLongerSide",
+      "pos": [
+        817.3239958429691,
+        -110.63714541080098
+      ],
+      "size": [
+        291.593359375,
+        82
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 50
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            52,
+            78
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-various",
+        "ver": "5bd85aaf7616878471469c4ec7e11bbd0cef3bf2",
+        "Node name for S&R": "JWImageResizeByLongerSide",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        1472,
+        "bicubic"
+      ]
+    },
+    {
+      "id": 1,
+      "type": "LoadImage",
+      "pos": [
+        -90.56216073008177,
+        46.14239606345017
+      ],
+      "size": [
+        282.798828125,
+        314
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            50
+          ]
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            55,
+            79
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "LoadImage",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        },
+        "image": "clipspace/clipspace-painted-masked-1784191942701.png [input]"
+      },
+      "widgets_values": [
+        "clipspace/clipspace-painted-masked-1784191942701.png [input]",
+        "image"
+      ]
+    },
+    {
+      "id": 30,
+      "type": "UNETLoader",
+      "pos": [
+        -121.66298929390322,
+        -630.6289599251239
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            40
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.18.1",
+        "Node name for S&R": "UNETLoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "krea2TurboOfficialComfy_krea2TurboNvfp4.safetensors",
+        "default"
+      ]
+    },
+    {
+      "id": 29,
+      "type": "Prompt (LoraManager)",
+      "pos": [
+        1383.7331523126124,
+        -405.5066756515228
+      ],
+      "size": [
+        407.86960005322544,
+        233.17855783027926
+      ],
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 31
+        },
+        {
+          "name": "seed",
+          "shape": 7,
+          "type": "INT",
+          "link": null
+        },
+        {
+          "name": "trigger_words1",
+          "shape": 7,
+          "type": "STRING",
+          "link": 32
+        },
+        {
+          "name": "trigger_words2",
+          "type": "STRING",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            45
+          ]
+        },
+        {
+          "name": "PROMPT",
+          "type": "STRING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-lora-manager",
+        "ver": "4fcf641d5780e5cf140a54f1c23fd31117ddb7e2",
+        "Node name for S&R": "Prompt (LoraManager)",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        },
+        "__lm_widget_ids": [
+          "__lm_autocomplete_meta_text",
+          "text"
+        ]
+      },
+      "widgets_values": [
+        {
+          "version": 1,
+          "textWidgetName": "text",
+          "lastAccepted": {
+            "start": 0,
+            "end": 9,
+            "insertedText": "12beat13,",
+            "textSnapshot": "12beat13,"
+          }
+        },
+        "korean girl"
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 14,
+      "type": "SaveImage",
+      "pos": [
+        321.27544781116023,
+        211.9154535777168
+      ],
+      "size": [
+        805.0496647217428,
+        1203.507734814826
+      ],
+      "flags": {},
+      "order": 26,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 62
+        }
+      ],
+      "outputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "SaveImage",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        }
+      },
+      "widgets_values": [
+        "ComfyUI"
+      ]
+    },
+    {
+      "id": 12,
+      "type": "VAEDecode",
+      "pos": [
+        1854.727483188264,
+        -298.49849528544695
+      ],
+      "size": [
+        140,
+        46
+      ],
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 48
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 17
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            80,
+            85
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "VAEDecode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.7"
+        }
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 40,
+      "type": "VAEEncode",
+      "pos": [
+        1286.2014157680758,
+        31.86479772775502
+      ],
+      "size": [
+        210,
+        46
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "pixels",
+          "type": "IMAGE",
+          "link": 52
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 53
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            54
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "VAEEncode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 41,
+      "type": "SetLatentNoiseMask",
+      "pos": [
+        1546.2014157680758,
+        31.86479772775502
+      ],
+      "size": [
+        210,
+        46
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 54
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 55
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            56
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.16.4",
+        "Node name for S&R": "SetLatentNoiseMask",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 43,
+      "type": "LanPaint_MaskBlend",
+      "pos": [
+        2388.816702727679,
+        -146.92603208283066
+      ],
+      "size": [
+        270,
+        110
+      ],
+      "flags": {},
+      "order": 25,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image1",
+          "type": "IMAGE",
+          "link": 82
+        },
+        {
+          "name": "image2",
+          "type": "IMAGE",
+          "link": 87
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 83
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            62
+          ]
+        }
+      ],
+      "title": "Blend Seam with Original",
+      "properties": {
+        "cnr_id": "lanpaint",
+        "ver": "1.5.5",
+        "Node name for S&R": "LanPaint_MaskBlend",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        51
+      ]
+    },
+    {
+      "id": 38,
+      "type": "LanPaint_KSamplerAdvanced",
+      "pos": [
+        1920.0939764613263,
+        -141.16323281521963
+      ],
+      "size": [
+        383.1676476648677,
+        950
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 44
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 45
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 46
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 56
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            48
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "lanpaint",
+        "ver": "1.5.5",
+        "Node name for S&R": "LanPaint_KSamplerAdvanced",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "enable",
+        198527596812840,
+        "randomize",
+        8,
+        1,
+        "euler",
+        "beta57",
+        0,
+        10000,
+        "disable",
+        3,
+        10.0,
+        0.1,
+        0.5,
+        10.0,
+        "Image First",
+        2,
+        "LanPaint KSampler Adv.",
+        "🖼️ Image Inpainting",
+        0.0,
+        1,
+        "lanpaint_star_button"
+      ]
+    },
+    {
+      "id": 48,
+      "type": "MatchImageAndMaskSize_Dolphin",
+      "pos": [
+        1286.2014157680758,
+        151.86479772775502
+      ],
+      "size": [
+        270,
+        130
+      ],
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image_to_resize",
+          "type": "IMAGE",
+          "link": 78
+        },
+        {
+          "name": "mask_to_resize",
+          "type": "MASK",
+          "link": 79
+        },
+        {
+          "name": "reference_image",
+          "type": "IMAGE",
+          "link": 80
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            82,
+            84
+          ]
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "links": [
+            83,
+            86
+          ]
+        }
+      ],
+      "title": "Match Original to Output Size",
+      "properties": {
+        "cnr_id": "dolphin_nodes",
+        "Node name for S&R": "MatchImageAndMaskSize_Dolphin"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 49,
+      "type": "MaskRegionColorMatch_Dolphin",
+      "pos": [
+        2165.4644495383623,
+        -332.50977690725466
+      ],
+      "size": [
+        270,
+        170
+      ],
+      "flags": {},
+      "order": 24,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "original_image",
+          "type": "IMAGE",
+          "link": 84
+        },
+        {
+          "name": "generated_image",
+          "type": "IMAGE",
+          "link": 85
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 86
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            87
+          ]
+        }
+      ],
+      "title": "Color Match (Mask Region Only)",
+      "properties": {
+        "cnr_id": "dolphin_nodes",
+        "Node name for S&R": "MaskRegionColorMatch_Dolphin"
+      },
+      "widgets_values": [
+        "reinhard",
+        0.5,
+        150,
+        40
+      ]
+    }
+  ],
+  "links": [
+    [
+      17,
+      7,
+      0,
+      12,
+      1,
+      "VAE"
+    ],
+    [
+      30,
+      28,
+      2,
+      27,
+      0,
+      "string"
+    ],
+    [
+      31,
+      28,
+      1,
+      29,
+      0,
+      "CLIP"
+    ],
+    [
+      32,
+      27,
+      0,
+      29,
+      2,
+      "STRING"
+    ],
+    [
+      37,
+      28,
+      1,
+      9,
+      0,
+      "CLIP"
+    ],
+    [
+      39,
+      31,
+      0,
+      28,
+      1,
+      "CLIP"
+    ],
+    [
+      40,
+      30,
+      0,
+      35,
+      0,
+      "MODEL"
+    ],
+    [
+      41,
+      35,
+      0,
+      28,
+      0,
+      "MODEL"
+    ],
+    [
+      42,
+      28,
+      0,
+      36,
+      0,
+      "MODEL"
+    ],
+    [
+      44,
+      36,
+      0,
+      38,
+      0,
+      "MODEL"
+    ],
+    [
+      45,
+      29,
+      0,
+      38,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      46,
+      9,
+      0,
+      38,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      48,
+      38,
+      0,
+      12,
+      0,
+      "LATENT"
+    ],
+    [
+      50,
+      1,
+      0,
+      39,
+      0,
+      "IMAGE"
+    ],
+    [
+      52,
+      39,
+      0,
+      40,
+      0,
+      "IMAGE"
+    ],
+    [
+      53,
+      7,
+      0,
+      40,
+      1,
+      "VAE"
+    ],
+    [
+      54,
+      40,
+      0,
+      41,
+      0,
+      "LATENT"
+    ],
+    [
+      55,
+      1,
+      1,
+      41,
+      1,
+      "MASK"
+    ],
+    [
+      56,
+      41,
+      0,
+      38,
+      3,
+      "LATENT"
+    ],
+    [
+      62,
+      43,
+      0,
+      14,
+      0,
+      "IMAGE"
+    ],
+    [
+      78,
+      39,
+      0,
+      48,
+      0,
+      "IMAGE"
+    ],
+    [
+      79,
+      1,
+      1,
+      48,
+      1,
+      "MASK"
+    ],
+    [
+      80,
+      12,
+      0,
+      48,
+      2,
+      "IMAGE"
+    ],
+    [
+      82,
+      48,
+      0,
+      43,
+      0,
+      "IMAGE"
+    ],
+    [
+      83,
+      48,
+      1,
+      43,
+      2,
+      "MASK"
+    ],
+    [
+      84,
+      48,
+      0,
+      49,
+      0,
+      "IMAGE"
+    ],
+    [
+      85,
+      12,
+      0,
+      49,
+      1,
+      "IMAGE"
+    ],
+    [
+      86,
+      48,
+      1,
+      49,
+      2,
+      "MASK"
+    ],
+    [
+      87,
+      49,
+      0,
+      43,
+      1,
+      "IMAGE"
+    ]
+  ],
+  "groups": [
+    {
+      "id": 1,
+      "title": "Turbo Lora",
+      "bounding": [
+        217.02048263467339,
+        -648.7621951869007,
+        299.2239373235054,
+        191.911637393992
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 2,
+      "title": "Sageattention",
+      "bounding": [
+        1316.448516061584,
+        300.1227252083272,
+        317.4210206114476,
+        152.78808325362013
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {
+    "workflowRendererVersion": "LG",
+    "ue_links": [],
+    "ds": {
+      "scale": 0.6934334949441378,
+      "offset": [
+        -984.5986415646988,
+        659.1808549965879
+      ]
+    },
+    "links_added_by_ue": [],
+    "frontendVersion": "1.45.20",
+    "VHS_latentpreview": false,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": false,
+    "VHS_KeepIntermediate": true
+  },
+  "version": 0.4
+}

_archive/workflows/slowmo_ab_test_A_core_wanimagetovideo.json

@@ -0,0 +1,1131 @@
+{
+ "last_node_id": 20,
+ "last_link_id": 28,
+ "nodes": [
+  {
+   "id": 1,
+   "type": "CLIPLoader",
+   "pos": [
+    0,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 0,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "CLIP",
+     "type": "CLIP",
+     "links": [
+      5,
+      6
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPLoader"
+   },
+   "widgets_values": [
+    "nsfw_wan_umt5-xxl_fp8_scaled.safetensors",
+    "wan",
+    "default"
+   ]
+  },
+  {
+   "id": 2,
+   "type": "VAELoader",
+   "pos": [
+    0,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 1,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "VAE",
+     "type": "VAE",
+     "links": [
+      16,
+      27
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAELoader"
+   },
+   "widgets_values": [
+    "Wan2_1_VAE_bf16.safetensors"
+   ]
+  },
+  {
+   "id": 3,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 2,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      1
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+   ],
+   "title": "High-noise UNet"
+  },
+  {
+   "id": 4,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 3,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      3
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+   ],
+   "title": "Low-noise UNet"
+  },
+  {
+   "id": 5,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 4,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 1
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      2,
+      7
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI_v2_PRO_Wan2.2-I2V-A14B_HIGH_lora_rank_128_fp16.safetensors",
+    1.0
+   ],
+   "title": "SVI LoRA (HIGH, 1.0) = base_high"
+  },
+  {
+   "id": 6,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 5,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 2
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      9
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan21_I2V_14B_lightx2v_cfg_step_distill_lora_rank64.safetensors",
+    1.0
+   ],
+   "title": "+ lightx2v (1.0) = lightning_high"
+  },
+  {
+   "id": 7,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 6,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 3
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      4
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI_v2_PRO_Wan2.2-I2V-A14B_LOW_lora_rank_128_fp16.safetensors",
+    1.0
+   ],
+   "title": "SVI LoRA (LOW, 1.0)"
+  },
+  {
+   "id": 8,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 7,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 4
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      11
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan21_I2V_14B_lightx2v_cfg_step_distill_lora_rank64.safetensors",
+    1.5
+   ],
+   "title": "+ lightx2v (1.5) = lightning_low"
+  },
+  {
+   "id": 9,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 8,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 5
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      8,
+      10,
+      12,
+      14
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "fast fluid continuous motion, real-time speed, dynamic movement, no slow motion, no freeze frame"
+   ],
+   "title": "Positive prompt"
+  },
+  {
+   "id": 10,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 9,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 6
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      15
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "static, frozen, slow motion, freeze frame, low quality, blurry, motionless"
+   ],
+   "title": "Negative prompt"
+  },
+  {
+   "id": 11,
+   "type": "WanVideoNAG",
+   "pos": [
+    1080,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 10,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 7
+    },
+    {
+     "name": "conditioning",
+     "type": "CONDITIONING",
+     "link": 8
+    }
+   ],
+   "outputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "links": [
+      20
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanVideoNAG"
+   },
+   "widgets_values": [
+    11.0,
+    0.25,
+    2.5,
+    "default",
+    false
+   ],
+   "title": "NAG(base_high)"
+  },
+  {
+   "id": 12,
+   "type": "WanVideoNAG",
+   "pos": [
+    1080,
+    400
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 11,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 9
+    },
+    {
+     "name": "conditioning",
+     "type": "CONDITIONING",
+     "link": 10
+    }
+   ],
+   "outputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "links": [
+      21
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanVideoNAG"
+   },
+   "widgets_values": [
+    11.0,
+    0.25,
+    2.5,
+    "default",
+    false
+   ],
+   "title": "NAG(lightning_high)"
+  },
+  {
+   "id": 13,
+   "type": "WanVideoNAG",
+   "pos": [
+    1080,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 12,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 11
+    },
+    {
+     "name": "conditioning",
+     "type": "CONDITIONING",
+     "link": 12
+    }
+   ],
+   "outputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "links": [
+      22
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanVideoNAG"
+   },
+   "widgets_values": [
+    11.0,
+    0.25,
+    2.5,
+    "default",
+    false
+   ],
+   "title": "NAG(lightning_low)"
+  },
+  {
+   "id": 14,
+   "type": "LoadImage",
+   "pos": [
+    1440,
+    660
+   ],
+   "size": [
+    320,
+    320
+   ],
+   "flags": {},
+   "order": 13,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      13
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "MASK",
+     "type": "MASK",
+     "links": [],
+     "slot_index": 1
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoadImage"
+   },
+   "widgets_values": [
+    "input.png",
+    "image"
+   ]
+  },
+  {
+   "id": 15,
+   "type": "WanNativeResize_Dolphin",
+   "pos": [
+    1800,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 14,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "image",
+     "type": "IMAGE",
+     "link": 13
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      17
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "links": [
+      18
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "links": [
+      19
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanNativeResize_Dolphin"
+   },
+   "widgets_values": [
+    "480P (832x480)",
+    "lanczos",
+    16
+   ]
+  },
+  {
+   "id": 16,
+   "type": "WanImageToVideo",
+   "pos": [
+    2160,
+    160
+   ],
+   "size": [
+    320,
+    220
+   ],
+   "flags": {},
+   "order": 15,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 14
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 15
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 16
+    },
+    {
+     "name": "clip_vision_output",
+     "type": "CLIP_VISION_OUTPUT",
+     "link": null,
+     "shape": 7
+    },
+    {
+     "name": "start_image",
+     "type": "IMAGE",
+     "link": 17,
+     "shape": 7
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "link": 18,
+     "widget": {
+      "name": "width"
+     }
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "link": 19,
+     "widget": {
+      "name": "height"
+     }
+    }
+   ],
+   "outputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "links": [
+      23
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "links": [
+      24
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "latent",
+     "type": "LATENT",
+     "links": [
+      25
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanImageToVideo"
+   },
+   "widgets_values": [
+    832,
+    480,
+    81,
+    1
+   ],
+   "title": "A: core WanImageToVideo"
+  },
+  {
+   "id": 17,
+   "type": "TripleKSamplerWan22LightningAdvanced",
+   "pos": [
+    2560,
+    160
+   ],
+   "size": [
+    360,
+    420
+   ],
+   "flags": {},
+   "order": 16,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "base_high",
+     "type": "MODEL",
+     "link": 20
+    },
+    {
+     "name": "lightning_high",
+     "type": "MODEL",
+     "link": 21
+    },
+    {
+     "name": "lightning_low",
+     "type": "MODEL",
+     "link": 22
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 23
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 24
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 25
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      26
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "TripleKSamplerWan22LightningAdvanced"
+   },
+   "widgets_values": [
+    909090909090,
+    "fixed",
+    5.0,
+    20,
+    -1,
+    5.0,
+    "euler",
+    "simple",
+    1,
+    20,
+    1.0,
+    "euler",
+    "simple",
+    "50% of steps",
+    -1,
+    0.875,
+    false
+   ],
+   "title": "TripleKSamplerWan22LightningAdvanced (real prod values: base_cfg=5, lightning_steps=20, boundary=0.875)"
+  },
+  {
+   "id": 18,
+   "type": "VAEDecode",
+   "pos": [
+    2960,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 17,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "samples",
+     "type": "LATENT",
+     "link": 26
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 27
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      28
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEDecode"
+   },
+   "widgets_values": []
+  },
+  {
+   "id": 19,
+   "type": "VHS_VideoCombine",
+   "pos": [
+    3320,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 18,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "images",
+     "type": "IMAGE",
+     "link": 28
+    }
+   ],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "VHS_VideoCombine"
+   },
+   "widgets_values": {
+    "frame_rate": 16,
+    "loop_count": 0,
+    "filename_prefix": "wan22_slowmo/ab_test_A_core_wanimagetovideo",
+    "format": "video/h264-mp4",
+    "pingpong": false,
+    "save_image": true,
+    "crf": 19,
+    "save_metadata": true,
+    "audio_file": ""
+   }
+  },
+  {
+   "id": 20,
+   "type": "Note",
+   "pos": [
+    2560,
+    620
+   ],
+   "size": [
+    1000,
+    220
+   ],
+   "flags": {},
+   "order": 19,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "Note"
+   },
+   "widgets_values": [
+    "A/B 테스트 A안: 코어 WanImageToVideo 사용 (SVIProGray 대신).\nB안과 완전히 동일한 모델/LoRA(base_high/lightning_high/lightning_low)/NAG/TripleKSamplerWan22LightningAdvanced 설정, 컨디셔닝 노드만 다름.\n여기서도 후반부 그레이가 나오면, 문제는 wan_svipro_gray.py가 아니라 '앵커 1장 + 81프레임 필러'라는 방식 자체가 이 LoRA/스텝 예산에서 한계에 부딪히는 것."
+   ],
+   "title": "A/B Test A: core WanImageToVideo",
+   "color": "#432",
+   "bgcolor": "#653"
+  }
+ ],
+ "links": [
+  [
+   1,
+   3,
+   0,
+   5,
+   0,
+   "MODEL"
+  ],
+  [
+   2,
+   5,
+   0,
+   6,
+   0,
+   "MODEL"
+  ],
+  [
+   3,
+   4,
+   0,
+   7,
+   0,
+   "MODEL"
+  ],
+  [
+   4,
+   7,
+   0,
+   8,
+   0,
+   "MODEL"
+  ],
+  [
+   5,
+   1,
+   0,
+   9,
+   0,
+   "CLIP"
+  ],
+  [
+   6,
+   1,
+   0,
+   10,
+   0,
+   "CLIP"
+  ],
+  [
+   7,
+   5,
+   0,
+   11,
+   0,
+   "MODEL"
+  ],
+  [
+   8,
+   9,
+   0,
+   11,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   9,
+   6,
+   0,
+   12,
+   0,
+   "MODEL"
+  ],
+  [
+   10,
+   9,
+   0,
+   12,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   11,
+   8,
+   0,
+   13,
+   0,
+   "MODEL"
+  ],
+  [
+   12,
+   9,
+   0,
+   13,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   13,
+   14,
+   0,
+   15,
+   0,
+   "IMAGE"
+  ],
+  [
+   14,
+   9,
+   0,
+   16,
+   0,
+   "CONDITIONING"
+  ],
+  [
+   15,
+   10,
+   0,
+   16,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   16,
+   2,
+   0,
+   16,
+   2,
+   "VAE"
+  ],
+  [
+   17,
+   15,
+   0,
+   16,
+   4,
+   "IMAGE"
+  ],
+  [
+   18,
+   15,
+   1,
+   16,
+   5,
+   "INT"
+  ],
+  [
+   19,
+   15,
+   2,
+   16,
+   6,
+   "INT"
+  ],
+  [
+   20,
+   11,
+   0,
+   17,
+   0,
+   "MODEL"
+  ],
+  [
+   21,
+   12,
+   0,
+   17,
+   1,
+   "MODEL"
+  ],
+  [
+   22,
+   13,
+   0,
+   17,
+   2,
+   "MODEL"
+  ],
+  [
+   23,
+   16,
+   0,
+   17,
+   3,
+   "CONDITIONING"
+  ],
+  [
+   24,
+   16,
+   1,
+   17,
+   4,
+   "CONDITIONING"
+  ],
+  [
+   25,
+   16,
+   2,
+   17,
+   5,
+   "LATENT"
+  ],
+  [
+   26,
+   17,
+   0,
+   18,
+   0,
+   "LATENT"
+  ],
+  [
+   27,
+   2,
+   0,
+   18,
+   1,
+   "VAE"
+  ],
+  [
+   28,
+   18,
+   0,
+   19,
+   0,
+   "IMAGE"
+  ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}

_archive/workflows/slowmo_ab_test_B_svigray.json

@@ -0,0 +1,1151 @@
+{
+ "last_node_id": 21,
+ "last_link_id": 28,
+ "nodes": [
+  {
+   "id": 1,
+   "type": "CLIPLoader",
+   "pos": [
+    0,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 0,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "CLIP",
+     "type": "CLIP",
+     "links": [
+      5,
+      6
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPLoader"
+   },
+   "widgets_values": [
+    "nsfw_wan_umt5-xxl_fp8_scaled.safetensors",
+    "wan",
+    "default"
+   ]
+  },
+  {
+   "id": 2,
+   "type": "VAELoader",
+   "pos": [
+    0,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 1,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "VAE",
+     "type": "VAE",
+     "links": [
+      15,
+      18,
+      27
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAELoader"
+   },
+   "widgets_values": [
+    "Wan2_1_VAE_bf16.safetensors"
+   ]
+  },
+  {
+   "id": 3,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 2,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      1
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+   ],
+   "title": "High-noise UNet"
+  },
+  {
+   "id": 4,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 3,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      3
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+   ],
+   "title": "Low-noise UNet"
+  },
+  {
+   "id": 5,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 4,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 1
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      2,
+      7
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI_v2_PRO_Wan2.2-I2V-A14B_HIGH_lora_rank_128_fp16.safetensors",
+    1.0
+   ],
+   "title": "SVI LoRA (HIGH, 1.0) = base_high"
+  },
+  {
+   "id": 6,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 5,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 2
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      9
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan21_I2V_14B_lightx2v_cfg_step_distill_lora_rank64.safetensors",
+    1.0
+   ],
+   "title": "+ lightx2v (1.0) = lightning_high"
+  },
+  {
+   "id": 7,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 6,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 3
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      4
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI_v2_PRO_Wan2.2-I2V-A14B_LOW_lora_rank_128_fp16.safetensors",
+    1.0
+   ],
+   "title": "SVI LoRA (LOW, 1.0)"
+  },
+  {
+   "id": 8,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 7,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 4
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      11
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan21_I2V_14B_lightx2v_cfg_step_distill_lora_rank64.safetensors",
+    1.5
+   ],
+   "title": "+ lightx2v (1.5) = lightning_low"
+  },
+  {
+   "id": 9,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 8,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 5
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      8,
+      10,
+      12,
+      16
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "fast fluid continuous motion, real-time speed, dynamic movement, no slow motion, no freeze frame"
+   ],
+   "title": "Positive prompt"
+  },
+  {
+   "id": 10,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 9,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 6
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      17
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "static, frozen, slow motion, freeze frame, low quality, blurry, motionless"
+   ],
+   "title": "Negative prompt"
+  },
+  {
+   "id": 11,
+   "type": "WanVideoNAG",
+   "pos": [
+    1080,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 10,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 7
+    },
+    {
+     "name": "conditioning",
+     "type": "CONDITIONING",
+     "link": 8
+    }
+   ],
+   "outputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "links": [
+      20
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanVideoNAG"
+   },
+   "widgets_values": [
+    11.0,
+    0.25,
+    2.5,
+    "default",
+    false
+   ],
+   "title": "NAG(base_high)"
+  },
+  {
+   "id": 12,
+   "type": "WanVideoNAG",
+   "pos": [
+    1080,
+    400
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 11,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 9
+    },
+    {
+     "name": "conditioning",
+     "type": "CONDITIONING",
+     "link": 10
+    }
+   ],
+   "outputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "links": [
+      21
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanVideoNAG"
+   },
+   "widgets_values": [
+    11.0,
+    0.25,
+    2.5,
+    "default",
+    false
+   ],
+   "title": "NAG(lightning_high)"
+  },
+  {
+   "id": 13,
+   "type": "WanVideoNAG",
+   "pos": [
+    1080,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 12,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 11
+    },
+    {
+     "name": "conditioning",
+     "type": "CONDITIONING",
+     "link": 12
+    }
+   ],
+   "outputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "links": [
+      22
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanVideoNAG"
+   },
+   "widgets_values": [
+    11.0,
+    0.25,
+    2.5,
+    "default",
+    false
+   ],
+   "title": "NAG(lightning_low)"
+  },
+  {
+   "id": 14,
+   "type": "LoadImage",
+   "pos": [
+    1440,
+    660
+   ],
+   "size": [
+    320,
+    320
+   ],
+   "flags": {},
+   "order": 13,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      13
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "MASK",
+     "type": "MASK",
+     "links": [],
+     "slot_index": 1
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoadImage"
+   },
+   "widgets_values": [
+    "input.png",
+    "image"
+   ]
+  },
+  {
+   "id": 15,
+   "type": "WanNativeResize_Dolphin",
+   "pos": [
+    1800,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 14,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "image",
+     "type": "IMAGE",
+     "link": 13
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      14
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "links": [],
+     "slot_index": 1
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "links": [],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanNativeResize_Dolphin"
+   },
+   "widgets_values": [
+    "480P (832x480)",
+    "lanczos",
+    16
+   ]
+  },
+  {
+   "id": 16,
+   "type": "VAEEncode",
+   "pos": [
+    2160,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 15,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "pixels",
+     "type": "IMAGE",
+     "link": 14
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 15
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      19
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEEncode"
+   },
+   "widgets_values": [],
+   "title": "Anchor encode"
+  },
+  {
+   "id": 17,
+   "type": "WanImageToVideoSVIProGray_Dolphin",
+   "pos": [
+    2160,
+    160
+   ],
+   "size": [
+    340,
+    220
+   ],
+   "flags": {},
+   "order": 16,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 16
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 17
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 18
+    },
+    {
+     "name": "anchor_samples",
+     "type": "LATENT",
+     "link": 19
+    },
+    {
+     "name": "prev_samples",
+     "type": "LATENT",
+     "link": null,
+     "shape": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "links": [
+      23
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "links": [
+      24
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "latent",
+     "type": "LATENT",
+     "links": [
+      25
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanImageToVideoSVIProGray_Dolphin"
+   },
+   "widgets_values": [
+    81,
+    0
+   ],
+   "title": "B: WanImageToVideoSVIProGray_Dolphin"
+  },
+  {
+   "id": 18,
+   "type": "TripleKSamplerWan22LightningAdvanced",
+   "pos": [
+    2560,
+    160
+   ],
+   "size": [
+    360,
+    420
+   ],
+   "flags": {},
+   "order": 17,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "base_high",
+     "type": "MODEL",
+     "link": 20
+    },
+    {
+     "name": "lightning_high",
+     "type": "MODEL",
+     "link": 21
+    },
+    {
+     "name": "lightning_low",
+     "type": "MODEL",
+     "link": 22
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 23
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 24
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 25
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      26
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "TripleKSamplerWan22LightningAdvanced"
+   },
+   "widgets_values": [
+    909090909090,
+    "fixed",
+    5.0,
+    20,
+    -1,
+    5.0,
+    "euler",
+    "simple",
+    1,
+    20,
+    1.0,
+    "euler",
+    "simple",
+    "50% of steps",
+    -1,
+    0.875,
+    false
+   ],
+   "title": "TripleKSamplerWan22LightningAdvanced (real prod values: base_cfg=5, lightning_steps=20, boundary=0.875)"
+  },
+  {
+   "id": 19,
+   "type": "VAEDecode",
+   "pos": [
+    2960,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 18,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "samples",
+     "type": "LATENT",
+     "link": 26
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 27
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      28
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEDecode"
+   },
+   "widgets_values": []
+  },
+  {
+   "id": 20,
+   "type": "VHS_VideoCombine",
+   "pos": [
+    3320,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 19,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "images",
+     "type": "IMAGE",
+     "link": 28
+    }
+   ],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "VHS_VideoCombine"
+   },
+   "widgets_values": {
+    "frame_rate": 16,
+    "loop_count": 0,
+    "filename_prefix": "wan22_slowmo/ab_test_B_svigray",
+    "format": "video/h264-mp4",
+    "pingpong": false,
+    "save_image": true,
+    "crf": 19,
+    "save_metadata": true,
+    "audio_file": ""
+   }
+  },
+  {
+   "id": 21,
+   "type": "Note",
+   "pos": [
+    2560,
+    620
+   ],
+   "size": [
+    1000,
+    260
+   ],
+   "flags": {},
+   "order": 20,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "Note"
+   },
+   "widgets_values": [
+    "A/B 테스트 B안: WanImageToVideoSVIProGray_Dolphin 사용.\n실제 프로덕션 값 재현: base_high=GGUF+SVI(1.0), lightning_high=+lightx2v(1.0), lightning_low=GGUF+SVI(1.0)+lightx2v(1.5). NAG(11/0.25/2.5) 세 모델 다 적용. TripleKSamplerWan22LightningAdvanced: base_cfg=5, lightning_steps=20, boundary=0.875, switch_strategy=50% of steps (0705_vision3.json 실측값). 단일 클립, anchor 1장만(콜드스타트).\nA안(core WanImageToVideo)과 완전히 동일한 모델/LoRA/NAG/샘플러 설정, 컨디셔닝 노드만 다름.\n둘 다 후반부 그레이면 '1앵커+80프레임필러' 자체의 한계, B만 그레이면 wan_svipro_gray.py 버그."
+   ],
+   "title": "A/B Test B: SVIProGray",
+   "color": "#432",
+   "bgcolor": "#653"
+  }
+ ],
+ "links": [
+  [
+   1,
+   3,
+   0,
+   5,
+   0,
+   "MODEL"
+  ],
+  [
+   2,
+   5,
+   0,
+   6,
+   0,
+   "MODEL"
+  ],
+  [
+   3,
+   4,
+   0,
+   7,
+   0,
+   "MODEL"
+  ],
+  [
+   4,
+   7,
+   0,
+   8,
+   0,
+   "MODEL"
+  ],
+  [
+   5,
+   1,
+   0,
+   9,
+   0,
+   "CLIP"
+  ],
+  [
+   6,
+   1,
+   0,
+   10,
+   0,
+   "CLIP"
+  ],
+  [
+   7,
+   5,
+   0,
+   11,
+   0,
+   "MODEL"
+  ],
+  [
+   8,
+   9,
+   0,
+   11,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   9,
+   6,
+   0,
+   12,
+   0,
+   "MODEL"
+  ],
+  [
+   10,
+   9,
+   0,
+   12,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   11,
+   8,
+   0,
+   13,
+   0,
+   "MODEL"
+  ],
+  [
+   12,
+   9,
+   0,
+   13,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   13,
+   14,
+   0,
+   15,
+   0,
+   "IMAGE"
+  ],
+  [
+   14,
+   15,
+   0,
+   16,
+   0,
+   "IMAGE"
+  ],
+  [
+   15,
+   2,
+   0,
+   16,
+   1,
+   "VAE"
+  ],
+  [
+   16,
+   9,
+   0,
+   17,
+   0,
+   "CONDITIONING"
+  ],
+  [
+   17,
+   10,
+   0,
+   17,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   18,
+   2,
+   0,
+   17,
+   2,
+   "VAE"
+  ],
+  [
+   19,
+   16,
+   0,
+   17,
+   3,
+   "LATENT"
+  ],
+  [
+   20,
+   11,
+   0,
+   18,
+   0,
+   "MODEL"
+  ],
+  [
+   21,
+   12,
+   0,
+   18,
+   1,
+   "MODEL"
+  ],
+  [
+   22,
+   13,
+   0,
+   18,
+   2,
+   "MODEL"
+  ],
+  [
+   23,
+   17,
+   0,
+   18,
+   3,
+   "CONDITIONING"
+  ],
+  [
+   24,
+   17,
+   1,
+   18,
+   4,
+   "CONDITIONING"
+  ],
+  [
+   25,
+   17,
+   2,
+   18,
+   5,
+   "LATENT"
+  ],
+  [
+   26,
+   18,
+   0,
+   19,
+   0,
+   "LATENT"
+  ],
+  [
+   27,
+   2,
+   0,
+   19,
+   1,
+   "VAE"
+  ],
+  [
+   28,
+   19,
+   0,
+   20,
+   0,
+   "IMAGE"
+  ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}

_archive/workflows/slowmo_scenario1_hi_cfg35_lo_lightx2v.json

@@ -0,0 +1,948 @@
+{
+ "last_node_id": 17,
+ "last_link_id": 23,
+ "nodes": [
+  {
+   "id": 1,
+   "type": "CLIPLoader",
+   "pos": [
+    0,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 0,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "CLIP",
+     "type": "CLIP",
+     "links": [
+      4,
+      5
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPLoader"
+   },
+   "widgets_values": [
+    "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+    "wan",
+    "default"
+   ]
+  },
+  {
+   "id": 2,
+   "type": "VAELoader",
+   "pos": [
+    0,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 1,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "VAE",
+     "type": "VAE",
+     "links": [
+      9,
+      22
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAELoader"
+   },
+   "widgets_values": [
+    "wan_2.1_vae.safetensors"
+   ]
+  },
+  {
+   "id": 3,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 2,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      1
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+   ],
+   "title": "High-noise UNet"
+  },
+  {
+   "id": 4,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 3,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      2
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+   ],
+   "title": "Low-noise UNet"
+  },
+  {
+   "id": 5,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    360,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 4,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 1
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      13
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "High noise (NO lightx2v, full CFG)"
+  },
+  {
+   "id": 6,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 5,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 2
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      3
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "wan2.2_i2v_A14b_low_noise_lora_rank64_lightx2v_4step_1022.safetensors",
+    1.0
+   ],
+   "title": "lightx2v LoRA (LOW only)"
+  },
+  {
+   "id": 7,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    720,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 6,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 3
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      17
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "Low noise (lightx2v, CFG1)"
+  },
+  {
+   "id": 8,
+   "type": "CLIPTextEncode",
+   "pos": [
+    720,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 7,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 4
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      7
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "fast fluid continuous motion, real-time speed, dynamic movement, no slow motion, no freeze frame"
+   ],
+   "title": "Positive prompt"
+  },
+  {
+   "id": 9,
+   "type": "CLIPTextEncode",
+   "pos": [
+    720,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 8,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 5
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      8
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "static, frozen, slow motion, freeze frame, low quality, blurry, motionless"
+   ],
+   "title": "Negative prompt"
+  },
+  {
+   "id": 10,
+   "type": "LoadImage",
+   "pos": [
+    720,
+    340
+   ],
+   "size": [
+    320,
+    320
+   ],
+   "flags": {},
+   "order": 9,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      6
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "MASK",
+     "type": "MASK",
+     "links": [],
+     "slot_index": 1
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoadImage"
+   },
+   "widgets_values": [
+    "input.png",
+    "image"
+   ]
+  },
+  {
+   "id": 11,
+   "type": "WanNativeResize_Dolphin",
+   "pos": [
+    1080,
+    340
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 10,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "image",
+     "type": "IMAGE",
+     "link": 6
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      10
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "links": [
+      11
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "links": [
+      12
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanNativeResize_Dolphin"
+   },
+   "widgets_values": [
+    "720P (1280x720)",
+    "lanczos",
+    16
+   ]
+  },
+  {
+   "id": 12,
+   "type": "WanImageToVideo",
+   "pos": [
+    1480,
+    160
+   ],
+   "size": [
+    320,
+    220
+   ],
+   "flags": {},
+   "order": 11,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 7
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 8
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 9
+    },
+    {
+     "name": "clip_vision_output",
+     "type": "CLIP_VISION_OUTPUT",
+     "link": null,
+     "shape": 7
+    },
+    {
+     "name": "start_image",
+     "type": "IMAGE",
+     "link": 10,
+     "shape": 7
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "link": 11,
+     "widget": {
+      "name": "width"
+     }
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "link": 12,
+     "widget": {
+      "name": "height"
+     }
+    }
+   ],
+   "outputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "links": [
+      14,
+      18
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "links": [
+      15,
+      19
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "latent",
+     "type": "LATENT",
+     "links": [
+      16
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanImageToVideo"
+   },
+   "widgets_values": [
+    1280,
+    720,
+    81,
+    1
+   ]
+  },
+  {
+   "id": 13,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    1900,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 12,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 13
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 14
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 15
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 16
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      20
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "enable",
+    999111222333,
+    "fixed",
+    16,
+    3.5,
+    "euler",
+    "simple",
+    0,
+    16,
+    "disable"
+   ],
+   "title": "HIGH stage - no lightx2v, CFG 3.5, independent 16-step schedule, finishes fully (0->16 of 16)"
+  },
+  {
+   "id": 14,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    2260,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 13,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 17
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 18
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 19
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 20
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      21
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "enable",
+    999111222333,
+    "fixed",
+    4,
+    1.0,
+    "euler",
+    "simple",
+    2,
+    4,
+    "disable"
+   ],
+   "title": "LOW stage - lightx2v, CFG 1, OWN independent 4-step schedule, re-noise at step 2/4 (denoise~0.5 touch-up)"
+  },
+  {
+   "id": 15,
+   "type": "VAEDecode",
+   "pos": [
+    2620,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 14,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "samples",
+     "type": "LATENT",
+     "link": 21
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 22
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      23
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEDecode"
+   },
+   "widgets_values": []
+  },
+  {
+   "id": 16,
+   "type": "VHS_VideoCombine",
+   "pos": [
+    2980,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 15,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "images",
+     "type": "IMAGE",
+     "link": 23
+    }
+   ],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "VHS_VideoCombine"
+   },
+   "widgets_values": {
+    "frame_rate": 16,
+    "loop_count": 0,
+    "filename_prefix": "wan22_slowmo/hi_nolightx2v_cfg35_lo_lightx2v",
+    "format": "video/h264-mp4",
+    "pingpong": false,
+    "save_image": true,
+    "crf": 19,
+    "save_metadata": true,
+    "audio_file": ""
+   }
+  },
+  {
+   "id": 17,
+   "type": "Note",
+   "pos": [
+    2620,
+    480
+   ],
+   "size": [
+    900,
+    260
+   ],
+   "flags": {},
+   "order": 16,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "Note"
+   },
+   "widgets_values": [
+    "시나리오: Hi=lightx2v 없음(CFG3.5) / Lo=lightx2v만(CFG1, 디테일 정제).\n2026-07-29 재설계: High/Low가 steps 총량을 공유하는 슬라이싱 구조를 버리고 완전히 독립된 스케줄로 분리함.\n- 문제 이력: 처음엔 steps=12 공유(0-8-12)로 캐릭터 얼굴/디테일이 흔들림 → High를 8→16, 총steps 12→20으로 늘렸더니 오히려 컬러 노이즈(TV 스노우 같은 발산)로 악화됨. 원인: 공유 스케줄에서 High 비중을 늘릴수록 Low가 넘겨받는 시그마 값이 lightx2v가 실제 학습한 4스텝 노이즈 레벨에서 더 멀어져서, Low가 완전히 낯선 노이즈 레벨을 받아 발산한 것.\n- 수정: High는 자기만의 독립된 16스텝 스케줄로 CFG3.5, 완전히 끝까지(0->16, leftover noise 없이) 디노이징. Low는 그 결과물에 add_noise=enable로 재노이즈를 살짝 태워서(steps=4의 2->4, denoise~0.5 상당) lightx2v 고유 4스텝 스케줄로 마무리. 두 스테이지가 이제 서로의 스텝 수에 영향 안 받음.\n튜닝 포인트: Low의 재노이즈 강도는 start_at_step(2/4)으로 조절 — 낮추면(1) lightx2v 영향/디테일 정제 강해지지만 캐릭터 드리프트 위험 커짐, 높이면(3) High 결과를 더 보존하지만 정제 효과 약해짐. 시드는 두 노드 동일(999111222333)."
+   ],
+   "title": "Scenario 1: Hi=CFG3.5(no lightx2v) / Lo=lightx2v only",
+   "color": "#432",
+   "bgcolor": "#653"
+  }
+ ],
+ "links": [
+  [
+   1,
+   3,
+   0,
+   5,
+   0,
+   "MODEL"
+  ],
+  [
+   2,
+   4,
+   0,
+   6,
+   0,
+   "MODEL"
+  ],
+  [
+   3,
+   6,
+   0,
+   7,
+   0,
+   "MODEL"
+  ],
+  [
+   4,
+   1,
+   0,
+   8,
+   0,
+   "CLIP"
+  ],
+  [
+   5,
+   1,
+   0,
+   9,
+   0,
+   "CLIP"
+  ],
+  [
+   6,
+   10,
+   0,
+   11,
+   0,
+   "IMAGE"
+  ],
+  [
+   7,
+   8,
+   0,
+   12,
+   0,
+   "CONDITIONING"
+  ],
+  [
+   8,
+   9,
+   0,
+   12,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   9,
+   2,
+   0,
+   12,
+   2,
+   "VAE"
+  ],
+  [
+   10,
+   11,
+   0,
+   12,
+   4,
+   "IMAGE"
+  ],
+  [
+   11,
+   11,
+   1,
+   12,
+   5,
+   "INT"
+  ],
+  [
+   12,
+   11,
+   2,
+   12,
+   6,
+   "INT"
+  ],
+  [
+   13,
+   5,
+   0,
+   13,
+   0,
+   "MODEL"
+  ],
+  [
+   14,
+   12,
+   0,
+   13,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   15,
+   12,
+   1,
+   13,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   16,
+   12,
+   2,
+   13,
+   3,
+   "LATENT"
+  ],
+  [
+   17,
+   7,
+   0,
+   14,
+   0,
+   "MODEL"
+  ],
+  [
+   18,
+   12,
+   0,
+   14,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   19,
+   12,
+   1,
+   14,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   20,
+   13,
+   0,
+   14,
+   3,
+   "LATENT"
+  ],
+  [
+   21,
+   14,
+   0,
+   15,
+   0,
+   "LATENT"
+  ],
+  [
+   22,
+   2,
+   0,
+   15,
+   1,
+   "VAE"
+  ],
+  [
+   23,
+   15,
+   0,
+   16,
+   0,
+   "IMAGE"
+  ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}

_archive/workflows/slowmo_scenario2_3ksampler_warmup.json

@@ -0,0 +1,1141 @@
+{
+ "last_node_id": 20,
+ "last_link_id": 29,
+ "nodes": [
+  {
+   "id": 1,
+   "type": "CLIPLoader",
+   "pos": [
+    0,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 0,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "CLIP",
+     "type": "CLIP",
+     "links": [
+      6,
+      7
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPLoader"
+   },
+   "widgets_values": [
+    "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+    "wan",
+    "default"
+   ]
+  },
+  {
+   "id": 2,
+   "type": "VAELoader",
+   "pos": [
+    0,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 1,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "VAE",
+     "type": "VAE",
+     "links": [
+      11,
+      28
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAELoader"
+   },
+   "widgets_values": [
+    "wan_2.1_vae.safetensors"
+   ]
+  },
+  {
+   "id": 3,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 2,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      1,
+      2
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+   ],
+   "title": "High-noise UNet"
+  },
+  {
+   "id": 4,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 3,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      4
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+   ],
+   "title": "Low-noise UNet"
+  },
+  {
+   "id": 5,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    360,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 4,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 1
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      15
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "Stage1: High, NO LoRA (warmup)"
+  },
+  {
+   "id": 6,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 5,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 2
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      3
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan_2_2_I2V_A14B_HIGH_lightx2v_4step_lora_v1030_rank_64_bf16.safetensors",
+    1.0
+   ],
+   "title": "lightx2v LoRA (HIGH)"
+  },
+  {
+   "id": 7,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    720,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 6,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 3
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      19
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "Stage2: High + lightx2v"
+  },
+  {
+   "id": 8,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    640
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 7,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 4
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      5
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "wan2.2_i2v_A14b_low_noise_lora_rank64_lightx2v_4step_1022.safetensors",
+    1.0
+   ],
+   "title": "lightx2v LoRA (LOW)"
+  },
+  {
+   "id": 9,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    720,
+    640
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 8,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 5
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      23
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "Stage3: Low + lightx2v"
+  },
+  {
+   "id": 10,
+   "type": "CLIPTextEncode",
+   "pos": [
+    720,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 9,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 6
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      9
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "fast fluid continuous motion, real-time speed, dynamic movement, no slow motion, no freeze frame"
+   ],
+   "title": "Positive prompt"
+  },
+  {
+   "id": 11,
+   "type": "CLIPTextEncode",
+   "pos": [
+    720,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 10,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      10
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "static, frozen, slow motion, freeze frame, low quality, blurry, motionless"
+   ],
+   "title": "Negative prompt"
+  },
+  {
+   "id": 12,
+   "type": "LoadImage",
+   "pos": [
+    720,
+    340
+   ],
+   "size": [
+    320,
+    320
+   ],
+   "flags": {},
+   "order": 11,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      8
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "MASK",
+     "type": "MASK",
+     "links": [],
+     "slot_index": 1
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoadImage"
+   },
+   "widgets_values": [
+    "input.png",
+    "image"
+   ]
+  },
+  {
+   "id": 13,
+   "type": "WanNativeResize_Dolphin",
+   "pos": [
+    1080,
+    340
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 12,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "image",
+     "type": "IMAGE",
+     "link": 8
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      12
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "links": [
+      13
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "links": [
+      14
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanNativeResize_Dolphin"
+   },
+   "widgets_values": [
+    "720P (1280x720)",
+    "lanczos",
+    16
+   ]
+  },
+  {
+   "id": 14,
+   "type": "WanImageToVideo",
+   "pos": [
+    1480,
+    160
+   ],
+   "size": [
+    320,
+    220
+   ],
+   "flags": {},
+   "order": 13,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 9
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 10
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 11
+    },
+    {
+     "name": "clip_vision_output",
+     "type": "CLIP_VISION_OUTPUT",
+     "link": null,
+     "shape": 7
+    },
+    {
+     "name": "start_image",
+     "type": "IMAGE",
+     "link": 12,
+     "shape": 7
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "link": 13,
+     "widget": {
+      "name": "width"
+     }
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "link": 14,
+     "widget": {
+      "name": "height"
+     }
+    }
+   ],
+   "outputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "links": [
+      16,
+      20,
+      24
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "links": [
+      17,
+      21,
+      25
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "latent",
+     "type": "LATENT",
+     "links": [
+      18
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanImageToVideo"
+   },
+   "widgets_values": [
+    1280,
+    720,
+    81,
+    1
+   ]
+  },
+  {
+   "id": 15,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    1900,
+    120
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 14,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 15
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 16
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 17
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 18
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      22
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "enable",
+    555222333111,
+    "fixed",
+    9,
+    3.5,
+    "euler",
+    "simple",
+    0,
+    1,
+    "enable"
+   ],
+   "title": "Stage1 - no LoRA, CFG 3.5, 1/9 step (motion warmup)"
+  },
+  {
+   "id": 16,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    2260,
+    120
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 15,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 19
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 20
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 21
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 22
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      26
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "disable",
+    555222333111,
+    "fixed",
+    9,
+    1.0,
+    "euler",
+    "simple",
+    1,
+    5,
+    "enable"
+   ],
+   "title": "Stage2 - High+lightx2v, CFG 1, steps 1->5 of 9"
+  },
+  {
+   "id": 17,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    2620,
+    120
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 16,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 23
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 24
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 25
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 26
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      27
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "disable",
+    555222333111,
+    "fixed",
+    9,
+    1.0,
+    "euler",
+    "simple",
+    5,
+    9,
+    "disable"
+   ],
+   "title": "Stage3 - Low+lightx2v, CFG 1, steps 5->9 of 9"
+  },
+  {
+   "id": 18,
+   "type": "VAEDecode",
+   "pos": [
+    2980,
+    120
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 17,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "samples",
+     "type": "LATENT",
+     "link": 27
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 28
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      29
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEDecode"
+   },
+   "widgets_values": []
+  },
+  {
+   "id": 19,
+   "type": "VHS_VideoCombine",
+   "pos": [
+    3340,
+    120
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 18,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "images",
+     "type": "IMAGE",
+     "link": 29
+    }
+   ],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "VHS_VideoCombine"
+   },
+   "widgets_values": {
+    "frame_rate": 16,
+    "loop_count": 0,
+    "filename_prefix": "wan22_slowmo/3ksampler_warmup",
+    "format": "video/h264-mp4",
+    "pingpong": false,
+    "save_image": true,
+    "crf": 19,
+    "save_metadata": true,
+    "audio_file": ""
+   }
+  },
+  {
+   "id": 20,
+   "type": "Note",
+   "pos": [
+    2980,
+    440
+   ],
+   "size": [
+    900,
+    260
+   ],
+   "flags": {},
+   "order": 19,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "Note"
+   },
+   "widgets_values": [
+    "시나리오: 3-KSampler 워밍업 구조.\n(1) LoRA 없이 CFG3.5 1스텝(모션 방향 예열) -> (2) High+lightx2v CFG1 4스텝 -> (3) Low+lightx2v CFG1 4스텝.\n총 steps=9(1+4+4)를 세 KSamplerAdvanced가 나눠서 하나의 연속된 노이즈 스케줄로 처리.\n튜닝 포인트: Stage2/3의 폭(2~4 steps 권장 범위)을 조절, 필요시 총 steps도 함께 변경. 시드는 세 노드 동일(555222333111).\nmemory 근거: wan_lightx2v_workarounds.md 참고 — 이 구조는 채택된 'Hi=CFG3.5 no-lightx2v / Lo=lightx2v only' 조합보다 덜 선호되지만 대안으로 남겨둠."
+   ],
+   "title": "Scenario 2: 3-KSampler warmup",
+   "color": "#432",
+   "bgcolor": "#653"
+  }
+ ],
+ "links": [
+  [
+   1,
+   3,
+   0,
+   5,
+   0,
+   "MODEL"
+  ],
+  [
+   2,
+   3,
+   0,
+   6,
+   0,
+   "MODEL"
+  ],
+  [
+   3,
+   6,
+   0,
+   7,
+   0,
+   "MODEL"
+  ],
+  [
+   4,
+   4,
+   0,
+   8,
+   0,
+   "MODEL"
+  ],
+  [
+   5,
+   8,
+   0,
+   9,
+   0,
+   "MODEL"
+  ],
+  [
+   6,
+   1,
+   0,
+   10,
+   0,
+   "CLIP"
+  ],
+  [
+   7,
+   1,
+   0,
+   11,
+   0,
+   "CLIP"
+  ],
+  [
+   8,
+   12,
+   0,
+   13,
+   0,
+   "IMAGE"
+  ],
+  [
+   9,
+   10,
+   0,
+   14,
+   0,
+   "CONDITIONING"
+  ],
+  [
+   10,
+   11,
+   0,
+   14,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   11,
+   2,
+   0,
+   14,
+   2,
+   "VAE"
+  ],
+  [
+   12,
+   13,
+   0,
+   14,
+   4,
+   "IMAGE"
+  ],
+  [
+   13,
+   13,
+   1,
+   14,
+   5,
+   "INT"
+  ],
+  [
+   14,
+   13,
+   2,
+   14,
+   6,
+   "INT"
+  ],
+  [
+   15,
+   5,
+   0,
+   15,
+   0,
+   "MODEL"
+  ],
+  [
+   16,
+   14,
+   0,
+   15,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   17,
+   14,
+   1,
+   15,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   18,
+   14,
+   2,
+   15,
+   3,
+   "LATENT"
+  ],
+  [
+   19,
+   7,
+   0,
+   16,
+   0,
+   "MODEL"
+  ],
+  [
+   20,
+   14,
+   0,
+   16,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   21,
+   14,
+   1,
+   16,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   22,
+   15,
+   0,
+   16,
+   3,
+   "LATENT"
+  ],
+  [
+   23,
+   9,
+   0,
+   17,
+   0,
+   "MODEL"
+  ],
+  [
+   24,
+   14,
+   0,
+   17,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   25,
+   14,
+   1,
+   17,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   26,
+   16,
+   0,
+   17,
+   3,
+   "LATENT"
+  ],
+  [
+   27,
+   17,
+   0,
+   18,
+   0,
+   "LATENT"
+  ],
+  [
+   28,
+   2,
+   0,
+   18,
+   1,
+   "VAE"
+  ],
+  [
+   29,
+   18,
+   0,
+   19,
+   0,
+   "IMAGE"
+  ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}

_archive/workflows/slowmo_svi_scenarioA_2clip_continuation.json

@@ -0,0 +1,1737 @@
+{
+ "last_node_id": 30,
+ "last_link_id": 47,
+ "nodes": [
+  {
+   "id": 1,
+   "type": "CLIPLoader",
+   "pos": [
+    0,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 0,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "CLIP",
+     "type": "CLIP",
+     "links": [
+      7,
+      8,
+      30,
+      31
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPLoader"
+   },
+   "widgets_values": [
+    "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+    "wan",
+    "default"
+   ]
+  },
+  {
+   "id": 2,
+   "type": "VAELoader",
+   "pos": [
+    0,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 1,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "VAE",
+     "type": "VAE",
+     "links": [
+      11,
+      14,
+      25,
+      29,
+      34,
+      46
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAELoader"
+   },
+   "widgets_values": [
+    "wan_2.1_vae.safetensors"
+   ]
+  },
+  {
+   "id": 3,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 2,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      1
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+   ],
+   "title": "High-noise UNet"
+  },
+  {
+   "id": 4,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 3,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      4
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+   ],
+   "title": "Low-noise UNet"
+  },
+  {
+   "id": 5,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 4,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 1
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      2
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI/SVI_Wan2.2-I2V-A14B_high_noise_lora_v2.0.safetensors",
+    1.0
+   ],
+   "title": "SVI LoRA (HIGH, strength 1.0)"
+  },
+  {
+   "id": 6,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 5,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 2
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      3
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan_2_2_I2V_A14B_HIGH_lightx2v_4step_lora_v1030_rank_64_bf16.safetensors",
+    0.5
+   ],
+   "title": "lightx2v LoRA (HIGH, strength 0.5)"
+  },
+  {
+   "id": 7,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    1080,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 6,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 3
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      16,
+      37
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "High noise (SVI 1.0 + lightx2v 0.5) - shared"
+  },
+  {
+   "id": 8,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 7,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 4
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      5
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI/SVI_Wan2.2-I2V-A14B_low_noise_lora_v2.0.safetensors",
+    1.0
+   ],
+   "title": "SVI LoRA (LOW, strength 1.0)"
+  },
+  {
+   "id": 9,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 8,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 5
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      6
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "wan2.2_i2v_A14b_low_noise_lora_rank64_lightx2v_4step_1022.safetensors",
+    1.0
+   ],
+   "title": "lightx2v LoRA (LOW, strength 1.0)"
+  },
+  {
+   "id": 10,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    1080,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 9,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 6
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      20,
+      41
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "Low noise (SVI 1.0 + lightx2v 1.0) - shared"
+  },
+  {
+   "id": 11,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 10,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      12
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "fast fluid continuous motion, real-time speed, dynamic movement, no slow motion, no freeze frame"
+   ],
+   "title": "Clip1 Positive prompt"
+  },
+  {
+   "id": 12,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 11,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 8
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      13
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "static, frozen, slow motion, freeze frame, low quality, blurry, motionless"
+   ],
+   "title": "Clip1 Negative prompt"
+  },
+  {
+   "id": 13,
+   "type": "LoadImage",
+   "pos": [
+    1080,
+    660
+   ],
+   "size": [
+    320,
+    320
+   ],
+   "flags": {},
+   "order": 12,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      9
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "MASK",
+     "type": "MASK",
+     "links": [],
+     "slot_index": 1
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoadImage"
+   },
+   "widgets_values": [
+    "input.png",
+    "image"
+   ]
+  },
+  {
+   "id": 14,
+   "type": "WanNativeResize_Dolphin",
+   "pos": [
+    1440,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 13,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "image",
+     "type": "IMAGE",
+     "link": 9
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      10
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "links": [],
+     "slot_index": 1
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "links": [],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanNativeResize_Dolphin"
+   },
+   "widgets_values": [
+    "480P (832x480)",
+    "lanczos",
+    16
+   ]
+  },
+  {
+   "id": 15,
+   "type": "VAEEncode",
+   "pos": [
+    1840,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 14,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "pixels",
+     "type": "IMAGE",
+     "link": 10
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 11
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      15
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEEncode"
+   },
+   "widgets_values": [],
+   "title": "Clip1 anchor encode"
+  },
+  {
+   "id": 16,
+   "type": "WanImageToVideoSVIProGray_Dolphin",
+   "pos": [
+    2240,
+    160
+   ],
+   "size": [
+    340,
+    220
+   ],
+   "flags": {},
+   "order": 15,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 12
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 13
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 14
+    },
+    {
+     "name": "anchor_samples",
+     "type": "LATENT",
+     "link": 15
+    },
+    {
+     "name": "prev_samples",
+     "type": "LATENT",
+     "link": null,
+     "shape": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "links": [
+      17,
+      21
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "links": [
+      18,
+      22
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "latent",
+     "type": "LATENT",
+     "links": [
+      19
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanImageToVideoSVIProGray_Dolphin"
+   },
+   "widgets_values": [
+    81,
+    0
+   ],
+   "title": "Clip1: SVIProGray (cold start, no prev_samples - unavoidable for clip 1)"
+  },
+  {
+   "id": 17,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    2640,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 16,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 16
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 17
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 18
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 19
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      23
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "enable",
+    424242424242,
+    "fixed",
+    8,
+    1.5,
+    "euler",
+    "simple",
+    0,
+    4,
+    "enable"
+   ],
+   "title": "Clip1 HIGH - CFG1.5, 0->4 of 8"
+  },
+  {
+   "id": 18,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    3000,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 17,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 20
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 21
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 22
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 23
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      24,
+      36
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "disable",
+    424242424242,
+    "fixed",
+    8,
+    1.5,
+    "euler",
+    "simple",
+    4,
+    8,
+    "disable"
+   ],
+   "title": "Clip1 LOW - CFG1.5, 4->8 of 8"
+  },
+  {
+   "id": 19,
+   "type": "VAEDecode",
+   "pos": [
+    3360,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 18,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "samples",
+     "type": "LATENT",
+     "link": 24
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 25
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      26,
+      27
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEDecode"
+   },
+   "widgets_values": [],
+   "title": "Clip1 decode"
+  },
+  {
+   "id": 20,
+   "type": "VHS_VideoCombine",
+   "pos": [
+    3720,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 19,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "images",
+     "type": "IMAGE",
+     "link": 26
+    }
+   ],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "VHS_VideoCombine"
+   },
+   "widgets_values": {
+    "frame_rate": 16,
+    "loop_count": 0,
+    "filename_prefix": "wan22_slowmo/svi_scenarioA_2clip/clip1",
+    "format": "video/h264-mp4",
+    "pingpong": false,
+    "save_image": true,
+    "crf": 19,
+    "save_metadata": true,
+    "audio_file": ""
+   },
+   "title": "Clip1 save"
+  },
+  {
+   "id": 21,
+   "type": "ImageFromBatch",
+   "pos": [
+    4080,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 20,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "image",
+     "type": "IMAGE",
+     "link": 27
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      28
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ImageFromBatch"
+   },
+   "widgets_values": [
+    -1,
+    1
+   ],
+   "title": "Get last frame of Clip1"
+  },
+  {
+   "id": 22,
+   "type": "VAEEncode",
+   "pos": [
+    4440,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 21,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "pixels",
+     "type": "IMAGE",
+     "link": 28
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 29
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      35
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEEncode"
+   },
+   "widgets_values": [],
+   "title": "Clip2 anchor encode (= Clip1 last frame)"
+  },
+  {
+   "id": 23,
+   "type": "CLIPTextEncode",
+   "pos": [
+    4080,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 22,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 30
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      32
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "fast fluid continuous motion, real-time speed, dynamic movement, no slow motion, no freeze frame"
+   ],
+   "title": "Clip2 Positive prompt"
+  },
+  {
+   "id": 24,
+   "type": "CLIPTextEncode",
+   "pos": [
+    4080,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 23,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 31
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      33
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "static, frozen, slow motion, freeze frame, low quality, blurry, motionless"
+   ],
+   "title": "Clip2 Negative prompt"
+  },
+  {
+   "id": 25,
+   "type": "WanImageToVideoSVIProGray_Dolphin",
+   "pos": [
+    4840,
+    160
+   ],
+   "size": [
+    340,
+    220
+   ],
+   "flags": {},
+   "order": 24,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 32
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 33
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 34
+    },
+    {
+     "name": "anchor_samples",
+     "type": "LATENT",
+     "link": 35
+    },
+    {
+     "name": "prev_samples",
+     "type": "LATENT",
+     "link": 36,
+     "shape": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "links": [
+      38,
+      42
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "links": [
+      39,
+      43
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "latent",
+     "type": "LATENT",
+     "links": [
+      40
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanImageToVideoSVIProGray_Dolphin"
+   },
+   "widgets_values": [
+    81,
+    3
+   ],
+   "title": "Clip2: SVIProGray (REAL continuation - anchor=clip1 last frame, prev_samples=clip1 raw latent, motion_latent_count=3)"
+  },
+  {
+   "id": 26,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    5240,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 25,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 37
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 38
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 39
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 40
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      44
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "enable",
+    858585858585,
+    "fixed",
+    8,
+    1.5,
+    "euler",
+    "simple",
+    0,
+    4,
+    "enable"
+   ],
+   "title": "Clip2 HIGH - CFG1.5, 0->4 of 8"
+  },
+  {
+   "id": 27,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    5600,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 26,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 41
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 42
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 43
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 44
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      45
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "disable",
+    858585858585,
+    "fixed",
+    8,
+    1.5,
+    "euler",
+    "simple",
+    4,
+    8,
+    "disable"
+   ],
+   "title": "Clip2 LOW - CFG1.5, 4->8 of 8"
+  },
+  {
+   "id": 28,
+   "type": "VAEDecode",
+   "pos": [
+    5960,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 27,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "samples",
+     "type": "LATENT",
+     "link": 45
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 46
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      47
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEDecode"
+   },
+   "widgets_values": [],
+   "title": "Clip2 decode"
+  },
+  {
+   "id": 29,
+   "type": "VHS_VideoCombine",
+   "pos": [
+    6320,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 28,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "images",
+     "type": "IMAGE",
+     "link": 47
+    }
+   ],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "VHS_VideoCombine"
+   },
+   "widgets_values": {
+    "frame_rate": 16,
+    "loop_count": 0,
+    "filename_prefix": "wan22_slowmo/svi_scenarioA_2clip/clip2",
+    "format": "video/h264-mp4",
+    "pingpong": false,
+    "save_image": true,
+    "crf": 19,
+    "save_metadata": true,
+    "audio_file": ""
+   },
+   "title": "Clip2 save"
+  },
+  {
+   "id": 30,
+   "type": "Note",
+   "pos": [
+    2640,
+    480
+   ],
+   "size": [
+    1100,
+    340
+   ],
+   "flags": {},
+   "order": 29,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "Note"
+   },
+   "widgets_values": [
+    "시나리오 A (2클립 진짜 연속 테스트, 2026-07-28).\n이전 버전(콜드스타트, anchor 1장만)에서 후반부에 그레이 노이즈가 나온 것에 대한 후속 테스트.\n가설: SVI Pro는 원래 '이전 클립의 진짜 모션 프레임'을 prev_samples로 이어받는 연속 생성용으로 튜닝된 것이라, anchor 1장짜리 콜드스타트(필러 20/21)로 테스트한 건 설계 범위 밖이었을 수 있음.\n이번엔 Clip1은 어쩔 수 없이 콜드스타트(anchor만, prev_samples 없음)로 만들고, Clip2는 Clip1의 마지막 프레임을 anchor로, Clip1의 원본(디코딩 안 된) latent를 prev_samples로 이어받아(motion_latent_count=3) 실제 연속 생성 상황을 재현함.\nCFG=1.5/steps=8(4+4)는 이전 테스트와 동일하게 유지 — 그레이 노이즈 원인이 '콜드스타트라서'였는지 'CFG/steps가 애초에 부족해서'였는지 이 변경 하나로 분리해서 확인하려는 목적.\n공식 README 권장대로 클립마다 다른 시드 사용(Clip1=424242424242, Clip2=858585858585).\nClip2가 여전히 그레이가 나오면 CFG/steps 부족 쪽에 무게가 실림 — 그땐 CFG를 올리거나 0705_vision3.json의 실제 TripleKSampler+튜닝값으로 SVIPro만 교체하는 테스트로 넘어갈 것."
+   ],
+   "title": "Scenario A - 2-clip real continuation test",
+   "color": "#432",
+   "bgcolor": "#653"
+  }
+ ],
+ "links": [
+  [
+   1,
+   3,
+   0,
+   5,
+   0,
+   "MODEL"
+  ],
+  [
+   2,
+   5,
+   0,
+   6,
+   0,
+   "MODEL"
+  ],
+  [
+   3,
+   6,
+   0,
+   7,
+   0,
+   "MODEL"
+  ],
+  [
+   4,
+   4,
+   0,
+   8,
+   0,
+   "MODEL"
+  ],
+  [
+   5,
+   8,
+   0,
+   9,
+   0,
+   "MODEL"
+  ],
+  [
+   6,
+   9,
+   0,
+   10,
+   0,
+   "MODEL"
+  ],
+  [
+   7,
+   1,
+   0,
+   11,
+   0,
+   "CLIP"
+  ],
+  [
+   8,
+   1,
+   0,
+   12,
+   0,
+   "CLIP"
+  ],
+  [
+   9,
+   13,
+   0,
+   14,
+   0,
+   "IMAGE"
+  ],
+  [
+   10,
+   14,
+   0,
+   15,
+   0,
+   "IMAGE"
+  ],
+  [
+   11,
+   2,
+   0,
+   15,
+   1,
+   "VAE"
+  ],
+  [
+   12,
+   11,
+   0,
+   16,
+   0,
+   "CONDITIONING"
+  ],
+  [
+   13,
+   12,
+   0,
+   16,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   14,
+   2,
+   0,
+   16,
+   2,
+   "VAE"
+  ],
+  [
+   15,
+   15,
+   0,
+   16,
+   3,
+   "LATENT"
+  ],
+  [
+   16,
+   7,
+   0,
+   17,
+   0,
+   "MODEL"
+  ],
+  [
+   17,
+   16,
+   0,
+   17,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   18,
+   16,
+   1,
+   17,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   19,
+   16,
+   2,
+   17,
+   3,
+   "LATENT"
+  ],
+  [
+   20,
+   10,
+   0,
+   18,
+   0,
+   "MODEL"
+  ],
+  [
+   21,
+   16,
+   0,
+   18,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   22,
+   16,
+   1,
+   18,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   23,
+   17,
+   0,
+   18,
+   3,
+   "LATENT"
+  ],
+  [
+   24,
+   18,
+   0,
+   19,
+   0,
+   "LATENT"
+  ],
+  [
+   25,
+   2,
+   0,
+   19,
+   1,
+   "VAE"
+  ],
+  [
+   26,
+   19,
+   0,
+   20,
+   0,
+   "IMAGE"
+  ],
+  [
+   27,
+   19,
+   0,
+   21,
+   0,
+   "IMAGE"
+  ],
+  [
+   28,
+   21,
+   0,
+   22,
+   0,
+   "IMAGE"
+  ],
+  [
+   29,
+   2,
+   0,
+   22,
+   1,
+   "VAE"
+  ],
+  [
+   30,
+   1,
+   0,
+   23,
+   0,
+   "CLIP"
+  ],
+  [
+   31,
+   1,
+   0,
+   24,
+   0,
+   "CLIP"
+  ],
+  [
+   32,
+   23,
+   0,
+   25,
+   0,
+   "CONDITIONING"
+  ],
+  [
+   33,
+   24,
+   0,
+   25,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   34,
+   2,
+   0,
+   25,
+   2,
+   "VAE"
+  ],
+  [
+   35,
+   22,
+   0,
+   25,
+   3,
+   "LATENT"
+  ],
+  [
+   36,
+   18,
+   0,
+   25,
+   4,
+   "LATENT"
+  ],
+  [
+   37,
+   7,
+   0,
+   26,
+   0,
+   "MODEL"
+  ],
+  [
+   38,
+   25,
+   0,
+   26,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   39,
+   25,
+   1,
+   26,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   40,
+   25,
+   2,
+   26,
+   3,
+   "LATENT"
+  ],
+  [
+   41,
+   10,
+   0,
+   27,
+   0,
+   "MODEL"
+  ],
+  [
+   42,
+   25,
+   0,
+   27,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   43,
+   25,
+   1,
+   27,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   44,
+   26,
+   0,
+   27,
+   3,
+   "LATENT"
+  ],
+  [
+   45,
+   27,
+   0,
+   28,
+   0,
+   "LATENT"
+  ],
+  [
+   46,
+   2,
+   0,
+   28,
+   1,
+   "VAE"
+  ],
+  [
+   47,
+   28,
+   0,
+   29,
+   0,
+   "IMAGE"
+  ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}

_archive/workflows/slowmo_svi_scenarioA_official_recipe.json

@@ -0,0 +1,1113 @@
+{
+ "last_node_id": 21,
+ "last_link_id": 26,
+ "nodes": [
+  {
+   "id": 1,
+   "type": "CLIPLoader",
+   "pos": [
+    0,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 0,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "CLIP",
+     "type": "CLIP",
+     "links": [
+      7,
+      8
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPLoader"
+   },
+   "widgets_values": [
+    "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+    "wan",
+    "default"
+   ]
+  },
+  {
+   "id": 2,
+   "type": "VAELoader",
+   "pos": [
+    0,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 1,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "VAE",
+     "type": "VAE",
+     "links": [
+      11,
+      14,
+      25
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAELoader"
+   },
+   "widgets_values": [
+    "wan_2.1_vae.safetensors"
+   ]
+  },
+  {
+   "id": 3,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 2,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      1
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+   ],
+   "title": "High-noise UNet"
+  },
+  {
+   "id": 4,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 3,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      4
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+   ],
+   "title": "Low-noise UNet"
+  },
+  {
+   "id": 5,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 4,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 1
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      2
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI/SVI_Wan2.2-I2V-A14B_high_noise_lora_v2.0.safetensors",
+    1.0
+   ],
+   "title": "SVI LoRA (HIGH, strength 1.0)"
+  },
+  {
+   "id": 6,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 5,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 2
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      3
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan_2_2_I2V_A14B_HIGH_lightx2v_4step_lora_v1030_rank_64_bf16.safetensors",
+    0.5
+   ],
+   "title": "lightx2v LoRA (HIGH, strength 0.5 - official SVI recipe)"
+  },
+  {
+   "id": 7,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    1080,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 6,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 3
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      16
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "High noise (SVI 1.0 + lightx2v 0.5)"
+  },
+  {
+   "id": 8,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 7,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 4
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      5
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI/SVI_Wan2.2-I2V-A14B_low_noise_lora_v2.0.safetensors",
+    1.0
+   ],
+   "title": "SVI LoRA (LOW, strength 1.0)"
+  },
+  {
+   "id": 9,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 8,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 5
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      6
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "wan2.2_i2v_A14b_low_noise_lora_rank64_lightx2v_4step_1022.safetensors",
+    1.0
+   ],
+   "title": "lightx2v LoRA (LOW, strength 1.0)"
+  },
+  {
+   "id": 10,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    1080,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 9,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 6
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      20
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    5.0
+   ],
+   "title": "Low noise (SVI 1.0 + lightx2v 1.0)"
+  },
+  {
+   "id": 11,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 10,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      12
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "fast fluid continuous motion, real-time speed, dynamic movement, no slow motion, no freeze frame"
+   ],
+   "title": "Positive prompt"
+  },
+  {
+   "id": 12,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 11,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 8
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      13
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "static, frozen, slow motion, freeze frame, low quality, blurry, motionless"
+   ],
+   "title": "Negative prompt"
+  },
+  {
+   "id": 13,
+   "type": "LoadImage",
+   "pos": [
+    1080,
+    660
+   ],
+   "size": [
+    320,
+    320
+   ],
+   "flags": {},
+   "order": 12,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      9
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "MASK",
+     "type": "MASK",
+     "links": [],
+     "slot_index": 1
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoadImage"
+   },
+   "widgets_values": [
+    "input.png",
+    "image"
+   ]
+  },
+  {
+   "id": 14,
+   "type": "WanNativeResize_Dolphin",
+   "pos": [
+    1440,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 13,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "image",
+     "type": "IMAGE",
+     "link": 9
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      10
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "links": [],
+     "slot_index": 1
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "links": [],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanNativeResize_Dolphin"
+   },
+   "widgets_values": [
+    "480P (832x480)",
+    "lanczos",
+    16
+   ]
+  },
+  {
+   "id": 15,
+   "type": "VAEEncode",
+   "pos": [
+    1840,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 14,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "pixels",
+     "type": "IMAGE",
+     "link": 10
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 11
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      15
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEEncode"
+   },
+   "widgets_values": [],
+   "title": "Encode anchor image -> LATENT"
+  },
+  {
+   "id": 16,
+   "type": "WanImageToVideoSVIProGray_Dolphin",
+   "pos": [
+    2240,
+    160
+   ],
+   "size": [
+    340,
+    220
+   ],
+   "flags": {},
+   "order": 15,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 12
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 13
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 14
+    },
+    {
+     "name": "anchor_samples",
+     "type": "LATENT",
+     "link": 15
+    },
+    {
+     "name": "prev_samples",
+     "type": "LATENT",
+     "link": null,
+     "shape": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "links": [
+      17,
+      21
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "links": [
+      18,
+      22
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "latent",
+     "type": "LATENT",
+     "links": [
+      19
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanImageToVideoSVIProGray_Dolphin"
+   },
+   "widgets_values": [
+    81,
+    0
+   ],
+   "title": "WanImageToVideoSVIProGray (root-cause-fixed, single clip: no prev_samples)"
+  },
+  {
+   "id": 17,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    2640,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 16,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 16
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 17
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 18
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 19
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      23
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "enable",
+    424242424242,
+    "fixed",
+    8,
+    1.5,
+    "euler",
+    "simple",
+    0,
+    4,
+    "enable"
+   ],
+   "title": "HIGH stage - SVI 1.0 + lightx2v 0.5, CFG 1.5, steps 0->4 of 8"
+  },
+  {
+   "id": 18,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    3000,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 17,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 20
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 21
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 22
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 23
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      24
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "disable",
+    424242424242,
+    "fixed",
+    8,
+    1.5,
+    "euler",
+    "simple",
+    4,
+    8,
+    "disable"
+   ],
+   "title": "LOW stage - SVI 1.0 + lightx2v 1.0, CFG 1.5, steps 4->8 of 8"
+  },
+  {
+   "id": 19,
+   "type": "VAEDecode",
+   "pos": [
+    3360,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 18,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "samples",
+     "type": "LATENT",
+     "link": 24
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 25
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      26
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEDecode"
+   },
+   "widgets_values": []
+  },
+  {
+   "id": 20,
+   "type": "VHS_VideoCombine",
+   "pos": [
+    3720,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 19,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "images",
+     "type": "IMAGE",
+     "link": 26
+    }
+   ],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "VHS_VideoCombine"
+   },
+   "widgets_values": {
+    "frame_rate": 16,
+    "loop_count": 0,
+    "filename_prefix": "wan22_slowmo/svi_scenarioA_official_recipe",
+    "format": "video/h264-mp4",
+    "pingpong": false,
+    "save_image": true,
+    "crf": 19,
+    "save_metadata": true,
+    "audio_file": ""
+   }
+  },
+  {
+   "id": 21,
+   "type": "Note",
+   "pos": [
+    2640,
+    480
+   ],
+   "size": [
+    1000,
+    320
+   ],
+   "flags": {},
+   "order": 20,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "Note"
+   },
+   "widgets_values": [
+    "시나리오 A: 공식 SVI Pro 레시피 재현 (vita-epfl/Stable-Video-Infinity, svi_wan22 브랜치 SVI-Wan22-1210-4-Clips.json 직접 분석해서 만듦).\n- lightx2v LoRA: High=0.5(절반 강도), Low=1.0(전체 강도) — 공식 워크플로우에서 그대로 확인.\n- SVI LoRA: High/Low 둘 다 1.0.\n- CFG: 1.5 균일 (README 원문: 'cfg 5가 원��� 기본값이지만 가속 컴포넌트(lightx2v) 때문에 유지가 안 돼서 1.5로 고정, 텍스트 순응도 올리려면 1~2 범위에서만 살짝 올려라').\n- 해상도: 480P(832x480) — 공식 예시와 커뮤니티 보고 모두 '480p가 720p보다 SVI+lightx2v 조합에서 더 안정적'이라고 함.\n  ⚠ 이건 메모리의 '832x480이 슬로우모션 유발'이라는 기록과 반대되는 관찰이라, SVI 맥락에서도 실제로 맞는지 이 테스트로 확인 필요.\n- 안카(anchor)만 있고 prev_samples는 없는 단일 클립 테스트입니다(WanImageToVideoSVIProGray_Dolphin의 root-cause fix는 적용됨). 멀티클립 체인(시나리오 D)은 별도 파일로.\n출처: raw.githubusercontent.com/vita-epfl/Stable-Video-Infinity/svi_wan22/comfyui_workflow/SVI-Wan22-1210-4-Clips.json, comfyui_workflow/README.md"
+   ],
+   "title": "Scenario A: Official SVI recipe (lightx2v Hi=0.5/Lo=1.0, CFG1.5, 480p)",
+   "color": "#432",
+   "bgcolor": "#653"
+  }
+ ],
+ "links": [
+  [
+   1,
+   3,
+   0,
+   5,
+   0,
+   "MODEL"
+  ],
+  [
+   2,
+   5,
+   0,
+   6,
+   0,
+   "MODEL"
+  ],
+  [
+   3,
+   6,
+   0,
+   7,
+   0,
+   "MODEL"
+  ],
+  [
+   4,
+   4,
+   0,
+   8,
+   0,
+   "MODEL"
+  ],
+  [
+   5,
+   8,
+   0,
+   9,
+   0,
+   "MODEL"
+  ],
+  [
+   6,
+   9,
+   0,
+   10,
+   0,
+   "MODEL"
+  ],
+  [
+   7,
+   1,
+   0,
+   11,
+   0,
+   "CLIP"
+  ],
+  [
+   8,
+   1,
+   0,
+   12,
+   0,
+   "CLIP"
+  ],
+  [
+   9,
+   13,
+   0,
+   14,
+   0,
+   "IMAGE"
+  ],
+  [
+   10,
+   14,
+   0,
+   15,
+   0,
+   "IMAGE"
+  ],
+  [
+   11,
+   2,
+   0,
+   15,
+   1,
+   "VAE"
+  ],
+  [
+   12,
+   11,
+   0,
+   16,
+   0,
+   "CONDITIONING"
+  ],
+  [
+   13,
+   12,
+   0,
+   16,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   14,
+   2,
+   0,
+   16,
+   2,
+   "VAE"
+  ],
+  [
+   15,
+   15,
+   0,
+   16,
+   3,
+   "LATENT"
+  ],
+  [
+   16,
+   7,
+   0,
+   17,
+   0,
+   "MODEL"
+  ],
+  [
+   17,
+   16,
+   0,
+   17,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   18,
+   16,
+   1,
+   17,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   19,
+   16,
+   2,
+   17,
+   3,
+   "LATENT"
+  ],
+  [
+   20,
+   10,
+   0,
+   18,
+   0,
+   "MODEL"
+  ],
+  [
+   21,
+   16,
+   0,
+   18,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   22,
+   16,
+   1,
+   18,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   23,
+   17,
+   0,
+   18,
+   3,
+   "LATENT"
+  ],
+  [
+   24,
+   18,
+   0,
+   19,
+   0,
+   "LATENT"
+  ],
+  [
+   25,
+   2,
+   0,
+   19,
+   1,
+   "VAE"
+  ],
+  [
+   26,
+   19,
+   0,
+   20,
+   0,
+   "IMAGE"
+  ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}

_archive/workflows/slowmo_svi_simple_nag_test.json

@@ -0,0 +1,1243 @@
+{
+ "last_node_id": 23,
+ "last_link_id": 30,
+ "nodes": [
+  {
+   "id": 1,
+   "type": "CLIPLoader",
+   "pos": [
+    0,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 0,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "CLIP",
+     "type": "CLIP",
+     "links": [
+      7,
+      8
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPLoader"
+   },
+   "widgets_values": [
+    "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+    "wan",
+    "default"
+   ]
+  },
+  {
+   "id": 2,
+   "type": "VAELoader",
+   "pos": [
+    0,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 1,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "VAE",
+     "type": "VAE",
+     "links": [
+      15,
+      18,
+      29
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAELoader"
+   },
+   "widgets_values": [
+    "wan_2.1_vae.safetensors"
+   ]
+  },
+  {
+   "id": 3,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 2,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      1
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+   ],
+   "title": "High-noise UNet"
+  },
+  {
+   "id": 4,
+   "type": "UnetLoaderGGUF",
+   "pos": [
+    0,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 3,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      4
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "UnetLoaderGGUF"
+   },
+   "widgets_values": [
+    "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+   ],
+   "title": "Low-noise UNet"
+  },
+  {
+   "id": 5,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 4,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 1
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      2
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI_v2_PRO_Wan2.2-I2V-A14B_HIGH_lora_rank_128_fp16.safetensors",
+    1.0
+   ],
+   "title": "SVI Pro 2.0 LoRA (HIGH, 1.0)"
+  },
+  {
+   "id": 6,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 5,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 2
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      3
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan21_I2V_14B_lightx2v_cfg_step_distill_lora_rank64.safetensors",
+    0.5
+   ],
+   "title": "lightx2v LoRA (HIGH, 0.5)"
+  },
+  {
+   "id": 7,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    1080,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 6,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 3
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      9
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    9.0
+   ],
+   "title": "ModelSamplingSD3 shift=9.0 (HIGH)"
+  },
+  {
+   "id": 8,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    360,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 7,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 4
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      5
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "SVI_v2_PRO_Wan2.2-I2V-A14B_LOW_lora_rank_128_fp16.safetensors",
+    1.0
+   ],
+   "title": "SVI Pro 2.0 LoRA (LOW, 1.0)"
+  },
+  {
+   "id": 9,
+   "type": "LoraLoaderModelOnly",
+   "pos": [
+    720,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 8,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 5
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      6
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoraLoaderModelOnly"
+   },
+   "widgets_values": [
+    "Wan21_I2V_14B_lightx2v_cfg_step_distill_lora_rank64.safetensors",
+    1.0
+   ],
+   "title": "lightx2v LoRA (LOW, 1.0)"
+  },
+  {
+   "id": 10,
+   "type": "ModelSamplingSD3",
+   "pos": [
+    1080,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 9,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 6
+    }
+   ],
+   "outputs": [
+    {
+     "name": "MODEL",
+     "type": "MODEL",
+     "links": [
+      11
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "ModelSamplingSD3"
+   },
+   "widgets_values": [
+    9.0
+   ],
+   "title": "ModelSamplingSD3 shift=9.0 (LOW)"
+  },
+  {
+   "id": 11,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    0
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 10,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      10,
+      12,
+      16
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "fast fluid continuous motion, real-time speed, dynamic movement, no slow motion, no freeze frame"
+   ],
+   "title": "Positive prompt"
+  },
+  {
+   "id": 12,
+   "type": "CLIPTextEncode",
+   "pos": [
+    1080,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 11,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "clip",
+     "type": "CLIP",
+     "link": 8
+    }
+   ],
+   "outputs": [
+    {
+     "name": "CONDITIONING",
+     "type": "CONDITIONING",
+     "links": [
+      17
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "CLIPTextEncode"
+   },
+   "widgets_values": [
+    "static, frozen, slow motion, freeze frame, low quality, blurry, motionless"
+   ],
+   "title": "Negative prompt"
+  },
+  {
+   "id": 13,
+   "type": "WanVideoNAG",
+   "pos": [
+    1440,
+    320
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 12,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 9
+    },
+    {
+     "name": "conditioning",
+     "type": "CONDITIONING",
+     "link": 10
+    }
+   ],
+   "outputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "links": [
+      20
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanVideoNAG"
+   },
+   "widgets_values": [
+    11.0,
+    0.25,
+    2.5,
+    "default",
+    false
+   ],
+   "title": "NAG (HIGH) - nag_scale 11/alpha .25/tau 2.5"
+  },
+  {
+   "id": 14,
+   "type": "WanVideoNAG",
+   "pos": [
+    1440,
+    480
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 13,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 11
+    },
+    {
+     "name": "conditioning",
+     "type": "CONDITIONING",
+     "link": 12
+    }
+   ],
+   "outputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "links": [
+      24
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanVideoNAG"
+   },
+   "widgets_values": [
+    11.0,
+    0.25,
+    2.5,
+    "default",
+    false
+   ],
+   "title": "NAG (LOW) - nag_scale 11/alpha .25/tau 2.5"
+  },
+  {
+   "id": 15,
+   "type": "LoadImage",
+   "pos": [
+    1080,
+    660
+   ],
+   "size": [
+    320,
+    320
+   ],
+   "flags": {},
+   "order": 14,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      13
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "MASK",
+     "type": "MASK",
+     "links": [],
+     "slot_index": 1
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "LoadImage"
+   },
+   "widgets_values": [
+    "input.png",
+    "image"
+   ]
+  },
+  {
+   "id": 16,
+   "type": "WanNativeResize_Dolphin",
+   "pos": [
+    1440,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 15,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "image",
+     "type": "IMAGE",
+     "link": 13
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      14
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "width",
+     "type": "INT",
+     "links": [],
+     "slot_index": 1
+    },
+    {
+     "name": "height",
+     "type": "INT",
+     "links": [],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanNativeResize_Dolphin"
+   },
+   "widgets_values": [
+    "480P (832x480)",
+    "lanczos",
+    16
+   ]
+  },
+  {
+   "id": 17,
+   "type": "VAEEncode",
+   "pos": [
+    1840,
+    660
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 16,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "pixels",
+     "type": "IMAGE",
+     "link": 14
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 15
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      19
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEEncode"
+   },
+   "widgets_values": [],
+   "title": "Anchor encode"
+  },
+  {
+   "id": 18,
+   "type": "WanImageToVideoSVIProGray_Dolphin",
+   "pos": [
+    1840,
+    160
+   ],
+   "size": [
+    340,
+    220
+   ],
+   "flags": {},
+   "order": 17,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 16
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 17
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 18
+    },
+    {
+     "name": "anchor_samples",
+     "type": "LATENT",
+     "link": 19
+    },
+    {
+     "name": "prev_samples",
+     "type": "LATENT",
+     "link": null,
+     "shape": 7
+    }
+   ],
+   "outputs": [
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "links": [
+      21,
+      25
+     ],
+     "slot_index": 0
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "links": [
+      22,
+      26
+     ],
+     "slot_index": 1
+    },
+    {
+     "name": "latent",
+     "type": "LATENT",
+     "links": [
+      23
+     ],
+     "slot_index": 2
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "WanImageToVideoSVIProGray_Dolphin"
+   },
+   "widgets_values": [
+    81,
+    0
+   ],
+   "title": "SVIProGray (root-cause-fixed, single clip)"
+  },
+  {
+   "id": 19,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    2240,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 18,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 20
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 21
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 22
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 23
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      27
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "enable",
+    373737373737,
+    "fixed",
+    8,
+    1.0,
+    "euler",
+    "simple",
+    0,
+    4,
+    "enable"
+   ],
+   "title": "HIGH - NAG model, CFG 1.0, 0->4 of 8"
+  },
+  {
+   "id": 20,
+   "type": "KSamplerAdvanced",
+   "pos": [
+    2600,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 19,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "model",
+     "type": "MODEL",
+     "link": 24
+    },
+    {
+     "name": "positive",
+     "type": "CONDITIONING",
+     "link": 25
+    },
+    {
+     "name": "negative",
+     "type": "CONDITIONING",
+     "link": 26
+    },
+    {
+     "name": "latent_image",
+     "type": "LATENT",
+     "link": 27
+    }
+   ],
+   "outputs": [
+    {
+     "name": "LATENT",
+     "type": "LATENT",
+     "links": [
+      28
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "KSamplerAdvanced"
+   },
+   "widgets_values": [
+    "disable",
+    373737373737,
+    "fixed",
+    8,
+    1.0,
+    "euler",
+    "simple",
+    4,
+    8,
+    "disable"
+   ],
+   "title": "LOW - NAG model, CFG 1.0, 4->8 of 8"
+  },
+  {
+   "id": 21,
+   "type": "VAEDecode",
+   "pos": [
+    2960,
+    160
+   ],
+   "size": [
+    320,
+    120
+   ],
+   "flags": {},
+   "order": 20,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "samples",
+     "type": "LATENT",
+     "link": 28
+    },
+    {
+     "name": "vae",
+     "type": "VAE",
+     "link": 29
+    }
+   ],
+   "outputs": [
+    {
+     "name": "IMAGE",
+     "type": "IMAGE",
+     "links": [
+      30
+     ],
+     "slot_index": 0
+    }
+   ],
+   "properties": {
+    "Node name for S&R": "VAEDecode"
+   },
+   "widgets_values": []
+  },
+  {
+   "id": 22,
+   "type": "VHS_VideoCombine",
+   "pos": [
+    3320,
+    160
+   ],
+   "size": [
+    320,
+    260
+   ],
+   "flags": {},
+   "order": 21,
+   "mode": 0,
+   "inputs": [
+    {
+     "name": "images",
+     "type": "IMAGE",
+     "link": 30
+    }
+   ],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "VHS_VideoCombine"
+   },
+   "widgets_values": {
+    "frame_rate": 16,
+    "loop_count": 0,
+    "filename_prefix": "wan22_slowmo/svi_simple_nag",
+    "format": "video/h264-mp4",
+    "pingpong": false,
+    "save_image": true,
+    "crf": 19,
+    "save_metadata": true,
+    "audio_file": ""
+   }
+  },
+  {
+   "id": 23,
+   "type": "Note",
+   "pos": [
+    2240,
+    480
+   ],
+   "size": [
+    1000,
+    300
+   ],
+   "flags": {},
+   "order": 22,
+   "mode": 0,
+   "inputs": [],
+   "outputs": [],
+   "properties": {
+    "Node name for S&R": "Note"
+   },
+   "widgets_values": [
+    "간단 버전 (0705_vision3.json 대체, 2026-07-28). 단일 클립, 프롬프트 디렉터/액션 스플리터 없음.\n이전 그레이 노이즈 실패 원인 진단 결과 반영:\n- WanVideoNAG 추가(nag_scale=11/alpha=0.25/tau=2.5, 기본값) - CFG를 1.0까지 낮춰도 되는 건 NAG가 negative guidance를 대신하기 때문. NAG 없이 CFG1.5만 썼던 이전 버전이 그레이 노이즈 원인이었을 가능성 높음 (civitai.com/models/2305587 'SVI2Pro w/ NAG' 참고).\n- ModelSamplingSD3 shift=9.0 (이전엔 5.0 - vita-epfl 리서치 기준이었는데, 실제 CivitAI 레시피는 9.0).\n- LoRA는 사용자 실제 파일과 동일 계보: SVI Pro 2.0(rank128 fp16, Kijai/WanVideo_comfy 미러) + lightx2v Wan2.1(High=0.5/Low=1.0, CivitAI 권장값).\n- WanImageToVideoSVIProGray_Dolphin(필러 버그 수정판) 그대로 사용.\n튜닝 포인트: nag_scale/alpha/tau, shift, LoRA 강도(0.5~0.6 범위 권장), steps(8=4+4)."
+   ],
+   "title": "Simple SVI+NAG test (replaces heavy 0705_vision3.json)",
+   "color": "#432",
+   "bgcolor": "#653"
+  }
+ ],
+ "links": [
+  [
+   1,
+   3,
+   0,
+   5,
+   0,
+   "MODEL"
+  ],
+  [
+   2,
+   5,
+   0,
+   6,
+   0,
+   "MODEL"
+  ],
+  [
+   3,
+   6,
+   0,
+   7,
+   0,
+   "MODEL"
+  ],
+  [
+   4,
+   4,
+   0,
+   8,
+   0,
+   "MODEL"
+  ],
+  [
+   5,
+   8,
+   0,
+   9,
+   0,
+   "MODEL"
+  ],
+  [
+   6,
+   9,
+   0,
+   10,
+   0,
+   "MODEL"
+  ],
+  [
+   7,
+   1,
+   0,
+   11,
+   0,
+   "CLIP"
+  ],
+  [
+   8,
+   1,
+   0,
+   12,
+   0,
+   "CLIP"
+  ],
+  [
+   9,
+   7,
+   0,
+   13,
+   0,
+   "MODEL"
+  ],
+  [
+   10,
+   11,
+   0,
+   13,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   11,
+   10,
+   0,
+   14,
+   0,
+   "MODEL"
+  ],
+  [
+   12,
+   11,
+   0,
+   14,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   13,
+   15,
+   0,
+   16,
+   0,
+   "IMAGE"
+  ],
+  [
+   14,
+   16,
+   0,
+   17,
+   0,
+   "IMAGE"
+  ],
+  [
+   15,
+   2,
+   0,
+   17,
+   1,
+   "VAE"
+  ],
+  [
+   16,
+   11,
+   0,
+   18,
+   0,
+   "CONDITIONING"
+  ],
+  [
+   17,
+   12,
+   0,
+   18,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   18,
+   2,
+   0,
+   18,
+   2,
+   "VAE"
+  ],
+  [
+   19,
+   17,
+   0,
+   18,
+   3,
+   "LATENT"
+  ],
+  [
+   20,
+   13,
+   0,
+   19,
+   0,
+   "MODEL"
+  ],
+  [
+   21,
+   18,
+   0,
+   19,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   22,
+   18,
+   1,
+   19,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   23,
+   18,
+   2,
+   19,
+   3,
+   "LATENT"
+  ],
+  [
+   24,
+   14,
+   0,
+   20,
+   0,
+   "MODEL"
+  ],
+  [
+   25,
+   18,
+   0,
+   20,
+   1,
+   "CONDITIONING"
+  ],
+  [
+   26,
+   18,
+   1,
+   20,
+   2,
+   "CONDITIONING"
+  ],
+  [
+   27,
+   19,
+   0,
+   20,
+   3,
+   "LATENT"
+  ],
+  [
+   28,
+   20,
+   0,
+   21,
+   0,
+   "LATENT"
+  ],
+  [
+   29,
+   2,
+   0,
+   21,
+   1,
+   "VAE"
+  ],
+  [
+   30,
+   21,
+   0,
+   22,
+   0,
+   "IMAGE"
+  ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}

_archive/workflows/wan22_v2v_high_denoise_compare.json

@@ -0,0 +1,1198 @@
+{
+  "last_node_id": 21,
+  "last_link_id": 31,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "CLIPLoader",
+      "pos": [
+        0,
+        0
+      ],
+      "size": [
+        320,
+        110
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "CLIPLoader"
+      },
+      "widgets_values": [
+        "nsfw_wan_umt5-xxl_fp8_scaled.safetensors",
+        "wan",
+        "default"
+      ],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            5,
+            6
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 2,
+      "type": "VAELoader",
+      "pos": [
+        0,
+        150
+      ],
+      "size": [
+        320,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "VAELoader"
+      },
+      "widgets_values": [
+        "Wan2_1_VAE_bf16.safetensors"
+      ],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            9,
+            19,
+            30
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 3,
+      "type": "UnetLoaderGGUF",
+      "pos": [
+        0,
+        250
+      ],
+      "size": [
+        320,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "UnetLoaderGGUF"
+      },
+      "widgets_values": [
+        "Wan2.2-I2V-A14B-HighNoise-Q8_0.gguf"
+      ],
+      "title": "Load HIGH-noise GGUF",
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            1
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 4,
+      "type": "UnetLoaderGGUF",
+      "pos": [
+        0,
+        350
+      ],
+      "size": [
+        320,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "UnetLoaderGGUF"
+      },
+      "widgets_values": [
+        "Wan2.2-I2V-A14B-LowNoise-Q8_0.gguf"
+      ],
+      "title": "Load LOW-noise GGUF",
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 5,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        360,
+        250
+      ],
+      "size": [
+        320,
+        80
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "LoraLoaderModelOnly"
+      },
+      "widgets_values": [
+        "Wan21_I2V_14B_lightx2v_cfg_step_distill_lora_rank64.safetensors",
+        1.0
+      ],
+      "title": "lightx2v LoRA (HIGH)",
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            3
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 6,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        360,
+        350
+      ],
+      "size": [
+        320,
+        80
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "LoraLoaderModelOnly"
+      },
+      "widgets_values": [
+        "Wan21_I2V_14B_lightx2v_cfg_step_distill_lora_rank64.safetensors",
+        1.0
+      ],
+      "title": "lightx2v LoRA (LOW)",
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            4
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 7,
+      "type": "ModelSamplingSD3",
+      "pos": [
+        720,
+        250
+      ],
+      "size": [
+        260,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "ModelSamplingSD3"
+      },
+      "widgets_values": [
+        5.0
+      ],
+      "title": "ModelSamplingSD3 (HIGH, shift=5)",
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            10,
+            21
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 8,
+      "type": "ModelSamplingSD3",
+      "pos": [
+        720,
+        350
+      ],
+      "size": [
+        260,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "ModelSamplingSD3"
+      },
+      "widgets_values": [
+        5.0
+      ],
+      "title": "ModelSamplingSD3 (LOW, shift=5)",
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            14,
+            25
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 9,
+      "type": "CLIPTextEncode",
+      "pos": [
+        360,
+        0
+      ],
+      "size": [
+        400,
+        150
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "fast fluid continuous motion, real-time speed, no slow motion, no freeze"
+      ],
+      "title": "Positive prompt",
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 5
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            11,
+            15,
+            22,
+            26
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 10,
+      "type": "CLIPTextEncode",
+      "pos": [
+        800,
+        0
+      ],
+      "size": [
+        400,
+        150
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "static, frozen, slow motion, low quality, blurry"
+      ],
+      "title": "Negative prompt",
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 6
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            12,
+            16,
+            23,
+            27
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 11,
+      "type": "VHS_LoadVideo",
+      "pos": [
+        0,
+        450
+      ],
+      "size": [
+        320,
+        380
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideo"
+      },
+      "widgets_values": {
+        "video": "existing_animation.mp4",
+        "force_rate": 16,
+        "force_size": "Disabled",
+        "custom_width": 0,
+        "custom_height": 0,
+        "frame_load_cap": 81,
+        "skip_first_frames": 0,
+        "select_every_nth": 1
+      },
+      "title": "Load EXISTING animation (V2V source)",
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": [],
+          "slot_index": 1
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [],
+          "slot_index": 2
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": [],
+          "slot_index": 3
+        }
+      ]
+    },
+    {
+      "id": 12,
+      "type": "WanNativeResize_Dolphin",
+      "pos": [
+        360,
+        450
+      ],
+      "size": [
+        320,
+        100
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "WanNativeResize_Dolphin"
+      },
+      "widgets_values": [
+        "720P (1280x720)",
+        "lanczos",
+        16
+      ],
+      "title": "Align source video to WAN resolution",
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            8
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [],
+          "slot_index": 1
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [],
+          "slot_index": 2
+        }
+      ]
+    },
+    {
+      "id": 13,
+      "type": "VAEEncode",
+      "pos": [
+        720,
+        450
+      ],
+      "size": [
+        260,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "VAEEncode"
+      },
+      "widgets_values": [],
+      "title": "Encode existing animation -> latent",
+      "inputs": [
+        {
+          "name": "pixels",
+          "type": "IMAGE",
+          "link": 8
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 9
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            13,
+            24
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 14,
+      "type": "KSamplerAdvanced",
+      "pos": [
+        1100,
+        250
+      ],
+      "size": [
+        320,
+        260
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "KSamplerAdvanced"
+      },
+      "widgets_values": [
+        "enable",
+        12345,
+        "fixed",
+        6,
+        1.0,
+        "euler",
+        "simple",
+        3,
+        4,
+        "enable"
+      ],
+      "title": "[CaseA] HIGH stage (denoise~0.5, steps 3->4)",
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 10
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 11
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 12
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 13
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            17
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 15,
+      "type": "KSamplerAdvanced",
+      "pos": [
+        1100,
+        550
+      ],
+      "size": [
+        320,
+        260
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "KSamplerAdvanced"
+      },
+      "widgets_values": [
+        "disable",
+        12345,
+        "fixed",
+        6,
+        1.0,
+        "euler",
+        "simple",
+        4,
+        6,
+        "disable"
+      ],
+      "title": "[CaseA] LOW stage (steps 4->6)",
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 14
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 15
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 16
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 17
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            18
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 16,
+      "type": "VAEDecode",
+      "pos": [
+        1100,
+        850
+      ],
+      "size": [
+        260,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      },
+      "widgets_values": [],
+      "title": "[CaseA] Decode",
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 18
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 19
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            20
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 17,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        1100,
+        950
+      ],
+      "size": [
+        320,
+        260
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 16,
+        "loop_count": 0,
+        "filename_prefix": "wan22_v2v_CaseA_denoise0.5",
+        "format": "video/h264-mp4",
+        "pingpong": false,
+        "save_image": true,
+        "crf": 19,
+        "save_metadata": true,
+        "audio_file": ""
+      },
+      "title": "[CaseA] Save (denoise~0.5)",
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 20
+        }
+      ]
+    },
+    {
+      "id": 18,
+      "type": "KSamplerAdvanced",
+      "pos": [
+        1500,
+        250
+      ],
+      "size": [
+        320,
+        260
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "KSamplerAdvanced"
+      },
+      "widgets_values": [
+        "enable",
+        12345,
+        "fixed",
+        6,
+        1.0,
+        "euler",
+        "simple",
+        2,
+        4,
+        "enable"
+      ],
+      "title": "[CaseB] HIGH stage (denoise~0.67, steps 2->4)",
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 21
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 22
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 23
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 24
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            28
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 19,
+      "type": "KSamplerAdvanced",
+      "pos": [
+        1500,
+        550
+      ],
+      "size": [
+        320,
+        260
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "KSamplerAdvanced"
+      },
+      "widgets_values": [
+        "disable",
+        12345,
+        "fixed",
+        6,
+        1.0,
+        "euler",
+        "simple",
+        4,
+        6,
+        "disable"
+      ],
+      "title": "[CaseB] LOW stage (steps 4->6)",
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 25
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 26
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 27
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 28
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            29
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 20,
+      "type": "VAEDecode",
+      "pos": [
+        1500,
+        850
+      ],
+      "size": [
+        260,
+        60
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      },
+      "widgets_values": [],
+      "title": "[CaseB] Decode",
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 29
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 30
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            31
+          ],
+          "slot_index": 0
+        }
+      ]
+    },
+    {
+      "id": 21,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        1500,
+        950
+      ],
+      "size": [
+        320,
+        260
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 16,
+        "loop_count": 0,
+        "filename_prefix": "wan22_v2v_CaseB_denoise0.67",
+        "format": "video/h264-mp4",
+        "pingpong": false,
+        "save_image": true,
+        "crf": 19,
+        "save_metadata": true,
+        "audio_file": ""
+      },
+      "title": "[CaseB] Save (denoise~0.67)",
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 31
+        }
+      ]
+    }
+  ],
+  "links": [
+    [
+      1,
+      3,
+      0,
+      5,
+      0,
+      "MODEL"
+    ],
+    [
+      2,
+      4,
+      0,
+      6,
+      0,
+      "MODEL"
+    ],
+    [
+      3,
+      5,
+      0,
+      7,
+      0,
+      "MODEL"
+    ],
+    [
+      4,
+      6,
+      0,
+      8,
+      0,
+      "MODEL"
+    ],
+    [
+      5,
+      1,
+      0,
+      9,
+      0,
+      "CLIP"
+    ],
+    [
+      6,
+      1,
+      0,
+      10,
+      0,
+      "CLIP"
+    ],
+    [
+      7,
+      11,
+      0,
+      12,
+      0,
+      "IMAGE"
+    ],
+    [
+      8,
+      12,
+      0,
+      13,
+      0,
+      "IMAGE"
+    ],
+    [
+      9,
+      2,
+      0,
+      13,
+      1,
+      "VAE"
+    ],
+    [
+      10,
+      7,
+      0,
+      14,
+      0,
+      "MODEL"
+    ],
+    [
+      11,
+      9,
+      0,
+      14,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      12,
+      10,
+      0,
+      14,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      13,
+      13,
+      0,
+      14,
+      3,
+      "LATENT"
+    ],
+    [
+      14,
+      8,
+      0,
+      15,
+      0,
+      "MODEL"
+    ],
+    [
+      15,
+      9,
+      0,
+      15,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      16,
+      10,
+      0,
+      15,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      17,
+      14,
+      0,
+      15,
+      3,
+      "LATENT"
+    ],
+    [
+      18,
+      15,
+      0,
+      16,
+      0,
+      "LATENT"
+    ],
+    [
+      19,
+      2,
+      0,
+      16,
+      1,
+      "VAE"
+    ],
+    [
+      20,
+      16,
+      0,
+      17,
+      0,
+      "IMAGE"
+    ],
+    [
+      21,
+      7,
+      0,
+      18,
+      0,
+      "MODEL"
+    ],
+    [
+      22,
+      9,
+      0,
+      18,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      23,
+      10,
+      0,
+      18,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      24,
+      13,
+      0,
+      18,
+      3,
+      "LATENT"
+    ],
+    [
+      25,
+      8,
+      0,
+      19,
+      0,
+      "MODEL"
+    ],
+    [
+      26,
+      9,
+      0,
+      19,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      27,
+      10,
+      0,
+      19,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      28,
+      18,
+      0,
+      19,
+      3,
+      "LATENT"
+    ],
+    [
+      29,
+      19,
+      0,
+      20,
+      0,
+      "LATENT"
+    ],
+    [
+      30,
+      2,
+      0,
+      20,
+      1,
+      "VAE"
+    ],
+    [
+      31,
+      20,
+      0,
+      21,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

arch_logic.py

@@ -0,0 +1,141 @@
+import os
+import json
+import folder_paths
+import comfy.sd
+import comfy.utils
+from safetensors import safe_open
+import hashlib
+import urllib.request
+
+CACHE_FILE = os.path.join(os.path.dirname(__file__), "dolphin_tags_cache.json")
+
+def load_dolphin_cache():
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except: return {}
+    return {}
+
+def save_dolphin_cache(cache_data):
+    try:
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(cache_data, f, indent=4)
+    except: pass
+
+class DolphinArchitectV15:
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + folder_paths.get_filename_list("loras")
+        
+        res = {
+            "required": {
+                "global_switch": ("BOOLEAN", {"default": True, "label_on": "GLOBAL ON", "label_off": "GLOBAL OFF (SKIP)"}),
+                "model_base": ("MODEL",), "clip_base": ("CLIP",),
+                "model_high": ("MODEL",), "clip_high": ("CLIP",),
+                "model_low": ("MODEL",), "clip_low": ("CLIP",),
+            },
+            "optional": {}
+        }
+
+        # [다이어트 완료] 오직 이름과 웨이트만 남겨서 가장 얇은 UI를 만듭니다.
+        res["optional"]["header_master"] = ("STRING", {"default": "─── [ MASTER: B+H ] ───", "multiline": False})
+        for i in range(1, 5): 
+            res["optional"][f"master_l_{i}"] = (loras, {"default": "None"})
+            res["optional"][f"master_b_w_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01})
+            res["optional"][f"master_h_w_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01})
+            
+        res["optional"]["header_low"] = ("STRING", {"default": "─── [ LOW ONLY ] ───", "multiline": False})
+        for i in range(1, 5): 
+            res["optional"][f"low_l_{i}"] = (loras, {"default": "None"})
+            res["optional"][f"low_w_{i}"] = ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01})
+
+        res["optional"]["manual_triggers"] = ("STRING", {"default": "", "multiline": True})
+        return res
+
+    RETURN_TYPES = ("MODEL", "CLIP", "MODEL", "CLIP", "MODEL", "CLIP", "STRING")
+    RETURN_NAMES = ("M_BASE", "C_BASE", "M_HIGH", "C_HIGH", "M_LOW", "C_LOW", "triggers")
+    FUNCTION = "exec"
+    CATEGORY = "Dolphin"
+
+    def get_trig(self, lora_name):
+        if lora_name == "None": return []
+        path = folder_paths.get_full_path("loras", lora_name)
+        if not path or not os.path.exists(path): return []
+        
+        triggers = []
+        try:
+            with safe_open(path, framework="pt", device="cpu") as f:
+                m = f.metadata()
+                if m and "modelspec.trigger_words" in m:
+                    tw = json.loads(m["modelspec.trigger_words"])
+                    if isinstance(tw, list): triggers.extend(tw)
+                    elif isinstance(tw, str): triggers.append(tw)
+        except: pass
+        if triggers: return triggers 
+
+        cache = load_dolphin_cache()
+        if lora_name in cache and cache[lora_name]: return cache[lora_name]
+
+        try:
+            sha256_hash = hashlib.sha256()
+            with open(path, "rb") as f:
+                for byte_block in iter(lambda: f.read(4096 * 1024), b""):
+                    sha256_hash.update(byte_block)
+            
+            url = f"https://civitai.com/api/v1/model-versions/by-hash/{sha256_hash.hexdigest()}"
+            req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+            with urllib.request.urlopen(req, timeout=5) as response:
+                data = json.loads(response.read().decode('utf-8'))
+                api_triggers = data.get("trainedWords", [])
+                if api_triggers:
+                    cache[lora_name] = api_triggers
+                    save_dolphin_cache(cache)
+                    return api_triggers
+        except: pass
+        return triggers
+
+    def exec(self, global_switch, model_base, clip_base, model_high, clip_high, model_low, clip_low, manual_triggers="", **kwargs):
+        mb, cb = model_base, clip_base
+        mh, ch = model_high, clip_high
+        ml, cl = model_low, clip_low
+        
+        if not global_switch:
+            trigs = [t.strip() for t in manual_triggers.split(',') if t.strip()]
+            ut = ", ".join(list(dict.fromkeys(trigs)))
+            return (mb, cb, mh, ch, ml, cl, ut)
+
+        applied_names = []
+
+        for i in range(1, 5): 
+            n = kwargs.get(f"master_l_{i}", "None")
+            w_b = kwargs.get(f"master_b_w_{i}", 1.0)
+            w_h = kwargs.get(f"master_h_w_{i}", 1.0)
+            
+            # [최적화] None이 아니면서, 웨이트가 0.0이 아닐 때만 적용 (0.0이면 스위치 OFF 효과)
+            if n != "None" and (w_b != 0.0 or w_h != 0.0):
+                applied_names.append(n)
+                lora_data = comfy.utils.load_torch_file(folder_paths.get_full_path("loras", n))
+                mb, cb = comfy.sd.load_lora_for_models(mb, cb, lora_data, w_b, w_b)
+                mh, ch = comfy.sd.load_lora_for_models(mh, ch, lora_data, w_h, w_h)
+
+        for i in range(1, 5): 
+            n = kwargs.get(f"low_l_{i}", "None")
+            w = kwargs.get(f"low_w_{i}", 1.0)
+            
+            if n != "None" and w != 0.0:
+                applied_names.append(n)
+                lora_data = comfy.utils.load_torch_file(folder_paths.get_full_path("loras", n))
+                ml, cl = comfy.sd.load_lora_for_models(ml, cl, lora_data, w, w)
+
+        trigs = []
+        for n in set(applied_names):
+            trigs.extend(self.get_trig(n))
+            
+        if manual_triggers.strip():
+            manual_list = [t.strip() for t in manual_triggers.split(',') if t.strip()]
+            trigs.extend(manual_list)
+        
+        unique_trigs = ", ".join(list(dict.fromkeys(trigs)))
+        
+        return (mb, cb, mh, ch, ml, cl, unique_trigs)

arch_logic_v16.py

@@ -0,0 +1,80 @@
+import os
+import comfy.sd
+import comfy.utils
+import folder_paths
+
+# civitai/civitaired 파일명 쿼리 방식은 개인 학습 로라(공개 DB 미등록)에 대해
+# 항상 빈 값으로 실패한다. DolphinVisionDirector가 이미 검증한 조회 순서
+# (safetensors 임베디드 메타데이터 -> LoRA Manager 로컬 SQLite -> 해시 기반 API)를
+# 그대로 재사용한다 - 중복 구현하면 두 노드의 트리거 조회 결과가 따로 놀게 됨.
+from .dolphin_vision_director import get_triggers, _load_cache, _save_cache
+
+_TRIPLE_LORA_CACHE = {}
+
+class DolphinTripleLoraMatrix:
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + folder_paths.get_filename_list("loras")
+        inputs = {
+            "model_base": ("MODEL",), "clip_base": ("CLIP",),
+            "model_high": ("MODEL",), "clip_high": ("CLIP",),
+            "model_low": ("MODEL",),  "clip_low": ("CLIP",),
+        }
+        for i in range(1, 7):
+            inputs[f"lora_{i}"] = (loras, {"default": "None"})
+            # 토글을 이름 바로 옆(가중치 앞)에 붙임 - Vision Director(c{c}_lora_{n},
+            # c{c}_lora_{n}_on, c{c}_w_{n} 순서)와 동일한 배치. optional 위젯은 항상
+            # required 위젯 전부 뒤에 렌더링되므로 "이름 옆"이 되려면 required여야 한다.
+            # 이 재배치로 위젯 순서가 바뀌므로, 이미 저장된 워크플로우의 widgets_values는
+            # migrate_architect_v16_widgets.py로 재배치해야 한다 (구버전 노드는 이름이
+            # 아니라 위치로 값이 매핑됨).
+            inputs[f"lora_{i}_on"] = ("BOOLEAN", {"default": True,
+                                                   "label_on": "ON", "label_off": "OFF"})
+            inputs[f"weights_{i}"] = ("STRING", {"default": "0.0, 0.0, 0.0"})
+        opt = {
+            # civitai/civitaired에 등록 안 된 개인 학습 로라는 자동 트리거 조회가
+            # 항상 빈 값으로 실패한다. 그런 경우 여기에 콤마로 직접 적으면
+            # trigger_words 출력에 합쳐진다.
+            "manual_triggers": ("STRING", {"default": "", "multiline": True}),
+        }
+        return {"required": inputs, "optional": opt}
+
+    RETURN_TYPES = ("MODEL", "CLIP", "MODEL", "CLIP", "MODEL", "CLIP", "STRING")
+    RETURN_NAMES = ("M_BASE", "C_BASE", "M_HIGH", "C_HIGH", "M_LOW", "C_LOW", "trigger_words")
+    FUNCTION = "apply_matrix"
+    CATEGORY = "Dolphin"
+
+    def apply_matrix(self, model_base, clip_base, model_high, clip_high, model_low, clip_low, **kwargs):
+        m_b, c_b = model_base, clip_base
+        m_h, c_h = model_high, clip_high
+        m_l, c_l = model_low, clip_low
+        all_triggers = []
+        trigger_cache = _load_cache()
+
+        for i in range(1, 7):
+            lora_name = kwargs.get(f"lora_{i}")
+            w_str = kwargs.get(f"weights_{i}")
+
+            if lora_name == "None": continue
+            if not kwargs.get(f"lora_{i}_on", True): continue
+
+            # 트리거 워드 수집 (safetensors 메타데이터 -> LoRA Manager DB -> 해시 API)
+            all_triggers.extend(get_triggers(lora_name, trigger_cache))
+
+            try:
+                parts = [float(x.strip()) for x in w_str.split(',')]
+                wb, wh, wl = parts[0], parts[1], parts[2]
+            except: continue
+
+            if lora_name not in _TRIPLE_LORA_CACHE:
+                path = folder_paths.get_full_path("loras", lora_name)
+                _TRIPLE_LORA_CACHE[lora_name] = comfy.utils.load_torch_file(path)
+            data = _TRIPLE_LORA_CACHE[lora_name]
+
+            if wb != 0: m_b, c_b = comfy.sd.load_lora_for_models(m_b, c_b, data, wb, wb)
+            if wh != 0: m_h, c_h = comfy.sd.load_lora_for_models(m_h, c_h, data, wh, wh)
+            if wl != 0: m_l, c_l = comfy.sd.load_lora_for_models(m_l, c_l, data, wl, wl)
+
+        manual = [t.strip() for t in kwargs.get("manual_triggers", "").split(',') if t.strip()]
+        all_triggers = list(dict.fromkeys(all_triggers + manual))
+        return (m_b, c_b, m_h, c_h, m_l, c_l, ", ".join(all_triggers))

disk_cache_provider.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+"""
+디스크 기반 노드 출력 캐시 (ComfyUI cache provider API).
+
+ComfyUI는 노드 출력을 "입력 서명"(위젯 값 + 모든 조상 노드의 서명, 세션 간
+결정적 SHA256)으로 캐싱하는데, 그 캐시는 메모리에만 있어서 (1) 재시작하면
+사라지고 (2) 기본 RAM_PRESSURE 모드에서는 RAM이 부족하면 수시로 증발한다.
+
+이 프로바이더는 캐시 저장 시 디스크에도 쓰고, 메모리 캐시 미스 시 디스크에서
+복원한다. 효과:
+  - 재시작해도 시드/프롬프트/이미지가 같은 클립은 JoyCaption부터 샘플러까지
+    전부 스킵 (실행되지 않고 디스크에서 결과만 복원)
+  - 시드 하나만 바꾸면 정확히 그 클립 체인만 다시 생성 (서명에 모든 입력이
+    포함되므로 무효화 판정은 ComfyUI가 알아서 정확하게 해줌)
+  - MODEL/CLIP/VAE/NOISE 같은 객체 출력은 직렬화 불가로 자동 제외되어 저장 안 됨
+
+캐시 위치/용량은 환경변수로 조정:
+  DOLPHIN_DISK_CACHE_DIR      (기본: <output>/_node_disk_cache)
+  DOLPHIN_DISK_CACHE_MAX_GB   (기본: 40  — 초과 시 오래된 것부터 삭제)
+  DOLPHIN_DISK_CACHE_MAX_ENTRY_GB (기본: 2 — 이보다 큰 단일 출력은 저장 안 함)
+"""
+import os
+import time
+import asyncio
+import logging
+
+import torch
+
+import folder_paths
+from comfy_execution.cache_provider import register_cache_provider
+from comfy_api.latest._caching import CacheProvider, CacheValue
+
+log = logging.getLogger("dolphin.diskcache")
+
+_DEFAULT_DIR = os.path.join(folder_paths.get_output_directory(), "_node_disk_cache")
+CACHE_DIR = os.environ.get("DOLPHIN_DISK_CACHE_DIR", _DEFAULT_DIR)
+MAX_TOTAL_BYTES = int(float(os.environ.get("DOLPHIN_DISK_CACHE_MAX_GB", "15")) * (1024 ** 3))
+# VAEDecode/이미지 배치 결과(수백MB~1GB, 디코드된 프레임)는 일부러 상한 아래로 뒀다.
+# 비싼 건 디퓨전 샘플링(latent, 수십MB)이고 VAE 디코드는 latent만 있으면 몇 초면
+# 다시 되므로, 큰 디코드 결과까지 디스크에 쌓아둘 실익이 없다 - 용량만 먹는다.
+MAX_ENTRY_BYTES = int(float(os.environ.get("DOLPHIN_DISK_CACHE_MAX_ENTRY_GB", "0.2")) * (1024 ** 3))
+
+_ALLOWED_SCALARS = (str, int, float, bool, bytes, type(None))
+
+
+def _serializable(obj):
+    """텐서/스칼라/컨테이너만 허용. MODEL, NOISE, SAMPLER 등 객체가 섞이면 False."""
+    if isinstance(obj, torch.Tensor):
+        return True
+    if isinstance(obj, _ALLOWED_SCALARS):
+        return True
+    if isinstance(obj, (list, tuple)):
+        return all(_serializable(x) for x in obj)
+    if isinstance(obj, dict):
+        return all(isinstance(k, _ALLOWED_SCALARS) and _serializable(v) for k, v in obj.items())
+    return False
+
+
+def _to_cpu(obj):
+    if isinstance(obj, torch.Tensor):
+        return obj.detach().to("cpu")
+    if isinstance(obj, list):
+        return [_to_cpu(x) for x in obj]
+    if isinstance(obj, tuple):
+        return tuple(_to_cpu(x) for x in obj)
+    if isinstance(obj, dict):
+        return {k: _to_cpu(v) for k, v in obj.items()}
+    return obj
+
+
+def _tensor_bytes(obj):
+    if isinstance(obj, torch.Tensor):
+        return obj.numel() * obj.element_size()
+    if isinstance(obj, dict):
+        return sum(_tensor_bytes(v) for v in obj.values())
+    if isinstance(obj, (list, tuple)):
+        return sum(_tensor_bytes(v) for v in obj)
+    return 0
+
+
+class DolphinDiskCache(CacheProvider):
+    def __init__(self, directory=CACHE_DIR):
+        self.dir = directory
+        os.makedirs(self.dir, exist_ok=True)
+        self.log_path = os.path.join(self.dir, "_diskcache.log")
+
+    def _flog(self, msg):
+        # 콘솔이 안 보이는 환경에서도 저장/스킵 경로를 추적할 수 있게 파일로 남긴다.
+        # 주의: should_cache가 아예 호출 안 된 노드는 ComfyUI 쪽 NaN 키 게이트
+        # (_contains_self_unequal)에서 걸러진 것 - 로그에 안 찍히는 것 자체가 단서.
+        try:
+            with open(self.log_path, "a", encoding="utf-8") as f:
+                f.write(f"{time.strftime('%H:%M:%S')} {msg}\n")
+        except OSError:
+            pass
+
+    def _path(self, context):
+        return os.path.join(self.dir, f"{context.cache_key_hash}.pt")
+
+    async def on_lookup(self, context):
+        path = self._path(context)
+        if not os.path.isfile(path):
+            return None
+
+        def load():
+            return torch.load(path, map_location="cpu", weights_only=False)
+
+        try:
+            data = await asyncio.to_thread(load)
+        except Exception as e:
+            log.warning(f"[DiskCache] 손상된 캐시 삭제 ({context.class_type}): {e}")
+            try:
+                os.remove(path)
+            except OSError:
+                pass
+            return None
+        try:
+            os.utime(path, None)  # LRU: 접근 시각 갱신 (prune 시 오래된 것부터 삭제)
+        except OSError:
+            pass
+        print(f"💾 [DiskCache] {context.class_type} 디스크에서 복원 (node {context.node_id})")
+        self._flog(f"RESTORE {context.class_type} (node {context.node_id})")
+        return CacheValue(outputs=data["outputs"], ui=data.get("ui"))
+
+    def should_cache(self, context, value=None):
+        if value is None:  # lookup 시점 - 파일 존재 여부로 판단하므로 항상 시도
+            return True
+        if not _serializable(value.outputs):
+            self._flog(f"SKIP not-serializable {context.class_type} (node {context.node_id})")
+            return False
+        size = _tensor_bytes(value.outputs)
+        if size > MAX_ENTRY_BYTES:
+            self._flog(f"SKIP too-big {context.class_type} {size/1024/1024:.0f}MB (node {context.node_id})")
+            return False
+        self._flog(f"STORE-OK {context.class_type} {size/1024/1024:.1f}MB (node {context.node_id})")
+        return True
+
+    async def on_store(self, context, value):
+        path = self._path(context)
+        if os.path.exists(path):
+            return
+        try:
+            payload = {
+                "outputs": _to_cpu(value.outputs),
+                "ui": value.ui,
+                "class_type": context.class_type,
+                "saved_at": time.time(),
+            }
+
+            def save():
+                tmp = path + ".tmp"
+                torch.save(payload, tmp)
+                os.replace(tmp, path)
+
+            await asyncio.to_thread(save)
+            self._flog(f"SAVED {context.class_type} (node {context.node_id})")
+        except Exception as e:
+            log.warning(f"[DiskCache] 저장 실패 ({context.class_type}): {e}")
+            self._flog(f"SAVE-FAIL {context.class_type} (node {context.node_id}): {type(e).__name__}: {e}")
+            try:
+                os.remove(path + ".tmp")
+            except OSError:
+                pass
+
+    def on_prompt_end(self, prompt_id):
+        try:
+            self._prune()
+        except Exception as e:
+            log.warning(f"[DiskCache] prune 실패: {e}")
+
+    def _prune(self):
+        entries = []
+        total = 0
+        with os.scandir(self.dir) as it:
+            for e in it:
+                if e.name.endswith(".pt") and e.is_file():
+                    st = e.stat()
+                    entries.append((st.st_mtime, st.st_size, e.path))
+                    total += st.st_size
+        if total <= MAX_TOTAL_BYTES:
+            return
+        entries.sort()  # mtime 오래된 순
+        for _, size, path in entries:
+            try:
+                os.remove(path)
+                total -= size
+            except OSError:
+                pass
+            if total <= MAX_TOTAL_BYTES:
+                break
+
+
+_provider = None
+
+
+def register():
+    global _provider
+    if _provider is None:
+        _provider = DolphinDiskCache()
+        register_cache_provider(_provider)
+        print(f"💾 [Dolphin] 디스크 노드 캐시 활성화: {_provider.dir}")

dolphin_director.py

@@ -0,0 +1,93 @@
+import os
+import re
+import json
+import hashlib
+import urllib.request
+import urllib.error
+
+import folder_paths
+import comfy.sd
+import comfy.lora
+import comfy.utils
+from safetensors import safe_open
+
+try:
+    from .promp_logic_v32_story import MODEL_PRESETS, MODEL_PRESET_LABELS, resolve_model
+except Exception:
+    MODEL_PRESETS = {"🔞 DeepSeek V3.2": "deepseek/deepseek-v3.2"}
+    MODEL_PRESET_LABELS = list(MODEL_PRESETS.keys())
+    def resolve_model(p, c): return c if p == "custom" else "deepseek/deepseek-v3.2"
+
+class DolphinCinematicDirector:
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + folder_paths.get_filename_list("loras")
+        return {
+            "required": {
+                "model_base": ("MODEL",), "model_high": ("MODEL",), "model_low": ("MODEL",),
+                "mode": (["🤖 Auto LLM (Story Splitter)", "✍️ Manual"], {"default": "🤖 Auto LLM (Story Splitter)"}),
+                "master_story": ("STRING", {"multiline": True}),
+                "tagger_context": ("STRING", {"multiline": True}),
+                "openrouter_api_key": ("STRING", {"default": ""}),
+            },
+            "optional": {
+                "external_triggers": ("STRING", {"forceInput": True}),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "MODEL", "MODEL", "STRING") * 4 + ("STRING",)
+    RETURN_NAMES = tuple([f"c{i}_{n}" for i in range(1, 5) for n in ["base", "high", "low", "prompt"]] + ["debug_info"])
+    FUNCTION = "direct"
+    CATEGORY = "Dolphin"
+
+    def _build_final(self, action, tags, master_scene, name, trigger_str):
+        # 1. 트리거 워드(trigger_str)와 캐릭터 이름(name)만 상단에 배치
+        header = []
+        if name: header.append(name)
+        if trigger_str: header.append(trigger_str)
+        
+        # 2. 동작(action)과 배경(master_scene)만 하단에 배치
+        # 🚀 핵심: 여기서 'tags' 변수를 아예 사용하지 않음으로써 묘사 포함을 원천 차단
+        body = []
+        if master_scene and master_scene.strip():
+            body.append(master_scene.strip())
+        if action and action.strip():
+            body.append(action.strip())
+        
+        # 결과값 결합
+        header_str = ", ".join(header)
+        body_str = " ".join(body)
+        
+        if header_str and body_str:
+            return f"{header_str}\n{body_str}"
+        return header_str or body_str
+
+    def _llm_split(self, story, name, tags, key, model):
+        # 🚀 수정: LLM에게는 묘사를 보내되, 출력 JSON에서는 동작만 뽑도록 강제
+       sys_p = (
+    "You are an action-only generator. "
+    "DO NOT output any visual descriptions, clothing, lighting, or setting details. "
+    "Your output must ONLY be the physical movement of the character. "
+    "If you include any adjective-heavy descriptions, you will be penalized. "
+    "Strictly output only the kinetic action in the JSON fields."
+)
+
+    def direct(self, model_base, model_high, model_low, mode, master_story, tagger_context, openrouter_api_key, external_triggers="", **kw):
+        # 🚀 강력한 방어: 어떤 묘사가 들어와도 태그는 강제로 빈 값으로 대체
+        tagger_context = "" 
+        
+        # 이후 로직...
+        # 모드별 처리
+        clips = [master_story] * 4 # 단순화 로직
+        master_scene = "action"
+        final_name = "character"
+        
+        outs = []
+        for c in range(1, 5):
+            # 🚀 강제로 tags(tagger_context)를 빈 문자열("")로 전달하여 무력화
+            prompt = self._build_final(clips[c-1], "", master_scene, final_name, external_triggers)
+            outs.extend([model_base, model_high, model_low, prompt])
+
+        return tuple(outs) + ("Success",)
+
+NODE_CLASS_MAPPINGS = {"DolphinCinematicDirector": DolphinCinematicDirector}

dolphin_lora_prompt.py

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+"""
+🧬 Dolphin LoRA Prompt Weaver
+
+이미 만들어진 클립 프롬프트를, "그 클립에 실제로 걸리는 로라들이 잘 발화하도록"
+다시 쓰는 후처리 노드. 기존 노드는 하나도 건드리지 않는 독립 노드다.
+
+왜 후처리인가:
+  프롬프트 생성 로직(_plan_shots의 연출 규칙 9개)은 오래 튜닝된 자산이라
+  복제하면 두 곳이 따로 놀게 된다. 그래서 생성은 기존 노드에 그대로 맡기고,
+  이 노드는 '완성된 프롬프트 + 로라 목록 -> 다시 쓴 프롬프트'만 담당한다.
+  덕분에 어떤 소스(Vision Director의 c*_prompt, Prompt Director Single의
+  prompt, 그냥 텍스트 노드)에든 뒤에 끼워 넣을 수 있다.
+
+무엇을 고치는가:
+  기존 파이프라인은 트리거 워드를 캐릭터 이름 옆에 콤마로 나열한다
+  ("Yuna, penis, bounce, swing"). 문법적 맥락이 없는 '맨몸 단어'라 모델이
+  어느 부위에 걸린 디테일인지 알 방법이 없고, bounce/swing 같은 범용 동작
+  동사가 전신 모션으로 새서 캐릭터가 무슨 동작을 하든 콩콩 뛰는 문제가
+  실측으로 확인됐다.
+
+  이 노드는 로라의 사이드카 메타데이터(설명/태그/학습캡션)를 읽어서 LLM에게
+  "이 로라가 무엇을 하는 물건인지"를 먼저 알려준 뒤, 트리거를 문장 안에
+  해당 부위에 붙여서 다시 쓰게 한다 ("her penis bounces and swings as ...").
+  로라는 학습 캡션 분포와 닮은 프롬프트에서 가장 잘 발화하므로, 발화 자체도
+  같이 좋아지는 게 기대 효과.
+
+안전장치:
+  - enabled=OFF, 로라 0개, API 키 없음, LLM 실패 -> 입력 프롬프트를 그대로 통과.
+    어떤 경우에도 프롬프트를 잃지 않는다.
+  - `4n4lfi5tin6` 같은 학습 식별자는 LLM이 "정상 철자로 고쳐주는" 순간 로라가
+    안 걸리므로, 출력에서 원문 그대로 있는지 검증하고 없으면 1회 재시도한 뒤
+    그래도 없으면 문장 앞에 직접 붙인다(예전 콤마 방식 품질로 폴백).
+"""
+import json
+import os
+
+import folder_paths
+
+from . import lora_profile
+from .dolphin_vision_director import (
+    DolphinVisionDirector,
+    resolve_slug,
+    resolve_api_key,
+    _load_cache,
+    _get_triggers_raw,
+    LLM_PRESETS,
+    LLM_PRESET_LABELS,
+)
+
+MAX_SLOTS = 6
+
+
+SYSTEM_PROMPT = (
+    "You rewrite a single video-clip motion prompt so that the LoRA adapters listed below "
+    "will actually fire, WITHOUT changing what happens in the clip.\n"
+    "\n"
+    "HARD CONSTRAINTS — violating any of these is a failure:\n"
+    "1) DO NOT change the choreography. Same actions, same order, same body positions, same "
+    "pacing and energy. You are not re-directing the shot; you are re-wording it. Do not add a "
+    "new action, do not remove one, do not reorder them.\n"
+    "2) DO NOT add scenery, lighting, mood, clothing description or camera talk that was not "
+    "already there. This is a motion description for an animation model, not prose.\n"
+    "3) Keep the output roughly the same length as the input (±25%). Do not pad.\n"
+    "4) If the input starts with a short line that is just a character name, keep that line "
+    "exactly as it is, on its own line, and rewrite only what follows.\n"
+    "5) Keep the blunt, literal, anatomical register of the input. Never soften body parts or "
+    "acts into euphemism or metaphor.\n"
+    "\n"
+    "WHAT TO CHANGE — weave the LoRA vocabulary in:\n"
+    "6) Each adapter below only fires when the prompt resembles the captions it was trained on. "
+    "Rewrite the sentence so that vocabulary appears naturally inside it, with correct grammar, "
+    "never as an appended tag list.\n"
+    "7) Any string marked MUST APPEAR VERBATIM is a learned identifier. Reproduce it "
+    "character-for-character exactly as written — same spelling, digits and capitalisation "
+    "(e.g. '4n4lfi5tin6' stays '4n4lfi5tin6'; NEVER 'correct' it into real words). Place it "
+    "naturally, normally near the start.\n"
+    "8) Words listed as 'vocabulary it was trained on' are OPTIONAL. Use one ONLY where it "
+    "genuinely fits the action that is already in the prompt, and ALWAYS grammatically attached "
+    "to the specific body part or object it belongs to — write 'her penis bounces and swings as "
+    "she thrusts', NEVER a bare whole-body 'she bounces'. If a word does not fit what is already "
+    "happening, omit it entirely: a forced word is worse than a missing one, because the model "
+    "then applies that motion to the whole body.\n"
+    "9) 'training caption example' shows the phrasing style that adapter responds to. Move the "
+    "wording toward that style only where rules 1-5 still hold.\n"
+    "10) An adapter being active describes what is ALREADY in the clip. It never licenses you to "
+    "add the adapter's subject matter if the clip does not contain it.\n"
+    "\n"
+    'OUTPUT ONLY JSON: {"prompt":"<the rewritten prompt>"}'
+)
+
+
+class DolphinLoraPromptWeaver:
+    """완성된 프롬프트 + 로라 선택 -> 로라에 맞게 다시 쓴 프롬프트."""
+
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + (folder_paths.get_filename_list("loras") or [])
+        req = {
+            "prompt": ("STRING", {"multiline": True, "default": "", "forceInput": True,
+                                  "tooltip": "다시 쓸 원본 클립 프롬프트. Vision Director의 "
+                                             "c1_prompt나 Prompt Director Single의 prompt를 연결."}),
+            "enabled": ("BOOLEAN", {"default": True, "label_on": "WEAVE ON",
+                                    "label_off": "PASSTHROUGH (원본 그대로)",
+                                    "tooltip": "OFF면 입력 프롬프트를 손대지 않고 그대로 내보낸다. "
+                                               "A/B 비교용."}),
+            "openrouter_api_key": ("STRING", {"default": ""}),
+            "llm_preset": (LLM_PRESET_LABELS, {"default": "🔞 DeepSeek V3.2 (무삭제·JSON안정·추천)"}),
+            "llm_model": ("STRING", {"default": "deepseek/deepseek-v3.2"}),
+            "creativity": ("FLOAT", {"default": 0.4, "min": 0.1, "max": 1.5, "step": 0.05,
+                                     "tooltip": "다시 쓰기는 창작이 아니라 재표현이라 원 프롬프트 "
+                                                "생성(0.7)보다 낮게 잡는 게 맞다."}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+        }
+        for i in range(1, MAX_SLOTS + 1):
+            req[f"lora_{i}"] = (loras, {"default": "None"})
+            req[f"lora_{i}_on"] = ("BOOLEAN", {"default": True,
+                                               "label_on": "ON", "label_off": "OFF"})
+        opt = {
+            # Architect V16 등이 이미 로라 이름을 문자열로 들고 있으면 여기로 넘겨도 된다
+            # (위젯으로 고른 것과 합쳐진다). 줄바꿈 또는 콤마 구분.
+            "lora_names": ("STRING", {"multiline": True, "default": "", "forceInput": True}),
+            # civitai에 없는 개인 학습 로라처럼 자동 조회가 실패하는 경우 직접 입력.
+            "manual_triggers": ("STRING", {"default": "", "multiline": True,
+                                           "tooltip": "콤마 구분. 자동 조회가 안 되는 로라의 "
+                                                      "트리거를 직접 넣으면 같이 녹여준다."}),
+        }
+        return {"required": req, "optional": opt}
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING")
+    RETURN_NAMES = ("prompt", "lora_report", "debug_info")
+    FUNCTION = "weave"
+    CATEGORY = "Dolphin"
+
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _split_names(text):
+        """줄바꿈/콤마 구분 로라 이름 파싱.
+
+        로라 파일명 자체에 콤마가 들어있는 경우가 있어서
+        (예: 'Penis Lora (+Blowjob, +Cumshot) [Taz]...') 줄바꿈이 하나라도
+        있으면 줄 단위로만 자른다.
+        """
+        raw = str(text or "").strip()
+        if not raw:
+            return []
+        parts = raw.splitlines() if "\n" in raw else raw.split(",")
+        return [p.strip() for p in parts if p.strip() and p.strip() != "None"]
+
+    def _gather_names(self, kw):
+        names = []
+        for i in range(1, MAX_SLOTS + 1):
+            name = kw.get(f"lora_{i}", "None")
+            if name and name != "None" and kw.get(f"lora_{i}_on", True):
+                names.append(name)
+        names.extend(self._split_names(kw.get("lora_names")))
+        return list(dict.fromkeys(names))
+
+    @staticmethod
+    def _profiles(names, manual_list):
+        cache = _load_cache()
+        profs = []
+        for name in names:
+            # 사이드카(.metadata.json)가 있으면 그걸 쓰고, 없을 때만 기존 조회
+            # 경로(sha256 + 네트워크)를 지연 호출한다.
+            p = lora_profile.load_profile(
+                name, fallback_triggers=lambda n=name: _get_triggers_raw(n, cache))
+            if p:
+                profs.append(p)
+            else:
+                print(f"ℹ️ [LoraWeaver] 프로필 없음(설명·트리거 모두 조회 실패): "
+                      f"{os.path.basename(name)}")
+        if manual_list:
+            hard, soft, captions = lora_profile.classify_trained_words(manual_list)
+            if hard or soft or captions:
+                profs.append({
+                    "lora_name": "(manual)", "file": "(manual)",
+                    "display_name": "(수동 입력 트리거)", "description": "",
+                    "tags": [], "base_model": "",
+                    "hard_tokens": hard, "soft_words": soft, "captions": captions,
+                    "source": "manual",
+                })
+        return profs
+
+    @staticmethod
+    def _report(profs):
+        if not profs:
+            return "(로라 없음)"
+        lines = []
+        for p in profs:
+            bits = [p["display_name"]]
+            if p["hard_tokens"]:
+                bits.append("verbatim=" + ",".join(p["hard_tokens"]))
+            if p["soft_words"]:
+                bits.append("vocab=" + ",".join(p["soft_words"]))
+            if p["captions"]:
+                bits.append(f"caption예시 {len(p['captions'])}개")
+            if not p["description"]:
+                bits.append("설명없음")
+            lines.append(" | ".join(bits))
+        return "\n".join(lines)
+
+    @staticmethod
+    def _force_insert(text, missing):
+        """재시도까지 실패했을 때의 최후 폴백 - 토큰만 앞에 붙인다."""
+        body = str(text or "").strip()
+        return ", ".join(missing) + (f", {body}" if body else "")
+
+    # ------------------------------------------------------------------
+    def weave(self, prompt, enabled, openrouter_api_key, llm_preset, llm_model,
+              creativity, seed, **kw):
+        original = str(prompt or "")
+
+        if not enabled:
+            return (original, "(비활성)", "enabled=OFF - 원본 그대로 통과")
+        if not original.strip():
+            return (original, "(입력 없음)", "prompt 입력이 비어있음 - 그대로 통과")
+
+        manual_list = [t.strip() for t in str(kw.get("manual_triggers", "") or "").split(",")
+                       if t.strip()]
+        names = self._gather_names(kw)
+        profs = self._profiles(names, manual_list)
+        report = self._report(profs)
+
+        if not profs:
+            return (original, report, "적용할 로라 없음 - 원본 그대로 통과")
+
+        key = resolve_api_key(openrouter_api_key)
+        if not key:
+            print("❌ [LoraWeaver] openrouter_api_key 없음(위젯도, OPENROUTER_API_KEY 환경변수도) "
+                  "- 원본 그대로 통과")
+            return (original, report, "no api key - 원본 그대로 통과")
+
+        model = resolve_slug(LLM_PRESETS, llm_preset, llm_model, "deepseek/deepseek-v3.2")
+        engine = DolphinVisionDirector()   # _call_or/_extract_json만 빌려 쓴다(상태 없음)
+
+        usr = ("LORA ADAPTERS ACTIVE FOR THIS CLIP:\n"
+               + lora_profile.format_profiles_for_llm(profs)
+               + "\n\nPROMPT TO REWRITE (keep the choreography identical):\n"
+               + original)
+        messages = [{"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": usr}]
+
+        temp = creativity
+        last_err = "no attempts ran"
+        for attempt in (1, 2):
+            try:
+                content = engine._call_or(messages, model, key, temp, force_json=True)
+                parsed = engine._extract_json(content)
+                new_prompt = str((parsed or {}).get("prompt", "")).strip()
+                if not new_prompt:
+                    last_err = f"빈 응답 (attempt {attempt}): {str(content)[:120]!r}"
+                    print(f"⚠️ [LoraWeaver] {last_err}")
+                    temp = min(creativity, 0.3)
+                    continue
+
+                missing = lora_profile.missing_hard_tokens(new_prompt, profs)
+                if missing and attempt == 1:
+                    # LLM이 `4n4lfi5tin6` 같은 토큰을 정상 철자로 고쳐버리면 로라가
+                    # 안 걸린다. 한 번은 명시적으로 지적해서 재시도.
+                    print(f"⚠️ [LoraWeaver] 학습 토큰 누락 -> 재시도 요청: {missing}")
+                    messages = messages + [
+                        {"role": "assistant",
+                         "content": json.dumps({"prompt": new_prompt}, ensure_ascii=False)},
+                        {"role": "user",
+                         "content": ("Your rewrite dropped these required verbatim identifiers: "
+                                     + ", ".join(f'"{t}"' for t in missing)
+                                     + ". Rewrite again, same choreography, with each of them "
+                                       "appearing EXACTLY as written, woven naturally into the "
+                                       "sentence. Output ONLY the JSON.")},
+                    ]
+                    last_err = f"verbatim token 누락: {missing}"
+                    temp = min(creativity, 0.3)
+                    continue
+
+                if missing:
+                    new_prompt = self._force_insert(new_prompt, missing)
+                    print(f"⚠️ [LoraWeaver] 재시도 후에도 누락 -> 앞에 강제 삽입: {missing}")
+                    dbg = f"⚠️ ok, 토큰 강제삽입 (attempt {attempt}): {missing}"
+                else:
+                    dbg = f"✅ ok (attempt {attempt}), 로라 {len(profs)}개"
+
+                print(f"\n🧬 [Dolphin LoRA Prompt Weaver] {dbg}\n"
+                      f"  BEFORE: {original[:110]}\n  AFTER : {new_prompt[:110]}")
+                return (new_prompt, report, dbg)
+
+            except Exception as e:      # 네트워크/파싱/HTTP 무엇이 터지든 원본은 지킨다
+                last_err = f"{type(e).__name__}: {e}"
+                print(f"❌ [LoraWeaver] 호출 실패 (attempt {attempt}): {last_err}")
+                temp = min(creativity, 0.3)
+
+        print(f"❌ [LoraWeaver] 2회 모두 실패 - 원본 그대로 통과 ({last_err})")
+        return (original, report, f"❌ 실패, 원본 통과: {last_err}")
+
+
+NODE_CLASS_MAPPINGS = {"DolphinLoraPromptWeaver": DolphinLoraPromptWeaver}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DolphinLoraPromptWeaver": "🧬 Dolphin LoRA Prompt Weaver (프롬프트→로라에 맞게 재작성)",
+}

dolphin_minimax_director.py

@@ -0,0 +1,1430 @@
+# -*- coding: utf-8 -*-
+"""
+MiniMax(Hailuo) 전용 프롬프트 디렉터.
+
+DolphinPromptDirector는 Wan 파이프라인 전제(5초 클립 N개, 클립마다 로라/트리거)라
+MiniMax에 그대로 쓰면 형식이 안 맞는다. MiniMax는:
+  - 클립 하나가 통째로 길다 (호스팅 Hailuo 02는 6/10초지만, 로컬 가중치는 그 제약이 없음)
+  - 카메라 무브를 대괄호 지시어로 직접 지정 ([Push in], [Tracking shot] ...)
+  - 프롬프트가 "피사체 + 동작 + 카메라 + 분위기" 한 덩어리 자연어
+
+그래서 이 노드는 하나의 클립 안을 초 단위 비트로 쪼개서
+  [0-2s] 동작 [Push in]
+  [2-4s] 동작 [Tracking shot]
+형태의 타임라인을 만든다. 길이는 duration_seconds로 자유롭게 정한다 — 20초짜리
+한 클립이라도 주어진 동작 목록을 시간축에 순서대로 분배해서, 중간에 멍하니
+늘어지거나 같은 동작을 루프하는 걸 막는 게 이 노드의 존재 이유다.
+
+비전 분석(VLM으로 앵커 뽑기)은 DolphinVisionDirector 것을 그대로 위임하고,
+샷 플래닝만 MiniMax 규약에 맞춰 새로 짰다.
+
+렌더러가 로컬 무검열 모델이라는 전제라, LLM 지시문에는
+dolphin_vision_director._plan_shots와 동일한 "노골적·해부학적 표현" 규칙을 넣었다.
+
+────────────────────────────────────────────────────────────────────────
+H3 프롬프트 규약 (2026-08 조사 결과, 실제 컷 튐 버그에서 역산)
+
+초기 버전은 비트마다 `[0-2s] 동작. [Push in]` 한 줄씩을 뱉었는데, 실제 렌더에서
+그 타임코드마다 다른 컷으로 점프하는 문제가 났다. 원인:
+
+  1. **`[...]`로 시작하는 줄 = H3의 샷 마커.** H3 공식 멀티샷 문법이
+     `[Shot 1]` / `[Shot 2] At 00:03.500, the camera cuts to ...` 다.
+     `[0-2s]`는 이것과 생김새가 같아서 모델이 샷 리스트로 읽는다.
+  2. **H3는 한 클립에 여러 샷을 넣는 게 기본 지원 기능.** 막는 지시가 없으면
+     알아서 자른다. "No cuts; one continuous take" 같은 제약을 명시해야 한다.
+  3. **비트마다 카메라 태그를 바꾸면 컷 신호가 더 강해진다.** 뷰포인트가 바뀔 땐
+     컷이 아니라 "카메라 무브"로 표현하라는 게 가이드 권장.
+  4. `[Push in]` 대괄호 카메라 문법은 구형 Director 모델(T2V-01-Director 등)
+     전용이다. H3는 평문으로 쓰되 **진폭+속도**를 붙이는 걸 권장
+     ("pulls out with large amplitude at slow speed").
+
+1차 수정(대괄호 제거 + 초 인라인)으로도 컷이 계속 났다. 특히 **첫 비트 경계에서**.
+2차 조사에서 원인이 대괄호가 아니라 **숫자 타임코드 자체**임이 확인됨:
+
+  > "Every prompt should begin with a shot identifier. The first shot does not
+  >  need a timestamp. Only later shots need precise cut times."
+  > "blocking the clip as 0 to 2 seconds, 2 to 5 seconds ... gives the model an
+  >  order to follow" — 이게 곧 멀티샷 블로킹 문법이다.
+
+즉 H3에서 `0-2s, 2-4s ...` 는 "그 시각에 컷하라"는 선언이다. 첫 구간은
+타임스탬프가 없어서 샷 1이고, 첫 숫자(2s)가 첫 컷 지점이 된다 — 사용자가 겪은
+"첫 2초 후 컷"과 정확히 일치. **초 단위 지정과 무컷은 H3에서 상호배타적이다.**
+
+그래서 컷을 원치 않으면 숫자 마커를 아예 쓰지 않고 지속시간을 말로만 쓴다:
+  `For the first two seconds she pushes off the ledge, then for the next three
+   seconds she strides toward the camera, and through the final two seconds ...`
+줄바꿈도 구분자 신호라서 연속 모드는 전부 한 문단(공백 조인)으로 낸다.
+숫자 블로킹/멀티샷/구형 Director 포맷은 `prompt_style` 옵션으로 남겨뒀다.
+
+출처: photogptai.com/guides/how-to-prompt-minimax-h3-video-model,
+mixio.studio/hailuo-h3-prompt-guide, videotoprompt.app/posts/hailuo-h3-prompt-guide
+
+────────────────────────────────────────────────────────────────────────
+공식 스펙 반영 (2026-08-10, MiniMax-AI/MiniMax-H3 공식 SKILL.md + HF 가이드 대조)
+
+위 문법은 전부 서드파티 블로그 기반이었는데, 공식 소스
+(github.com/MiniMax-AI/MiniMax-H3/skills/h3-prompt-writing/SKILL.md,
+huggingface.co/MiniMaxAI/MiniMax-H3/docs/VIDEO_PROMPT_WRITING_GUIDE_base_en.md)를
+대조해서 아래 3가지 갭을 반영했다:
+
+  1. **오디오 필드 부재.** H3는 비디오+오디오 동시생성 모델인데 기존 출력엔 오디오
+     지시가 전혀 없었다. 공식 포맷은 3필드: `integrated_multimodal_description` /
+     `overall_soundscape`(환경음·물리음, 대사·음악 제외) / `non_diegetic_music`
+     (배경음���). `include_audio_fields` 토글로 LLM이 이 둘을 추가로 써서
+     라벨 붙은 섹션으로 감싼다.
+  2. **카메라 용어 목록이 15개로 낡음.** 공식은 19개 — `POV`, `Roll clockwise`,
+     `Roll counterclockwise` 추가, `Shake`는 `Shake slightly`/`Shake strongly`로
+     분리.
+  3. **I2V 정렬 문장 누락.** 공식 I2VA 예시는 전부 본문 앞에
+     `"For the target video, at 0.00 seconds into the target video, <Picture 1>
+     (from [Shot 1]) is fully referenced."`를 붙인다. `i2v_alignment_prefix`
+     토글로 이미지가 연결됐을 때만 붙인다.
+
+기존에 실측으로 검증된 "숫자 타임코드 = 컷 선언" 로직(`_assemble`)은 건드리지
+않았다 — 새 필드는 그 결과물을 감싸기만 한다. 로컬 무검열 가중치가 이 공식
+포맷을 실제로 따르는지는 미검증이라 두 토글 다 기본 ON이지만 렌더 확인 필요.
+
+────────────────────────────────────────────────────────────────────────
+비트별 대사(dialogue) 추가 (2026-08-23, 의미불명 발화 버그 대응)
+
+공식 HF 디스커션(huggingface.co/MiniMaxAI/MiniMax-H3/discussions/76)에서
+"대사가 정확히 정의되지 않으면 H3가 랜덤/의미불명의 음성을 지어낸다"는 게
+확인됐다. 기존 오디오 규칙(soundscape)은 "대사를 언급하지 말라"고만 했지
+대사 자체를 넣을 자리도, 무대사를 명시할 자리도 없었다 - 정확히 이 버그를
+유발하는 구멍이었다.
+
+그래서 `_plan_beats`가 비트마다 "이 순간에 대사가 어울리는가"를 독립적으로
+판단하게 하고(`dialogue` 필드, rule 15), 어울리면 `_assemble`이 그 비트의
+문장에 자연스럽게 끼워넣는다. 대사는 작은따옴표(' ')로 감싸는데, 이건
+rule 11(다른 필드는 따옴표 금지)의 유일한 예외이자 JSON 파싱에도 안전하다
+(큰따옴표가 아니라 이스케이프 문제가 없음). 숫자 타임코드는 여기도 금지 -
+컷 유발 로직과 동일한 원칙.
+
+한 비트에도 대사가 안 들어갔으면 공식 부정 문장(`DIALOGUE_NEGATIVE` =
+"No dialogue. No voiceover. No singing. No lyrics. No random voices. No
+individual background speech.")을 자동으로 붙인다 - 침묵을 명시적으로
+선언해야 의미불명 발화가 안 나온다는 게 위 디스커션의 핵심이었다.
+별도 토글 안 만들고 기존 `include_audio_fields`에 묶었다 - 대사도 오디오
+스펙의 일부라 위젯을 늘릴 이유가 없었다.
+"""
+import json
+import math
+import random
+import re
+import urllib.request
+import urllib.error
+
+from .dolphin_vision_director import (
+    DolphinVisionDirector,
+    resolve_slug,
+    resolve_api_key,
+    _price_tag,
+    tensor_to_base64,
+    split_action_parts,
+)
+
+# 이 노드는 위젯 UI를 영어로 노출한다 - dolphin_vision_director의 공유
+# VLM_PRESETS/LLM_PRESETS(한글 라벨)는 다른 노드(VisionDirector 등)가 계속 쓰므로
+# 건드리지 않고, 여기서만 쓰는 영어 라벨 버전을 따로 둔다.
+VLM_PRESETS = {
+    "👁 Qwen2.5-VL 72B (special cases · recommended)": "qwen/qwen2.5-vl-72b-instruct",
+    "👁 Qwen2.5-VL 32B (balanced)": "qwen/qwen2.5-vl-32b-instruct",
+    "👁 Qwen2.5-VL 32B (free)": "qwen/qwen2.5-vl-32b-instruct:free",
+    "👁 Mistral Small 3.1 24B (Pixtral)": "mistralai/mistral-small-3.1-24b-instruct",
+    "👁 Gemma 3 27B (lightweight)": "google/gemma-3-27b-it",
+    "⚙️ custom (use text field below)": "__custom__",
+}
+VLM_PRESET_LABELS = list(VLM_PRESETS.keys())
+
+LLM_PRESETS = {
+    "🔞 DeepSeek V3.2 (uncensored · stable JSON · recommended)": "deepseek/deepseek-v3.2",
+    "🔞 Magnum v4 72B (natural phrasing)": "anthracite-org/magnum-v4-72b",
+    "🔞 Cydonia 24B v4.1 (lightweight · fast)": "thedrummer/cydonia-24b-v4.1",
+    # 2026-09-03: :free 슬러그 404 - 유료로 교체.
+    "🔞 Dolphin Mistral Venice (uncensored)": "cognitivecomputations/dolphin-mistral-24b-venice-edition",
+    # 2026-09-03 추가 (모델 페이지로만 확인, chat completions 스모크테스트 미완).
+    "🔞 Hermes 4 405B (steerable · strict format)": "nousresearch/hermes-4-405b",
+    # 2026-09-03: grok-4 / grok-4-fast deprecated(404) - grok-4.3으로 교체.
+    "🔞 Grok 4.3 (edgy prose · $1.25/$2.5)": "x-ai/grok-4.3",
+    "🔞 Euryale 70B L3.3 (sensory prose · loose format)": "sao10k/l3.3-euryale-70b",
+    "⚙️ custom (use text field below)": "__custom__",
+}
+# 2026-08-28: Valkyrie 49B V1(thedrummer/valkyrie-49b-v1) 추가했다가 뺐다 - 실제
+# API 호출이 404 "No endpoints found". 자세한 건 dolphin_vision_director.py의
+# LLM_PRESETS 옆 주석 참고(이 딕셔너리는 그 파일의 복제본).
+LLM_PRESET_LABELS = list(LLM_PRESETS.keys())
+
+
+# ======================================================================
+#  MiniMax 공식 카메라 무��� 지시어
+#  Director 계열 모델(T2V-01-Director / I2V-01-Director / Hailuo 02)이
+#  인식하는 건 아래 19개뿐(2026-08-10, 공식 SKILL.md 대조로 POV/Roll 추가,
+#  Shake를 slightly/strongly로 분리). 목록에 없는 표현은 그냥 일반 텍스트로
+#  먹혀서 카메라 제어가 안 걸리므로, LLM이 뭘 뱉든 여기로 정규화해서 거른다.
+# ======================================================================
+MINIMAX_CAMERA_MOVES = [
+    "Truck left", "Truck right",
+    "Pan left", "Pan right",
+    "Push in", "Pull out",
+    "Pedestal up", "Pedestal down",
+    "Tilt up", "Tilt down",
+    "Zoom in", "Zoom out",
+    "Shake slightly", "Shake strongly",
+    "Tracking shot", "Static shot",
+    "POV", "Roll clockwise", "Roll counterclockwise",
+]
+_CAMERA_LOOKUP = {m.lower(): m for m in MINIMAX_CAMERA_MOVES}
+
+# H3 프롬프트 필드 하드 상한(문자 수). 넘으면 뒤가 잘린다.
+MINIMAX_FIELD_LIMIT = 7000
+# 권장 상한. 필드는 7000자까지 받지만 가이드는 훨씬 짧게(대략 50~120 단어) 쓰는 쪽을
+# 권한다 - 길수록 모델이 지시를 평균내버려서 오히려 타임라인을 안 지킨다.
+MINIMAX_SOFT_LIMIT = 1200
+
+# 한 클립을 하나의 끊김 없는 테이크로 못 박는 제약 블록. H3는 멀티샷이 기본
+# 지원이라 이 문장이 없으면 타임코드 경계마다 컷을 넣어버린다.
+NO_CUT_CONSTRAINT = ("One continuous take. No cuts, no shot changes, no camera angle jumps, "
+                     "no dissolves or transitions, no teleporting — the camera path and the "
+                     "subject's motion stay unbroken from the first second to the last.")
+
+# 어느 비트에도 대사를 안 넣기로 한 경우 붙이는 공식 부정 지시문. H3는 "말하는
+# 상황처럼 보이는데 대사가 명시 안 되면" 의미불명의 음성을 지어내는 버릇이 있다
+# (공식 HF 디스커션 #76에서 확인) - 이걸 명시적으로 막아야 한다.
+DIALOGUE_NEGATIVE = ("No dialogue. No voiceover. No singing. No lyrics. No random voices. "
+                     "No individual background speech.")
+
+# "귀엽게/섹시하게" 같은 장식 부사가 들어오면 rule 13이 "뻔한 걸 피하라"고만 시켜서,
+# LLM이 그래도 두세 번째로 뻔한 제스처(손하트 다음은 고개 갸웃 정도)로 계속 수렴한다 -
+# 부정 지시만으로는 실제 다양성이 안 나온다는 게 반복 관찰됨(2026-08-23, "귀여운 포즈"
+# 입력 시 매번 비슷한 동작만 나온다는 사용자 리포트). 그래서 카테고리별 제스처 풀을
+# 만들어두고 seed로 하나를 미리 뽑아 "이걸 써라"고 프롬프트에 박아준다 - 시드가 바뀌면
+# 힌트도 바뀌니 실제로 결과가 달라진다. 손하트/V사인/브이/머리카락 넘기기처럼 이미
+# rule 13이 명시적으로 금지한 클리셰는 풀에서 아예 제외했다.
+GESTURE_BANK = {
+    "cute": [
+        "tilts their head and scrunches their nose while grinning",
+        "hops once on the balls of their feet with elbows tucked in",
+        "presses both palms to their own cheeks",
+        "spins once and lands with knees bent, beaming",
+        "shimmies their shoulders side to side in a small bounce",
+        "puffs out both cheeks and crosses their eyes",
+        "curls both hands into paws up near their chin",
+        "bites their bottom lip and gives a small shrug",
+        "wiggles their fingers in a tiny wave close to their chest",
+        "claps both hands together once in delight",
+        "sticks out their tongue briefly and grins",
+        "hugs their own arms and rocks side to side",
+        "taps their own chin with one finger, feigning innocence",
+        "does a quick curtsy, hem pinched between two fingers",
+        "crouches briefly with both fists raised in a tiny cheer",
+        "leans forward with hands clasped behind their back, rocking on their heels",
+        "flutters both hands like tiny wings at shoulder height",
+    ],
+    "playful": [
+        "sticks out their tongue and darts to one side",
+        "does a mock bow then springs back up laughing",
+        "hops from foot to foot, beckoning teasingly",
+        "spins a nearby object between their fingers",
+        "throws a playful mock punch at the air and dodges back",
+        "sneaks a few tiptoe steps then bursts into a run",
+        "flicks their own hair and dashes off laughing",
+        "mimes tossing something invisible over their shoulder",
+        "does a little skip-step and spins around",
+        "wags a finger teasingly then turns away giggling",
+    ],
+    "sexy": [
+        "trails one hand slowly down their own side",
+        "rolls their hips in a slow figure-eight while stepping forward",
+        "arches their back and rolls their shoulders",
+        "bites their bottom lip while holding eye contact, stepping closer",
+        "drags fingertips slowly along their own collarbone",
+        "sinks down slowly, hands trailing down their own thighs",
+        "leans back and stretches, arching their spine",
+        "runs both hands up their own torso and pauses at the ribs",
+    ],
+    "shy": [
+        "tucks their chin down and peeks up through their lashes",
+        "hides half their face behind one raised hand",
+        "picks at their own sleeve, eyes lowered",
+        "takes a half-step back, one foot turning inward",
+        "hugs something to their chest and looks away",
+        "presses their lips together and rubs one arm",
+        "ducks briefly behind their own shoulder",
+    ],
+    "happy": [
+        "throws both arms up and spins once",
+        "jumps and pumps a fist",
+        "claps rapidly while bouncing on their toes",
+        "laughs with their head tipped back",
+        "skips forward two quick steps",
+    ],
+    "confident": [
+        "squares their shoulders and plants their feet wide",
+        "flips their hair back and strides forward",
+        "points decisively toward camera",
+        "crosses their arms and cocks an eyebrow",
+        "plants both hands on their hips, chin raised",
+    ],
+}
+
+_GESTURE_KEYWORDS = {
+    "cute": ["cute", "cutely", "adorable", "adorably", "귀여운", "귀엽게", "깜찍"],
+    "playful": ["playful", "playfully", "mischievous", "장난스럽게", "장난스런", "장난기"],
+    "sexy": ["sexy", "sexily", "seductive", "seductively", "섹시", "요염"],
+    "shy": ["shy", "shyly", "bashful", "bashfully", "수줍", "부끄럽"],
+    "happy": ["happy", "happily", "joyful", "joyfully", "기쁘게", "즐겁게", "신나게"],
+    "confident": ["confident", "confidently", "당당하게", "자신있게"],
+}
+
+# 2026-08-28 추가: 위 _GESTURE_KEYWORDS는 essential_actions에 사용자가 직접 "cutely"
+# 같은 장식 부사를 타이핑했을 때만 발동한다. 요청: 이미지 자체의 표정을 읽어서(예:
+# 웃고 있으면 cute쪽, 심각한 표정이면 confident/sexy쪽) 자동으로 유도해달라 - 그래서
+# _vision_analyze()가 뽑는 anchors의 5번째 줄(표정/무드)을 같은 방식으로 스캔하는
+# 별도 키워드셋. "serious"/"intense"는 사용자가 명시한 대로 confident와 sexy 둘 다에
+# 걸어뒀다 - 심각한 표정이 상황에 따라 둘 중 어느 쪽으로도 자연스럽게 갈 수 있어서,
+# 매칭되면 두 카테고리 힌트가 다 뜨고 LLM이 장면에 맞는 쪽을 고른다.
+_MOOD_EXPRESSION_KEYWORDS = {
+    "cute": ["smiling", "smile", "grin", "grinning", "beaming", "sweet expression",
+             "warm smile", "giggl"],
+    "playful": ["smirk", "smirking", "mischievous", "teasing expression", "wink"],
+    "sexy": ["sultry", "seductive", "smoldering", "sensual", "half-lidded", "alluring",
+             "serious", "intense stare", "intense gaze"],
+    "shy": ["shy", "blushing", "bashful", "timid", "looking away", "averting"],
+    "happy": ["happy", "joyful", "laughing", "delighted", "elated", "cheerful"],
+    "confident": ["serious", "stern", "intense", "solemn", "unsmiling", "composed",
+                  "focused", "determined", "cold expression"],
+}
+
+
+def _kw_hit(text, kw):
+    """단어 경계 매치 - 부분 문자열 `in` 검사로는 "unsmiling"이 "smiling"에 우연히
+    걸려서 안 웃는(=정반대) 표정을 "cute"로 오인식하는 사고가 난다(2026-08-28, anchors
+    스캔 추가 직후 테스트로 실제 발견함). kw가 여러 단어 구(phrase)여도 앞뒤 경계만
+    잡으면 되므로 그대로 통한다."""
+    return re.search(r"\b" + re.escape(kw) + r"\b", text) is not None
+
+
+def _gesture_hints(actions, anchors, seed):
+    """actions의 장식 부사 + anchors(이미지에서 읽은 표정/무드, rule 5c) 둘 다 스캔해서
+    카테고리를 찾고, seed로 고정한 제스처 힌트를 만든다.
+
+    같은 카테고리라도 seed가 다르면 GESTURE_BANK에서 다른 항목을 뽑으므로, "귀여운
+    포즈" 같은 입력을 여러 번 돌려도(=시드가 바뀌면) 실제로 다른 동작이 나온다.
+    같은 seed 키(f"{seed}:{cat}")를 두 소스가 공유하므로, 텍스트로 "cutely"라고
+    썼든 이미지가 웃고 있어서 감지됐든 같은 카테고리면 같은 픽이 나와서 일관된다."""
+    act_text = (actions or "").lower()
+    anc_text = (anchors or "").lower()
+    hits = []
+    for cat, kws in _GESTURE_KEYWORDS.items():
+        from_action = any(_kw_hit(act_text, kw) for kw in kws)
+        from_image = any(_kw_hit(anc_text, kw) for kw in _MOOD_EXPRESSION_KEYWORDS.get(cat, []))
+        if from_action or from_image:
+            bank = GESTURE_BANK[cat]
+            pick = bank[random.Random(f"{seed}:{cat}").randrange(len(bank))]
+            source = "action wording" if from_action else "image expression"
+            hits.append(f'  - for "{cat}" (from {source}): {pick}')
+    if not hits:
+        return ""
+    return ("SUGGESTED GESTURES (seed-specific, per rule 13 — use this AS your concrete "
+            "gesture for the matching mood instead of inventing the usual cliché; adapt the "
+            "wording naturally into the action, and only substitute something else of your "
+            "own invention if this one truly cannot fit the scene):\n"
+            + "\n".join(hits) + "\n\n")
+
+
+# GESTURE_BANK/_gesture_hints는 "귀엽게/섹시하게" 같은 특정 수식어가 actions 텍스트에
+# 있을 때만 발동한다. 근데 그 트리거 없이도 - 즉 essential_actions가 완전히 똑같아도 -
+# LLM이 매번 "가장 그럴듯한" 동작·대사로 수렴하는 문제가 있었다(2026-08-28, "프롬프트가
+# 같더라도 좀 더 다양한 행동을 할수 없어? 매번 같은 패턴에 같은 대사"). creativity/seed는
+# 이미 정상 설정(0.7, 매 배치 randomize)이었는데도 반복됐다는 게 확인됨 - 온도만으론
+# 이 수렴을 잘 못 깬다는 뜻이라, GESTURE_BANK와 같은 방식(seed로 고정 선택 -> 명시
+# 주입)을 트리거 조건 없이 매번 강제로 적용하도록 일반화했다.
+ACTION_VARIATION_BANK = [
+    "let a secondary, incidental body part move independently of the main motion (fingers "
+    "flex, toes curl, head tilts) — a small detail that isn't the point but grounds it",
+    "vary the pacing within the beat itself: start slower than expected, then let it "
+    "accelerate or snap partway through",
+    "have the character's weight or balance point visibly shift during the motion, not just "
+    "the primary limb",
+    "let breath be audible in the action itself — a caught breath, a held breath released, "
+    "breathing syncing to the rhythm of the motion",
+    "introduce one small hesitation, correction, or stumble before the motion fully commits",
+    "let something in the immediate environment react to the motion — fabric shifts, an "
+    "object gets nudged, hair falls or sways",
+    "make the motion asymmetric — one side of the body leads distinctly before the other "
+    "catches up",
+    "let the eyes or gaze do something specific and separate from the main physical action "
+    "(glancing away, locking on, closing briefly)",
+    "vary where the tension sits in the body — sometimes the hands, sometimes the jaw, "
+    "sometimes the shoulders",
+    "let the motion overshoot slightly before settling, rather than stopping cleanly",
+]
+
+DIALOGUE_REGISTER_BANK = [
+    "teasing, drawing the words out slowly",
+    "breathless and urgent, words clipped short",
+    "mock-commanding, testing how it lands",
+    "quiet and half-embarrassed, almost muttered",
+    "defiant, chin raised, daring a reaction",
+    "worshipful and hushed, reverent",
+    "playfully mocking, biting back a laugh",
+    "pleading, voice cracking slightly at the edges",
+    "flat and matter-of-fact, almost surprising in how calm it is",
+    "sharp and startled, the words tumbling out before thought",
+    "low and deliberate, each word placed like a challenge",
+    "sing-song and light, almost taunting",
+]
+
+
+def _variation_hints(seed):
+    """essential_actions가 완전히 같아도 seed가 다르면 동작 실행 스타일과 대사 톤이
+    실제로 갈리도록, 매번(트리거 조건 없이) 한 쌍을 강제로 골라 주입한다.
+
+    _gesture_hints와 달리 특정 수식어 매치가 필요 없다 - "같은 프롬프트, 다른 결과"
+    문제 자체가 목적이라 항상 켜져 있어야 한다."""
+    action_pick = ACTION_VARIATION_BANK[
+        random.Random(f"{seed}:action_variation").randrange(len(ACTION_VARIATION_BANK))]
+    dialogue_pick = DIALOGUE_REGISTER_BANK[
+        random.Random(f"{seed}:dialogue_register").randrange(len(DIALOGUE_REGISTER_BANK))]
+    return (
+        "TAKE VARIATION (seed-specific — this run's distinct angle on an otherwise identical "
+        "prompt, per rules 4c/15c):\n"
+        f"  - execution style for this take: {action_pick}\n"
+        f"  - if any dialogue line is used, its delivery register should lean toward: "
+        f"{dialogue_pick}\n"
+        "  Weave these into the actual beats naturally - do not narrate them as separate "
+        "sentences, name them explicitly, or let them override what the action list or scene "
+        "anchors actually call for.\n\n")
+
+
+# 비트 개수 상한. 긴 클립(예: 60초)에 1초 단위를 걸면 비트가 수십 개가 되어
+# 프롬프트가 상한을 넘고, 모델도 그 정도 밀도의 지시는 못 따라온다.
+# 넘으면 거부하는 대신 beat 길이를 자동으로 넓히고 경고만 찍는다.
+MAX_BEATS = 24
+
+
+def _norm_camera(raw):
+    """LLM/사용자가 준 카메라 문자열을 '[Push in, Zoom in]' 형태로 정규화.
+
+    대괄호 유무·대소문자·순서 상관없이 받아서, 공식 15개에 매칭되는 것만 남긴다.
+    매칭이 하나도 없으면 빈 문자열(=카메라 지시 없음)."""
+    if not raw:
+        return ""
+    text = str(raw).replace("[", " ").replace("]", " ")
+    hits, seen = [], set()
+    for token in re.split(r"[,;/|]+", text):
+        key = " ".join(token.split()).lower()
+        if key in _CAMERA_LOOKUP and key not in seen:
+            seen.add(key)
+            hits.append(_CAMERA_LOOKUP[key])
+    if not hits:
+        return ""
+    # MiniMax 문서 권장: 한 번에 3개까지. 그 이상은 서로 상쇄돼서 무의미해진다.
+    return "[" + ", ".join(hits[:3]) + "]"
+
+
+# "순차 접속사" 스타일에서 쓰는 연결어. H3 가이드가 first/then/as/finally 같은
+# 순차 표현으로 순서를 못 박으라고 권한다.
+_SEQ_CONNECTIVES = ["then", "as", "then", "next", "then", "and then"]
+
+
+def _fmt_sec(x):
+    """2.0 -> '2', 2.5 -> '2.5'. 타임코드가 지저분해지는 것만 막는 용도."""
+    return str(int(x)) if float(x) == int(x) else f"{float(x):g}"
+
+
+_NUM_WORDS = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
+              "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen",
+              "seventeen", "eighteen", "nineteen", "twenty"]
+
+
+def _dur_parts(seconds):
+    """2.0 -> ('two seconds', False), 2.4 -> ('two seconds', True).
+
+    지속시간을 숫자 없이 말로만 쓰기 위한 것. H3에서 `0-2s` 같은 숫자 마커는
+    '그 시각에 컷하라'는 선언으로 읽히므로, 연속 테이크를 원하면 숫자를 쓰면 안 된다.
+    근사 여부를 따로 돌려주는 건 'For the first about two seconds' 같은 어색한
+    어순을 피하고 'For roughly the first two seconds'로 붙이기 위해서."""
+    s = float(seconds)
+    n = max(int(round(s)), 1)
+    word = _NUM_WORDS[n] if n < len(_NUM_WORDS) else str(n)
+    unit = "second" if n == 1 else "seconds"
+    return f"{word} {unit}", abs(s - n) > 0.05
+
+
+def _fmt_timecode(sec):
+    """3.5 -> '00:03.500'. H3 멀티샷 문법이 쓰는 컷 시점 표기."""
+    return f"{int(sec) // 60:02d}:{int(sec) % 60:02d}.{int(round((sec % 1) * 1000)):03d}"
+
+
+def _sentence(text):
+    """앞 글자를 대문자로 올리고 마침표를 하나만 붙인다. 연속 모드에서는 모든 블록이
+    한 문단에 이어 붙으므로 문장처럼 보여야 한다."""
+    t = str(text).strip().rstrip(".").strip()
+    if not t:
+        return ""
+    return t[0].upper() + t[1:] + "."
+
+
+def _strip_brackets(text):
+    """대괄호를 걷어낸다. H3는 `[...]`를 샷 마커로 읽기 때문에, 연속샷 포맷에서는
+    LLM이 액션 문장 안에 대괄호를 흘려도 그게 컷 신호가 되면 안 된다."""
+    return " ".join(str(text).replace("[", " ").replace("]", " ").split())
+
+
+def _lower_first(text):
+    """문장을 이어붙일 때 첫 글자만 소문자로. 고유명사/대문자 약어는 건드리지 않는다."""
+    t = str(text).strip().rstrip(".")
+    if not t or not t[0].isupper():
+        return t
+    # "She"는 낮추고 "Yuna"/"NASA"는 그대로 — 두 번째 글자가 대문자면 약어로 본다.
+    if len(t) > 1 and t[1].isupper():
+        return t
+    head = t.split()[0].strip(",")
+    if head in _PRONOUN_STARTS:
+        return t[0].lower() + t[1:]
+    return t
+
+
+# 이어붙일 때 소문자로 낮춰도 안전한 문장 시작 단어(대명사/관사). 이름으로 시작하는
+# 문장은 그대로 둬야 해서 화이트리스트 방식으로 간다.
+_PRONOUN_STARTS = {"She", "He", "They", "It", "The", "A", "An", "Her", "His", "Their", "Its"}
+
+
+def _auto_beat_count(duration):
+    """beat_seconds=0(auto)일 때 쓸 비트 개수. 대략 2.5초에 하나, 3~8개로 제한."""
+    return max(3, min(8, int(round(duration / 2.5))))
+
+
+def _beat_bounds(duration, beat_seconds):
+    """(start, end) 구간 리스트. beat_seconds<=0이면 None(=LLM이 직접 나눔)."""
+    duration = float(duration)
+    if beat_seconds is None or beat_seconds <= 0:
+        return None
+    step = float(beat_seconds)
+    if duration / step > MAX_BEATS:
+        widened = math.ceil(duration / MAX_BEATS * 10) / 10.0
+        print(f"⚠️ [MinimaxDirector] Splitting {_fmt_sec(duration)}s into {_fmt_sec(step)}s beats "
+              f"makes too many beats - widening to {_fmt_sec(widened)}s beats (max {MAX_BEATS} beats).")
+        step = widened
+
+    bounds, t = [], 0.0
+    while t < duration - 1e-6:
+        end = min(t + step, duration)
+        bounds.append((round(t, 2), round(end, 2)))
+        t = end
+
+    # 자투리 흡수: 20초를 3초로 나누면 마지막이 2초짜리로 남는데, 그게 한 비트의
+    # 절반도 안 되면 직전 비트에 합친다. 1초도 안 되는 비트에 동작을 하나 배정해봐야
+    # 모델이 못 따라오고 타임코드만 지저분해진다.
+    if len(bounds) > 1 and (bounds[-1][1] - bounds[-1][0]) < step * 0.5:
+        bounds = bounds[:-2] + [(bounds[-2][0], bounds[-1][1])]
+    return bounds
+
+
+def _call_openrouter(messages, model, key, temp, seed=None, timeout=120, force_json=False,
+                     usage_acc=None):
+    """DolphinVisionDirector._call_or와 같은 호출이지만 seed를 실제로 payload에 넣는다.
+
+    기존 _plan_shots는 seed 인자를 받기만 하고 API에 안 넘겨서, 같은 입력·같은
+    시���에도 매번 다른 프롬프트가 나왔다(A/B 비교가 불가능했던 원인). 여기서는
+    seed를 넘겨서 지원하는 프로바이더에서는 재현이 되게 한다."""
+    payload = {"model": model.strip(), "messages": messages, "temperature": temp}
+    if force_json:
+        payload["response_format"] = {"type": "json_object"}
+    if seed is not None:
+        # OpenRouter는 32bit 범위를 넘는 seed를 거부하는 프로바이더가 있어서 접는다.
+        payload["seed"] = int(seed) % (2 ** 31)
+    payload["usage"] = {"include": True}
+    req = urllib.request.Request(
+        "https://openrouter.ai/api/v1/chat/completions",
+        data=json.dumps(payload).encode("utf-8"),
+        headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"})
+    raw = json.loads(urllib.request.urlopen(req, timeout=timeout).read().decode("utf-8"))
+    u = raw.get("usage") or {}
+    if usage_acc is not None and u:
+        usage_acc["prompt"] += u.get("prompt_tokens", 0) or 0
+        usage_acc["completion"] += u.get("completion_tokens", 0) or 0
+        c = u.get("cost")
+        if c is None:
+            c = (u.get("cost_details") or {}).get("upstream_inference_cost")
+        usage_acc["cost"] += float(c or 0)
+    if "choices" not in raw:
+        err = raw.get("error") or raw
+        msg = err.get("message") if isinstance(err, dict) else str(err)
+        code = err.get("code") if isinstance(err, dict) else "?"
+        raise ValueError(f"API error (code={code}): {msg}")
+    return raw["choices"][0]["message"]["content"].strip()
+
+
+class DolphinMinimaxDirector:
+    """
+    이미지(선택) + 동작 서술 -> MiniMax/Hailuo용 초 단위 타임라인 프롬프트 1개.
+
+      1) IMAGE -> VLM이 앵커(외형/자세/지지물/환경) 추출 (vision_caption 입력이 있으면 그걸 사용)
+      2) 그 앵커 위에서 동작을 duration 안의 초 단위 비트로 분배 (LLM, 실패 시 로컬 폴백)
+      3) MiniMax 규약대로 조립: 피사체 문장 + [0-2s] 동작 [카메라] ... + 분위기 문장
+
+    image를 안 꽂으면 T2V 모드로 동작한다(앵커 없이 텍스트만으로 플래닝).
+    """
+
+    @classmethod
+    def INPUT_TYPES(s):
+        req = {
+            "essential_actions": ("STRING", {"multiline": True,
+                "default": "stands up and walks toward the camera, stops and looks back",
+                "tooltip": "If left empty, the LLM directs the action on its own using only the "
+                           "image anchors."}),
+            "duration_seconds": ("INT", {"default": 6, "min": 1, "max": 300, "step": 1,
+                "tooltip": "Total length of the clip to make, in seconds. The hosted Hailuo API "
+                           "only accepts 6/10 seconds, but local weights have no such limit, so "
+                           "20 or even 60 seconds gets distributed to match."}),
+            "beat_seconds": ("FLOAT", {"default": 2.0, "min": 0.0, "max": 30.0, "step": 0.5,
+                "tooltip": "How many seconds each timeline beat spans. 0 = auto (the LLM splits "
+                           f"it into 3-8 segments on its own). Going as fine as 1 second can make "
+                           f"the motion feel choppy, and if the beat count would exceed "
+                           f"{MAX_BEATS} it's widened automatically."}),
+            "prompt_style": (["Continuous prose (duration in words, no cuts — recommended)",
+                              "Sequential connectives (no time mentioned, strongest cut prevention)",
+                              "Second timeblocking (0-2s = a cut-point declaration in H3)",
+                              "Multi-shot [Shot N] (intentional cuts)",
+                              "Director brackets (for legacy T2V-01-Director)"],
+                {"default": "Continuous prose (duration in words, no cuts — recommended)",
+                 "tooltip": "In H3, a numeric timecode is a declaration to 'cut at that moment' - "
+                            "exact-second timing and no-cut are mutually exclusive, so you have "
+                            "to pick a style.\n"
+                            "Continuous prose: one paragraph like 'For the first two seconds ..., "
+                            "then for the next three seconds ...'. No numbers, so no cut happens "
+                            "while timing is still conveyed.\n"
+                            "Sequential connectives: no time mentioned at all, just order via "
+                            "first/then/finally. Use this if prose mode still produces cuts.\n"
+                            "Second timeblocking: only when exact seconds must be honored. This "
+                            "causes cuts.\n"
+                            "Multi-shot: for when you want cuts on purpose. Official [Shot N] "
+                            "syntax.\n"
+                            "Director brackets: for legacy T2V-01-Director-family models only."}),
+            "no_cut_constraint": ("BOOLEAN", {"default": True,
+                "label_on": "NO CUT (force continuous take)", "label_off": "No cut constraint",
+                "tooltip": "Appends a 'One continuous take. No cuts...' constraint to the end of "
+                           "the prompt. H3 supports multi-shot by default, so without this it "
+                           "inserts cuts on its own. Automatically ignored in Multi-shot style."}),
+            "camera_mode": (["Single continuous camera (LLM, recommended)",
+                             "off (no camera mentioned)",
+                             "manual (fixed value below)",
+                             "Per-segment brackets (Director only)"],
+                {"default": "Single continuous camera (LLM, recommended)",
+                 "tooltip": "In H3, swapping the camera on every beat is itself a cut signal. "
+                            "The default is a single camera move written in plain prose that "
+                            "runs through the whole clip."}),
+            "camera_manual": ("STRING", {"default": "slow push in, small amplitude",
+                "tooltip": "Only used when set to manual. In continuous/prose mode the sentence "
+                           "goes in as-is (H3's recommended notation: move + amplitude + speed, "
+                           "e.g. 'pulls out with large amplitude at slow speed'). Only in "
+                           "'Per-segment brackets' mode are segments split with | and only the "
+                           f"following moves are recognized: {', '.join(MINIMAX_CAMERA_MOVES)}"}),
+            "character_name": ("STRING", {"default": "AUTO"}),
+            "artistic_vibe": ("STRING", {"multiline": True,
+                                         "default": "cinematic lighting, natural motion"}),
+            "detail_level": (["Short (concise)", "Essentials + anchors only", "Detailed"],
+                             {"default": "Essentials + anchors only"}),
+            "use_vision": ("BOOLEAN", {"default": True,
+                                       "label_on": "VISION ON", "label_off": "VISION OFF (text only)"}),
+            "openrouter_api_key": ("STRING", {"default": ""}),
+            "vlm_preset": (VLM_PRESET_LABELS, {"default": "👁 Qwen2.5-VL 72B (special cases · recommended)"}),
+            "vlm_model": ("STRING", {"default": "qwen/qwen2.5-vl-72b-instruct"}),
+            "llm_preset": (LLM_PRESET_LABELS, {"default": "🔞 DeepSeek V3.2 (uncensored · stable JSON · recommended)"}),
+            "llm_model": ("STRING", {"default": "deepseek/deepseek-v3.2"}),
+            "creativity": ("FLOAT", {"default": 0.7, "min": 0.1, "max": 1.5, "step": 0.05}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            # 2026-08-10 추가분 - 기존 워크플로우의 widgets_values 포지션이 안 밀리도록
+            # 반드시 맨 끝에 붙인다(중간에 넣으면 이 뒤의 모든 위젯값이 밀린다 - 실제로
+            # 한 번 겪었음, [[dolphin-nodes-repo-features]] 참고).
+            "include_audio_fields": ("BOOLEAN", {"default": True,
+                "label_on": "Include audio fields (official format)",
+                "label_off": "Video only (legacy format)",
+                "tooltip": "Wraps the output in the official H3 3-field format "
+                           "(integrated_multimodal_description / overall_soundscape / "
+                           "non_diegetic_music). H3 is a model that generates video+audio "
+                           "together, so leaving this field unfilled does not mean silence - the "
+                           "model invents its own sound. Turn this on if you want intentional "
+                           "sound. Without an LLM (local fallback) it can't write audio "
+                           "sentences, so it's dropped automatically.\n"
+                           "This toggle also manages dialogue: the LLM judges per-beat whether a "
+                           "line fits, and inserts a short natural line only where it fits, or "
+                           "appends the 'No dialogue...' negative directive if no beat got one - "
+                           "this safeguard is needed because H3 tends to invent meaningless "
+                           "speech if dialogue isn't explicitly specified (official HF discussion "
+                           "#76)."}),
+            "i2v_alignment_prefix": ("BOOLEAN", {"default": False,
+                "label_on": "Include I2V alignment prefix (⚠️ cut risk)",
+                "label_off": "No prefix (default)",
+                "tooltip": "⚠️ Default OFF - when an image is connected (I2V), the official "
+                           "alignment sentence 'For the target video, at 0.00 seconds..., "
+                           "<Picture 1> (from [Shot 1]) is fully referenced.' gets prepended, "
+                           "but that sentence contains both a '[Shot 1]' bracket AND a '0.00 "
+                           "seconds' numeric timecode - exactly the H3 cut-triggering pattern "
+                           "confirmed by testing ([Shot N] At timestamp = the official multi-shot "
+                           "syntax), which directly conflicts with no_cut_constraint. Turning it "
+                           "on was reproduced to cause random cuts in practice (2026-08-13) - "
+                           "root cause unconfirmed but a prime suspect, so the default was "
+                           "reverted to OFF. Don't turn it on unless you're doing strict-spec "
+                           "experiments like FL2VA/Ref2VA."}),
+        }
+        opt = {
+            # I2V면 연결, T2V면 비워둠.
+            "image": ("IMAGE",),
+            # JoyCaption 등 로컬 캡션 노드 출력. 있으면 OpenRouter VLM 호출을 건너뛴다.
+            "vision_caption": ("STRING", {"multiline": True, "default": "", "forceInput": True}),
+            # 앞 클립의 프롬프트/동작을 연결하면 이번 클립이 그 끝 자세에서 이어진다.
+            "previous_action": ("STRING", {"multiline": True, "default": "", "forceInput": True}),
+        }
+        return {"required": req, "optional": opt}
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING", "STRING", "STRING")
+    RETURN_NAMES = ("prompt", "timeline_json", "debug_info", "resolved_character_name",
+                    "soundscape", "non_diegetic_music")
+    FUNCTION = "direct"
+    CATEGORY = "Dolphin"
+
+    # ------------------------------------------------------------------
+    #  LLM 플래닝
+    # ------------------------------------------------------------------
+    def _plan_beats(self, anchors, actions, name, vibe, detail, duration, bounds,
+                    camera_style, no_cut, llm_model, key, temp, seed, previous_action="",
+                    include_audio=True):
+        auto_direct = not actions.strip()
+        dur_s = _fmt_sec(duration)
+
+        # 대사도 오디오 스펙의 일부라 별도 토글 없이 include_audio에 묶는다.
+        # manner(전달 방식 묘사)와 line(실제 발화)을 필드 단계에서부터 분리한다 -
+        # 예전엔 한 필드에 같이 넣고 조립 시 이어붙였더니 "moaning softly" 같은
+        # 톤 묘사 단어까지 H3가 그대로 발화하는 문제가 있었다(2026-08-25, 실사용
+        # 리포트). line만 <d>...</d> 태그로 감싸서 발화 대상임을 명시하고, manner는
+        # 산문 서술로만 쓰이게 분리해서 고쳤다.
+        dialogue_field = (',"dialogue_manner":"<optional short delivery description for THIS '
+                          'beat, or empty>",'
+                          '"dialogue_line":"<optional exact spoken line for THIS beat, or empty>"'
+                          if include_audio else "")
+
+        if bounds is None:
+            n_hint = _auto_beat_count(duration)
+            slot_block = (f"  Split the {dur_s}-second clip into {n_hint} consecutive beats "
+                          f"yourself. They must tile 0 to {dur_s} seconds with no gaps and no "
+                          f"overlap: the first starts at 0, the last ends at {dur_s}.")
+            schema_beats = ('"beats":[{"start":<number>,"end":<number>,"action":"<...>",'
+                            '"camera":"<...>"' + dialogue_field + '}, ...]')
+        else:
+            slot_block = "\n".join(
+                f"  beat {i}: start={_fmt_sec(a)} end={_fmt_sec(b)}"
+                for i, (a, b) in enumerate(bounds, 1))
+            schema_beats = ('"beats":[' + ",".join(
+                f'{{"start":{_fmt_sec(a)},"end":{_fmt_sec(b)},"action":"<what happens in this '
+                f'{_fmt_sec(b - a)}-second window>","camera":"<...>"' + dialogue_field + '}'
+                for a, b in bounds) + "]")
+
+        n_beats = len(bounds) if bounds is not None else n_hint
+        act_parts = split_action_parts(actions)
+
+        if auto_direct:
+            action_rule = (
+                "1) INVENT THE ACTION. No action list is given. Design one coherent, continuously "
+                "developing movement that plausibly follows from the character's exact pose and "
+                f"situation in the SCENE ANCHORS, and that genuinely fills all {dur_s} seconds — "
+                "what would they naturally do next, starting right now from that position? Do not "
+                "invent new characters, new props, or a change of location.\n")
+            assign_label = "ACTION LIST: (none — invent it per rule 1)"
+            assign_body = ""
+        else:
+            # 20초짜리 클립에 동작 4개처럼 "비트 수 >> 동작 수"가 흔한데, 그냥 두면
+            # LLM이 앞쪽 비트에서 동작을 다 소진하고 남은 시간을 반복/정지로 때운다.
+            # 그래서 배분 비율을 계산해서 명시적으로 못 박는다.
+            if len(act_parts) and len(act_parts) < n_beats:
+                span = n_beats / len(act_parts)
+                ratio_rule = (
+                    f"   You have {len(act_parts)} action(s) for {n_beats} beats, so each action must "
+                    f"occupy roughly {span:.1f} consecutive beats. Do NOT finish the whole list early "
+                    "and then pad the remaining beats with idling, repetition, or a held pose. Break "
+                    "each action into its own sub-phases — wind-up, execution, follow-through, "
+                    "recovery — so it genuinely spans its share of the timeline as one continuous "
+                    "movement rather than being restated.\n")
+            elif len(act_parts) > n_beats:
+                ratio_rule = (
+                    f"   You have {len(act_parts)} actions for {n_beats} beats, so group consecutive "
+                    "actions together — roughly "
+                    f"{len(act_parts) / max(n_beats, 1):.1f} per beat — keeping the given order and "
+                    "dropping none of them.\n")
+            else:
+                ratio_rule = (
+                    f"   You have {len(act_parts)} actions for {n_beats} beats — one action per beat, "
+                    "in order.\n")
+            action_rule = (
+                "1) FOLLOW THE ACTION LIST. Distribute the listed actions across the beats IN THE "
+                "GIVEN ORDER — earlier actions in earlier beats, the last action in the last beat. "
+                "Never move a later action into an earlier beat, and never skip one.\n"
+                + ratio_rule)
+            assign_label = "ACTION LIST (in order — distribute across the beats per rule 1):"
+            # 원본 텍스트를 통짜로 넘기면 LLM이 구분자를 못 알아채고 전부 한 동작으로
+            # 읽어서 첫 비트에 몰아넣는다(실제로 겪은 버그) - 미리 쪼갠 항목을 번호 매겨
+            # 넘겨야 "몇 개의 동작인지"와 "경계가 어디인지"가 명확해진다.
+            assign_body = "\n".join(f"  {i}. {p}" for i, p in enumerate(act_parts, 1))
+
+        # 긴 클립일수록 "한 동작을 계속 반복" 실패 모드가 심해진다. 짧은 클립엔
+        # 불필요한 잔소리라 길이 기준으로만 붙인다.
+        arc_rule = ""
+        if duration >= 12:
+            arc_rule = (
+                f"1b) LONG CLIP ({dur_s}s). This is long enough that a single repeated motion will "
+                "read as a stuttering loop. The timeline needs a visible beginning, middle and end: "
+                "each beat must show the body in a measurably DIFFERENT position or phase from the "
+                "beat before it. Before writing, check that no two beats could be swapped without "
+                "the sequence making less sense — if they could, they are too similar.\n")
+
+        if camera_style == "perbeat":
+            camera_rule = (
+                "6) CAMERA (per beat). For every beat, pick the camera instruction that best serves "
+                "that beat's motion, chosen ONLY from this exact list:\n"
+                f"   {', '.join(MINIMAX_CAMERA_MOVES)}\n"
+                "   Write it in that beat's \"camera\" field as bracketed text, e.g. \"[Push in]\". "
+                "At most 3 combined in one bracket. Use the EXACT wording above. Do not change "
+                "camera on every beat — hold one move across neighbouring beats and leave "
+                "\"camera\" empty for beats that simply continue the previous one. Leave the "
+                "top-level \"camera\" field empty.\n")
+            cam_schema = '"camera":""'
+        elif camera_style == "continuous":
+            camera_rule = (
+                "6) CAMERA — ONE UNBROKEN MOVE FOR THE WHOLE CLIP. Put a single camera description "
+                "in the TOP-LEVEL \"camera\" field and leave every per-beat \"camera\" field empty. "
+                "Write it as plain English prose, NOT as a bracketed tag, and give it a move, an "
+                "amplitude and a speed — e.g. 'the camera pushes in with small amplitude at slow "
+                "speed, drifting to the left as she rises'. Usable moves: push in, pull out, truck "
+                "left/right, pan left/right, tilt up/down, pedestal up/down, arc, tracking shot, "
+                "static. It must be ONE continuous path that survives the entire clip: it may "
+                "accelerate, ease, or change direction smoothly, but it must never cut, jump to a "
+                "new angle, or restart from a different framing. If the subject's own motion is "
+                "the point, say the camera holds a static frame — that is also a valid answer.\n")
+            cam_schema = ('"camera":"<one continuous camera move for the whole clip, plain prose '
+                          'with amplitude and speed>"')
+        else:
+            camera_rule = (
+                "6) CAMERA. Leave the top-level \"camera\" field and every per-beat \"camera\" "
+                "field as empty strings. Camera is handled elsewhere — do not mention lenses, "
+                "shots, angles, zooms or any camera movement anywhere in the action text either.\n")
+            cam_schema = '"camera":""'
+
+        # H3는 한 클립에 여러 샷을 넣는 �� 기본 지원 기능이라, 막는 지시가 없으면
+        # 비트 경계마다 컷을 넣어버린다(실제로 겪은 버그). 그래서 규칙으로 못 박는다.
+        no_cut_rule = (
+            "0) ONE CONTINUOUS TAKE — THIS OVERRIDES EVERYTHING ELSE. The whole clip is a single "
+            "unbroken shot filmed in one go. The beats below are moments WITHIN that one shot, not "
+            "separate shots in an edit. Never write a cut, a shot change, a new angle, a "
+            "reframing, a dissolve, a transition, 'meanwhile', or 'we then see'. If the viewpoint "
+            "needs to change, the CAMERA MOVES there continuously — it never cuts there. The "
+            "subject must remain physically present and continuously visible the entire time; they "
+            "cannot teleport, reappear elsewhere, or be replaced by a different framing of "
+            "themselves.\n"
+            # 이게 실제로 컷을 유발한 범인이었다: 이 렌더러는 숫자 시각 표기를
+            # "그 시각에 컷하라"는 선언으로 읽는다. 슬롯 경계는 우리가 배분용으로만
+            # 쓰고, 모델에 넘어가는 문장에는 숫자가 한 개도 없어야 한다.
+            "0b) NEVER WRITE A TIME MARKER. Do not put any numeric time reference inside "
+            "\"action\", \"subject\", \"camera\" or \"atmosphere\" — no '0-2s', no '00:03', no "
+            "'at 5 seconds', no 'after two seconds', no 'by the 10-second mark'. In this renderer "
+            "a numeric time marker declares a CUT POINT, which is exactly what we are trying to "
+            "avoid. The beat boundaries you are given below are for pacing only: use them to "
+            "decide HOW MUCH motion goes in each beat, never quote them back.\n"
+            if no_cut else "")
+
+        continuity_rule = ""
+        if previous_action.strip():
+            continuity_rule = (
+                "2b) CONTINUES A PRIOR CLIP. The action in PREVIOUS CLIP ACTION below already "
+                "happened. The first beat must begin from the exact physical end-state that action "
+                "would leave the body in — same position, orientation, momentum — not from a reset "
+                "neutral stance, and it must not repeat that action. Do not narrate the hand-off "
+                "(no 'continuing', 'still', 'as before').\n")
+
+        # 공식 H3 포맷의 오디오 2필드(overall_soundscape/non_diegetic_music). H3는
+        # 비디오+오디오를 동시생성하는 모델이라 이 지시가 없으면 모델이 사운드를 알아서
+        # 지어낸다 - 의도한 사운드를 원하면 명시해야 한다.
+        if include_audio:
+            audio_rule = (
+                "14) AUDIO (official H3 fields). Also write two short audio-direction fields "
+                "matching the mood of \"atmosphere\" and the physical intensity of the beats:\n"
+                "   \"soundscape\": 1 to 4 sentences of DIEGETIC sound only — ambience, physical "
+                "action noise (footsteps, fabric, contact, mechanical/environmental sound), "
+                "non-verbal human sound (breathing, effort). Never mention dialogue or music here.\n"
+                "   \"music\": 1 to 3 sentences of NON-diegetic score — instruments, tempo, rhythm, "
+                "and how the dynamics change across the clip. If the scene genuinely calls for no "
+                "score, write exactly \"None.\" instead of inventing one.\n"
+                "15) DIALOGUE (per-beat \"dialogue_manner\" and \"dialogue_line\" fields). This "
+                "renderer invents meaningless gibberish speech on its own whenever a moment looks "
+                "like talking but no exact line was given — so silence must be deliberate, not "
+                "accidental. For EACH beat, decide independently whether that specific instant "
+                "plausibly calls for a short spoken or vocal line (a reaction, a name, a request, "
+                "a taunt, a moan, a gasp with words). Most beats will NOT need one — do not force "
+                "a line into every beat. When a beat does get one, fill BOTH fields: "
+                "\"dialogue_manner\" is a short prose phrase describing HOW it is delivered (e.g. "
+                "'moaning softly', 'breathlessly', 'sharply, as a startled curse', 'teasing') — "
+                "this is narration that is never spoken aloud, so plain English prose is fine. "
+                "\"dialogue_line\" is ONLY the exact spoken text: '[Language] <exact short line, "
+                "under 8 words>' — e.g. [Korean] 거기, 거기예요, [English] don't stop, [Korean] "
+                "아 시발, or [English] is that all you've got. Those four only show the FORMAT — "
+                "never reuse one verbatim or default to the single most obvious line for the "
+                "moment (reflex filler like 'yes/more/don't stop' for pleasure, a bare gasp of "
+                "the character's name for surprise). "
+                "15c) The TAKE VARIATION block below (if present) names a delivery register for "
+                "this take — let dialogue_manner and the actual wording/rhythm of dialogue_line "
+                "lean into that register instead of defaulting to the flattest obvious phrasing. "
+                "Write a line specific to what THIS beat's "
+                "action and delivery manner actually are — a taunt sounds different from a plea, a "
+                "startled reaction sounds different from a satisfied one. If PREVIOUS CLIP ACTION "
+                "(rule 2b) already contains a dialogue line, this clip's lines must be different "
+                "wording, not a repeat or a trivial rephrase of it. Pick whichever language "
+                "actually fits the character and setting (default to English unless the "
+                "name/scene clearly calls for another one), and write the line itself in that "
+                "language's OWN NATIVE SCRIPT — never a romanized/phonetic spelling of it (write "
+                "안녕하세요, not 'annyeonghaseyo'; write ありがとう, not 'arigatou'; write 谢谢, "
+                "not 'xiexie'). The \"[Language]\" tag stays in English; only the text after it "
+                "switches script. Do NOT put quote marks around the line and do NOT repeat any of "
+                "the delivery-manner words inside \"dialogue_line\" — this renderer speaks the "
+                "exact text of \"dialogue_line\" aloud verbatim, so anything written in that field "
+                "is heard exactly as written, while \"dialogue_manner\" is only ever narrated as "
+                "prose and is never itself spoken (this is why the two are separate fields — "
+                "putting a delivery description inside \"dialogue_line\" makes it get spoken too). "
+                "Never put a numeric timestamp in either field. Leave BOTH as empty strings for "
+                "every beat with no line; if none of the beats end up with a line, that is "
+                "normal and expected for most short clips — do not manufacture one just to fill "
+                "the fields.\n")
+            audio_schema = ',"soundscape":"<1-4 sentences, diegetic sound only>","music":"<1-3 sentences, or \\"None.\\">"'
+        else:
+            audio_rule, audio_schema = "", ""
+
+        sys = (
+            f"You are a shot director writing a prompt for the MiniMax (Hailuo) video model. "
+            f"The output is ONE {dur_s}-second clip, and you are choreographing it second by "
+            f"second so the model never idles, loops, or repeats a beat to fill time.\n"
+            "\n"
+            "ABSOLUTE RULES:\n"
+            + no_cut_rule + action_rule + arc_rule +
+            "2) PHYSICAL CONTINUITY. The beats are one unbroken performance, not separate poses. "
+            "Each beat starts from the exact body position, orientation and momentum the previous "
+            "beat ended in. Never restart from a neutral stance mid-clip.\n"
+            + continuity_rule +
+            "3) STARTING PHYSICS. Read the character's CURRENT pose and what they are supported by "
+            "or in contact with from the SCENE ANCHORS (seated on something, kneeling, gripping an "
+            "object, leaning on a wall). The first beat must start FROM that exact situation and "
+            "honour its constraints — do not have them standing if the anchors show them seated "
+            "without first getting up. Spend at most one short clause on this grounding, and make "
+            "that clause itself an active verb, never a static description of the pose.\n"
+            "4) ONE PRIMARY MOTION PER BEAT. Each beat gets exactly one clear physical movement "
+            "that genuinely fills its time window — not a list of three things crammed into two "
+            "seconds, and not a held pose. Write plain physical movement: what the body does. "
+            "Present tense, third person.\n"
+            "4c) TAKE VARIATION. A TAKE VARIATION block is given below with an execution-style "
+            "note for this specific take. Let it shape HOW the beats' motions physically play "
+            "out (pacing, weight, a secondary body detail) — it never changes WHAT the action "
+            "list or scene anchors call for, it only changes the texture of the performance.\n"
+            "5) REAL-TIME SPEED. Everything plays at natural speed. No slow motion, no freeze, no "
+            "holding a pose. But do not inflate the movement either: match the verb to what the "
+            "action actually is (walks, turns, leans, reaches, lifts) and save hard percussive "
+            "verbs (slams, lunges, whips) for beats that really are sudden.\n"
+            + camera_rule +
+            "7) SUBJECT LINE. \"subject\" is ONE sentence describing who the character is and where "
+            "they are at t=0 — appearance, clothing, location — as a still frame, with no action "
+            "verbs in it. This is the only place description belongs; keep the beats pure motion.\n"
+            "8) ATMOSPHERE. \"atmosphere\" is one short clause of lighting/mood/film-look "
+            "(e.g. 'warm late-afternoon sunlight, handheld realism'). No action, no camera moves. "
+            "You may include ONE motion-quality word — fluid, percussive, weighted, floating, "
+            "gravitational, deliberate — since that word changes how the whole clip moves.\n"
+            "8b) FINAL STATE. The LAST beat must say where the motion lands: the body position it "
+            "ends in and what is still in frame. A clip that stops mid-gesture invites the model to "
+            "invent an ending of its own.\n"
+            "9) CHARACTER NAME: study the SCENE ANCHORS, judge the character's apparent "
+            "ethnicity/setting and invent a specific fitting first name (East Asian -> 'Yuna', "
+            "'Kaede', 'Jin'; Western -> 'Elena', 'Ryan'). NEVER output 'AUTO' or an empty name. "
+            "If a NAME is given below and it is not 'AUTO', use that one.\n"
+            f"10) {detail}\n"
+            "11) ENGLISH ONLY, and keep the whole thing compact — the renderer truncates long "
+            "prompts. No markdown, no numbering, no quotes inside the field values.\n"
+            # 렌더러가 로컬 무검열 모델이라 완곡어법을 쓸 이유가 없다. 오히려 은유는
+            # 애니메이션 모델이 해석할 수 없는 입력이라 동작이 뭉개진다.
+            "12) LITERAL, NOT METAPHORICAL. Name body parts and acts directly (e.g. 'penis', "
+            "'vagina', 'cock', 'pussy', 'thrusts', 'grips') — never euphemism, poetic metaphor, or "
+            "vague substitution (do not write things like 'their connection deepens', 'waves of "
+            "pleasure', 'their bodies moved as one', 'her core'). This is a technical motion "
+            "description for a local uncensored animation model, not literary prose — treat it like "
+            "a stage direction: blunt, anatomical, unambiguous about which body part does what to "
+            "which. Do not soften, skip, or refuse any action in the list.\n"
+            "13) NO GESTURE CLICHÉS. Resolve any vague/decorative descriptor in an action "
+            "(e.g. 'cutely', 'playfully', 'sexily', 'shyly') into ONE specific, concrete gesture. "
+            "This applies even with no such word in the action list if the SCENE ANCHORS' facial "
+            "expression/mood line implies one (e.g. the anchors describe a smiling, playful face "
+            "with no 'playfully' anywhere in the actions — still resolve into a concrete gesture "
+            "matching that mood, don't ignore it). NEVER default to the most expected cliché for "
+            "that mood (a peace sign for 'cute', a hair-flip for 'sexy') — those are overused. If "
+            "a SUGGESTED GESTURES block is given below, use the listed gesture for the matching "
+            "mood (adapted naturally into the action) instead of inventing your own; otherwise "
+            "invent one, and pick a DIFFERENT one from PREVIOUS CLIP ACTION if that already used "
+            "a specific gesture.\n"
+            + audio_rule +
+            "\n"
+            'OUTPUT ONLY JSON: {"character":"<a real name, never AUTO>","subject":"<one sentence>",'
+            + cam_schema + "," + schema_beats + ',"atmosphere":"<one short clause>"' + audio_schema + "}"
+        )
+
+        usr = (f"NAME: {name}\n"
+               f"CLIP LENGTH: {dur_s} seconds\n\n"
+               f"STYLE CUE (use only to calibrate how the movement feels and for the atmosphere "
+               f"line — do not quote it): {vibe.strip() or '(none)'}\n\n"
+               f"SCENE ANCHORS (from the input image — use the pose to ground the first beat and "
+               f"the overall look for the subject line):\n"
+               f"{anchors or '(none — no image given; invent a plausible subject from the actions)'}\n\n"
+               + (f"PREVIOUS CLIP ACTION (per rule 2b):\n{previous_action.strip()}\n\n"
+                  if previous_action.strip() else "")
+               + _gesture_hints(actions, anchors, seed)
+               + _variation_hints(seed)
+               + f"{assign_label}\n{assign_body}\n\n"
+               f"BEAT SLOTS (fill every one, in order):\n{slot_block}\n")
+
+        messages = [{"role": "system", "content": sys}, {"role": "user", "content": usr}]
+        t = temp
+        last = "⚠️ plan failed (no attempts ran)"
+        for attempt in (1, 2):
+            try:
+                content = _call_openrouter(messages, llm_model, key, t, seed=seed, force_json=True,
+                                           usage_acc=getattr(self, "_usage_acc", None))
+                parsed = self._validate_plan(self._extract(content), bounds, duration)
+                if parsed:
+                    return parsed, f"✅ plan ok (attempt {attempt})"
+                last = f"⚠️ incomplete JSON (attempt {attempt}): {content[:150]!r}"
+                print(f"⚠️ [MinimaxDirector] plan attempt {attempt} incomplete JSON: {content[:300]}")
+            except urllib.error.HTTPError as e:
+                body = ""
+                try:
+                    body = e.read().decode("utf-8")[:200]
+                except Exception:
+                    pass
+                last = f"❌ plan HTTP {e.code} (attempt {attempt}): {body}"
+                print(f"❌ [MinimaxDirector] {last}")
+            except (urllib.error.URLError, TimeoutError, KeyError, ValueError) as e:
+                last = f"❌ plan error (attempt {attempt}): {type(e).__name__}: {e}"
+                print(f"❌ [MinimaxDirector] {last}")
+            t = min(temp, 0.4)
+        return None, last
+
+    def _extract(self, text):
+        # JSON 파싱은 검증된 기존 구현을 그대로 씀(코드펜스/트레일링 콤마 처리 포함).
+        return DolphinVisionDirector()._extract_json(text)
+
+    def _validate_plan(self, parsed, bounds, duration):
+        """LLM 응답에서 beats를 꺼내 구간·동작이 실제로 채워졌는지 확인하고 정규화."""
+        if not isinstance(parsed, dict):
+            return None
+        beats = parsed.get("beats")
+        if not isinstance(beats, list) or not beats:
+            return None
+        if bounds is not None and len(beats) != len(bounds):
+            # 슬롯 수가 안 맞으면 재시도. (개수가 맞아야 초 단위 지정이 의미가 있다.)
+            return None
+        clean = []
+        for i, b in enumerate(beats):
+            if not isinstance(b, dict):
+                return None
+            action = str(b.get("action", "")).strip()
+            if not action:
+                return None
+            if bounds is not None:
+                start, end = bounds[i]
+            else:
+                try:
+                    start, end = float(b.get("start")), float(b.get("end"))
+                except (TypeError, ValueError):
+                    return None
+                if end <= start or end > duration + 1e-6:
+                    return None
+            clean.append({"start": float(start), "end": float(end), "action": action,
+                          "camera": _norm_camera(b.get("camera")),
+                          "dialogue_manner": str(b.get("dialogue_manner", "") or "").strip(),
+                          "dialogue_line": str(b.get("dialogue_line", "") or "").strip()})
+        parsed["beats"] = clean
+        return parsed
+
+    # ------------------------------------------------------------------
+    #  LLM 없이(키 없음/실패) 쓰는 로컬 폴백
+    # ------------------------------------------------------------------
+    # 폴백 전용 위상 라벨. 한 동작이 여러 비트에 걸칠 때 똑같은 문장을 그대로 반복하는
+    # 대신 어느 단계인지라도 구분해준다. LLM 없이 할 수 있는 건 여기까지.
+    _PHASES = ["(wind-up)", "(committing)", "(mid-motion)", "(peak effort)", "(follow-through)"]
+
+    def _local_beats(self, actions, bounds, duration):
+        """API 키가 없거나 LLM 플래닝이 실패했을 때 쓰는 로컬 분배.
+
+        DolphinVisionDirector._split_actions_to_clips는 클립 4개 전제라 비트가 10개쯤
+        되면 남는 비트를 전부 "(move toward) <마지막동작>"으로 채워버린다 — 20초 클립에서
+        같은 줄이 6번 반복되는 꼴이라 여기서는 쓰지 않고 직접 나눈다."""
+        if bounds is None:
+            bounds = _beat_bounds(duration, float(duration) / _auto_beat_count(duration))
+        if not actions.strip():
+            actions = "몸을 움직이기 시작한다, 동작에 힘이 실린다, 자세를 마무리한다"
+        parts = split_action_parts(actions) or [actions.strip()]
+
+        n = len(bounds)
+        phrases = []
+        if len(parts) >= n:
+            # 동작이 비트보다 많으면 연속된 것끼리 묶어서 한 비트에 넣는다.
+            k, m = divmod(len(parts), n)
+            idx = 0
+            for i in range(n):
+                take = k + (1 if i < m else 0)
+                phrases.append(", ".join(parts[idx:idx + take]))
+                idx += take
+        else:
+            # 동작이 적으면 각 동작에 연속된 비트 구간을 통째로 배정하고,
+            # 그 안에서는 위상 라벨로 구분한다.
+            k, m = divmod(n, len(parts))
+            for i, phrase in enumerate(parts):
+                span = k + (1 if i < m else 0)
+                for j in range(span):
+                    if span == 1:
+                        phrases.append(phrase)
+                    else:
+                        pos = int(round(j * (len(self._PHASES) - 1) / (span - 1)))
+                        phrases.append(f"{self._PHASES[pos]} {phrase}")
+
+        # 로컬 폴백은 LLM이 없어서 맥락에 맞는 대사를 지어낼 수 없다 - 항상 빈 채로
+        # 두고, _assemble이 DIALOGUE_NEGATIVE로 무대사를 명시하게 맡긴다.
+        return [{"start": a, "end": b, "action": phrases[i], "camera": "",
+                  "dialogue_manner": "", "dialogue_line": ""}
+                for i, (a, b) in enumerate(bounds)]
+
+    # ------------------------------------------------------------------
+    #  최종 프롬프트 조립
+    # ------------------------------------------------------------------
+    def _resolve_camera(self, beats, camera_mode, camera_manual, camera_overall):
+        """카메라를 (구간별 대괄호) 또는 (클립 전체를 관통하는 문장 하나) 중 하나로 확정.
+
+        H3에서는 비트마다 카메라를 갈아끼우는 것 자체가 컷 신호라서, 기본값은
+        '전체 하나'다. 구간별 대괄호는 구형 Director 모델용으로만 남겨둔다."""
+        for b in beats:
+            b.setdefault("camera", "")
+        if camera_mode.startswith("Per-segment"):
+            manual = str(camera_manual or "")
+            if "|" in manual:
+                groups = [_norm_camera(g) for g in manual.split("|")]
+                for i, b in enumerate(beats):
+                    b["camera"] = groups[i] if i < len(groups) else ""
+            return beats, ""
+
+        for b in beats:
+            b["camera"] = ""
+        if camera_mode.startswith("off"):
+            return beats, ""
+        # 전체 카메라 문장에 대괄호가 남으면 그것도 샷 마커로 읽힌다.
+        if camera_mode.startswith("manual"):
+            return beats, _strip_brackets(camera_manual or "")
+        return beats, _strip_brackets(camera_overall or "")
+
+    def _assemble(self, subject, beats, atmosphere, camera_overall, style, name, no_cut,
+                  include_audio):
+        head = subject.strip().strip(",. ")
+        if name and head and name.lower() not in head.lower():
+            head = f"{name}, {head[0].lower() + head[1:]}"
+        elif name and not head:
+            head = name
+        blocks = []
+        if head:
+            blocks.append(head.rstrip(".") + ".")
+
+        # 어느 비트든 대사가 하나라도 있으면 DIALOGUE_NEGATIVE를 안 붙인다 - 명시된
+        # 대사와 "대사 없음" 선언이 동시에 들어가면 모순이라서.
+        any_dialogue = any(str(b.get("dialogue_line", "")).strip() for b in beats)
+
+        def _dialogue_sentence(b):
+            """비트의 dialogue_manner/dialogue_line에서 화자 절을 만든다.
+            manner(전달 방식 묘사)는 산문으로 서술하고, 실제 발화 내용만 공식 H3
+            <d>...</d> 태그로 감싼다 - 한 필드에 같이 넣었더니 톤 묘사 단어까지
+            H3가 그대로 발화하는 문제가 있어서 필드부터 분리했다(2026-08-25)."""
+            line = str(b.get("dialogue_line", "")).strip()
+            if not line:
+                return ""
+            manner = str(b.get("dialogue_manner", "")).strip()
+            if manner:
+                return f"{name}, {manner}, says <d>{line}</d>"
+            return f"{name} says <d>{line}</d>"
+
+        def _dlg_clause(b):
+            """비트에 대사가 있으면 이어붙일 절(선행 콤마 포함)을 반환. 없으면 빈 문자열."""
+            s = _dialogue_sentence(b)
+            return f", {s}" if s else ""
+
+        if style.startswith("Continuous prose"):
+            # 숫자 타임코드를 한 개도 쓰지 않고 지속시간을 말로만 표현한다.
+            # H3는 `0-2s` 같은 숫자 마커를 컷 지점 선언으로 읽기 때문 - 타이밍은
+            # 전달하면서 컷 신호는 안 주는 유일한 방법.
+            segs = []
+            for i, b in enumerate(beats):
+                d, approx = _dur_parts(b["end"] - b["start"])
+                fuzzy = "roughly " if approx else ""
+                body = _lower_first(_strip_brackets(b["action"]))
+                if i == 0:
+                    lead = f"For {fuzzy}the first {d}"
+                elif i == len(beats) - 1:
+                    lead = f"and through {fuzzy}the final {d}"
+                else:
+                    lead = f"then for {fuzzy}the next {d}"
+                segs.append(f"{lead} {body}{_dlg_clause(b)}")
+            blocks.append(", ".join(segs).rstrip(".") + ".")
+        elif style.startswith("Second timeblocking"):
+            # 정확한 초를 지켜야 할 때만. H3에선 이게 곧 멀티샷 블로킹이라 컷이 난다.
+            segs = [f"{_fmt_sec(b['start'])}-{_fmt_sec(b['end'])}s "
+                    f"{_lower_first(_strip_brackets(b['action']))}{_dlg_clause(b)}"
+                    for b in beats]
+            blocks.append(", ".join(segs).rstrip(".") + ".")
+        elif style.startswith("Sequential connectives"):
+            segs = []
+            for i, b in enumerate(beats):
+                body = _lower_first(_strip_brackets(b["action"]))
+                if i == 0:
+                    lead = "First,"
+                elif i == len(beats) - 1:
+                    lead = "finally"
+                else:
+                    lead = _SEQ_CONNECTIVES[(i - 1) % len(_SEQ_CONNECTIVES)]
+                segs.append(f"{lead} {body}{_dlg_clause(b)}")
+            blocks.append(", ".join(segs).rstrip(".") + ".")
+        elif style.startswith("Multi-shot"):
+            # 컷을 '일부러' 낼 때만. H3 공식 문법: [Shot 1]은 타임코드 없이,
+            # 이후 샷은 [Shot N] At mm:ss.mmm, ... 로 컷 시점을 못 박는다.
+            for i, b in enumerate(beats, 1):
+                body = b["action"].strip().rstrip(".")
+                if i == 1:
+                    line = f"[Shot 1] {body}."
+                else:
+                    # 마커 자체가 컷을 뜻하므로 "the camera cuts to"를 덧붙이지 않는다
+                    # (붙이면 "cuts to she strides"처럼 비문이 된다).
+                    line = f"[Shot {i}] At {_fmt_timecode(b['start'])}, {_lower_first(body)}."
+                if b["camera"]:
+                    line = f"{line} {b['camera']}"
+                s = _dialogue_sentence(b)
+                if s:
+                    line = f"{line} {s}"
+                blocks.append(line)
+        else:  # Director 대괄호
+            for b in beats:
+                s, e = _fmt_sec(b["start"]), _fmt_sec(b["end"])
+                line = f"[{s}-{e}s] {b['action'].strip().rstrip('.')}."
+                if b["camera"]:
+                    line = f"{line} {b['camera']}"
+                s2 = _dialogue_sentence(b)
+                if s2:
+                    line = f"{line} {s2}"
+                blocks.append(line)
+
+        # 한 문단으로 붙는 모드에서는 이것들이 문장 중간에 오므로 첫 글자를 올린다.
+        if camera_overall.strip():
+            blocks.append(_sentence(camera_overall))
+        if atmosphere.strip():
+            blocks.append(_sentence(atmosphere))
+        # 대사가 어디에도 안 들어갔으면 "무대사"를 명시한다 - 공식 HF 디스커션
+        # #76에서 확인된 대로, 명시 안 하면 H3가 의미불명의 음성을 지어낸다.
+        if include_audio and not any_dialogue:
+            blocks.append(DIALOGUE_NEGATIVE)
+        # 멀티샷은 컷이 목적이라 제약을 붙이면 자기모순이 된다.
+        if no_cut and not style.startswith("Multi-shot"):
+            blocks.append(NO_CUT_CONSTRAINT)
+
+        # 줄바꿈도 "여기서 끊긴다"는 구분자 신호로 읽힌다. 연속 테이크를 노리는
+        # 스타일은 전부 한 문단으로 붙이고, 샷을 나누는 스타일만 줄로 분리한다.
+        if style.startswith("Continuous prose") or style.startswith("Sequential connectives"):
+            return " ".join(blocks)
+        return "\n".join(blocks)
+
+    def _finalize_output(self, body, soundscape, music, image_present,
+                         include_audio, i2v_prefix):
+        """공식 H3 포맷으로 최종 감싸기. `body`(기존 _assemble 결과, 컷 회피 로직
+        검증 완료)는 절대 건드리지 않고 앞뒤로 라벨/프리픽스만 붙인다.
+
+        i2v_prefix는 include_audio와 무관하게 독립 토글 - 정렬 문장은 오디오
+        유무와 상관없이 이미지가 있으면 붙는 게 공식 스펙."""
+        parts = []
+        if i2v_prefix and image_present:
+            parts.append("For the target video, at 0.00 seconds into the target video, "
+                          "<Picture 1> (from [Shot 1]) is fully referenced.")
+        if include_audio:
+            parts.append(f"integrated_multimodal_description: {body}")
+            if soundscape.strip():
+                parts.append(f"overall_soundscape: {soundscape.strip()}")
+            if music.strip():
+                parts.append(f"non_diegetic_music: {music.strip()}")
+        else:
+            parts.append(body)
+        return "\n\n".join(parts)
+
+    # ------------------------------------------------------------------
+    def direct(self, essential_actions, duration_seconds, beat_seconds, prompt_style,
+               no_cut_constraint, camera_mode, camera_manual, character_name, artistic_vibe,
+               detail_level, use_vision, openrouter_api_key, vlm_preset, vlm_model, llm_preset,
+               llm_model, creativity, seed, include_audio_fields=True,
+               i2v_alignment_prefix=False, **kw):
+
+        engine = DolphinVisionDirector()
+        # 비전(engine._call_or)과 플래닝(_call_openrouter)이 같은 dict에 토큰/비용 누적.
+        self._usage_acc = {"prompt": 0, "completion": 0, "cost": 0.0}
+        engine._usage_acc = self._usage_acc
+        image = kw.get("image", None)
+        vision_caption = str(kw.get("vision_caption", "") or "").strip()
+        previous_action = str(kw.get("previous_action", "") or "").strip()
+
+        dur = float(duration_seconds)
+        bounds = _beat_bounds(dur, float(beat_seconds))
+        vlm = resolve_slug(VLM_PRESETS, vlm_preset, vlm_model, "qwen/qwen2.5-vl-72b-instruct")
+        llm = resolve_slug(LLM_PRESETS, llm_preset, llm_model, "deepseek/deepseek-v3.2")
+        user_name = "" if character_name.strip().upper() in ["AUTO", ""] else character_name.strip()
+        key = resolve_api_key(openrouter_api_key)
+
+        # ---- STEP 1: 비전 앵커 ----
+        anchors, dbg_v = "", ""
+        if vision_caption:
+            anchors, dbg_v = vision_caption, "vision ok (local caption node)"
+        elif not use_vision:
+            dbg_v = "vision OFF (check toggle)"
+        elif image is None:
+            dbg_v = "no image (T2V mode)"
+        elif not key:
+            dbg_v = "no api key"
+            print("❌ [MinimaxDirector] openrouter_api_key missing (neither widget nor OPENROUTER_API_KEY env var set) - vision/LLM unavailable")
+        else:
+            data_uri = tensor_to_base64(image)
+            if data_uri:
+                anchors, err = engine._vision_analyze(data_uri, vlm, key, min(creativity, 0.5))
+                dbg_v = err or "vision ok"
+            else:
+                dbg_v = "image encode failed / PIL missing"
+
+        # ---- STEP 2: 초 단위 비트 플래닝 ----
+        if camera_mode.startswith("Per-segment"):
+            camera_style = "perbeat"
+        elif camera_mode.startswith("off") or camera_mode.startswith("manual"):
+            camera_style = "none"
+        else:
+            camera_style = "continuous"
+        # 멀티샷 스타일은 컷을 내는 게 목적이라 연속 테이크 제약을 걸면 자기모순.
+        no_cut = bool(no_cut_constraint) and not prompt_style.startswith("Multi-shot")
+        subject, atmosphere, camera_overall = "", artistic_vibe.strip(), ""
+        if key:
+            parsed, dbg_p = self._plan_beats(
+                anchors, essential_actions, character_name, artistic_vibe,
+                engine._detail_hint(detail_level), dur, bounds, camera_style, no_cut,
+                llm, key, creativity, seed, previous_action=previous_action,
+                include_audio=bool(include_audio_fields))
+        else:
+            parsed, dbg_p = None, "no api key"
+
+        if parsed:
+            beats = parsed["beats"]
+            subject = str(parsed.get("subject", "")).strip()
+            atmosphere = str(parsed.get("atmosphere", "")).strip() or artistic_vibe.strip()
+            camera_overall = str(parsed.get("camera", "")).strip()
+            cand = str(parsed.get("character", "")).strip()
+            if not cand or cand.upper() == "AUTO":
+                cand = engine._fallback_name(anchors)
+            final_name = user_name or cand
+            soundscape = str(parsed.get("soundscape", "")).strip() if include_audio_fields else ""
+            music = str(parsed.get("music", "")).strip() if include_audio_fields else ""
+        else:
+            beats = self._local_beats(essential_actions, bounds, dur)
+            # 폴백에선 앵커를 그대로 피사체 문장으로 쓴다(한 줄로 눌러서).
+            subject = " ".join(anchors.split())[:200]
+            final_name = user_name or (engine._fallback_name(anchors) if anchors else "")
+            # 로컬 폴백은 LLM이 없어서 오디오 문장을 지어낼 수 없다 - 빈 채로 둔다
+            # (_finalize_output이 빈 문자열이면 해당 라벨 섹션 자체를 생략함).
+            soundscape, music = "", ""
+
+        # ---- STEP 3: 카메라 확정 + 조립 ----
+        beats, camera_overall = self._resolve_camera(beats, camera_mode, camera_manual,
+                                                     camera_overall)
+        body = self._assemble(subject, beats, atmosphere, camera_overall, prompt_style,
+                              final_name, no_cut, bool(include_audio_fields))
+
+        # 연속 테이크를 노리는데 숫자 시각 표기가 새어나갔으면 잡아준다(LLM 규칙 0b 위반).
+        # 초 타임블로킹/Director는 숫자를 내는 게 정상이라 검사 대상이 아니다. 오디오
+        # 필드(soundscape/music)는 별도 텍스트라 이 검사 대상이 아니다.
+        if no_cut and not prompt_style.startswith(("Second timeblocking", "Director brackets")):
+            leaked = re.findall(r"\d+\s*(?:-\s*\d+\s*)?(?:s\b|sec|seconds?\b)|\d{2}:\d{2}", body)
+            if leaked:
+                print(f"⚠️ [MinimaxDirector] Numeric time markers leaked into the prompt {leaked[:5]} - "
+                      f"H3 reads these as cut points. This means the LLM violated rule 0b; "
+                      f"re-run, or use the 'Sequential connectives' style.")
+
+        i2v_prefix_applied = bool(i2v_alignment_prefix) and image is not None
+        prompt = self._finalize_output(body, soundscape, music, image is not None,
+                                       bool(include_audio_fields), bool(i2v_alignment_prefix))
+
+        # 하드 상한은 실제로 필드가 잘리는 기준이라 오디오 라벨까지 합친 최종
+        # prompt(전체 전송분) 기준. 소프트 상한("길면 지시를 평균낸다")은 원래
+        # 타임라인/동작 지시가 있는 body 분량에 대한 경험칙이라, 오디오 라벨/
+        # soundscape/music/I2V 프리픽스처럼 body 뒤에 붙는 별개 콘텐츠까지 합쳐서
+        # 재면 오디오 필드를 켜기만 해도 항상 걸려서 무의미한 경고��� 된다.
+        if len(prompt) > MINIMAX_FIELD_LIMIT:
+            print(f"❌ [MinimaxDirector] Prompt exceeds the field limit ({MINIMAX_FIELD_LIMIT} chars) "
+                  f"by {len(prompt) - MINIMAX_FIELD_LIMIT} chars - the tail will be truncated.")
+        elif len(body) > MINIMAX_SOFT_LIMIT:
+            print(f"⚠️ [MinimaxDirector] The video description (body) is {len(body)} chars "
+                  f"(recommended under {MINIMAX_SOFT_LIMIT}, full prompt is {len(prompt)} chars). "
+                  f"If it's too long the model averages out the instructions and follows the "
+                  f"timeline less closely - lower detail_level or reduce the beat count. "
+                  f"(soundscape/music/I2V prefix are not counted against this limit.)")
+        if prompt_style.startswith("Director brackets"):
+            print("⚠️ [MinimaxDirector] 'Director brackets' is for legacy T2V-01-Director-family "
+                  "models only. Using it with H3 makes [0-2s] read as a shot marker, causing a "
+                  "cut at every timecode.")
+        elif prompt_style.startswith("Second timeblocking") and no_cut:
+            print("⚠️ [MinimaxDirector] 'Second timeblocking' is effectively H3's multi-shot "
+                  "blocking syntax - numeric timecodes are read as cut-point declarations, which "
+                  "conflicts with the no_cut constraint. To avoid cuts, use 'Continuous prose' "
+                  "or 'Sequential connectives'.")
+        if include_audio_fields and key and not (soundscape or music):
+            print("⚠️ [MinimaxDirector] include_audio_fields is ON but the LLM didn't fill "
+                  "soundscape/music - they will be omitted from the output.")
+
+        timeline_json = json.dumps(
+            {"duration": dur, "character": final_name, "subject": subject,
+             "camera": camera_overall, "atmosphere": atmosphere, "beats": beats,
+             "soundscape": soundscape, "non_diegetic_music": music,
+             "i2v_alignment_prefix_applied": i2v_prefix_applied},
+            ensure_ascii=False, indent=2)
+        # llm/vlm 슬러그를 debug_info에 노출한다 - preset 드롭다운을 바꿔도 실제로
+        # 어떤 모델이 호출됐는지 확인할 화면 요소가 없어서, JS 프리셋 동기화가
+        # 깨졌을 때("모델이 안 바뀐다" 리포트, 2026-08-28) 눈으로 검증할 방법이
+        # 아예 없었다. resolve_slug()가 실제로 고른 값을 그대로 찍어서 다음엔
+        # 여기만 봐도 바로 확인되게 한다.
+        debug = (f"llm={llm} | vlm={vlm} | vision={dbg_v} | plan={dbg_p} | char={final_name} | "
+                 f"{_fmt_sec(dur)}s / {len(beats)} beats | "
+                 f"{'no-cut' if no_cut else 'cuts allowed'} | "
+                 f"audio={'on' if include_audio_fields else 'off'} | "
+                 f"i2v_prefix={'on' if i2v_prefix_applied else 'off'} | {len(prompt)} chars")
+        _pt = _price_tag(llm, self._usage_acc, key)
+        if _pt:
+            debug += f" | {_pt}"
+
+        print(f"\n🎬🅜 [Dolphin Minimax Director] {debug}")
+        for b in beats:
+            dl = b.get("dialogue_line", "")
+            dm = b.get("dialogue_manner", "")
+            dlg = f" 💬{dm + ' ' if dm else ''}{dl}" if dl else ""
+            print(f"  {_fmt_sec(b['start'])}-{_fmt_sec(b['end'])}s {b['action'][:80]} {b['camera']}{dlg}")
+        if camera_overall:
+            print(f"  📷 {camera_overall}")
+        if soundscape:
+            print(f"  🔊 {soundscape}")
+        if music:
+            print(f"  🎵 {music}")
+
+        return (prompt, timeline_json, debug, final_name, soundscape, music)
+
+
+NODE_CLASS_MAPPINGS = {
+    "DolphinMinimaxDirector": DolphinMinimaxDirector,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DolphinMinimaxDirector": "🎬🅜 Dolphin Minimax Director (second-by-second timeline → Hailuo prompt)",
+}

dolphin_prompt_director.py

@@ -0,0 +1,331 @@
+# -*- coding: utf-8 -*-
+"""
+DolphinVisionDirector와 완전히 동일한 비전+LLM 프롬프트 엔진을 쓰되,
+MODEL 입력/LoRA 적용/트리거워드 주입을 전부 뺀 "프롬프트 분배 전용" 버전.
+
+로라/모델 로딩은 별도 노드(Architect V16 등)에 맡기고, 이 노드는
+이미지+필수동작 -> N개 클립 프롬프트 문자열만 뽑는 역할에 집중한다.
+
+엔진 로직(비전 분석/샷 플래닝/로컬 폴백/프롬프트 조립)은 DolphinVisionDirector의
+메서드를 그대로 재사용한다(중복 구현하면 프롬프트 정책이 두 파일에서 따로
+놀게 되므로, 여기서는 새로 만들지 않고 위임한다). 그 메서드들은 로라/모델
+상태를 전혀 건드리지 않는 순수 로직이라 안전하게 재사용 가능.
+"""
+from .dolphin_vision_director import (
+    DolphinVisionDirector,
+    resolve_slug,
+    resolve_api_key,
+    _price_tag,
+    tensor_to_base64,
+    VLM_PRESETS,
+    VLM_PRESET_LABELS,
+    LLM_PRESETS,
+    LLM_PRESET_LABELS,
+)
+
+
+class DolphinPromptDirector:
+    """
+    이미지 하나와 '필수 동작'만 넣으면 N개 연속 클립의 프롬프트 문자열이
+    완성되는 노드. DolphinVisionDirector에서 MODEL/LoRA 관련 부분을 전부
+    뺀 버전 — 모델/로라는 별도 노드(Architect V16 등)에서 처리한다는 전제.
+
+      1) IMAGE -> 비전 VLM(또는 vision_caption 입력)이 앵커(자세/지지물/환경) 파악
+      2) 그 맥락 위에서 essential_actions를 N샷으로 분배 (LLM, 실패 시 로컬 폴백)
+      3) 클립별 최종 프롬프트 문자열 조립 (로라 트리거 없음)
+    """
+
+    @classmethod
+    def INPUT_TYPES(s):
+        req = {
+            "image": ("IMAGE",),
+            "essential_actions": ("STRING", {"multiline": True,
+                "default": ("charges forward, swings a sword to strike down the enemy, deflects "
+                            "a bullet, finishes them off")}),
+            "num_clips": (["4 (20s)", "3 (15s)", "2 (10s)"], {"default": "4 (20s)",
+                "tooltip": "Number of clips actually used. Remaining clip slots repeat the last "
+                           "clip's content."}),
+            "character_name": ("STRING", {"default": "AUTO"}),
+            "artistic_vibe": ("STRING", {"multiline": True,
+                                         "default": "cinematic lighting, dynamic motion"}),
+            "pacing": (["auto", "slow-burn (1 beat)", "balanced (multi beat)", "rapid (4 distinct)"],
+                       {"default": "auto"}),
+            "detail_level": (["Short (concise)", "Essentials + anchors only", "Detailed"],
+                             {"default": "Essentials + anchors only"}),
+            "use_vision": ("BOOLEAN", {"default": True,
+                                       "label_on": "VISION ON", "label_off": "VISION OFF (text only)"}),
+            "openrouter_api_key": ("STRING", {"default": ""}),
+            "vlm_preset": (VLM_PRESET_LABELS, {"default": "👁 Qwen2.5-VL 72B (special cases · recommended)"}),
+            "vlm_model": ("STRING", {"default": "qwen/qwen2.5-vl-72b-instruct"}),
+            "llm_preset": (LLM_PRESET_LABELS, {"default": "🔞 DeepSeek V3.2 (uncensored · stable JSON · recommended)"}),
+            "llm_model": ("STRING", {"default": "deepseek/deepseek-v3.2"}),
+            "creativity": ("FLOAT", {"default": 0.7, "min": 0.1, "max": 1.5, "step": 0.05}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+        }
+        opt = {
+            # 로컬 캡션 노드(JoyCaption 등)의 STRING 출력을 연결하면 그걸 앵커로 쓰고
+            # OpenRouter VLM 호출은 건너뜀. 비워두면 OpenRouter VLM 경로로 폴백.
+            "vision_caption": ("STRING", {"multiline": True, "default": "", "forceInput": True}),
+        }
+        return {"required": req, "optional": opt}
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING")
+    RETURN_NAMES = ("c1_prompt", "c2_prompt", "c3_prompt", "c4_prompt")
+    FUNCTION = "direct"
+    CATEGORY = "Dolphin"
+
+    def direct(self, image, essential_actions, num_clips, character_name, artistic_vibe,
+               pacing, detail_level, use_vision, openrouter_api_key, vlm_preset, vlm_model,
+               llm_preset, llm_model, creativity, seed, **kw):
+
+        # 비전/플래닝 엔진은 DolphinVisionDirector 것을 그대로 위임한다 (로직 중복 방지).
+        # 이 인스턴스로는 _vision_analyze/_plan_shots/_local_split/_build_final 같은
+        # 순수 메서드만 호출하고, MODEL/LoRA를 만지는 _patch_clip 등은 아예 안 씀.
+        engine = DolphinVisionDirector()
+        engine._usage_acc = {"prompt": 0, "completion": 0, "cost": 0.0}
+
+        n_clips = int(str(num_clips).split()[0])
+        vlm = resolve_slug(VLM_PRESETS, vlm_preset, vlm_model, "qwen/qwen2.5-vl-72b-instruct")
+        llm = resolve_slug(LLM_PRESETS, llm_preset, llm_model, "deepseek/deepseek-v3.2")
+        user_name = "" if character_name.strip().upper() in ["AUTO", ""] else character_name.strip()
+        key = resolve_api_key(openrouter_api_key)
+
+        # ---- STEP 1: 비전 ----
+        vision_caption = str(kw.get("vision_caption", "") or "").strip()
+        anchors, dbg_v = "", ""
+        if vision_caption:
+            anchors = vision_caption
+            dbg_v = "vision ok (local caption node)"
+            print(f"👁 [PromptDirector] Using local caption input (JoyCaption etc.):\n{anchors[:300]}")
+        elif not use_vision:
+            dbg_v = "vision OFF (check toggle)"
+            print("ℹ️ [PromptDirector] use_vision=OFF - skipping vision")
+        elif not key:
+            dbg_v = "no api key"
+            print("❌ [PromptDirector] openrouter_api_key missing (neither widget nor OPENROUTER_API_KEY env var set) - vision/LLM unavailable")
+        elif image is None:
+            dbg_v = "no image"
+            print("❌ [PromptDirector] image input missing - check the IMAGE connection")
+        else:
+            data_uri = tensor_to_base64(image)
+            if data_uri:
+                anchors, err = engine._vision_analyze(data_uri, vlm, key, min(creativity, 0.5))
+                dbg_v = err or "vision ok"
+            else:
+                dbg_v = "image encode failed / PIL missing"
+        if not vision_caption and use_vision and key and image is not None and not anchors:
+            print(f"⚠️ [PromptDirector] Vision anchors are empty -> no basis for name/scene. Cause: {dbg_v}")
+
+        # ---- STEP 2: N샷 분배 ----
+        if key:
+            parsed, dbg_p = engine._plan_shots(anchors, essential_actions, character_name,
+                                               artistic_vibe, pacing, engine._detail_hint(detail_level),
+                                               llm, key, creativity, seed, num_clips=n_clips)
+            if parsed:
+                clips = [str(parsed[f"clip_{i}"]).strip() for i in range(1, n_clips + 1)]
+                master = str(parsed.get("master_scene", "")).strip()
+                cand = str(parsed.get("character", "")).strip()
+                if not cand or cand.upper() == "AUTO":
+                    cand = engine._fallback_name(anchors)
+                final_name = user_name or cand
+            else:
+                clips = engine._local_split(essential_actions, num_clips=n_clips)
+                master = anchors.replace("\n", " ")[:160]
+                final_name = user_name or engine._fallback_name(anchors)
+        else:
+            parsed, dbg_p = None, "no api key"
+            clips = engine._local_split(essential_actions, num_clips=n_clips)
+            master = anchors.replace("\n", " ")[:160]
+            final_name = user_name
+
+        if len(clips) < 4:
+            clips = clips + [clips[-1]] * (4 - len(clips))
+
+        # ---- STEP 3: 프롬프트 조립 (로라/트리거 없음) ----
+        outs = []
+        for c in range(1, 5):
+            if c > n_clips:
+                prompt = engine._build_final(clips[c - 1], master, final_name, "")
+                outs.append(prompt)
+                print(f"  [clip{c}] SKIPPED (num_clips={n_clips}) - text only, ignored downstream")
+                continue
+            prompt = engine._build_final(clips[c - 1], master, final_name, "")
+            outs.append(prompt)
+
+        debug = f"vlm={dbg_v} | plan={dbg_p} | char={final_name} | clips={n_clips} ({n_clips*5}s)"
+        _pt = _price_tag(llm, getattr(engine, "_usage_acc", None), key)
+        if _pt:
+            debug += f" | {_pt}"
+        print(f"\n🎬 [Dolphin Prompt Director] {debug}\nANCHORS: {anchors[:120]}")
+        for i, p in enumerate(outs, 1):
+            print(f"  CLIP {i}: {p[:90]}")
+
+        return tuple(outs)
+
+
+class DolphinActionSplitter:
+    """
+    essential_actions 텍스트 하나를 클립별 액션 조각으로 나누기만 하는 노드.
+    LLM/비전 호출이 전혀 없는 순수 로컬 로직(정규식 기반)이라 비용이 0에 가깝고,
+    시드나 렌더링 개수와 무관하게 항상 같은 입력에 같은 출력을 낸다.
+
+    DolphinVisionDirector처럼 "몇 클립 낼지"와 "플래닝"이 한 노드에 묶여있으면,
+    렌더링 개수만 바꿔도(예: 2클립->4클립 연장) 전체 재플래닝이 발생해서 이미 만든
+    클립까지 캐시가 깨진다. 이 노드는 그 분배 단계만 따로 떼어내서 - total_clips를
+    항상 고정해두면(보통 4) 이 노드의 출력은 절대 안 바뀌고, 그 뒤에 물리는 클립별
+    DolphinPromptDirectorSingle들도 자기 몫 액션 조각이 그대로면 캐시가 유지된다.
+    """
+
+    @classmethod
+    def INPUT_TYPES(s):
+        req = {
+            "essential_actions": ("STRING", {"multiline": True,
+                "default": ("charges forward, swings a sword to strike down the enemy, deflects "
+                            "a bullet, finishes them off")}),
+            "total_clips": (["4", "3", "2"], {"default": "4",
+                "tooltip": "How many beats to split into. If you later increase the render count "
+                           "without changing this value, the action chunks of clips you've "
+                           "already made stay the same."}),
+        }
+        return {"required": req}
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING")
+    RETURN_NAMES = ("c1_action", "c2_action", "c3_action", "c4_action")
+    FUNCTION = "split"
+    CATEGORY = "Dolphin"
+
+    def split(self, essential_actions, total_clips):
+        engine = DolphinVisionDirector()
+        n = int(total_clips)
+        assign = engine._split_actions_to_clips(essential_actions, n)
+        outs = [", ".join(assign[c]) for c in range(1, n + 1)]
+        if len(outs) < 4:
+            outs = outs + [""] * (4 - len(outs))
+        print(f"✂️ [ActionSplitter] {n} clips: " + " | ".join(f"c{i+1}={o[:40]}" for i, o in enumerate(outs) if o))
+        return tuple(outs)
+
+
+class DolphinPromptDirectorSingle:
+    """
+    DolphinPromptDirector의 단일 프롬프트 버전. num_clips 개념 없이
+    이미지 하나 + '동작' 하나로 프롬프트 문자열 1개만 뽑는다.
+
+    5초 단발 테스트(로라 테스트 워크플로우 등)처럼 클립 분할/연속성 로직이
+    전혀 필요 없는 경우를 위한 것 - 엔진 내부적으로 num_clips=1로 호출하면
+    _plan_shots/_local_split가 이미 단일 클립 케이스를 지원하므로 그대로 위임.
+    """
+
+    @classmethod
+    def INPUT_TYPES(s):
+        req = {
+            "image": ("IMAGE",),
+            "action": ("STRING", {"multiline": True,
+                "default": "charges forward, swings a sword to strike down the enemy"}),
+            "character_name": ("STRING", {"default": "AUTO"}),
+            "artistic_vibe": ("STRING", {"multiline": True,
+                                         "default": "cinematic lighting, dynamic motion"}),
+            "detail_level": (["Short (concise)", "Essentials + anchors only", "Detailed"],
+                             {"default": "Essentials + anchors only"}),
+            "use_vision": ("BOOLEAN", {"default": True,
+                                       "label_on": "VISION ON", "label_off": "VISION OFF (text only)"}),
+            "openrouter_api_key": ("STRING", {"default": ""}),
+            "vlm_preset": (VLM_PRESET_LABELS, {"default": "👁 Qwen2.5-VL 72B (special cases · recommended)"}),
+            "vlm_model": ("STRING", {"default": "qwen/qwen2.5-vl-72b-instruct"}),
+            "llm_preset": (LLM_PRESET_LABELS, {"default": "🔞 DeepSeek V3.2 (uncensored · stable JSON · recommended)"}),
+            "llm_model": ("STRING", {"default": "deepseek/deepseek-v3.2"}),
+            "creativity": ("FLOAT", {"default": 0.7, "min": 0.1, "max": 1.5, "step": 0.05}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "forceInput": True}),
+        }
+        opt = {
+            "vision_caption": ("STRING", {"multiline": True, "default": "", "forceInput": True}),
+            # 이전 클립이 만든 prompt(또는 그 액션 부분)를 연결하면, 이번 클립이 그
+            # 동작이 끝난 지점부터 자연스럽게 이어지도록 LLM에 문맥으로 넘긴다.
+            # 비워두면(체인의 첫 클립) 그냥 단독 클립처럼 취급.
+            "previous_action": ("STRING", {"multiline": True, "default": "", "forceInput": True}),
+            # DolphinTripleLoraMatrix 등 로라 패처의 trigger_words 출력을 연결하면
+            # 최종 프롬프트 상단(이름 옆)에 붙는다. DolphinVisionDirector의
+            # inject_triggers 기능과 동일한 자리.
+            "trigger_words": ("STRING", {"default": "", "forceInput": True}),
+        }
+        return {"required": req, "optional": opt}
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING")
+    RETURN_NAMES = ("prompt", "debug_info", "resolved_character_name")
+    FUNCTION = "direct"
+    CATEGORY = "Dolphin"
+
+    def direct(self, image, action, character_name, artistic_vibe, detail_level, use_vision,
+               openrouter_api_key, vlm_preset, vlm_model, llm_preset, llm_model, creativity, seed, **kw):
+
+        engine = DolphinVisionDirector()
+        engine._usage_acc = {"prompt": 0, "completion": 0, "cost": 0.0}
+        previous_action = str(kw.get("previous_action", "") or "").strip()
+        trigger_words = str(kw.get("trigger_words", "") or "").strip()
+        vlm = resolve_slug(VLM_PRESETS, vlm_preset, vlm_model, "qwen/qwen2.5-vl-72b-instruct")
+        llm = resolve_slug(LLM_PRESETS, llm_preset, llm_model, "deepseek/deepseek-v3.2")
+        user_name = "" if character_name.strip().upper() in ["AUTO", ""] else character_name.strip()
+        key = resolve_api_key(openrouter_api_key)
+
+        # ---- STEP 1: 비전 ----
+        vision_caption = str(kw.get("vision_caption", "") or "").strip()
+        anchors, dbg_v = "", ""
+        if vision_caption:
+            anchors = vision_caption
+            dbg_v = "vision ok (local caption node)"
+        elif not use_vision:
+            dbg_v = "vision OFF (check toggle)"
+        elif not key:
+            dbg_v = "no api key"
+        elif image is None:
+            dbg_v = "no image"
+        else:
+            data_uri = tensor_to_base64(image)
+            if data_uri:
+                anchors, err = engine._vision_analyze(data_uri, vlm, key, min(creativity, 0.5))
+                dbg_v = err or "vision ok"
+            else:
+                dbg_v = "image encode failed / PIL missing"
+
+        # ---- STEP 2: 단일 샷 플래닝 ----
+        if key:
+            parsed, dbg_p = engine._plan_shots(anchors, action, character_name, artistic_vibe,
+                                               "auto", engine._detail_hint(detail_level),
+                                               llm, key, creativity, seed, num_clips=1,
+                                               continuity_context=previous_action)
+            if parsed:
+                clip = str(parsed["clip_1"]).strip()
+                master = str(parsed.get("master_scene", "")).strip()
+                cand = str(parsed.get("character", "")).strip()
+                if not cand or cand.upper() == "AUTO":
+                    cand = engine._fallback_name(anchors)
+                final_name = user_name or cand
+            else:
+                clip = engine._local_split(action, num_clips=1)[0]
+                master = ""
+                final_name = user_name or engine._fallback_name(anchors)
+        else:
+            parsed, dbg_p = None, "no api key"
+            clip = engine._local_split(action, num_clips=1)[0]
+            master = ""
+            final_name = user_name
+
+        prompt = engine._build_final(clip, master, final_name, trigger_words)
+        debug = f"vlm={dbg_v} | plan={dbg_p} | char={final_name}"
+        _pt = _price_tag(llm, getattr(engine, "_usage_acc", None), key)
+        if _pt:
+            debug += f" | {_pt}"
+        print(f"\n🎬 [Dolphin Prompt Director Single] {debug}\nPROMPT: {prompt[:200]}")
+
+        return (prompt, debug, final_name)
+
+
+NODE_CLASS_MAPPINGS = {
+    "DolphinPromptDirector": DolphinPromptDirector,
+    "DolphinPromptDirectorSingle": DolphinPromptDirectorSingle,
+    "DolphinActionSplitter": DolphinActionSplitter,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DolphinPromptDirector": "🎬📝 Dolphin Prompt Director (Image→N Prompts, no model/LoRA)",
+    "DolphinPromptDirectorSingle": "🎬📝 Dolphin Prompt Director (Single, Image→1 Prompt)",
+    "DolphinActionSplitter": "✂️ Dolphin Action Splitter (deterministic, no LLM)",
+}

dolphin_seed_controller.py

@@ -0,0 +1,70 @@
+class DolphinBatchSeedController:
+    """
+    클립 4개짜리 파이프라인(First + Extend×3)의 영상 샘플러 시드를 한 곳에서
+    스위칭하기 위한 노드. 기존에는 클립마다 서로 다른 서브그래프 안에 묻힌
+    SeedGenerator 위젯을 4번 따로 조작해야 "매 배치 랜덤"과 "특정 클립부터
+    재생성"을 오갈 수 있었다.
+
+    "seed"라는 이름의 INT 위젯에는 ComfyUI 프론트엔드가 자동으로
+    control_after_generate(fixed/increment/decrement/randomize) 드롭다운을
+    붙여준다 - 그래서 "전체 랜덤"/"특정 클립부터 재생성"에 필요한 새 시드는
+    이 위젯 하나의 randomize/increment만으로 나오고, 노드 자체는 매 실행
+    무작위를 호출할 필요 없는 순수 함수로 남는다.
+
+    주의: "특정 클립부터 재생성"이지 "그 클립만 재생성"이 아니다. Extend
+    서브그래프는 이전 클립의 실제 디코딩된 프레임을 입력으로 받는 continuity
+    구조라, N번 클립 시드를 바꾸면 N+1, N+2... 클립은 자기 시드값이 그대로여도
+    입력 latent가 달라져서 캐시가 깨지고 무조건 다시 렌더링된다. N보다 앞
+    클립들만 그대로 캐시된다.
+    """
+
+    MODE_FIXED = "🔒 고정 (재현)"
+    MODE_RANDOM_ALL = "🎲 전체 랜덤 (매 배치)"
+    MODE_REGEN_FROM = "♻️ 특정 클립부터 재생성 (그 뒤 클립도 연쇄 재생성됨)"
+
+    GOLDEN = 0x9E3779B97F4A7C15
+    MASK = 0xFFFFFFFFFFFFFFFF
+
+    @classmethod
+    def INPUT_TYPES(s):
+        req = {
+            "mode": ([s.MODE_FIXED, s.MODE_RANDOM_ALL, s.MODE_REGEN_FROM], {"default": s.MODE_FIXED}),
+            "regen_clip": (["1", "2", "3", "4"], {"default": "1",
+                "tooltip": "'특정 클립부터 재생성' 모드에서 몇 번 클립부터 새 시드를 줄지. "
+                           "그 클립 이후 클립들도 continuity 때문에 같이 다시 렌더링된다 "
+                           "(이전 클립들만 캐시 유지)."}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": s.MASK}),
+            "c1_seed": ("INT", {"default": 196010661098274, "min": 0, "max": s.MASK}),
+            "c2_seed": ("INT", {"default": 316514109857979, "min": 0, "max": s.MASK}),
+            "c3_seed": ("INT", {"default": 732840722629067, "min": 0, "max": s.MASK}),
+            "c4_seed": ("INT", {"default": 599880917933127, "min": 0, "max": s.MASK}),
+        }
+        return {"required": req}
+
+    RETURN_TYPES = ("INT", "INT", "INT", "INT", "STRING")
+    RETURN_NAMES = ("c1_seed", "c2_seed", "c3_seed", "c4_seed", "debug_info")
+    FUNCTION = "get_seeds"
+    CATEGORY = "Dolphin"
+
+    def get_seeds(self, mode, regen_clip, seed, c1_seed, c2_seed, c3_seed, c4_seed):
+        base = [c1_seed, c2_seed, c3_seed, c4_seed]
+
+        if mode == self.MODE_RANDOM_ALL:
+            out = [(seed + i * self.GOLDEN) & self.MASK for i in range(4)]
+        elif mode == self.MODE_REGEN_FROM:
+            out = list(base)
+            out[int(regen_clip) - 1] = seed
+        else:
+            out = list(base)
+
+        debug = f"mode={mode} | c1={out[0]} c2={out[1]} c3={out[2]} c4={out[3]}"
+        print(f"🎲 [BatchSeedController] {debug}")
+        return (*out, debug)
+
+
+NODE_CLASS_MAPPINGS = {
+    "DolphinBatchSeedController": DolphinBatchSeedController,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DolphinBatchSeedController": "🎲 Dolphin Batch Seed Controller (random-all / regen-from-clip)",
+}

dolphin_vision_director.py

@@ -0,0 +1,1028 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+import io
+import json
+import base64
+import hashlib
+import sqlite3
+import urllib.request
+import urllib.error
+
+import numpy as np
+import folder_paths
+import comfy.sd
+import comfy.lora
+import comfy.utils
+from safetensors import safe_open
+from comfy_execution.graph_utils import ExecutionBlocker
+
+try:
+    from PIL import Image
+    _HAS_PIL = True
+except Exception:
+    _HAS_PIL = False
+
+CACHE_FILE = os.path.join(os.path.dirname(__file__), "dolphin_tags_cache.json")
+
+
+# ======================================================================
+#  모델 프리셋 (텍스트 LLM = 4샷 분배 / 비전 VLM = 이미지 인식)
+# ======================================================================
+LLM_PRESETS = {
+    "🔞 DeepSeek V3.2 (uncensored · stable JSON · recommended)": "deepseek/deepseek-v3.2",
+    "🔞 Magnum v4 72B (natural phrasing)": "anthracite-org/magnum-v4-72b",
+    "🔞 Cydonia 24B v4.1 (lightweight · fast)": "thedrummer/cydonia-24b-v4.1",
+    # 2026-09-03: :free 슬러그가 404 됨("unavailable for free, use paid slug"). 유료로 교체.
+    "🔞 Dolphin Mistral Venice (uncensored)": "cognitivecomputations/dolphin-mistral-24b-venice-edition",
+    # 2026-09-03 추가. OpenRouter 모델 페이지로 슬러그/서빙 여부만 확인했고
+    # 실제 chat completions 호출로는 아직 스모크테스트 안 함 - 처음 쓸 때 확인할 것.
+    "🔞 Hermes 4 405B (steerable · strict format)": "nousresearch/hermes-4-405b",
+    # 2026-09-03: grok-4 / grok-4-fast 둘 다 deprecated(404) - grok-4.3으로 교체.
+    "🔞 Grok 4.3 (edgy prose · $1.25/$2.5)": "x-ai/grok-4.3",
+    "🔞 Euryale 70B L3.3 (sensory prose · loose format)": "sao10k/l3.3-euryale-70b",
+    "⚙️ custom (use text field below)": "__custom__",
+}
+# 2026-08-28: Valkyrie 49B V1(thedrummer/valkyrie-49b-v1)을 여기 넣었다가 뺐다 -
+# OpenRouter 마케팅 페이지는 정상으로 보였지만 실제 chat completions 호출은
+# 404 "No endpoints found"(프로바이더가 하나도 없음). 페이지가 살아있다고 실제
+# 서빙 중이란 보장이 없다 - 프리셋에 새 모델을 넣기 전엔 반드시 실제 API 호출로
+# 확인할 것(스크레이핑만으로는 부족했음, 실측: debug_info의 plan= 필드에 뜬
+# HTTP 404가 증거).
+LLM_PRESET_LABELS = list(LLM_PRESETS.keys())
+
+# 비전 모델: 특수 상황 이해 + 다국어. Qwen2.5-VL 계열이 포즈/맥락 파악에 강함.
+VLM_PRESETS = {
+    "👁 Qwen2.5-VL 72B (special cases · recommended)": "qwen/qwen2.5-vl-72b-instruct",
+    "👁 Qwen2.5-VL 32B (balanced)": "qwen/qwen2.5-vl-32b-instruct",
+    "👁 Qwen2.5-VL 32B (free)": "qwen/qwen2.5-vl-32b-instruct:free",
+    "👁 Mistral Small 3.1 24B (Pixtral)": "mistralai/mistral-small-3.1-24b-instruct",
+    "👁 Gemma 3 27B (lightweight)": "google/gemma-3-27b-it",
+    "⚙️ custom (use text field below)": "__custom__",
+}
+VLM_PRESET_LABELS = list(VLM_PRESETS.keys())
+
+
+def resolve_slug(table, label, custom_text, default):
+    slug = table.get(label, "__custom__")
+    if slug == "__custom__":
+        return custom_text.strip() or default
+    return slug
+
+
+# ----------------------------------------------------------------------
+#  OpenRouter 토큰 단가 조회 (debug_info 표시용)
+#  /api/v1/models 는 무인증 공개 엔드포인트. 프로세스 살아있는 동안 1회만 받는다.
+#  pricing.prompt/completion 은 "토큰 1개당 USD" 문자열이라 1e6 곱해 1M당 단가로.
+# ----------------------------------------------------------------------
+_OR_PRICE_CACHE = {}
+
+
+def _or_model_prices(key=None):
+    if _OR_PRICE_CACHE:
+        return _OR_PRICE_CACHE
+    try:
+        hdr = {'Authorization': f'Bearer {key}'} if key else {}
+        req = urllib.request.Request("https://openrouter.ai/api/v1/models", headers=hdr)
+        raw = json.loads(urllib.request.urlopen(req, timeout=15).read().decode('utf-8'))
+        for m in raw.get("data", []):
+            p = m.get("pricing") or {}
+            try:
+                _OR_PRICE_CACHE[m["id"]] = (float(p.get("prompt", 0) or 0) * 1e6,
+                                            float(p.get("completion", 0) or 0) * 1e6)
+            except (TypeError, ValueError, KeyError):
+                pass
+    except Exception as e:
+        print(f"⚠️ [Director] OpenRouter 단가표 조회 실패(무시): {e}")
+    return _OR_PRICE_CACHE
+
+
+def _price_tag(slug, usage=None, key=None):
+    """'slug $0.28/$0.88 per 1M | spent ~$0.0031 (1450→820 tok)' 형태."""
+    parts = []
+    pc = _or_model_prices(key).get((slug or "").strip())
+    if pc:
+        parts.append(f"{slug} ${pc[0]:.3g}/${pc[1]:.3g} per 1M")
+    if usage:
+        pt, ct, cost = usage.get("prompt", 0), usage.get("completion", 0), usage.get("cost", 0.0)
+        if pt or ct or cost:
+            parts.append(f"spent ~${cost:.4f} ({pt}→{ct} tok)")
+    return " | ".join(parts)
+
+
+def resolve_api_key(widget_value):
+    """위젯에 키�� 있으면 그대로 사용. 비어있으면 OPENROUTER_API_KEY 환경변수로 폴백.
+    -> 워크플로우 JSON(공유/백업 시 유출 위험)에 실키를 박아둘 필요가 없어짐."""
+    key = (widget_value or "").strip()
+    if key:
+        return key
+    return os.environ.get("OPENROUTER_API_KEY", "").strip()
+
+
+# ======================================================================
+#  캐시 & 트리거 (검증된 로직 재사용)
+# ======================================================================
+def _load_cache():
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def _save_cache(cache):
+    try:
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(cache, f, indent=4, ensure_ascii=False)
+    except OSError:
+        pass
+
+
+def _file_sig(path):
+    st = os.stat(path)
+    return f"{os.path.basename(path)}::{st.st_size}::{int(st.st_mtime)}"
+
+
+def _sha256(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(4096 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+# CivitAI 및 미러(civitaired) 해시 조회 엔드포인트. 앞에서부터 순서대로 시도.
+TRIGGER_HASH_APIS = [
+    "https://civitai.com/api/v1/model-versions/by-hash/{h}",
+    "https://civitaired.com/api/v1/model-versions/by-hash/{h}",
+]
+
+# LoRA Manager(comfyui-lora-manager)가 스캔 시 만들어두는 로컬 SQLite 캐시.
+# sha256으로 trained_words를 즉시 조회 가능 -> 네트워크 호출 없이 트리거워드 확보.
+LORA_MANAGER_DB = os.path.join(
+    os.environ.get("LOCALAPPDATA", ""), "ComfyUI-LoRA-Manager", "cache", "model", "comfyui.sqlite")
+
+
+def _query_lora_manager_db(digest):
+    """LoRA Manager SQLite 캐시에서 sha256으로 trained_words 조회. 실패/미발견 시 None."""
+    if not digest or not os.path.exists(LORA_MANAGER_DB):
+        return None
+    try:
+        uri = f"file:{LORA_MANAGER_DB}?mode=ro"
+        con = sqlite3.connect(uri, uri=True, timeout=3)
+        try:
+            cur = con.cursor()
+            cur.execute(
+                "SELECT trained_words FROM models WHERE model_type='lora' AND sha256=? LIMIT 1",
+                (digest,))
+            row = cur.fetchone()
+        finally:
+            con.close()
+        if not row or not row[0]:
+            return None
+        tw = json.loads(row[0])
+        return tw if isinstance(tw, list) else None
+    except (sqlite3.Error, OSError, ValueError, json.JSONDecodeError) as e:
+        print(f"⚠️ [Director] LoRA Manager DB lookup failed: {type(e).__name__}: {e}")
+        return None
+
+
+def _query_trigger_api(url):
+    """단일 해시 조회 엔드포인트에서 trainedWords 리스트를 반환. 실패 시 ([], 사유)."""
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req, timeout=8) as r:
+            data = json.loads(r.read().decode('utf-8'))
+            return (data.get("trainedWords", []) or []), None
+    except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError,
+            OSError, ValueError, json.JSONDecodeError) as e:
+        return [], f"{type(e).__name__}: {e}"
+
+
+# 트리거 워드가 "penis, bounce, swing"처럼 캐릭터 이름 옆에 콤마로 그냥 나열되면
+# (_build_final 참고) 어느 신체 부위에 국한된 디테일인지 모델이 알 방법이 없어서,
+# bounce/swing 같은 범용 동작 동사가 전신 모션으로 새버리는 게 실측으로 확인됨
+# (예: "penis, bounce, swing"의 flaccid LoRA 트리거 때문에 캐릭터가 무슨 동작을
+# 하든 콩콩 뛰었음). 문법적 문맥이 없는 "맨몸 단어"(공백 없는 한 단어)로만 등장하는
+# 범용 동작 동사는 걸러낸다 - "penis becomes erect"처럼 이미 문장으로 묶여 들어온
+# 여러 단어짜리 구는 건드리지 않음(이미 anchoring이 있어서 안전).
+_GENERIC_MOTION_VERBS = {
+    "bounce", "bouncing", "swing", "swinging", "shake", "shaking",
+    "sway", "swaying", "wiggle", "wiggling", "jiggle", "jiggling",
+    "wobble", "wobbling", "jump", "jumping", "hop", "hopping",
+    "bob", "bobbing", "quiver", "quivering", "tremble", "trembling",
+    "spin", "spinning", "twitch", "twitching",
+}
+
+
+def _filter_generic_motion_verbs(words):
+    kept, dropped = [], []
+    for w in words:
+        if w.strip().lower() in _GENERIC_MOTION_VERBS:
+            dropped.append(w)
+        else:
+            kept.append(w)
+    if dropped:
+        print(f"🚫 [Director] Excluded generic motion-verb triggers: {dropped}")
+    return kept
+
+
+def get_triggers(lora_name, cache):
+    return _filter_generic_motion_verbs(_get_triggers_raw(lora_name, cache))
+
+
+def _get_triggers_raw(lora_name, cache):
+    if lora_name == "None":
+        return []
+    path = folder_paths.get_full_path("loras", lora_name)
+    if not path or not os.path.exists(path):
+        return []
+    try:
+        with safe_open(path, framework="pt", device="cpu") as f:
+            m = f.metadata()
+            if m and "modelspec.trigger_words" in m:
+                tw = json.loads(m["modelspec.trigger_words"])
+                if isinstance(tw, list):
+                    return tw
+                if isinstance(tw, str):
+                    return [tw]
+    except (OSError, ValueError, json.JSONDecodeError):
+        pass
+    try:
+        sig = _file_sig(path)
+    except OSError:
+        sig = lora_name
+    # 캐시에 '비어있지 않은' 결과가 있을 때만 신뢰. 과거에 실패로 저장된 빈 값은
+    # 무시하고 재조회한다 (빈 값 영구화 회귀 방지).
+    cached = cache.get(sig)
+    if cached:
+        return cached
+
+    # 해시는 1회만 계산해서 LoRA Manager DB -> CivitAI -> civitaired 순으로 조회.
+    result, base = [], os.path.basename(path)
+    try:
+        digest = _sha256(path)
+    except OSError as e:
+        print(f"⚠️ [Director] Hash computation failed ({base}): {e}")
+        digest = None
+    if digest:
+        found = _query_lora_manager_db(digest)
+        if found:
+            print(f"✅ [Director] Trigger lookup succeeded ({base}) @ LoRA Manager DB: {found}")
+            result = found
+    if digest and not result:
+        for tmpl in TRIGGER_HASH_APIS:
+            host = tmpl.split('/')[2]
+            found, err = _query_trigger_api(tmpl.format(h=digest))
+            if found:
+                print(f"✅ [Director] Trigger lookup succeeded ({base}) @ {host}: {found}")
+                result = found
+                break
+            print(f"⚠️ [Director] Trigger lookup failed ({base}) @ {host}: {err or 'no trainedWords'}")
+
+    # 성공(비어있지 않음)일 때만 캐싱. 빈 결과는 저장하지 않아 다음 실행에서 재시도됨.
+    if result:
+        cache[sig] = result
+        _save_cache(cache)
+    return result
+
+
+def apply_model_lora(model, lora_data, weight):
+    try:
+        return comfy.sd.load_lora_for_models(model, None, lora_data, weight, 0)[0]
+    except (AttributeError, TypeError):
+        new_model = model.clone()
+        key_map = comfy.lora.model_lora_keys_unet(new_model.model)
+        loaded = comfy.lora.load_lora(lora_data, key_map)
+        new_model.add_patches(loaded, weight)
+        return new_model
+
+
+def tensor_to_base64(image_tensor, max_side=1024):
+    """ComfyUI IMAGE 텐서(B,H,W,C, 0~1 float) 첫 프레임을 JPEG base64 data URI로."""
+    if not _HAS_PIL:
+        print("❌ [Director] PIL (Pillow) missing - vision unavailable. Run `pip install Pillow`.")
+        return None
+    if image_tensor is None:
+        print("❌ [Director] image input is None - check the IMAGE connection.")
+        return None
+    try:
+        img = image_tensor
+        if hasattr(img, "cpu"):
+            img = img.cpu().numpy()
+        img = np.asarray(img)
+        if img.ndim == 4:
+            img = img[0]
+        arr = np.clip(img * 255.0, 0, 255).astype(np.uint8)
+        pil = Image.fromarray(arr)
+        w, h = pil.size
+        if max(w, h) > max_side:
+            scale = max_side / float(max(w, h))
+            pil = pil.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
+        buf = io.BytesIO()
+        pil.convert("RGB").save(buf, format="JPEG", quality=90)
+        b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+        print(f"🖼 [Director] image encoded ok: {w}x{h} -> {pil.size}, {len(b64)//1024}KB base64")
+        return f"data:image/jpeg;base64,{b64}"
+    except Exception as e:
+        print(f"❌ [Director] image encode failed: {type(e).__name__}: {e}")
+        return None
+
+
+def split_action_parts(actions):
+    """essential_actions를 조각으로 나눈다.
+
+    '/'가 있으면 그건 사용자가 클립/비트 경계를 명시적으로 못 박은 것이므로
+    '/'만 경계로 쓰고 그 안의 쉼표는 한 덩어리로 유지한다 - 안 그러면 "동작A,
+    디테일1, 디테일2 / 동작B, 디테일3" 처럼 '/'로 묶은 한 클립 분량이 쉼표
+    때문에 다시 여러 조각으로 쪼개져서 클립 경계가 어긋난다(실제로 겪은 버그).
+    '/'가 없을 때만 기존처럼 쉼표/문장부호/줄바꿈으로 나눈다."""
+    if '/' in actions:
+        parts = actions.split('/')
+    else:
+        parts = re.split(r'(?<=[.!?。])\s+|[,、]|\n+', actions)
+    return [p.strip() for p in parts if len(p.strip()) > 1]
+
+
+# ======================================================================
+#  Vision Director: 이미지 인식 + 필수동작 실행 + 클립당 4로라
+# ======================================================================
+class DolphinVisionDirector:
+    """
+    이미지 하나와 '필수 동작'과 로라만 넣으면 4개 연속 클립이 완성되는 올인원 노드.
+
+      1) IMAGE -> 비전 VLM 이 상황(캐릭터 상태/자세/환경)만 앵커로 파악
+      2) 그 맥락 위에서 '내가 준 필수 동작(essential_actions)'만 4샷으로 분배
+      3) 클립마다 로라 4개씩 개별 적용(웨이트도 개별) + 트리거 자동 주입
+    """
+
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + (folder_paths.get_filename_list("loras") or [])
+        req = {
+            "image": ("IMAGE",),
+            "model_base": ("MODEL",),
+            "model_high": ("MODEL",),
+            "model_low": ("MODEL",),
+            "essential_actions": ("STRING", {"multiline": True,
+                "default": ("charges forward, swings a sword to strike down the enemy, deflects "
+                            "a bullet, finishes them off"),
+                "tooltip": "Essential actions, comma-separated. If left empty (empty string), "
+                           "'auto-direct' mode kicks in - the LLM imagines a natural action "
+                           "sequence on its own using only the vision anchors (character "
+                           "state/pose/context) and artistic_vibe. This only works meaningfully "
+                           "if image recognition is on via use_vision/vision_caption (without "
+                           "vision, the anchors are empty and the result is vague)."}),
+            "num_clips": (["4 (20s)", "3 (15s)", "2 (10s)"], {"default": "4 (20s)",
+                "tooltip": "The number of clips to actually render/save (this node is the single "
+                           "control - other bypass toggles in the graph are not used). Remaining "
+                           "clip slots repeat the last clip's content."}),
+            "artistic_vibe": ("STRING", {"multiline": True,
+                                         "default": "cinematic lighting, dynamic motion"}),
+            "pacing": (["auto", "slow-burn (1 beat)", "balanced (multi beat)", "rapid (4 distinct)"],
+                       {"default": "auto"}),
+            "detail_level": (["Short (concise)", "Essentials + anchors only", "Detailed"],
+                             {"default": "Essentials + anchors only"}),
+            "inject_triggers": ("BOOLEAN", {"default": True,
+                                            "label_on": "TRIGGERS ON", "label_off": "TRIGGERS OFF"}),
+            "use_vision": ("BOOLEAN", {"default": True,
+                                       "label_on": "VISION ON", "label_off": "VISION OFF (text only)"}),
+            "openrouter_api_key": ("STRING", {"default": ""}),
+            "character_name": ("STRING", {"default": "AUTO"}),
+            "vlm_preset": (VLM_PRESET_LABELS, {"default": "👁 Qwen2.5-VL 72B (special cases · recommended)"}),
+            "vlm_model": ("STRING", {"default": "qwen/qwen2.5-vl-72b-instruct"}),
+            "llm_preset": (LLM_PRESET_LABELS, {"default": "🔞 DeepSeek V3.2 (uncensored · stable JSON · recommended)"}),
+            "llm_model": ("STRING", {"default": "deepseek/deepseek-v3.2"}),
+            "creativity": ("FLOAT", {"default": 0.7, "min": 0.1, "max": 1.5, "step": 0.05}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+        }
+        opt = {}
+        for c in range(1, 5):
+            for n in range(1, 5):
+                opt[f"c{c}_lora_{n}"] = (loras, {"default": "None"})
+                opt[f"c{c}_lora_{n}_on"] = ("BOOLEAN", {"default": True,
+                                                        "label_on": "ON", "label_off": "OFF"})
+                opt[f"c{c}_w_{n}"] = ("STRING", {"default": "1.0, 1.0, 1.0", "multiline": False})
+        opt["manual_triggers"] = ("STRING", {"default": "", "multiline": True})
+        opt["vision_caption"] = ("STRING", {"multiline": True, "default": "",
+                                            "forceInput": True})
+        return {"required": req, "optional": opt}
+
+    RETURN_TYPES = (
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "STRING", "STRING", "STRING",
+        "BOOLEAN", "BOOLEAN", "BOOLEAN", "BOOLEAN",
+    )
+    RETURN_NAMES = (
+        "c1_base", "c1_high", "c1_low", "c1_prompt",
+        "c2_base", "c2_high", "c2_low", "c2_prompt",
+        "c3_base", "c3_high", "c3_low", "c3_prompt",
+        "c4_base", "c4_high", "c4_low", "c4_prompt",
+        "triggers", "scene_analysis", "debug_info",
+        "c1_is_final", "c2_is_final", "c3_is_final", "c4_is_final",
+    )
+    FUNCTION = "direct"
+    CATEGORY = "Dolphin"
+
+    def _build_final(self, action, master_scene, name, trigger_str):
+        head = ", ".join([p for p in [name, trigger_str] if p])
+        body = " ".join([p for p in [master_scene.strip().strip(",. "), action.strip()] if p])
+        if head and body:
+            return f"{head}\n{body}"
+        return head or body
+
+    def _pacing_hint(self, p):
+        return {
+            "auto": "Decide pacing yourself based on how many distinct beats the actions contain.",
+            "slow-burn (1 beat)": "One climactic beat: clips 1-3 build tension, clip 4 detonates.",
+            "balanced (multi beat)": "Early clips build, later clips deliver; keep motion continuous.",
+            "rapid (4 distinct)": "Four distinct consecutive actions, one per clip, each kinetic.",
+        }.get(p, "Decide pacing yourself.")
+
+    def _detail_hint(self, d):
+        # 영어 키(Short/Essentials/Detailed)는 DolphinMinimaxDirector처럼 영어 UI를 쓰는
+        # 노드용 - 값은 한글 키와 동일, 이 함수를 공유하는 다른 노드(한글 드롭다운)를
+        # 깨지 않기 위해 새로 추가만 했다.
+        detailed_hint = (
+            "Keep the physical motion itself simple and singular — exactly the one action "
+            "given, no extra movements, no additional beats. Instead add rich VISUAL detail "
+            "around that single motion: skin/fabric texture, muscle tension, facial expression, "
+            "breathing, sweat, lighting, camera framing. Do NOT make the motion more complex or "
+            "add new movements to fill time.")
+        return {
+            "짧게(간결)": "Keep each clip to a short punchy motion phrase. Pure movement verbs only.",
+            "Short (concise)": "Keep each clip to a short punchy motion phrase. Pure movement verbs only.",
+            "필수+앵커만": "Each clip is one concise continuous motion. No description, only movement.",
+            "Essentials + anchors only": "Each clip is one concise continuous motion. No description, only movement.",
+            # 예전 문구("동작을 더 자세히 묘사")는 "동작 자체를 더 복잡하게"로 읽혀서, 모션을
+            # 계속 밀어붙이는 다른 튜닝(NAG/CFG/LoRA)과 겹치면 깡총거리기 같은 의미없는
+            # 필러 동작을 만들어냈다. 동작은 하나로 고정하고 시각적 디테일(질감/표정/조명/
+            # 카메라 등)만 늘리는 쪽으로 반전 - 새 동작/추가 비트를 유발하면 안 됨.
+            "상세": detailed_hint,
+            "Detailed": detailed_hint,
+        }.get(d, "Motion only, no description.")
+
+    def _extract_json(self, text):
+        if not text:
+            return None
+        text = re.sub(r'```(?:json)?', '', text).strip()
+        a, b = text.find('{'), text.rfind('}')
+        if a == -1 or b <= a:
+            return None
+        blob = text[a:b + 1]
+        try:
+            return json.loads(blob)
+        except json.JSONDecodeError:
+            try:
+                return json.loads(re.sub(r',\s*([}\]])', r'\1', blob))
+            except json.JSONDecodeError:
+                return None
+
+    def _call_or(self, messages, model, key, temp, timeout=120, force_json=False):
+        payload = {"model": model.strip(), "messages": messages, "temperature": temp,
+                   "usage": {"include": True}}
+        if force_json:
+            payload["response_format"] = {"type": "json_object"}
+        req = urllib.request.Request(
+            "https://openrouter.ai/api/v1/chat/completions",
+            data=json.dumps(payload).encode('utf-8'),
+            headers={'Authorization': f'Bearer {key}', 'Content-Type': 'application/json'})
+        raw = json.loads(urllib.request.urlopen(req, timeout=timeout).read().decode('utf-8'))
+        acc = getattr(self, "_usage_acc", None)
+        u = raw.get("usage") or {}
+        if acc is not None and u:
+            acc["prompt"] += u.get("prompt_tokens", 0) or 0
+            acc["completion"] += u.get("completion_tokens", 0) or 0
+            c = u.get("cost")
+            if c is None:
+                c = (u.get("cost_details") or {}).get("upstream_inference_cost")
+            acc["cost"] += float(c or 0)
+        if "choices" not in raw:
+            err = raw.get("error") or raw
+            msg = err.get("message") if isinstance(err, dict) else str(err)
+            code = err.get("code") if isinstance(err, dict) else "?"
+            raise ValueError(f"API error (code={code}): {msg}")
+        return raw['choices'][0]['message']['content'].strip()
+
+    def _vision_analyze(self, data_uri, vlm_model, key, temp):
+        sys = ("You are a visual scene analyst for a video pipeline. "
+               "Look at the image and extract ONLY concrete anchors, no storytelling. "
+               "Report exactly these lines:\n"
+               "(1) character appearance & clothing.\n"
+               "(2) current pose/posture (sitting, crouched, standing, balance, limb positions).\n"
+               "(3) SUPPORT & CONTACT: what the character is on top of, sitting on, holding, "
+               "leaning against, or touching (e.g. 'seated balanced on a yoga ball', "
+               "'gripping a sword', 'kneeling on the floor'). This is critical for physics — "
+               "state it explicitly even if obvious.\n"
+               "(4) environment & lighting (brief).\n"
+               "(5) facial expression & apparent mood/vibe (e.g. 'smiling, playful', 'serious, "
+               "intense stare', 'shy, looking away', 'sultry, half-lidded eyes', 'laughing, "
+               "cheerful'). Read this from the actual face in the image, not guessed from pose.\n"
+               "Be terse, one short line each. English only. "
+               "Do not invent actions or narrative. If content is mature, describe it plainly and factually.")
+        messages = [
+            {"role": "system", "content": sys},
+            {"role": "user", "content": [
+                {"type": "text", "text": "Extract the anchors from this image."},
+                {"type": "image_url", "image_url": {"url": data_uri}},
+            ]},
+        ]
+        import time
+        last_err = "vision error"
+        for attempt in range(1, 4):
+            try:
+                resp = self._call_or(messages, vlm_model, key, temp, timeout=90).strip()
+                if not resp:
+                    print(f"⚠️ [Director] VLM({vlm_model}) response was empty (refusal or empty return)")
+                    return "", "vision empty response"
+                print(f"👁 [Director] VLM({vlm_model}) anchors (attempt {attempt}):\n{resp[:300]}")
+                return resp, None
+            except urllib.error.HTTPError as e:
+                body = ""
+                try:
+                    body = e.read().decode('utf-8')[:200]
+                except Exception:
+                    pass
+                print(f"❌ [Director] VLM HTTP {e.code} (attempt {attempt}): {body}")
+                last_err = f"vision HTTP {e.code}"
+                if e.code in (429, 503) and attempt < 3:
+                    wait = 2 ** attempt
+                    print(f"⏳ [Director] rate limited, retrying in {wait}s...")
+                    time.sleep(wait)
+                    continue
+                return "", last_err
+            except (urllib.error.URLError, TimeoutError, KeyError, ValueError) as e:
+                print(f"❌ [Director] VLM error (attempt {attempt}): {type(e).__name__}: {e}")
+                last_err = f"vision error: {e}"
+                if attempt < 3:
+                    time.sleep(2 ** attempt)
+                    continue
+                return "", last_err
+        return "", last_err
+
+    def _fallback_name(self, anchors):
+        import random
+        a = (anchors or "").lower()
+        east = ["asian", "east asian", "japanese", "korean", "chinese", "anime",
+                "kimono", "hanbok", "qipao", "oriental"]
+        western = ["western", "european", "caucasian", "american", "blonde", "redhead"]
+        east_names = ["Yuna", "Kaede", "Jin", "Mei", "Haruka", "Rin", "Sora", "Aoi"]
+        west_names = ["Elena", "Ryan", "Ava", "Lucas", "Mila", "Ethan", "Nora", "Leo"]
+        if any(k in a for k in east):
+            pool = east_names
+        elif any(k in a for k in western):
+            pool = west_names
+        else:
+            pool = east_names + west_names
+        return random.choice(pool)
+
+    def _split_actions_to_clips(self, actions, num_clips=4):
+        parts = split_action_parts(actions)
+        if not parts:
+            parts = [actions.strip()]
+        n = len(parts)
+        last = num_clips
+        assign = {c: [] for c in range(1, num_clips + 1)}
+        if num_clips == 1:
+            assign[1] = parts
+            return assign
+        build_labels = ["(build-up toward)", "(begin)", "(escalate)", "(continue escalating)"]
+        if n == 1:
+            for c in range(1, last):
+                label = build_labels[min(c - 1, len(build_labels) - 1)]
+                assign[c] = [f"{label} {parts[0]}"]
+            assign[last] = [parts[0]]
+        elif n <= num_clips:
+            assign[last] = [parts[-1]]
+            head = parts[:-1]
+            for i, ph in enumerate(head):
+                assign[min(i + 1, last - 1)].append(ph)
+            for c in range(1, last):
+                if not assign[c]:
+                    nxt = parts[min(c, n - 1)]
+                    assign[c] = [f"(move toward) {nxt}"]
+        else:
+            assign[last] = [parts[-1]]
+            rest = parts[:-1]
+            k, m = divmod(len(rest), last - 1)
+            idx = 0
+            for c in range(1, last):
+                end = idx + k + (1 if (c - 1) < m else 0)
+                assign[c] = rest[idx:end]
+                idx = end
+        return assign
+
+    def _plan_shots(self, anchors, actions, name, vibe, pacing, detail, llm_model, key, temp, seed,
+                     num_clips=4, continuity_context=""):
+        auto_direct = not actions.strip()
+        if auto_direct:
+            assign_block = (
+                "  (none given — INVENT the full action sequence yourself per rule 1 below, "
+                "grounded in the SCENE ANCHORS and MOTION STYLE)")
+        else:
+            assign = self._split_actions_to_clips(actions, num_clips)
+            assign_block = "\n".join(
+                f"  clip_{c}: {', '.join(assign[c]) if assign[c] else '(continue previous motion)'}"
+                for c in range(1, num_clips + 1))
+
+        last_clip = num_clips
+        total_seconds = num_clips * 5
+        if num_clips >= 3:
+            chain = " and ".join(f"clip_{c}<-clip_{c-1}" for c in range(3, num_clips + 1))
+            continuity_middle = (f". The same applies {chain}: each clip picks up exactly where the "
+                                  f"previous clip's body position left off")
+        else:
+            continuity_middle = ""
+            
+        continuity_rule = ""
+
+        # 클립을 여러 개 나눠서 순차적으로 별도 호출할 때(예: 클립마다 독립된 노드로
+        # 쪼갠 경우) 쓰는 "호출 간" 연속성 규칙. num_clips>=2의 "호출 내" 연속성 규칙과는
+        # 별개 - 이번 호출이 만드는 clip_1이 이전 호출에서 이미 확정된 동작 뒤를 잇게 한다.
+        if continuity_context.strip():
+            continuity_rule += (
+                "3b) CONTINUES A PRIOR CLIP. The action just before this one already happened "
+                "(see PREVIOUS CLIP ACTION below) and clip_1 here MUST begin from the exact physical "
+                "end-state that action would leave the body in — same position, orientation, momentum. "
+                "Do not restart from a neutral stance and do not repeat the previous action. Do NOT "
+                "narrate the hand-off explicitly (no 'continuing', 'still', 'as before').\n"
+            )
+        if num_clips >= 2:
+            continuity_rule += (
+                "3) INTER-CLIP CONTINUITY. clip_2 MUST begin from the exact physical end-state of "
+                "clip_1's action (same position, body orientation, and momentum) — it continues the "
+                "motion, it does not restart from a neutral stance" + continuity_middle +
+                f", as one unbroken {total_seconds}-second performance rather than {num_clips} separate poses. Do "
+                "NOT explicitly narrate the hand-off (no phrases like 'continuing from', 'still', 'as "
+                "before', 'picking up where') — simply choreograph the new action so it is kinematically "
+                "consistent with how the previous action would have left the body positioned. This is a "
+                "physical-continuity constraint, not a scripted transition line.\n"
+            )
+
+        json_clip_fields = ",".join(
+            f'"clip_{i}":"<only clip_{i} action{", the finisher" if i == last_clip else ""}, '
+            f'one continuous real-time motion>"' for i in range(1, num_clips + 1))
+
+        if auto_direct:
+            intro = (
+                f"You are an elite movement choreographer AND director for a {total_seconds}-second "
+                f"video made of {num_clips} consecutive 5-second clip{'s' if num_clips != 1 else ''}. "
+                "No action list is given — you invent the entire beat-by-beat sequence yourself, using "
+                "the SCENE ANCHORS (the character's starting look/pose/place from an image) and the "
+                "MOTION STYLE cue as your only creative brief.\n"
+            )
+            rule1 = (
+                "1) INVENT THE SEQUENCE. Design a self-contained, progressively developing action "
+                f"sequence of exactly "
+                f"{num_clips} beat{'s' if num_clips != 1 else ''} that plausibly follows from the "
+                "character's exact pose/state/context in the SCENE ANCHORS — what would this character "
+                "naturally do next, right now, from exactly that position? Build it so the sequence "
+                f"develops beat by beat and the LAST beat (clip_{last_clip}) is its clear payoff — "
+                "'develops' means the situation moves forward, NOT that each beat must be more violent "
+                "than the last. Do not invent new characters, props, or a change of "
+                "location — stay grounded in what the anchors describe. "
+                "(ONE exception: clip_1 may prepend a brief transition OUT of the starting physics from "
+                "rule 2 — e.g. leaving the yoga ball — before its invented action. This is not skipping "
+                "ahead; it is grounding the first beat.)\n"
+            )
+        else:
+            intro = (
+                f"You are an elite movement choreographer for a {total_seconds}-second video made of "
+                f"{num_clips} consecutive 5-second clip{'s' if num_clips != 1 else ''}. You are given SCENE "
+                "ANCHORS (the character's starting look/pose/place from an image) and a STRICT per-clip "
+                "action assignment.\n"
+            )
+            rule1 = (
+                "1) FOLLOW THE ASSIGNMENT EXACTLY. Each clip animates ONLY the action(s) assigned "
+                "to it below. You MUST NOT move a later clip's action into an earlier clip. "
+                f"clip_1 must NOT contain clip_{last_clip}'s action. The final action happens ONLY in "
+                f"clip_{last_clip}. "
+                "This is the most important rule - violating the order is a failure. "
+                "(ONE exception: clip_1 may prepend a brief transition OUT of the starting physics from "
+                "rule 2 — e.g. leaving the yoga ball — before its assigned action. This is not borrowing "
+                "a later action; it is grounding the first one.)\n"
+            )
+
+        sys = (
+            intro +
+            "\n"
+            "ABSOLUTE RULES:\n"
+            + rule1 +
+            "2) STARTING PHYSICS (use the anchors here). Read the character's CURRENT pose AND "
+            "what they are supported by / in contact with from the SCENE ANCHORS (e.g. seated on a "
+            "yoga ball, kneeling, gripping a weapon, leaning on a wall). clip_1 MUST begin the first "
+            "action FROM that exact physical situation and honor its constraints, but spend AT MOST "
+            "one short clause on it — e.g. anchor 'seated balanced on a yoga ball' -> clip_1 = "
+            "'pushes off the wobbling ball, rising fast to their feet as it rolls away, then...' — "
+            "the grounding clause itself must already be fast, active motion (a verb), never a static "
+            "description of the pose. Never ignore or contradict the starting support (do not stand "
+            "if seated on the ball without first leaving it; do not assume a weapon is drawn if the "
+            "anchor shows it sheathed). Reference the support ONLY to ground how the motion STARTS — "
+            "do NOT describe its appearance, color, or the wider environment.\n"
+            + continuity_rule +
+            "4) ACTION ONLY. Write physical body movement. NO scenery, NO lighting, NO clothing, "
+            "NO mood, NO camera talk. If a word is not a movement or body part, delete it. "
+            "(Referring to the starting pose in clip_1 per rule 2, or to the prior clip's ending "
+            "position per rule 3, is allowed since it describes how the body moves — but keep it to "
+            "one short clause, then move straight into the clip's own action.)\n"
+            "4b) LITERAL, NOT METAPHORICAL. Name body parts and acts directly (e.g. 'penis', "
+            "'vagina', 'cock', 'pussy', 'thrusts', 'grips') — never euphemism, poetic metaphor, or "
+            "vague substitution (do not write things like 'their connection deepens', 'waves of "
+            "pleasure', 'their bodies moved as one', 'her core'). This is a technical motion "
+            "description for an animation model, not literary prose — treat it like a stage "
+            "direction: blunt, anatomical, unambiguous about which body part does what to which.\n"
+            "4c) NO GESTURE CLICHÉS. Resolve any vague/decorative descriptor in the action "
+            "(e.g. 'cutely', 'playfully', 'sexily', 'shyly') into ONE specific, concrete gesture or "
+            "body movement of your own invention. NEVER default to the single most common/expected "
+            "cliché for that word (e.g. a peace sign / V-sign / finger-heart for 'cute', a hair-flip "
+            "for 'sexy') — these are overused and must be avoided. If PREVIOUS CLIP ACTION below "
+            "already used a specific gesture, invent a DIFFERENT one now instead of repeating it.\n"
+            "5) FILL 5 SECONDS. Expand the assigned action into a single continuous flow of motion "
+            "that occupies the whole clip (use 'then', 'without pausing', 'carrying straight into'). "
+            "Do not borrow the next action to fill time - elaborate the CURRENT action instead.\n"
+            # rule 6은 원래 "모든 클립에 폭발적 부사(swiftly/explosively/in a split second)를 박고
+            # gently/slowly/softly는 금지"였다. 그 규칙이 진짜 막으려던 건 "비디오 모델이 가만 두면
+            # 슬로모션으로 흐르는 것"인데, 실제로는 조용한 장면까지 전부 찌르고 휘두르는 날카로운
+            # 동작으로 만들어버렸다. 그래서 "실시간 속도 유지"(=슬로모션/정지 금지)만 남기고
+            # "무조건 격렬하게"는 뺐다 - 동사의 세기는 배정된 동작 자체가 정한다.
+            "6) REAL-TIME SPEED, NOT FORCED VIOLENCE: every clip plays at natural real-time "
+            "speed — NO slow motion, NO freeze, NO holding a pose, the body keeps moving "
+            "throughout. But do NOT inflate the movement: match the force of the verb to what "
+            "the action actually is. Reach for the plain accurate verb first (walks, turns, "
+            "leans, reaches, lifts, pushes, presses) and use hard percussive verbs (slams, "
+            "whips, snaps, lunges, explodes) or urgency adverbs (explosively, in a split "
+            "second) ONLY where the assigned action is itself sudden or violent. A quiet "
+            "action stays quiet while still moving continuously. 'Build-up' in rule 1 refers "
+            "ONLY to which action-beat is assigned to a clip — it does NOT mean a clip should "
+            "move slower, look hesitant, or read as a held state. Every clip is deliberate and "
+            "physically committed, but 'committed' means clear and purposeful, not aggressive.\n"
+            "7) CHARACTER NAME: study the SCENE ANCHORS. Judge the character's apparent ethnicity/"
+            "setting (East Asian, Western, etc.) and INVENT a specific fitting first name that "
+            "matches it (e.g. East Asian -> 'Yuna','Kaede','Jin'; Western -> 'Elena','Ryan'). "
+            "NEVER output 'AUTO' or an empty name. If a NAME is given below (not 'AUTO'), use it.\n"
+            f"8) {detail}\n"
+            "9) MOTION ENERGY: a MOTION STYLE cue is given below (e.g. 'cinematic lighting, dynamic "
+            "motion'). Use it ONLY to calibrate how forceful/graceful/frantic the movement FEELS "
+            "(word choice, verb intensity). Do NOT quote it and do NOT let any scenery/lighting/mood "
+            "words from it leak into the output — rule 4 still applies. Where the cue and rule 6 "
+            "disagree about how hard the movement should be, RULE 6 WINS.\n"
+            "\n"
+            "master_scene: leave it EMPTY.\n"
+            "\n"
+            'OUTPUT ONLY JSON: {"character":"<a real name, never AUTO>","master_scene":"",'
+            + json_clip_fields + "}"
+        )
+        assign_label = (
+            f"INVENT THE SEQUENCE (no actions given — design {num_clips} progressively developing "
+            f"beats yourself per rule 1, finisher in clip_{last_clip}):"
+            if auto_direct else
+            f"STRICT PER-CLIP ACTION ASSIGNMENT (animate ONLY what is listed per clip, "
+            f"in this order, finisher in clip_{last_clip}):"
+        )
+        continuity_block = (
+            f"PREVIOUS CLIP ACTION (per rule 3b — clip_1 continues from this end-state):\n"
+            f"{continuity_context.strip()}\n\n"
+            if continuity_context.strip() else ""
+        )
+        usr = (f"NAME: {name}\nPACING: {self._pacing_hint(pacing)}\n\n"
+               f"MOTION STYLE (kinetic energy cue only, per rule 9 — do not describe scenery/"
+               f"lighting/mood from this): {vibe.strip() or '(none)'}\n\n"
+               f"SCENE ANCHORS (use the POSE to start clip_1's motion per rule 2; "
+               f"use overall look only for naming — do NOT copy look into the clips):\n"
+               f"{anchors or '(none — assume a neutral ready stance)'}\n\n"
+               f"{continuity_block}"
+               f"{assign_label}\n{assign_block}\n")
+        messages = [{"role": "system", "content": sys}, {"role": "user", "content": usr}]
+        t = temp
+        last = "⚠️ plan failed (no attempts ran)"
+        for attempt in (1, 2):
+            try:
+                content = self._call_or(messages, llm_model, key, t, force_json=True)
+                parsed = self._extract_json(content)
+                if parsed and all(parsed.get(f"clip_{i}") for i in range(1, num_clips + 1)):
+                    return parsed, f"✅ plan ok (attempt {attempt})"
+                last = f"⚠️ incomplete JSON (attempt {attempt}): {content[:150]!r}"
+                print(f"⚠️ [Director] plan attempt {attempt} returned incomplete JSON: {content[:300]}")
+            except urllib.error.HTTPError as e:
+                body = ""
+                try:
+                    body = e.read().decode('utf-8')[:200]
+                except Exception:
+                    pass
+                last = f"❌ plan HTTP {e.code} (attempt {attempt}): {body}"
+                print(f"❌ [Director] plan {last}")
+            except (urllib.error.URLError, TimeoutError, KeyError, ValueError) as e:
+                last = f"❌ plan error (attempt {attempt}): {type(e).__name__}: {e}"
+                print(f"❌ [Director] {last}")
+            t = min(temp, 0.4)
+        return None, last
+
+    def _local_split(self, actions, num_clips=4):
+        if not actions.strip():
+            # 자동 연출 모드인데 LLM(키)이 없어서 실제로 "연출"은 못 함 - 이미지 근거 없이
+            # 그럴듯한 즉흥 동작이라도 채워서 그래프가 안 깨지게 함(무의미한 빈 문구 방지).
+            actions = ("starts moving, the motion gains force, reaches its peak")
+        parts = split_action_parts(actions)
+        if not parts:
+            parts = [actions.strip()]
+        n = len(parts)
+        last = num_clips - 1
+
+        def fast(phrase, lead="swiftly"):
+            p = phrase.strip()
+            return f"{lead} {p}, continuous real-time motion, no slow motion" if p else ""
+
+        if num_clips == 1:
+            return [fast(", ".join(parts), "explosively")]
+
+        if n == 1:
+            a = parts[0]
+            templates = [
+                f"rapidly moves into position toward {a}, no pause",
+                f"immediately begins {a}, brisk continuous motion, no slow motion",
+                f"presses {a} without stopping, fast decisive movement",
+            ]
+            out = [templates[min(i, len(templates) - 1)] for i in range(num_clips - 1)]
+            out.append(f"explosively completes {a} at real-time speed, no slow motion, no freeze")
+        elif n <= num_clips:
+            out = [""] * num_clips
+            out[last] = fast(parts[-1], "explosively")
+            head = parts[:-1]
+            for i, ph in enumerate(head):
+                s = min(i, num_clips - 2)
+                out[s] = (out[s] + ", then " + fast(ph)).strip(", ") if out[s] else fast(ph)
+            for i in range(num_clips - 1):
+                if not out[i]:
+                    key = parts[min(i, n - 1)]
+                    out[i] = f"rapidly moves toward {key}, brisk continuous motion, no slow motion"
+        else:
+            k, m = divmod(n - 1, num_clips - 1)
+            idx, chunks = 0, []
+            for i in range(num_clips - 1):
+                end = idx + k + (1 if i < m else 0)
+                seg = parts[idx:end]
+                idx = end
+                chunks.append(", then ".join(fast(p) for p in seg) if seg else "")
+            out = chunks + [fast(parts[-1], "explosively")]
+        return out[:num_clips]
+
+    def _load(self, name):
+        return comfy.utils.load_torch_file(folder_paths.get_full_path("loras", name))
+
+    @staticmethod
+    def _parse_weights(text):
+        try:
+            nums = [float(x) for x in re.split(r'[,\s]+', text.strip()) if x != ""]
+        except (ValueError, AttributeError):
+            nums = []
+        if not nums:
+            return 1.0, 1.0, 1.0
+        if len(nums) == 1:
+            return nums[0], nums[0], nums[0]
+        if len(nums) == 2:
+            return nums[0], nums[1], nums[1]
+        return nums[0], nums[1], nums[2]
+
+    def _patch_clip(self, mb, mh, ml, slots, cache, inject):
+        cb, ch, cl = mb, mh, ml
+        used = []
+        for (name, w_str) in slots:
+            if name == "None":
+                continue
+            w_b, w_h, w_l = self._parse_weights(w_str)
+            if w_b == 0.0 and w_h == 0.0 and w_l == 0.0:
+                continue
+            data = self._load(name)
+            if w_b != 0.0:
+                cb = apply_model_lora(cb, data, w_b)
+            if w_h != 0.0:
+                ch = apply_model_lora(ch, data, w_h)
+            if w_l != 0.0:
+                cl = apply_model_lora(cl, data, w_l)
+            used.append(name)
+        trig = []
+        trig_dbg = []
+        for n in dict.fromkeys(used):
+            found = get_triggers(n, cache)
+            trig.extend(found)
+            trig_dbg.append(f"{os.path.basename(n)}:{len(found)}")
+        self._last_trig_dbg = trig_dbg
+        trig_str = ", ".join(dict.fromkeys(t for t in trig if t))
+        prompt_trig = trig_str if inject else ""
+        return cb, ch, cl, prompt_trig, trig_str
+
+    def direct(self, image, model_base, model_high, model_low, essential_actions, num_clips,
+               artistic_vibe, pacing, detail_level, inject_triggers,
+               use_vision, openrouter_api_key, character_name, vlm_preset, vlm_model, llm_preset, llm_model,
+               creativity, seed, **kw):
+
+        n_clips = int(str(num_clips).split()[0])
+        self._usage_acc = {"prompt": 0, "completion": 0, "cost": 0.0}
+        vlm = resolve_slug(VLM_PRESETS, vlm_preset, vlm_model, "qwen/qwen2.5-vl-72b-instruct")
+        llm = resolve_slug(LLM_PRESETS, llm_preset, llm_model, "deepseek/deepseek-v3.2")
+        user_name = "" if character_name.strip().upper() in ["AUTO", ""] else character_name.strip()
+        key = resolve_api_key(openrouter_api_key)
+
+        vision_caption = str(kw.get("vision_caption", "") or "").strip()
+        anchors, dbg_v = "", ""
+        if vision_caption:
+            anchors = vision_caption
+            dbg_v = "vision ok (local caption node)"
+            print(f"👁 [Director] Using local caption input (JoyCaption etc.):\n{anchors[:300]}")
+        elif not use_vision:
+            dbg_v = "vision OFF (check toggle)"
+            print("ℹ️ [Director] use_vision=OFF - skipping vision")
+        elif not key:
+            dbg_v = "no api key"
+            print("❌ [Director] openrouter_api_key missing (neither widget nor OPENROUTER_API_KEY env var set) - vision/LLM unavailable")
+        elif image is None:
+            dbg_v = "no image"
+            print("❌ [Director] image input missing - check the IMAGE connection")
+        else:
+            data_uri = tensor_to_base64(image)
+            if data_uri:
+                anchors, err = self._vision_analyze(data_uri, vlm, key, min(creativity, 0.5))
+                dbg_v = err or "vision ok"
+            else:
+                dbg_v = "image encode failed / PIL missing"
+        if not vision_caption and use_vision and key and image is not None and not anchors:
+            print(f"⚠️ [Director] Vision anchors are empty -> no basis for name/scene. Cause: {dbg_v}")
+
+        if key:
+            parsed, dbg_p = self._plan_shots(anchors, essential_actions, character_name,
+                                             artistic_vibe, pacing, self._detail_hint(detail_level),
+                                             llm, key, creativity, seed, num_clips=n_clips)
+            if parsed:
+                clips = [str(parsed[f"clip_{i}"]).strip() for i in range(1, n_clips + 1)]
+                master = str(parsed.get("master_scene", "")).strip()
+                cand = str(parsed.get("character", "")).strip()
+                if not cand or cand.upper() == "AUTO":
+                    cand = self._fallback_name(anchors)
+                final_name = user_name or cand
+            else:
+                clips = self._local_split(essential_actions, num_clips=n_clips)
+                # master_scene은 LLM 경로와 동일하게 비움 - 안 그러면 VLM이 뽑은 정적 사진
+                # 묘사(모델/조명/배경 등)가 매 클립 프롬프트 앞에 그대로 붙어서 "동작만" 규칙이
+                # 깨지고, 결과가 그냥 비전 캡션을 반복하는 것처럼 보임 (버그였음, 2026-07-03 수정).
+                master = ""
+                final_name = user_name or self._fallback_name(anchors)
+        else:
+            parsed = None
+            dbg_p = ("no api key (auto-direct unavailable, generic filler used)"
+                     if not essential_actions.strip() else "no api key")
+            clips = self._local_split(essential_actions, num_clips=n_clips)
+            master = ""
+            final_name = user_name
+
+        if len(clips) < 4:
+            clips = clips + [clips[-1]] * (4 - len(clips))
+
+        cache = _load_cache()
+        manual_list = [t.strip() for t in kw.get("manual_triggers", "").split(',') if t.strip()]
+        outs = []
+        all_trigs_collected = []
+        for c in range(1, 5):
+            if c > n_clips:
+                cb = ch = cl = ExecutionBlocker(None)
+                prompt = self._build_final(clips[c - 1], master, final_name, "")
+                outs.extend([cb, ch, cl, prompt])
+                print(f"  [clip{c}] SKIPPED (num_clips={n_clips}) - returning ExecutionBlocker")
+                continue
+            slots = [(kw.get(f"c{c}_lora_{n}", "None"),
+                      kw.get(f"c{c}_w_{n}", "1.0, 1.0, 1.0")) for n in range(1, 5)
+                     if kw.get(f"c{c}_lora_{n}_on", True)]
+            cb, ch, cl, prompt_trig, always_trig = self._patch_clip(
+                model_base, model_high, model_low, slots, cache, inject_triggers)
+            all_trig = ", ".join(dict.fromkeys(
+                ([prompt_trig] if prompt_trig else []) + manual_list)) \
+                if (prompt_trig or manual_list) else ""
+            if always_trig:
+                all_trigs_collected.extend(t.strip() for t in always_trig.split(',') if t.strip())
+            prompt = self._build_final(clips[c - 1], master, final_name, all_trig)
+            outs.extend([cb, ch, cl, prompt])
+            print(f"  [clip{c}] loras/triggers: {getattr(self, '_last_trig_dbg', [])} "
+                  f"inject={inject_triggers}")
+
+        triggers_out = ", ".join(dict.fromkeys(
+            [t for t in all_trigs_collected if t] + manual_list))
+
+        debug = f"vlm={dbg_v} | plan={dbg_p} | char={final_name} | clips={n_clips} ({n_clips*5}s)"
+        _pt = _price_tag(llm, self._usage_acc, key)
+        if _pt:
+            debug += f" | {_pt}"
+        print(f"\n🎬 [Dolphin Vision Director] {debug}\nANCHORS: {anchors[:120]}")
+        for i in range(4):
+            print(f"  CLIP {i+1}: {outs[i*4+3][:90]}")
+
+        is_final = tuple(c == n_clips for c in range(1, 5))
+
+        return tuple(outs) + (triggers_out, anchors, debug) + is_final
+
+
+NODE_CLASS_MAPPINGS = {"DolphinVisionDirector": DolphinVisionDirector}
+NODE_DISPLAY_NAME_MAPPINGS = {"DolphinVisionDirector": "🎬👁 Dolphin Vision Director (Image→4Clips)"}

h3_wan_refine.json

@@ -0,0 +1,866 @@
+{
+  "id": "b7f1a2c4-h3wan-refine-0001",
+  "revision": 0,
+  "last_node_id": 15,
+  "last_link_id": 14,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VHS_LoadVideoPath",
+      "pos": [
+        40,
+        380
+      ],
+      "size": [
+        400,
+        240
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null,
+          "shape": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null,
+          "shape": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            9
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": [],
+          "slot_index": 1
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [
+            10
+          ],
+          "slot_index": 2
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": [],
+          "slot_index": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideoPath"
+      },
+      "widgets_values": {
+        "video": "D:/sd/output/H3/여기에_H3_출력_mp4_경로.mp4",
+        "force_rate": 0,
+        "custom_width": 0,
+        "custom_height": 0,
+        "frame_load_cap": 0,
+        "skip_first_frames": 0,
+        "select_every_nth": 1
+      },
+      "title": "1. H3 출력 영상 (force_rate=0 유지!)",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 2,
+      "type": "UNETLoader",
+      "pos": [
+        40,
+        40
+      ],
+      "size": [
+        400,
+        60
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            1
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "UNETLoader"
+      },
+      "widgets_values": [
+        "wan2.2_i2v_low_noise_14B_fp16.safetensors",
+        "fp8_e4m3fn_fast"
+      ],
+      "title": "2. Wan 2.2 I2V LOW noise (fp8 fast)",
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 3,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        40,
+        150
+      ],
+      "size": [
+        400,
+        90
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoraLoaderModelOnly"
+      },
+      "widgets_values": [
+        "Wan2.2-Fun-A14B-InP-low-noise-MPS.safetensors",
+        1.0
+      ],
+      "title": "3. 캐릭터 LoRA — 교체 후 bypass 해제(Ctrl+B)",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 4,
+      "type": "WanContextWindowsManual",
+      "pos": [
+        40,
+        280
+      ],
+      "size": [
+        400,
+        250
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            3
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "WanContextWindowsManual"
+      },
+      "widgets_values": [
+        81,
+        8,
+        "standard_uniform",
+        1,
+        false,
+        "pyramid",
+        true,
+        false,
+        false
+      ],
+      "title": "4. 컨텍스트 윈도우 (81프레임 이하 클립이면 bypass)",
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 5,
+      "type": "CLIPLoader",
+      "pos": [
+        40,
+        660
+      ],
+      "size": [
+        400,
+        110
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            4,
+            5
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPLoader"
+      },
+      "widgets_values": [
+        "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+        "wan",
+        "default"
+      ],
+      "title": "5. umt5 (Wan 전용 - H3 텍스트 인코더 아님)",
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 6,
+      "type": "CLIPTextEncode",
+      "pos": [
+        480,
+        660
+      ],
+      "size": [
+        420,
+        160
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "H3에 넣었던 프롬프트를 그대로 붙여넣을 것. 캐릭터 LoRA를 켰다면 트리거 워드를 여기 추가. 저denoise에선 프롬프트가 구도를 바꾸진 못하고 질감 방향만 잡는다."
+      ],
+      "title": "positive",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 7,
+      "type": "CLIPTextEncode",
+      "pos": [
+        480,
+        850
+      ],
+      "size": [
+        420,
+        160
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 5
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "blurry, low quality, oversharpened, plastic skin, waxy, flicker, 色调艳丽, 过曝, 静态, 细节模糊不清, 字幕, 风格, 作品, 画作, 画面, 静止, 整体发灰, 最差质量, 低质量, JPEG压缩残留, 丑陋的, 残缺的, 多余的手指"
+      ],
+      "title": "negative"
+    },
+    {
+      "id": 8,
+      "type": "VAELoader",
+      "pos": [
+        40,
+        810
+      ],
+      "size": [
+        400,
+        60
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAELoader"
+      },
+      "widgets_values": [
+        "Wan2_1_VAE_bf16.safetensors"
+      ],
+      "title": "6. Wan2.1 VAE (16ch) — 다른 걸 꽂으면 노드가 막는다",
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 9,
+      "type": "WanH3Refine_Dolphin",
+      "pos": [
+        960,
+        300
+      ],
+      "size": [
+        430,
+        430
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 3
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 6
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        },
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 9
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": 10,
+          "shape": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            11
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [
+            12
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "frames",
+          "type": "INT",
+          "links": [],
+          "slot_index": 2
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [],
+          "slot_index": 3
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [],
+          "slot_index": 4
+        },
+        {
+          "name": "info",
+          "type": "STRING",
+          "links": [
+            13
+          ],
+          "slot_index": 5
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "WanH3Refine_Dolphin"
+      },
+      "widgets_values": [
+        0,
+        "fixed",
+        4,
+        1.0,
+        "euler",
+        "simple",
+        0.3,
+        3.0,
+        "trim",
+        "first_frame",
+        1.0,
+        1.0,
+        24
+      ],
+      "title": "7. Wan Refine H3 — 리파인 패스 본체",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 10,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        1440,
+        300
+      ],
+      "size": [
+        460,
+        560
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 11
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": 12,
+          "shape": 7
+        },
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null,
+          "shape": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null,
+          "shape": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "H3_REFINE/%date:yy-MM-dd-hh-mm%_h3refine",
+        "format": "video/nvenc_h264-mp4",
+        "pix_fmt": "yuv420p",
+        "bitrate": 10,
+        "megabit": true,
+        "save_metadata": true,
+        "pingpong": false,
+        "save_output": true
+      },
+      "title": "8. 저장 (24fps 고정 — H3 네이티브)",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 11,
+      "type": "PreviewAny",
+      "pos": [
+        1440,
+        900
+      ],
+      "size": [
+        460,
+        200
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 13
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      },
+      "widgets_values": [],
+      "title": "리파인 리포트 (시작 σ / MoE 판정 / 정렬 로그)"
+    },
+    {
+      "id": 12,
+      "type": "WanH3FrameGrid_Dolphin",
+      "pos": [
+        960,
+        40
+      ],
+      "size": [
+        430,
+        110
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "length",
+          "type": "INT",
+          "links": [],
+          "slot_index": 0
+        },
+        {
+          "name": "seconds",
+          "type": "FLOAT",
+          "links": [],
+          "slot_index": 1
+        },
+        {
+          "name": "info",
+          "type": "STRING",
+          "links": [
+            14
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "WanH3FrameGrid_Dolphin"
+      },
+      "widgets_values": [
+        5.9,
+        "wan_compatible"
+      ],
+      "title": "H3 length 계산기 (실행 전 여기서 값부터 확인)",
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 13,
+      "type": "PreviewAny",
+      "pos": [
+        960,
+        190
+      ],
+      "size": [
+        430,
+        80
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 14
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      },
+      "widgets_values": [],
+      "title": "→ 이 length를 H3 노드에 넣어라"
+    },
+    {
+      "id": 14,
+      "type": "Note",
+      "pos": [
+        480,
+        40
+      ],
+      "size": [
+        440,
+        560
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "H3 → Wan 2.2 리파인 패스\n\n■ 실행 순서\n1) 노드 12(계산기)만 먼저 돌려서 length 확인 → H3 생성 때 그 값을 쓴다.\n   두 그리드가 겹치는 값: 5 / 73 / 141 / 209 / 277 / 345\n   H3 기본 124는 Wan에서 불법이라 121로 잘리고, 그만큼 오디오 싱크가 밀린다.\n2) 노드 1에 H3 출력 mp4 경로를 넣는다. force_rate는 반드시 0\n   (24fps 원본을 그대로 읽어야 한다).\n3) 노드 3에 캐릭터 LoRA를 지정하고 Ctrl+B로 bypass 해제.\n   이게 이 파이프라인의 핵심 이득이다 — H3엔 못 거는 LoRA를 여기서 건다.\n4) 노드 6에 H3 프롬프트 + LoRA 트리거를 붙여넣는다.\n\n■ 왜 LOW noise만 로드하나\ndenoise 0.30 / shift 3.0이면 시작 σ가 0.562라서 MoE 경계(0.9)를 안 넘는다.\nHIGH expert는 호출 자체가 안 되므로 로드할 이유가 없다.\nshift=5면 denoise 0.62까지, shift=3이면 0.75까지 LOW 단독 구간이다.\n노드 7의 info 출력이 매 실행마다 이 판정을 찍어준다."
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 15,
+      "type": "Note",
+      "pos": [
+        480,
+        1050
+      ],
+      "size": [
+        440,
+        560
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "■ 튜닝 순서 (한 번에 하나씩)\n\n1차 A/B — denoise 0.20 / 0.30 / 0.40\n  Wan은 16fps 기준으로 학습돼서 24fps 소스를 '덜 움직이는 영상'으로 읽는다.\n  올릴수록 모션을 죽이는 방향이므로 모션이 뭉개지기 시작하는 지점이 상한선.\n  보통 0.35 근처.\n\n2차 A/B — 캐릭터 LoRA 강도 0.6 / 1.0 / 1.3\n\n■ 건드리지 말 것\n· steps=6은 '실제로 도는 스텝 수'다. denoise가 낮다고 3배로 올리지 말 것\n  (스케줄 총 길이가 steps/denoise로 자동으로 늘어난다).\n· sigma_shift는 생성용 5가 아니라 2~3. 리파인은 저시그마를 촘촘히 밟아야\n  하는데 shift가 크면 스텝이 고시그마로 쏠린다.\n· cfg는 증류(lightning/lightx2v) LoRA를 걸었으면 1.0, 뺐으면 2.5~3.5.\n  리파인 패스엔 증류 LoRA를 아예 안 거는 걸 권장 — 궤적 끝 30%만 밟는\n  상황과 전체 궤적 기준 증류가 안 맞는다.\n· upscale_by는 1.3까지. 큰 업스케일은 SeedVR2/Topaz로 따로.\n\n■ 이 패스로 못 고치는 것\n· 작은 얼굴 붕괴 → ComfyUI-H3-FaceRefine (크롭해서 H3로 재생성)\n· 대사 샷 립싱크 → denoise 0.2 이하로 묶거나 아예 리파인 제외\n· 해상도 증가 → 이 패스 다음에 SeedVR2/Topaz"
+      ],
+      "color": "#432",
+      "bgcolor": "#653"
+    }
+  ],
+  "links": [
+    [
+      1,
+      2,
+      0,
+      3,
+      0,
+      "MODEL"
+    ],
+    [
+      2,
+      3,
+      0,
+      4,
+      0,
+      "MODEL"
+    ],
+    [
+      3,
+      4,
+      0,
+      9,
+      0,
+      "MODEL"
+    ],
+    [
+      4,
+      5,
+      0,
+      6,
+      0,
+      "CLIP"
+    ],
+    [
+      5,
+      5,
+      0,
+      7,
+      0,
+      "CLIP"
+    ],
+    [
+      6,
+      6,
+      0,
+      9,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      7,
+      7,
+      0,
+      9,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      8,
+      8,
+      0,
+      9,
+      3,
+      "VAE"
+    ],
+    [
+      9,
+      1,
+      0,
+      9,
+      4,
+      "IMAGE"
+    ],
+    [
+      10,
+      1,
+      2,
+      9,
+      5,
+      "AUDIO"
+    ],
+    [
+      11,
+      9,
+      0,
+      10,
+      0,
+      "IMAGE"
+    ],
+    [
+      12,
+      9,
+      1,
+      10,
+      1,
+      "AUDIO"
+    ],
+    [
+      13,
+      9,
+      5,
+      11,
+      0,
+      "STRING"
+    ],
+    [
+      14,
+      12,
+      2,
+      13,
+      0,
+      "STRING"
+    ]
+  ],
+  "groups": [
+    {
+      "id": 1,
+      "title": "모델 체인 (LOW noise 단독)",
+      "bounding": [
+        20,
+        -20,
+        440,
+        570
+      ],
+      "color": "#3f789e",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "id": 2,
+      "title": "리파인",
+      "bounding": [
+        940,
+        260,
+        470,
+        500
+      ],
+      "color": "#a1309b",
+      "font_size": 24,
+      "flags": {}
+    }
+  ],
+  "definitions": {
+    "subgraphs": []
+  },
+  "config": {},
+  "extra": {
+    "frontendVersion": "1.48.7",
+    "ds": {
+      "scale": 0.6,
+      "offset": [
+        100,
+        100
+      ]
+    }
+  },
+  "version": 0.4
+}

lora_profile.py

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+"""
+로라 파일 하나를 "LLM에게 설명할 수 있는 프로필"로 변환한다.
+
+기존 `get_triggers()`(dolphin_vision_director.py)는 트리거 '단어'만 뽑아서
+캐릭터 이름 옆에 콤마로 나열하는 용도였다. 그 방식은 문법적 맥락이 없어서
+`bounce`/`swing` 같은 범용 동작 동사가 전신 모션으로 새는 문제가 있었고,
+대응으로 그런 단어를 아예 제외하는 필터(_filter_generic_motion_verbs)를
+넣어둔 상태다 - 로라가 의도한 효과까지 같이 사라지는 우회책이다.
+
+이 모듈은 다른 방향으로 접근한다: 트리거를 '나중에 덧붙일 토큰'이 아니라
+'프롬프트를 쓰기 전에 LLM에게 줄 재료'로 본다. LoRA Manager가 파일 옆에
+만들어두는 `<이름>.metadata.json` 사이드카에 이미 다음이 다 들어있다.
+
+  - model_name / civitai.model.name : 이 로라의 이름
+  - modelDescription               : 자연어 설명(HTML)
+  - tags / civitai.model.tags      : 분류 태그
+  - civitai.trainedWords           : 학습 트리거. 단어인 경우도 있지만
+                                     상당수는 학습 캡션 문장 그대로다
+                                     (예: "She pulls down her pants revealing a penis.")
+  - base_model                     : Wan 2.1/2.2, i2v/t2v 구분
+
+로라는 학습 캡션 분포와 닮은 프롬프트에서 가장 잘 발화하므로, 이 재료를
+LLM에 먼저 주면 트리거를 문장 안에 문법적으로 녹인 프롬프트를 쓸 수 있다.
+
+trainedWords 3분류 (`classify_trained_words` 참고):
+  hard  : 공백 없고 숫자나 대문자가 섞인 학습 식별자. LLM이 "고쳐주면"
+          로라가 안 걸리므로 원문 그대로 나와야 한다 (예: `4n4lfi5tin6`,
+          `PENISLORA`). 출력 검증 대상.
+  soft  : 공백 없는 평범한 소문자 영단어 (예: `bounce`, `penis`).
+          강제하지 않는다 - 강제 삽입이 바로 예전 버그의 원인이었다.
+          문맥에 맞을 때 몸 부위에 붙여 쓰라고 '권고'만 한다.
+  caption: 공백이 있는 구/문장. 학습 캡션 예시로만 준다(문체 참고용).
+"""
+import json
+import os
+import re
+
+_HTML_TAG_RE = re.compile(r"<[^>]+>")
+_WS_RE = re.compile(r"\s+")
+
+# 세션 내 프로필 캐시. 키는 로라 파일의 (경로, size, mtime).
+_PROFILE_CACHE = {}
+
+# LLM 컨텍스트를 잡아먹지 않도록 설명은 잘라서 준다. 로라 설명문은 보통
+# 앞부분에 "무엇을 하는 로라인지"가 있고 뒤는 학습 설정/후원 링크다.
+MAX_DESC_CHARS = 400
+MAX_CAPTION_EXAMPLES = 2
+
+
+def _strip_html(s):
+    if not s:
+        return ""
+    s = re.sub(r"<br\s*/?>", " ", s, flags=re.IGNORECASE)
+    s = re.sub(r"</p>", " ", s, flags=re.IGNORECASE)
+    s = _HTML_TAG_RE.sub("", s)
+    s = (s.replace("&nbsp;", " ").replace("&amp;", "&")
+          .replace("&lt;", "<").replace("&gt;", ">").replace("&quot;", '"'))
+    return _WS_RE.sub(" ", s).strip()
+
+
+def _truncate(s, limit):
+    if not s or len(s) <= limit:
+        return s
+    cut = s[:limit]
+    # 문장 중간에서 자르지 않도록 마지막 문장부호까지만.
+    for sep in (". ", "! ", "? "):
+        idx = cut.rfind(sep)
+        if idx > limit * 0.5:
+            return cut[:idx + 1]
+    return cut.rstrip() + "..."
+
+
+def is_hard_token(word):
+    """LLM이 철자를 바꾸면 안 되는 학습 식별자인가.
+
+    공백이 없고(=단일 토큰) 숫자나 대문자가 섞여있으면 학습 식별자로 본다.
+    `4n4lfi5tin6`, `PENISLORA`, `az420` -> True
+    `bounce`, `penis`, `swing`          -> False (평범한 소문자 영단어)
+    """
+    w = word.strip()
+    if not w or _WS_RE.search(w):
+        return False
+    return any(c.isdigit() for c in w) or any(c.isupper() for c in w)
+
+
+def classify_trained_words(words):
+    """trainedWords 리스트를 (hard, soft, captions)로 나눈다."""
+    hard, soft, captions = [], [], []
+    for raw in words or []:
+        w = str(raw).strip().strip(",")
+        if not w:
+            continue
+        if _WS_RE.search(w):
+            captions.append(w)
+        elif is_hard_token(w):
+            hard.append(w)
+        else:
+            soft.append(w)
+    # 순서 유지 중복 제거
+    return (list(dict.fromkeys(hard)), list(dict.fromkeys(soft)),
+            list(dict.fromkeys(captions)))
+
+
+def _sidecar_path(lora_path):
+    """LoRA Manager가 만드는 `<확장자 뗀 이름>.metadata.json`."""
+    return os.path.splitext(lora_path)[0] + ".metadata.json"
+
+
+def _read_sidecar(lora_path):
+    p = _sidecar_path(lora_path)
+    if not os.path.exists(p):
+        return None
+    try:
+        with open(p, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (OSError, ValueError, json.JSONDecodeError) as e:
+        print(f"⚠️ [LoraProfile] 사이드카 파싱 실패({os.path.basename(p)}): "
+              f"{type(e).__name__}: {e}")
+        return None
+
+
+def _resolve_lora_path(lora_name):
+    try:
+        import folder_paths
+        return folder_paths.get_full_path("loras", lora_name)
+    except Exception:
+        return lora_name if os.path.exists(lora_name) else None
+
+
+def build_profile_from_sidecar(data, lora_name, lora_path):
+    """사이드카 dict -> 프로필 dict. 사이드카가 없으면 호출하지 않는다."""
+    civitai = data.get("civitai") or {}
+    model = civitai.get("model") or {}
+
+    name = (data.get("model_name") or model.get("name")
+            or os.path.splitext(os.path.basename(lora_name))[0])
+    desc = _strip_html(data.get("modelDescription") or model.get("description") or "")
+    tags = data.get("tags") or model.get("tags") or []
+    if not isinstance(tags, list):
+        tags = []
+    trained = civitai.get("trainedWords") or []
+    if not isinstance(trained, list):
+        trained = [trained]
+    hard, soft, captions = classify_trained_words(trained)
+
+    return {
+        "lora_name": lora_name,
+        "file": os.path.basename(lora_name),
+        "display_name": str(name).strip(),
+        "description": _truncate(desc, MAX_DESC_CHARS),
+        "tags": [str(t).strip() for t in tags if str(t).strip()],
+        "base_model": str(data.get("base_model") or civitai.get("baseModel") or "").strip(),
+        "hard_tokens": hard,
+        "soft_words": soft,
+        "captions": captions[:MAX_CAPTION_EXAMPLES],
+        "source": "sidecar",
+    }
+
+
+def load_profile(lora_name, fallback_triggers=None):
+    """로라 이름(ComfyUI 상대경로) -> 프로필 dict. 실패 시 None.
+
+    사이드카가 없으면 `fallback_triggers`(기존 get_triggers 경로의 결과)로
+    최소 프로필이라도 만든다 - 개인 학습 로라처럼 civitai에 없는 경우.
+
+    `fallback_triggers`는 리스트 또는 "호출하면 리스트를 주는 함수"를 받는다.
+    기존 조회 경로는 sha256 해시(수 GB 파일) + 네트워크 호출까지 할 수 있어서,
+    사이드카가 있는 99.5%의 경우엔 아예 호출되지 않도록 지연 평가한다.
+    """
+    if not lora_name or lora_name == "None":
+        return None
+
+    path = _resolve_lora_path(lora_name)
+    cache_key = lora_name
+    if path and os.path.exists(path):
+        try:
+            st = os.stat(path)
+            cache_key = f"{lora_name}::{st.st_size}::{int(st.st_mtime)}"
+        except OSError:
+            pass
+    if cache_key in _PROFILE_CACHE:
+        return _PROFILE_CACHE[cache_key]
+
+    profile = None
+    if path:
+        data = _read_sidecar(path)
+        if data:
+            profile = build_profile_from_sidecar(data, lora_name, path)
+
+    if profile is None:
+        # 사이드카 없음 - 기존 트리거 조회 결과로 최소 프로필.
+        fb = fallback_triggers() if callable(fallback_triggers) else fallback_triggers
+        hard, soft, captions = classify_trained_words(fb or [])
+        if not (hard or soft or captions):
+            return None
+        profile = {
+            "lora_name": lora_name,
+            "file": os.path.basename(lora_name),
+            "display_name": os.path.splitext(os.path.basename(lora_name))[0],
+            "description": "",
+            "tags": [],
+            "base_model": "",
+            "hard_tokens": hard,
+            "soft_words": soft,
+            "captions": captions[:MAX_CAPTION_EXAMPLES],
+            "source": "triggers-only",
+        }
+
+    _PROFILE_CACHE[cache_key] = profile
+    return profile
+
+
+def format_profiles_for_llm(profiles, indent="  "):
+    """프로필 목록 -> LLM 프롬프트에 넣을 텍스트 블록.
+
+    한 로라당 4줄 이내로 압축한다. 로라가 4개까지 걸릴 수 있고 클립도 4개라
+    장황하면 시스템 프롬프트의 다른 규칙이 묻힌다.
+    """
+    if not profiles:
+        return ""
+    lines = []
+    for p in profiles:
+        head = f"{indent}- {p['display_name']}"
+        if p.get("tags"):
+            head += f"  [tags: {', '.join(p['tags'][:5])}]"
+        lines.append(head)
+        if p.get("description"):
+            lines.append(f"{indent}  what it does: {p['description']}")
+        if p.get("hard_tokens"):
+            lines.append(f"{indent}  MUST APPEAR VERBATIM: "
+                         + ", ".join(f'"{t}"' for t in p["hard_tokens"]))
+        if p.get("soft_words"):
+            lines.append(f"{indent}  vocabulary it was trained on (use only where it "
+                         f"genuinely fits, anchored to the body part): "
+                         + ", ".join(p["soft_words"]))
+        for cap in p.get("captions", []):
+            lines.append(f'{indent}  training caption example: "{cap}"')
+    return "\n".join(lines)
+
+
+def collect_hard_tokens(profiles):
+    out = []
+    for p in profiles or []:
+        out.extend(p.get("hard_tokens") or [])
+    return list(dict.fromkeys(out))
+
+
+def missing_hard_tokens(text, profiles):
+    """생성된 프롬프트에 빠진 hard token 목록.
+
+    LLM은 `4n4lfi5tin6` 같은 토큰을 "정상 철자로 고쳐주는" 경향이 있어서
+    (그 순간 로라가 안 걸린다) 대소문자 무시하고 존재만 확인한다.
+    """
+    low = (text or "").lower()
+    return [t for t in collect_hard_tokens(profiles) if t.lower() not in low]
+
+
+if __name__ == "__main__":
+    # 실제 로라 폴더에 대고 돌려보는 자체 점검.
+    import glob
+    import sys
+
+    # ComfyUI 콘솔은 UTF-8이지만 맨손으로 돌릴 땐 cp949라 이모지 print가 죽는다.
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except (AttributeError, OSError):
+        pass
+
+    root = sys.argv[1] if len(sys.argv) > 1 else "."
+    files = sorted(glob.glob(os.path.join(root, "*.safetensors")))
+    print(f"safetensors {len(files)}개 검사\n")
+    stats = {"sidecar": 0, "none": 0, "hard": 0, "soft": 0, "caption": 0, "desc": 0}
+    samples = []
+    for f in files:
+        data = _read_sidecar(f)
+        if not data:
+            stats["none"] += 1
+            continue
+        p = build_profile_from_sidecar(data, os.path.basename(f), f)
+        stats["sidecar"] += 1
+        if p["hard_tokens"]:
+            stats["hard"] += 1
+        if p["soft_words"]:
+            stats["soft"] += 1
+        if p["captions"]:
+            stats["caption"] += 1
+        if p["description"]:
+            stats["desc"] += 1
+        if p["hard_tokens"] and len(samples) < 5:
+            samples.append(p)
+    print(f"사이드카 있음: {stats['sidecar']} / 없음: {stats['none']}")
+    print(f"  설명 있음:        {stats['desc']}")
+    print(f"  hard token 있음:  {stats['hard']}")
+    print(f"  soft word 있음:   {stats['soft']}")
+    print(f"  caption 예시 있음: {stats['caption']}\n")
+    for p in samples:
+        print("=" * 60)
+        print(format_profiles_for_llm([p]))

mask_region_color_match.py

@@ -0,0 +1,103 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+class MaskRegionColorMatch_Dolphin:
+    """Color-matches the pixels inside the mask against the pixels in a
+    ring immediately outside the mask, using only those two pixel sets
+    (never a rectangular crop that mixes correct and incorrect pixels).
+    Mixing dilutes the statistical difference the transfer function sees;
+    comparing pure "already correct" vs pure "actually wrong" pixels gives
+    the strongest possible correction signal."""
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "original_image": ("IMAGE", {"tooltip": "Reference image (same size as generated_image)."}),
+                "generated_image": ("IMAGE", {"tooltip": "Image to color-correct (same size as original_image)."}),
+                "mask": ("MASK", {"tooltip": "Inpainted region mask (same size as the images)."}),
+                "method": (["hm", "mkl", "reinhard", "mvgd", "hm-mvgd-hm", "hm-mkl-hm"], {"default": "hm", "tooltip": "hm (histogram matching) is numerically stable for small pixel counts. mkl/mvgd need a matrix square root and can go complex/unstable on small or low-variance regions."}),
+                "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step": 0.05}),
+                "ring_width": ("INT", {"default": 60, "min": 4, "max": 512, "step": 2, "tooltip": "Thickness in pixels of the original-image ring just outside the mask used as the color reference."}),
+                "edge_feather": ("INT", {"default": 40, "min": 0, "max": 512, "step": 2, "tooltip": "Fades the correction from 0 at the mask boundary up to full strength this many pixels inside the mask, so there's no color cliff for MaskBlend to reveal as a ring."}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "match"
+    CATEGORY = "image/postprocessing"
+
+    def match(self, original_image, generated_image, mask, method, strength, ring_width, edge_feather):
+        if strength == 0:
+            return (generated_image,)
+
+        try:
+            from color_matcher import ColorMatcher
+        except ImportError as e:
+            raise ImportError("Can't import color-matcher, install with: pip install color-matcher") from e
+
+        out = generated_image.clone()
+        batch = generated_image.shape[0]
+        cm = ColorMatcher()
+        kernel_size = ring_width * 2 + 1
+
+        for i in range(batch):
+            m = mask[min(i, mask.shape[0] - 1)]
+            m_bin = (m > 0.5).float()
+            if m_bin.max() <= 0:
+                continue
+
+            dilated = F.max_pool2d(m_bin.unsqueeze(0).unsqueeze(0), kernel_size=kernel_size, stride=1, padding=ring_width)
+            dilated = (dilated.squeeze(0).squeeze(0) > 0.5)
+            interior = m_bin > 0.5
+            ring = dilated & (~interior)
+
+            if ring.sum().item() < 10:
+                ring = ~interior
+
+            ref_pixels = original_image[i][ring].cpu().numpy()
+            target_pixels = generated_image[i][interior].cpu().numpy()
+            if target_pixels.shape[0] == 0 or ref_pixels.shape[0] == 0:
+                continue
+
+            # Per-pixel correction weight: 0 right at the mask boundary,
+            # ramping up to 1 over edge_feather px toward the mask interior.
+            # Without this, the correction is uniform inside the mask and
+            # MaskBlend's outer feather ends up revealing the resulting
+            # color jump as a visible ring instead of hiding it.
+            if edge_feather > 0:
+                k = edge_feather * 2 + 1
+                falloff = F.avg_pool2d(m_bin.unsqueeze(0).unsqueeze(0), kernel_size=k, stride=1, padding=edge_feather)
+                falloff = falloff.squeeze(0).squeeze(0).clamp(0, 1)
+                alpha = falloff[interior].numpy()[:, None]
+            else:
+                alpha = 1.0
+
+            try:
+                result = cm.transfer(src=target_pixels[:, None, :], ref=ref_pixels[:, None, :], method=method)
+                result = result[:, 0, :]
+                if np.iscomplexobj(result):
+                    # mkl/mvgd take a matrix square root; on small or low-variance
+                    # pixel sets this can go complex. The imaginary part is
+                    # numerical noise here, so drop it rather than silently
+                    # discarding the whole correction.
+                    result = result.real
+                result = np.nan_to_num(result, nan=0.0, posinf=1.0, neginf=0.0)
+                result = target_pixels + (strength * alpha) * (result - target_pixels)
+                result_t = torch.from_numpy(result).clamp(0, 1).to(out.dtype)
+                out[i][interior] = result_t
+            except Exception as e:
+                print(f"[MaskRegionColorMatch_Dolphin] batch {i} failed, leaving uncorrected: {e}")
+
+        return (out,)
+
+
+NODE_CLASS_MAPPINGS = {
+    "MaskRegionColorMatch_Dolphin": MaskRegionColorMatch_Dolphin,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MaskRegionColorMatch_Dolphin": "🐬 Mask-Region Color Match (Dolphin)",
+}

match_size.py

@@ -0,0 +1,47 @@
+import torch
+import torch.nn.functional as F
+
+
+class MatchImageAndMaskSize_Dolphin:
+    """Resizes an image and a mask to exactly match a reference image's
+    runtime pixel size. Reads reference.shape directly at execution time,
+    so it can't drift out of sync the way two separately-wired
+    GetImageSize -> width/height links can."""
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image_to_resize": ("IMAGE", {"tooltip": "Image that will be resized to match the reference."}),
+                "mask_to_resize": ("MASK", {"tooltip": "Mask that will be resized to match the reference."}),
+                "reference_image": ("IMAGE", {"tooltip": "Image whose size image_to_resize and mask_to_resize will be matched to."}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("image", "mask")
+    FUNCTION = "match"
+    CATEGORY = "image/postprocessing"
+
+    def match(self, image_to_resize, mask_to_resize, reference_image):
+        target_h = reference_image.shape[1]
+        target_w = reference_image.shape[2]
+
+        img = image_to_resize.movedim(-1, 1)
+        img = F.interpolate(img, size=(target_h, target_w), mode="bicubic", antialias=True)
+        img = img.clamp(0, 1).movedim(1, -1)
+
+        mask = mask_to_resize
+        if mask.ndim == 2:
+            mask = mask.unsqueeze(0)
+        mask = F.interpolate(mask.unsqueeze(1), size=(target_h, target_w), mode="nearest-exact").squeeze(1)
+
+        return (img, mask)
+
+
+NODE_CLASS_MAPPINGS = {
+    "MatchImageAndMaskSize_Dolphin": MatchImageAndMaskSize_Dolphin,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MatchImageAndMaskSize_Dolphin": "🐬 Match Image & Mask Size (Dolphin)",
+}