feat: ✨ aBINC 2.2

.gitignore

@@ -0,0 +1,16 @@
+# Ignorar dependências clonadas
+/deps/
+
+# Ignorar o diretório do workspace da aplicação
+/deformes_workspace/
+
+# Ignorar arquivos de cache do Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Ignorar logs e arquivos de ambiente
+*.log
+aduc_log.txt
+.env

Dockerfile

@@ -0,0 +1,480 @@
+# =============================================================================
+# DOCKERFILE - Complete AI Video Suite v2.0.0
+# Optimized for 8x NVIDIA L40S GPUs (384GB Total VRAM)
+# Production-Ready Multi-GPU Video Generation Suite
+# =============================================================================
+
+FROM nvidia/cuda:12.8.0-devel-ubuntu22.04
+
+# =============================================================================
+# METADATA AND LABELS
+# =============================================================================
+
+LABEL maintainer="Complete AI Video Suite Team"
+LABEL description="Multi-GPU AI Video Generation Suite with LTX FP8, Q8 Kernels, SeedVR, Wan2.2, VINCIE, MMAudio"
+LABEL version="2.0.0"
+LABEL build_date="2025-09-18"
+LABEL cuda_version="12.4.0"
+LABEL python_version="3.10"
+LABEL pytorch_version="2.8.0+cu128"
+LABEL architecture="amd64"
+LABEL gpu_optimized="8x_L40S"
+LABEL total_vram="384GB"
+LABEL license="MIT"
+
+
+# =============================================================================
+# ENVIRONMENT VARIABLES - PRODUCTION OPTIMIZED
+# =============================================================================
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=UTC
+ENV LC_ALL=C.UTF-8
+ENV LANG=C.UTF-8
+
+# Python optimization
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONIOENCODING=utf-8
+ENV PIP_NO_CACHE_DIR=1
+ENV PIP_DISABLE_PIP_VERSION_CHECK=0
+
+# CUDA optimizations for 8x L40S GPUs
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility,graphics
+ENV NVIDIA_REQUIRE_CUDA="cuda>=12.8"
+ENV CUDA_LAUNCH_BLOCKING=0
+ENV TORCH_CUDA_ARCH_LIST="8.9"
+ENV CUDA_CACHE_MAXSIZE=2147483648
+
+# Multi-GPU distributed training
+ENV NCCL_DEBUG=DEBUG
+ENV NCCL_TREE_THRESHOLD=1
+ENV NCCL_P2P_DISABLE=0
+ENV NCCL_IB_DISABLE=0
+ENV NCCL_NVLS_ENABLE=1
+ENV NCCL_CROSS_NIC=1
+
+# PyTorch optimizations
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512,roundup_power2_divisions:16
+ENV TORCH_BACKENDS_CUDNN_BENCHMARK=1
+ENV TORCH_BACKENDS_CUDA_MATMUL_ALLOW_TF32=1
+ENV TORCH_BACKENDS_CUDNN_ALLOW_TF32=1
+
+# Application paths
+ENV APP_HOME=/app
+ENV HF_HOME=/app/model_cache
+ENV HF_HUB_CACHE=/app/model_cache/hub
+ENV TRANSFORMERS_CACHE=/app/model_cache/transformers
+ENV TORCH_HOME=/app/model_cache/torch
+ENV TMPDIR=/app/tmp
+ENV OUTPUT_DIR=/app/outputs
+
+# CPU optimizations
+ENV OMP_NUM_THREADS=8
+ENV MKL_NUM_THREADS=8
+ENV NUMEXPR_NUM_THREADS=8
+ENV OPENBLAS_NUM_THREADS=8
+
+# =============================================================================
+# SYSTEM PACKAGE INSTALLATION
+# =============================================================================
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    ninja-build \
+    pkg-config \
+    python3.11 \
+    python3.11-dev \
+    python3.11-distutils \
+    python3-pip \
+    python3.11-venv \
+    git \
+    git-lfs \
+    curl \
+    wget \
+    rsync \
+    unzip \
+    zip \
+    ffmpeg \
+    libavcodec-dev \
+    libavformat-dev \
+    libavutil-dev \
+    libswscale-dev \
+    libgl1-mesa-glx \
+    libgl1-mesa-dev \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libglu1-mesa \
+    libglu1-mesa-dev \
+    htop \
+    nvtop \
+    tree \
+    vim \
+    nano \
+    tmux \
+    screen \
+    net-tools \
+    iproute2 \
+    iotop \
+    && apt-get autoremove -y \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* \
+    && rm -rf /tmp/* \
+    && rm -rf /var/tmp/*
+
+# =============================================================================
+# PYTHON SETUP AND OPTIMIZATION
+# =============================================================================
+
+RUN ln -sf /usr/bin/python3.10 /usr/bin/python3 && \
+    ln -sf /usr/bin/python3.10 /usr/bin/python && \
+    python3 -m pip install --upgrade pip==24.2 setuptools==70.0.0 wheel==0.43.0
+
+RUN pip install  \
+    packaging \
+    ninja \
+    cmake \
+    pybind11 \
+    scikit-build \
+    cython \
+    numpy>=1.24.3
+
+# =============================================================================
+# PYTORCH AND CUDA LIBRARIES
+# =============================================================================
+
+RUN pip install \
+    torch>=2.8.0+cu128 \
+    torchvision \
+    torchaudio \
+    --index-url https://download.pytorch.org/whl/cu128
+
+RUN pip install torchao
+
+RUN python3 -c "import torch; print(f'PyTorch: {torch.__version__}'); print(f'CUDA available: {torch.cuda.is_available()}'); print(f'CUDA version: {torch.version.cuda}'); print(f'Device count: {torch.cuda.device_count()}')"
+
+
+# =============================================================================
+# AI/ML LIBRARIES INSTALLATION
+# =============================================================================
+
+WORKDIR $APP_HOME
+COPY . .
+
+RUN pip install -r requirements.txt
+
+# =============================================================================
+# APPLICATION STRUCTURE SETUP
+# =============================================================================
+
+RUN mkdir -p \
+    $APP_HOME/installer \
+    $APP_HOME/monitoring \
+    $APP_HOME/tools \
+    $APP_HOME/configs \
+    $APP_HOME/build_cache \
+    $APP_HOME/model_cache/hub \
+    $APP_HOME/model_cache/transformers \
+    $APP_HOME/model_cache/torch \
+    $APP_HOME/model_cache/ltx_models \
+    $APP_HOME/tmp \
+    $APP_HOME/outputs \
+    $APP_HOME/logs \
+    && chmod -R 755 $APP_HOME
+
+# =============================================================================
+# DOWNLOAD PREREQUISITE FILES
+# =============================================================================
+
+
+COPY . .
+
+COPY configs/ ./configs/
+
+
+RUN chmod +x start.sh && \
+    find . -name "*.sh" -exec chmod +x {} \; && \
+    find . -name "*.py" -exec chmod +x {} \;
+
+# =============================================================================
+# CREATE OPTIMIZATION PATCHES AND TOOLS (FIXED SYNTAX)
+# =============================================================================
+
+
+# =============================================================================
+# CONFIGURATION FILES
+# =============================================================================
+
+# Create default LTX FP8 configuration
+RUN cat <<'YAML_CONFIG' > $APP_HOME/configs/ltxv-13b-0.9.8-distilled-fp8.yaml
+# LTX Video FP8 Distilled Configuration
+# Optimized for 8x L40S GPUs (384GB VRAM)
+model:
+  target: "ltx_video.models.transformer_temporal.TransformerTemporalModel"
+  params:
+    transformer_additional_kwargs:
+      attention_mode: "sdpa"
+      enable_flash_attention: true
+      memory_efficient_attention: true
+    network_config:
+      model_name: "ltxv-13b-0.9.8-distilled-fp8"
+      fp8_optimization: true
+      quantization: "fp8"
+      ada_optimized: true
+      multi_gpu_support: true
+
+scheduler:
+  target: "diffusers.LTXVideoScheduler"
+  params:
+    num_train_timesteps: 1000
+    beta_start: 0.0001
+    beta_end: 0.02
+    beta_schedule: "scaled_linear"
+
+vae:
+  target: "diffusers.AutoencoderKLLTXVideo"
+  params:
+    force_upcast: false
+    enable_slicing: true
+    enable_tiling: true
+
+text_encoder:
+  target: "transformers.T5EncoderModel"
+  params:
+    torch_dtype: "bfloat16"
+
+pipeline:
+  target: "diffusers.LTXVideoPipeline"
+  params:
+    scheduler_type: "LTXVideoScheduler"
+    num_inference_steps: 4
+    guidance_scale: 1.0
+    height: 704
+    width: 1216
+    num_frames: 121
+    fps: 30
+    enable_memory_efficient_attention: true
+    enable_cpu_offload: false
+    enable_model_cpu_offload: false
+    max_batch_size: 4
+
+multi_gpu:
+  enabled: true
+  num_gpus: 8
+  distribution_strategy: "data_parallel"
+  load_balancing: "memory_aware"
+  synchronize_gpus: true
+YAML_CONFIG
+
+# Create multi-GPU optimization config
+RUN cat <<'GPU_CONFIG' > $APP_HOME/configs/multi_gpu_config.yaml
+# Multi-GPU Configuration for 8x L40S Setup
+system:
+  gpu_count: 8
+  total_vram: "384GB"
+  compute_capability: "8.9"
+  architecture: "ADA_LOVELACE"
+
+distributed_training:
+  backend: "nccl"
+  init_method: "env://"
+  world_size: 8
+  rank: 0
+
+memory_optimization:
+  gradient_checkpointing: true
+  mixed_precision: "bf16"
+  max_batch_size_per_gpu: 8
+  gradient_accumulation_steps: 4
+  memory_fraction: 0.95
+
+performance:
+  torch_compile: true
+  cuda_graphs: true
+  tensor_cores: true
+  flash_attention: true
+  memory_efficient_attention: true
+
+load_balancing:
+  strategy: "memory_aware"
+  rebalance_interval: 30
+  utilization_threshold: 0.8
+
+thermal_management:
+  max_temperature: 83
+  fan_curve: "aggressive"
+  throttle_threshold: 80
+  monitoring_interval: 10
+
+power_management:
+  max_power_limit: 300
+  efficiency_mode: false
+  power_monitoring: true
+GPU_CONFIG
+
+# =============================================================================
+# HEALTH CHECK SCRIPT
+# =============================================================================
+
+RUN cat <<'HEALTHCHECK_SCRIPT' > $APP_HOME/healthcheck.py
+#!/usr/bin/env python3
+"""
+Health check script for Complete AI Video Suite
+"""
+import sys
+import requests
+import torch
+import time
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def check_cuda():
+    """Check CUDA availability and GPU status"""
+    if not torch.cuda.is_available():
+        logger.error("CUDA not available")
+        return False
+    
+    gpu_count = torch.cuda.device_count()
+    logger.info(f"CUDA available with {gpu_count} GPUs")
+    
+    for i in range(gpu_count):
+        try:
+            torch.cuda.set_device(i)
+            props = torch.cuda.get_device_properties(i)
+            memory_allocated = torch.cuda.memory_allocated() / 1024**3
+            memory_total = props.total_memory / 1024**3
+            
+            logger.info(f"GPU {i}: {props.name} ({memory_allocated:.2f}GB/{memory_total:.1f}GB)")
+            
+            x = torch.randn(100, 100, device=f'cuda:{i}')
+            y = torch.matmul(x, x)
+            torch.cuda.synchronize()
+            
+        except Exception as e:
+            logger.error(f"GPU {i} test failed: {e}")
+            return False
+    
+    return True
+
+def check_web_service():
+    """Check if web service is responding"""
+    try:
+        response = requests.get("http://localhost:7860/", timeout=10)
+        if response.status_code == 200:
+            logger.info("Web service is responding")
+            return True
+        else:
+            logger.error(f"Web service returned status code: {response.status_code}")
+            return False
+    except requests.RequestException as e:
+        logger.error(f"Web service check failed: {e}")
+        return False
+
+def main():
+    """Main health check routine"""
+    logger.info("Starting health check...")
+    
+    if not check_cuda():
+        sys.exit(1)
+    
+    if not check_web_service():
+        sys.exit(1)
+    
+    logger.info("All health checks passed")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+HEALTHCHECK_SCRIPT
+
+RUN chmod +x $APP_HOME/healthcheck.py
+
+# =============================================================================
+# USER SETUP AND SECURITY
+# =============================================================================
+
+RUN mkdir -p /etc/sudoers.d && \
+    useradd -m -u 1000 -s /bin/bash appuser && \
+    usermod -aG sudo appuser && \
+    chown -R appuser:appuser $APP_HOME && \
+    echo "appuser ALL=(ALL) NOPASSWD: /usr/bin/nvidia-smi, /usr/bin/nvidia-ml-py" > /etc/sudoers.d/appuser
+
+USER appuser
+
+WORKDIR $APP_HOME
+
+# =============================================================================
+# RUNTIME CONFIGURATION
+# =============================================================================
+
+EXPOSE 7860 8001 8002 6006
+
+VOLUME ["/app/model_cache", "/app/outputs", "/app/logs", "/app/build_cache"]
+
+HEALTHCHECK --interval=60s --timeout=30s --start-period=300s --retries=3 \
+    CMD python3 /app/healthcheck.py
+
+# =============================================================================
+# FINAL SETUP AND ENTRY POINT
+# =============================================================================
+
+RUN cat <<'ENTRYPOINT_SCRIPT' > $APP_HOME/docker-entrypoint.sh
+#!/bin/bash
+set -euo pipefail
+
+echo "🚀 Complete AI Suite - Docker Container Starting..."
+echo "🐳 Container: $(hostname)"
+echo "👤 User: $(whoami)"
+echo "🎮 GPUs: $(nvidia-smi --list-gpus | wc -l || echo '0')"
+
+if command -v nvidia-smi >/dev/null 2>&1; then
+    echo "💾 CUDA Memory:"
+    nvidia-smi --query-gpu=memory.total,memory.used --format=csv,noheader,nounits | nl
+fi
+
+echo "🔧 Applying optimization patches..."
+python3 /app/tools/optimization_patch.py
+
+echo "📁 Setting up permissions..."
+chmod -R 755 /app/installer
+chmod -R 755 /app/monitoring
+chmod +x /app/start.sh
+
+mkdir -p /app/logs /app/outputs /app/tmp
+chmod 777 /app/logs /app/outputs /app/tmp
+
+echo "✅ Docker container initialization complete"
+echo "🚀 Starting Complete AI Video Suite..."
+
+exec /app/start.sh "$@"
+ENTRYPOINT_SCRIPT
+
+RUN chmod +x $APP_HOME/docker-entrypoint.sh
+
+ENTRYPOINT ["/app/docker-entrypoint.sh"]
+
+CMD ["--listen", "--multi-gpu", "--optimize"]
+
+# =============================================================================
+# FINAL METADATA
+# =============================================================================
+
+RUN echo "Complete AI Video Suite v2.0.0" > /app/VERSION && \
+    echo "Build Date: 2025-09-18T$(date +%H:%M:%S)" >> /app/VERSION && \
+    echo "CUDA: 12.4.1" >> /app/VERSION && \
+    echo "PyTorch: $(python3 -c 'import torch; print(torch.__version__)')" >> /app/VERSION && \
+    echo "Optimized for: 8x NVIDIA L40S GPUs" >> /app/VERSION
+
+LABEL org.opencontainers.image.title="Complete AI Video Suite"
+LABEL org.opencontainers.image.description="Production-ready multi-GPU video generation with LTX FP8, Q8 Kernels, and more"
+LABEL org.opencontainers.image.version="2.0.0"
+LABEL org.opencontainers.image.created="2025-09-18T17:42:00Z"
+LABEL org.opencontainers.image.revision="main"
+LABEL org.opencontainers.image.licenses="MIT"

LICENSE

@@ -0,0 +1,25 @@
+# Euia-AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR para geração de vídeo coerente.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+#
+# 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 (Ltx-SuperTime-60Secondos): https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/
+# Hugging Face (Novinho): https://huggingface.co/spaces/Carlexxx/Novinho/
+#
+# 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/>.

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,10 +1,212 @@
 ---
-title: Aduc-sdr-2 5
-emoji: 💻
-colorFrom: yellow
+title: Euia-AducSdr
+emoji: 🎥
+colorFrom: indigo
 colorTo: purple
-sdk: docker
-pinned: false
+sdk: gradio
+app_file: app.py
+pinned: true
+license: agpl-3.0
+setup_file: setup.sh
+short_description: Uma implementação aberta e funcional da arquitetura ADUC-SDR
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+### 🇧🇷 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 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.
+
+- **Copyright (C) 4 de Agosto de 2025, Carlos Rodrigues dos Santos**
+- Uma cópia completa da licença pode ser encontrada no arquivo [LICENSE](LICENSE).
+
+---
+
+### 🇬🇧 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 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.
+
+- **Copyright (C) August 4, 2025, Carlos Rodrigues dos Santos**
+- A full copy of the license can be found in the [LICENSE](LICENSE) file.
+
+---
+
+## **Aviso de Propriedade Intelectual e Patenteamento**
+
+### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
+
+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**.
+
+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**.
+
+---
+
+### Contact / Contato / Contacto
+
+- **Author / Autor:** Carlos Rodrigues dos Santos
+- **Email:** [email protected]
+- **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/)
+
+---

aduc_framework/__init__.py

@@ -0,0 +1,57 @@
+# aduc_framework/__init__.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 6.2.0 (Alinhamento Final de API da Fábrica)
+# - Alinha a assinatura da função `create_aduc_instance` e a chamada ao
+#   construtor do AducSdr para usar `workspace_root` consistentemente.
+# - Resolve o `TypeError` na inicialização da aplicação.
+
+import logging
+
+from .aduc_sdr import AducSdr
+from .types import (
+    GenerationState,
+    PreProductionParams,
+    ProductionParams,
+    GenerationParameters,
+    MediaRef,
+    Ato,
+    Scene,
+    KeyframeData,
+    VideoData
+)
+
+logger = logging.getLogger(__name__)
+
+# <<< CORREÇÃO APLICADA AQUI >>>
+def create_aduc_instance(workspace_root: str) -> AducSdr:
+    """
+    Ponto de entrada de fábrica para criar uma instância do Aduc Framework.
+    
+    Args:
+        workspace_root (str): O diretório raiz onde todas as pastas de
+                              projetos serão criadas.
+    """
+    logger.info(f"Fábrica ADUC: Criando instância de AducSdr com workspace_root em '{workspace_root}'...")
+    # Passa o argumento com o nome correto para o construtor do AducSdr
+    instance = AducSdr(workspace_root=workspace_root)
+    logger.info("Fábrica ADUC: Instância AducSdr criada e pronta para uso.")
+    return instance
+
+logger.info("Módulo 'aduc_framework' carregado. Use 'create_aduc_instance()' para começar.")
+
+# Define a API pública do pacote principal
+__all__ = [
+    "create_aduc_instance",
+    "AducSdr",
+    "GenerationState",
+    "PreProductionParams",
+    "ProductionParams",
+    "GenerationParameters",
+    "MediaRef",
+    "Ato",
+    "Scene",
+    "KeyframeData",
+    "VideoData",
+]

aduc_framework/aduc_sdr.py

@@ -0,0 +1,137 @@
+# aduc_framework/aduc_sdr.py
+#
+# Versão 16.0.0 (Maestro de Produção Integrado)
+# - Implementa o método `task_produce_movie` para delegar a produção de vídeo
+#   ao especialista `Planner5D`, ativando o pipeline de produção iterativo.
+# - Atua como a ponte final entre a interface do usuário (UI) e o complexo
+#   fluxo de trabalho de geração de vídeo cena a cena.
+# - Utiliza o sistema de `yield from` para transmitir de forma eficiente as
+#   atualizações de estado do `Planner5D` de volta para a UI.
+
+import logging
+import os
+from typing import Generator
+
+# Importa os especialistas de alto nível (Engenheiros)
+from .engineers.composer_2D import composer_2d_singleton as Composer2D
+from .engineers.planner_5D import planner_5d_singleton as Planner5D
+
+# Importa as estruturas de dados (o DNA Digital)
+from .types import GenerationState, PreProductionParams, ProductionParams, MediaRef
+from .director import AducDirector
+
+logger = logging.getLogger(__name__)
+
+class AducSdr:
+    """
+    O Maestro do framework ADUC-SDR. Orquestra os especialistas (Engineers)
+    e gerencia o fluxo de dados através do Diretor (estado persistente).
+    """
+    def __init__(self, workspace_root: str):
+        self.workspace_root = workspace_root
+        self.director: AducDirector | None = None
+        self.composer_2d = Composer2D
+        self.planner_5d = Planner5D
+        logger.info("ADUC-SDR Maestro (Arquitetura V2) inicializado e pronto.")
+
+    def load_project(self, project_name: str):
+        """Carrega um projeto existente ou cria um novo."""
+        project_path = os.path.join(self.workspace_root, project_name)
+        self.director = AducDirector(project_path=project_path)
+        logger.info(f"Projeto '{project_name}' carregado no Diretor.")
+
+    def _ensure_project_loaded(self):
+        """Garante que um projeto foi carregado antes de executar tarefas."""
+        if not self.director:
+            raise RuntimeError("Nenhum projeto foi carregado. Chame `aduc.load_project(project_name)` primeiro.")
+
+    def get_current_state(self) -> GenerationState:
+        """Retorna o estado completo e atual do projeto."""
+        self._ensure_project_loaded()
+        return self.director.get_full_state()
+
+    def process_image_for_story(self, image_path: str, filename: str) -> str:
+        """Processa uma imagem de referência para um formato padrão."""
+        self._ensure_project_loaded()
+        from PIL import Image
+        size = 480; quality = 40
+        img = Image.open(image_path).convert("RGB"); img.thumbnail((size, size), Image.Resampling.LANCZOS)
+        background = Image.new('RGB', (size, size), (0, 0, 0)); img_w, img_h = img.size; offset = ((size - img_w) // 2, (size - img_h) // 2)
+        background.paste(img, offset)
+        processed_path = os.path.join(self.director.project_path, filename)
+        background.save(processed_path, 'JPEG', quality=quality)
+        return processed_path
+
+    def _process_and_yield_updates(self, generator: Generator[GenerationState, None, None]):
+        """
+        Loop genérico para processar atualizações de um especialista, salvar o estado
+        e repassar para a UI.
+        """
+        for updated_dna in generator:
+            self.director.load_state_from_dict(updated_dna.model_dump())
+
+            if self.director.state.should_checkpoint():
+                checkpoint_dir = os.path.join(self.director.project_path, "checkpoints")
+                path = self.director.state.create_checkpoint(checkpoint_dir)
+                logger.info(f"Checkpoint do projeto salvo em: {path}")
+
+            self.director.save_state()
+            yield self.director.get_full_state()
+
+    def task_run_story_and_keyframes(self, params: PreProductionParams) -> Generator[GenerationState, None, None]:
+        """
+        Orquestra a pré-produção (Fase 1), delegando ao Composer2D para criar o storyboard.
+        """
+        self._ensure_project_loaded()
+        logger.info("Maestro: Iniciando Pré-Produção (Storyboard) com o Composer2D...")
+        
+        initial_state = self.director.get_full_state()
+        initial_state.parametros_geracao.pre_producao = params
+        initial_state.midias_referencia = [
+            MediaRef(id=i, tag=f"<IMG{i}>", caminho=path)
+            for i, path in enumerate(params.ref_paths)
+        ]
+        
+        initial_state.texto_global_historia = None
+        initial_state.ativos_catalogados = None
+        initial_state.storyboard_producao = []
+        initial_state.chat_history.append({
+            "role": "Sistema",
+            "content": f"Iniciando pré-produção. {len(params.ref_paths)} imagens de referência foram tageadas para uso pela IA."
+        })
+
+        pre_production_generator = self.composer_2d.compose_storyboard(initial_state)
+        
+        yield from self._process_and_yield_updates(pre_production_generator)
+        logger.info("Maestro: Pré-Produção (Fase 1) concluída.")
+
+    def task_produce_movie(self, params: ProductionParams) -> Generator[GenerationState, None, None]:
+        """
+        Orquestra a produção completa do filme (Fase 2), delegando ao Planner5D.
+        """
+        self._ensure_project_loaded()
+        logger.info("Maestro: Iniciando Produção de Vídeo com o Planner5D...")
+
+        # 1. Obter o estado atual, que já contém o storyboard da pré-produção.
+        current_state = self.director.get_full_state()
+
+        # 2. Atualizar o estado com os novos parâmetros de produção vindos da UI.
+        if current_state.parametros_geracao:
+            current_state.parametros_geracao.producao = params
+        
+        current_state.chat_history.append({
+            "role": "Sistema",
+            "content": f"Parâmetros de produção recebidos. O Diretor de Produção (Planner5D) está assumindo o controle."
+        })
+        
+        # Salva os parâmetros no dna.json antes de iniciar o processo longo.
+        self.director.save_state()
+
+        # 3. Chamar o especialista Planner5D com o estado atualizado.
+        # Ele agora irá controlar o loop de Deformes3D e Deformes4D.
+        production_generator = self.planner_5d.produce_movie_by_scene(current_state)
+
+        # 4. Processar as atualizações, salvar o estado e repassar para a UI em tempo real.
+        yield from self._process_and_yield_updates(production_generator)
+
+        logger.info("Maestro: Produção de vídeo (Fase 2) concluída.")

aduc_framework/director.py

@@ -0,0 +1,98 @@
+# aduc_framework/director.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 4.0.0 (Gerenciamento de Estado Persistente)
+#
+# - O Diretor agora gerencia um arquivo `dna.json` dentro de um diretório de projeto.
+# - No `__init__`, ele tenta carregar um estado existente do arquivo ou cria um novo.
+# - O método `save_state()` permite que o Maestro ADUC comande a persistência
+#   do estado atual em disco em marcos importantes do processo.
+
+import logging
+import os
+import json
+from pathlib import Path
+from typing import List, Dict, Any
+
+from .types import GenerationState, PreProductionParams, Scene, Ato, MediaRef
+
+logger = logging.getLogger(__name__)
+
+class AducDirector:
+    """
+    Representa o Diretor de Cena, responsável por gerenciar o estado
+    persistente de um único projeto (`dna.json`).
+    """
+    def __init__(self, project_path: str):
+        self.project_path = Path(project_path)
+        self.dna_file_path = self.project_path / "dna.json"
+        
+        self.project_path.mkdir(parents=True, exist_ok=True)
+        
+        self.state: GenerationState = self._load_or_initialize_state()
+        logger.info(f"AducDirector inicializado para o projeto em '{self.project_path}'.")
+
+    def _load_or_initialize_state(self) -> GenerationState:
+        """Carrega o estado do dna.json ou cria um novo se não existir."""
+        if self.dna_file_path.exists():
+            try:
+                logger.info(f"Encontrado dna.json existente. Carregando estado...")
+                with open(self.dna_file_path, 'r', encoding='utf-8') as f:
+                    state_dict = json.load(f)
+                    return GenerationState(**state_dict)
+            except (json.JSONDecodeError, TypeError) as e:
+                logger.error(f"Falha ao carregar ou validar dna.json: {e}. Criando um novo estado.")
+                return GenerationState(workspace_dir=str(self.project_path))
+        else:
+            logger.info("Nenhum dna.json encontrado. Criando novo estado de geração.")
+            return GenerationState(workspace_dir=str(self.project_path))
+
+    def save_state(self):
+        """Salva o estado atual (self.state) no arquivo dna.json."""
+        logger.info(f"Persistindo estado atual para '{self.dna_file_path}'...")
+        with open(self.dna_file_path, 'w', encoding='utf-8') as f:
+            f.write(self.state.model_dump_json(indent=2))
+        logger.info("Estado salvo com sucesso.")
+
+    def get_full_state(self) -> GenerationState:
+        """Retorna o objeto de estado Pydantic completo."""
+        return self.state
+
+    def load_state_from_dict(self, state_dict: Dict[str, Any]):
+        """Carrega o estado a partir de um dicionário (ex: vindo de um planner)."""
+        try:
+            self.state = GenerationState(**state_dict)
+            logger.info("Diretor: Estado em memória atualizado com sucesso a partir de um dicionário.")
+        except Exception as e:
+            logger.error(f"Diretor: Falha ao carregar estado a partir do dicionário: {e}", exc_info=True)
+
+    def update_parameters(self, stage: str, params: Any):
+        """Atualiza o nó de parâmetros no estado de geração."""
+        if hasattr(self.state.parametros_geracao, stage):
+            setattr(self.state.parametros_geracao, stage, params)
+        else:
+            logger.warning(f"Tentativa de atualizar parâmetros para um estágio desconhecido: '{stage}'")
+            
+    def update_state_from_pre_production_dna(self, params: PreProductionParams, final_dna_json: Dict[str, Any]):
+        """Analisa o dicionário bruto do Composer e o usa para popular o estado."""
+        logger.info("Diretor: Recebendo DNA da pré-produção para popular o estado.")
+
+        self.state.parametros_geracao.pre_producao = params
+        self.state.prompt_geral = final_dna_json.get("global_prompt", "")
+        
+        ref_paths = final_dna_json.get("initial_media_paths", [])
+        self.state.midias_referencia = [MediaRef(id=i, caminho=path) for i, path in enumerate(ref_paths)]
+        
+        self.state.scenes = []
+        scenes_data = final_dna_json.get("scenes", [])
+        
+        for scene_dict in scenes_data:
+            ato_objects = [
+                Ato(id=ato_dict.get("act_id", i), resumo_ato=ato_dict.get("context", ""))
+                for i, ato_dict in enumerate(scene_dict.get("acts", []))
+            ]
+            scene_object = Scene(id=scene_dict.get("scene_id"), atos=ato_objects)
+            self.state.scenes.append(scene_object)
+
+        logger.info(f"Diretor: Estado populado com sucesso. {len(self.state.scenes)} cenas carregadas.")

aduc_framework/engineers/LICENSE

@@ -0,0 +1,23 @@
+# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR para geração de vídeo coerente.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+#
+# 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
+#
+# 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/>.

aduc_framework/engineers/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

aduc_framework/engineers/README.md

@@ -0,0 +1,211 @@
+---
+title: Euia-AducSdr
+emoji: 🎥
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+app_file: app.py
+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 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.
+
+- **Copyright (C) 4 de Agosto de 2025, Carlos Rodrigues dos Santos**
+- Uma cópia completa da licença pode ser encontrada no arquivo [LICENSE](LICENSE).
+
+---
+
+### 🇬🇧 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 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.
+
+- **Copyright (C) August 4, 2025, Carlos Rodrigues dos Santos**
+- A full copy of the license can be found in the [LICENSE](LICENSE) file.
+
+---
+
+## **Aviso de Propriedade Intelectual e Patenteamento**
+
+### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
+
+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**.
+
+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**.
+
+---
+
+### Contact / Contato / Contacto
+
+- **Author / Autor:** Carlos Rodrigues dos Santos
+- **Email:** [email protected]
+- **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/)
+
+---

aduc_framework/engineers/__init__.py

@@ -0,0 +1,35 @@
+# aduc_framework/engineers/__init__.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Expõe os singletons de todos os engenheiros (Planners e Deformes)
+# para que o orquestrador e outros componentes possam importá-los
+# a partir de um único local.
+
+# Importa os Planners (Gerentes)
+
+from .planner_3d import planner_3d_singleton
+from .planner_4d import planner_4d_singleton
+from .planner_5D import planner_5d_singleton
+
+# Importa o Composer (Motor de Execução de LLM)
+from .composer import composer_singleton
+from .composer_2D import composer_2d_singleton
+from .neura_link import neura_link_singleton
+
+# Importa os Motores de Geração (Trabalhadores Especialistas)
+from .deformes3D import deformes3d_engine_singleton
+from .deformes4D import deformes4d_engine_singleton
+
+
+# Define a lista de componentes que são parte da "API pública" deste sub-pacote
+__all__ = [
+    "planner_5d_singleton",
+    "neura_link_singleton",
+    "composer_2d_singleton",
+    "planner_3d_singleton",
+    "planner_4d_singleton",
+    "composer_singleton",
+    "deformes3d_engine_singleton",
+    "Deformes4DEngine",
+]

aduc_framework/engineers/composer.py

@@ -0,0 +1,156 @@
+# aduc_framework/engineers/composer.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 4.1.0 (Hub Cognitivo Consolidado)
+#
+# - A arquitetura está estável e completa. O Composer atua como o hub
+#   central de comunicação com os LLMs.
+# - O método `execute_plan` é usado pelo Planner2D para a criação do roteiro.
+# - O método `execute_cognitive_task` é uma ferramenta genérica usada por
+#   outros especialistas (como Planner4D e Deformes3D) para solicitar
+#   tarefas de raciocínio pontuais ao LLM, como decidir um movimento de
+#   câmera ou um plano de composição de imagem.
+
+import logging
+import json
+import re
+import yaml
+from pathlib import Path
+from PIL import Image
+from typing import List, Dict, Any, Generator, Optional, Callable
+
+from .prompt_engine import prompt_engine_singleton
+from ..managers.llama_multimodal_manager import llama_multimodal_manager_singleton
+from ..managers.gemini_manager import gemini_manager_singleton
+
+logger = logging.getLogger(__name__)
+
+def robust_json_parser(raw_text: str) -> dict:
+    """
+    Analisa um objeto JSON de uma string que pode conter texto extra.
+    """
+    logger.debug(f"COMPOSER(JSON_PARSER): Tentando parsear JSON (primeiros 500 chars):\n---\n{raw_text[:500]}\n---")
+    match = re.search(r'```json\s*(\{.*?\})\s*```', raw_text, re.DOTALL)
+    if match:
+        json_str = match.group(1); logger.debug("JSON explícito encontrado.")
+        return json.loads(json_str)
+    try:
+        start_index = raw_text.find('{'); end_index = raw_text.rfind('}')
+        if start_index != -1 and end_index != -1 and end_index > start_index:
+            json_str = raw_text[start_index : end_index + 1]; logger.debug("JSON por delimitadores '{...}' encontrado.")
+            return json.loads(json_str)
+    except json.JSONDecodeError: pass
+    logger.warning("Nenhum JSON válido encontrado nos métodos primários. Tentando parsear o texto inteiro.")
+    return json.loads(raw_text)
+
+class Composer:
+    """
+    O Composer é o hub central de comunicação com o Large Language Model (LLM).
+    Ele executa tanto planos de trabalho de várias etapas quanto tarefas cognitivas únicas.
+    """
+    def __init__(self):
+        logger.info("COMPOSER: Lendo config.yaml para selecionar o LLM Engine...")
+        with open("config.yaml", 'r') as f:
+            config = yaml.safe_load(f)
+        
+        self.provider = config.get('specialists', {}).get('llm_engine', {}).get('provider', 'llama_multimodal')
+        
+        if self.provider == 'gemini':
+            self.llm_manager = gemini_manager_singleton
+            logger.info("COMPOSER: Motor de LLM configurado para usar 'Gemini'.")
+        else:
+            self.llm_manager = llama_multimodal_manager_singleton
+            logger.info("COMPOSER: Motor de LLM configurado para usar 'Llama' (padrão).")
+
+        prompt_engine_singleton.set_provider(self.provider)
+        self.task_templates = self._load_task_templates()
+        logger.info(f"Composer inicializado com {len(self.task_templates)} templates de tarefa.")
+
+    def _load_task_templates(self) -> Dict[str, str]:
+        templates = {}
+        template_dir = Path(__file__).resolve().parent.parent / "prompts" / "task_templates"
+        if not template_dir.is_dir():
+            raise FileNotFoundError(f"Diretório de templates de tarefa não encontrado: {template_dir}")
+        for task_file in template_dir.glob("*.txt"):
+            task_id = task_file.stem
+            with open(task_file, 'r', encoding='utf-8') as f:
+                templates[task_id] = f.read()
+        return templates
+
+    def _talk_to_llm(self, generic_prompt: str, images: Optional[List[Image.Image]] = None, expected_format="text") -> Any:
+        final_model_prompt = prompt_engine_singleton.translate(
+            generic_prompt_content=generic_prompt, has_image=bool(images)
+        )
+        logger.info(f"COMPOSER: PROMPT FINAL SENDO ENVIADO para ({self.provider}):\n--- INÍCIO DO PROMPT ---\n{final_model_prompt}\n--- FIM DO PROMPT ---")
+        response_raw = self.llm_manager.process_turn(prompt_text=final_model_prompt, image_list=images)
+        logger.info(f"COMPOSER: RESPOSTA BRUTA RECEBIDA de ({self.provider}):\n--- INÍCIO DA RESPOSTA BRUTA ---\n{response_raw}\n--- FIM DA RESPOSTA BRUTA ---")
+        
+        if expected_format == "json":
+            try:
+                return robust_json_parser(response_raw)
+            except (json.JSONDecodeError, ValueError) as e:
+                raise ValueError(f"O LLM ({self.provider}) retornou um formato JSON inválido. Erro: {e}")
+        return response_raw
+
+    def execute_cognitive_task(self, task_id: str, template_data: Dict[str, Any], images: Optional[List[Image.Image]] = None) -> Any:
+        """
+        Executa uma única tarefa cognitiva (de "pensamento") e retorna o resultado.
+        """
+        logger.info(f"COMPOSER: Executando tarefa cognitiva: {task_id}")
+        generic_template = self.task_templates.get(task_id)
+        if not generic_template:
+            raise ValueError(f"Template para a tarefa cognitiva '{task_id}' não foi encontrado.")
+            
+        prompt_content = generic_template
+        for key, value in template_data.items():
+            prompt_content = prompt_content.replace(f"{{{key}}}", str(value))
+        
+        expected_format = "json" if "JSON REQUIRED" in generic_template.upper() else "text"
+        
+        response = self._talk_to_llm(generic_prompt=prompt_content, images=images, expected_format=expected_format)
+        
+        if expected_format == "text":
+            return response.strip().replace("\"", "")
+        return response
+
+    def execute_plan(self, execution_plan: List[Dict[str, Any]], initial_data: Dict[str, Any]) -> Generator[Dict[str, Any], None, None]:
+        """
+        Executa um plano de trabalho de várias etapas para a criação do roteiro.
+        """
+        dna = {"global_prompt": initial_data["global_prompt"], "initial_media_paths": initial_data["user_media_paths"], "continuous_story": "", "scenes": []}
+        user_media = [Image.open(p) for p in initial_data["user_media_paths"]]
+
+        for i, task in enumerate(execution_plan):
+            try:
+                task_id = task['task_id']
+                yield {"status": "progress", "message": task.get('description', '')}
+                
+                generic_template = self.task_templates.get(task_id)
+                if not generic_template:
+                    raise ValueError(f"Template para a tarefa '{task_id}' não foi encontrado.")
+
+                prompt_content = generic_template
+                prompt_content = prompt_content.replace("{global_prompt}", str(dna.get("global_prompt", "")))
+                prompt_content = prompt_content.replace("{num_scenes}", str(task.get('inputs', {}).get("num_scenes", "")))
+                prompt_content = prompt_content.replace("{continuous_story}", str(dna.get("continuous_story", "")))
+                prompt_content = prompt_content.replace("{independent_scenes_json}", json.dumps({"scenes": dna.get("scenes", [])}, indent=2))
+
+                is_json_output = task_id in ["STEP_02_CREATE_INDEPENDENT_SCENES", "STEP_03_FRAGMENT_SCENES_INTO_ACTS", "STEP_04_FINAL_REVIEW"]
+                expected_format = "json" if is_json_output else "text"
+
+                response = self._talk_to_llm(prompt_content, user_media if i == 0 else None, expected_format)
+                
+                if task_id == "STEP_01_CREATE_CONTINUOUS_STORY":
+                    dna["continuous_story"] = response
+                elif task_id == "STEP_02_CREATE_INDEPENDENT_SCENES":
+                    dna["scenes"] = response.get("scenes", [])
+                elif task_id == "STEP_03_FRAGMENT_SCENES_INTO_ACTS":
+                    dna["scenes"] = response.get("scenes", [])
+                
+            except Exception as e:
+                raise e
+
+        yield {"status": "complete", "message": "Execução do Composer concluída.", "dna": dna}
+
+composer_singleton = Composer()

aduc_framework/engineers/composer_2D.py

@@ -0,0 +1,160 @@
+# aduc_framework/engineers/composer_2D.py
+
+# Versão 3.1.0 (Diálogo de Revisão Estruturado)
+#
+# - Implementa o fluxo de revisão em duas etapas (4.5 e 5) para
+#   maior qualidade e consistência do storyboard.
+# - Etapa 4.5: A IA recebe o storyboard completo para uma análise global.
+# - Etapa 5: A IA itera cena a cena para fazer um polimento fino,
+#   usando o contexto global absorvido na etapa anterior.
+# - Utiliza os métodos de serialização do Pydantic (`model_dump(mode='json')` e
+#   `model_dump_json()`) para evitar TypeErrors com objetos datetime.
+
+import logging
+import json
+from typing import Generator, Dict, Any, List
+
+# --- Interface neural e tipos ---
+from .neura_link import neura_link_singleton as NeuraLink
+from ..types import GenerationState, CatalogoDeAtivos, Scene, Ato, AtivoCatalogado
+
+logger = logging.getLogger(__name__)
+
+class Composer2D:
+    """
+    Orquestra um pipeline conversacional para gerar e refinar um storyboard,
+    usando um sistema de identificação de ativos universal e um diálogo de
+    revisão em várias etapas.
+    """
+
+    def compose_storyboard(self, dna: GenerationState) -> Generator[GenerationState, None, None]:
+        """
+        Executa o pipeline completo de pré-produção, incluindo a fase de revisão.
+        """
+        params = getattr(dna.parametros_geracao, "pre_producao", None)
+        if not params:
+            raise ValueError("Parâmetros de pré-produção ausentes no DNA (parametros_geracao.pre_producao requerido).")
+        
+        num_scenes = params.num_scenes
+        duration_per_fragment = params.duration_per_fragment
+        global_prompt = params.prompt
+
+        refs = list(getattr(dna, "midias_referencia", []))
+        image_paths = [r.caminho for r in refs if r.caminho]
+        image_map_para_llm = [{"tag_referencia": r.tag} for r in refs]
+
+        NeuraLink.reset_memory()
+        dna.chat_history.append({"role": "Composer2D", "content": "Memória da IA reiniciada. Iniciando roteiro..."})
+        yield dna
+
+        # --- ETAPAS 1-4: GERAÇÃO DO RASCUNHO INICIAL ---
+
+        # ETAPA 1: NARRATIVA
+        narrativa = NeuraLink.execute_task(
+            task_id="TASK_01_CREATE_CINEMATIC_NARRATIVE",
+            template_data={"global_prompt": global_prompt, "num_scenes": num_scenes},
+            image_paths=image_paths or None, expected_format="text", use_memory=True,
+        )
+        dna.texto_global_historia = (narrativa or "").strip()
+        dna.chat_history.append({"role": "Composer2D", "content": "Narrativa global criada."})
+        yield dna
+
+        # ETAPA 2: CATÁLOGO DE ATIVOS
+        asset_catalog_dict = NeuraLink.execute_task(
+            task_id="TASK_02_SELECT_AND_CATALOG_ASSETS",
+            template_data={"image_map": json.dumps(image_map_para_llm, ensure_ascii=False, indent=2)},
+            expected_format="json", use_memory=True,
+        )
+        dna.ativos_catalogados = CatalogoDeAtivos(**(asset_catalog_dict or {}))
+        dna.chat_history.append({"role": "Composer2D", "content": "Catálogo de ativos universais definido."})
+        yield dna
+
+        all_assets_by_id: Dict[str, AtivoCatalogado] = {asset.id: asset for asset_list in [dna.ativos_catalogados.cenarios, dna.ativos_catalogados.personagens, dna.ativos_catalogados.objetos] for asset in asset_list}
+
+        def upsert_asset_from_llm(llm_obj: Dict[str, Any], asset_type: str) -> AtivoCatalogado:
+            asset_id = llm_obj.get("id")
+            if not asset_id: raise ValueError(f"Ativo do tipo '{asset_type}' recebido do LLM sem 'id'.")
+            if asset_id in all_assets_by_id: return all_assets_by_id[asset_id]
+            
+            logger.info(f"IA propôs um novo ativo dinamicamente: {asset_id} (Tipo: {asset_type})")
+            novo_ativo = AtivoCatalogado(**llm_obj)
+            getattr(dna.ativos_catalogados, f"{asset_type}s", []).append(novo_ativo)
+            all_assets_by_id[novo_ativo.id] = novo_ativo
+            return novo_ativo
+
+        # ETAPA 3: STORYBOARD
+        storyboard_dict = NeuraLink.execute_task(
+            task_id="TASK_03_CREATE_DIRECTORS_STORYBOARD",
+            template_data={"num_scenes": num_scenes}, expected_format="json", use_memory=True,
+        )
+        scene_list = (storyboard_dict or {}).get("storyboard", [])
+        normalized_scenes: List[Scene] = []
+        for idx, s_dict in enumerate(scene_list):
+            if "id_cena" not in s_dict: s_dict["id_cena"] = idx + 1
+            canonical_cenario = upsert_asset_from_llm(s_dict.get("cenario_escolhido", {}), "cenario")
+            s_dict["cenario_escolhido"] = canonical_cenario.model_dump()
+            normalized_scenes.append(Scene(**s_dict))
+        dna.storyboard_producao = normalized_scenes
+        dna.chat_history.append({"role": "Composer2D", "content": f"Rascunho do storyboard com {len(normalized_scenes)} cenas criado."})
+        yield dna
+
+        # ETAPA 4: ATOS
+        for scene in dna.storyboard_producao:
+            acts_dict = NeuraLink.execute_task(
+                task_id="TASK_04_DETAIL_SCENE_INTO_ACTS",
+                template_data={"scene_directors_manual": scene.model_dump_json(indent=2), "max_duration_per_act_s": duration_per_fragment},
+                expected_format="json", use_memory=True,
+            )
+            scene.atos = [Ato(**a) for a in (acts_dict or {}).get("atos", [])]
+            dna.chat_history.append({"role": "Composer2D", "content": f"Cena {scene.id_cena}: atos detalhados."})
+            yield dna
+
+        # --- ETAPA 4.5: PRÉ-REVISÃO (CARREGAMENTO DE CONTEXTO OTIMIZADO) ---
+        dna.chat_history.append({"role": "Composer2D", "content": "Rascunho finalizado. Apresentando à IA para análise global antes do polimento..."})
+        yield dna
+
+        full_storyboard_json = json.dumps(
+            [s.model_dump(mode='json') for s in dna.storyboard_producao], 
+            indent=2, 
+            ensure_ascii=False
+        )
+        confirmation_message = NeuraLink.execute_task(
+            task_id="TASK_4_5_PRE_REVIEW_CONTEXT",
+            template_data={"full_storyboard_json": full_storyboard_json},
+            expected_format="text", use_memory=True,
+        )
+        dna.chat_history.append({"role": "Supervisor de Roteiro (IA)", "content": confirmation_message})
+        yield dna
+
+        # --- ETAPA 5: REVISÃO DE CONTINUIDADE CENA A CENA (COM CONTEXTO IMPLÍCITO) ---
+        dna.chat_history.append({"role": "Composer2D", "content": "Contexto carregado. Iniciando revisão detalhada cena a cena..."})
+        yield dna
+        
+        refined_storyboard = []
+        for scene_to_review in dna.storyboard_producao:
+            dna.chat_history.append({"role": "Composer2D", "content": f"Polindo Cena {scene_to_review.id_cena}/{len(dna.storyboard_producao)}: '{scene_to_review.titulo_cena}'..."})
+            yield dna
+
+            scene_json_for_prompt = scene_to_review.model_dump_json(indent=2)
+            
+            refined_scene_dict = NeuraLink.execute_task(
+                task_id="TASK_05_SCENE_CONTINUITY_REVIEW",
+                template_data={"scene_to_review_json": scene_json_for_prompt},
+                expected_format="json", use_memory=True,
+            )
+            try:
+                refined_scene = Scene(**refined_scene_dict)
+                refined_storyboard.append(refined_scene)
+            except Exception as e:
+                logger.warning(f"Falha ao validar cena refinada {scene_to_review.id_cena}. Mantendo a versão original. Erro: {e}")
+                refined_storyboard.append(scene_to_review)
+
+        dna.storyboard_producao = refined_storyboard
+        dna.chat_history.append({"role": "Composer2D", "content": "Revisão de continuidade concluída. Storyboard finalizado e polido."})
+        yield dna
+
+        logger.info("Pipeline completo do Composer2D (Geração e Revisão) concluído com sucesso.")
+        return
+
+# Singleton
+composer_2d_singleton = Composer2D()

aduc_framework/engineers/deformes3D.py

@@ -0,0 +1,152 @@
+# aduc_framework/engineers/deformes3D.py
+#
+# Versão 12.4.0 (Correção de Integração com VaeManager v2)
+# - Remove a função auxiliar obsoleta `_pil_to_latent` que ainda tentava
+#   chamar o antigo método `vae_manager_singleton.encode()`.
+# - Consolida o uso exclusivo do método `encode_batch` para toda a codificação
+#   de imagens, alinhando-se com a arquitetura de VAE persistente e otimizada.
+
+import os
+import logging
+import torch
+import numpy as np
+from PIL import Image
+from typing import List, Dict, Any
+
+from ..types import LatentConditioningItem, KeyframeGenerationJob
+from ..managers.ltx_manager import ltx_manager_singleton
+from ..managers.vae_manager import vae_manager_singleton
+
+logger = logging.getLogger(__name__)
+
+class Deformes3DEngine:
+    def __init__(self):
+        self.workspace_dir: str | None = None
+        logger.info("Deformes3DEngine (Pintor de Sequência) instanciado.")
+
+    def initialize(self, workspace_dir: str):
+        if self.workspace_dir is not None and self.workspace_dir == workspace_dir:
+            return
+        self.workspace_dir = workspace_dir
+        logger.info(f"Pintor 3D inicializado com workspace: {self.workspace_dir}.")
+
+    def generate_keyframes_from_job(
+        self,
+        job: KeyframeGenerationJob
+    ) -> List[Dict[str, Any]]:
+        from .composer import composer_singleton as Composer
+
+        if not self.workspace_dir:
+            raise RuntimeError("Deformes3DEngine não foi inicializado.")
+
+        storyboard = job.storyboard
+        num_keyframes_to_generate = len(storyboard)
+        global_prompt = job.global_prompt
+        ref_id_to_path_map = job.ref_id_to_path_map
+        available_ref_ids = job.available_ref_ids
+        keyframe_prefix = job.keyframe_prefix
+        
+        target_resolution_tuple = (512, 512)
+        current_base_image_path = job.ref_image_paths[0]
+        previous_prompt = ""
+        all_keyframes_data: List[Dict[str, Any]] = []
+                    
+        logger.info(f"Pintor 3D: Recebida ordem para gerar {num_keyframes_to_generate} keyframes para a cena '{keyframe_prefix}'.")
+
+        # --- FLUXO DE CODIFICAÇÃO EM LOTE OTIMIZADO ---
+        # 1. Coletar  a imagens base
+        images_to_encode = [Image.open(current_base_image_path).convert("RGB")]
+        ref_weights = [0.4] # Peso fixo para a imagem anterior
+        encoded_latents = vae_manager_singleton.encode_batch(images_to_encode, target_resolution_tuple)
+        
+        for i in range(num_keyframes_to_generate):
+            scene_index = i + 1
+            current_scene_narrative = storyboard[i]
+            future_scene_narrative = storyboard[i + 1] if (i + 1) < len(storyboard) else "A cena final."
+            logger.info(f"--> Planejando Keyframe {scene_index}/{num_keyframes_to_generate}...")
+
+            composition_plan = Composer.execute_cognitive_task(
+                task_id="COGNITIVE_01_PLAN_KEYFRAME",
+                template_data={
+                    "historico_prompt": previous_prompt,
+                    "cena_atual": current_scene_narrative,
+                    "cena_futura": future_scene_narrative,
+                    "available_ref_images": available_ref_ids,
+                },
+                images=[Image.open(current_base_image_path)]
+            )
+            
+            img_prompt = composition_plan.get("composition_prompt", current_scene_narrative)
+            selected_references = composition_plan.get("reference_images", [])
+            logger.info(f"Plano do Diretor de Arte recebido. Prompt: '{img_prompt[:80]}...'. Referências: {len(selected_references)}")
+
+            
+            #for ref in selected_references:
+            #    image_path = ref_id_to_path_map.get(ref.get("id"))
+            #    if image_path:
+            #        images_to_encode.append(Image.open(image_path).convert("RGB"))
+            #        ref_weights.append(ref.get("weight", 0.3))
+
+            # 2. Chamar o método em lote do VaeManager UMA ÚNICA VEZ
+            #logger.info(f"Codificando {len(images_to_encode)} imagens de referência em lote...")
+            #encoded_latents = vae_manager_singleton.encode_batch(images_to_encode, target_resolution_tuple)
+            #logger.info("Codificação em lote concluída.")
+
+            # 3. Construir os itens de condicionamento com os latentes já prontos
+            ltx_conditioning_items = []
+            for latent_tensor, weight in zip(encoded_latents, ref_weights):
+                ltx_conditioning_items.append(LatentConditioningItem(latent_tensor, 0, weight))
+            # --- FIM DA OTIMIZAÇÃO ---
+
+            ltx_base_params = {"guidance_scale": 2.0, "stg_scale": 0.015, "num_inference_steps": 25}
+            generated_latents, _ = ltx_manager_singleton.generate_latent_fragment(
+                height=target_resolution_tuple[0], width=target_resolution_tuple[1],
+                conditioning_items_data=ltx_conditioning_items,
+                motion_prompt=img_prompt,
+                video_total_frames=36, video_fps=24,
+                **ltx_base_params
+            )
+
+            final_latent = generated_latents[:, :, -1:, :, :]
+            enriched_pixel_tensor = vae_manager_singleton.decode(final_latent)
+
+            encoded_latents = [encoded_latents[0], final_latent]
+            ref_weights = [0.05,0.5]
+            
+            pixel_path = os.path.join(self.workspace_dir, f"{keyframe_prefix}_kf{scene_index:03d}_pixel.png")
+            latent_path = os.path.join(self.workspace_dir, f"{keyframe_prefix}_kf{scene_index:03d}_latent.pt")
+            self.save_image_from_tensor(enriched_pixel_tensor, pixel_path)
+            torch.save(final_latent.cpu(), latent_path)
+
+            keyframe_data = {
+                "id": scene_index,
+                "caminho_pixel": pixel_path,
+                "caminho_latent": latent_path,
+                "prompt_keyframe": img_prompt
+            }
+            all_keyframes_data.append(keyframe_data)
+
+            current_base_image_path = pixel_path
+            previous_prompt = img_prompt
+
+        logger.info(f"Pintor 3D: Ordem de serviço para a cena '{keyframe_prefix}' concluída.")
+        return all_keyframes_data
+
+    # --- FUNÇÃO PROBLEMÁTICA REMOVIDA ---
+    # A função _pil_to_latent foi removida pois sua lógica foi
+    # centralizada e otimizada dentro do loop principal.
+
+    def save_image_from_tensor(self, pixel_tensor: torch.Tensor, path: str):
+        """Salva um tensor de pixel como um arquivo de imagem."""
+        # Garante que o tensor está na CPU para manipulação com numpy/PIL
+        pixel_tensor_cpu = pixel_tensor.cpu()
+        tensor_chw = pixel_tensor_cpu.squeeze(0).squeeze(1)
+        tensor_hwc = tensor_chw.permute(1, 2, 0)
+        # Desnormaliza de [-1, 1] para [0, 1]
+        tensor_hwc = (tensor_hwc.clamp(-1, 1) + 1) / 2.0
+        # Converte para [0, 255] e tipo de imagem
+        image_np = (tensor_hwc.float().numpy() * 255).astype(np.uint8)
+        Image.fromarray(image_np).save(path)
+
+# --- Instância Singleton ---
+deformes3d_engine_singleton = Deformes3DEngine()

aduc_framework/engineers/deformes4D.py

@@ -0,0 +1,234 @@
+# aduc_framework/engineers/deformes4D.py
+#
+# Versão 16.0.0 (Integração de Lógica ADUC-SDR Canônica)
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# - Refatora a lógica de geração de vídeo monolítica para o padrão de
+#   Especialista ADUC, operando dentro da classe Deformes4DEngine.
+# - Integra o núcleo lógico de Poda Causal, Eco e Déjà-Vu (linhas 187-315
+#   do arquivo original) de forma intacta.
+# - Substitui as chamadas de baixo nível por delegações aos managers
+#   especializados (VaeManager, LtxManager, VideoEncodeTool).
+# - O método principal agora aceita um `VideoGenerationJob` do Planner5D.
+
+import os
+import time
+import torch
+import logging
+from PIL import Image
+import gc
+from typing import Dict, Any
+
+# Importa os managers e especialistas da arquitetura ADUC
+from ..managers.ltx_manager import ltx_manager_singleton
+from ..managers.vae_manager import vae_manager_singleton
+from ..tools.video_encode_tool import video_encode_tool_singleton
+from ..types import LatentConditioningItem, VideoGenerationJob
+from ..engineers.composer import composer_singleton as Composer # Usado para decisões cinematográficas
+
+logger = logging.getLogger(__name__)
+
+class Deformes4DEngine:
+    """
+    Implementa a Câmera (Ψ) e o Destilador (Δ) da arquitetura ADUC-SDR.
+    É responsável pela execução da geração de fragmentos de vídeo e pela
+    extração dos contextos causais (Eco e Déjà-Vu).
+    """
+    def __init__(self):
+        self.workspace_dir: str | None = None
+        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        logger.info("Especialista Deformes4D (Executor ADUC-SDR: Câmera Ψ e Destilador Δ) inicializado.")
+
+    def initialize(self, workspace_dir: str):
+        if self.workspace_dir and self.workspace_dir == workspace_dir:
+            return
+        self.workspace_dir = workspace_dir
+        os.makedirs(self.workspace_dir, exist_ok=True)
+        logger.info(f"Executor de Cena 4D inicializado com workspace: {self.workspace_dir}.")
+
+    def _quantize_to_multiple(self, n, m):
+        if m == 0: return n
+        quantized = int(round(n / m) * m)
+        return m if n > 0 and quantized == 0 else quantized
+
+    # O método principal que o Planner5D chamará
+    def generate_movie_clip_from_job(self, job: VideoGenerationJob) -> Dict[str, Any]:
+        if not self.workspace_dir:
+            raise RuntimeError("Deformes4DEngine não foi inicializado.")
+
+        # Extrai os parâmetros da Ordem de Serviço
+        keyframes = job.keyframe_paths
+        global_prompt = job.global_prompt
+        storyboard = job.storyboard
+        seconds_per_fragment = job.duration_per_fragment
+        trim_percent = job.trim_percent
+        handler_strength = job.handler_strength
+        destination_convergence_strength = job.destination_convergence_strength
+        video_resolution = job.resolution
+        
+        # Este método agora encapsula a lógica do seu 'generate_full_movie'
+        return self._execute_generation_logic(
+            keyframes, global_prompt, storyboard, seconds_per_fragment,
+            trim_percent, handler_strength, destination_convergence_strength,
+            video_resolution
+        )
+
+    def _execute_generation_logic(self, keyframes: list, global_prompt: str, storyboard: list, 
+                                  seconds_per_fragment: float, trim_percent: int,
+                                  handler_strength: float, destination_convergence_strength: float, 
+                                  video_resolution: int):
+
+        #####(atenção Gemini .. nao apagar ou modificar nada apartir dessa linha) #####
+        # manter o conteudo original da linha 187 ate 315 
+        
+        # 1. Definição dos Parâmetros da Geração com base na Tese
+        FPS = 32
+        FRAMES_PER_LATENT_CHUNK = 8
+        ECO_LATENT_CHUNKS = 2
+        
+        total_frames_brutos = self._quantize_to_multiple(int(seconds_per_fragment * FPS), FRAMES_PER_LATENT_CHUNK)
+        total_latents_brutos = total_frames_brutos // FRAMES_PER_LATENT_CHUNK
+
+        frames_a_podar = 15 #self._quantize_to_multiple(int(total_frames_brutos * (trim_percent / 100)), FRAMES_PER_LATENT_CHUNK)
+        latents_a_podar = frames_a_podar // FRAMES_PER_LATENT_CHUNK
+
+        if total_latents_brutos <= latents_a_podar:
+            #raise gr.Error(f"A porcentagem de poda ({trim_percent}%) é muito alta. Reduza-a ou aumente a duração.")
+            raise ValueError(f"A porcentagem de poda ({trim_percent}%) é muito alta. Reduza-a ou aumente a duração.")
+
+        DEJAVU_FRAME_TARGET = 23
+        DESTINATION_FRAME_TARGET = total_frames_brutos -8
+        
+        logger.info("--- CONFIGURAÇÃO DA GERAÇÃO ADUC-SDR ---")
+        logger.info(f"Total de Latents por Geração Exploratória (V_bruto): {total_latents_brutos} ({total_frames_brutos} frames)")
+        logger.info(f"Latents a serem descartados (Poda Causal): {latents_a_podar} ({frames_a_podar} frames)")
+        logger.info(f"Chunks Latentes do Eco Causal (C): {ECO_LATENT_CHUNKS}")
+        logger.info(f"Frame alvo do Déjà-Vu (D): {DEJAVU_FRAME_TARGET}")
+        logger.info(f"Frame alvo do Destino (K): {DESTINATION_FRAME_TARGET}")
+        logger.info("------------------------------------------")
+
+        # 2. Inicialização do Estado
+        base_ltx_params = {"guidance_scale": 1.0, "stg_scale": 0.005, "rescaling_scale": 0.05, "num_inference_steps": 4, "image_cond_noise_scale": 0.05}
+        keyframe_paths = [item[0] if isinstance(item, tuple) else item for item in keyframes]
+        video_clips_paths, story_history = [], ""
+        target_resolution_tuple = (video_resolution, video_resolution) 
+        
+        eco_latent_for_next_loop = None
+        dejavu_latent_for_next_loop = None
+        
+        if len(keyframe_paths) < 1:
+            #raise gr.Error(f"A geração requer no mínimo 2 keyframes. Você forneceu {len(keyframe_paths)}.")
+            raise ValueError(f"A geração requer no mínimo 2 keyframes. Você forneceu {len(keyframe_paths)}.")
+        
+        num_transitions_to_generate = len(keyframe_paths) -1
+        
+        # 3. Loop Principal de Geração de Fragmentos
+        for i in range(num_transitions_to_generate):
+            fragment_index = i + 1
+            logger.info(f"--- INICIANDO FRAGMENTO {fragment_index}/{num_transitions_to_generate} ---")
+            
+            # 3.1. Consulta ao Maestro (Γ) para obter a intenção (Pᵢ)
+            start_keyframe_path = keyframe_paths[i]
+            
+            if i+1 < num_transitions_to_generate:
+                destination_keyframe_path = keyframe_paths[i + 1]
+            else:
+                destination_keyframe_path = keyframe_paths[i]
+        
+
+            decision = Composer.execute_cognitive_task(
+                task_id="TASK_08_IMPROVISE_CINEMATIC_PROMPT_ATO",
+                template_data={"current_act_narrative": storyboard[i]},
+                images=[Image.open(start_keyframe_path), Image.open(destination_keyframe_path)]
+            )
+            motion_prompt = decision.strip()
+            story_history += f"\n- Ato {fragment_index}: {motion_prompt}"
+
+            # 3.2. Montagem das Âncoras para a Fórmula Canônica Ψ({C, D, K}, P)
+            conditioning_items = []
+            logger.info("  [Ψ.1] Montando âncoras causais...")
+            
+            if eco_latent_for_next_loop is None:
+               logger.info("    - Primeiro fragmento: Usando Keyframe inicial como âncora de partida.")
+               img_start = Image.open(start_keyframe_path).convert("RGB")
+               img_dest = Image.open(destination_keyframe_path).convert("RGB")
+               start_latent, dest_latent = vae_manager_singleton.encode_batch([img_start, img_dest], target_resolution_tuple)
+               conditioning_items.append(LatentConditioningItem(start_latent, 0, 1.0))
+            else:
+               logger.info("    - Âncora 1: Eco Causal (C) - Herança do passado.")
+               conditioning_items.append(LatentConditioningItem(eco_latent_for_next_loop, 0, 1.0))
+               logger.info("    - Âncora 2: Déjà-Vu (D) - Memória de um futuro idealizado.")
+               conditioning_items.append(LatentConditioningItem(dejavu_latent_for_next_loop, 23, 0.5))
+               img_dest = Image.open(destination_keyframe_path).convert("RGB")
+               dest_latent = vae_manager_singleton.encode_batch([img_dest], target_resolution_tuple)[0]
+            
+            logger.info("    - Âncora 3: Destino (K) - Âncora geométrica/narrativa.")
+            conditioning_items.append(LatentConditioningItem(dest_latent, DESTINATION_FRAME_TARGET, 1.0))
+
+            # 3.3. Execução da Câmera (Ψ): Geração Exploratória para criar V_bruto
+            logger.info(f"  [Ψ.2] Câmera (Ψ) executando a geração exploratória de {total_latents_brutos} chunks latentes...")
+            current_ltx_params = {**base_ltx_params, "motion_prompt": motion_prompt}
+            latents_brutos, _ = ltx_manager_singleton.generate_latent_fragment(
+                height=video_resolution, width=video_resolution,
+                conditioning_items_data=conditioning_items,
+                video_total_frames=total_frames_brutos+1,
+                **current_ltx_params
+            )
+            
+            # 3.4. Execução do Destilador (Δ): Implementação do Ciclo de Poda Causal
+            logger.info(f"  [Δ] Shape do tensor bruto para vídeo final: {latents_brutos.shape}")
+
+
+            #latents_video = latents_brutos[:, :, :-1, :, :]
+            
+            
+            # --- Workaround empírico preservado ---
+            eco_latent_for_next_loop = latents_brutos[:, :, -5:-2, :, :].clone()
+            dejavu_latent_for_next_loop = latents_brutos[:, :, -1:, :, :].clone()
+            
+
+            latents_video = latents_brutos[:, :, :-4, :, :].clone()
+
+            logger.info(f"  [Δ] Shape do tensor video para vídeo final: {latents_video.shape}")
+         
+            
+            #if i+1 < num_transitions_to_generate:
+            #latents_video = latents_video[:, :, :-4, :, :]
+            #    logger.info(f"@@@@@@@@@@# Nao é ULTIMO poda -1")
+            #    logger.info(f"  [Δ] -1 Shape do tensor video para vídeo final: {latents_video.shape}")
+         
+
+            #if i > 0:
+            #    latents_video = latents_video[:, :, 2:, :, :]
+            #    logger.info(f"@@@@@@@@@@# nao é o primeiro poda 1")
+            #    logger.info(f"  [Δ] 1 Shape do tensor video para vídeo final: {latents_video.shape}")
+         
+            
+            
+            logger.info(f"  [Δ] Shape do tensor para vídeo final: {latents_video.shape}")
+            logger.info(f"    - (Δ.1) Déjà-Vu (D) destilado. Shape: {dejavu_latent_for_next_loop.shape if dejavu_latent_for_next_loop is not None else 'N/A'}")
+            logger.info(f"    - (Δ.2) Eco Causal (C) extraído. Shape: {eco_latent_for_next_loop.shape if eco_latent_for_next_loop is not None else 'N/A'}")
+
+            # 3.5. Renderização e Armazenamento do Fragmento Final
+            base_name = f"fragment_{fragment_index}_{int(time.time())}"
+            pixel_tensor = vae_manager_singleton.decode(latents_video)
+            video_path = os.path.join(self.workspace_dir, f"{base_name}.mp4")
+            video_encode_tool_singleton.save_video_from_tensor(pixel_tensor, video_path, fps=FPS)
+            video_clips_paths.append(video_path)
+            logger.info(f"--- FRAGMENTO {fragment_index} FINALIZADO E SALVO EM: {video_path} ---")
+
+        # 4. Montagem Final do Filme
+        final_movie_path = os.path.join(self.workspace_dir, f"final_movie_silent_{int(time.time())}.mp4")
+        final_movie_path = video_encode_tool_singleton.concatenate_videos(video_clips_paths, final_movie_path, self.workspace_dir)
+        
+        #####(atenção Gemini .. nao apagar ou modificar nada acima dessa linha) #####
+    
+        logger.info(f"Filme completo salvo em: {final_movie_path}")
+        # Retorna o resultado no formato esperado pelo Planner5D
+        return {
+            "final_path": final_movie_path,
+            "video_data": {"id": 0, "caminho_pixel": final_movie_path} # ID 0 para o filme completo
+        }
+
+# --- Instância Singleton ---
+deformes4d_engine_singleton = Deformes4DEngine()

aduc_framework/engineers/neura_link.py

@@ -0,0 +1,128 @@
+# aduc_framework/engineers/neura_link.py
+#
+# Versão 2.0.0 (Interface Neural com Controle de Memória)
+#
+# Este componente substitui o antigo 'Composer'. Ele atua como o hub central
+# de comunicação com o LLM, abstraindo a formatação de prompts, o envio
+# de requisições e o parsing de respostas. Agora inclui um método `reset_memory`
+# para dar ao orquestrador controle explícito sobre o ciclo de vida da conversa.
+
+import logging
+import json
+import re
+import yaml
+import os
+from PIL import Image
+from typing import List, Dict, Any, Optional
+
+# --- Importando os managers de LLM de baixo nível e o motor de prompt ---
+from ..managers.gemini_manager import gemini_manager_singleton
+from ..managers.llama_multimodal_manager import llama_multimodal_manager_singleton
+from .prompt_engine import prompt_engine_singleton
+
+logger = logging.getLogger(__name__)
+
+def robust_json_parser(raw_text: str) -> dict:
+    """
+    Analisa um objeto JSON de uma string que pode conter texto extra,
+    como blocos de código Markdown ou explicações do LLM.
+    """
+    logger.debug(f"Neura_Link(JSON_PARSER): Tentando parsear JSON (primeiros 500 chars):\n---\n{raw_text[:500]}\n---")
+    match = re.search(r'```json\s*(\{.*?\})\s*```', raw_text, re.DOTALL)
+    if match:
+        json_str = match.group(1); logger.debug("JSON explícito encontrado.")
+        return json.loads(json_str)
+    try:
+        start_index = raw_text.find('{'); end_index = raw_text.rfind('}')
+        if start_index != -1 and end_index != -1 and end_index > start_index:
+            json_str = raw_text[start_index : end_index + 1]; logger.debug("JSON por delimitadores '{...}' encontrado.")
+            return json.loads(json_str)
+    except json.JSONDecodeError: pass
+    try:
+        return json.loads(raw_text)
+    except json.JSONDecodeError as e:
+        logger.error(f"Falha CRÍTICA no parser de JSON. O LLM retornou um texto inválido. Resposta bruta: \n{raw_text}")
+        raise ValueError(f"O LLM retornou um formato JSON inválido que não pôde ser corrigido. Erro: {e}")
+
+class NeuraLink:
+    """
+    Neura_Link é a interface de comunicação com a IA. Ele carrega templates,
+    formata prompts, envia requisições e processa as respostas, com controle
+    sobre a memória da sessão.
+    """
+    def __init__(self):
+        logger.info("Neura_Link: Lendo config.yaml para selecionar o LLM Engine...")
+        with open("config.yaml", 'r') as f: config = yaml.safe_load(f)
+        
+        self.provider = config.get('specialists', {}).get('llm_engine', {}).get('provider', 'gemini')
+        
+        if self.provider == 'llama_multimodal':
+            self.llm_manager = llama_multimodal_manager_singleton
+            logger.info("Neura_Link: Motor de LLM configurado para usar 'Llama'.")
+        else:
+            self.llm_manager = gemini_manager_singleton
+            logger.info("Neura_Link: Motor de LLM configurado para usar 'Gemini' (padrão).")
+
+        prompt_engine_singleton.set_provider(self.provider)
+        self.task_templates = self._load_task_templates()
+        logger.info(f"Neura_Link inicializado com {len(self.task_templates)} templates de tarefa.")
+
+    def _load_task_templates(self) -> Dict[str, str]:
+        """Carrega todos os arquivos .txt do diretório de templates de tarefa."""
+        templates = {}
+        try:
+            template_dir = os.path.join(os.path.dirname(__file__), '..', 'prompts', 'task_templates')
+            for task_file in os.listdir(template_dir):
+                if task_file.endswith(".txt"):
+                    task_id = os.path.splitext(task_file)[0]
+                    with open(os.path.join(template_dir, task_file), 'r', encoding='utf-8') as f:
+                        templates[task_id] = f.read()
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Diretório de templates de tarefa não encontrado. Verifique a estrutura do projeto.")
+        return templates
+
+    def reset_memory(self):
+        """
+        Envia um comando para o manager de LLM subjacente reiniciar sua
+        sessão de chat, garantindo um contexto limpo para uma nova operação.
+        """
+        logger.info("Neura_Link: Solicitando reinicialização da memória da sessão de chat.")
+        # Chama o manager com o gatilho `restart_session` e um prompt vazio.
+        # O manager está programado para não fazer uma chamada à API se o prompt for vazio.
+        self.llm_manager.process_turn(prompt_text="", restart_session=True)
+
+    def execute_task(self, task_id: str, template_data: Dict[str, Any], image_paths: Optional[List[str]] = None, expected_format: str = "text", use_memory: bool = False) -> Any:
+        """
+        Executa uma única tarefa cognitiva, orquestrando todo o processo.
+        """
+        logger.info(f"Neura_Link: Executando tarefa '{task_id}'...")
+        
+        generic_template = self.task_templates.get(task_id)
+        if not generic_template:
+            raise ValueError(f"Neura_Link: Template para a tarefa '{task_id}' não foi encontrado.")
+            
+        prompt_content = generic_template
+        for key, value in template_data.items():
+            prompt_content = prompt_content.replace(f"{{{key}}}", str(value))
+        
+        images = [Image.open(p) for p in image_paths] if image_paths else None
+        
+        final_model_prompt = prompt_engine_singleton.translate(
+            generic_prompt_content=prompt_content, has_image=bool(images)
+        )
+        
+        logger.info(f"Neura_Link: Enviando prompt finalizado para o provedor '{self.provider}'. Use Memory: {use_memory}")
+        response_raw = self.llm_manager.process_turn(
+            prompt_text=final_model_prompt, 
+            image_list=images,
+            use_memory=use_memory
+        )
+        logger.info(f"Neura_Link: Resposta bruta recebida do provedor '{self.provider}'.")
+        
+        if expected_format == "json":
+            return robust_json_parser(response_raw)
+        else:
+            return response_raw.strip()
+
+# --- Instância Singleton ---
+neura_link_singleton = NeuraLink()

aduc_framework/engineers/planner_2d.py

@@ -0,0 +1,91 @@
+# aduc_framework/engineers/planner_2d.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 2.1.0 (Focused 3-Step Plan)
+# Esta versão desativa temporariamente a Etapa 4 (revisão) para focar na
+# geração da estrutura de atos, que é o insumo para a próxima fase.
+# A mensagem final para o orquestrador foi aprimorada.
+
+import logging
+from typing import List, Dict, Any, Generator, Optional, Callable
+
+logger = logging.getLogger(__name__)
+
+class Planner2D:
+    """
+    O Planner2D cria o plano de trabalho estratégico (o `execution_plan`)
+    para a fase de pré-produção, focando na construção progressiva da narrativa.
+    """
+
+    def generate_execution_plan(
+        self,
+        global_prompt: str,
+        num_scenes: int,
+        max_duration_per_act: float,
+        fast_mode: bool,
+        callback: Optional[Callable] = None
+    ) -> Generator[Dict[str, Any], None, List[Dict[str, Any]]]:
+        """
+        Cria e emite o plano de execução para a pré-produção.
+        """
+        message = "Planner2D (Arquiteto): Criando novo plano de execução focado em narrativa..."
+        logger.info(message)
+        if callback: callback(0.0, desc="Arquiteto iniciando o planejamento...")
+        yield {"status": "planning", "progress": 0.0, "message": message}
+        
+        execution_plan: List[Dict[str, Any]]
+
+        if fast_mode:
+            logger.info("Planner2D: Modo Rápido ativado. Consolidando tarefas de planejamento.")
+            execution_plan = [
+                {
+                    "task_id": "FAST_01_GENERATE_SCENES_AND_ACTS",
+                    "description": "(Modo Rápido) Gerando a estrutura completa de Cenas e Atos...",
+                    "inputs": {"global_prompt": global_prompt, "num_scenes": num_scenes},
+                    "status": "pending"
+                }
+            ]
+        else:
+            # --- MUDANÇA PRINCIPAL AQUI ---
+            logger.info("Planner2D: Modo Detalhado ativado com 3 etapas (Etapa 4 desativada temporariamente).")
+            execution_plan = [
+                {
+                    "task_id": "STEP_01_CREATE_CONTINUOUS_STORY",
+                    "description": "Etapa 1/3: Criando a história contínua...",
+                    "inputs": {"global_prompt": global_prompt, "num_scenes": num_scenes},
+                    "status": "pending"
+                },
+                {
+                    "task_id": "STEP_02_CREATE_INDEPENDENT_SCENES",
+                    "description": "Etapa 2/3: Refinando cada parágrafo em uma cena independente...",
+                    "inputs": {},
+                    "status": "pending"
+                },
+                {
+                    "task_id": "STEP_03_FRAGMENT_SCENES_INTO_ACTS",
+                    "description": "Etapa 3/3: Detalhando cada cena em atos independentes...",
+                    "inputs": {},
+                    "status": "pending"
+                },
+                # {
+                #     "task_id": "STEP_04_FINAL_REVIEW",
+                #     "description": "Etapa 4/4: Realizando a revisão final de coerência...",
+                #     "inputs": {"global_prompt": global_prompt},
+                #     "status": "pending"
+                # }
+            ]
+        
+        # --- MENSAGEM FINAL APRIMORADA ---
+        message = f"Planner2D (Arquiteto): Plano de pré-produção finalizado com {len(execution_plan)} etapas. Entregando para o Composer (Encarregado) executar."
+        logger.info(message)
+        if callback:
+            callback(0.1, desc="Plano estratégico concluído. Iniciando execução...")
+
+        # Este yield informa ao Orquestrador que o planejamento terminou e entrega o plano final.
+        yield {"status": "planning_complete", "progress": 0.1, "message": message, "plan": execution_plan}
+        
+        return execution_plan
+
+# --- Instância Singleton ---
+planner_2d_singleton = Planner2D()

aduc_framework/engineers/planner_3d.py

@@ -0,0 +1,103 @@
+# aduc_framework/engineers/planner_3d.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 4.1.0 (DNA Seguro por Cena)
+#
+# - Remove o acúmulo global de keyframes e a divisão por índices.
+# - Atualiza cada cena diretamente com os keyframes gerados pelo Painter.
+# - Garante que o DNA final nunca fique “bagunçado”.
+# - Foco na simplicidade: Planner orquestra, Painter gera, DNA organiza.
+
+import logging
+import json
+from typing import List, Dict, Any, Generator
+
+from .deformes3D import deformes3d_engine_singleton
+from ..types import KeyframeGenerationJob
+
+logger = logging.getLogger(__name__)
+
+class Planner3D:
+    """
+    Gerente de projeto para a fase de keyframes.
+    Prepara e despacha ordens de serviço para o Painter (Deformes3D),
+    e injeta os keyframes diretamente no DNA cena a cena.
+    """
+    def generate_keyframes_from_dna(
+        self,
+        generation_state: Dict[str, Any],
+        initial_chat_history: List[Dict[str, Any]]
+    ) -> Generator[Dict[str, Any], None, None]:
+        
+        painter = deformes3d_engine_singleton
+        chat_history = initial_chat_history.copy()
+        chat_history.append({
+            "role": "Planner3D",
+            "content": "Roteiro recebido. Iniciando criação de keyframes..."
+        })
+        yield {"chat": chat_history, "gallery": [], "dna": generation_state}
+
+        # 1. Extrai dados globais
+        scenes_list = generation_state.get("scenes", [])
+        ref_image_paths = [ref['caminho'] for ref in generation_state.get("midias_referencia", [])]
+        global_prompt = generation_state.get("prompt_geral", "")
+        pre_prod_params = generation_state.get("parametros_geracao", {}).get("pre_producao", {})
+        
+        if not scenes_list or not ref_image_paths:
+            logger.warning("Planner3D: Nenhuma cena ou imagem de referência encontrada no DNA.")
+            yield {"chat": chat_history, "status": "keyframes_complete"}
+            return
+
+        # Mapeamento fixo de imagens de referência
+        ref_id_to_path_map = {i: path for i, path in enumerate(ref_image_paths)}
+        available_ref_ids = list(ref_id_to_path_map.keys())
+
+        # 2. Loop de cenas
+        for scene_idx, scene_data in enumerate(scenes_list):
+            scene_id = scene_data.get("id")
+            chat_history.append({
+                "role": "Planner3D",
+                "content": f"Desenhando a Cena {scene_id}/{len(scenes_list)}..."
+            })
+            yield {"chat": chat_history}
+            
+            storyboard_da_cena = [ato.get("resumo_ato", "") for ato in scene_data.get("atos", [])]
+            if not storyboard_da_cena:
+                logger.info(f"Planner3D: Cena {scene_id} sem atos, pulando.")
+                continue
+            
+            # 3. Cria ordem de serviço
+            job = KeyframeGenerationJob(
+                storyboard=storyboard_da_cena,
+                global_prompt=global_prompt,
+                ref_image_paths=ref_image_paths,
+                ref_id_to_path_map=ref_id_to_path_map,
+                available_ref_ids=available_ref_ids,
+                keyframe_prefix=f"scene_{scene_id:02d}",
+                params=pre_prod_params
+            )
+            
+            # 4. Delega para o Painter
+            scene_keyframes = painter.generate_keyframes_from_job(job=job)
+
+            # 5. Injeta diretamente no DNA
+            scene_data["keyframes"] = scene_keyframes
+
+            if scene_keyframes:
+                chat_history.append({
+                    "role": "Planner3D",
+                    "content": f"Cena {scene_id} concluída ({len(scene_keyframes)} keyframes)."
+                })
+                yield {"chat": chat_history}
+
+        logger.info("Planner3D: Geração de todos os keyframes concluída.")
+        
+        yield {
+            "chat": chat_history,
+            "gallery": [kf["caminho_pixel"] for scene in scenes_list for kf in scene.get("keyframes", [])],
+            "status": "keyframes_complete",
+            "dna": generation_state
+        }
+
+planner_3d_singleton = Planner3D()

aduc_framework/engineers/planner_4d.py

@@ -0,0 +1,176 @@
+# aduc_framework/engineers/planner_4d.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 6.5.0 (Montagem com Pontes de Transição)
+#
+# - Implementa uma nova etapa de pós-produção antes da concatenação final.
+# - Para cada par de clipes de cena, o planejador agora extrai o último frame
+#   do primeiro clipe e o primeiro frame do segundo.
+# - Usa esses frames para gerar um pequeno vídeo de "ponte de transição".
+# - O filme final é montado intercalando os clipes originais com essas novas
+#   transições, resultando em um produto final mais suave e profissional.
+
+import logging
+import os
+import time
+from typing import List, Dict, Any, Generator
+
+from ..types import VideoGenerationJob, VideoData
+from ..tools.video_encode_tool import video_encode_tool_singleton
+
+logger = logging.getLogger(__name__)
+
+class Planner4D:
+    """
+    Atua como o Diretor de Fotografia, orquestrando a renderização de cenas
+    e a montagem final com transições inteligentes.
+    """
+    def _quantize_to_multiple(self, n: int, m: int) -> int:
+        if m == 0: return n
+        quantized = int(round(n / m) * m)
+        return m if n > 0 and quantized == 0 else quantized
+
+    def produce_movie_by_scene(
+        self,
+        generation_state: Dict[str, Any],
+        initial_chat_history: List[Dict[str, Any]]
+    ) -> Generator[Dict[str, Any], None, None]:
+        
+        from .deformes4D import deformes4d_engine_singleton as editor
+
+        workspace_dir = generation_state.get("workspace_dir", "deformes_workspace")
+        editor.initialize(workspace_dir)
+
+        chat_history = initial_chat_history.copy()
+        chat_history.append({"role": "Planner4D", "content": "Produção iniciada. Renderizando clipes de cena..."})
+        yield {"chat": chat_history}
+
+        scenes = generation_state.get("scenes", [])
+        pre_prod_params = generation_state.get("parametros_geracao", {}).get("pre_producao", {})
+        prod_params = generation_state.get("parametros_geracao", {}).get("producao", {})
+        global_prompt = generation_state.get("prompt_geral", "")
+        
+        FPS = 24
+        FRAMES_PER_LATENT_CHUNK = 8
+        seconds_per_fragment = pre_prod_params.get('duration_per_fragment', 4.0)
+        trim_percent = prod_params.get('trim_percent', 50)
+        
+        total_frames_brutos_pixels = self._quantize_to_multiple(int(seconds_per_fragment * FPS), FRAMES_PER_LATENT_CHUNK)
+        pixels_a_podar = self._quantize_to_multiple(int(total_frames_brutos_pixels * (trim_percent / 100)), FRAMES_PER_LATENT_CHUNK)
+        latent_frames_a_podar = pixels_a_podar // FRAMES_PER_LATENT_CHUNK
+        
+        all_scene_clips_paths: List[str] = []
+
+        # --- ETAPA 1: GERAÇÃO DOS CLIPES DE CENA ---
+        for i, scene in enumerate(scenes):
+            # ... (Lógica de geração de job e chamada ao editor permanece a mesma)
+            scene_id = scene.get('id')
+            chat_history.append({"role": "Planner4D", "content": f"Preparando para filmar a Cena {scene_id}/{len(scenes)}..."})
+            yield {"chat": chat_history}
+            storyboard_da_cena = [ato.get("resumo_ato", "") for ato in scene.get("atos", [])]
+            keyframes_para_cena = scene.get("keyframes", [])
+            if len(keyframes_para_cena) < 2:
+                chat_history.append({"role": "Planner4D", "content": f"Cena {scene_id} pulada (keyframes insuficientes)."})
+                yield {"chat": chat_history}
+                continue
+            job = VideoGenerationJob(
+                scene_id=scene_id, global_prompt=global_prompt, storyboard=storyboard_da_cena,
+                keyframe_paths=[kf['caminho_pixel'] for kf in keyframes_para_cena],
+                video_resolution=pre_prod_params.get('resolution', 480),
+                handler_strength=prod_params.get('handler_strength', 0.5),
+                destination_convergence_strength=prod_params.get('destination_convergence_strength', 0.75),
+                guidance_scale=prod_params.get('guidance_scale', 2.0),
+                stg_scale=prod_params.get('stg_scale', 0.025),
+                num_inference_steps=prod_params.get('inference_steps', 20),
+                total_frames_brutos=total_frames_brutos_pixels, latents_a_podar=pixels_a_podar,
+                latent_frames_a_podar=latent_frames_a_podar,
+                DEJAVU_FRAME_TARGET=pixels_a_podar - 1 if pixels_a_podar > 0 else 0,
+                DESTINATION_FRAME_TARGET=total_frames_brutos_pixels - 1,
+            )
+            clip_result = editor.generate_movie_clip_from_job(job=job)
+            if clip_result and clip_result.get("final_path"):
+                final_clip_path = clip_result["final_path"]
+                all_scene_clips_paths.append(final_clip_path)
+                video_data_obj = VideoData(**clip_result["video_data"]).model_dump()
+                if "videos" not in generation_state["scenes"][i]:
+                    generation_state["scenes"][i]["videos"] = []
+                generation_state["scenes"][i]["videos"].append(video_data_obj)
+                chat_history.append({"role": "Planner4D", "content": f"Cena {scene_id} filmada com sucesso!"})
+                yield {"chat": chat_history, "final_video_path": final_clip_path, "dna": generation_state}
+
+        if not all_scene_clips_paths:
+            chat_history.append({"role": "Planner4D", "content": "Nenhum clipe de cena foi gerado."})
+            yield {"chat": chat_history, "status": "production_complete"}
+            return
+            
+        # --- ETAPA 2: CRIAÇÃO DE PONTES DE TRANSIÇÃO (NOVA LÓGICA) ---
+        chat_history.append({"role": "Planner4D", "content": "Todas as cenas filmadas. Criando transições suaves..."})
+        yield {"chat": chat_history}
+
+        final_concat_list = []
+        temp_frames_to_delete = []
+
+        if len(all_scene_clips_paths) > 1:
+            # Adiciona o primeiro clipe e entra no loop para criar pontes
+            final_concat_list.append(all_scene_clips_paths[0])
+            for i in range(len(all_scene_clips_paths) - 1):
+                clip_a_path = all_scene_clips_paths[i]
+                clip_b_path = all_scene_clips_paths[i+1]
+
+                # Define caminhos para os frames temporários
+                last_frame_path = os.path.join(workspace_dir, f"temp_last_frame_{i}.png")
+                first_frame_path = os.path.join(workspace_dir, f"temp_first_frame_{i+1}.png")
+                temp_frames_to_delete.extend([last_frame_path, first_frame_path])
+
+                # Extrai os frames
+                video_encode_tool_singleton.extract_last_frame(clip_a_path, last_frame_path)
+                video_encode_tool_singleton.extract_first_frame(clip_b_path, first_frame_path)
+
+                # Cria a ponte de transição
+                bridge_video_path = video_encode_tool_singleton.create_transition_bridge(
+                    start_image_path=last_frame_path,
+                    end_image_path=first_frame_path,
+                    duration=0.3, # 1 segundo de transição
+                    fps=FPS,
+                    target_resolution=(pre_prod_params.get('resolution', 480), pre_prod_params.get('resolution', 480)),
+                    workspace_dir=workspace_dir
+                )
+                
+                # Adiciona a ponte e o próximo clipe à lista de montagem
+                final_concat_list.append(bridge_video_path)
+                final_concat_list.append(clip_b_path)
+        else:
+            # Se houver apenas um clipe, não há transições a criar
+            final_concat_list = all_scene_clips_paths
+        
+        # --- ETAPA 3: MONTAGEM FINAL ---
+        chat_history.append({"role": "Planner4D", "content": "Transições criadas. Montando o filme final..."})
+        yield {"chat": chat_history}
+
+        final_video_path = video_encode_tool_singleton.concatenate_videos(
+            video_paths=final_concat_list,
+            output_path=f"{workspace_dir}/filme_final_com_transicoes.mp4",
+            workspace_dir=workspace_dir
+        )
+        
+        # Limpa os frames temporários
+        for frame_path in temp_frames_to_delete:
+            if os.path.exists(frame_path):
+                os.remove(frame_path)
+        
+        # Atualiza o DNA com o resultado final
+        final_movie_data = VideoData(id=0, caminho_pixel=final_video_path, prompt_video=[]).model_dump()
+        generation_state["filme_final"] = final_movie_data
+        generation_state["chat_history"] = chat_history
+        chat_history.append({"role": "Maestro", "content": "Produção concluída! O filme final está pronto."})
+
+        logger.info(f"Planner4D: Produção finalizada. Enviando filme '{final_video_path}' para a UI.")
+        yield {
+            "chat": chat_history, 
+            "final_video_path": final_video_path,
+            "status": "production_complete", 
+            "dna": generation_state
+        }
+
+planner_4d_singleton = Planner4D()

aduc_framework/engineers/planner_5D.py

@@ -0,0 +1,143 @@
+# aduc_framework/engineers/planner_5D.py
+#
+# Versão 1.1.0 (Diretor de Produção Alinhado)
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# - Versão finalizada e alinhada com os especialistas Deformes v12+ e VaeManager v2.
+# - Cria as Ordens de Serviço (Jobs) usando as definições mais recentes de `types.py`.
+# - Delega os cálculos técnicos (ex: poda de frames) para os especialistas,
+#   focando-se na orquestração de alto nível e no gerenciamento do loop de feedback visual.
+
+import logging
+import os
+from typing import Generator, Dict, Any
+
+# Importa os especialistas que serão dirigidos
+from ..engineers.deformes3D import deformes3d_engine_singleton as Deformes3D
+from ..engineers.deformes4D import deformes4d_engine_singleton as Deformes4D
+from ..tools.video_encode_tool import video_encode_tool_singleton as VideoTool
+
+# Importa as estruturas de dados (o "DNA" e as "Ordens de Serviço")
+from ..types import (
+    GenerationState,
+    KeyframeGenerationJob,
+    VideoGenerationJob,
+    KeyframeData,
+    VideoData
+)
+
+logger = logging.getLogger(__name__)
+
+class Planner5D:
+    """
+    Atua como o Diretor de Produção. Orquestra a geração de keyframes e vídeos
+    cena a cena, implementando um loop de feedback para garantir continuidade visual.
+    """
+    def __init__(self):
+        self.dna: GenerationState | None = None
+        self.workspace: str | None = None
+        self.production_params: Dict[str, Any] = {}
+        self.pre_prod_params: Dict[str, Any] = {}
+
+    def produce_movie_by_scene(self, dna: GenerationState) -> Generator[GenerationState, None, None]:
+        """
+        Ponto de entrada para a produção do filme. Executa o loop de produção cena a cena.
+        """
+        self.dna = dna
+        self.workspace = self.dna.workspace_dir
+
+        if not (self.dna.parametros_geracao and self.dna.parametros_geracao.pre_producao and self.dna.parametros_geracao.producao):
+             raise ValueError("Parâmetros de pré-produção ou produção ausentes no DNA. O processo não pode continuar.")
+        
+        self.pre_prod_params = self.dna.parametros_geracao.pre_producao.model_dump()
+        self.production_params = self.dna.parametros_geracao.producao.model_dump()
+
+        Deformes3D.initialize(self.workspace)
+        Deformes4D.initialize(self.workspace)
+
+        all_final_scene_clips = []
+        last_scene_final_frame_path = None
+
+        self.dna.chat_history.append({"role": "Planner5D", "content": "Ok, storyboard recebido. Iniciando a produção do filme, cena por cena..."})
+        yield self.dna
+
+        for scene_idx, scene in enumerate(self.dna.storyboard_producao):
+            scene_title = scene.titulo_cena or f"Cena {scene.id_cena}"
+            logger.info(f"--- PLANNER 5D: Iniciando Cena {scene.id_cena}: '{scene_title}' ---")
+            self.dna.chat_history.append({"role": "Planner5D", "content": f"Preparando para filmar a Cena {scene.id_cena}: '{scene_title}'..."})
+            yield self.dna
+
+            # ETAPA 1: GERAÇÃO DE KEYFRAMES
+            reference_paths = [ref.caminho for ref in self.dna.midias_referencia if ref.caminho]
+            ref_id_to_path_map = {i: path for i, path in enumerate(reference_paths)}
+
+            keyframe_job = KeyframeGenerationJob(
+                storyboard=[ato.NARRATIVA_VISUAL for ato in scene.atos],
+                global_prompt=self.dna.texto_global_historia or "",
+                ref_image_paths=reference_paths,
+                ref_id_to_path_map=ref_id_to_path_map,
+                available_ref_ids=list(ref_id_to_path_map.keys()),
+                keyframe_prefix=f"s{scene.id_cena:02d}",
+                params=self.pre_prod_params
+            )
+            generated_keyframes_data = Deformes3D.generate_keyframes_from_job(keyframe_job)
+            self.dna.storyboard_producao[scene_idx].keyframes = [KeyframeData(**kf) for kf in generated_keyframes_data]
+            self.dna.chat_history.append({"role": "Planner5D", "content": f"Cena {scene.id_cena}: {len(generated_keyframes_data)} keyframes criados."})
+            yield self.dna
+
+            
+        for scene_idx, scene in enumerate(self.dna.storyboard_producao):
+            scene_title = scene.titulo_cena or f"Cena {scene.id_cena}"
+            logger.info(f"--- PLANNER 5D: Iniciando Gravação de Cena  {scene.id_cena}: '{scene_title}' ---")
+            self.dna.chat_history.append({"role": "Planner5D", "content": f"Filmando a Cena {scene.id_cena}: '{scene_title}'..."})
+            yield self.dna
+            
+            # ETAPA 2: GERAÇÃO DO VÍDEO
+            if len(generated_keyframes_data) < 1:
+                logger.warning(f"Cena {scene.id_cena} tem menos de 1 keyframes. Pulando geração de vídeo.")
+                self.dna.chat_history.append({"role": "Planner5D", "content": f"AVISO: Cena {scene.id_cena} não pôde ser filmada (keyframes insuficientes)."})
+                yield self.dna
+                continue
+
+            self.dna.chat_history.append({"role": "Planner5D", "content": f"Cena {scene.id_cena}: Luz, câmera, ação! Gerando o clipe de vídeo..."})
+            yield self.dna
+
+            # Criando a Ordem de Serviço para Deformes4D com os parâmetros de alto nível
+            video_job = VideoGenerationJob(
+                scene_id=scene.id_cena,
+                global_prompt=self.dna.texto_global_historia or "",
+                storyboard=[ato.NARRATIVA_VISUAL for ato in scene.atos],
+                keyframe_paths=[kf['caminho_pixel'] for kf in generated_keyframes_data],
+                **self.pre_prod_params,
+                **self.production_params
+            )
+
+            video_result = Deformes4D.generate_movie_clip_from_job(video_job)
+            scene_clip_path = video_result.get("final_path")
+
+            if scene_clip_path:
+                all_final_scene_clips.append(scene_clip_path)
+                video_data = video_result.get("video_data", {})
+                self.dna.storyboard_producao[scene_idx].video_gerado = VideoData(**video_data)
+                self.dna.caminho_filme_final_bruto = scene_clip_path
+                self.dna.chat_history.append({"role": "Planner5D", "content": f"Cena {scene.id_cena} filmada! O resultado será usado como ponto de partida para a próxima cena."})
+                yield self.dna
+
+        # ETAPA FINAL: MONTAGEM DO FILME
+        if not all_final_scene_clips:
+            self.dna.chat_history.append({"role": "Planner5D", "content": "Produção falhou. Nenhum clipe de vídeo foi gerado."})
+            yield self.dna
+            return
+
+        self.dna.chat_history.append({"role": "Planner5D", "content": "Todas as cenas foram filmadas. Iniciando a montagem final do filme..."})
+        yield self.dna
+        
+        final_movie_path = os.path.join(self.workspace, "filme_final.mp4")
+        final_movie_path = VideoTool.concatenate_videos(all_final_scene_clips, final_movie_path, self.workspace)
+        
+        self.dna.caminho_filme_final_bruto = final_movie_path
+        self.dna.chat_history.append({"role": "Maestro", "content": "Produção concluída! O filme final está pronto para ser assistido."})
+        yield self.dna
+
+# --- Instância Singleton ---
+planner_5d_singleton = Planner5D()

aduc_framework/engineers/prompt_engine.py

@@ -0,0 +1,110 @@
+# aduc_framework/engineers/prompt_engine.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 3.0.0 (Provider-Aware Prompt Translator)
+#
+# O PromptEngine atua como o tradutor entre a lógica de tarefa agnóstica
+# do Composer e o formato de prompt específico exigido por um LLM.
+# Esta versão é ciente do provedor (Llama, Gemini, etc.) e aplica os
+# templates de formatação apenas quando necessário (ex: para o Llama),
+# usando um prompt genérico direto para outros (ex: Gemini).
+
+import logging
+from pathlib import Path
+from typing import Dict
+
+logger = logging.getLogger(__name__)
+
+class PromptEngine:
+    """
+    O PromptEngine traduz prompts genéricos para o formato específico do
+    modelo de linguagem alvo. Ele seleciona o template correto com base
+    no provedor de LLM ativo e na presença de imagens na requisição.
+    """
+    def __init__(self):
+        """
+        Inicializa o PromptEngine em um estado "em espera". O provedor
+        e os templates são carregados posteriormente pelo Composer.
+        """
+        self.provider: str | None = None
+        self.model_map_name: str = "llama_3_2_vision" # Padrão para Llama
+        self.template_with_image: str | None = None
+        self.template_text_only: str | None = None
+        logger.info("PromptEngine inicializado (aguardando configuração do provedor pelo Composer).")
+
+    def _load_model_template(self, map_name: str, template_file: str) -> str:
+        """
+        Carrega um arquivo de template de um mapa de modelo específico.
+        """
+        map_path = Path(__file__).resolve().parent.parent / "prompts" / "model_maps" / map_name / template_file
+        if not map_path.is_file():
+            raise FileNotFoundError(f"Template de modelo '{template_file}' não encontrado no mapa '{map_name}' em: {map_path}")
+        
+        with open(map_path, 'r', encoding='utf-8') as f:
+            return f.read()
+
+    def set_provider(self, provider: str):
+        """
+        Configura o provedor de LLM ativo (ex: 'llama_multimodal', 'gemini')
+        e carrega os templates de formatação específicos, se necessário.
+        Este método é chamado pelo Composer durante sua inicialização.
+        """
+        if self.provider == provider:
+            return # Evita recarregamentos desnecessários
+            
+        self.provider = provider
+        logger.info(f"PromptEngine: Provedor de LLM definido como '{self.provider}'.")
+        
+        # Carrega os templates específicos do Llama apenas se ele for o provedor.
+        # Para o Gemini, nenhum template é necessário, então os atributos permanecem None.
+        if self.provider == 'llama_multimodal':
+            logger.info(f"Carregando templates para o mapa de modelo '{self.model_map_name}'...")
+            self.template_with_image = self._load_model_template(self.model_map_name, "image_template.txt")
+            self.template_text_only = self._load_model_template(self.model_map_name, "text_template.txt")
+        else:
+            self.template_with_image = None
+            self.template_text_only = None
+
+    def translate(self, generic_prompt_content: str, has_image: bool) -> str:
+        """
+        Envolve o conteúdo do prompt genérico com o template específico do modelo,
+        mas somente se o provedor ativo (Llama) exigir. Para provedores como o
+        Gemini, retorna o prompt genérico sem modificação.
+
+        Args:
+            generic_prompt_content (str): O conteúdo do prompt agnóstico gerado pelo Composer.
+            has_image (bool): Sinaliza se a tarefa atual inclui um contexto visual.
+
+        Returns:
+            str: O prompt final, formatado e pronto para ser enviado ao LLM.
+        """
+        if self.provider is None:
+            raise RuntimeError("PromptEngine: O provedor não foi definido. Chame set_provider() antes de usar.")
+            
+        # --- LÓGICA CONDICIONAL ---
+        # Se o provedor for Gemini, ele usa o "prompt padrão genérico" sem modificação.
+        if self.provider == 'gemini':
+            logger.debug("PROMPT ENGINE (Gemini): Retornando prompt genérico sem aplicar template.")
+            return generic_prompt_content
+            
+        # A lógica original do Llama é executada para o provedor padrão ('llama_multimodal')
+        logger.debug(f"--- PROMPT ENGINE ({self.provider}): INICIANDO TRADUÇÃO (Imagem: {has_image}) ---")
+        
+        template = self.template_with_image if has_image else self.template_text_only
+        if not template:
+             raise RuntimeError(f"PromptEngine: Template para o provedor '{self.provider}' não foi carregado corretamente.")
+        
+        try:
+            # Insere o conteúdo genérico dentro do template específico do modelo
+            final_prompt = template.format(generic_prompt_content=generic_prompt_content)
+            logger.debug(f"--- PROMPT ENGINE ({self.provider}): TRADUÇÃO CONCLUÍDA ---")
+            return final_prompt
+        except KeyError as e:
+            logger.error(f"PROMPT ENGINE: Erro de chave durante a tradução! Chave não encontrada: {e}", exc_info=True)
+            logger.error("Verifique se o template do modelo contém apenas o placeholder '{generic_prompt_content}'.")
+            raise e
+
+# --- Instância Singleton ---
+# A instância é criada vazia e será configurada dinamicamente pelo Composer.
+prompt_engine_singleton = PromptEngine()

aduc_framework/managers/LICENSE

@@ -0,0 +1,25 @@
+# Euia-AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR para geração de vídeo coerente.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+#
+# 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 (Ltx-SuperTime-60Secondos): https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/
+# Hugging Face (Novinho): https://huggingface.co/spaces/Carlexxx/Novinho/
+#
+# 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/>.

aduc_framework/managers/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

aduc_framework/managers/NOTICE.md

@@ -0,0 +1,60 @@
+# 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.
+
+---
+
+
+**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

aduc_framework/managers/README.md

@@ -0,0 +1,156 @@
+# 🛠️ managers/ - Ferramentas de IA de Terceiros para orquestração ADUC-SDR
+
+Esta pasta contém implementações adaptadas de modelos e utilitários de IA de terceiros, que servem como "especialistas" ou "ferramentas" de baixo nível para a arquitetura ADUC-SDR.
+
+**IMPORTANTE:** O conteúdo desta pasta é de autoria de seus respectivos idealizadores e desenvolvedores originais. Esta pasta **NÃO FAZ PARTE** do projeto principal ADUC-SDR em termos de sua arquitetura inovadora. Ela serve como um repositório para as **dependências diretas e modificadas** que os `Deformes enginers` (os estágios do "foguete" ADUC-SDR) invocam para realizar tarefas específicas (geração de imagem, vídeo, áudio).
+
+As modificações realizadas nos arquivos aqui presentes visam principalmente:
+1.  **Adaptação de Interfaces:** Padronizar as interfaces para que se encaixem no fluxo de orquestração do ADUC-SDR.
+2.  **Gerenciamento de Recursos:** Integrar lógicas de carregamento/descarregamento de modelos (GPU management) e configurações via arquivos YAML.
+3.  **Otimização de Fluxo:** Ajustar as pipelines para aceitar formatos de entrada mais eficientes (ex: tensores pré-codificados em vez de caminhos de mídia, pulando etapas de codificação/decodificação redundantes).
+
+---
+
+## 📄 Licenciamento
+
+O conteúdo original dos projetos listados abaixo é licenciado sob a **Licença Apache 2.0**, ou outra licença especificada pelos autores originais. Todas as modificações e o uso desses arquivos dentro da estrutura `helpers/` do projeto ADUC-SDR estão em conformidade com os termos da **Licença Apache 2.0**.
+
+As licenças originais dos projetos podem ser encontradas nas suas respectivas fontes ou nos subdiretórios `incl_licenses/` dentro de cada módulo adaptado.
+
+---
+
+## 🛠️ API dos Helpers e Guia de Uso
+
+Esta seção detalha como cada helper (agente especialista) deve ser utilizado dentro do ecossistema ADUC-SDR. Todos os agentes são instanciados como **singletons** no `hardware_manager.py` para garantir o gerenciamento centralizado de recursos de GPU.
+
+### **gemini_helpers.py (GeminiAgent)**
+
+*   **Propósito:** Atua como o "Oráculo de Síntese Adaptativo", responsável por todas as tarefas de processamento de linguagem natural, como criação de storyboards, geração de prompts, e tomada de decisões narrativas.
+*   **Singleton Instance:** `gemini_agent_singleton`
+*   **Construtor:** `GeminiAgent()`
+    *   Lê `configs/gemini_config.yaml` para obter o nome do modelo, parâmetros de inferência e caminhos de templates de prompt. A chave da API é lida da variável de ambiente `GEMINI_API_KEY`.
+*   **Métodos Públicos:**
+    *   `generate_storyboard(prompt: str, num_keyframes: int, ref_image_paths: list[str])`
+        *   **Inputs:**
+            *   `prompt`: A ideia geral do filme (string).
+            *   `num_keyframes`: O número de cenas a serem geradas (int).
+            *   `ref_image_paths`: Lista de caminhos para as imagens de referência (list[str]).
+        *   **Output:** `tuple[list[str], str]` (Uma tupla contendo a lista de strings do storyboard e um relatório textual da operação).
+    *   `select_keyframes_from_pool(storyboard: list, base_image_paths: list[str], pool_image_paths: list[str])`
+        *   **Inputs:**
+            *   `storyboard`: A lista de strings do storyboard gerado.
+            *   `base_image_paths`: Imagens de referência base (list[str]).
+            *   `pool_image_paths`: O "banco de imagens" de onde selecionar (list[str]).
+        *   **Output:** `tuple[list[str], str]` (Uma tupla contendo a lista de caminhos de imagens selecionadas e um relatório textual).
+    *   `get_anticipatory_keyframe_prompt(...)`
+        *   **Inputs:** Contexto narrativo e visual para gerar um prompt de imagem.
+        *   **Output:** `tuple[str, str]` (Uma tupla contendo o prompt gerado para o modelo de imagem e um relatório textual).
+    *   `get_initial_motion_prompt(...)`
+        *   **Inputs:** Contexto narrativo e visual para a primeira transição de vídeo.
+        *   **Output:** `tuple[str, str]` (Uma tupla contendo o prompt de movimento gerado e um relatório textual).
+    *   `get_transition_decision(...)`
+        *   **Inputs:** Contexto narrativo e visual para uma transição de vídeo intermediária.
+        *   **Output:** `tuple[dict, str]` (Uma tupla contendo um dicionário `{"transition_type": "...", "motion_prompt": "..."}` e um relatório textual).
+    *   `generate_audio_prompts(...)`
+        *   **Inputs:** Contexto narrativo global.
+        *   **Output:** `tuple[dict, str]` (Uma tupla contendo um dicionário `{"music_prompt": "...", "sfx_prompt": "..."}` e um relatório textual).
+
+### **flux_kontext_helpers.py (FluxPoolManager)**
+
+*   **Propósito:** Especialista em geração de imagens de alta qualidade (keyframes) usando a pipeline FluxKontext. Gerencia um pool de workers para otimizar o uso de múltiplas GPUs.
+*   **Singleton Instance:** `flux_kontext_singleton`
+*   **Construtor:** `FluxPoolManager(device_ids: list[str], flux_config_file: str)`
+    *   Lê `configs/flux_config.yaml`.
+*   **Método Público:**
+    *   `generate_image(prompt: str, reference_images: list[Image.Image], width: int, height: int, seed: int = 42, callback: callable = None)`
+        *   **Inputs:**
+            *   `prompt`: Prompt textual para guiar a geração (string).
+            *   `reference_images`: Lista de objetos `PIL.Image` como referência visual.
+            *   `width`, `height`: Dimensões da imagem de saída (int).
+            *   `seed`: Semente para reprodutibilidade (int).
+            *   `callback`: Função de callback opcional para monitorar o progresso.
+        *   **Output:** `PIL.Image.Image` (O objeto da imagem gerada).
+
+### **dreamo_helpers.py (DreamOAgent)**
+
+*   **Propósito:** Especialista em geração de imagens de alta qualidade (keyframes) usando a pipeline DreamO, com capacidades avançadas de edição e estilo a partir de referências.
+*   **Singleton Instance:** `dreamo_agent_singleton`
+*   **Construtor:** `DreamOAgent(device_id: str = None)`
+    *   Lê `configs/dreamo_config.yaml`.
+*   **Método Público:**
+    *   `generate_image(prompt: str, reference_images: list[Image.Image], width: int, height: int)`
+        *   **Inputs:**
+            *   `prompt`: Prompt textual para guiar a geração (string).
+            *   `reference_images`: Lista de objetos `PIL.Image` como referência visual. A lógica interna atribui a primeira imagem como `style` e as demais como `ip`.
+            *   `width`, `height`: Dimensões da imagem de saída (int).
+        *   **Output:** `PIL.Image.Image` (O objeto da imagem gerada).
+
+### **ltx_manager_helpers.py (LtxPoolManager)**
+
+*   **Propósito:** Especialista na geração de fragmentos de vídeo no espaço latente usando a pipeline LTX-Video. Gerencia um pool de workers para otimizar o uso de múltiplas GPUs.
+*   **Singleton Instance:** `ltx_manager_singleton`
+*   **Construtor:** `LtxPoolManager(device_ids: list[str], ltx_model_config_file: str, ltx_global_config_file: str)`
+    *   Lê o `ltx_global_config_file` e o `ltx_model_config_file` para configurar a pipeline.
+*   **Método Público:**
+    *   `generate_latent_fragment(**kwargs)`
+        *   **Inputs:** Dicionário de keyword arguments (`kwargs`) contendo todos os parâmetros da pipeline LTX, incluindo:
+            *   `height`, `width`: Dimensões do vídeo (int).
+            *   `video_total_frames`: Número total de frames a serem gerados (int).
+            *   `video_fps`: Frames por segundo (int).
+            *   `motion_prompt`: Prompt de movimento (string).
+            *   `conditioning_items_data`: Lista de objetos `LatentConditioningItem` contendo os tensores latentes de condição.
+            *   `guidance_scale`, `stg_scale`, `num_inference_steps`, etc.
+        *   **Output:** `tuple[torch.Tensor, tuple]` (Uma tupla contendo o tensor latente gerado e os valores de padding utilizados).
+
+### **mmaudio_helper.py (MMAudioAgent)**
+
+*   **Propósito:** Especialista em geração de áudio para um determinado fragmento de vídeo.
+*   **Singleton Instance:** `mmaudio_agent_singleton`
+*   **Construtor:** `MMAudioAgent(workspace_dir: str, device_id: str = None, mmaudio_config_file: str)`
+    *   Lê `configs/mmaudio_config.yaml`.
+*   **Método Público:**
+    *   `generate_audio_for_video(video_path: str, prompt: str, negative_prompt: str, duration_seconds: float)`
+        *   **Inputs:**
+            *   `video_path`: Caminho para o arquivo de vídeo silencioso (string).
+            *   `prompt`: Prompt textual para guiar a geração de áudio (string).
+            *   `negative_prompt`: Prompt negativo para áudio (string).
+            *   `duration_seconds`: Duração exata do vídeo (float).
+        *   **Output:** `str` (O caminho para o novo arquivo de vídeo com a faixa de áudio integrada).
+
+
+### **seedvr_helpers.py (SeedVrManager)**
+
+*   **Propósito:** Especialista em pós-produção de vídeo, aplicando super-resolução com IA (`Video Super-Resolution`) para adicionar detalhes finos, nitidez e texturas realistas a um vídeo já renderizado.
+*   **Singleton Instance:** `seedvr_manager_singleton`
+*   **Construtor:** `SeedVrManager(workspace_dir: str, device_id: str = None)`
+    *   Lê `configs/seedvr_config.yaml`.
+*   **Método Público:**
+    *   `process_video(input_video_path: str, output_video_path: str, prompt: str, model_version: str = '7B', steps: int = 100, seed: int = 666)`
+        *   **Inputs:**
+            *   `input_video_path`: Caminho para o vídeo de entrada a ser aprimorado (string).
+            *   `output_video_path`: Caminho onde o vídeo finalizado será salvo (string).
+            *   `prompt`: Um prompt de estilo geral para guiar o aprimoramento (string).
+            *   `model_version`: A versão do modelo a ser usada, '3B' ou '7B' (string).
+            *   `steps`: Número de passos de inferência para o processo de aprimoramento (int).
+            *   `seed`: Semente para reprodutibilidade (int).
+        *   **Output:** `str` (O caminho para o vídeo finalizado em alta definição).
+
+---
+
+## 🔗 Projetos Originais e Atribuições
+(A seção de atribuições e licenças permanece a mesma que definimos anteriormente)
+
+### DreamO
+*   **Repositório Original:** [https://github.com/bytedance/DreamO](https://github.com/bytedance/DreamO)
+...
+
+### LTX-Video
+*   **Repositório Original:** [https://github.com/Lightricks/LTX-Video](https://github.com/Lightricks/LTX-Video)
+...
+
+### MMAudio
+*   **Repositório Original:** [https://github.com/hkchengrex/MMAudio](https://github.com/hkchengrex/MMAudio)
+...
+
+### SeedVr
+*   **Repositório Original:** [https://github.com/ByteDance-Seed/SeedVR](https://github.com/ByteDance-Seed/SeedVR)

aduc_framework/managers/__init__.py

@@ -0,0 +1,25 @@
+# Em: aduc_framework/managers/__init__.py
+
+# Expõe os singletons dos managers de especialistas de baixo nível.
+
+from .gemini_manager import gemini_manager_singleton
+
+# ORDEM CRÍTICA: LTX Manager precisa ser inicializado primeiro, pois o VAE Manager
+# depende dele para obter a instância do modelo VAE.
+from .ltx_manager import ltx_manager_singleton
+from .vae_manager import vae_manager_singleton
+
+from .latent_enhancer_manager import latent_enhancer_specialist_singleton
+from .mmaudio_manager import mmaudio_manager_singleton
+from .seedvr_manager import seedvr_manager_singleton
+from .llama_multimodal_manager import llama_multimodal_manager_singleton
+
+__all__ = [
+    "gemini_manager_singleton",
+    "ltx_manager_singleton",
+    "vae_manager_singleton", # A ordem aqui não importa, apenas a ordem dos imports acima
+    "latent_enhancer_specialist_singleton",
+    "mmaudio_manager_singleton",
+    "seedvr_manager_singleton",
+    "llama_multimodal_manager_singleton",
+]

aduc_framework/managers/config.yaml

@@ -0,0 +1,24 @@
+# config.yaml
+# Configuração central para a aplicação Deformes4D e seus especialistas.
+
+application:
+  workspace_dir: "deformes_workspace"
+
+# Configuração para Hugging Face Spaces
+sdk: gradio
+app_file: app.py
+
+specialists:
+  flux:
+    # Define quantas GPUs o pool do Flux deve tentar alocar.
+    # Se não houver GPUs suficientes, o hardware_manager lançará um erro.
+    # Se 0, usará a CPU.
+    gpus_required: 4
+  
+  ltx:
+    # Define quantas GPUs o pool do LTX deve tentar alocar.
+    gpus_required: 4
+    
+    # Aponta para o arquivo de configuração específico do modelo LTX.
+    # Alterado para usar o modelo 0.9.8-dev.
+    config_file: "ltxv-13b-0.9.8-distilled.yaml"

aduc_framework/managers/flux_kontext_manager.py

@@ -0,0 +1,165 @@
+# flux_kontext_helpers.py (ADUC: O Especialista Pintor - com suporte a callback)
+# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+#
+# 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
+#
+#
+# PENDING PATENT NOTICE: Please see NOTICE.md.
+#
+# Version 1.0.1
+
+import torch
+from PIL import Image, ImageOps
+import gc
+from diffusers import FluxKontextPipeline
+import huggingface_hub
+import os
+import threading
+import yaml
+import logging
+
+from ..tools.hardware_manager import hardware_manager
+
+logger = logging.getLogger(__name__)
+
+class FluxWorker:
+    """Representa uma única instância do pipeline FluxKontext em um dispositivo."""
+    def __init__(self, device_id='cuda:0'):
+        self.cpu_device = torch.device('cpu')
+        self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
+        self.pipe = None
+        self._load_pipe_to_cpu()
+
+    def _load_pipe_to_cpu(self):
+        if self.pipe is None:
+            logger.info(f"FLUX Worker ({self.device}): Carregando modelo para a CPU...")
+            self.pipe = FluxKontextPipeline.from_pretrained(
+                "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
+            ).to(self.cpu_device)
+            logger.info(f"FLUX Worker ({self.device}): Modelo pronto na CPU.")
+
+    def to_gpu(self):
+        if self.device.type == 'cpu': return
+        logger.info(f"FLUX Worker: Movendo modelo para a GPU {self.device}...")
+        self.pipe.to(self.device)
+
+    def to_cpu(self):
+        if self.device.type == 'cpu': return
+        logger.info(f"FLUX Worker: Descarregando modelo da GPU {self.device}...")
+        self.pipe.to(self.cpu_device)
+        gc.collect()
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
+
+    def _create_composite_reference(self, images: list[Image.Image], target_width: int, target_height: int) -> Image.Image:
+        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:
+            if valid_images[0].size != (target_width, target_height):
+                return ImageOps.fit(valid_images[0], (target_width, target_height), Image.Resampling.LANCZOS)
+            return valid_images[0]
+
+        base_height = valid_images[0].height
+        resized_for_concat = []
+        for img in valid_images:
+            if img.height != base_height:
+                aspect_ratio = img.width / img.height
+                new_width = int(base_height * aspect_ratio)
+                resized_for_concat.append(img.resize((new_width, base_height), Image.Resampling.LANCZOS))
+            else:
+                resized_for_concat.append(img)
+        
+        total_width = sum(img.width for img in resized_for_concat)
+        concatenated = Image.new('RGB', (total_width, base_height))
+        x_offset = 0
+        for img in resized_for_concat:
+            concatenated.paste(img, (x_offset, 0))
+            x_offset += img.width
+            
+        #final_reference = ImageOps.fit(concatenated, (target_width, target_height), Image.Resampling.LANCZOS)
+        return concatenated
+
+    @torch.inference_mode()
+    def generate_image_internal(self, reference_images: list[Image.Image], prompt: str, target_width: int, target_height: int, seed: int, callback: callable = None):
+        composite_reference = self._create_composite_reference(reference_images, target_width, target_height)
+        
+        num_steps = 12 # Valor fixo otimizado
+
+        logger.info(f"\n===== [CHAMADA AO PIPELINE FLUX em {self.device}] =====\n"
+                    f"  - Prompt: '{prompt}'\n"
+                    f"  - Resolução: {target_width}x{target_height}, Seed: {seed}, Passos: {num_steps}\n"
+                    f"  - Nº de Imagens na Composição: {len(reference_images)}\n"
+                    f"==========================================")
+        
+        generated_image = self.pipe(
+            image=composite_reference, 
+            prompt=prompt, 
+            guidance_scale=2.5, 
+            width=target_width,
+            height=target_height,
+            num_inference_steps=num_steps,
+            generator=torch.Generator(device="cpu").manual_seed(seed),
+            callback_on_step_end=callback,
+            callback_on_step_end_tensor_inputs=["latents"] if callback else None
+        ).images[0]
+        
+        return generated_image
+
+class FluxPoolManager:
+    def __init__(self, device_ids):
+        logger.info(f"FLUX POOL MANAGER: Criando workers para os dispositivos: {device_ids}")
+        self.workers = [FluxWorker(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_thread(self, worker):
+        logger.info(f"FLUX CLEANUP THREAD: Iniciando limpeza de {worker.device} em background...")
+        worker.to_cpu()
+
+    def generate_image(self, reference_images, prompt, width, height, seed=42, callback=None):
+        worker_to_use = None
+        try:
+            with self.lock:
+                if self.last_cleanup_thread and self.last_cleanup_thread.is_alive():
+                    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_thread, 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)
+            
+            logger.info(f"FLUX POOL MANAGER: Gerando imagem em {worker_to_use.device}...")
+            return worker_to_use.generate_image_internal(
+                reference_images=reference_images,
+                prompt=prompt,
+                target_width=width,
+                target_height=height,
+                seed=seed,
+                callback=callback
+            )
+        except Exception as e:
+            logger.error(f"FLUX POOL MANAGER: Erro durante a geração: {e}", exc_info=True)
+            raise e
+        finally:
+            pass
+
+# --- Instanciação Singleton Dinâmica ---
+logger.info("Lendo config.yaml para inicializar o FluxKontext Pool Manager...")
+with open("config.yaml", 'r') as f: config = yaml.safe_load(f)
+hf_token = os.getenv('HF_TOKEN'); 
+if hf_token: huggingface_hub.login(token=hf_token)
+flux_gpus_required = config['specialists']['flux']['gpus_required']
+flux_device_ids = hardware_manager.allocate_gpus('Flux', flux_gpus_required)
+flux_kontext_singleton = FluxPoolManager(device_ids=flux_device_ids)
+logger.info("Especialista de Imagem (Flux) pronto.")

aduc_framework/managers/gemini_manager.py

@@ -0,0 +1,115 @@
+# aduc_framework/managers/gemini_manager.py
+#
+# Versão 3.0.0 (Com Gerenciamento de Memória Flexível)
+#
+# Esta versão evolui o GeminiManager para suportar conversas com estado
+# (com memória), mantendo a capacidade de operar sem estado.
+# Introduz um gatilho `restart_session=True` para controle explícito
+# sobre o ciclo de vida da memória, evitando contaminação de contexto.
+
+import os
+import logging
+from PIL import Image
+import google.generativeai as genai
+from typing import List, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+class GeminiManager:
+    """
+    Gerencia interações com a API do Google Gemini, com suporte opcional
+    para sessões de chat com memória e um gatilho de reinicialização.
+    """
+    def __init__(self):
+        """
+        Inicializa o manager. Carrega a chave da API e configura o modelo.
+        """
+        self.api_key = os.environ.get("GEMINI_API_KEY")
+        self.model = None
+        self.chat_session = None # Armazena a sessão de chat com memória ativa
+
+        if self.api_key:
+            try:
+                genai.configure(api_key=self.api_key)
+                # Usando um modelo recente e capaz
+                self.model = genai.GenerativeModel('gemini-2.0-flash') 
+                logger.info("GeminiManager (V3 com Memória) inicializado com sucesso.")
+            except Exception as e:
+                logger.error(f"Falha ao configurar a API do Gemini. Verifique a chave e as permissões. Erro: {e}")
+                self.model = None
+        else:
+            logger.warning("Variável de ambiente GEMINI_API_KEY não encontrada. GeminiManager está desabilitado.")
+            
+    def _check_model(self):
+        """Verificação interna para garantir que o modelo está pronto para uso."""
+        if not self.model:
+            raise RuntimeError("O modelo Gemini não está inicializado. Verifique a chave da API (GEMINI_API_KEY).")
+
+    def process_turn(
+        self, 
+        prompt_text: str, 
+        image_list: Optional[List[Image.Image]] = None, 
+        use_memory: bool = False,
+        restart_session: bool = False
+    ) -> str:
+        """
+        Ponto de entrada principal. Processa uma requisição textual ou multimodal,
+        com gerenciamento de memória opcional.
+
+        Args:
+            prompt_text (str): O prompt textual a ser enviado.
+            image_list (Optional[List[Image.Image]]): Lista de imagens a serem incluídas na requisição.
+            use_memory (bool): Se True, utiliza ou cria uma sessão de chat com memória (stateful).
+                               Se False, faz uma chamada única (stateless).
+            restart_session (bool): Se True, força o descarte da sessão de memória atual
+                                    e o início de uma nova na próxima chamada com `use_memory=True`.
+        """
+        self._check_model()
+        
+        # --- Lógica do Gatilho de Reinicialização ---
+        if restart_session and self.chat_session is not None:
+            logger.info("Gatilho de reinicialização acionado. Descartando sessão de chat anterior.")
+            self.chat_session = None
+            # Se o objetivo era apenas reiniciar, podemos retornar sem fazer uma chamada.
+            if not prompt_text:
+                return ""
+        
+        # Constrói o conteúdo a ser enviado
+        prompt_parts = []
+        if prompt_text:
+            prompt_parts.append(prompt_text)
+        if image_list:
+            prompt_parts.extend(image_list)
+
+        # Se não houver nada a ser enviado, retorna uma string vazia.
+        if not prompt_parts:
+            return ""
+
+        try:
+            # --- Lógica de Gerenciamento de Memória ---
+            if use_memory:
+                if self.chat_session is None:
+                    logger.info("Iniciando nova sessão de chat com memória (stateful).")
+                    self.chat_session = self.model.start_chat(history=[])
+                
+                logger.info("Enviando mensagem para a sessão de chat com memória...")
+                response = self.chat_session.send_message(prompt_parts)
+            else:
+                # Modo stateless (sem memória)
+                logger.info("Enviando requisição sem memória (stateless)...")
+                response = self.model.generate_content(prompt_parts)
+            
+            # Extrai e retorna o texto da resposta
+            response_text = response.text
+            logger.debug(f"Gemini respondeu com texto bruto: {response_text[:500]}...")
+            return response_text
+
+        except Exception as e:
+            logger.error(f"GEMINI_MANAGER: Falha na chamada da API: {e}", exc_info=True)
+            # Em caso de erro na comunicação, é seguro zerar a sessão para evitar um estado corrompido.
+            self.chat_session = None
+            raise RuntimeError(f"Erro na comunicação com a API do Gemini: {e}")
+
+# --- Instância Singleton ---
+# Esta instância única será importada por outros componentes, como o Neura_Link.
+gemini_manager_singleton = GeminiManager()

aduc_framework/managers/latent_enhancer_manager.py

@@ -0,0 +1,109 @@
+# latent_enhancer_specialist.py
+# AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+#
+# 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
+#
+#
+# PENDING PATENT NOTICE: Please see NOTICE.md.
+#
+# Version 1.0.1
+
+import torch
+import logging
+import time
+from diffusers import LTXLatentUpsamplePipeline
+from ..managers.ltx_manager import ltx_manager_singleton
+
+logger = logging.getLogger(__name__)
+
+class LatentEnhancerSpecialist:
+    """
+    Especialista responsável por melhorar a qualidade de tensores latentes,
+    incluindo upscaling espacial e refinamento por denoise.
+    """
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.pipe_upsample = None
+        self.base_vae = None # VAE para o upscaler
+
+    def _lazy_init_upscaler(self):
+        """Inicializa a pipeline de upscaling apenas quando for usada."""
+        if self.pipe_upsample is not None:
+            return
+        try:
+            from diffusers.models.autoencoders import AutoencoderKLLTXVideo
+            self.base_vae = AutoencoderKLLTXVideo.from_pretrained(
+                "linoyts/LTX-Video-spatial-upscaler-0.9.8",
+                subfolder="vae",
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            ).to(self.device)
+
+            self.pipe_upsample = LTXLatentUpsamplePipeline.from_pretrained(
+                "linoyts/LTX-Video-spatial-upscaler-0.9.8",
+                vae=self.base_vae,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            ).to(self.device)
+            logger.info("[Enhancer] Pipeline de Upscale carregada com sucesso.")
+        except Exception as e:
+            logger.error(f"[Enhancer] Falha ao carregar pipeline de Upscale: {e}")
+            self.pipe_upsample = None
+
+    @torch.no_grad()
+    def upscale(self, latents: torch.Tensor) -> torch.Tensor:
+        """Aplica o upscaling 2x nos tensores latentes fornecidos."""
+        self._lazy_init_upscaler()
+        if self.pipe_upsample is None:
+            logger.warning("[Enhancer] Pipeline de Upscale indisponível. Retornando latentes originais.")
+            return latents
+        try:
+            logger.info(f"[Enhancer] Recebido shape {latents.shape} para Upscale.")
+            result = self.pipe_upsample(latents=latents, output_type="latent")
+            output_tensor = result.frames
+            logger.info(f"[Enhancer] Upscale concluído. Novo shape: {output_tensor.shape}")
+            return output_tensor
+        except Exception as e:
+            logger.error(f"[Enhancer] Erro durante upscale: {e}", exc_info=True)
+            return latents
+
+    @torch.no_grad()
+    def refine(self, latents: torch.Tensor, fps: int = 24, **kwargs) -> torch.Tensor:
+        """
+        Invoca o LTX Pool Manager para refinar um tensor latente existente.
+        """
+        logger.info(f"[Enhancer] Refinando tensor latente com shape {latents.shape}.")
+        
+        main_pipeline_vae = ltx_manager_singleton.workers[0].pipeline.vae
+        video_scale_factor = getattr(main_pipeline_vae.config, 'temporal_scale_factor', 8)
+        
+        _, _, num_latent_frames, _, _ = latents.shape
+        
+        # --- [CORREÇÃO FINAL E CRÍTICA] ---
+        # A pipeline de refinamento (vid2vid) espera o número de frames de pixels que CORRESPONDE
+        # ao latente existente, SEM a lógica do +1 que ela aplicará internamente.
+        pixel_frames = (num_latent_frames - 1) * video_scale_factor
+
+        final_ltx_params = {
+            "video_total_frames": pixel_frames,
+            "video_fps": fps,
+            "current_fragment_index": int(time.time()),
+            **kwargs
+        }
+        
+        refined_latents_tensor, _ = ltx_manager_singleton.refine_latents(latents, **final_ltx_params)
+        
+        if refined_latents_tensor is None:
+            logger.warning("[Enhancer] O refinamento falhou. Retornando tensor original não refinado.")
+            return latents
+        
+        logger.info(f"[Enhancer] Retornando tensor latente refinado com shape: {refined_latents_tensor.shape}")
+        return refined_latents_tensor
+
+# --- Singleton Global ---
+latent_enhancer_specialist_singleton = LatentEnhancerSpecialist()

aduc_framework/managers/llama_multimodal_manager.py

@@ -0,0 +1,153 @@
+# aduc_framework/managers/llama_multimodal_manager.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 1.3.0 (Comprehensive Logging & Stable Attention)
+#
+# Manager especialista em conversas multimodais. Esta versão adiciona
+# logging detalhado em todos os pontos críticos para garantir que não haja
+# falhas silenciosas e para fornecer visibilidade total do fluxo de dados.
+# Opera de forma stateless, recebendo prompts completos a cada chamada.
+
+import yaml
+import os
+import logging
+import torch
+from PIL import Image
+from typing import List, Dict, Any, Optional
+import json
+
+from transformers import MllamaForConditionalGeneration, MllamaProcessor
+from huggingface_hub import HfFolder
+
+from ..tools.hardware_manager import hardware_manager
+
+# Logger específico para este manager
+logger = logging.getLogger(__name__)
+
+class LlamaMultiModalManager:
+    """
+    Gerencia uma única instância do Llama 3.2 Vision, com logging robusto
+    para rastrear todo o ciclo de vida de uma requisição. Opera de forma stateless.
+    """
+    def __init__(self, config: dict):
+        logger.debug("LLAMA_MANAGER: Iniciando __init__.")
+        self.hf_token = os.getenv("HF_TOKEN") or HfFolder.get_token()
+        if not self.hf_token:
+            raise ValueError("Token da Hugging Face não encontrado. Faça login via `huggingface-cli login` ou defina a variável de ambiente HF_TOKEN.")
+
+        self.model_id = config['model_id']
+        self.max_new_tokens = config.get('max_new_tokens', 8096)
+        self.temperature = config.get('temperature', 0.9)
+        self.top_p = config.get('top_p', 0.9)
+        self.max_image_size = (480, 480)
+
+        logger.info(f"LLAMA_MANAGER: Carregando processador do modelo: {self.model_id}...")
+        self.processor = MllamaProcessor.from_pretrained(self.model_id, token=self.hf_token)
+        logger.info("LLAMA_MANAGER: Processador carregado.")
+
+        logger.info(f"LLAMA_MANAGER: Carregando modelo base: {self.model_id}...")
+        # A implementação de atenção padrão é usada para máxima compatibilidade.
+        self.model = MllamaForConditionalGeneration.from_pretrained(
+            self.model_id,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+            token=self.hf_token
+        )
+        logger.info("LLAMA_MANAGER: Modelo carregado e mapeado para o dispositivo.")
+        logger.debug("LLAMA_MANAGER: __init__ concluído.")
+
+    def _preprocess_image(self, image: Image.Image) -> Image.Image:
+        """Garante que a imagem esteja no formato RGB e dentro do tamanho máximo."""
+        logger.debug(f"Pré-processando imagem. Tamanho original: {image.size}, Modo: {image.mode}")
+        img = image.convert("RGB")
+        if img.width > self.max_image_size[0] or img.height > self.max_image_size[1]:
+            original_size = img.size
+            img.thumbnail(self.max_image_size, Image.Resampling.LANCZOS)
+            logger.debug(f"Imagem redimensionada de {original_size} para {img.size}.")
+        return img
+
+    @torch.inference_mode()
+    def process_turn(self, prompt_text: str, image_list: Optional[List[Image.Image]] = None) -> str:
+        """
+        Ponto de entrada para processar uma requisição. Lida com a orquestração
+        interna e o tratamento de exceções.
+        """
+        logger.info(f"LLAMA_MANAGER: Recebido novo turno. Comprimento do prompt: {len(prompt_text)}, Imagens: {len(image_list) if image_list else 0}.")
+        image_list = image_list or []
+        
+        try:
+            # Prepara a imagem (se houver)
+            processed_image = self._preprocess_image(image_list[0]) if image_list else None
+            
+            # Gera a resposta
+            assistant_response_text = self._generate_response(prompt_text, processed_image)
+            
+            logger.info("LLAMA_MANAGER: Turno processado com sucesso.")
+            return assistant_response_text
+
+        except Exception as e:
+            logger.error(f"LLAMA_MANAGER: ERRO BRUTO DURANTE O PROCESSAMENTO DO TURNO: {e}", exc_info=True)
+            raise e
+
+    def _generate_response(self, prompt_str: str, image: Optional[Image.Image] = None) -> str:
+        """
+        Função de inferência interna: processa, gera e decodifica.
+        """
+        # 1. Processamento da Entrada
+        logger.debug("---> LLAMA_MANAGER: Etapa de Processamento da Entrada Iniciada.")
+        logger.debug(f"Texto do prompt recebido (primeiros 500 chars):\n---\n{prompt_str[:500]}\n---")
+        
+        inputs = self.processor(
+            text=prompt_str,
+            images=[image] if image else None,
+            return_tensors="pt"
+        ).to(self.model.device)
+        logger.debug(f"Entrada processada e movida para o dispositivo: {self.model.device}. Shape dos input_ids: {inputs['input_ids'].shape}")
+
+        # 2. Geração do Modelo
+        logger.debug("---> LLAMA_MANAGER: Etapa de Geração do Modelo Iniciada.")
+        generate_ids = self.model.generate(
+            **inputs,
+            max_new_tokens=self.max_new_tokens,
+            do_sample=True,
+            temperature=self.temperature,
+            top_p=self.top_p,
+        )
+        logger.debug(f"Geração concluída. Shape dos IDs de saída: {generate_ids.shape}")
+
+        # 3. Decodificação da Saída
+        logger.debug("---> LLAMA_MANAGER: Etapa de Decodificação da Saída Iniciada.")
+        input_ids_len = inputs['input_ids'].shape[1]
+        output_ids = generate_ids[:, input_ids_len:]
+        
+        response_text_raw = self.processor.batch_decode(
+            output_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )[0]
+        
+        logger.debug(f"<--- LLAMA_MANAGER: Resposta bruta decodificada (antes da limpeza):\n---\n{response_text_raw}\n---")
+        
+        return response_text_raw.strip()
+
+
+# --- Placeholder e Instanciação Singleton ---
+class LlamaMultiModalPlaceholder:
+    def __init__(self, reason: str = "Motivo desconhecido"):
+        logger.error(f"LlamaMultiModalManager não inicializado. Razão: {reason}. Placeholder em uso.")
+        self.reason = reason
+    def process_turn(self, *args, **kwargs):
+        return json.dumps({"error": f"Especialista Llama MultiModal indisponível. Razão: {self.reason}"})
+
+try:
+    with open("config.yaml", 'r') as f:
+        config = yaml.safe_load(f)
+    llama_config = config['specialists'].get('llama_multimodal')
+    if llama_config and llama_config.get('gpus_required', 0) > 0:
+        hardware_manager.allocate_gpus('LlamaMultiModal', llama_config['gpus_required'])
+        llama_multimodal_manager_singleton = LlamaMultiModalManager(config=llama_config)
+        logger.info("Especialista Llama MultiModal (Stateless) pronto.")
+    else:
+        llama_multimodal_manager_singleton = LlamaMultiModalPlaceholder("Não habilitado ou sem gpus_required na config.yaml")
+except Exception as e:
+    logger.critical(f"Falha CRÍTICA ao inicializar o LlamaMultiModalManager: {e}", exc_info=True)
+    llama_multimodal_manager_singleton = LlamaMultiModalPlaceholder(reason=str(e))

aduc_framework/managers/ltx_manager.py

@@ -0,0 +1,360 @@
+# aduc_framework/managers/ltx_manager.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 2.5.0 (Suporte a múltiplos LoRAs e inicialização robusta)
+#
+# Este manager é responsável por controlar a pipeline LTX-Video. Ele gerencia
+# um pool de workers para otimizar o uso de múltiplas GPUs, lida com a inicialização
+# e o setup de dependências complexas (clonando o repo LTX de forma segura), e expõe
+# uma interface de alto nível para a geração de vídeo, agora com suporte a uma lista
+# de LoRAs para composição avançada de estilos.
+
+import torch
+import gc
+import os
+import sys
+import yaml
+import logging
+import huggingface_hub
+import time
+import threading
+import subprocess
+import shutil
+from pathlib import Path
+from typing import Optional, List, Tuple, Union
+
+# --- Imports Relativos Corrigidos ---
+from ..types import LatentConditioningItem
+from ..tools.optimization import optimize_ltx_worker, can_optimize_fp8
+from ..tools.hardware_manager import hardware_manager
+
+logger = logging.getLogger(__name__)
+
+# --- Gerenciamento de Dependências e Placeholders ---
+DEPS_DIR = Path("./deps")
+LTX_VIDEO_REPO_DIR = DEPS_DIR / "LTX-Video"
+LTX_VIDEO_REPO_URL = "https://github.com/Lightricks/LTX-Video.git"
+
+# Placeholders para módulos importados tardiamente (lazy-loaded)
+create_ltx_video_pipeline = None
+calculate_padding = None
+LTXVideoPipeline = None
+ConditioningItem = None
+LTXMultiScalePipeline = None
+vae_encode = None
+latent_to_pixel_coords = None
+randn_tensor = None
+
+class LtxPoolManager:
+    """
+    Gerencia um pool de LtxWorkers e expõe a pipeline de aprimoramento de prompt.
+    """
+    def __init__(self, device_ids: List[str], ltx_config_file_name: str):
+        logger.info(f"LTX POOL MANAGER: Criando workers para os dispositivos: {device_ids}")
+        self._ltx_modules_loaded = False
+        self._setup_dependencies()
+        self._lazy_load_ltx_modules()
+
+        self.ltx_config_file = LTX_VIDEO_REPO_DIR / "configs" / ltx_config_file_name
+
+        self.workers = [LtxWorker(dev_id, self.ltx_config_file) for dev_id in device_ids]
+        self.current_worker_index = 0
+        self.lock = threading.Lock()
+
+        self.prompt_enhancement_pipeline = self.workers[0].pipeline if self.workers else None
+        if self.prompt_enhancement_pipeline:
+            logger.info("LTX POOL MANAGER: Pipeline de aprimoramento de prompt exposta para outros especialistas.")
+
+        self._apply_ltx_pipeline_patches()
+
+        if all(w.device.type == 'cuda' for w in self.workers):
+            logger.info("LTX POOL MANAGER: MODO HOT START ATIVADO. Pré-aquecendo todas as GPUs...")
+            for worker in self.workers:
+                worker.to_gpu()
+            logger.info("LTX POOL MANAGER: Todas as GPUs estão prontas.")
+        else:
+            logger.info("LTX POOL MANAGER: Operando em modo CPU ou misto. Pré-aquecimento de GPU pulado.")
+
+
+    def _setup_dependencies(self):
+        """
+        Verifica a integridade do repositório LTX-Video e o clona usando um token de
+        autenticação (se disponível), adicionando-o ao sys.path.
+        """
+        check_file = LTX_VIDEO_REPO_DIR / "README.md"
+        
+        if not check_file.exists():
+            logger.warning(f"Repositório LTX-Video parece estar incompleto ou ausente. Tentando um clone limpo...")
+            
+            if LTX_VIDEO_REPO_DIR.exists():
+                try:
+                    shutil.rmtree(LTX_VIDEO_REPO_DIR)
+                    logger.info(f"Diretório corrompido '{LTX_VIDEO_REPO_DIR}' removido.")
+                except OSError as e:
+                    logger.error(f"Não foi possível remover o diretório corrompido: {e}")
+                    raise RuntimeError("Falha ao limpar dependência corrompida.")
+
+            # --- INÍCIO DA LÓGICA DE AUTENTICAÇÃO ---
+            # Procura pelo token no ambiente (configurado via 'Secrets' no HF Spaces)
+            auth_token = os.getenv("HF_TOKEN")
+            repo_url = LTX_VIDEO_REPO_URL # URL padrão sem autenticação
+
+            if auth_token:
+                logger.info("Token de autenticação (HF_TOKEN) encontrado. Usando URL autenticada para o clone.")
+                # Monta a URL no formato https://<token>@github.com/...
+                repo_url = LTX_VIDEO_REPO_URL.replace("https://", f"https://{auth_token}@")
+            else:
+                logger.warning("Nenhum token de autenticação (HF_TOKEN) encontrado. O clone pode falhar se o repositório exigir login para LFS.")
+            # --- FIM DA LÓGICA DE AUTENTICAÇÃO ---
+
+            logger.info(f"Clonando repositório LTX-Video...")
+            try:
+                DEPS_DIR.mkdir(exist_ok=True)
+                # Usa a `repo_url` que pode ou não conter o token
+                subprocess.run(
+                    ["git", "clone", "--depth", "1", repo_url, str(LTX_VIDEO_REPO_DIR), "--quiet"],
+                    check=True, capture_output=True, text=True
+                )
+                logger.info("Repositório LTX-Video clonado com sucesso.")
+            except subprocess.CalledProcessError as e:
+                logger.error(f"Falha CRÍTICA ao clonar o repositório LTX-Video. Git stderr: {e.stderr}")
+                raise RuntimeError(f"Não foi possível clonar a dependência LTX-Video. Causa provável: {e.stderr}")
+        else:
+            logger.info("Repositório LTX-Video local encontrado e parece completo.")
+
+        resolved_path = str(LTX_VIDEO_REPO_DIR.resolve())
+        if resolved_path not in sys.path:
+            sys.path.insert(0, resolved_path)
+            logger.info(f"Adicionado '{resolved_path}' ao sys.path.")
+
+    
+    def _lazy_load_ltx_modules(self):
+        """Importa dinamicamente os módulos do LTX-Video após garantir que o repositório existe."""
+        if self._ltx_modules_loaded:
+            return
+
+        global create_ltx_video_pipeline, calculate_padding, LTXVideoPipeline, ConditioningItem, LTXMultiScalePipeline
+        global vae_encode, latent_to_pixel_coords, randn_tensor
+        
+        from .ltx_pipeline_utils import create_ltx_video_pipeline, calculate_padding
+        from ltx_video.pipelines.pipeline_ltx_video import LTXVideoPipeline, ConditioningItem, LTXMultiScalePipeline
+        from ltx_video.models.autoencoders.vae_encode import vae_encode, latent_to_pixel_coords
+        from diffusers.utils.torch_utils import randn_tensor
+        
+        self._ltx_modules_loaded = True
+        logger.info("Módulos do LTX-Video foram carregados dinamicamente.")
+
+    def _apply_ltx_pipeline_patches(self):
+        """Aplica patches em tempo de execução na pipeline LTX para compatibilidade com ADUC-SDR."""
+        logger.info("LTX POOL MANAGER: Aplicando patches ADUC-SDR na pipeline LTX...")
+        for worker in self.workers:
+            worker.pipeline.prepare_conditioning = _aduc_prepare_conditioning_patch.__get__(worker.pipeline, LTXVideoPipeline)
+        logger.info("LTX POOL MANAGER: Todas as instâncias da pipeline foram corrigidas com sucesso.")
+
+    def _get_next_worker(self) -> 'LtxWorker':
+        with self.lock:
+            worker = self.workers[self.current_worker_index]
+            self.current_worker_index = (self.current_worker_index + 1) % len(self.workers)
+            return worker
+    
+    def _prepare_pipeline_params(self, worker: 'LtxWorker', **kwargs) -> dict:
+        pipeline_params = {
+            "height": kwargs['height'], "width": kwargs['width'], "num_frames": kwargs['video_total_frames'],
+            "frame_rate": kwargs.get('video_fps', 24),
+            "generator": torch.Generator(device=worker.device).manual_seed(int(time.time()) + kwargs.get('current_fragment_index', 0)),
+            "is_video": True, "vae_per_channel_normalize": True,
+            "prompt": kwargs.get('motion_prompt', ""), "negative_prompt": kwargs.get('negative_prompt', "blurry, distorted, static, bad quality"),
+            "guidance_scale": kwargs.get('guidance_scale', 1.0), "stg_scale": kwargs.get('stg_scale', 0.0),
+            "rescaling_scale": kwargs.get('rescaling_scale', 0.15), "num_inference_steps": kwargs.get('num_inference_steps', 20),
+            "output_type": "latent"
+        }
+        if 'latents' in kwargs:
+            pipeline_params["latents"] = kwargs['latents'].to(worker.device, dtype=worker.pipeline.transformer.dtype)
+        if 'strength' in kwargs:
+            pipeline_params["strength"] = kwargs['strength']
+        
+        if 'conditioning_items_data' in kwargs:
+            final_conditioning_items = []
+            for item in kwargs['conditioning_items_data']:
+                item.latent_tensor = item.latent_tensor.to(worker.device)
+                final_conditioning_items.append(item)
+            pipeline_params["conditioning_items"] = final_conditioning_items
+
+        if worker.is_distilled:
+            fixed_timesteps = worker.config.get("first_pass", {}).get("timesteps")
+            if fixed_timesteps:
+                pipeline_params["timesteps"] = fixed_timesteps
+                pipeline_params["num_inference_steps"] = len(fixed_timesteps)
+        
+        callback = kwargs.get('callback')
+        if callback:
+            pipeline_params["callback_on_step_end"] = callback
+            pipeline_params["callback_on_step_end_tensor_inputs"] = ["latents"]
+        
+        return pipeline_params
+
+    def generate_latent_fragment(self, **kwargs) -> Tuple[torch.Tensor, tuple]:
+        worker_to_use = self._get_next_worker()
+        try:
+            height, width = kwargs['height'], kwargs['width']
+            padded_h, padded_w = ((height - 1) // 32 + 1) * 32, ((width - 1) // 32 + 1) * 32
+            padding_vals = calculate_padding(height, width, padded_h, padded_w)
+            kwargs['height'], kwargs['width'] = padded_h, padded_w
+            
+            pipeline_params = self._prepare_pipeline_params(worker_to_use, **kwargs)
+            
+            logger.info(f"Iniciando GERAÇÃO em {worker_to_use.device} com shape {padded_w}x{padded_h}")
+            
+            if isinstance(worker_to_use.pipeline, LTXMultiScalePipeline):
+                result = worker_to_use.pipeline.video_pipeline(**pipeline_params).images
+            else:
+                result = worker_to_use.generate_video_fragment_internal(**pipeline_params)
+            return result, padding_vals
+        except Exception as e:
+            logger.error(f"LTX POOL MANAGER: Erro durante a geração em {worker_to_use.device}: {e}", exc_info=True)
+            raise e
+        finally:
+            if worker_to_use and worker_to_use.device.type == 'cuda':
+                with torch.cuda.device(worker_to_use.device):
+                    gc.collect()
+                    torch.cuda.empty_cache()
+
+    def refine_latents(self, latents_to_refine: torch.Tensor, **kwargs) -> Tuple[torch.Tensor, tuple]:
+        pass
+
+class LtxWorker:
+    """Representa uma única instância da pipeline LTX-Video em um dispositivo específico."""
+    def __init__(self, device_id, ltx_config_file):
+        self.cpu_device = torch.device('cpu')
+        self.device = torch.device(device_id if torch.cuda.is_available() else 'cpu')
+        logger.info(f"LTX Worker ({self.device}): Inicializando com config '{ltx_config_file}'...")
+        
+        with open(ltx_config_file, "r") as file:
+            self.config = yaml.safe_load(file)
+
+        with open("config.yaml", 'r') as f:
+            global_config = yaml.safe_load(f)
+        lora_config = global_config.get('specialists', {}).get('ltx', {}).get('lora', {})
+        
+        self.is_distilled = "distilled" in self.config.get("checkpoint_path", "")
+        models_dir = LTX_VIDEO_REPO_DIR / "models_downloaded"
+        
+        logger.info(f"LTX Worker ({self.device}): Preparando para carregar modelo...")
+        model_filename = self.config["checkpoint_path"]
+        model_path = huggingface_hub.hf_hub_download(
+            repo_id="Lightricks/LTX-Video", filename=model_filename,
+            local_dir=str(models_dir), local_dir_use_symlinks=False
+        )
+        
+        self.pipeline = create_ltx_video_pipeline(
+            ckpt_path=model_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'
+        )
+
+        if lora_config and isinstance(lora_config, list):
+            logger.info(f"LTX Worker ({self.device}): Encontrados {len(lora_config)} LoRAs para carregar.")
+            
+            for lora_item in lora_config:
+                lora_model_id = lora_item.get("model_id")
+                lora_weight = lora_item.get("weight", 0.7)
+
+                if not lora_model_id:
+                    logger.warning(f"LTX Worker ({self.device}): Item de LoRA na lista sem 'model_id'. Pulando.")
+                    continue
+
+                logger.info(f"LTX Worker ({self.device}): Carregando e aplicando LoRA '{lora_model_id}' com peso {lora_weight}...")
+                try:
+                    self.pipeline.load_lora_weights(lora_model_id)
+                    self.pipeline.fuse_lora(lora_scale=lora_weight)
+                    logger.info(f"LTX Worker ({self.device}): LoRA '{lora_model_id}' fundido ao modelo com sucesso.")
+                except Exception as e:
+                    logger.error(f"LTX Worker ({self.device}): Falha ao carregar ou fundir o LoRA '{lora_model_id}'. Erro: {e}", exc_info=True)
+        
+        logger.info(f"LTX Worker ({self.device}): Modelo pronto na CPU. É um modelo distilled? {self.is_distilled}")
+    
+    def to_gpu(self):
+        if self.device.type == 'cpu': return
+        logger.info(f"LTX Worker: Movendo pipeline para a GPU {self.device}...")
+        self.pipeline.to(self.device)
+        if self.device.type == 'cuda' and can_optimize_fp8():
+            logger.info(f"LTX Worker ({self.device}): GPU com suporte a FP8 detectada. Otimizando...")
+            optimize_ltx_worker(self)
+            logger.info(f"LTX Worker ({self.device}): Otimização completa.")
+    
+    def to_cpu(self):
+        if self.device.type == 'cpu': return
+        logger.info(f"LTX Worker: Descarregando pipeline da GPU {self.device}...")
+        self.pipeline.to('cpu')
+        gc.collect()
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
+
+    def generate_video_fragment_internal(self, **kwargs):
+        return self.pipeline(**kwargs).images
+
+def _aduc_prepare_conditioning_patch(
+    self: "LTXVideoPipeline",
+    conditioning_items: Optional[List[Union["ConditioningItem", "LatentConditioningItem"]]],
+    init_latents: torch.Tensor,
+    num_frames: int,
+    height: int,
+    width: int,
+    vae_per_channel_normalize: bool = False,
+    generator=None,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, int]:
+    if not conditioning_items:
+        init_latents, init_latent_coords = self.patchifier.patchify(latents=init_latents)
+        init_pixel_coords = latent_to_pixel_coords(init_latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
+        return init_latents, init_pixel_coords, None, 0
+    
+    init_conditioning_mask = torch.zeros_like(init_latents[:, 0, ...], dtype=torch.float32, device=init_latents.device)
+    extra_conditioning_latents, extra_conditioning_pixel_coords, extra_conditioning_mask = [], [], []
+    extra_conditioning_num_latents = 0
+    
+    for item in conditioning_items:
+        if not isinstance(item, LatentConditioningItem):
+            logger.warning("Patch ADUC: Item de condicionamento não é um LatentConditioningItem e será ignorado.")
+            continue
+        
+        media_item_latents = item.latent_tensor.to(dtype=init_latents.dtype, device=init_latents.device)
+        media_frame_number, strength = item.media_frame_number, item.conditioning_strength
+        
+        if media_frame_number == 0:
+            f_l, h_l, w_l = media_item_latents.shape[-3:]
+            init_latents[..., :f_l, :h_l, :w_l] = torch.lerp(init_latents[..., :f_l, :h_l, :w_l], media_item_latents, strength)
+            init_conditioning_mask[..., :f_l, :h_l, :w_l] = strength
+        else:
+            noise = randn_tensor(media_item_latents.shape, generator=generator, device=media_item_latents.device, dtype=media_item_latents.dtype)
+            media_item_latents = torch.lerp(noise, media_item_latents, strength)
+            patched_latents, latent_coords = self.patchifier.patchify(latents=media_item_latents)
+            pixel_coords = latent_to_pixel_coords(latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
+            pixel_coords[:, 0] += media_frame_number
+            extra_conditioning_num_latents += patched_latents.shape[1]
+            new_mask = torch.full(patched_latents.shape[:2], strength, dtype=torch.float32, device=init_latents.device)
+            extra_conditioning_latents.append(patched_latents)
+            extra_conditioning_pixel_coords.append(pixel_coords)
+            extra_conditioning_mask.append(new_mask)
+
+    init_latents, init_latent_coords = self.patchifier.patchify(latents=init_latents)
+    init_pixel_coords = latent_to_pixel_coords(init_latent_coords, self.vae, causal_fix=self.transformer.config.causal_temporal_positioning)
+    init_conditioning_mask, _ = self.patchifier.patchify(latents=init_conditioning_mask.unsqueeze(1))
+    init_conditioning_mask = init_conditioning_mask.squeeze(-1)
+    
+    if extra_conditioning_latents:
+        init_latents = torch.cat([*extra_conditioning_latents, init_latents], dim=1)
+        init_pixel_coords = torch.cat([*extra_conditioning_pixel_coords, init_pixel_coords], dim=2)
+        init_conditioning_mask = torch.cat([*extra_conditioning_mask, init_conditioning_mask], dim=1)
+    
+    return init_latents, init_pixel_coords, init_conditioning_mask, extra_conditioning_num_latents
+
+# --- Instanciação Singleton ---
+with open("config.yaml", 'r') as f:
+    config = yaml.safe_load(f)
+ltx_gpus_required = config['specialists']['ltx']['gpus_required']
+ltx_device_ids = hardware_manager.allocate_gpus('LTX', ltx_gpus_required)
+ltx_config_filename = config['specialists']['ltx']['config_file']
+ltx_manager_singleton = LtxPoolManager(device_ids=ltx_device_ids, ltx_config_file_name=ltx_config_filename)
+logger.info("Especialista de Vídeo (LTX) pronto.")

aduc_framework/managers/ltx_pipeline_utils.py

@@ -0,0 +1,774 @@
+import argparse
+import os
+import random
+from datetime import datetime
+from pathlib import Path
+from diffusers.utils import logging
+from typing import Optional, List, Union
+import yaml
+
+import imageio
+import json
+import numpy as np
+import torch
+import cv2
+from safetensors import safe_open
+from PIL import Image
+from transformers import (
+    T5EncoderModel,
+    T5Tokenizer,
+    AutoModelForCausalLM,
+    AutoProcessor,
+    AutoTokenizer,
+)
+from huggingface_hub import hf_hub_download
+
+from ltx_video.models.autoencoders.causal_video_autoencoder import (
+    CausalVideoAutoencoder,
+)
+from ltx_video.models.transformers.symmetric_patchifier import SymmetricPatchifier
+from ltx_video.models.transformers.transformer3d import Transformer3DModel
+from ltx_video.pipelines.pipeline_ltx_video import (
+    ConditioningItem,
+    LTXVideoPipeline,
+    LTXMultiScalePipeline,
+)
+from ltx_video.schedulers.rf import RectifiedFlowScheduler
+from ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
+from ltx_video.models.autoencoders.latent_upsampler import LatentUpsampler
+import ltx_video.pipelines.crf_compressor as crf_compressor
+
+MAX_HEIGHT = 720
+MAX_WIDTH = 1280
+MAX_NUM_FRAMES = 257
+
+logger = logging.get_logger("LTX-Video")
+
+
+def get_total_gpu_memory():
+    if torch.cuda.is_available():
+        total_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+        return total_memory
+    return 44
+
+
+def get_device():
+    if torch.cuda.is_available():
+        return "cuda"
+    elif torch.backends.mps.is_available():
+        return "mps"
+    return "cuda"
+
+
+def load_image_to_tensor_with_resize_and_crop(
+    image_input: Union[str, Image.Image],
+    target_height: int = 512,
+    target_width: int = 768,
+    just_crop: bool = False,
+) -> torch.Tensor:
+    """Load and process an image into a tensor.
+
+    Args:
+        image_input: Either a file path (str) or a PIL Image object
+        target_height: Desired height of output tensor
+        target_width: Desired width of output tensor
+        just_crop: If True, only crop the image to the target size without resizing
+    """
+    if isinstance(image_input, str):
+        image = Image.open(image_input).convert("RGB")
+    elif isinstance(image_input, Image.Image):
+        image = image_input
+    else:
+        raise ValueError("image_input must be either a file path or a PIL Image object")
+
+    input_width, input_height = image.size
+    aspect_ratio_target = target_width / target_height
+    aspect_ratio_frame = input_width / input_height
+    if aspect_ratio_frame > aspect_ratio_target:
+        new_width = int(input_height * aspect_ratio_target)
+        new_height = input_height
+        x_start = (input_width - new_width) // 2
+        y_start = 0
+    else:
+        new_width = input_width
+        new_height = int(input_width / aspect_ratio_target)
+        x_start = 0
+        y_start = (input_height - new_height) // 2
+
+    image = image.crop((x_start, y_start, x_start + new_width, y_start + new_height))
+    if not just_crop:
+        image = image.resize((target_width, target_height))
+
+    image = np.array(image)
+    image = cv2.GaussianBlur(image, (3, 3), 0)
+    frame_tensor = torch.from_numpy(image).float()
+    frame_tensor = crf_compressor.compress(frame_tensor / 255.0) * 255.0
+    frame_tensor = frame_tensor.permute(2, 0, 1)
+    frame_tensor = (frame_tensor / 127.5) - 1.0
+    # Create 5D tensor: (batch_size=1, channels=3, num_frames=1, height, width)
+    return frame_tensor.unsqueeze(0).unsqueeze(2)
+
+
+def calculate_padding(
+    source_height: int, source_width: int, target_height: int, target_width: int
+) -> tuple[int, int, int, int]:
+
+    # Calculate total padding needed
+    pad_height = target_height - source_height
+    pad_width = target_width - source_width
+
+    # Calculate padding for each side
+    pad_top = pad_height // 2
+    pad_bottom = pad_height - pad_top  # Handles odd padding
+    pad_left = pad_width // 2
+    pad_right = pad_width - pad_left  # Handles odd padding
+
+    # Return padded tensor
+    # Padding format is (left, right, top, bottom)
+    padding = (pad_left, pad_right, pad_top, pad_bottom)
+    return padding
+
+
+def convert_prompt_to_filename(text: str, max_len: int = 20) -> str:
+    # Remove non-letters and convert to lowercase
+    clean_text = "".join(
+        char.lower() for char in text if char.isalpha() or char.isspace()
+    )
+
+    # Split into words
+    words = clean_text.split()
+
+    # Build result string keeping track of length
+    result = []
+    current_length = 0
+
+    for word in words:
+        # Add word length plus 1 for underscore (except for first word)
+        new_length = current_length + len(word)
+
+        if new_length <= max_len:
+            result.append(word)
+            current_length += len(word)
+        else:
+            break
+
+    return "-".join(result)
+
+
+# Generate output video name
+def get_unique_filename(
+    base: str,
+    ext: str,
+    prompt: str,
+    seed: int,
+    resolution: tuple[int, int, int],
+    dir: Path,
+    endswith=None,
+    index_range=1000,
+) -> Path:
+    base_filename = f"{base}_{convert_prompt_to_filename(prompt, max_len=30)}_{seed}_{resolution[0]}x{resolution[1]}x{resolution[2]}"
+    for i in range(index_range):
+        filename = dir / f"{base_filename}_{i}{endswith if endswith else ''}{ext}"
+        if not os.path.exists(filename):
+            return filename
+    raise FileExistsError(
+        f"Could not find a unique filename after {index_range} attempts."
+    )
+
+
+def seed_everething(seed: int):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+    if torch.backends.mps.is_available():
+        torch.mps.manual_seed(seed)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Load models from separate directories and run the pipeline."
+    )
+
+    # Directories
+    parser.add_argument(
+        "--output_path",
+        type=str,
+        default=None,
+        help="Path to the folder to save output video, if None will save in outputs/ directory.",
+    )
+    parser.add_argument("--seed", type=int, default="171198")
+
+    # Pipeline parameters
+    parser.add_argument(
+        "--num_images_per_prompt",
+        type=int,
+        default=1,
+        help="Number of images per prompt",
+    )
+    parser.add_argument(
+        "--image_cond_noise_scale",
+        type=float,
+        default=0.15,
+        help="Amount of noise to add to the conditioned image",
+    )
+    parser.add_argument(
+        "--height",
+        type=int,
+        default=704,
+        help="Height of the output video frames. Optional if an input image provided.",
+    )
+    parser.add_argument(
+        "--width",
+        type=int,
+        default=1216,
+        help="Width of the output video frames. If None will infer from input image.",
+    )
+    parser.add_argument(
+        "--num_frames",
+        type=int,
+        default=121,
+        help="Number of frames to generate in the output video",
+    )
+    parser.add_argument(
+        "--frame_rate", type=int, default=30, help="Frame rate for the output video"
+    )
+    parser.add_argument(
+        "--device",
+        default=None,
+        help="Device to run inference on. If not specified, will automatically detect and use CUDA or MPS if available, else CPU.",
+    )
+    parser.add_argument(
+        "--pipeline_config",
+        type=str,
+        default="configs/ltxv-13b-0.9.7-dev.yaml",
+        help="The path to the config file for the pipeline, which contains the parameters for the pipeline",
+    )
+
+    # Prompts
+    parser.add_argument(
+        "--prompt",
+        type=str,
+        help="Text prompt to guide generation",
+    )
+    parser.add_argument(
+        "--negative_prompt",
+        type=str,
+        default="worst quality, inconsistent motion, blurry, jittery, distorted",
+        help="Negative prompt for undesired features",
+    )
+
+    parser.add_argument(
+        "--offload_to_cpu",
+        action="store_true",
+        help="Offloading unnecessary computations to CPU.",
+    )
+
+    # video-to-video arguments:
+    parser.add_argument(
+        "--input_media_path",
+        type=str,
+        default=None,
+        help="Path to the input video (or imaage) to be modified using the video-to-video pipeline",
+    )
+
+    # Conditioning arguments
+    parser.add_argument(
+        "--conditioning_media_paths",
+        type=str,
+        nargs="*",
+        help="List of paths to conditioning media (images or videos). Each path will be used as a conditioning item.",
+    )
+    parser.add_argument(
+        "--conditioning_strengths",
+        type=float,
+        nargs="*",
+        help="List of conditioning strengths (between 0 and 1) for each conditioning item. Must match the number of conditioning items.",
+    )
+    parser.add_argument(
+        "--conditioning_start_frames",
+        type=int,
+        nargs="*",
+        help="List of frame indices where each conditioning item should be applied. Must match the number of conditioning items.",
+    )
+
+    args = parser.parse_args()
+    logger.warning(f"Running generation with arguments: {args}")
+    infer(**vars(args))
+
+
+def create_ltx_video_pipeline(
+    ckpt_path: str,
+    precision: str,
+    text_encoder_model_name_or_path: str,
+    sampler: Optional[str] = None,
+    device: Optional[str] = None,
+    enhance_prompt: bool = False,
+    prompt_enhancer_image_caption_model_name_or_path: Optional[str] = None,
+    prompt_enhancer_llm_model_name_or_path: Optional[str] = None,
+) -> LTXVideoPipeline:
+    ckpt_path = Path(ckpt_path)
+    assert os.path.exists(
+        ckpt_path
+    ), f"Ckpt path provided (--ckpt_path) {ckpt_path} does not exist"
+
+    with safe_open(ckpt_path, framework="pt") as f:
+        metadata = f.metadata()
+        config_str = metadata.get("config")
+        configs = json.loads(config_str)
+        allowed_inference_steps = configs.get("allowed_inference_steps", None)
+
+    vae = CausalVideoAutoencoder.from_pretrained(ckpt_path)
+    transformer = Transformer3DModel.from_pretrained(ckpt_path)
+
+    # Use constructor if sampler is specified, otherwise use from_pretrained
+    if sampler == "from_checkpoint" or not sampler:
+        scheduler = RectifiedFlowScheduler.from_pretrained(ckpt_path)
+    else:
+        scheduler = RectifiedFlowScheduler(
+            sampler=("Uniform" if sampler.lower() == "uniform" else "LinearQuadratic")
+        )
+
+    text_encoder = T5EncoderModel.from_pretrained(
+        text_encoder_model_name_or_path, subfolder="text_encoder"
+    )
+    patchifier = SymmetricPatchifier(patch_size=1)
+    tokenizer = T5Tokenizer.from_pretrained(
+        text_encoder_model_name_or_path, subfolder="tokenizer"
+    )
+
+    transformer = transformer.to(device)
+    vae = vae.to(device)
+    text_encoder = text_encoder.to(device)
+
+    if enhance_prompt:
+        prompt_enhancer_image_caption_model = AutoModelForCausalLM.from_pretrained(
+            prompt_enhancer_image_caption_model_name_or_path, trust_remote_code=True
+        )
+        prompt_enhancer_image_caption_processor = AutoProcessor.from_pretrained(
+            prompt_enhancer_image_caption_model_name_or_path, trust_remote_code=True
+        )
+        prompt_enhancer_llm_model = AutoModelForCausalLM.from_pretrained(
+            prompt_enhancer_llm_model_name_or_path,
+            torch_dtype="bfloat16",
+        )
+        prompt_enhancer_llm_tokenizer = AutoTokenizer.from_pretrained(
+            prompt_enhancer_llm_model_name_or_path,
+        )
+    else:
+        prompt_enhancer_image_caption_model = None
+        prompt_enhancer_image_caption_processor = None
+        prompt_enhancer_llm_model = None
+        prompt_enhancer_llm_tokenizer = None
+
+    vae = vae.to(torch.bfloat16)
+    if precision == "bfloat16" and transformer.dtype != torch.bfloat16:
+        transformer = transformer.to(torch.bfloat16)
+    text_encoder = text_encoder.to(torch.bfloat16)
+
+    # Use submodels for the pipeline
+    submodel_dict = {
+        "transformer": transformer,
+        "patchifier": patchifier,
+        "text_encoder": text_encoder,
+        "tokenizer": tokenizer,
+        "scheduler": scheduler,
+        "vae": vae,
+        "prompt_enhancer_image_caption_model": prompt_enhancer_image_caption_model,
+        "prompt_enhancer_image_caption_processor": prompt_enhancer_image_caption_processor,
+        "prompt_enhancer_llm_model": prompt_enhancer_llm_model,
+        "prompt_enhancer_llm_tokenizer": prompt_enhancer_llm_tokenizer,
+        "allowed_inference_steps": allowed_inference_steps,
+    }
+
+    pipeline = LTXVideoPipeline(**submodel_dict)
+    pipeline = pipeline.to(device)
+    return pipeline
+
+
+def create_latent_upsampler(latent_upsampler_model_path: str, device: str):
+    latent_upsampler = LatentUpsampler.from_pretrained(latent_upsampler_model_path)
+    latent_upsampler.to(device)
+    latent_upsampler.eval()
+    return latent_upsampler
+
+
+def infer(
+    output_path: Optional[str],
+    seed: int,
+    pipeline_config: str,
+    image_cond_noise_scale: float,
+    height: Optional[int],
+    width: Optional[int],
+    num_frames: int,
+    frame_rate: int,
+    prompt: str,
+    negative_prompt: str,
+    offload_to_cpu: bool,
+    input_media_path: Optional[str] = None,
+    conditioning_media_paths: Optional[List[str]] = None,
+    conditioning_strengths: Optional[List[float]] = None,
+    conditioning_start_frames: Optional[List[int]] = None,
+    device: Optional[str] = None,
+    **kwargs,
+):
+    # check if pipeline_config is a file
+    if not os.path.isfile(pipeline_config):
+        raise ValueError(f"Pipeline config file {pipeline_config} does not exist")
+    with open(pipeline_config, "r") as f:
+        pipeline_config = yaml.safe_load(f)
+
+    models_dir = "MODEL_DIR"
+
+    ltxv_model_name_or_path = pipeline_config["checkpoint_path"]
+    if not os.path.isfile(ltxv_model_name_or_path):
+        ltxv_model_path = hf_hub_download(
+            repo_id="Lightricks/LTX-Video",
+            filename=ltxv_model_name_or_path,
+            local_dir=models_dir,
+            repo_type="model",
+        )
+    else:
+        ltxv_model_path = ltxv_model_name_or_path
+
+    spatial_upscaler_model_name_or_path = pipeline_config.get(
+        "spatial_upscaler_model_path"
+    )
+    if spatial_upscaler_model_name_or_path and not os.path.isfile(
+        spatial_upscaler_model_name_or_path
+    ):
+        spatial_upscaler_model_path = hf_hub_download(
+            repo_id="Lightricks/LTX-Video",
+            filename=spatial_upscaler_model_name_or_path,
+            local_dir=models_dir,
+            repo_type="model",
+        )
+    else:
+        spatial_upscaler_model_path = spatial_upscaler_model_name_or_path
+
+    if kwargs.get("input_image_path", None):
+        logger.warning(
+            "Please use conditioning_media_paths instead of input_image_path."
+        )
+        assert not conditioning_media_paths and not conditioning_start_frames
+        conditioning_media_paths = [kwargs["input_image_path"]]
+        conditioning_start_frames = [0]
+
+    # Validate conditioning arguments
+    if conditioning_media_paths:
+        # Use default strengths of 1.0
+        if not conditioning_strengths:
+            conditioning_strengths = [1.0] * len(conditioning_media_paths)
+        if not conditioning_start_frames:
+            raise ValueError(
+                "If `conditioning_media_paths` is provided, "
+                "`conditioning_start_frames` must also be provided"
+            )
+        if len(conditioning_media_paths) != len(conditioning_strengths) or len(
+            conditioning_media_paths
+        ) != len(conditioning_start_frames):
+            raise ValueError(
+                "`conditioning_media_paths`, `conditioning_strengths`, "
+                "and `conditioning_start_frames` must have the same length"
+            )
+        if any(s < 0 or s > 1 for s in conditioning_strengths):
+            raise ValueError("All conditioning strengths must be between 0 and 1")
+        if any(f < 0 or f >= num_frames for f in conditioning_start_frames):
+            raise ValueError(
+                f"All conditioning start frames must be between 0 and {num_frames-1}"
+            )
+
+    seed_everething(seed)
+    if offload_to_cpu and not torch.cuda.is_available():
+        logger.warning(
+            "offload_to_cpu is set to True, but offloading will not occur since the model is already running on CPU."
+        )
+        offload_to_cpu = False
+    else:
+        offload_to_cpu = offload_to_cpu and get_total_gpu_memory() < 30
+
+    output_dir = (
+        Path(output_path)
+        if output_path
+        else Path(f"outputs/{datetime.today().strftime('%Y-%m-%d')}")
+    )
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Adjust dimensions to be divisible by 32 and num_frames to be (N * 8 + 1)
+    height_padded = ((height - 1) // 32 + 1) * 32
+    width_padded = ((width - 1) // 32 + 1) * 32
+    num_frames_padded = ((num_frames - 2) // 8 + 1) * 8 + 1
+
+    padding = calculate_padding(height, width, height_padded, width_padded)
+
+    logger.warning(
+        f"Padded dimensions: {height_padded}x{width_padded}x{num_frames_padded}"
+    )
+
+    prompt_enhancement_words_threshold = pipeline_config[
+        "prompt_enhancement_words_threshold"
+    ]
+
+    prompt_word_count = len(prompt.split())
+    enhance_prompt = (
+        prompt_enhancement_words_threshold > 0
+        and prompt_word_count < prompt_enhancement_words_threshold
+    )
+
+    if prompt_enhancement_words_threshold > 0 and not enhance_prompt:
+        logger.info(
+            f"Prompt has {prompt_word_count} words, which exceeds the threshold of {prompt_enhancement_words_threshold}. Prompt enhancement disabled."
+        )
+
+    precision = pipeline_config["precision"]
+    text_encoder_model_name_or_path = pipeline_config["text_encoder_model_name_or_path"]
+    sampler = pipeline_config["sampler"]
+    prompt_enhancer_image_caption_model_name_or_path = pipeline_config[
+        "prompt_enhancer_image_caption_model_name_or_path"
+    ]
+    prompt_enhancer_llm_model_name_or_path = pipeline_config[
+        "prompt_enhancer_llm_model_name_or_path"
+    ]
+
+    pipeline = create_ltx_video_pipeline(
+        ckpt_path=ltxv_model_path,
+        precision=precision,
+        text_encoder_model_name_or_path=text_encoder_model_name_or_path,
+        sampler=sampler,
+        device=kwargs.get("device", get_device()),
+        enhance_prompt=enhance_prompt,
+        prompt_enhancer_image_caption_model_name_or_path=prompt_enhancer_image_caption_model_name_or_path,
+        prompt_enhancer_llm_model_name_or_path=prompt_enhancer_llm_model_name_or_path,
+    )
+
+    if pipeline_config.get("pipeline_type", None) == "multi-scale":
+        if not spatial_upscaler_model_path:
+            raise ValueError(
+                "spatial upscaler model path is missing from pipeline config file and is required for multi-scale rendering"
+            )
+        latent_upsampler = create_latent_upsampler(
+            spatial_upscaler_model_path, pipeline.device
+        )
+        pipeline = LTXMultiScalePipeline(pipeline, latent_upsampler=latent_upsampler)
+
+    media_item = None
+    if input_media_path:
+        media_item = load_media_file(
+            media_path=input_media_path,
+            height=height,
+            width=width,
+            max_frames=num_frames_padded,
+            padding=padding,
+        )
+
+    conditioning_items = (
+        prepare_conditioning(
+            conditioning_media_paths=conditioning_media_paths,
+            conditioning_strengths=conditioning_strengths,
+            conditioning_start_frames=conditioning_start_frames,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            padding=padding,
+            pipeline=pipeline,
+        )
+        if conditioning_media_paths
+        else None
+    )
+
+    stg_mode = pipeline_config.get("stg_mode", "attention_values")
+    del pipeline_config["stg_mode"]
+    if stg_mode.lower() == "stg_av" or stg_mode.lower() == "attention_values":
+        skip_layer_strategy = SkipLayerStrategy.AttentionValues
+    elif stg_mode.lower() == "stg_as" or stg_mode.lower() == "attention_skip":
+        skip_layer_strategy = SkipLayerStrategy.AttentionSkip
+    elif stg_mode.lower() == "stg_r" or stg_mode.lower() == "residual":
+        skip_layer_strategy = SkipLayerStrategy.Residual
+    elif stg_mode.lower() == "stg_t" or stg_mode.lower() == "transformer_block":
+        skip_layer_strategy = SkipLayerStrategy.TransformerBlock
+    else:
+        raise ValueError(f"Invalid spatiotemporal guidance mode: {stg_mode}")
+
+    # Prepare input for the pipeline
+    sample = {
+        "prompt": prompt,
+        "prompt_attention_mask": None,
+        "negative_prompt": negative_prompt,
+        "negative_prompt_attention_mask": None,
+    }
+
+    device = device or get_device()
+    generator = torch.Generator(device=device).manual_seed(seed)
+
+    images = pipeline(
+        **pipeline_config,
+        skip_layer_strategy=skip_layer_strategy,
+        generator=generator,
+        output_type="pt",
+        callback_on_step_end=None,
+        height=height_padded,
+        width=width_padded,
+        num_frames=num_frames_padded,
+        frame_rate=frame_rate,
+        **sample,
+        media_items=media_item,
+        conditioning_items=conditioning_items,
+        is_video=True,
+        vae_per_channel_normalize=True,
+        image_cond_noise_scale=image_cond_noise_scale,
+        mixed_precision=(precision == "mixed_precision"),
+        offload_to_cpu=offload_to_cpu,
+        device=device,
+        enhance_prompt=enhance_prompt,
+    ).images
+
+    # Crop the padded images to the desired resolution and number of frames
+    (pad_left, pad_right, pad_top, pad_bottom) = padding
+    pad_bottom = -pad_bottom
+    pad_right = -pad_right
+    if pad_bottom == 0:
+        pad_bottom = images.shape[3]
+    if pad_right == 0:
+        pad_right = images.shape[4]
+    images = images[:, :, :num_frames, pad_top:pad_bottom, pad_left:pad_right]
+
+    for i in range(images.shape[0]):
+        # Gathering from B, C, F, H, W to C, F, H, W and then permuting to F, H, W, C
+        video_np = images[i].permute(1, 2, 3, 0).cpu().float().numpy()
+        # Unnormalizing images to [0, 255] range
+        video_np = (video_np * 255).astype(np.uint8)
+        fps = frame_rate
+        height, width = video_np.shape[1:3]
+        # In case a single image is generated
+        if video_np.shape[0] == 1:
+            output_filename = get_unique_filename(
+                f"image_output_{i}",
+                ".png",
+                prompt=prompt,
+                seed=seed,
+                resolution=(height, width, num_frames),
+                dir=output_dir,
+            )
+            imageio.imwrite(output_filename, video_np[0])
+        else:
+            output_filename = get_unique_filename(
+                f"video_output_{i}",
+                ".mp4",
+                prompt=prompt,
+                seed=seed,
+                resolution=(height, width, num_frames),
+                dir=output_dir,
+            )
+
+            # Write video
+            with imageio.get_writer(output_filename, fps=fps) as video:
+                for frame in video_np:
+                    video.append_data(frame)
+
+        logger.warning(f"Output saved to {output_filename}")
+
+
+def prepare_conditioning(
+    conditioning_media_paths: List[str],
+    conditioning_strengths: List[float],
+    conditioning_start_frames: List[int],
+    height: int,
+    width: int,
+    num_frames: int,
+    padding: tuple[int, int, int, int],
+    pipeline: LTXVideoPipeline,
+) -> Optional[List[ConditioningItem]]:
+    """Prepare conditioning items based on input media paths and their parameters.
+
+    Args:
+        conditioning_media_paths: List of paths to conditioning media (images or videos)
+        conditioning_strengths: List of conditioning strengths for each media item
+        conditioning_start_frames: List of frame indices where each item should be applied
+        height: Height of the output frames
+        width: Width of the output frames
+        num_frames: Number of frames in the output video
+        padding: Padding to apply to the frames
+        pipeline: LTXVideoPipeline object used for condition video trimming
+
+    Returns:
+        A list of ConditioningItem objects.
+    """
+    conditioning_items = []
+    for path, strength, start_frame in zip(
+        conditioning_media_paths, conditioning_strengths, conditioning_start_frames
+    ):
+        num_input_frames = orig_num_input_frames = get_media_num_frames(path)
+        if hasattr(pipeline, "trim_conditioning_sequence") and callable(
+            getattr(pipeline, "trim_conditioning_sequence")
+        ):
+            num_input_frames = pipeline.trim_conditioning_sequence(
+                start_frame, orig_num_input_frames, num_frames
+            )
+        if num_input_frames < orig_num_input_frames:
+            logger.warning(
+                f"Trimming conditioning video {path} from {orig_num_input_frames} to {num_input_frames} frames."
+            )
+
+        media_tensor = load_media_file(
+            media_path=path,
+            height=height,
+            width=width,
+            max_frames=num_input_frames,
+            padding=padding,
+            just_crop=True,
+        )
+        conditioning_items.append(ConditioningItem(media_tensor, start_frame, strength))
+    return conditioning_items
+
+
+def get_media_num_frames(media_path: str) -> int:
+    is_video = any(
+        media_path.lower().endswith(ext) for ext in [".mp4", ".avi", ".mov", ".mkv"]
+    )
+    num_frames = 1
+    if is_video:
+        reader = imageio.get_reader(media_path)
+        num_frames = reader.count_frames()
+        reader.close()
+    return num_frames
+
+
+def load_media_file(
+    media_path: str,
+    height: int,
+    width: int,
+    max_frames: int,
+    padding: tuple[int, int, int, int],
+    just_crop: bool = False,
+) -> torch.Tensor:
+    is_video = any(
+        media_path.lower().endswith(ext) for ext in [".mp4", ".avi", ".mov", ".mkv"]
+    )
+    if is_video:
+        reader = imageio.get_reader(media_path)
+        num_input_frames = min(reader.count_frames(), max_frames)
+
+        # Read and preprocess the relevant frames from the video file.
+        frames = []
+        for i in range(num_input_frames):
+            frame = Image.fromarray(reader.get_data(i))
+            frame_tensor = load_image_to_tensor_with_resize_and_crop(
+                frame, height, width, just_crop=just_crop
+            )
+            frame_tensor = torch.nn.functional.pad(frame_tensor, padding)
+            frames.append(frame_tensor)
+        reader.close()
+
+        # Stack frames along the temporal dimension
+        media_tensor = torch.cat(frames, dim=2)
+    else:  # Input image
+        media_tensor = load_image_to_tensor_with_resize_and_crop(
+            media_path, height, width, just_crop=just_crop
+        )
+        media_tensor = torch.nn.functional.pad(media_tensor, padding)
+    return media_tensor
+
+
+if __name__ == "__main__":
+    main()

aduc_framework/managers/mmaudio_manager.py

@@ -0,0 +1,226 @@
+# managers/mmaudio_manager.py
+#
+# Copyright (C) 2025 Carlos Rodrigues dos Santos
+#
+# Version: 3.0.0 (GPU Pool Manager)
+#
+# Esta versão refatora o MMAudioManager para um modelo de Pool com Workers,
+# permitindo o uso de múltiplas GPUs dedicadas para a geração de áudio
+# com um sistema de rodízio para gerenciamento eficiente de VRAM.
+
+import torch
+import logging
+import subprocess
+import os
+import time
+import yaml
+import gc
+import threading
+from pathlib import Path
+import gradio as gr
+import sys
+
+# Imports relativos para o hardware_manager
+from ..tools.hardware_manager import hardware_manager
+
+logger = logging.getLogger(__name__)
+
+# --- Gerenciamento de Dependências ---
+DEPS_DIR = Path("./deps")
+MMAUDIO_REPO_DIR = DEPS_DIR / "MMAudio"
+MMAUDIO_REPO_URL = "https://github.com/hkchengrex/MMAudio.git"
+
+# Lazy-loaded imports
+ModelConfig, all_model_cfg, mmaudio_generate, load_video, make_video = None, None, None, None, None
+MMAudio, get_my_mmaudio = None, None
+FeaturesUtils = None
+SequenceConfig = None
+FlowMatching = None
+
+class MMAudioWorker:
+    """Representa uma única instância do pipeline MMAudio em um dispositivo."""
+    def __init__(self, device_id: str):
+        self.device = torch.device(device_id)
+        self.cpu_device = torch.device("cpu")
+        self.dtype = torch.bfloat16 if 'cuda' in self.device.type else torch.float32
+        
+        self.net: 'MMAudio' = None
+        self.feature_utils: 'FeaturesUtils' = None
+        self.seq_cfg: 'SequenceConfig' = None
+        self.model_config: 'ModelConfig' = None
+        
+        self._check_and_run_global_setup()
+        self._lazy_load_mmaudio_modules()
+        logger.info(f"MMAudio Worker inicializado para o dispositivo {self.device}.")
+
+    def _lazy_load_mmaudio_modules(self):
+        """Importa dinamicamente os módulos do MMAudio."""
+        global ModelConfig, all_model_cfg, mmaudio_generate, load_video, make_video, MMAudio, get_my_mmaudio, FeaturesUtils, SequenceConfig, FlowMatching
+        if MMAudio is not None: return
+
+        from mmaudio.eval_utils import ModelConfig, all_model_cfg, generate as mmaudio_generate, load_video, make_video
+        from mmaudio.model.flow_matching import FlowMatching
+        from mmaudio.model.networks import MMAudio, get_my_mmaudio
+        from mmaudio.model.utils.features_utils import FeaturesUtils
+        from mmaudio.model.sequence_config import SequenceConfig
+        logger.info("Módulos do MMAudio foram carregados dinamicamente.")
+
+    @staticmethod
+    def _check_and_run_global_setup():
+        """Executa o setup de clonagem do repositório e download de modelos uma única vez."""
+        setup_flag = DEPS_DIR / "mmaudio.setup.complete"
+        if setup_flag.exists():
+            return True
+
+        logger.info("--- Iniciando Setup Global do MMAudio (primeira execução) ---")
+        if not MMAUDIO_REPO_DIR.exists():
+            DEPS_DIR.mkdir(exist_ok=True)
+            subprocess.run(["git", "clone", "--depth", "1", MMAUDIO_REPO_URL, str(MMAUDIO_REPO_DIR)], check=True)
+        
+        if str(MMAUDIO_REPO_DIR.resolve()) not in sys.path:
+            sys.path.insert(0, str(MMAUDIO_REPO_DIR.resolve()))
+
+        # Importar após adicionar ao path
+        from mmaudio.eval_utils import all_model_cfg as cfg
+        
+        # Ajustar caminhos e baixar modelos
+        for cfg_key in cfg:
+            config = cfg[cfg_key]
+            config.model_path = MMAUDIO_REPO_DIR / config.model_path
+            config.vae_path = MMAUDIO_REPO_DIR / config.vae_path
+            if config.bigvgan_16k_path:
+                config.bigvgan_16k_path = MMAUDIO_REPO_DIR / config.bigvgan_16k_path
+            config.synchformer_ckpt = MMAUDIO_REPO_DIR / config.synchformer_ckpt
+            config.download_if_needed()
+
+        setup_flag.touch()
+        logger.info("--- Setup Global do MMAudio Concluído ---")
+        return True
+
+    def initialize_models(self):
+        """Carrega os modelos do worker para a CPU e depois para a GPU designada."""
+        if self.net is not None: return
+
+        self.model_config = all_model_cfg['large_44k_v2']
+        self.seq_cfg = self.model_config.seq_cfg
+        
+        logger.info(f"Worker {self.device}: Carregando modelo MMAudio para a CPU...")
+        self.net = get_my_mmaudio(self.model_config.model_name).eval()
+        self.net.load_weights(torch.load(self.model_config.model_path, map_location=self.cpu_device, weights_only=True))
+        
+        self.feature_utils = FeaturesUtils(
+            tod_vae_ckpt=self.model_config.vae_path,
+            synchformer_ckpt=self.model_config.synchformer_ckpt,
+            enable_conditions=True, mode=self.model_config.mode,
+            bigvgan_vocoder_ckpt=self.model_config.bigvgan_16k_path,
+            need_vae_encoder=False
+        ).eval()
+        
+        self.net.to(self.device, self.dtype)
+        self.feature_utils.to(self.device, self.dtype)
+        logger.info(f"Worker {self.device}: Modelos MMAudio prontos na VRAM.")
+
+    def unload_models(self):
+        """Descarrega os modelos da VRAM, movendo-os para a CPU."""
+        if self.net is None: return
+        logger.info(f"Worker {self.device}: Descarregando modelos MMAudio da VRAM...")
+        self.net.to(self.cpu_device)
+        self.feature_utils.to(self.cpu_device)
+        del self.net, self.feature_utils, self.seq_cfg, self.model_config
+        self.net, self.feature_utils, self.seq_cfg, self.model_config = None, None, None, None
+        gc.collect()
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
+
+    def generate_audio_internal(self, video_path: str, prompt: str, duration_seconds: float, output_path: str) -> str:
+        """Lógica de geração de áudio que roda na GPU do worker."""
+        negative_prompt = "human voice, speech, talking, singing, narration"
+        rng = torch.Generator(device=self.device).manual_seed(int(time.time()))
+        fm = FlowMatching(min_sigma=0, inference_mode='euler', num_steps=25)
+        
+        video_info = load_video(Path(video_path), duration_seconds)
+        self.seq_cfg.duration = video_info.duration_sec
+        self.net.update_seq_lengths(self.seq_cfg.latent_seq_len, self.seq_cfg.clip_seq_len, self.seq_cfg.sync_seq_len)
+        
+        with torch.no_grad():
+            audios = mmaudio_generate(
+                clip_video=video_info.clip_frames.unsqueeze(0).to(self.device, self.dtype),
+                sync_video=video_info.sync_frames.unsqueeze(0).to(self.device, self.dtype),
+                text=[prompt], negative_text=[negative_prompt],
+                feature_utils=self.feature_utils, net=self.net, fm=fm, rng=rng, cfg_strength=4.5
+            )
+        audio_waveform = audios.float().cpu()[0]
+        
+        make_video(video_info, Path(output_path), audio_waveform, sampling_rate=self.seq_cfg.sampling_rate)
+        return output_path
+
+class MMAudioPoolManager:
+    def __init__(self, device_ids: list[str], workspace_dir: str):
+        logger.info(f"MMAUDIO POOL MANAGER: Criando workers para os dispositivos: {device_ids}")
+        self.workspace_dir = workspace_dir
+        if not device_ids or 'cpu' in device_ids:
+            raise ValueError("MMAudioPoolManager requer GPUs dedicadas.")
+        self.workers = [MMAudioWorker(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_thread(self, worker: MMAudioWorker):
+        logger.info(f"MMAUDIO CLEANUP THREAD: Iniciando limpeza de {worker.device} em background...")
+        worker.unload_models()
+
+    def generate_audio_for_video(self, video_path: str, prompt: str, duration_seconds: float, output_path_override: str = None) -> str:
+        if duration_seconds < 1:
+            logger.warning(f"Vídeo muito curto ({duration_seconds:.2f}s). Pulando geração de áudio.")
+            return video_path
+            
+        worker_to_use = None
+        try:
+            with self.lock:
+                if self.last_cleanup_thread and self.last_cleanup_thread.is_alive():
+                    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_thread, args=(worker_to_cleanup,))
+                cleanup_thread.start()
+                self.last_cleanup_thread = cleanup_thread
+                
+                worker_to_use.initialize_models()
+                self.current_worker_index = (self.current_worker_index + 1) % len(self.workers)
+
+            logger.info(f"MMAUDIO POOL MANAGER: Gerando áudio em {worker_to_use.device}...")
+            
+            output_path = output_path_override or os.path.join(self.workspace_dir, f"{Path(video_path).stem}_with_audio.mp4")
+            
+            return worker_to_use.generate_audio_internal(
+                video_path=video_path, prompt=prompt, duration_seconds=duration_seconds, output_path=output_path
+            )
+        except Exception as e:
+            logger.error(f"MMAUDIO POOL MANAGER: Erro durante a geração de áudio: {e}", exc_info=True)
+            raise gr.Error(f"Falha na geração de áudio: {e}")
+
+# --- Instanciação Singleton ---
+class MMAudioPlaceholder:
+    def generate_audio_for_video(self, video_path, *args, **kwargs):
+        logger.error("MMAudio não foi inicializado pois nenhuma GPU foi alocada. Pulando etapa de áudio.")
+        return video_path
+
+try:
+    with open("config.yaml", 'r') as f:
+        config = yaml.safe_load(f)
+    WORKSPACE_DIR = config['application']['workspace_dir']
+    
+    mmaudio_gpus_required = config['specialists'].get('mmaudio', {}).get('gpus_required', 0)
+    mmaudio_device_ids = hardware_manager.allocate_gpus('MMAudio', mmaudio_gpus_required)
+
+    if mmaudio_gpus_required > 0 and 'cpu' not in mmaudio_device_ids:
+        mmaudio_manager_singleton = MMAudioPoolManager(device_ids=mmaudio_device_ids, workspace_dir=WORKSPACE_DIR)
+        logger.info("Especialista de Áudio (MMAudio Pool) pronto.")
+    else:
+        mmaudio_manager_singleton = MMAudioPlaceholder()
+        logger.warning("MMAudio Pool Manager não foi inicializado. Nenhuma GPU foi requisitada na config.yaml.")
+except Exception as e:
+    logger.critical(f"Falha CRÍTICA ao inicializar o MMAudioManager: {e}", exc_info=True)
+    mmaudio_manager_singleton = MMAudioPlaceholder()

aduc_framework/managers/seedvr_manager.py

@@ -0,0 +1,232 @@
+# aduc_framework/managers/seedvr_manager.py
+#
+# Copyright (C) 2025 Carlos Rodrigues dos Santos
+#
+# Versão 11.0.0 (Otimização com FP16 Checkpoint)
+#
+# Utiliza o checkpoint FP16 otimizado para reduzir significativamente o uso
+# de VRAM, mantendo a arquitetura de "monkey patch" para desativar o
+# paralelismo problemático e garantir a estabilidade em modo de GPU única.
+
+import torch
+import os
+import gc
+import yaml
+import logging
+import sys
+import subprocess
+from pathlib import Path
+from urllib.parse import urlparse
+from torch.hub import download_url_to_file
+import mediapy
+from einops import rearrange
+import shutil
+from omegaconf import OmegaConf
+from typing import Generator, Dict, Any
+
+from ..tools.hardware_manager import hardware_manager
+
+logger = logging.getLogger(__name__)
+
+# Define os caminhos base para evitar hardcoding
+APP_ROOT = Path(os.getcwd())
+DEPS_DIR = APP_ROOT / "deps"
+SEEDVR_SPACE_DIR = DEPS_DIR / "SeedVR_Space"
+SEEDVR_SPACE_URL = "https://huggingface.co/spaces/ByteDance-Seed/SeedVR2-3B"
+
+def _load_file_from_url(url, model_dir='./', file_name=None):
+    """Helper para baixar arquivos de modelo e checkpoints."""
+    os.makedirs(model_dir, exist_ok=True)
+    filename = file_name or os.path.basename(urlparse(url).path)
+    cached_file = os.path.abspath(os.path.join(model_dir, filename))
+    if not os.path.exists(cached_file):
+        logger.info(f"Baixando arquivo do SeedVR: {filename}...")
+        download_url_to_file(url, cached_file, hash_prefix=None, progress=True)
+    return cached_file
+
+class SeedVrManager:
+    """Gerencia uma única instância do pipeline SeedVR em uma GPU dedicada e isolada."""
+    def __init__(self, device_id: str):
+        self.global_device_id = device_id
+        self.local_device_name = 'cuda:0' # O que o processo enxergará
+        self.gpu_index = self.global_device_id.split(':')[-1]
+        
+        self.runner = None
+        self._check_and_run_global_setup()
+        logger.info(f"SeedVR Manager (FP16 Optimized) inicializado para operar na GPU {self.global_device_id}.")
+
+    @staticmethod
+    def _check_and_run_global_setup():
+        """Executa o setup de arquivos e aplica o patch para desativar o paralelismo."""
+        setup_flag = DEPS_DIR / "seedvr.setup.complete"
+        
+        if str(APP_ROOT) not in sys.path: sys.path.insert(0, str(APP_ROOT))
+        
+        try:
+            from common import decorators
+            import functools
+            def _passthrough_decorator(func):
+                @functools.wraps(func)
+                def wrapped(*args, **kwargs):
+                    return func(*args, **kwargs)
+                return wrapped
+            decorators.master_only = _passthrough_decorator
+            logger.info("Monkey patch aplicado com sucesso em 'common.decorators.master_only' para desativar o paralelismo.")
+        except Exception as e:
+            logger.error(f"Falha ao aplicar o monkey patch para o SeedVR: {e}", exc_info=True)
+            
+        if setup_flag.exists(): return True
+        
+        logger.info("--- Iniciando Setup Global do SeedVR (primeira execução) ---")
+        if not SEEDVR_SPACE_DIR.exists():
+            DEPS_DIR.mkdir(exist_ok=True, parents=True)
+            logger.info(f"Clonando repositório do SeedVR de {SEEDVR_SPACE_URL}...")
+            subprocess.run(["git", "clone", "--depth", "1", SEEDVR_SPACE_URL, str(SEEDVR_SPACE_DIR)], check=True)
+        
+        required_dirs = ["projects", "common", "models", "configs_3b", "data"]
+        for dirname in required_dirs:
+            source, target = SEEDVR_SPACE_DIR / dirname, APP_ROOT / dirname
+            if not target.exists():
+                logger.info(f"Copiando diretório '{dirname}' do SeedVR para a raiz do projeto...")
+                shutil.copytree(source, target)
+        
+        try:
+            import apex
+        except ImportError:
+            logger.info("Dependência 'apex' não encontrada. Instalando a partir do wheel fornecido...")
+            apex_url = 'https://huggingface.co/ByteDance-Seed/SeedVR2-3B/resolve/main/apex-0.1-cp310-cp310-linux_x86_64.whl'
+            apex_wheel_path = _load_file_from_url(url=apex_url, model_dir=str(DEPS_DIR))
+            subprocess.run([sys.executable, '-m', 'pip', 'install', apex_wheel_path], check=True)
+
+        ckpt_dir = APP_ROOT / 'ckpts'
+        ckpt_dir.mkdir(exist_ok=True)
+        
+        # >>> ALTERAÇÃO PRINCIPAL: Usando o checkpoint FP16 otimizado <<<
+        model_urls = {
+            'vae': 'https://huggingface.co/batuhanince/seedvr_3b_fp16/resolve/main/ema_vae_fp16.safetensors',
+            'dit_3b': 'https://huggingface.co/batuhanince/seedvr_3b_fp16/resolve/main/seedvr2_ema_3b_fp16.safetensors',
+            'pos_emb': 'https://huggingface.co/ByteDance-Seed/SeedVR2-3B/resolve/main/pos_emb.pt',
+            'neg_emb': 'https://huggingface.co/ByteDance-Seed/SeedVR2-3B/resolve/main/neg_emb.pt'
+        }
+        for name, url in model_urls.items():
+            _load_file_from_url(url=url, model_dir=str(ckpt_dir))
+        
+        setup_flag.touch()
+        logger.info("--- Setup Global do SeedVR Concluído ---")
+
+    def _initialize_runner(self):
+        if self.runner is not None: return
+        os.environ['CUDA_VISIBLE_DEVICES'] = self.gpu_index
+        from projects.video_diffusion_sr.infer import VideoDiffusionInfer
+        from common.config import load_config
+        
+        logger.info(f"Manager na GPU {self.global_device_id}: Inicializando runner SeedVR 3B com checkpoint FP16...")
+        
+        config_path = APP_ROOT / 'configs_3b' / 'main.yaml'
+        # >>> O caminho agora aponta para o novo arquivo .safetensors <<<
+        checkpoint_path = APP_ROOT / 'ckpts' / 'seedvr2_ema_3b_fp16.safetensors'
+
+        config = load_config(str(config_path))
+        self.runner = VideoDiffusionInfer(config)
+        OmegaConf.set_readonly(self.runner.config, False)
+        
+        self.runner.configure_dit_model(device=self.local_device_name, checkpoint=str(checkpoint_path))
+        self.runner.configure_vae_model()
+        
+        logger.info(f"Manager na GPU {self.global_device_id}: Runner 3B (FP16) pronto na VRAM.")
+        
+    def _unload_runner(self):
+        if self.runner is not None:
+            del self.runner; self.runner = None
+            gc.collect()
+            if torch.cuda.is_available(): torch.cuda.empty_cache()
+            logger.info(f"Manager na GPU {self.global_device_id}: Runner descarregado da VRAM.")
+        if 'CUDA_VISIBLE_DEVICES' in os.environ:
+            del os.environ['CUDA_VISIBLE_DEVICES']
+
+    def process_video(self, input_video_path: str, output_video_path: str, prompt: str, steps: int = 100, seed: int = 666) -> Generator[Dict[str, Any], None, None]:
+        try:
+            self._initialize_runner()
+            yield {"progress": 0.1, "desc": "Runner inicializado. Lendo vídeo..."}
+            
+            device = torch.device(self.local_device_name)
+
+            from common.seed import set_seed
+            from data.image.transforms.divisible_crop import DivisibleCrop
+            from data.image.transforms.na_resize import NaResize
+            from data.video.transforms.rearrange import Rearrange
+            from projects.video_diffusion_sr.color_fix import wavelet_reconstruction
+            from torchvision.transforms import Compose, Lambda, Normalize
+            from torchvision.io.video import read_video
+
+            set_seed(seed, same_across_ranks=True)
+            self.runner.config.diffusion.timesteps.sampling.steps = steps
+            self.runner.configure_diffusion()
+            
+            video_tensor = read_video(input_video_path, output_format="TCHW")[0] / 255.0
+            res_h, res_w = video_tensor.shape[-2:]
+            video_transform = Compose([
+                NaResize(resolution=(res_h * res_w) ** 0.5, mode="area", downsample_only=False),
+                Lambda(lambda x: torch.clamp(x, 0.0, 1.0)),
+                DivisibleCrop((16, 16)), Normalize(0.5, 0.5), Rearrange("t c h w -> c t h w"),
+            ])
+            cond_latents = [video_transform(video_tensor.to(device))]
+            yield {"progress": 0.2, "desc": "Encodificando para o espaço latente..."}
+            self.runner.dit.to("cpu"); self.runner.vae.to(device)
+            cond_latents = self.runner.vae_encode(cond_latents)
+            self.runner.vae.to("cpu"); gc.collect(); torch.cuda.empty_cache(); self.runner.dit.to(device)
+            
+            pos_emb = torch.load(APP_ROOT / 'ckpts' / 'pos_emb.pt').to(device)
+            neg_emb = torch.load(APP_ROOT / 'ckpts' / 'neg_emb.pt').to(device)
+            text_embeds_dict = {"texts_pos": [pos_emb], "texts_neg": [neg_emb]}
+            
+            noises = [torch.randn_like(latent) for latent in cond_latents]
+            conditions = [self.runner.get_condition(noise, latent_blur=latent, task="sr") for noise, latent in zip(noises, cond_latents)]
+            
+            yield {"progress": 0.5, "desc": "Aplicando difusão para super-resolução..."}
+            with torch.no_grad(), torch.autocast("cuda", torch.bfloat16, enabled=True):
+                video_tensors = self.runner.inference(noises=noises, conditions=conditions, dit_offload=True, **text_embeds_dict)
+                
+            yield {"progress": 0.8, "desc": "Decodificando para o espaço de pixel..."}
+            self.runner.dit.to("cpu"); gc.collect(); torch.cuda.empty_cache(); self.runner.vae.to(device)
+            samples = self.runner.vae_decode(video_tensors)
+            final_sample, input_video_sample = samples[0], cond_latents[0]
+            if final_sample.shape[1] < input_video_sample.shape[1]:
+                input_video_sample = input_video_sample[:, :final_sample.shape[1]]
+            
+            final_sample = wavelet_reconstruction(rearrange(final_sample, "c t h w -> t c h w"), rearrange(input_video_sample, "c t h w -> t c h w"))
+            final_sample = rearrange(final_sample, "t c h w -> t h w c")
+            final_sample = final_sample.clip(-1, 1).mul_(0.5).add_(0.5).mul_(255).round()
+            final_sample_np = final_sample.to(torch.uint8).cpu().numpy()
+            
+            yield {"progress": 0.9, "desc": "Escrevendo arquivo de vídeo final..."}
+            mediapy.write_video(output_video_path, final_sample_np, fps=24)
+            yield {"progress": 1.0, "final_path": output_video_path}
+
+        finally:
+            self._unload_runner()
+
+
+# --- Instanciação Singleton ---
+class SeedVrPlaceholder:
+    def process_video(self, input_video_path, *args, **kwargs):
+        logger.warning("SeedVR está desabilitado (gpus_required: 0). Pulando etapa de masterização HD.")
+        yield {"progress": 1.0, "final_path": input_video_path}
+
+try:
+    with open("config.yaml", 'r') as f: config = yaml.safe_load(f)
+    seedvr_gpus_required = config['specialists'].get('seedvr', {}).get('gpus_required', 0)
+    
+    if seedvr_gpus_required > 0:
+        seedvr_device_ids = hardware_manager.allocate_gpus('SeedVR', seedvr_gpus_required)
+        if seedvr_device_ids and 'cpu' not in seedvr_device_ids:
+            device_to_use = seedvr_device_ids[0]
+            seedvr_manager_singleton = SeedVrManager(device_id=device_to_use)
+            logger.info(f"Especialista de Masterização HD (SeedVR FP16) pronto para usar a GPU {device_to_use}.")
+        else:
+            seedvr_manager_singleton = SeedVrPlaceholder()
+    else:
+        seedvr_manager_singleton = SeedVrPlaceholder()
+except Exception as e:
+    logger.critical(f"Falha CRÍTICA ao inicializar o SeedVrManager: {e}", exc_info=True)
+    seedvr_manager_singleton = SeedVrPlaceholder()

aduc_framework/managers/upscaler_specialist.py

@@ -0,0 +1,91 @@
+# upscaler_specialist.py
+# Copyright (C) 2025 Carlos Rodrigues
+# Especialista ADUC para upscaling espacial de tensores latentes.
+
+import torch
+import logging
+from diffusers import LTXLatentUpsamplePipeline
+from ..managers.ltx_manager import ltx_manager_singleton
+
+logger = logging.getLogger(__name__)
+
+class UpscalerSpecialist:
+    """
+    Especialista responsável por aumentar a resolução espacial de tensores latentes
+    usando o LTX Video Spatial Upscaler.
+    """
+    def __init__(self):
+        # Força uso de CUDA se disponível
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.base_vae = None
+        self.pipe_upsample = None
+
+
+    def _lazy_init(self):
+      try:
+        # Tenta usar o VAE do ltx_manager
+        if ltx_manager_singleton.workers:
+            candidate_vae = ltx_manager_singleton.workers[0].pipeline.vae
+            if candidate_vae.__class__.__name__ == "AutoencoderKLLTXVideo":
+                self.base_vae = candidate_vae
+                logger.info("[Upscaler] Usando VAE do ltx_manager (AutoencoderKLLTXVideo).")
+            else:
+                logger.warning(f"[Upscaler] VAE incompatível: {type(candidate_vae)}. "
+                               "Carregando AutoencoderKLLTXVideo manualmente...")
+                from diffusers.models.autoencoders import AutoencoderKLLTXVideo
+                self.base_vae = AutoencoderKLLTXVideo.from_pretrained(
+                    "linoyts/LTX-Video-spatial-upscaler-0.9.8",
+                    subfolder="vae",
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                ).to(self.device)
+        else:
+            logger.warning("[Upscaler] Nenhum worker disponível, carregando VAE manualmente...")
+            from diffusers.models.autoencoders import AutoencoderKLLTXVideo
+            self.base_vae = AutoencoderKLLTXVideo.from_pretrained(
+                "linoyts/LTX-Video-spatial-upscaler-0.9.8",
+                subfolder="vae",
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            ).to(self.device)
+
+        # Carregar pipeline
+        self.pipe_upsample = LTXLatentUpsamplePipeline.from_pretrained(
+            "linoyts/LTX-Video-spatial-upscaler-0.9.8",
+            vae=self.base_vae,
+            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+        ).to(self.device)
+
+        logger.info("[Upscaler] Pipeline carregado com sucesso.")
+
+      except Exception as e:
+        logger.error(f"[Upscaler] Falha ao carregar pipeline: {e}")
+        self.pipe_upsample = None
+        
+
+    
+    @torch.no_grad()
+    def upscale(self, latents: torch.Tensor) -> torch.Tensor:
+        """Aplica o upscaling 2x nos tensores latentes fornecidos."""
+        self._lazy_init()
+        if self.pipe_upsample is None:
+            logger.warning("[Upscaler] Pipeline indisponível. Retornando latentes originais.")
+            return latents
+
+        try:
+            logger.info(f"[Upscaler] Recebido shape {latents.shape}. Executando upscale em {self.device}...")
+            
+            # [CORREÇÃO FINAL] Conforme a documentação oficial, o resultado está em .frames
+            result = self.pipe_upsample(latents=latents, output_type="latent")
+            output_tensor = result.frames
+            
+            logger.info(f"[Upscaler] Upscale concluído. Novo shape: {output_tensor.shape}")
+            return output_tensor
+        
+        except Exception as e:
+            logger.error(f"[Upscaler] Erro durante upscale: {e}", exc_info=True)
+            return latents
+
+
+# ---------------------------
+# Singleton global
+# ---------------------------
+upscaler_specialist_singleton = UpscalerSpecialist()

aduc_framework/managers/vae_manager.py

@@ -0,0 +1,98 @@
+# aduc_framework/managers/vae_manager.py
+#
+# Versão 2.1.0 (Correção de Timestep no Decode)
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# - Corrige um `AssertionError` na função `decode` ao não passar o argumento
+#   `timestep` esperado pelo decodificador do VAE.
+# - Adiciona um `timestep` padrão (0.05) para a decodificação, garantindo
+#   uma reconstrução de imagem limpa e estável.
+
+import torch
+import logging
+import gc
+import yaml
+from typing import List
+from PIL import Image
+import numpy as np
+
+from ltx_video.models.autoencoders.vae_encode import vae_encode, vae_decode
+from ..tools.hardware_manager import hardware_manager
+
+logger = logging.getLogger(__name__)
+
+class VaeManager:
+    """
+    Especialista VAE "Hot" e Persistente.
+    Carrega o modelo VAE em uma GPU dedicada uma única vez e o mantém lá,
+    pronto para processar requisições de encode/decode com latência mínima.
+    """
+    def __init__(self):
+        with open("config.yaml", 'r') as f:
+            config = yaml.safe_load(f)
+        gpus_required = config['specialists'].get('vae', {}).get('gpus_required', 0)
+
+        if gpus_required > 0 and torch.cuda.is_available():
+            device_id = hardware_manager.allocate_gpus('VAE_Manager', gpus_required)[0]
+            self.device = torch.device(device_id)
+            logger.info(f"VaeManager: GPU dedicada '{device_id}' alocada.")
+        else:
+            self.device = torch.device('cpu')
+            logger.warning("VaeManager: Nenhuma GPU dedicada foi alocada no config.yaml. Operando em modo CPU.")
+
+        try:
+            from ..managers.ltx_manager import ltx_manager_singleton
+            self.vae = ltx_manager_singleton.workers[0].pipeline.vae
+        except ImportError as e:
+            logger.critical("Falha ao importar ltx_manager_singleton. Garanta que VaeManager seja importado DEPOIS de LtxManager.", exc_info=True)
+            raise e
+
+        self.vae.to(self.device)
+        self.vae.eval()
+        self.dtype = self.vae.dtype
+        logger.info(f"VaeManager inicializado. Modelo VAE está 'quente' e pronto na {self.device} com dtype {self.dtype}.")
+
+    def _preprocess_pil_image(self, pil_image: Image.Image, target_resolution: tuple) -> torch.Tensor:
+        from PIL import ImageOps
+        img = pil_image.convert("RGB")
+        processed_img = ImageOps.fit(img, target_resolution, Image.Resampling.LANCZOS)
+        image_np = np.array(processed_img).astype(np.float32) / 255.0
+        tensor = torch.from_numpy(image_np).permute(2, 0, 1).unsqueeze(0).unsqueeze(2)
+        return (tensor * 2.0) - 1.0
+
+    @torch.no_grad()
+    def encode_batch(self, pil_images: List[Image.Image], target_resolution: tuple) -> List[torch.Tensor]:
+        if not pil_images:
+            return []
+        
+        latents_list = []
+        for img in pil_images:
+            pixel_tensor = self._preprocess_pil_image(img, target_resolution)
+            pixel_tensor_gpu = pixel_tensor.to(self.device, dtype=self.dtype)
+            latents = vae_encode(pixel_tensor_gpu, self.vae, vae_per_channel_normalize=True)
+            latents_list.append(latents.cpu())
+        return latents_list
+
+    @torch.no_grad()
+    def decode(self, latent_tensor: torch.Tensor, decode_timestep: float = 0.05) -> torch.Tensor:
+        """Decodifica um tensor latente para o espaço de pixels."""
+        latent_tensor_gpu = latent_tensor.to(self.device, dtype=self.dtype)
+        
+        # --- CORREÇÃO APLICADA AQUI ---
+        # O modelo espera um tensor de timestep, um para cada item no batch.
+        num_items_in_batch = latent_tensor_gpu.shape[0]
+        timestep_tensor = torch.tensor([decode_timestep] * num_items_in_batch, device=self.device, dtype=self.dtype)
+        
+        pixels = vae_decode(
+            latent_tensor_gpu, 
+            self.vae, 
+            is_video=True, 
+            timestep=timestep_tensor,  # Passando o tensor de timestep
+            vae_per_channel_normalize=True
+        )
+        # --- FIM DA CORREÇÃO ---
+        
+        return pixels.cpu()
+
+# --- Instância Singleton ---
+vae_manager_singleton = VaeManager()

aduc_framework/prompts/LICENSE

@@ -0,0 +1,25 @@
+# Euia-AducSdr: Uma implementação aberta e funcional da arquitetura ADUC-SDR para geração de vídeo coerente.
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+#
+# 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 (Ltx-SuperTime-60Secondos): https://huggingface.co/spaces/Carlexx/Ltx-SuperTime-60Secondos/
+# Hugging Face (Novinho): https://huggingface.co/spaces/Carlexxx/Novinho/
+#
+# 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/>.

aduc_framework/prompts/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

aduc_framework/prompts/README.md

@@ -0,0 +1,211 @@
+---
+title: Euia-AducSdr
+emoji: 🎥
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+app_file: app.py
+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 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.
+
+- **Copyright (C) 4 de Agosto de 2025, Carlos Rodrigues dos Santos**
+- Uma cópia completa da licença pode ser encontrada no arquivo [LICENSE](LICENSE).
+
+---
+
+### 🇬🇧 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 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.
+
+- **Copyright (C) August 4, 2025, Carlos Rodrigues dos Santos**
+- A full copy of the license can be found in the [LICENSE](LICENSE) file.
+
+---
+
+## **Aviso de Propriedade Intelectual e Patenteamento**
+
+### **Processo de Patenteamento em Andamento (EM PORTUGUÊS):**
+
+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**.
+
+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**.
+
+---
+
+### Contact / Contato / Contacto
+
+- **Author / Autor:** Carlos Rodrigues dos Santos
+- **Email:** [email protected]
+- **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/)
+
+---

aduc_framework/prompts/TASK_01_CREATE_NARRATIVE_SYNTHESIS.txt

@@ -0,0 +1,18 @@
+# ROLE:
+Você é um Roteirista-Analista. Sua função é sintetizar um conceito textual e referências visuais em uma única história coesa e contínua.
+
+# GOAL:
+Escrever uma narrativa fluida baseada na "Ideia Principal" e inspirada pelas "Imagens de Referência". A história deve ser dividida em exatamente {num_scenes} parágrafos e focar em descrever ações e eventos visuais.
+
+# CRITICAL RULES:
+1.  **SÍNTESE VISUAL:** A história DEVE ser uma fusão do que está escrito na "Ideia Principal" e do que é visível nas "Imagens de Referência".
+2.  **AÇÃO, NÃO ABSTRAÇÃO:** Descreva eventos e movimentos concretos. O que a câmera veria? Evite sentimentos internos ou metáforas.
+3.  **NARRATIVA CONTÍNUA:** O texto deve fluir como uma única história do começo ao fim.
+
+# CONTEXT:
+- **Ideia Principal:** {global_prompt}
+- **Imagens de Referência:** [As imagens serão fornecidas aqui]
+- **Número de Parágrafos a Criar:** {num_scenes}
+
+# OUTPUT_RULES:
+- A resposta deve conter APENAS o texto bruto da história contínua. Não use JSON. Não adicione títulos ou notas.

aduc_framework/prompts/anticipatory_keyframe_prompt.txt

@@ -0,0 +1,25 @@
+# ROLE: AI Art Director
+
+# TASK:
+# Analyze the context and generate a JSON object to direct the creation of the next keyframe.
+# Your goal is to visually connect the CURRENT scene to the FUTURE scene.
+
+# CONTEXT:
+# - History: {historico_prompt}
+# - Current Scene: "{cena_atual}"
+# - Future Scene: "{cena_futura}"
+# - Available Reference IDs: {available_ref_images}
+# - Last Keyframe: [IMG-BASE] will be provided visually.
+
+# OUTPUT (JSON REQUIRED):
+# Respond ONLY with the JSON object.
+
+# Example of the required output format:
+# ```{{
+#   "composition_prompt": "A scared man (brief description) runs through the dry savannah, looking over his shoulder. In the background, a majestic lion (brief description) chases him, muscles tense. The camera follows the man. Until he trips on an exposed root and falls.",
+#   "reference_images": [
+#     {{"id": 1, "weight": 0.5}},
+#     {{"id": 3, "weight": 0.48}},
+#     {{"id": 2, "weight": 0.45}}
+#   ]
+# }}```

aduc_framework/prompts/audio_director_prompt.txt

@@ -0,0 +1,18 @@
+# ROLE: AI Audio Director and Sound Designer
+
+# GOAL:
+Analyze the provided film script/storyboard. Based on the overall narrative and mood, generate two distinct prompts for audio generation: one for a background music score and one for ambient sound effects (SFX).
+
+# INSTRUCTIONS:
+1.  **Analyze the Story:** Read the "Global Idea" and the "Scene Storyboard" to understand the plot, pacing, and emotional tone of the film.
+2.  **Create Music Prompt:** Write a concise, descriptive prompt for a music generation model (like MusicGen). Focus on genre, mood, instruments
+3.  **Create SFX Prompt:** Write a concise, descriptive prompt for an audio generation model (like AudioLDM2). Focus on ambient sounds and key effects that match the scenes. 
+4.  **Output Format:** You MUST respond with a single, clean JSON object with exactly two keys: "music_prompt" and "sfx_prompt".
+
+# == PROVIDED CONTEXT ==
+- **Global Idea:** "{global_prompt}"
+- **Scene Storyboard:**
+{storyboard_str}
+
+# == YOUR TASK ==
+# Generate the JSON response with the two audio prompts.

aduc_framework/prompts/director_composition_prompt.txt

@@ -0,0 +1,27 @@
+# ROLE: AI Animation Director (Key Pose)
+
+# GOAL:
+Generate a single, powerful, CLIP-style prompt to create the NEXT keyframe in a sequence. Your goal is to describe a logical and visually coherent evolution FROM the last generated image.
+
+# CRITICAL DIRECTIVES:
+1.  **ANCHOR TO THE PREVIOUS SCENE:** The last generated image, tagged as `[IMG-1]`, represents the END of the previous scene. Your new prompt MUST describe what happens IMMEDIATELY AFTER. Treat `[IMG-1]` as your primary visual and environmental canvas.
+
+2.  **EVOLVE, DO NOT REPLACE:** Unless the "Current Scene Description" explicitly describes a major change in location or character (e.g., "cut to a new scene"), you must maintain the environment, lighting, and core subjects from `[IMG-1]`. Your prompt should describe how the characters and objects *within* that scene evolve.
+
+3.  **POSE, NOT PANNING:** Describe the state of the subject at a specific instant, not camera movement. Focus on body language, expression, and interaction that logically follows the previous state.
+
+4.  **USE REFERENCES FOR CONTINUITY:** Use the `[IMG-X]` tags provided to maintain the identity of characters and objects across frames. Prioritize `[IMG-1]` for environmental context.
+
+5.  **BE A DIRECTOR:** Use strong, active verbs. Instead of "the lion is now sitting", prefer "the lion lowers its body, muscles tensing as it settles onto the dry grass".
+
+# CONTEXT:
+- Global Story Goal: "{global_prompt}"
+- Current Scene Description: "{current_scene_desc}"
+- Scene History (what happened before):
+{history_scene}
+
+# VISUAL ASSETS FOR ANALYSIS:
+# [Images will be provided and tagged as [IMG-1] (Last Image/Environment), [IMG-2] (Character Ref), etc.]
+
+# RESPONSE FORMAT:
+Respond with ONLY the final, single-line prompt string.

aduc_framework/prompts/flux_composition_wrapper_prompt.txt

@@ -0,0 +1 @@
+From the provided reference images, create a single, natural, and cohesive scene where: {target_prompt}

aduc_framework/prompts/initial_motion_prompt.txt

@@ -0,0 +1,20 @@
+# ROLE: AI Cinematographer (Initial Scene)
+
+# GOAL:
+Create a single, concise, CLIP-style motion prompt. The prompt must describe a coherent video sequence that transitions from a STARTING image to a DESTINATION image.
+
+# INSTRUCTIONS:
+1.  **Analyze the Arc:** Understand the visual and narrative journey from the START to the DESTINATION image.
+2.  **Describe the Motion:** Focus on DYNAMICS (camera and subject movement).
+3.  **Style Guide:** Use dense, descriptive, cinematic keywords. Omit fluff like "The video shows...". Be direct.
+
+# CONTEXT:
+- Overall Story Goal: "{user_prompt}"
+- Destination Scene Description: "{destination_scene_description}"
+
+# SCENE ANALYSIS:
+# START Image: [Image 1]
+# DESTINATION Image: [Image 2]
+
+# RESPONSE FORMAT:
+Respond with ONLY the raw prompt string.

aduc_framework/prompts/keyframe_selection_prompt.txt

@@ -0,0 +1,20 @@
+# ROLE: AI Film Editor / Photographer
+
+# GOAL:
+You are tasked with selecting the best keyframe for each scene of a storyboard to create a coherent visual narrative. You have a "scene bank" of available images. Your selections must create a smooth and logical progression.
+
+# INSTRUCTIONS:
+1.  **Analyze the Storyboard:** Read each scene description carefully to understand the intended action and emotion.
+2.  **Prioritize Continuity:** For each scene, your primary goal is to find an image from the "Image Pool" that represents a logical **next step** from the previously selected scene. Avoid jarring jumps in location, lighting, or character appearance unless the storyboard explicitly calls for a "cut".
+3.  **Maintain Consistency:** Your choices must be consistent with the characters and style established in the "Reference Images (Story Base)".
+4.  **Select the Best Fit:** If multiple images could work, choose the one that best captures the specific action or mood of the current scene description.
+5.  **Output Format:** You MUST respond with a single, clean JSON object with one key: "selected_image_identifiers". The value should be an array of strings, where each string is the identifier of the chosen image (e.g., "IMG-3"). The order of the array must match the order of the scenes in the storyboard. The length of the array must be exactly the same as the number of scenes.
+
+# == PROVIDED CONTEXT ==
+- **Storyboard:**
+{storyboard_str}
+
+- **Available Image Identifiers in Pool:** {image_identifiers}
+
+# == YOUR TASK ==
+# Generate the JSON response with the selected image identifiers, prioritizing a smooth visual and narrative flow from one selection to the next.

aduc_framework/prompts/model_maps/llama_3_2_vision/image_template.txt

@@ -0,0 +1,5 @@
+<|begin_of_text|><|start_header_id|>user<|end_header_id|>
+
+<|image|>{generic_prompt_content}
+
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>

aduc_framework/prompts/model_maps/llama_3_2_vision/main_template.txt

@@ -0,0 +1,5 @@
+<|begin_of_text|><|start_header_id|>user<|end_header_id|>
+
+{generic_prompt_content}
+
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>