Upload 12 files

LICENSE

@@ -22,5 +22,4 @@
 # GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
- ---
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.

NOTICE.md

@@ -0,0 +1,76 @@
+# NOTICE
+
+Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved.
+
+---
+
+## Aviso de Propriedade Intelectual e Licenciamento
+
+### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
+
+O método e o sistema de orquestração de prompts denominados **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste documento e implementados neste software, estão atualmente em processo de patenteamento.
+
+O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, incluindo, mas não se limitando a:
+
+*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
+*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
+*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
+*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
+*   O uso de "tokens universais" para comunicação agnóstica a modelos.
+
+### **Reconhecimento e Implicações (EM PORTUGUÊS):**
+
+Ao acessar ou utilizar este software e a arquitetura ADUC aqui implementada, você reconhece:
+
+1.  A natureza inovadora e a importância da arquitetura ADUC no campo da orquestração de prompts para IA.
+2.  Que a essência desta arquitetura, ou suas implementações derivadas, podem estar sujeitas a direitos de propriedade intelectual, incluindo patentes.
+3.  Que o uso comercial, a reprodução da lógica central da ADUC em sistemas independentes, ou a exploração direta da invenção sem o devido licenciamento podem infringir os direitos de patente pendente.
+
+---
+
+### **Patent Pending (IN ENGLISH):**
+
+The method and system for prompt orchestration named **ADUC (Automated Discovery and Orchestration of Complex tasks)**, as described herein and implemented in this software, are currently in the process of being patented.
+
+The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
+
+*   Fragmentation and scaling of requests exceeding AI model context limits.
+*   Intelligent distribution of sub-tasks to heterogeneous specialists.
+*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
+*   Cost, latency, and quality-aware planning and routing.
+*   The use of "universal tokens" for model-agnostic communication.
+
+### **Acknowledgement and Implications (IN ENGLISH):**
+
+By accessing or using this software and the ADUC architecture implemented herein, you acknowledge:
+
+1.  The innovative nature and significance of the ADUC architecture in the field of AI prompt orchestration.
+2.  That the essence of this architecture, or its derivative implementations, may be subject to intellectual property rights, including patents.
+3.  That commercial use, reproduction of ADUC's core logic in independent systems, or direct exploitation of the invention without proper licensing may infringe upon pending patent rights.
+
+---
+
+## Licença AGPLv3
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+---
+
+**Contato para Consultas:**
+
+Para mais informações sobre a arquitetura ADUC, o status do patenteamento, ou para discutir licenciamento para usos comerciais ou não conformes com a AGPLv3, por favor, entre em contato:
+
+Carlos Rodrigues dos Santos
+[email protected]
+Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025

README.md

@@ -1,17 +1,19 @@
 ---
 title: Euia-AducSdr
-emoji: 🎬
+emoji: 🎥
 colorFrom: indigo
 colorTo: purple
 sdk: gradio
 sdk_version: 5.42.0
 app_file: app.py
-pinned: false
+pinned: true
+license: agpl-3.0
+short_description: Uma implementação aberta e funcional da arquitetura ADUC-SDR
 ---
 
 ### 🇧🇷 Português
 
-Uma implementação aberta e funcional da arquitetura ADUC-SDR (Arquitetura de Unificação Compositiva - Escala Dinâmica e Resiliente), projetada para a geração de vídeo coerente de longa duração. Este projeto materializa os princípios de fragmentação, navegação geométrica e um mecanismo de "eco causal" para garantir a continuidade física e narrativa em sequências de vídeo geradas por múltiplos modelos de IA.
+Uma implementação aberta e funcional da arquitetura ADUC-SDR (Arquitetura de Unificação Compositiva - Escala Dinâmica e Resiliente), projetada para a geração de vídeo coerente de longa duração. Este projeto materializa os princípios de fragmentação, navegação geométrica e um mecanismo de "eco causal 4bits memoria" para garantir a continuidade física e narrativa em sequências de vídeo geradas por múltiplos modelos de IA.
 
 **Licença:** Este projeto é licenciado sob os termos da **GNU Affero General Public License v3.0**. Isto significa que se você usar este software (ou qualquer trabalho derivado) para fornecer um serviço através de uma rede, você é **obrigado a disponibilizar o código-fonte completo** da sua versão para os usuários desse serviço.
 
@@ -22,7 +24,7 @@ Uma implementação aberta e funcional da arquitetura ADUC-SDR (Arquitetura de U
 
 ### 🇬🇧 English
 
-An open and functional implementation of the ADUC-SDR (Architecture for Compositive Unification - Dynamic and Resilient Scaling) architecture, designed for long-form coherent video generation. This project materializes the principles of fragmentation, geometric navigation, and a "causal echo" mechanism to ensure physical and narrative continuity in video sequences generated by multiple AI models.
+An open and functional implementation of the ADUC-SDR (Architecture for Compositive Unification - Dynamic and Resilient Scaling) architecture, designed for long-form coherent video generation. This project materializes the principles of fragmentation, geometric navigation, and a "causal echo 4bits memori" mechanism to ensure physical and narrative continuity in video sequences generated by multiple AI models.
 
 **License:** This project is licensed under the terms of the **GNU Affero General Public License v3.0**. This means that if you use this software (or any derivative work) to provide a service over a network, you are **required to make the complete source code** of your version available to the users of that service.
 
@@ -31,14 +33,169 @@ An open and functional implementation of the ADUC-SDR (Architecture for Composit
 
 ---
 
-### 🇪🇸 Español
+## **Aviso de Propriedade Intelectual e Patenteamento**
 
-Una implementación abierta y funcional de la arquitectura ADUC-SDR (Arquitectura de Unificación Compositiva - Escala Dinámica y Resiliente), diseñada para la generación de video coherente de larga duración. Este proyecto materializa los principios de fragmentación, navegación geométrica y un mecanismo de "eco causal" para garantizar la continuidad física y narrativa en secuencias de video generadas por múltiples modelos de IA.
+### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
 
-**Licencia:** Este proyecto está licenciado bajo los términos de la **Licencia Pública General Affero de GNU v3.0**. Esto significa que si usted utiliza este software (o cualquier obra derivada) para proporcionar un servicio a través de una red, está **obligado a ofrecer el código fuente completo** de su versión a los usuarios de dicho servicio.
+A arquitetura e o método **ADUC (Automated Discovery and Orchestration of Complex tasks)**, conforme descritos neste projeto e nas reivindicações associadas, estão **atualmente em processo de patenteamento**.
 
-- **Copyright (C) 4 de Agosto de 2025, Carlos Rodrigues dos Santos**
-- Puede encontrar una copia completa de la licencia en el archivo [LICENSE](LICENSE).
+O titular dos direitos, Carlos Rodrigues dos Santos, está buscando proteção legal para as inovações chave da arquitetura ADUC, que incluem, mas não se limitam a:
+
+*   Fragmentação e escalonamento de solicitações que excedem limites de contexto de modelos de IA.
+*   Distribuição inteligente de sub-tarefas para especialistas heterogêneos.
+*   Gerenciamento de estado persistido com avaliação iterativa e realimentação para o planejamento de próximas etapas.
+*   Planejamento e roteamento sensível a custo, latência e requisitos de qualidade.
+*   O uso de "tokens universais" para comunicação agnóstica a modelos.
+
+Ao utilizar este software e a arquitetura ADUC aqui implementada, você reconhece a natureza inovadora desta arquitetura e que a **reprodução ou exploração da lógica central da ADUC em sistemas independentes pode infringir direitos de patente pendente.**
+
+---
+
+### **Patent Pending (IN ENGLISH):**
+
+The **ADUC (Automated Discovery and Orchestration of Complex tasks)** architecture and method, as described in this project and its associated claims, are **currently in the process of being patented.**
+
+The rights holder, Carlos Rodrigues dos Santos, is seeking legal protection for the key innovations of the ADUC architecture, including, but not limited to:
+
+*   Fragmentation and scaling of requests exceeding AI model context limits.
+*   Intelligent distribution of sub-tasks to heterogeneous specialists.
+*   Persistent state management with iterative evaluation and feedback for planning subsequent steps.
+*   Cost, latency, and quality-aware planning and routing.
+*   The use of "universal tokens" for model-agnostic communication.
+
+By using this software and the ADUC architecture implemented herein, you acknowledge the innovative nature of this architecture and that **the reproduction or exploitation of ADUC's core logic in independent systems may infringe upon pending patent rights.**
+
+---
+
+### Detalhes Técnicos e Reivindicações da ADUC
+
+#### 🇧🇷 Definição Curta (para Tese e Patente)
+
+**ADUC** é um *framework pré-input* e *intermediário* de **gerenciamento de prompts** que:
+
+1.  **fragmenta** solicitações acima do limite de contexto de qualquer modelo,
+2.  **escala linearmente** (processo sequencial com memória persistida),
+3.  **distribui** sub-tarefas a **especialistas** (modelos/ferramentas heterogêneos), e
+4.  **realimenta** a próxima etapa com avaliação do que foi feito/esperado (LLM diretor).
+
+Não é um modelo; é uma **camada orquestradora** plugável antes do input de modelos existentes (texto, imagem, áudio, vídeo), usando *tokens universais* e a tecnologia atual.
+
+#### 🇬🇧 Short Definition (for Thesis and Patent)
+
+**ADUC** is a *pre-input* and *intermediate* **prompt management framework** that:
+
+1.  **fragments** requests exceeding any model's context limit,
+2.  **scales linearly** (sequential process with persisted memory),
+3.  **distributes** sub-tasks to **specialists** (heterogeneous models/tools), and
+4.  **feeds back** to the next step with an evaluation of what was done/expected (director LLM).
+
+It is not a model; it is a pluggable **orchestration layer** before the input of existing models (text, image, audio, video), using *universal tokens* and current technology.
+
+---
+
+#### 🇧🇷 Elementos Essenciais (Telegráfico)
+
+*   **Agnóstico a modelos:** opera com qualquer LLM/difusor/API.
+*   **Pré-input manager:** recebe pedido do usuário, **divide** em blocos ≤ limite de tokens, **prioriza**, **agenda** e **roteia**.
+*   **Memória persistida:** resultados/latentes/“eco” viram **estado compartilhado** para o próximo bloco (nada é ignorado).
+*   **Especialistas:** *routers* decidem quem faz o quê (ex.: “descrição → LLM-A”, “keyframe → Img-B”, “vídeo → Vid-C”).
+*   **Controle de qualidade:** LLM diretor compara *o que fez* × *o que deveria* × *o que falta* e **regenera objetivos** do próximo fragmento.
+*   **Custo/latência-aware:** planeja pela **VRAM/tempo/custo**, não tenta “abraçar tudo de uma vez”.
+
+#### 🇬🇧 Essential Elements (Telegraphic)
+
+*   **Model-agnostic:** operates with any LLM/diffuser/API.
+*   **Pre-input manager:** receives user request, **divides** into blocks ≤ token limit, **prioritizes**, **schedules**, and **routes**.
+*   **Persisted memory:** results/latents/“echo” become **shared state** for the next block (nothing is ignored).
+*   **Specialists:** *routers* decide who does what (e.g., “description → LLM-A”, “keyframe → Img-B”, “video → Vid-C”).
+*   **Quality control:** director LLM compares *what was done* × *what should be done* × *what is missing* and **regenerates objectives** for the next fragment.
+*   **Cost/latency-aware:** plans by **VRAM/time/cost**, does not try to “embrace everything at once”.
+
+---
+
+#### 🇧🇷 Reivindicações Independentes (Método e Sistema)
+
+**Reivindicação Independente (Método) — Versão Enxuta:**
+
+1.  **Método** de **orquestração de prompts** para execução de tarefas acima do limite de contexto de modelos de IA, compreendendo:
+    (a) **receber** uma solicitação que excede um limite de tokens;
+    (b) **analisar** a solicitação por um **LLM diretor** e **fragmentá-la** em sub-tarefas ≤ limite;
+    (c) **selecionar** especialistas de execução para cada sub-tarefa com base em capacidades declaradas;
+    (d) **gerar** prompts específicos por sub-tarefa em **tokens universais**, incluindo referências ao **estado persistido** de execuções anteriores;
+    (e) **executar sequencialmente** as sub-tarefas e **persistir** suas saídas como memória (incluindo latentes/eco/artefatos);
+    (f) **avaliar** automaticamente a saída versus metas declaradas e **regenerar objetivos** do próximo fragmento;
+    (g) **iterar** (b)–(f) até que os critérios de completude sejam atendidos, produzindo o resultado agregado;
+    em que o framework **escala linearmente** no tempo e armazenamento físico, **independente** da janela de contexto dos modelos subjacentes.
+
+**Reivindicação Independente (Sistema):**
+
+2.  **Sistema** de orquestração de prompts, compreendendo: um **planejador LLM diretor**; um **roteador de especialistas**; um **banco de estado persistido** (incl. memória cinética para vídeo); um **gerador de prompts universais**; e um **módulo de avaliação/realimentação**, acoplados por uma **API pré-input** a modelos heterogêneos.
+
+#### 🇬🇧 Independent Claims (Method and System)
+
+**Independent Claim (Method) — Concise Version:**
+
+1.  A **method** for **prompt orchestration** for executing tasks exceeding AI model context limits, comprising:
+    (a) **receiving** a request that exceeds a token limit;
+    (b) **analyzing** the request by a **director LLM** and **fragmenting it** into sub-tasks ≤ the limit;
+    (c) **selecting** execution specialists for each sub-task based on declared capabilities;
+    (d) **generating** specific prompts per sub-task in **universal tokens**, including references to the **persisted state** of previous executions;
+    (e) **sequentially executing** the sub-tasks and **persisting** their outputs as memory (including latents/echo/artifacts);
+    (f) **automatically evaluating** the output against declared goals and **regenerating objectives** for the next fragment;
+    (g) **iterating** (b)–(f) until completion criteria are met, producing the aggregated result;
+    wherein the framework **scales linearly** in time and physical storage, **independent** of the context window of the underlying models.
+
+**Independent Claim (System):**
+
+2.  A prompt orchestration **system**, comprising: a **director LLM planner**; a **specialist router**; a **persisted state bank** (incl. kinetic memory for video); a **universal prompt generator**; and an **evaluation/feedback module**, coupled via a **pre-input API** to heterogeneous models.
+
+---
+
+#### 🇧🇷 Dependentes Úteis
+
+*   (3) Onde o roteamento considera **custo/latência/VRAM** e metas de qualidade.
+*   (4) Onde o banco de estado inclui **eco cinético** para vídeo (últimos *n* frames/latentes/fluxo).
+*   (5) Onde a avaliação usa métricas específicas por domínio (Lflow, consistência semântica, etc.).
+*   (6) Onde *tokens universais* padronizam instruções entre especialistas.
+*   (7) Onde a orquestração decide **cut vs continuous** e **corte regenerativo** (Déjà-Vu) ao editar vídeo.
+*   (8) Onde o sistema **nunca descarta** conteúdo excedente: **reagenda** em novos fragmentos.
+
+#### 🇬🇧 Useful Dependents
+
+*   (3) Wherein routing considers **cost/latency/VRAM** and quality goals.
+*   (4) Wherein the state bank includes **kinetic echo** for video (last *n* frames/latents/flow).
+*   (5) Wherein evaluation uses domain-specific metrics (Lflow, semantic consistency, etc.).
+*   (6) Wherein *universal tokens* standardize instructions between specialists.
+*   (7) Wherein orchestration decides **cut vs continuous** and **regenerative cut** (Déjà-Vu) when editing video.
+*   (8) Wherein the system **never discards** excess content: it **reschedules** it in new fragments.
+
+---
+
+#### 🇧🇷 Como isso conversa com SDR (Vídeo)
+
+*   **Eco Cinético**: é um **tipo de estado persistido** consumido pelo próximo passo.
+*   **Déjà-Vu (Corte Regenerativo)**: é **uma política de orquestração** aplicada quando há edição; ADUC decide, monta os prompts certos e chama o especialista de vídeo.
+*   **Cut vs Continuous**: decisão do **diretor** com base em estado + metas; ADUC roteia e garante a sobreposição/remoção final.
+
+#### 🇬🇧 How this Converses with SDR (Video)
+
+*   **Kinetic Echo**: is a **type of persisted state** consumed by the next step.
+*   **Déjà-Vu (Regenerative Cut)**: is an **orchestration policy** applied during editing; ADUC decides, crafts the right prompts, and calls the video specialist.
+*   **Cut vs Continuous**: decision made by the **director** based on state + goals; ADUC routes and ensures the final overlap/removal.
+
+---
+
+#### 🇧🇷 Mensagem Clara ao Usuário (Experiência)
+
+> “Seu pedido excede o limite X do modelo Y. Em vez de truncar silenciosamente, o **ADUC** dividirá e **entregará 100%** do conteúdo por etapas coordenadas.”
+
+Isso é diferencial prático e jurídico: **não-obviedade** por transformar limite de contexto em **pipeline controlado**, com **persistência de estado** e **avaliação iterativa**.
+
+#### 🇬🇧 Clear User Message (Experience)
+
+> "Your request exceeds model Y's limit X. Instead of silently truncating, **ADUC** will divide and **deliver 100%** of the content through coordinated steps."
+
+This is a practical and legal differentiator: **non-obviousness** by transforming context limits into a **controlled pipeline**, with **state persistence** and **iterative evaluation**.
 
 ---
 
@@ -49,4 +206,6 @@ Una implementación abierta y funcional de la arquitectura ADUC-SDR (Arquitectur
 - **GitHub:** [https://github.com/carlex22/Aduc-sdr](https://github.com/carlex22/Aduc-sdr)
 - **Hugging Face Spaces:**
   - [Ltx-SuperTime-60Secondos](https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/)
-  - [Novinho](https://huggingface.co/spaces/Carlexxx/Novinho/)
+  - [Novinho](https://huggingface.co/spaces/Carlexxx/Novinho/)
+
+---

app.py

@@ -4,12 +4,11 @@
 # Contato:
 # Carlos Rodrigues dos Santos
 # [email protected]
-# Rua Eduardo Carlos Pereira, 4125, B1 Ap32, Curitiba, PR, Brazil, CEP 8102025
 #
 # Repositórios e Projetos Relacionados:
 # GitHub: https://github.com/carlex22/Aduc-sdr
-# Hugging Face: https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/
-# Hugging Face: https://huggingface.co/spaces/Carlexxx/Novinho/
+# YouTube (Resultados): https://m.youtube.com/channel/UC3EgoJi_Fv7yuDpvfYNtoIQ
+# Hugging Face: https://huggingface.co/spaces/Carlexx/ADUC-Sdr_Gemini_Drem0_Ltx_Video60seconds/
 #
 # Este programa é software livre: você pode redistribuí-lo e/ou modificá-lo
 # sob os termos da Licença Pública Geral Affero da GNU como publicada pela
@@ -24,65 +23,238 @@
 # Você deve ter recebido uma cópia da Licença Pública Geral Affero da GNU
 # junto com este programa. Se não, veja <https://www.gnu.org/licenses/>.
 
-# --- app_gpu.py (NOVINHO-6.1: Eco + Déjà Vu para HF Spaces) ---
+# --- app.py (ADUC-SDR-2.9: Diretor de Cena com Prompt Único e Extração) ---
 
-# --- Ato 1: A Convocação da Orquestra (Importações) ---
 import gradio as gr
 import torch
 import os
+import re
 import yaml
 from PIL import Image, ImageOps, ExifTags
 import shutil
-import gc
 import subprocess
 import google.generativeai as genai
 import numpy as np
 import imageio
 from pathlib import Path
-import huggingface_hub
 import json
 import time
-import spaces # Importação para o decorador de GPU do Hugging Face Spaces
+import math
 
-from inference import create_ltx_video_pipeline, load_image_to_tensor_with_resize_and_crop, ConditioningItem, calculate_padding
-from dreamo_helpers import dreamo_generator_singleton
+os.environ["TOKENIZERS_PARALLELISM"] = "false" 
 
-# --- Ato 2: A Preparação do Palco (Configurações) ---
-config_file_path = "configs/ltxv-13b-0.9.8-distilled.yaml"
-with open(config_file_path, "r") as file: PIPELINE_CONFIG_YAML = yaml.safe_load(file)
+from flux_kontext_helpers import flux_kontext_singleton
+from ltx_manager_helpers import ltx_manager_singleton
 
-LTX_REPO = "Lightricks/LTX-Video"
-models_dir = "downloaded_models_gradio"
-Path(models_dir).mkdir(parents=True, exist_ok=True)
 WORKSPACE_DIR = "aduc_workspace"
 GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
 
-VIDEO_FPS = 24
-TARGET_RESOLUTION = 420
-
-print("Criando pipelines LTX na CPU (estado de repouso)...")
-distilled_model_actual_path = huggingface_hub.hf_hub_download(repo_id=LTX_REPO, filename=PIPELINE_CONFIG_YAML["checkpoint_path"], local_dir=models_dir, local_dir_use_symlinks=False)
-pipeline_instance = create_ltx_video_pipeline(
-    ckpt_path=distilled_model_actual_path,
-    precision=PIPELINE_CONFIG_YAML["precision"],
-    text_encoder_model_name_or_path=PIPELINE_CONFIG_YAML["text_encoder_model_name_or_path"],
-    sampler=PIPELINE_CONFIG_YAML["sampler"],
-    device='cpu' # Os modelos iniciam na CPU para economizar recursos
-)
-print("Modelos LTX prontos (na CPU).")
+# ======================================================================================
+# SEÇÃO 1: FUNÇÕES UTILITÁRIAS E DE PROCESSAMENTO DE MÍDIA
+# ======================================================================================
 
+def robust_json_parser(raw_text: str) -> dict:
+    """
+    Analisa uma string de texto bruto para encontrar e decodificar o primeiro objeto JSON válido.
+    É essencial para extrair respostas estruturadas de modelos de linguagem.
 
-# --- Ato 3: As Partituras dos Músicos (Funções de Geração e Análise) ---
+    Args:
+        raw_text (str): A string completa retornada pela IA.
 
-def robust_json_parser(raw_text: str) -> dict:
+    Returns:
+        dict: Um dicionário Python representando o objeto JSON.
+    
+    Raises:
+        ValueError: Se nenhum objeto JSON válido for encontrado ou a decodificação falhar.
+    """
+    clean_text = raw_text.strip()
     try:
-        start_index = raw_text.find('{'); end_index = raw_text.rfind('}')
+        start_index = clean_text.find('{'); end_index = clean_text.rfind('}')
         if start_index != -1 and end_index != -1 and end_index > start_index:
-            json_str = raw_text[start_index : end_index + 1]; return json.loads(json_str)
+            json_str = clean_text[start_index : end_index + 1]
+            return json.loads(json_str)
         else: raise ValueError("Nenhum objeto JSON válido encontrado na resposta da IA.")
     except json.JSONDecodeError as e: raise ValueError(f"Falha ao decodificar JSON: {e}")
 
+def process_image_to_square(image_path: str, size: int, output_filename: str = None) -> str:
+    """
+    Processa uma imagem para um formato quadrado, redimensionando e cortando centralmente.
+
+    Args:
+        image_path (str): Caminho para a imagem de entrada.
+        size (int): A dimensão (altura e largura) da imagem de saída.
+        output_filename (str, optional): Nome do arquivo de saída.
+
+    Returns:
+        str: O caminho para a imagem processada.
+    """
+    if not image_path: return None
+    try:
+        img = Image.open(image_path).convert("RGB")
+        img_square = ImageOps.fit(img, (size, size), Image.Resampling.LANCZOS)
+        if output_filename: output_path = os.path.join(WORKSPACE_DIR, output_filename)
+        else: output_path = os.path.join(WORKSPACE_DIR, f"edited_ref_{time.time()}.png")
+        img_square.save(output_path)
+        return output_path
+    except Exception as e: raise gr.Error(f"Falha ao processar a imagem de referência: {e}")
+
+def trim_video_to_frames(input_path: str, output_path: str, frames_to_keep: int) -> str:
+    """
+    Usa o FFmpeg para cortar um vídeo, mantendo um número específico de frames do início.
+
+    Args:
+        input_path (str): Caminho para o vídeo de entrada.
+        output_path (str): Caminho para salvar o vídeo cortado.
+        frames_to_keep (int): Número de frames a serem mantidos.
+
+    Returns:
+        str: O caminho para o vídeo cortado.
+    """
+    try:
+        subprocess.run(f"ffmpeg -y -v error -i \"{input_path}\" -vf \"select='lt(n,{frames_to_keep})'\" -an \"{output_path}\"", shell=True, check=True, text=True)
+        return output_path
+    except subprocess.CalledProcessError as e: raise gr.Error(f"FFmpeg falhou ao cortar vídeo: {e.stderr}")
+
+def extract_last_n_frames_as_video(input_path: str, output_path: str, n_frames: int) -> str:
+    """
+    Usa o FFmpeg para extrair os últimos N frames de um vídeo para criar o "Eco Cinético".
+
+    Args:
+        input_path (str): Caminho para o vídeo de entrada.
+        output_path (str): Caminho para salvar o vídeo de saída (o eco).
+        n_frames (int): Número de frames a serem extraídos do final.
+
+    Returns:
+        str: O caminho para o vídeo de eco gerado.
+    """
+    try:
+        cmd_probe = f"ffprobe -v error -select_streams v:0 -count_frames -show_entries stream=nb_read_frames -of default=nokey=1:noprint_wrappers=1 \"{input_path}\""
+        result = subprocess.run(cmd_probe, shell=True, check=True, text=True, capture_output=True)
+        total_frames = int(result.stdout.strip())
+        if n_frames >= total_frames: shutil.copyfile(input_path, output_path); return output_path
+        start_frame = total_frames - n_frames
+        cmd_ffmpeg = f"ffmpeg -y -v error -i \"{input_path}\" -vf \"select='gte(n,{start_frame})'\" -vframes {n_frames} -an \"{output_path}\""
+        subprocess.run(cmd_ffmpeg, shell=True, check=True, text=True)
+        return output_path
+    except (subprocess.CalledProcessError, ValueError) as e: raise gr.Error(f"FFmpeg falhou ao extrair os últimos {n_frames} frames: {getattr(e, 'stderr', str(e))}")
+
+def concatenate_final_video(fragment_paths: list, fragment_duration_frames: int, eco_video_frames: int, progress=gr.Progress()):
+    """
+    Concatena os fragmentos de vídeo gerados em uma única "Obra-Prima" final.
+    Fragmentos marcados como 'cut' (identificados pelo nome do arquivo)
+    não terão sua duração cortada para preservar a intenção do corte.
+
+    Args:
+        fragment_paths (list): Lista de caminhos para os fragmentos de vídeo.
+                                Cada caminho pode conter '_cut.mp4' no nome se for um corte.
+        fragment_duration_frames (int): A duração esperada de cada clipe (usado apenas para
+                                        fragmentos que NÃO são cortes).
+        eco_video_frames (int): O tamanho da sobreposição que deve ser cortada para fragmentos
+                                que NÃO são cortes (usado para o 'eco').
+        progress (gr.Progress): Objeto do Gradio para atualizar a barra de progresso.
+
+    Returns:
+        str: O caminho para o vídeo final montado.
+    """
+    if not fragment_paths:
+        raise gr.Error("Nenhum fragmento de vídeo para concatenar.")
+
+    progress(0.1, desc="Preparando fragmentos para a montagem final...");
+
+    try:
+        list_file_path = os.path.abspath(os.path.join(WORKSPACE_DIR, f"concat_list_final_{time.time()}.txt"))
+        final_output_path = os.path.abspath(os.path.join(WORKSPACE_DIR, "masterpiece_final.mp4"))
+        temp_files_for_concat = []
+        
+        # Calculamos a duração a ser mantida APENAS para fragmentos que NÃO são cortes
+        # Se for um corte, consideramos a duração total do fragmento original
+        duration_for_non_cut_fragments = int(fragment_duration_frames - eco_video_frames)
+        duration_for_non_cut_fragments = max(1, duration_for_non_cut_fragments) # Garantir que seja pelo menos 1 frame
+
+        for i, p in enumerate(fragment_paths):
+            is_last_fragment = (i == len(fragment_paths) - 1)
+            
+            # Verificamos se o nome do arquivo contém "_cut.mp4" para identificar um corte
+            if "_cut.mp4" in os.path.basename(p) or is_last_fragment:
+                # Se for um corte ou o último fragmento, usamos o arquivo original sem cortar o fim
+                temp_files_for_concat.append(os.path.abspath(p))
+                # Apenas para o último fragmento, garantimos que ele também seja considerado
+                if is_last_fragment and "_cut.mp4" not in os.path.basename(p):
+                    pass # O último fragmento original já foi adicionado
+            else:
+                # Para fragmentos que não são cortes e não são o último, cortamos o fim
+                temp_path = os.path.join(WORKSPACE_DIR, f"final_temp_concat_{i}.mp4")
+                # Aqui usamos a duração calculada para não-cortes (fragment_duration - eco)
+                trim_video_to_frames(p, temp_path, duration_for_non_cut_fragments)
+                temp_files_for_concat.append(os.path.abspath(temp_path))
+        
+        progress(0.8, desc="Concatenando clipe final...");
+
+        with open(list_file_path, "w") as f:
+            for p_temp in temp_files_for_concat:
+                f.write(f"file '{p_temp}'\n")
+        
+        ffmpeg_command = f"ffmpeg -y -v error -f concat -safe 0 -i \"{list_file_path}\" -c copy \"{final_output_path}\""
+        subprocess.run(ffmpeg_command, shell=True, check=True, text=True)
+        
+        progress(1.0, desc="Montagem final concluída!");
+        return final_output_path
+    except subprocess.CalledProcessError as e:
+        error_output = e.stderr if e.stderr else "Nenhuma saída de erro do FFmpeg."
+        raise gr.Error(f"FFmpeg falhou na concatenação final: {error_output}")
+    except Exception as e:
+        raise gr.Error(f"Um erro ocorreu durante a concatenação final: {e}")
+
+def concatenate_final_video1(fragment_paths: list, fragment_duration_frames: int, eco_video_frames: int, progress=gr.Progress()):
+    """
+    Concatena os fragmentos de vídeo gerados em uma única "Obra-Prima" final.
+
+    Args:
+        fragment_paths (list): Lista de caminhos para os fragmentos de vídeo.
+        fragment_duration_frames (int): A duração de cada clipe na montagem final.
+        eco_video_frames (int): O tamanho da sobreposição que deve ser cortada.
+        progress (gr.Progress): Objeto do Gradio para atualizar a barra de progresso.
+
+    Returns:
+        str: O caminho para o vídeo final montado.
+    """
+    if not fragment_paths: raise gr.Error("Nenhum fragmento de vídeo para concatenar.")
+    progress(0.1, desc="Preparando e cortando fragmentos para a montagem final...");
+    try:
+        list_file_path = os.path.abspath(os.path.join(WORKSPACE_DIR, f"concat_list_final_{time.time()}.txt"))
+        final_output_path = os.path.abspath(os.path.join(WORKSPACE_DIR, "masterpiece_final.mp4"))
+        temp_files_for_concat = []
+        final_clip_len = int(fragment_duration_frames - eco_video_frames)
+        for i, p in enumerate(fragment_paths):
+            is_last_fragment = (i == len(fragment_paths) - 1)
+            if is_last_fragment or "_cut.mp4" in os.path.basename(p):
+                temp_files_for_concat.append(os.path.abspath(p))
+            else:
+                temp_path = os.path.join(WORKSPACE_DIR, f"final_temp_concat_{i}.mp4")
+                trim_video_to_frames(p, temp_path, final_clip_len)
+                temp_files_for_concat.append(os.path.abspath(temp_path))
+        progress(0.8, desc="Concatenando clipe final...")
+        with open(list_file_path, "w") as f:
+            for p_temp in temp_files_for_concat:
+                f.write(f"file '{p_temp}'\n")
+        ffmpeg_command = f"ffmpeg -y -v error -f concat -safe 0 -i \"{list_file_path}\" -c copy \"{final_output_path}\""
+        subprocess.run(ffmpeg_command, shell=True, check=True, text=True)
+        progress(1.0, desc="Montagem final concluída!")
+        return final_output_path
+    except subprocess.CalledProcessError as e:
+        error_output = e.stderr if e.stderr else "Nenhuma saída de erro do FFmpeg."
+        raise gr.Error(f"FFmpeg falhou na concatenação final: {error_output}")
+
 def extract_image_exif(image_path: str) -> str:
+    """
+    Extrai metadados EXIF relevantes de uma imagem.
+
+    Args:
+        image_path (str): O caminho para o arquivo de imagem.
+
+    Returns:
+        str: Uma string formatada contendo os metadados EXIF.
+    """
     try:
         img = Image.open(image_path); exif_data = img._getexif()
         if not exif_data: return "No EXIF metadata found."
@@ -92,17 +264,39 @@ def extract_image_exif(image_path: str) -> str:
         return metadata_str if metadata_str else "No relevant EXIF metadata found."
     except Exception: return "Could not read EXIF data."
 
-def run_storyboard_generation(num_fragments: int, prompt: str, initial_image_path: str):
-    if not initial_image_path: raise gr.Error("Por favor, forneça uma imagem de referência inicial.")
+# ======================================================================================
+# SEÇÃO 2: ORQUESTRADORES DE IA (As "Etapas" da Geração)
+# ======================================================================================
+
+def run_storyboard_generation(num_fragments: int, prompt: str, reference_paths: list):
+    """
+    Orquestra a Etapa 1: O Roteiro.
+    Chama a IA (Gemini) para atuar como "Roteirista", analisando o prompt do usuário e
+    todas as imagens de referência para criar uma narrativa coesa dividida em atos.
+
+    Args:
+        num_fragments (int): O número de keyframes (atos) a serem gerados no roteiro.
+        prompt (str): A ideia geral do usuário.
+        reference_paths (list): Lista de caminhos para todas as imagens de referência fornecidas.
+
+    Returns:
+        list: Uma lista de strings, onde cada string é a descrição de uma cena.
+    """
+    if not reference_paths: raise gr.Error("Por favor, forneça pelo menos uma imagem de referência.")
     if not GEMINI_API_KEY: raise gr.Error("Chave da API Gemini não configurada!")
-    exif_metadata = extract_image_exif(initial_image_path)
+    main_ref_path = reference_paths[0]
+    exif_metadata = extract_image_exif(main_ref_path)
     prompt_file = "prompts/unified_storyboard_prompt.txt"
     with open(os.path.join(os.path.dirname(__file__), prompt_file), "r", encoding="utf-8") as f: template = f.read()
     director_prompt = template.format(user_prompt=prompt, num_fragments=int(num_fragments), image_metadata=exif_metadata)
     genai.configure(api_key=GEMINI_API_KEY)
-    model = genai.GenerativeModel('gemini-1.5-flash'); img = Image.open(initial_image_path)
-    print("Gerando roteiro com análise de visão integrada...")
-    response = model.generate_content([director_prompt, img])
+    model = genai.GenerativeModel('gemini-2.5-flash')
+    model_contents = [director_prompt]
+    for i, img_path in enumerate(reference_paths):
+        model_contents.append(f"Reference Image {i+1}:")
+        model_contents.append(Image.open(img_path))
+    print(f"Gerando roteiro com {len(reference_paths)} imagens de referência...")
+    response = model.generate_content(model_contents)
     try:
         storyboard_data = robust_json_parser(response.text)
         storyboard = storyboard_data.get("scene_storyboard", [])
@@ -110,57 +304,134 @@ def run_storyboard_generation(num_fragments: int, prompt: str, initial_image_pat
         return storyboard
     except Exception as e: raise gr.Error(f"O Roteirista (Gemini) falhou ao criar o roteiro: {e}. Resposta recebida: {response.text}")
 
-def get_dreamo_prompt_for_transition(previous_image_path: str, target_scene_description: str) -> str:
-    genai.configure(api_key=GEMINI_API_KEY)
-    prompt_file = "prompts/img2img_evolution_prompt.txt"
-    with open(os.path.join(os.path.dirname(__file__), prompt_file), "r", encoding="utf-8") as f: template = f.read()
-    director_prompt = template.format(target_scene_description=target_scene_description)
-    model = genai.GenerativeModel('gemini-1.5-flash'); img = Image.open(previous_image_path)
-    response = model.generate_content([director_prompt, "Previous Image:", img])
-    return response.text.strip().replace("\"", "")
-
-@spaces.GPU(duration=180) # Ativa a GPU para esta função com timeout de 3 minutos
-def run_keyframe_generation(storyboard, ref_images_tasks, progress=gr.Progress()):
+def run_keyframe_generation(storyboard, fixed_reference_paths, keyframe_resolution, global_prompt, progress=gr.Progress()):
+    """
+    Orquestra a Etapa 2: Os Keyframes.
+    A cada iteração, chama a IA (Gemini) para atuar como "Diretor de Cena". A IA analisa
+    o roteiro, as referências fixas e as últimas 3 imagens geradas para criar um prompt
+    de composição. O prompt usa tags [IMG-X] para referenciar as fontes, que são então
+    mapeadas para os arquivos reais e enviadas ao `FluxKontext` para a geração da imagem.
+
+    Args:
+        storyboard (list): A lista de atos do roteiro.
+        fixed_reference_paths (list): Lista de caminhos para as imagens de referência fixas.
+        keyframe_resolution (int): A resolução para os keyframes a serem gerados.
+        global_prompt (str): A ideia geral do usuário para dar contexto à IA.
+        progress (gr.Progress): Objeto do Gradio para a barra de progresso.
+
+    Yields:
+        dict: Atualizações para os componentes da UI do Gradio durante a geração.
+    """
     if not storyboard: raise gr.Error("Nenhum roteiro para gerar keyframes.")
-    initial_ref_image_path = ref_images_tasks[0]['image']
-    if not initial_ref_image_path or not os.path.exists(initial_ref_image_path): raise gr.Error("A imagem de referência principal (à esquerda) é obrigatória.")
-    log_history = ""; generated_images_for_gallery = [] 
+    if not fixed_reference_paths: raise gr.Error("A imagem de referência inicial é obrigatória.")
+    
+    initial_ref_image_path = fixed_reference_paths[0]
+    log_history = ""; generated_images_for_gallery = []
+    width, height = keyframe_resolution, keyframe_resolution
+    
+    keyframe_paths_for_video = [] 
+    scene_history = "N/A"
+
+    wrapper_prompt_path = os.path.join(os.path.dirname(__file__), "prompts/flux_composition_wrapper_prompt.txt")
+    with open(wrapper_prompt_path, "r", encoding="utf-8") as f:
+        kontext_template = f.read()
+        
+    director_prompt_path = os.path.join(os.path.dirname(__file__), "prompts/director_composition_prompt.txt")
+    with open(director_prompt_path, "r", encoding="utf-8") as f:
+        director_template = f.read()
+
     try:
-        dreamo_generator_singleton.to_gpu() # Move o modelo para a GPU ativada
-        with Image.open(initial_ref_image_path) as img: width, height = (img.width // 32) * 32, (img.height // 32) * 32
-        keyframe_paths, current_ref_image_path = [initial_ref_image_path], initial_ref_image_path
+        genai.configure(api_key=GEMINI_API_KEY)
+        model = genai.GenerativeModel('gemini-2.5-flash')
+
         for i, scene_description in enumerate(storyboard):
-            progress(i / len(storyboard), desc=f"Pintando Keyframe {i+1}/{len(storyboard)}")
-            log_history += f"\n--- PINTANDO KEYFRAME {i+1}/{len(storyboard)} ---\n"
-            dreamo_prompt = get_dreamo_prompt_for_transition(current_ref_image_path, scene_description)
-            reference_items = []
-            fixed_references_basenames = [os.path.basename(item['image']) for item in ref_images_tasks if item['image']]
-            for item in ref_images_tasks:
-                if item['image']:
-                    reference_items.append({'image_np': np.array(Image.open(item['image']).convert("RGB")), 'task': item['task']})
-            dynamic_references_paths = keyframe_paths[-3:]
-            for ref_path in dynamic_references_paths:
-                if os.path.basename(ref_path) not in fixed_references_basenames:
-                    reference_items.append({'image_np': np.array(Image.open(ref_path).convert("RGB")), 'task': 'ip'})
-            log_history += f"  - Roteiro: '{scene_description}'\n  - Usando {len(reference_items)} referências visuais.\n  - Prompt do D.A.: \"{dreamo_prompt}\"\n"
-            yield {keyframe_log_output: gr.update(value=log_history), keyframe_gallery_output: gr.update(value=generated_images_for_gallery)}
+            progress(i / len(storyboard), desc=f"Compondo Keyframe {i+1}/{len(storyboard)} ({width}x{height})")
+            log_history += f"\n--- COMPONDO KEYFRAME {i+1}/{len(storyboard)} ---\n"
+            
+            last_three_paths = ([initial_ref_image_path] + keyframe_paths_for_video)[-3:]
+            
+            log_history += f"  - Diretor de Cena está analisando o contexto...\n"
+            yield {keyframe_log_output: gr.update(value=log_history), keyframe_gallery_output: gr.update(value=generated_images_for_gallery), keyframe_images_state: gr.update(value=generated_images_for_gallery)}
+            
+            director_prompt = director_template.format(
+                global_prompt=global_prompt,
+                scene_history=scene_history,
+                current_scene_desc=scene_description,
+            )
+            
+            model_contents = []
+            image_map = {}
+            current_image_index = 1
+            
+            for path in last_three_paths:
+                if path not in image_map.values():
+                    image_map[current_image_index] = path
+                    model_contents.extend([f"IMG-{current_image_index}:", Image.open(path)])
+                    current_image_index += 1
+            
+            for path in fixed_reference_paths:
+                if path not in image_map.values():
+                    image_map[current_image_index] = path
+                    model_contents.extend([f"IMG-{current_image_index}:", Image.open(path)])
+                    current_image_index += 1
+            
+            model_contents.append(director_prompt)
+
+            response_text = model.generate_content(model_contents).text
+            composition_prompt_with_tags = response_text.strip()
+            
+            referenced_indices = [int(idx) for idx in re.findall(r'\[IMG-(\d+)\]', composition_prompt_with_tags)]
+            
+            current_reference_paths = [image_map[idx] for idx in sorted(list(set(referenced_indices))) if idx in image_map]
+            if not current_reference_paths:
+                current_reference_paths = [last_three_paths[-1]]
+
+            reference_images_pil = [Image.open(p) for p in current_reference_paths]
+            final_kontext_prompt = re.sub(r'\[IMG-\d+\]', '', composition_prompt_with_tags).strip()
+            
+            log_history += f"  - Diretor de Cena decidiu usar as imagens: {[os.path.basename(p) for p in current_reference_paths]}\n"
+            log_history += f"  - Prompt Final do Diretor: \"{final_kontext_prompt}\"\n"
+            scene_history += f"Scene {i+1}: {final_kontext_prompt}\n"
+            
+            yield {keyframe_log_output: gr.update(value=log_history), keyframe_gallery_output: gr.update(value=generated_images_for_gallery), keyframe_images_state: gr.update(value=generated_images_for_gallery)}
+
+            final_kontext_prompt_wrapped = kontext_template.format(target_prompt=final_kontext_prompt)
             output_path = os.path.join(WORKSPACE_DIR, f"keyframe_{i+1}.png")
-            image = dreamo_generator_singleton.generate_image_with_gpu_management(reference_items=reference_items, prompt=dreamo_prompt, width=width, height=height)
+            
+            image = flux_kontext_singleton.generate_image(
+                reference_images=reference_images_pil, 
+                prompt=final_kontext_prompt_wrapped, 
+                width=width, height=height, seed=int(time.time())
+            )
+            
             image.save(output_path)
-            keyframe_paths.append(output_path); generated_images_for_gallery.append(output_path); current_ref_image_path = output_path
-            yield {keyframe_log_output: gr.update(value=log_history), keyframe_gallery_output: gr.update(value=generated_images_for_gallery)}
-    except Exception as e: raise gr.Error(f"O Pintor (DreamO) ou Diretor de Arte (Gemini) falhou: {e}")
-    finally:
-        dreamo_generator_singleton.to_cpu() # Libera a VRAM da GPU
-        gc.collect()
-        torch.cuda.empty_cache()
-    log_history += "\nPintura de todos os keyframes concluída.\n"
-    yield {keyframe_log_output: gr.update(value=log_history), keyframe_gallery_output: gr.update(value=generated_images_for_gallery), keyframe_images_state: keyframe_paths}
+            keyframe_paths_for_video.append(output_path)
+            generated_images_for_gallery.append(output_path)
+
+    except Exception as e: 
+        raise gr.Error(f"O Compositor (FluxKontext) ou o Diretor de Cena (Gemini) falhou: {e}")
+            
+    log_history += "\nComposição de todos os keyframes concluída.\n"
+    final_keyframes = keyframe_paths_for_video
+    yield {keyframe_log_output: gr.update(value=log_history), keyframe_gallery_output: final_keyframes, keyframe_images_state: final_keyframes}
 
 def get_initial_motion_prompt(user_prompt: str, start_image_path: str, destination_image_path: str, dest_scene_desc: str):
+    """
+    Chama a IA (Gemini) para atuar como "Cineasta Inicial".
+    Gera o prompt de movimento para o primeiro fragmento de vídeo, que não possui um eco anterior.
+
+    Args:
+        user_prompt (str): A ideia geral da história.
+        start_image_path (str): Caminho para o primeiro keyframe.
+        destination_image_path (str): Caminho para o segundo keyframe.
+        dest_scene_desc (str): A descrição do roteiro para a cena de destino.
+
+    Returns:
+        str: O prompt de movimento gerado.
+    """
     if not GEMINI_API_KEY: raise gr.Error("Chave da API Gemini não configurada!")
     try:
-        genai.configure(api_key=GEMINI_API_KEY); model = genai.GenerativeModel('gemini-1.5-flash'); prompt_file = "prompts/initial_motion_prompt.txt"
+        genai.configure(api_key=GEMINI_API_KEY); model = genai.GenerativeModel('gemini-2.5-flash'); prompt_file = "prompts/initial_motion_prompt.txt"
         with open(os.path.join(os.path.dirname(__file__), prompt_file), "r", encoding="utf-8") as f: template = f.read()
         cinematographer_prompt = template.format(user_prompt=user_prompt, destination_scene_description=dest_scene_desc)
         start_img, dest_img = Image.open(start_image_path), Image.open(destination_image_path)
@@ -169,372 +440,300 @@ def get_initial_motion_prompt(user_prompt: str, start_image_path: str, destinati
         return response.text.strip()
     except Exception as e: raise gr.Error(f"O Cineasta de IA (Inicial) falhou: {e}. Resposta: {getattr(e, 'text', 'No text available.')}")
 
-def get_dynamic_motion_prompt(user_prompt, story_history, memory_media_path, path_image_path, destination_image_path, path_scene_desc, dest_scene_desc):
+def get_transition_decision(user_prompt, story_history, memory_media_path, path_image_path, destination_image_path, midpoint_scene_description, dest_scene_desc):
+    """
+    Chama a IA (Gemini) para atuar como "Diretor de Continuidade".
+    Analisa o eco, o keyframe atual e o próximo para decidir entre uma transição contínua
+    ou um corte de cena, e gera o prompt de movimento apropriado.
+
+    Args:
+        (Vários argumentos de contexto sobre a história e as imagens)
+
+    Returns:
+        dict: Um dicionário contendo 'transition_type' e 'motion_prompt'.
+    """
     if not GEMINI_API_KEY: raise gr.Error("Chave da API Gemini não configurada!")
     try:
-        genai.configure(api_key=GEMINI_API_KEY); model = genai.GenerativeModel('gemini-1.5-flash'); prompt_file = "prompts/dynamic_motion_prompt.txt"
+        genai.configure(api_key=GEMINI_API_KEY); model = genai.GenerativeModel('gemini-2.5-flash'); prompt_file = "prompts/transition_decision_prompt.txt"
         with open(os.path.join(os.path.dirname(__file__), prompt_file), "r", encoding="utf-8") as f: template = f.read()
-        cinematographer_prompt = template.format(user_prompt=user_prompt, story_history=story_history, midpoint_scene_description=path_scene_desc, destination_scene_description=dest_scene_desc)
-        
-        with imageio.get_reader(memory_media_path) as reader:
-            mem_img = Image.fromarray(reader.get_data(0))
-            
+        continuity_prompt = template.format(user_prompt=user_prompt, story_history=story_history, midpoint_scene_description=midpoint_scene_description, destination_scene_description=dest_scene_desc)
+        with imageio.get_reader(memory_media_path) as reader: mem_img = Image.fromarray(reader.get_data(0))
         path_img, dest_img = Image.open(path_image_path), Image.open(destination_image_path)
-        model_contents = ["START Image (from Kinetic Echo):", mem_img, "MIDPOINT Image (Path):", path_img, "DESTINATION Image (Destination):", dest_img, cinematographer_prompt]
+        model_contents = ["START Image (from Kinetic Echo):", mem_img, "MIDPOINT Image (Path):", path_img, "DESTINATION Image (Destination):", dest_img, continuity_prompt]
         response = model.generate_content(model_contents)
-        return response.text.strip()
-    except Exception as e: raise gr.Error(f"O Cineasta de IA (Dinâmico) falhou: {e}. Resposta: {getattr(e, 'text', 'No text available.')}")
+        decision_data = robust_json_parser(response.text)
+        if "transition_type" not in decision_data or "motion_prompt" not in decision_data: raise ValueError("A resposta da IA não contém as chaves 'transition_type' ou 'motion_prompt'.")
+        return decision_data
+    except Exception as e: raise gr.Error(f"O Diretor de Continuidade (IA) falhou: {e}. Resposta: {getattr(e, 'text', str(e))}")
 
-@spaces.GPU(duration=360) # Ativa a GPU com timeout de 6 minutos para a geração de vídeo
 def run_video_production(
+    video_resolution,
     video_duration_seconds, video_fps, eco_video_frames, use_attention_slicing,
-    fragment_duration_frames, mid_cond_strength, num_inference_steps,
-    prompt_geral, keyframe_images_state, scene_storyboard, cfg, 
+    fragment_duration_frames, mid_cond_strength, dest_cond_strength, num_inference_steps,
+    decode_timestep, image_cond_noise_scale,
+    prompt_geral, keyframe_images_state, scene_storyboard, cfg,
     progress=gr.Progress()
 ):
-    video_total_frames = int(video_duration_seconds * video_fps)
-    if not keyframe_images_state or len(keyframe_images_state) < 3: raise gr.Error("Pinte pelo menos 2 keyframes para produzir uma transição.")
-    if int(fragment_duration_frames) > video_total_frames:
-        raise gr.Error(f"A 'Duração de Cada Fragmento' ({fragment_duration_frames} frames) não pode ser maior que a 'Duração da Geração Bruta' ({video_total_frames} frames).")
-
-    log_history = "\n--- FASE 3/4: Iniciando Produção (Eco + Déjà Vu)...\n"
-    yield {
-        production_log_output: log_history, 
-        video_gallery_glitch: [],
-        prod_media_start_output: gr.update(value=None),
-        prod_media_mid_output: gr.update(value=None, visible=False),
-        prod_media_end_output: gr.update(value=None),
-    }
-    
-    seed = int(time.time())
-    target_device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    """
+    Orquestra a Etapa 3: A Produção.
+    Itera sobre os keyframes e chama os cineastas de IA para gerar os fragmentos de vídeo.
+
+    Args:
+        (Vários parâmetros da UI para controlar a geração de vídeo)
+
+    Yields:
+        dict: Atualizações para os componentes da UI do Gradio.
+    """
     try:
-        pipeline_instance.to(target_device)
-        video_fragments, story_history = [], ""; kinetic_memory_path = None
-        with Image.open(keyframe_images_state[1]) as img: width, height = img.size
+        valid_keyframes = [p for p in keyframe_images_state if p is not None and os.path.exists(p)]
+        width, height = video_resolution, video_resolution
+        video_total_frames_user = int(video_duration_seconds * video_fps)
+        video_total_frames_ltx = int(round((float(video_total_frames_user) - 1.0) / 8.0) * 8 + 1)
+        if not valid_keyframes or len(valid_keyframes) < 2: raise gr.Error("São necessários pelo menos 2 keyframes válidos para produzir uma transição.")
+        if int(fragment_duration_frames) > video_total_frames_user: raise gr.Error(f"Duração do fragmento ({fragment_duration_frames}) não pode ser maior que a Duração Bruta ({video_total_frames_user}).")
+        log_history = f"\n--- FASE 3/4: Iniciando Produção ({width}x{height})...\n"
+        yield {
+            production_log_output: log_history, video_gallery_output: [],
+            prod_media_start_output: None, prod_media_mid_output: gr.update(visible=False), prod_media_end_output: None
+        }
+        seed = int(time.time()); video_fragments, story_history = [], ""; kinetic_memory_path = None
+        num_transitions = len(valid_keyframes) - 1
         
-        num_transitions = len(keyframe_images_state) - 2
         for i in range(num_transitions):
             fragment_num = i + 1
-            progress(i / num_transitions, desc=f"Preparando Fragmento {fragment_num}...")
+            progress(i / num_transitions, desc=f"Gerando Fragmento {fragment_num}...")
             log_history += f"\n--- FRAGMENTO {fragment_num}/{num_transitions} ---\n"
+            destination_frame = int(video_total_frames_ltx - 1)
             
-            if i == 0:
-                start_path, destination_path = keyframe_images_state[1], keyframe_images_state[2]
-                dest_scene_desc = scene_storyboard[1]
-                log_history += f"  - Início (Big Bang): {os.path.basename(start_path)}\n  - Destino: {os.path.basename(destination_path)}\n"
+            if i == 0 or kinetic_memory_path is None:
+                start_path, destination_path = valid_keyframes[i], valid_keyframes[i+1]
+                dest_scene_desc = scene_storyboard[i]
+                log_history += f"  - Início (Cena Nova): {os.path.basename(start_path)}\n  - Destino: {os.path.basename(destination_path)}\n"
                 current_motion_prompt = get_initial_motion_prompt(prompt_geral, start_path, destination_path, dest_scene_desc)
-                conditioning_items_data = [(start_path, 0, 1.0), (destination_path, int(video_total_frames), 1.0)]
-                
-                yield {
-                    production_log_output: gr.update(value=log_history),
-                    prod_media_start_output: gr.update(value=start_path),
-                    prod_media_mid_output: gr.update(value=None, visible=False),
-                    prod_media_end_output: gr.update(value=destination_path),
-                }
+                conditioning_items_data = [(start_path, 0, 1.0), (destination_path, destination_frame, dest_cond_strength)]
+                transition_type = "continuous"
+                yield { production_log_output: log_history, prod_media_start_output: start_path, prod_media_mid_output: gr.update(visible=False), prod_media_end_output: destination_path }
             else:
-                memory_path, path_path, destination_path = kinetic_memory_path, keyframe_images_state[i+1], keyframe_images_state[i+2]
-                path_scene_desc, dest_scene_desc = scene_storyboard[i], scene_storyboard[i+1]
-                log_history += f"  - Memória Cinética (Vídeo): {os.path.basename(memory_path)}\n  - Caminho: {os.path.basename(path_path)}\n  - Destino: {os.path.basename(destination_path)}\n"
-                
-                mid_cond_frame_calculated = int(video_total_frames - fragment_duration_frames + eco_video_frames)
-                log_history += f"  - Frame de Condicionamento do 'Caminho' calculado: {mid_cond_frame_calculated}\n"
-
-                current_motion_prompt = get_dynamic_motion_prompt(prompt_geral, story_history, memory_path, path_path, destination_path, path_scene_desc, dest_scene_desc)
-                conditioning_items_data = [(memory_path, 0, 1.0), (path_path, mid_cond_frame_calculated, mid_cond_strength), (destination_path, int(video_total_frames), 1.0)]
-
-                yield {
-                    production_log_output: gr.update(value=log_history),
-                    prod_media_start_output: gr.update(value=memory_path),
-                    prod_media_mid_output: gr.update(value=path_path, visible=True),
-                    prod_media_end_output: gr.update(value=destination_path),
-                }
+                memory_path, path_path, destination_path = kinetic_memory_path, valid_keyframes[i], valid_keyframes[i+1]
+                path_scene_desc, dest_scene_desc = scene_storyboard[i-1], scene_storyboard[i]
+                log_history += f"  - Diretor de Continuidade analisando...\n  - Memória: {os.path.basename(memory_path)}\n  - Caminho: {os.path.basename(path_path)}\n  - Destino: {os.path.basename(destination_path)}\n"
+                yield { production_log_output: log_history, prod_media_start_output: gr.update(value=memory_path, visible=True), prod_media_mid_output: gr.update(value=path_path, visible=True), prod_media_end_output: destination_path }
+                decision_data = get_transition_decision(prompt_geral, story_history, memory_path, path_path, destination_path, midpoint_scene_description=path_scene_desc, dest_scene_desc=dest_scene_desc)
+                transition_type = decision_data["transition_type"]
+                current_motion_prompt = decision_data["motion_prompt"]
+                log_history += f"  - Decisão: {transition_type.upper()}\n"
+                mid_cond_frame_calculated = int(video_total_frames_ltx - fragment_duration_frames + eco_video_frames)
+                conditioning_items_data = [(memory_path, 0, 1.0), (path_path, mid_cond_frame_calculated, mid_cond_strength), (destination_path, destination_frame, dest_cond_strength)]
 
             story_history += f"\n- Ato {fragment_num + 1}: {current_motion_prompt}"
             log_history += f"  - Instrução do Cineasta: '{current_motion_prompt}'\n"; yield {production_log_output: log_history}
             
-            progress(i / num_transitions, desc=f"Filmando Fragmento {fragment_num}...")
-            full_fragment_path, actual_frames_generated = run_ltx_animation(
-                current_fragment_index=fragment_num, motion_prompt=current_motion_prompt, 
-                conditioning_items_data=conditioning_items_data, width=width, height=height, 
-                seed=seed, cfg=cfg, progress=progress,
-                video_total_frames=video_total_frames, video_fps=video_fps,
-                use_attention_slicing=use_attention_slicing, num_inference_steps=num_inference_steps
+            output_filename = f"fragment_{fragment_num}_{transition_type}.mp4"
+            full_fragment_path, _ = ltx_manager_singleton.generate_video_fragment(
+                motion_prompt=current_motion_prompt, conditioning_items_data=conditioning_items_data,
+                width=width, height=height, seed=seed, cfg=cfg, progress=progress,
+                video_total_frames=video_total_frames_ltx, video_fps=video_fps,
+                use_attention_slicing=use_attention_slicing, num_inference_steps=num_inference_steps,
+                decode_timestep=decode_timestep, image_cond_noise_scale=image_cond_noise_scale,
+                current_fragment_index=fragment_num, output_path=os.path.join(WORKSPACE_DIR, output_filename)
             )
-            
-            log_history += f"  - LOG: Gerei o fragmento_{fragment_num} bruto com {actual_frames_generated} frames.\n"
-            yield {production_log_output: log_history}
-            
-            trimmed_fragment_path = os.path.join(WORKSPACE_DIR, f"fragment_{fragment_num}_trimmed.mp4")
-            trim_video_to_frames(full_fragment_path, trimmed_fragment_path, int(fragment_duration_frames))
-            
-            log_history += f"  - LOG: Reduzi o fragmento_{fragment_num} para {int(fragment_duration_frames)} frames.\n"
-            yield {production_log_output: log_history}
+            log_history += f"  - LOG: Gerei {output_filename}.\n"
             
             is_last_fragment = (i == num_transitions - 1)
-            if not is_last_fragment:
+            
+            if is_last_fragment:
+                log_history += "  - Último fragmento. Mantendo duração total.\n"
+                video_fragments.append(full_fragment_path)
+                kinetic_memory_path = None
+            elif transition_type == "cut":
+                log_history += "  - CORTE DE CENA: Fragmento mantido, memória reiniciada.\n"
+                video_fragments.append(full_fragment_path)
+                kinetic_memory_path = None
+            else:
+                trimmed_fragment_path = os.path.join(WORKSPACE_DIR, f"fragment_{fragment_num}_trimmed.mp4")
+                trim_video_to_frames(full_fragment_path, trimmed_fragment_path, int(fragment_duration_frames))
                 eco_output_path = os.path.join(WORKSPACE_DIR, f"eco_from_frag_{fragment_num}.mp4")
                 kinetic_memory_path = extract_last_n_frames_as_video(trimmed_fragment_path, eco_output_path, int(eco_video_frames))
-                log_history += f"  - LOG: Gerei o eco com {int(eco_video_frames)} frames a partir do final do fragmento reduzido.\n"
-                log_history += f"  - Novo Eco Cinético (Vídeo) criado: {os.path.basename(kinetic_memory_path)}\n"
-            else:
-                 log_history += f"  - Este é o último fragmento, não é necessário gerar um eco.\n"
-
-            video_fragments.append(trimmed_fragment_path)
-            yield {production_log_output: log_history, video_gallery_glitch: video_fragments}
-            
-        progress(1.0, desc="Produção Concluída.")
-        log_history += "\nProdução de todos os fragmentos concluída.\n"
-        yield {production_log_output: log_history, video_gallery_glitch: video_fragments, fragment_list_state: video_fragments}
-    finally:
-        pipeline_instance.to('cpu')
-        gc.collect()
-        torch.cuda.empty_cache()
-
-def process_image_to_square(image_path: str, size: int = TARGET_RESOLUTION) -> str:
-    if not image_path: return None
-    try:
-        img = Image.open(image_path).convert("RGB"); img_square = ImageOps.fit(img, (size, size), Image.Resampling.LANCZOS)
-        output_path = os.path.join(WORKSPACE_DIR, f"initial_ref_{size}x{size}.png"); img_square.save(output_path)
-        return output_path
-    except Exception as e: raise gr.Error(f"Falha ao processar a imagem de referência: {e}")
-
-def load_conditioning_tensor(media_path: str, height: int, width: int) -> torch.Tensor:
-    if media_path.lower().endswith(('.mp4', '.mov', '.avi')):
-        with imageio.get_reader(media_path) as reader:
-            first_frame_np = reader.get_data(0)
-        temp_img_path = os.path.join(WORKSPACE_DIR, f"temp_frame_from_{os.path.basename(media_path)}.png")
-        Image.fromarray(first_frame_np).save(temp_img_path)
-        return load_image_to_tensor_with_resize_and_crop(temp_img_path, height, width)
-    else:
-        return load_image_to_tensor_with_resize_and_crop(media_path, height, width)
-
-def run_ltx_animation(
-    current_fragment_index, motion_prompt, conditioning_items_data, 
-    width, height, seed, cfg, progress,
-    video_total_frames, video_fps, use_attention_slicing, num_inference_steps
-):
-    progress(0, desc=f"[Câmera LTX] Filmando Cena {current_fragment_index}...");
-    output_path = os.path.join(WORKSPACE_DIR, f"fragment_{current_fragment_index}_full.mp4")
-    target_device = pipeline_instance.device # A pipeline já estará no dispositivo correto (cuda)
-    try:
-        if use_attention_slicing: pipeline_instance.enable_attention_slicing()
-        
-        conditioning_items = [ConditioningItem(load_conditioning_tensor(p, height, width).to(target_device), s, t) for p, s, t in conditioning_items_data]
-        
-        actual_num_frames = int(round((float(video_total_frames) - 1.0) / 8.0) * 8 + 1)
-        padded_h, padded_w = ((height - 1) // 32 + 1) * 32, ((width - 1) // 32 + 1) * 32
-        padding_vals = calculate_padding(height, width, padded_h, padded_w)
-        for item in conditioning_items: item.media_item = torch.nn.functional.pad(item.media_item, padding_vals)
-        
-        first_pass_config = PIPELINE_CONFIG_YAML.get("first_pass", {}).copy()
-        first_pass_config['num_inference_steps'] = int(num_inference_steps)
-
-        kwargs = {"prompt": motion_prompt, "negative_prompt": "blurry, distorted, bad quality, artifacts", "height": padded_h, "width": padded_w, "num_frames": actual_num_frames, "frame_rate": video_fps, "generator": torch.Generator(device=target_device).manual_seed(int(seed) + current_fragment_index), "output_type": "pt", "guidance_scale": float(cfg), "timesteps": first_pass_config.get("timesteps"), "conditioning_items": conditioning_items, "decode_timestep": PIPELINE_CONFIG_YAML.get("decode_timestep"), "decode_noise_scale": PIPELINE_CONFIG_YAML.get("decode_noise_scale"), "stochastic_sampling": PIPELINE_CONFIG_YAML.get("stochastic_sampling"), "image_cond_noise_scale": 0.15, "is_video": True, "vae_per_channel_normalize": True, "mixed_precision": (PIPELINE_CONFIG_YAML.get("precision") == "mixed_precision"), "enhance_prompt": False, "decode_every": 4, "num_inference_steps": int(num_inference_steps)}
-        
-        result_tensor = pipeline_instance(**kwargs).images
-        
-        pad_l, pad_r, pad_t, pad_b = map(int, padding_vals); slice_h = -pad_b if pad_b > 0 else None; slice_w = -pad_r if pad_r > 0 else None
-        
-        cropped_tensor = result_tensor[:, :, :actual_num_frames, pad_t:slice_h, pad_l:slice_w]
-        video_np = (cropped_tensor[0].permute(1, 2, 3, 0).cpu().float().numpy() * 255).astype(np.uint8)
-        
-        with imageio.get_writer(output_path, fps=video_fps, codec='libx264', quality=8) as writer:
-            for i, frame in enumerate(video_np): writer.append_data(frame)
-        return output_path, actual_num_frames
-    finally:
-        if use_attention_slicing: pipeline_instance.disable_attention_slicing()
-        # Não movemos a pipeline para a CPU aqui; isso é feito no final da função `run_video_production`
-
-def trim_video_to_frames(input_path: str, output_path: str, frames_to_keep: int) -> str:
-    try:
-        subprocess.run(f"ffmpeg -y -v error -i \"{input_path}\" -vf \"select='lt(n,{frames_to_keep})'\" -an \"{output_path}\"", shell=True, check=True, text=True)
-        return output_path
-    except subprocess.CalledProcessError as e: raise gr.Error(f"FFmpeg falhou ao cortar vídeo: {e.stderr}")
-
-def extract_last_n_frames_as_video(input_path: str, output_path: str, n_frames: int) -> str:
-    try:
-        cmd_probe = f"ffprobe -v error -select_streams v:0 -count_frames -show_entries stream=nb_read_frames -of default=nokey=1:noprint_wrappers=1 \"{input_path}\""
-        result = subprocess.run(cmd_probe, shell=True, check=True, text=True, capture_output=True)
-        total_frames = int(result.stdout.strip())
-        
-        if n_frames >= total_frames:
-             shutil.copyfile(input_path, output_path)
-             return output_path
+                video_fragments.append(full_fragment_path)
+                log_history += f"  - CONTINUIDADE: Eco criado: {os.path.basename(kinetic_memory_path)}\n"
 
-        start_frame = total_frames - n_frames
-        cmd_ffmpeg = f"ffmpeg -y -v error -i \"{input_path}\" -vf \"select='gte(n,{start_frame})'\" -vframes {n_frames} -an \"{output_path}\""
-        subprocess.run(cmd_ffmpeg, shell=True, check=True, text=True)
-        return output_path
-    except (subprocess.CalledProcessError, ValueError) as e:
-        raise gr.Error(f"FFmpeg falhou ao extrair os últimos {n_frames} frames: {getattr(e, 'stderr', str(e))}")
+            yield {production_log_output: log_history, video_gallery_output: video_fragments}
 
-def concatenate_and_trim_masterpiece(fragment_paths: list, fragment_duration_frames: int, eco_video_frames: int, progress=gr.Progress()):
-    if not fragment_paths: raise gr.Error("Nenhum fragmento de vídeo para concatenar.")
-    progress(0.1, desc="Preparando fragmentos para montagem final...");
-    
-    try:
-        list_file_path = os.path.join(WORKSPACE_DIR, "concat_list.txt")
-        final_output_path = os.path.join(WORKSPACE_DIR, "masterpiece_final.mp4")
-        temp_files_for_concat = []
-        
-        final_clip_len = int(fragment_duration_frames - eco_video_frames)
+        progress(1.0, desc="Produção dos fragmentos concluída.")
+        log_history += "\nProdução de todos os fragmentos concluída. Pronto para montar o vídeo final.\n"
+        yield {
+            production_log_output: log_history, 
+            video_gallery_output: video_fragments, 
+            fragment_list_state: video_fragments
+        }
+    except Exception as e: raise gr.Error(f"A Produção de Vídeo (LTX) falhou: {e}")
 
-        for i, p in enumerate(fragment_paths):
-            if i == len(fragment_paths) - 1:
-                temp_files_for_concat.append(os.path.abspath(p))
-                progress(0.1 + (i / len(fragment_paths)) * 0.8, desc=f"Mantendo último fragmento: {os.path.basename(p)}")
-            else:
-                temp_path = os.path.join(WORKSPACE_DIR, f"temp_concat_{i}.mp4")
-                progress(0.1 + (i / len(fragment_paths)) * 0.8, desc=f"Cortando {os.path.basename(p)} para {final_clip_len} frames")
-                trim_video_to_frames(p, temp_path, final_clip_len)
-                temp_files_for_concat.append(temp_path)
-        
-        progress(0.9, desc="Concatenando clipes...")
-        with open(list_file_path, "w") as f:
-            for p_temp in temp_files_for_concat:
-                f.write(f"file '{p_temp}'\n")
-        
-        subprocess.run(f"ffmpeg -y -v error -f concat -safe 0 -i \"{list_file_path}\" -c copy \"{final_output_path}\"", shell=True, check=True, text=True)
-        progress(1.0, desc="Montagem concluída!")
-        return final_output_path
-    except subprocess.CalledProcessError as e:
-        raise gr.Error(f"FFmpeg falhou na concatenação final: {e.stderr}")
+# ======================================================================================
+# SEÇÃO 3: DEFINIÇÃO DA INTERFACE GRÁFICA (UI com Gradio)
+# ======================================================================================
 
-# --- Ato 5: A Interface com o Mundo (UI) ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# NOVIM-6.1 (Painel de Controle do Diretor)\n*By Carlex & Gemini & DreamO - Versão HF Spaces*")
+    gr.Markdown(f"# NOVIM-13.1 (Painel de Controle do Diretor)\n*Arquitetura ADUC-SDR com Documentação Completa*")
+
     if os.path.exists(WORKSPACE_DIR): shutil.rmtree(WORKSPACE_DIR)
     os.makedirs(WORKSPACE_DIR); Path("prompts").mkdir(exist_ok=True)
-    
-    scene_storyboard_state, keyframe_images_state, fragment_list_state = gr.State([]), gr.State([]), gr.State([])
-    prompt_geral_state, processed_ref_path_state = gr.State(""), gr.State("")
+
+    # --- Definição dos Estados da UI ---
+    scene_storyboard_state = gr.State([])
+    keyframe_images_state = gr.State([])
+    fragment_list_state = gr.State([])
+    prompt_geral_state = gr.State("")
+    processed_ref_paths_state = gr.State([])
+    fragment_duration_state = gr.State()
+    eco_frames_state = gr.State()
+
+    # --- Layout da UI ---
+    gr.Markdown("## CONFIGURAÇÕES GLOBAIS DE RESOLUÇÃO")
+    with gr.Row():
+        video_resolution_selector = gr.Radio([512, 720, 1024], value=512, label="Resolução de Geração do Vídeo (px)")
+        keyframe_resolution_selector = gr.Radio([512, 720, 1024], value=512, label="Resolução dos Keyframes (px)")
 
     gr.Markdown("--- \n ## ETAPA 1: O ROTEIRO (IA Roteirista)")
     with gr.Row():
         with gr.Column(scale=1):
             prompt_input = gr.Textbox(label="Ideia Geral (Prompt)")
-            num_fragments_input = gr.Slider(2, 5, 4, step=1, label="Número de Atos (Keyframes)")
-            image_input = gr.Image(type="filepath", label=f"Imagem de Referência Principal (será {TARGET_RESOLUTION}x{TARGET_RESOLUTION})")
+            num_fragments_input = gr.Slider(2, 50, 4, step=1, label="Nº de Keyframes a Gerar")
+            reference_gallery = gr.Gallery(
+                label="Imagens de Referência (A primeira é a principal)",
+                type="filepath",
+                columns=4, rows=1, object_fit="contain", height="auto"
+            )
             director_button = gr.Button("▶️ 1. Gerar Roteiro", variant="primary")
         with gr.Column(scale=2): storyboard_to_show = gr.JSON(label="Roteiro de Cenas Gerado (em Inglês)")
 
-    gr.Markdown("--- \n ## ETAPA 2: OS KEYFRAMES (IA Pintor & Diretor de Arte)")
+    gr.Markdown("--- \n ## ETAPA 2: OS KEYFRAMES (IA Compositor & Diretor de Cena)")
     with gr.Row():
         with gr.Column(scale=2):
-            gr.Markdown("Forneça referências para guiar a IA. A Principal é obrigatória. A Secundária é opcional (ex: para estilo ou uma segunda pessoa).")
-            with gr.Row():
-                with gr.Column():
-                    ref1_image = gr.Image(label="Referência Principal (Conteúdo/ID)", type="filepath")
-                    ref1_task = gr.Dropdown(choices=["ip", "id", "style"], value="ip", label="Tarefa da Ref. Principal")
-                with gr.Column():
-                    ref2_image = gr.Image(label="Referência Secundária (Opcional)", type="filepath")
-                    ref2_task = gr.Dropdown(choices=["ip", "id", "style"], value="style", label="Tarefa da Ref. Secundária")
-            photographer_button = gr.Button("▶️ 2. Pintar Imagens-Chave em Cadeia", variant="primary")
-        with gr.Column(scale=1):
-            keyframe_log_output = gr.Textbox(label="Diário de Bordo do Pintor", lines=15, interactive=False)
-            keyframe_gallery_output = gr.Gallery(label="Imagens-Chave Pintadas", object_fit="contain", height="auto", type="filepath")
+            gr.Markdown("O Diretor de Cena IA irá analisar as referências e o roteiro para compor cada keyframe de forma autônoma.")
+            photographer_button = gr.Button("▶️ 2. Compor Imagens-Chave em Cadeia", variant="primary")
+            keyframe_gallery_output = gr.Gallery(label="Galeria de Keyframes Gerados", object_fit="contain", height="auto", type="filepath", interactive=False)
+        with gr.Column(scale=1): 
+            keyframe_log_output = gr.Textbox(label="Diário de Bordo do Compositor", lines=25, interactive=False)
 
     gr.Markdown("--- \n ## ETAPA 3: A PRODUÇÃO (IA Cineasta & Câmera)")
     with gr.Row():
         with gr.Column(scale=1):
-            cfg_slider = gr.Slider(1.0, 10.0, 2.5, step=0.1, label="CFG")
+            cfg_slider = gr.Slider(0.5, 10.0, 1.0, step=0.1, label="CFG (Guidance Scale)")
             with gr.Accordion("Controles Avançados de Timing e Performance", open=False):
-                video_duration_slider = gr.Slider(label="Duração da Geração Bruta (segundos)", minimum=2.0, maximum=10.0, value=6.0, step=0.5)
-                video_fps_slider = gr.Slider(label="FPS do Vídeo", minimum=12, maximum=30, value=30, step=1)
-                num_inference_steps_slider = gr.Slider(label="Etapas de Inferência", minimum=10, maximum=50, value=30, step=1)
+                video_duration_slider = gr.Slider(label="Duração da Geração Bruta (s)", minimum=2.0, maximum=10.0, value=6.0, step=0.5)
+                video_fps_radio = gr.Radio(choices=[8, 16, 24, 32], value=24, label="FPS do Vídeo")
+                num_inference_steps_slider = gr.Slider(label="Etapas de Inferência", minimum=4, maximum=20, value=10, step=1)
                 slicing_checkbox = gr.Checkbox(label="Usar Attention Slicing (Economiza VRAM)", value=True)
                 gr.Markdown("---"); gr.Markdown("#### Controles de Duração (Arquitetura Eco + Déjà Vu)")
-                fragment_duration_slider = gr.Slider(label="Duração de Cada Fragmento (Frames)", minimum=30, maximum=300, value=90, step=1)
+                fragment_duration_slider = gr.Slider(label="Duração de Cada Fragmento (% da Geração Bruta)", minimum=1, maximum=100, value=75, step=1)
                 eco_frames_slider = gr.Slider(label="Tamanho do Eco Cinético (Frames)", minimum=4, maximum=48, value=8, step=1)
                 mid_cond_strength_slider = gr.Slider(label="Força do 'Caminho'", minimum=0.1, maximum=1.0, value=0.5, step=0.05)
-            gr.Markdown(
-                """
-                **Instruções (Nova Arquitetura):**
-                - **Duração da Geração Bruta:** Tempo total que a IA tem para criar a transição. Deve ser MAIOR que a Duração do Fragmento.
-                - **Duração de Cada Fragmento:** O comprimento final de cada clipe de vídeo que será gerado.
-                - **Tamanho do Eco Cinético:** Quantos frames do *final* de um fragmento serão passados para o próximo para garantir continuidade.
-                - **Força do Caminho:** Define o quão forte a imagem-chave intermediária ('Caminho') influencia a transição.
-                """
-            )
-            animator_button = gr.Button("▶️ 3. Produzir Cenas (Handoff Cinético)", variant="primary")
+                dest_cond_strength_slider = gr.Slider(label="Força do 'Destino'", minimum=0.1, maximum=1.0, value=1.0, step=0.05)
+                gr.Markdown("---"); gr.Markdown("#### Controles do VAE (Avançado)")
+                decode_timestep_slider = gr.Slider(label="VAE Decode Timestep", minimum=0.0, maximum=0.2, value=0.05, step=0.005)
+                image_cond_noise_scale_slider = gr.Slider(label="VAE Image Cond Noise Scale", minimum=0.0, maximum=0.1, value=0.025, step=0.005)
+                
+            animator_button = gr.Button("▶️ 3. Produzir Cenas", variant="primary")
             with gr.Accordion("Visualização das Mídias de Condicionamento (Ao Vivo)", open=True):
                 with gr.Row():
                     prod_media_start_output = gr.Video(label="Mídia Inicial (Eco/K1)", interactive=False)
                     prod_media_mid_output = gr.Image(label="Mídia do Caminho (K_i-1)", interactive=False, visible=False)
                     prod_media_end_output = gr.Image(label="Mídia de Destino (K_i)", interactive=False)
             production_log_output = gr.Textbox(label="Diário de Bordo da Produção", lines=10, interactive=False)
-        with gr.Column(scale=1): video_gallery_glitch = gr.Gallery(label="Fragmentos Gerados (Versões Cortadas)", object_fit="contain", height="auto", type="video")
-    
-    fragment_duration_state = gr.State()
-    eco_frames_state = gr.State()
-    
-    gr.Markdown(f"--- \n ## ETAPA 4: PÓS-PRODUÇÃO (Editor)")
-    editor_button = gr.Button("▶️ 4. Montar Vídeo Final", variant="primary")
-    final_video_output = gr.Video(label="A Obra-Prima Final", width=TARGET_RESOLUTION)
+        with gr.Column(scale=1): video_gallery_output = gr.Gallery(label="Fragmentos Gerados", object_fit="contain", height="auto", type="video")
+
+    gr.Markdown(f"--- \n ## ETAPA 4: PÓS-PRODUÇÃO (Montagem Final)")
+    with gr.Row():
+        with gr.Column():
+            editor_button = gr.Button("▶️ 4. Montar Vídeo Final", variant="primary")
+            final_video_output = gr.Video(label="A Obra-Prima Final")
 
     gr.Markdown(
         """
         ---
-        ### A Arquitetura: Eco + Déjà Vu
-        A geração começa com um "Big Bang" entre os dois primeiros keyframes. A partir daí, a mágica acontece.
-        *   **O Eco (A Memória Física):** No final de cada cena, os últimos frames são capturados e salvos como um pequeno vídeo, o `Eco`. Ele carrega a "energia cinética" do movimento, iluminação e atmosfera da cena que acabou.
-        *   **O Déjà Vu (A Memória Conceitual):** Para criar a próxima cena, o Cineasta de IA (Gemini) assiste ao `Eco`, olha para o keyframe do "caminho" e o keyframe do "destino". Com essa visão tripla, ele tem um "déjà vu", uma memória do que acabou de acontecer que o inspira a escrever uma instrução de câmera precisa para conectar o passado ao futuro de forma fluida e coerente.
+        ### A Arquitetura: ADUC-SDR
+        **ADUC (Arquitetura de Unificação Compositiva):** O sistema não usa um único modelo, mas uma equipe de IAs especializadas. Um **Roteirista** cria a história. Um **Diretor de Cena** decide a composição de cada keyframe, selecionando elementos de um "álbum" de referências visuais. Um **Compositor** (`FluxKontext`) cria as imagens.
+        
+        **SDR (Escala Dinâmica e Resiliente):** A geração de vídeo é dividida em fragmentos, permitindo criar vídeos de longa duração. A continuidade é garantida pela arquitetura **Eco + Déjà Vu**:
+        - **O Eco:** Os últimos frames de um clipe são passados para o próximo, transferindo o *momentum* físico e a iluminação.
+        - **O Déjà Vu:** Uma IA **Cineasta** analisa o Eco e os keyframes futuros para criar uma instrução de movimento que seja ao mesmo tempo contínua e narrativamente coerente, sabendo até quando realizar um corte de cena.
         """
     )
-    
-    # --- Ato 6: A Regência (Lógica de Conexão dos Botões) ---
-    def process_and_update_storyboard(num_fragments, prompt, image_path):
-        processed_path = process_image_to_square(image_path)
-        if not processed_path: raise gr.Error("A imagem de referência é inválida ou não foi fornecida.")
-        storyboard = run_storyboard_generation(num_fragments, prompt, processed_path)
-        return storyboard, prompt, processed_path
+    # --- Lógica de Conexão dos Componentes ---
+    def process_and_run_storyboard(num_fragments, prompt, gallery_files, keyframe_resolution):
+        if not gallery_files:
+            raise gr.Error("Por favor, suba pelo menos uma imagem de referência na galeria.")
+        
+        raw_paths = [item[0] for item in gallery_files]
+        processed_paths = []
+        for i, path in enumerate(raw_paths):
+            filename = f"processed_ref_{i}_{keyframe_resolution}x{keyframe_resolution}.png"
+            processed_path = process_image_to_square(path, keyframe_resolution, filename)
+            processed_paths.append(processed_path)
+
+        storyboard = run_storyboard_generation(num_fragments, prompt, processed_paths)
+        return storyboard, prompt, processed_paths
 
     director_button.click(
-        fn=process_and_update_storyboard, 
-        inputs=[num_fragments_input, prompt_input, image_input], 
-        outputs=[scene_storyboard_state, prompt_geral_state, processed_ref_path_state]
-    ).success(
-        fn=lambda s, p: (s, p),
-        inputs=[scene_storyboard_state, processed_ref_path_state],
-        outputs=[storyboard_to_show, ref1_image]
-    )
-    
-    @photographer_button.click(
-        inputs=[scene_storyboard_state, ref1_image, ref1_task, ref2_image, ref2_task],
+        fn=process_and_run_storyboard,
+        inputs=[num_fragments_input, prompt_input, reference_gallery, keyframe_resolution_selector],
+        outputs=[scene_storyboard_state, prompt_geral_state, processed_ref_paths_state]
+    ).success(fn=lambda s: s, inputs=[scene_storyboard_state], outputs=[storyboard_to_show])
+
+    photographer_button.click(
+        fn=run_keyframe_generation,
+        inputs=[scene_storyboard_state, processed_ref_paths_state, keyframe_resolution_selector, prompt_geral_state],
         outputs=[keyframe_log_output, keyframe_gallery_output, keyframe_images_state]
     )
-    def run_keyframe_generation_wrapper(storyboard, ref1_img, ref1_tsk, ref2_img, ref2_tsk, progress=gr.Progress()):
-        ref_data = [
-            {'image': ref1_img, 'task': ref1_tsk},
-            {'image': ref2_img, 'task': ref2_tsk}
-        ]
-        # Esta chamada agora invoca a função decorada com @spaces.GPU
-        yield from run_keyframe_generation(storyboard, ref_data, progress)
+    
+    def updated_animator_click(
+        video_resolution,
+        video_duration_seconds, video_fps, eco_video_frames, use_attention_slicing,
+        fragment_duration_percentage, mid_cond_strength, dest_cond_strength, num_inference_steps,
+        decode_timestep, image_cond_noise_scale,
+        prompt_geral, keyframe_images_state, scene_storyboard, cfg, progress=gr.Progress()):
+        
+        total_frames = video_duration_seconds * video_fps
+        fragment_duration_in_frames = int(math.floor((fragment_duration_percentage / 100.0) * total_frames))
+        fragment_duration_in_frames = max(1, fragment_duration_in_frames)
+
+        for update in run_video_production(
+            video_resolution,
+            video_duration_seconds, video_fps, eco_video_frames, use_attention_slicing,
+            fragment_duration_in_frames, mid_cond_strength, dest_cond_strength, num_inference_steps,
+            decode_timestep, image_cond_noise_scale,
+            prompt_geral, keyframe_images_state, scene_storyboard, cfg, progress):
+            yield update
+        
+        yield {
+            fragment_duration_state: fragment_duration_in_frames,
+            eco_frames_state: eco_video_frames
+        }
 
     animator_button.click(
-        fn=lambda frag_dur, eco_dur: (frag_dur, eco_dur),
-        inputs=[fragment_duration_slider, eco_frames_slider],
-        outputs=[fragment_duration_state, eco_frames_state]
-    ).then(
-        fn=run_video_production, # Esta função é decorada com @spaces.GPU
+        fn=updated_animator_click,
         inputs=[
-            video_duration_slider, video_fps_slider, eco_frames_slider, slicing_checkbox,
-            fragment_duration_slider, mid_cond_strength_slider,
-            num_inference_steps_slider,
+            video_resolution_selector,
+            video_duration_slider, video_fps_radio, eco_frames_slider, slicing_checkbox,
+            fragment_duration_slider, mid_cond_strength_slider, dest_cond_strength_slider, num_inference_steps_slider,
+            decode_timestep_slider, image_cond_noise_scale_slider,
             prompt_geral_state, keyframe_images_state, scene_storyboard_state, cfg_slider
         ],
         outputs=[
-            production_log_output, video_gallery_glitch, fragment_list_state,
-            prod_media_start_output, prod_media_mid_output, prod_media_end_output
+            production_log_output, video_gallery_output, fragment_list_state,
+            prod_media_start_output, prod_media_mid_output, prod_media_end_output,
+            fragment_duration_state, eco_frames_state
         ]
     )
     
     editor_button.click(
-        fn=concatenate_and_trim_masterpiece, 
-        inputs=[fragment_list_state, fragment_duration_state, eco_frames_state], 
+        fn=concatenate_final_video,
+        inputs=[fragment_list_state, fragment_duration_state, eco_frames_state],
         outputs=[final_video_output]
     )
 
 if __name__ == "__main__":
+    if os.path.exists(WORKSPACE_DIR): shutil.rmtree(WORKSPACE_DIR)
+    os.makedirs(WORKSPACE_DIR); Path("prompts").mkdir(exist_ok=True)
+    
     demo.queue().launch(server_name="0.0.0.0", share=True)

flux_kontext_helpers.py

@@ -0,0 +1,98 @@
+# flux_kontext_helpers.py
+# Módulo de serviço para o FluxKontext, com gestão de memória atômica.
+# Este arquivo é parte do projeto Euia-AducSdr e está sob a licença AGPL v3.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+
+import torch
+from PIL import Image
+import gc
+from diffusers import FluxKontextPipeline
+import huggingface_hub
+import os
+
+class Generator:
+    def __init__(self, device_id='cuda:0'):
+        self.cpu_device = torch.device('cpu')
+        self.gpu_device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
+        print(f"WORKER COMPOSITOR: Usando dispositivo: {self.gpu_device}")
+        self.pipe = None
+        self._load_pipe_to_cpu()
+
+    def _load_pipe_to_cpu(self):
+        if self.pipe is None:
+            print("WORKER COMPOSITOR: Carregando modelo FluxKontext para a CPU...")
+            self.pipe = FluxKontextPipeline.from_pretrained(
+                "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
+            ).to(self.cpu_device)
+            print("WORKER COMPOSITOR: Modelo FluxKontext pronto (na CPU).")
+
+    def to_gpu(self):
+        if self.gpu_device.type == 'cpu': return
+        print(f"WORKER COMPOSITOR: Movendo modelo para {self.gpu_device}...")
+        self.pipe.to(self.gpu_device)
+        print(f"WORKER COMPOSITOR: Modelo na GPU {self.gpu_device}.")
+
+    def to_cpu(self):
+        if self.gpu_device.type == 'cpu': return
+        print(f"WORKER COMPOSITOR: Descarregando modelo da GPU {self.gpu_device}...")
+        self.pipe.to(self.cpu_device)
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    def _concatenate_images(self, images, direction="horizontal"):
+        if not images: return None
+        valid_images = [img.convert("RGB") for img in images if img is not None]
+        if not valid_images: return None
+        if len(valid_images) == 1: return valid_images[0]
+        
+        if direction == "horizontal":
+            total_width = sum(img.width for img in valid_images)
+            max_height = max(img.height for img in valid_images)
+            concatenated = Image.new('RGB', (total_width, max_height))
+            x_offset = 0
+            for img in valid_images:
+                y_offset = (max_height - img.height) // 2
+                concatenated.paste(img, (x_offset, y_offset))
+                x_offset += img.width
+        else:
+            max_width = max(img.width for img in valid_images)
+            total_height = sum(img.height for img in valid_images)
+            concatenated = Image.new('RGB', (max_width, total_height))
+            y_offset = 0
+            for img in valid_images:
+                x_offset = (max_width - img.width) // 2
+                concatenated.paste(img, (x_offset, y_offset))
+                y_offset += img.height
+        return concatenated
+
+    @torch.inference_mode()
+    def generate_image(self, reference_images, prompt, width, height, seed=42):
+        try:
+            self.to_gpu()
+            
+            concatenated_image = self._concatenate_images(reference_images, "horizontal")
+            if concatenated_image is None:
+                raise ValueError("Nenhuma imagem de referência válida foi fornecida.")
+            
+            # ### CORREÇÃO ###
+            # Ignora o tamanho da imagem concatenada e usa os parâmetros `width` e `height` fornecidos.
+            image = self.pipe(
+                image=concatenated_image, 
+                prompt=prompt,
+                guidance_scale=2.5,
+                width=width,
+                height=height,
+                generator=torch.Generator(device="cpu").manual_seed(seed)
+            ).images[0]
+            
+            return image
+        finally:
+            self.to_cpu()
+
+# --- Instância Singleton ---
+print("Inicializando o Compositor de Cenas (FluxKontext)...")
+hf_token = os.getenv('HF_TOKEN')
+if hf_token: huggingface_hub.login(token=hf_token)
+flux_kontext_singleton = Generator(device_id='cuda:0')
+print("Compositor de Cenas pronto.")

ltx_helpers.py

@@ -0,0 +1,190 @@
+# ltx_manager_helpers.py
+# Gerente de Pool de Workers LTX para revezamento assíncrono em múltiplas GPUs.
+# Este arquivo é parte do projeto Euia-AducSdr e está sob a licença AGPL v3.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+
+import torch
+import gc
+import os
+import yaml
+import numpy as np
+import imageio
+from pathlib import Path
+import huggingface_hub
+import threading
+from PIL import Image
+
+# Importa as funções e classes necessárias do inference.py
+from inference import (
+    create_ltx_video_pipeline,
+    ConditioningItem,
+    calculate_padding,
+    prepare_conditioning
+)
+
+class LtxWorker:
+    """
+    Representa uma única instância do pipeline LTX, associada a uma GPU específica.
+    O pipeline é carregado na CPU por padrão e movido para a GPU sob demanda.
+    """
+    def __init__(self, device_id='cuda:0'):
+        self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
+        print(f"LTX Worker: Inicializando para o dispositivo {self.device} (carregando na CPU)...")
+        
+        config_file_path = "configs/ltxv-13b-0.9.8-distilled.yaml"
+        with open(config_file_path, "r") as file:
+            self.config = yaml.safe_load(file)
+
+        LTX_REPO = "Lightricks/LTX-Video"
+        models_dir = "downloaded_models_gradio"
+        
+        distilled_model_actual_path = huggingface_hub.hf_hub_download(
+            repo_id=LTX_REPO,
+            filename=self.config["checkpoint_path"],
+            local_dir=models_dir,
+            local_dir_use_symlinks=False
+        )
+        
+        self.pipeline = create_ltx_video_pipeline(
+            ckpt_path=distilled_model_actual_path,
+            precision=self.config["precision"],
+            text_encoder_model_name_or_path=self.config["text_encoder_model_name_or_path"],
+            sampler=self.config["sampler"],
+            device='cpu'
+        )
+        print(f"LTX Worker para {self.device} pronto na CPU.")
+
+    def to_gpu(self):
+        """Move o pipeline para a GPU designada."""
+        if self.device.type == 'cpu': return
+        print(f"LTX Worker: Movendo pipeline para {self.device}...")
+        self.pipeline.to(self.device)
+        print(f"LTX Worker: Pipeline na GPU {self.device}.")
+
+    def to_cpu(self):
+        """Move o pipeline de volta para a CPU e limpa a memória da GPU."""
+        if self.device.type == 'cpu': return
+        print(f"LTX Worker: Descarregando pipeline da GPU {self.device}...")
+        self.pipeline.to('cpu')
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        print(f"LTX Worker: GPU {self.device} limpa.")
+    
+    def generate_video_fragment_internal(self, **kwargs):
+        """A lógica real da geração de vídeo, que espera estar na GPU."""
+        return self.pipeline(**kwargs)
+
+class LtxPoolManager:
+    """
+    Gerencia um pool de LtxWorkers, orquestrando um revezamento entre GPUs
+    para permitir que a limpeza de uma GPU ocorra em paralelo com a computação em outra.
+    """
+    def __init__(self, device_ids=['cuda:2', 'cuda:3']):
+        print(f"LTX POOL MANAGER: Criando workers para os dispositivos: {device_ids}")
+        self.workers = [LtxWorker(device_id) for device_id in device_ids]
+        self.current_worker_index = 0
+        self.lock = threading.Lock()
+        self.last_cleanup_thread = None
+
+    def _cleanup_worker(self, worker):
+        """Função alvo para a thread de limpeza."""
+        print(f"CLEANUP THREAD: Iniciando limpeza da GPU {worker.device} em background...")
+        worker.to_cpu()
+        print(f"CLEANUP THREAD: Limpeza da GPU {worker.device} concluída.")
+
+    def generate_video_fragment(
+        self,
+        motion_prompt: str, conditioning_items_data: list,
+        width: int, height: int, seed: int, cfg: float, video_total_frames: int,
+        video_fps: int, num_inference_steps: int, use_attention_slicing: bool,
+        current_fragment_index: int, output_path: str, progress
+    ):
+        worker_to_use = None
+        try:
+            with self.lock:
+                # 1. Espera a limpeza da thread anterior, se ainda estiver rodando.
+                if self.last_cleanup_thread and self.last_cleanup_thread.is_alive():
+                    print("LTX POOL MANAGER: Aguardando limpeza da GPU anterior...")
+                    self.last_cleanup_thread.join()
+                    print("LTX POOL MANAGER: Limpeza anterior concluída.")
+
+                # 2. Seleciona o worker ATUAL para o trabalho
+                worker_to_use = self.workers[self.current_worker_index]
+                
+                # 3. Seleciona o worker ANTERIOR para iniciar a limpeza
+                previous_worker_index = (self.current_worker_index - 1 + len(self.workers)) % len(self.workers)
+                worker_to_cleanup = self.workers[previous_worker_index]
+
+                # 4. Dispara a limpeza do worker ANTERIOR em uma nova thread
+                cleanup_thread = threading.Thread(target=self._cleanup_worker, args=(worker_to_cleanup,))
+                cleanup_thread.start()
+                self.last_cleanup_thread = cleanup_thread
+                
+                # 5. Prepara o worker ATUAL para a computação
+                worker_to_use.to_gpu()
+                
+                # 6. Atualiza o índice para a PRÓXIMA chamada
+                self.current_worker_index = (self.current_worker_index + 1) % len(self.workers)
+            
+            # --- A GERAÇÃO OCORRE FORA DO LOCK ---
+            target_device = worker_to_use.device
+            
+            if use_attention_slicing:
+                worker_to_use.pipeline.enable_attention_slicing()
+
+            media_paths = [item[0] for item in conditioning_items_data]
+            start_frames = [item[1] for item in conditioning_items_data]
+            strengths = [item[2] for item in conditioning_items_data]
+
+            padded_h, padded_w = ((height - 1) // 32 + 1) * 32, ((width - 1) // 32 + 1) * 32
+            padding_vals = calculate_padding(height, width, padded_h, padded_w)
+
+            conditioning_items = prepare_conditioning(
+                conditioning_media_paths=media_paths, conditioning_strengths=strengths,
+                conditioning_start_frames=start_frames, height=height, width=width,
+                num_frames=video_total_frames, padding=padding_vals, pipeline=worker_to_use.pipeline,
+            )
+            
+            for item in conditioning_items:
+                item.media_item = item.media_item.to(target_device)
+
+            first_pass_config = worker_to_use.config.get("first_pass", {}).copy()
+            first_pass_config['num_inference_steps'] = int(num_inference_steps)
+
+            kwargs = {
+                "prompt": motion_prompt, "negative_prompt": "blurry, distorted, bad quality, artifacts",
+                "height": padded_h, "width": padded_w, "num_frames": video_total_frames,
+                "frame_rate": video_fps,
+                "generator": torch.Generator(device=target_device).manual_seed(int(seed) + current_fragment_index),
+                "output_type": "pt", "guidance_scale": float(cfg),
+                "timesteps": first_pass_config.get("timesteps"),
+                "conditioning_items": conditioning_items,
+                "decode_timestep": worker_to_use.config.get("decode_timestep"),
+                "decode_noise_scale": worker_to_use.config.get("decode_noise_scale"),
+                "stochastic_sampling": worker_to_use.config.get("stochastic_sampling"),
+                "image_cond_noise_scale": 0.15, "is_video": True, "vae_per_channel_normalize": True,
+                "mixed_precision": (worker_to_use.config.get("precision") == "mixed_precision"),
+                "enhance_prompt": False, "decode_every": 4, "num_inference_steps": int(num_inference_steps)
+            }
+            
+            progress(0.1, desc=f"[Câmera LTX em {worker_to_use.device}] Filmando Cena {current_fragment_index}...")
+            result_tensor = worker_to_use.generate_video_fragment_internal(**kwargs).images
+            
+            pad_l, pad_r, pad_t, pad_b = map(int, padding_vals); slice_h = -pad_b if pad_b > 0 else None; slice_w = -pad_r if pad_r > 0 else None
+            cropped_tensor = result_tensor[:, :, :video_total_frames, pad_t:slice_h, pad_l:slice_w]
+            video_np = (cropped_tensor[0].permute(1, 2, 3, 0).cpu().float().numpy() * 255).astype(np.uint8)
+            
+            with imageio.get_writer(output_path, fps=video_fps, codec='libx264', quality=8) as writer:
+                for frame in video_np: writer.append_data(frame)
+            
+            return output_path, video_total_frames
+
+        finally:
+            if use_attention_slicing and worker_to_use and worker_to_use.pipeline:
+                worker_to_use.pipeline.disable_attention_slicing()
+            # A limpeza do worker_to_use será feita na PRÓXIMA chamada a esta função.
+
+# Singleton do Gerenciador de Pool
+# Por padrão, usa cuda:2 e cuda:3. Altere aqui se necessário.
+ltx_manager_singleton = LtxPoolManager(device_ids=['cuda:2', 'cuda:3'])

ltx_manager_helpers.py

@@ -0,0 +1,181 @@
+# ltx_manager_helpers.py
+# Gerente de Pool de Workers LTX para revezamento assíncrono em múltiplas GPUs.
+# Este arquivo é parte do projeto Euia-AducSdr e está sob a licença AGPL v3.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+
+import torch
+import gc
+import os
+import yaml
+import numpy as np
+import imageio
+from pathlib import Path
+import huggingface_hub
+import threading
+from PIL import Image
+
+# Importa as funções e classes necessárias do inference.py
+from inference import (
+    create_ltx_video_pipeline,
+    ConditioningItem,
+    calculate_padding,
+    prepare_conditioning
+)
+
+class LtxWorker:
+    """
+    Representa uma única instância do pipeline LTX, associada a uma GPU específica.
+    O pipeline é carregado na CPU por padrão e movido para a GPU sob demanda.
+    """
+    def __init__(self, device_id='cuda:0'):
+        self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
+        print(f"LTX Worker: Inicializando para o dispositivo {self.device} (carregando na CPU)...")
+        
+        config_file_path = "configs/ltxv-13b-0.9.8-distilled.yaml"
+        with open(config_file_path, "r") as file:
+            self.config = yaml.safe_load(file)
+
+        LTX_REPO = "Lightricks/LTX-Video"
+        models_dir = "downloaded_models_gradio"
+        
+        distilled_model_actual_path = huggingface_hub.hf_hub_download(
+            repo_id=LTX_REPO,
+            filename=self.config["checkpoint_path"],
+            local_dir=models_dir,
+            local_dir_use_symlinks=False
+        )
+        
+        self.pipeline = create_ltx_video_pipeline(
+            ckpt_path=distilled_model_actual_path,
+            precision=self.config["precision"],
+            text_encoder_model_name_or_path=self.config["text_encoder_model_name_or_path"],
+            sampler=self.config["sampler"],
+            device='cpu'
+        )
+        print(f"LTX Worker para {self.device} pronto na CPU.")
+
+    def to_gpu(self):
+        """Move o pipeline para a GPU designada."""
+        if self.device.type == 'cpu': return
+        print(f"LTX Worker: Movendo pipeline para {self.device}...")
+        self.pipeline.to(self.device)
+        print(f"LTX Worker: Pipeline na GPU {self.device}.")
+
+    def to_cpu(self):
+        """Move o pipeline de volta para a CPU e limpa a memória da GPU."""
+        if self.device.type == 'cpu': return
+        print(f"LTX Worker: Descarregando pipeline da GPU {self.device}...")
+        self.pipeline.to('cpu')
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        print(f"LTX Worker: GPU {self.device} limpa.")
+    
+    def generate_video_fragment_internal(self, **kwargs):
+        """A lógica real da geração de vídeo, que espera estar na GPU."""
+        return self.pipeline(**kwargs)
+
+class LtxPoolManager:
+    """
+    Gerencia um pool de LtxWorkers, orquestrando um revezamento entre GPUs
+    para permitir que a limpeza de uma GPU ocorra em paralelo com a computação em outra.
+    """
+    def __init__(self, device_ids=['cuda:0', 'cuda:1']):
+        print(f"LTX POOL MANAGER: Criando workers para os dispositivos: {device_ids}")
+        self.workers = [LtxWorker(device_id) for device_id in device_ids]
+        self.current_worker_index = 0
+        self.lock = threading.Lock()
+        self.last_cleanup_thread = None
+
+    def _cleanup_worker(self, worker):
+        """Função alvo para a thread de limpeza."""
+        print(f"CLEANUP THREAD: Iniciando limpeza da GPU {worker.device} em background...")
+        worker.to_cpu()
+        print(f"CLEANUP THREAD: Limpeza da GPU {worker.device} concluída.")
+
+    def generate_video_fragment(
+        self,
+        motion_prompt: str, conditioning_items_data: list,
+        width: int, height: int, seed: int, cfg: float, video_total_frames: int,
+        video_fps: int, num_inference_steps: int, use_attention_slicing: bool,
+        decode_timestep: float, image_cond_noise_scale: float,
+        current_fragment_index: int, output_path: str, progress
+    ):
+        worker_to_use = None
+        try:
+            with self.lock:
+                if self.last_cleanup_thread and self.last_cleanup_thread.is_alive():
+                    print("LTX POOL MANAGER: Aguardando limpeza da GPU anterior...")
+                    self.last_cleanup_thread.join()
+                    print("LTX POOL MANAGER: Limpeza anterior concluída.")
+
+                worker_to_use = self.workers[self.current_worker_index]
+                previous_worker_index = (self.current_worker_index - 1 + len(self.workers)) % len(self.workers)
+                worker_to_cleanup = self.workers[previous_worker_index]
+
+                cleanup_thread = threading.Thread(target=self._cleanup_worker, args=(worker_to_cleanup,))
+                cleanup_thread.start()
+                self.last_cleanup_thread = cleanup_thread
+                
+                worker_to_use.to_gpu()
+                
+                self.current_worker_index = (self.current_worker_index + 1) % len(self.workers)
+            
+            target_device = worker_to_use.device
+            
+            if use_attention_slicing:
+                worker_to_use.pipeline.enable_attention_slicing()
+
+            media_paths = [item[0] for item in conditioning_items_data]
+            start_frames = [item[1] for item in conditioning_items_data]
+            strengths = [item[2] for item in conditioning_items_data]
+
+            padded_h, padded_w = ((height - 1) // 32 + 1) * 32, ((width - 1) // 32 + 1) * 32
+            padding_vals = calculate_padding(height, width, padded_h, padded_w)
+
+            conditioning_items = prepare_conditioning(
+                conditioning_media_paths=media_paths, conditioning_strengths=strengths,
+                conditioning_start_frames=start_frames, height=height, width=width,
+                num_frames=video_total_frames, padding=padding_vals, pipeline=worker_to_use.pipeline,
+            )
+            
+            for item in conditioning_items:
+                item.media_item = item.media_item.to(target_device)
+
+            first_pass_config = worker_to_use.config.get("first_pass", {}).copy()
+            first_pass_config['num_inference_steps'] = int(num_inference_steps)
+
+            kwargs = {
+                "prompt": motion_prompt, "negative_prompt": "blurry, distorted, bad quality, artifacts",
+                "height": padded_h, "width": padded_w, "num_frames": video_total_frames,
+                "frame_rate": video_fps,
+                "generator": torch.Generator(device=target_device).manual_seed(int(seed) + current_fragment_index),
+                "output_type": "pt", "guidance_scale": float(cfg),
+                "timesteps": first_pass_config.get("timesteps"),
+                "conditioning_items": conditioning_items,
+                "decode_timestep": decode_timestep,
+                "decode_noise_scale": worker_to_use.config.get("decode_noise_scale"),
+                "image_cond_noise_scale": image_cond_noise_scale,
+                "stochastic_sampling": worker_to_use.config.get("stochastic_sampling"),
+                "is_video": True, "vae_per_channel_normalize": True,
+                "mixed_precision": (worker_to_use.config.get("precision") == "mixed_precision"),
+                "enhance_prompt": False, "decode_every": 4, "num_inference_steps": int(num_inference_steps)
+            }
+            
+            progress(0.1, desc=f"[Câmera LTX em {worker_to_use.device}] Filmando Cena {current_fragment_index}...")
+            result_tensor = worker_to_use.generate_video_fragment_internal(**kwargs).images
+            
+            pad_l, pad_r, pad_t, pad_b = map(int, padding_vals); slice_h = -pad_b if pad_b > 0 else None; slice_w = -pad_r if pad_r > 0 else None
+            cropped_tensor = result_tensor[:, :, :video_total_frames, pad_t:slice_h, pad_l:slice_w]
+            video_np = (cropped_tensor[0].permute(1, 2, 3, 0).cpu().float().numpy() * 255).astype(np.uint8)
+            
+            with imageio.get_writer(output_path, fps=video_fps, codec='libx264', quality=8) as writer:
+                for frame in video_np: writer.append_data(frame)
+            
+            return output_path, video_total_frames
+
+        finally:
+            if use_attention_slicing and worker_to_use and worker_to_use.pipeline:
+                worker_to_use.pipeline.disable_attention_slicing()
+
+ltx_manager_singleton = LtxPoolManager(device_ids=['cuda:1', 'cuda:2'])

ltx_upscaler_manager_helpers.py

@@ -0,0 +1,62 @@
+# ltx_upscaler_manager_helpers.py
+# Gerente de Pool para o revezamento de workers de Upscaling.
+# Este arquivo é parte do projeto Euia-AducSdr e está sob a licença AGPL v3.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+
+import torch
+import gc
+import os
+import threading
+from ltx_worker_upscaler import LtxUpscaler
+
+class LtxUpscalerPoolManager:
+    """
+    Gerencia um pool de LtxUpscalerWorkers, orquestrando um revezamento entre GPUs
+    para a tarefa de upscaling.
+    """
+    def __init__(self, device_ids=['cuda:2', 'cuda:3']):
+        print(f"LTX UPSCALER POOL MANAGER: Criando workers para os dispositivos: {device_ids}")
+        self.workers = [LtxUpscaler(device_id) for device_id in device_ids]
+        self.current_worker_index = 0
+        self.lock = threading.Lock()
+        self.last_cleanup_thread = None
+
+    def _cleanup_worker(self, worker):
+        """Função alvo para a thread de limpeza em background."""
+        print(f"UPSCALER CLEANUP THREAD: Iniciando limpeza da GPU {worker.device}...")
+        worker.to_cpu()
+        print(f"UPSCALER CLEANUP THREAD: Limpeza da GPU {worker.device} concluída.")
+
+    def upscale_video_fragment(self, video_path_low_res: str, output_path: str, video_fps: int):
+        """
+        Seleciona um worker livre, faz o upscale de um fragmento e limpa o worker anterior.
+        """
+        worker_to_use = None
+        try:
+            with self.lock:
+                if self.last_cleanup_thread and self.last_cleanup_thread.is_alive():
+                    print("UPSCALER POOL MANAGER: Aguardando limpeza da GPU anterior...")
+                    self.last_cleanup_thread.join()
+
+                worker_to_use = self.workers[self.current_worker_index]
+                previous_worker_index = (self.current_worker_index - 1 + len(self.workers)) % len(self.workers)
+                worker_to_cleanup = self.workers[previous_worker_index]
+
+                cleanup_thread = threading.Thread(target=self._cleanup_worker, args=(worker_to_cleanup,))
+                cleanup_thread.start()
+                self.last_cleanup_thread = cleanup_thread
+                
+                worker_to_use.to_gpu()
+                
+                self.current_worker_index = (self.current_worker_index + 1) % len(self.workers)
+            
+            print(f"UPSCALER POOL MANAGER: Worker em {worker_to_use.device} iniciando upscale de {os.path.basename(video_path_low_res)}...")
+            worker_to_use.upscale_video_fragment(video_path_low_res, output_path, video_fps)
+            print(f"UPSCALER POOL MANAGER: Upscale de {os.path.basename(video_path_low_res)} concluído.")
+
+        finally:
+            # A limpeza do worker_to_use será feita na próxima chamada
+            pass
+
+# --- Instância Singleton do Gerenciador de Upscaling ---
+ltx_upscaler_manager_singleton = LtxUpscalerPoolManager(device_ids=['cuda:2', 'cuda:3'])

ltx_worker_base.py

@@ -0,0 +1,133 @@
+# ltx_worker_base.py (GPU-C: cuda:2)
+# Worker para gerar os fragmentos de vídeo em resolução base.
+# Este arquivo é parte do projeto Euia-AducSdr e está sob a licença AGPL v3.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+
+import torch
+import gc
+import os
+import yaml
+import numpy as np 
+import imageio
+from pathlib import Path
+import huggingface_hub
+
+from inference import (
+    create_ltx_video_pipeline,
+    ConditioningItem,
+    calculate_padding,
+    prepare_conditioning
+)
+
+class LtxGenerator:
+    def __init__(self, device_id='cuda:2'):
+        print(f"WORKER CÂMERA-BASE: Inicializando...")
+        self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
+        print(f"WORKER CÂMERA-BASE: Usando dispositivo: {self.device}")
+        
+        config_file_path = "configs/ltxv-13b-0.9.8-distilled.yaml"
+        with open(config_file_path, "r") as file:
+            self.config = yaml.safe_load(file)
+
+        LTX_REPO = "Lightricks/LTX-Video"
+        models_dir = "downloaded_models_gradio"
+        Path(models_dir).mkdir(parents=True, exist_ok=True)
+
+        print("WORKER CÂMERA-BASE: Carregando pipeline LTX na CPU (estado de repouso)...")
+        distilled_model_actual_path = huggingface_hub.hf_hub_download(
+            repo_id=LTX_REPO,
+            filename=self.config["checkpoint_path"],
+            local_dir=models_dir,
+            local_dir_use_symlinks=False
+        )
+        
+        self.pipeline = create_ltx_video_pipeline(
+            ckpt_path=distilled_model_actual_path,
+            precision=self.config["precision"],
+            text_encoder_model_name_or_path=self.config["text_encoder_model_name_or_path"],
+            sampler=self.config["sampler"],
+            device='cpu'
+        )
+        print("WORKER CÂMERA-BASE: Pronto (na CPU).")
+
+    def to_gpu(self):
+        if self.pipeline and torch.cuda.is_available():
+            print(f"WORKER CÂMERA-BASE: Movendo LTX para {self.device}...")
+            self.pipeline.to(self.device)
+
+    def to_cpu(self):
+        if self.pipeline:
+            print(f"WORKER CÂMERA-BASE: Descarregando LTX da GPU {self.device}...")
+            self.pipeline.to('cpu')
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+    def generate_video_fragment(
+        self, motion_prompt: str, conditioning_items_data: list,
+        width: int, height: int, seed: int, cfg: float, video_total_frames: int,
+        video_fps: int, num_inference_steps: int, use_attention_slicing: bool,
+        current_fragment_index: int, output_path: str, progress
+    ):
+        progress(0.1, desc=f"[Câmera LTX Base] Filmando Cena {current_fragment_index}...")
+        
+        target_device = self.pipeline.device
+        
+        if use_attention_slicing:
+            self.pipeline.enable_attention_slicing()
+
+        media_paths = [item[0] for item in conditioning_items_data]
+        start_frames = [item[1] for item in conditioning_items_data]
+        strengths = [item[2] for item in conditioning_items_data]
+
+        padded_h, padded_w = ((height - 1) // 32 + 1) * 32, ((width - 1) // 32 + 1) * 32
+        padding_vals = calculate_padding(height, width, padded_h, padded_w)
+
+        conditioning_items = prepare_conditioning(
+            conditioning_media_paths=media_paths, conditioning_strengths=strengths,
+            conditioning_start_frames=start_frames, height=height, width=width,
+            num_frames=video_total_frames, padding=padding_vals, pipeline=self.pipeline,
+        )
+        
+        for item in conditioning_items:
+            item.media_item = item.media_item.to(target_device)
+
+        actual_num_frames = int(round((float(video_total_frames) - 1.0) / 8.0) * 8 + 1)
+        first_pass_config = self.config.get("first_pass", {}).copy()
+        first_pass_config['num_inference_steps'] = int(num_inference_steps)
+
+        kwargs = {
+            "prompt": motion_prompt, "negative_prompt": "blurry, distorted, bad quality, artifacts",
+            "height": padded_h, "width": padded_w, "num_frames": actual_num_frames,
+            "frame_rate": video_fps,
+            "generator": torch.Generator(device=target_device).manual_seed(int(seed) + current_fragment_index),
+            "output_type": "pt", "guidance_scale": float(cfg),
+            "timesteps": first_pass_config.get("timesteps"),
+            "conditioning_items": conditioning_items,
+            "decode_timestep": self.config.get("decode_timestep"),
+            "decode_noise_scale": self.config.get("decode_noise_scale"),
+            "stochastic_sampling": self.config.get("stochastic_sampling"),
+            "image_cond_noise_scale": 0.15, "is_video": True, "vae_per_channel_normalize": True,
+            "mixed_precision": (self.config.get("precision") == "mixed_precision"),
+            "enhance_prompt": False, "decode_every": 4, "num_inference_steps": int(num_inference_steps)
+        }
+        
+        result_tensor = self.pipeline(**kwargs).images
+        
+        pad_l, pad_r, pad_t, pad_b = map(int, padding_vals)
+        slice_h = -pad_b if pad_b > 0 else None; slice_w = -pad_r if pad_r > 0 else None
+        
+        cropped_tensor = result_tensor[:, :, :actual_num_frames, pad_t:slice_h, pad_l:slice_w]
+        video_np = (cropped_tensor[0].permute(1, 2, 3, 0).cpu().float().numpy() * 255).astype(np.uint8)
+        
+        with imageio.get_writer(output_path, fps=video_fps, codec='libx264', quality=8) as writer:
+            for frame in video_np:
+                writer.append_data(frame)
+        
+        if use_attention_slicing and self.pipeline:
+            self.pipeline.disable_attention_slicing()
+
+        return output_path, actual_num_frames
+
+# --- Instância Singleton para o Worker Base ---
+ltx_base_singleton = LtxGenerator(device_id='cuda:2')

ltx_worker_upscaler.py

@@ -0,0 +1,99 @@
+# ltx_worker_upscaler.py (Corrigido com dtype=bfloat16)
+# Worker para fazer upscale dos fragmentos de vídeo para alta resolução.
+# Este arquivo é parte do projeto Euia-AducSdr e está sob a licença AGPL v3.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+
+import torch
+import gc
+import os
+import yaml
+import numpy as np 
+import imageio
+from pathlib import Path
+import huggingface_hub
+from einops import rearrange
+
+from inference import create_ltx_video_pipeline
+from ltx_video.models.autoencoders.latent_upsampler import LatentUpsampler
+from ltx_video.models.autoencoders.vae_encode import vae_encode, vae_decode
+
+class LtxUpscaler:
+    def __init__(self, device_id='cuda:2'):
+        print(f"WORKER CÂMERA-UPSCALER: Inicializando para {device_id}...")
+        self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
+        self.model_dtype = torch.bfloat16 # <<<--- DEFINIR O DTYPE DO MODELO
+        
+        config_file_path = "configs/ltxv-13b-0.9.8-distilled.yaml"
+        with open(config_file_path, "r") as file:
+            self.config = yaml.safe_load(file)
+
+        LTX_REPO = "Lightricks/LTX-Video"
+        models_dir = "downloaded_models_gradio"
+        Path(models_dir).mkdir(parents=True, exist_ok=True)
+
+        print(f"WORKER CÂMERA-UPSCALER ({self.device}): Carregando VAE na CPU...")
+        distilled_model_actual_path = huggingface_hub.hf_hub_download(
+            repo_id=LTX_REPO, filename=self.config["checkpoint_path"],
+            local_dir=models_dir, local_dir_use_symlinks=False
+        )
+        temp_pipeline = create_ltx_video_pipeline(
+            ckpt_path=distilled_model_actual_path, precision=self.config["precision"],
+            text_encoder_model_name_or_path=self.config["text_encoder_model_name_or_path"],
+            sampler=self.config["sampler"], device='cpu'
+        )
+        self.vae = temp_pipeline.vae.to(self.model_dtype) # <<<--- CARREGA NO DTYPE CORRETO
+        del temp_pipeline
+        gc.collect()
+
+        print(f"WORKER CÂMERA-UPSCALER ({self.device}): Carregando Latent Upsampler na CPU...")
+        upscaler_path = huggingface_hub.hf_hub_download(
+            repo_id=LTX_REPO, filename=self.config["spatial_upscaler_model_path"],
+            local_dir=models_dir, local_dir_use_symlinks=False
+        )
+        self.latent_upsampler = LatentUpsampler.from_pretrained(upscaler_path).to(self.model_dtype) # <<<--- CARREGA NO DTYPE CORRETO
+        self.latent_upsampler.to('cpu')
+        
+        print(f"WORKER CÂMERA-UPSCALER ({self.device}): Pronto (na CPU).")
+
+    def to_gpu(self):
+        if self.latent_upsampler and self.vae and torch.cuda.is_available():
+            print(f"WORKER CÂMERA-UPSCALER: Movendo modelos para {self.device}...")
+            self.latent_upsampler.to(self.device)
+            self.vae.to(self.device)
+
+    def to_cpu(self):
+        if self.latent_upsampler and self.vae:
+            print(f"WORKER CÂMERA-UPSCALER: Descarregando modelos da GPU {self.device}...")
+            self.latent_upsampler.to('cpu')
+            self.vae.to('cpu')
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+    
+    @torch.no_grad()
+    def upscale_video_fragment(self, video_path_low_res: str, output_path: str, video_fps: int):
+        print(f"UPSCALER ({self.device}): Processando {os.path.basename(video_path_low_res)}")
+        
+        with imageio.get_reader(video_path_low_res) as reader:
+            video_frames = [frame for frame in reader]
+        video_np = np.stack(video_frames)
+        
+        # <<<--- CORREÇÃO CRÍTICA AQUI ---_>>>
+        video_tensor = torch.from_numpy(video_np).permute(0, 3, 1, 2).float() / 255.0
+        video_tensor = (video_tensor * 2.0) - 1.0
+        video_tensor = video_tensor.unsqueeze(0).permute(0, 2, 1, 3, 4)
+        video_tensor = video_tensor.to(self.device, dtype=self.model_dtype) # Envia para GPU JÁ NO DTYPE CORRETO
+
+        latents = vae_encode(video_tensor, self.vae)
+        upsampled_latents = self.latent_upsampler(latents)
+        upsampled_video_tensor = vae_decode(upsampled_latents, self.vae, is_video=True)
+        
+        upsampled_video_tensor = (upsampled_video_tensor.clamp(-1, 1) + 1) / 2.0
+        video_np_high_res = (upsampled_video_tensor[0].permute(1, 2, 3, 0).cpu().float().numpy() * 255).astype(np.uint8) # Converte de volta para float para salvar
+        
+        with imageio.get_writer(output_path, fps=video_fps, codec='libx264', quality=8) as writer:
+            for frame in video_np_high_res:
+                writer.append_data(frame)
+
+        print(f"UPSCALER ({self.device}): Arquivo salvo em {os.path.basename(output_path)}")
+        return output_path

requirements.txt

@@ -11,16 +11,17 @@ torchvision
 huggingface_hub>=0.20.0
 spaces
 opencv-python
-huggingface_hub
 imageio
 imageio-ffmpeg
 einops
 timm
+safetensors
+
 av
-#git+https://github.com/huggingface/diffusers.git@main
+git+https://github.com/huggingface/diffusers.git@main
 torch
 peft
-diffusers==0.31.0
-transformers==4.45.2
-accelerate==0.32.0
+#diffusers==0.31.0
+transformers
+accelerate
 git+https://github.com/ToTheBeginning/facexlib.git