feat: Implement self-contained specialist managers

aduc_framework/__init__.py

@@ -0,0 +1,75 @@
+# aduc_framework/__init__.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 3.0.0 (Framework Entry Point)
+#
+# Este arquivo serve como o ponto de entrada principal para o Aduc Framework.
+# Ele define a interface pública que os clientes (UIs, APIs, etc.) usarão
+# para criar e interagir com o sistema de orquestração.
+#
+# A principal responsabilidade deste arquivo é expor uma função de fábrica
+# ('create_aduc_instance') que encapsula a lógica de inicialização do
+# orquestrador e seus componentes, garantindo que o framework seja fácil
+# de consumir.
+
+import logging
+
+# Importa as classes e tipos que formarão a interface pública do framework
+from .orchestrator import AducOrchestrator
+from .types import (
+    GenerationState,
+    PreProductionParams,
+    ProductionParams,
+    GenerationParameters,
+    MediaRef,
+    Ato,
+    KeyframeData,
+    VideoData
+)
+
+# Configura um logger para o framework para que os clientes possam ver as mensagens de inicialização.
+logger = logging.getLogger(__name__)
+
+def create_aduc_instance(workspace_dir: str) -> AducOrchestrator:
+    """
+    Ponto de entrada de fábrica para criar uma instância totalmente funcional do Aduc Framework.
+
+    Esta função abstrai a complexidade da inicialização do AducOrchestrator e de todos
+    os seus engenheiros e managers dependentes. Clientes do framework devem usar esta
+    função para garantir uma inicialização correta e consistente.
+
+    Args:
+        workspace_dir (str): O caminho para o diretório onde todos os artefatos
+                             (imagens, vídeos, latentes, logs) serão salvos.
+
+    Returns:
+        AducOrchestrator: Uma instância pronta para uso do orquestrador principal.
+    """
+    logger.info(f"Fábrica ADUC: Criando uma nova instância com workspace em '{workspace_dir}'...")
+    
+    # Futuramente, lógicas mais complexas de inicialização, como a verificação de
+    # dependências ou configuração de hardware, podem ser adicionadas aqui.
+    
+    instance = AducOrchestrator(workspace_dir=workspace_dir)
+    
+    logger.info("Fábrica ADUC: Instância do framework criada e pronta para uso.")
+    
+    return instance
+
+# Mensagem de log para confirmar que o pacote do framework foi importado com sucesso.
+logger.info("Módulo 'aduc_framework' carregado. Use a função 'create_aduc_instance()' para começar.")
+
+# Opcional: Definir __all__ para controlar o que é importado com 'from aduc_framework import *'
+__all__ = [
+    "create_aduc_instance",
+    "AducOrchestrator",
+    "GenerationState",
+    "PreProductionParams",
+    "ProductionParams",
+    "GenerationParameters",
+    "MediaRef",
+    "Ato",
+    "KeyframeData",
+    "VideoData"
+]

aduc_framework/director.py

@@ -0,0 +1,116 @@
+# aduc_framework/director.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 3.0.0 (Framework State Manager)
+#
+# Este arquivo contém a classe AducDirector. Sua única responsabilidade
+# é gerenciar o objeto de estado da geração (GenerationState). Ele atua
+# como o "score" da orquestra ou o "script" do filme, mantendo um registro
+# preciso de todos os parâmetros e artefatos gerados.
+
+import logging
+import os
+from typing import List, Dict, Any
+
+# Importa os modelos de dados Pydantic que ele irá gerenciar
+from .types import GenerationState, PreProductionParams, ProductionParams, Ato, MediaRef, KeyframeData, VideoData
+
+logger = logging.getLogger(__name__)
+
+class AducDirector:
+    """
+    Representa o Diretor de Cena, responsável por gerenciar o estado da produção.
+    Atua como a fonte única da verdade para todos os dados relacionados a uma
+    única tarefa de geração de vídeo.
+    """
+    def __init__(self, workspace_dir: str):
+        """
+        Inicializa o Diretor.
+
+        Args:
+            workspace_dir (str): O diretório onde os artefatos são salvos.
+                                 O Diretor usa isso para referenciar caminhos se necessário.
+        """
+        self.workspace_dir = workspace_dir
+        self.state: GenerationState = self._initialize_state()
+        os.makedirs(self.workspace_dir, exist_ok=True)
+        logger.info(f"AducDirector inicializado. O estado de geração foi criado.")
+
+    def _initialize_state(self) -> GenerationState:
+        """
+        Cria uma instância vazia e válida do modelo GenerationState.
+        """
+        return GenerationState()
+
+    def get_full_state(self) -> GenerationState:
+        """
+        Retorna o objeto de estado Pydantic completo.
+
+        Returns:
+            GenerationState: O estado atual da geração.
+        """
+        return self.state
+    
+    def get_full_state_as_dict(self) -> Dict[str, Any]:
+        """
+        Retorna o estado completo serializado como um dicionário Python.
+        Útil para passar para bibliotecas que não suportam Pydantic diretamente.
+
+        Returns:
+            Dict[str, Any]: O estado atual como um dicionário.
+        """
+        return self.state.model_dump()
+
+    def update_parameters(self, stage: str, params: Any):
+        """
+        Atualiza o nó de parâmetros no estado de geração.
+
+        Args:
+            stage (str): O estágio da produção ('pre_producao', 'producao', etc.).
+            params (BaseModel): O objeto Pydantic contendo os parâmetros para aquele estágio.
+        """
+        if hasattr(self.state.parametros_geracao, stage):
+            setattr(self.state.parametros_geracao, stage, params)
+            logger.info(f"Parâmetros do estágio '{stage}' atualizados no estado.")
+        else:
+            logger.warning(f"Tentativa de atualizar parâmetros para um estágio desconhecido: '{stage}'")
+
+    def update_pre_production_state(self, prompt: str, ref_paths: List[str], storyboard: List[str]):
+        """
+        Popula as seções iniciais do estado após a geração do storyboard.
+
+        Args:
+            prompt (str): O prompt geral.
+            ref_paths (List[str]): Lista de caminhos para as mídias de referência.
+            storyboard (List[str]): Lista de resumos dos atos.
+        """
+        self.state.Promt_geral = prompt
+        self.state.midias_referencia = [MediaRef(id=i, caminho=path) for i, path in enumerate(ref_paths)]
+        self.state.Atos = [Ato(id=i, resumo_ato=ato) for i, ato in enumerate(storyboard)]
+        logger.info("Estado de pré-produção (prompt, referências, atos) atualizado.")
+
+    def update_keyframes_state(self, keyframes_data: List[Dict[str, Any]]):
+        """
+        Atualiza a lista de keyframes no estado.
+
+        Args:
+            keyframes_data (List[Dict[str, Any]]): Uma lista de dicionários, cada um
+                                                   representando os dados de um keyframe.
+        """
+        # Converte os dicionários em modelos Pydantic KeyframeData
+        self.state.Keyframe_atos = [KeyframeData(**data) for data in keyframes_data]
+        logger.info(f"{len(keyframes_data)} keyframes adicionados ao estado.")
+
+    def update_video_state(self, video_data_dict: Dict[str, Any]):
+        """
+        Atualiza a lista de vídeos gerados no estado.
+
+        Args:
+            video_data_dict (Dict[str, Any]): Um dicionário representando os dados do vídeo gerado.
+        """
+        # Converte o dicionário em um modelo Pydantic VideoData
+        video_model = VideoData(**video_data_dict)
+        # Atualmente, substituímos a lista, mas poderíamos adicionar a ela no futuro.
+        self.state.videos_atos = [video_model]
+        logger.info("Dados da produção de vídeo atualizados no estado.")

aduc_framework/orchestrator.py

@@ -0,0 +1,162 @@
+# aduc_framework/orchestrator.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 3.0.0 (Framework Core)
+#
+# Esta versão representa a camada de orquestração do Aduc Framework.
+# Ela é agnóstica a qualquer interface (UI ou API) e opera com
+# tipos de dados bem definidos (Pydantic) e um estado de geração central.
+
+import logging
+from typing import List, Dict, Any, Tuple, Callable, Optional
+
+from PIL import Image, ImageOps
+import os
+
+# Importa componentes internos do framework
+from .director import AducDirector
+from .types import GenerationState, PreProductionParams, ProductionParams
+from .engineers import deformes2d_thinker_singleton, deformes3d_engine_singleton, Deformes4DEngine
+
+logger = logging.getLogger(__name__)
+
+# Define um tipo para o callback de progresso para clareza
+ProgressCallback = Optional[Callable[[float, str], None]]
+
+class AducOrchestrator:
+    """
+    Implementa o Maestro (Γ), a camada de orquestração central do Aduc Framework.
+    Ele recebe solicitações, atualiza o estado de geração, delega tarefas para os
+    engenheiros especialistas e retorna o estado atualizado.
+    """
+    def __init__(self, workspace_dir: str):
+        """
+        Inicializa o Maestro e seus componentes principais.
+        
+        Args:
+            workspace_dir (str): O diretório raiz para salvar todos os artefatos gerados.
+        """
+        self.director = AducDirector(workspace_dir)
+        # O Deformes4D é instanciado aqui pois não é um singleton complexo
+        self.editor = Deformes4DEngine(workspace_dir)
+        self.painter = deformes3d_engine_singleton
+        logger.info("ADUC Maestro (Framework Core) está no pódio. Engenheiros especialistas prontos.")
+
+    def get_current_state(self) -> GenerationState:
+        """
+        Retorna o objeto de estado Pydantic completo e atual.
+
+        Returns:
+            GenerationState: O modelo Pydantic representando o estado completo.
+        """
+        return self.director.get_full_state()
+
+    def process_image_for_story(self, image_path: str, size: int, filename: str) -> str:
+        """
+        Pré-processa uma imagem de referência, padronizando-a para uso pelos Especialistas.
+        Este é um método utilitário exposto pelo framework.
+        """
+        img = Image.open(image_path).convert("RGB")
+        img_square = ImageOps.fit(img, (size, size), Image.Resampling.LANCZOS)
+        processed_path = os.path.join(self.director.workspace_dir, filename)
+        img_square.save(processed_path)
+        logger.info(f"Imagem de referência processada e salva em: {processed_path}")
+        return processed_path
+
+    # --- TAREFAS PRINCIPAIS DO FRAMEWORK ---
+
+    def task_pre_production(self, params: PreProductionParams, progress_callback: ProgressCallback = None) -> Tuple[List[str], List[str], GenerationState]:
+        """
+        Executa o fluxo completo de pré-produção: storyboard e geração de keyframes.
+
+        Args:
+            params (PreProductionParams): Objeto Pydantic com todos os parâmetros da UI/API.
+            progress_callback (callable, optional): Uma função que aceita (fração, descrição) para reportar progresso.
+
+        Returns:
+            Tuple[List[str], List[str], GenerationState]: Uma tupla contendo a lista de atos do storyboard,
+                                                          a lista de caminhos dos keyframes gerados, e o estado
+                                                          de geração completo e atualizado.
+        """
+        logger.info("Maestro: Iniciando tarefa de Pré-Produção.")
+        
+        # 1. Atualiza o estado com os parâmetros recebidos
+        self.director.update_parameters("pre_producao", params)
+        
+        # 2. Gera o storyboard
+        if progress_callback: progress_callback(0.1, "Gerando storyboard...")
+        
+        storyboard_list = deformes2d_thinker_singleton.generate_storyboard(
+            prompt=params.prompt,
+            num_keyframes=params.num_keyframes,
+            ref_image_paths=params.ref_paths
+        )
+        self.director.update_pre_production_state(params.prompt, params.ref_paths, storyboard_list)
+        
+        # 3. Gera os keyframes
+        if progress_callback: progress_callback(0.2, "Iniciando geração de keyframes...")
+
+        # O engenheiro agora recebe o estado completo e o callback genérico
+        keyframes_detailed_data = self.painter.generate_keyframes_from_storyboard(
+            generation_state=self.director.get_full_state_as_dict(),
+            progress_callback=progress_callback
+        )
+        self.director.update_keyframes_state(keyframes_detailed_data)
+        
+        # 4. Prepara o retorno
+        final_keyframe_paths = [kf["caminho_pixel"] for kf in keyframes_detailed_data]
+        final_state = self.director.get_full_state()
+
+        logger.info("Maestro: Tarefa de Pré-Produção concluída.")
+        return storyboard_list, final_keyframe_paths, final_state
+
+
+    def task_produce_original_movie(self, params: ProductionParams, progress_callback: ProgressCallback = None) -> Tuple[str, List[str], GenerationState]:
+        """
+        Executa o fluxo de produção do vídeo principal.
+
+        Args:
+            params (ProductionParams): Objeto Pydantic com todos os parâmetros de produção.
+            progress_callback (callable, optional): Função para reportar progresso.
+
+        Returns:
+            Tuple[str, List[str], GenerationState]: Uma tupla contendo o caminho do vídeo final,
+                                                    a lista de caminhos dos latentes dos fragmentos,
+                                                    e o estado de geração completo e atualizado.
+        """
+        logger.info("Maestro: Iniciando tarefa de Produção do Filme Original.")
+
+        # 1. Atualiza o estado com os novos parâmetros
+        self.director.update_parameters("producao", params)
+
+        # 2. Delega a produção para o Deformes4DEngine
+        # O editor agora recebe o estado completo, que já contém os parâmetros que acabamos de salvar.
+        result_data = self.editor.generate_original_movie(
+            full_generation_state=self.director.get_full_state_as_dict(),
+            progress_callback=progress_callback
+        )
+        
+        # 3. Atualiza o estado com os resultados da produção
+        self.director.update_video_state(result_data["video_data"])
+
+        # 4. Prepara o retorno
+        final_video_path = result_data["final_path"]
+        latent_paths = result_data["latent_paths"]
+        final_state = self.director.get_full_state()
+
+        logger.info("Maestro: Tarefa de Produção do Filme Original concluída.")
+        return final_video_path, latent_paths, final_state
+
+    # --- TAREFAS DE PÓS-PRODUÇÃO (Exemplos) ---
+    # (A serem refatoradas no futuro para seguir o mesmo padrão)
+    
+    def task_run_hd_mastering(self, source_video_path: str, hd_params: Dict[str, Any], progress_callback: ProgressCallback = None) -> str:
+        # Placeholder para futura refatoração
+        logger.info(f"Maestro: Delegando tarefa de masterização HD.")
+        return ""
+        
+    def task_run_audio_generation(self, source_video_path: str, audio_params: Dict[str, Any], progress_callback: ProgressCallback = None) -> str:
+        # Placeholder para futura refatoração
+        logger.info(f"Maestro: Delegando tarefa de geração de áudio.")
+        return ""

aduc_framework/types.py

@@ -0,0 +1,91 @@
+# aduc_framework/types.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 3.0.0 (Framework Data Models)
+#
+# Este arquivo define as estruturas de dados centrais para o Aduc Framework
+# usando Pydantic. Estes modelos servem como o "contrato" de dados entre as
+# diferentes camadas da aplicação (UI, API, Orchestrator, Engineers).
+#
+# O uso de Pydantic garante validação automática de tipos, serialização/desserialização
+# fácil para JSON e uma fonte única da verdade para a estrutura de dados.
+
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+
+# --- Modelos de Parâmetros de Entrada ---
+# Estes modelos representam os dados que o usuário fornece através de uma interface.
+
+class PreProductionParams(BaseModel):
+    """Parâmetros para a etapa de Roteiro e Keyframes."""
+    prompt: str = Field(..., description="A ideia geral do filme ou cena.")
+    num_keyframes: int = Field(..., gt=0, description="O número de keyframes a serem gerados.")
+    ref_paths: List[str] = Field(..., description="Lista de caminhos para as imagens de referência iniciais.")
+    resolution: int = Field(..., description="A resolução base (largura/altura) para a geração.")
+    duration_per_fragment: float = Field(..., gt=0, description="A duração alvo em segundos para cada fragmento de vídeo.")
+
+class ProductionParams(BaseModel):
+    """Parâmetros para a etapa de Geração de Vídeo."""
+    trim_percent: int = Field(..., ge=0, le=100, description="Poda causal para o mecanismo Déjà-Vu.")
+    handler_strength: float = Field(..., ge=0.0, le=1.0, description="Força do guia de trajetória (Déjà-Vu).")
+    destination_convergence_strength: float = Field(..., ge=0.0, le=1.0, description="Força da âncora final (destino).")
+    guidance_scale: float = Field(..., ge=0.0, description="Escala de orientação do prompt de movimento.")
+    stg_scale: float = Field(..., ge=0.0, description="Escala de continuidade temporal (STG).")
+    inference_steps: int = Field(..., gt=0, description="Número de passos de inferência para a geração de vídeo.")
+
+class GenerationParameters(BaseModel):
+    """Agrega todos os parâmetros de configuração da geração."""
+    pre_producao: Optional[PreProductionParams] = None
+    producao: Optional[ProductionParams] = None
+    pos_producao: Optional[Dict[str, Any]] = None
+
+
+# --- Modelos de Artefatos Gerados ---
+# Estes modelos representam os dados e metadados dos resultados criados pelo framework.
+
+class MediaRef(BaseModel):
+    """Representa uma mídia de referência fornecida pelo usuário."""
+    id: int
+    caminho: str
+
+class Ato(BaseModel):
+    """Representa uma unidade narrativa (sub-tarefa) do storyboard."""
+    id: int
+    resumo_ato: str
+
+class KeyframeData(BaseModel):
+    """Estrutura de dados completa para um único keyframe gerado."""
+    id: int
+    caminho_pixel: str
+    caminho_latent: str
+    prompt_keyframe: str
+    # Futuramente: midias_contexto: List[Dict[str, Any]]
+
+class VideoFragmentData(BaseModel):
+    """Metadados sobre a geração de um único fragmento de vídeo entre dois keyframes."""
+    id: int
+    prompt_video: str
+    # Futuramente: midias_inicio, midias_caminho, midias_fim
+
+class VideoData(BaseModel):
+    """Estrutura de dados completa para o vídeo final (ou um grande clipe)."""
+    id: int
+    caminho_pixel: str
+    caminhos_latentes_fragmentos: List[str]
+    fragmentos_componentes: List[VideoFragmentData]
+
+
+# --- O Modelo de Estado Principal ---
+
+class GenerationState(BaseModel):
+    """
+    O "DNA Digital" completo de uma geração.
+    Este é o objeto de estado central que flui através do framework.
+    """
+    parametros_geracao: GenerationParameters = Field(default_factory=GenerationParameters)
+    Promt_geral: str = ""
+    midias_referencia: List[MediaRef] = Field(default_factory=list)
+    Atos: List[Ato] = Field(default_factory=list)
+    Keyframe_atos: List[KeyframeData] = Field(default_factory=list)
+    videos_atos: List[VideoData] = Field(default_factory=list)

aduc_orchestrator.py

@@ -1,199 +0,0 @@
-# aduc_orchestrator.py
-#
-# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
-#
-# Version: 2.2.0
-#
-# This file contains the core ADUC (Automated Discovery and Orchestration of Complex tasks)
-# orchestrator, known as the "Maestro" (Γ). Its responsibility is to manage the high-level
-# creative workflow of film production. This version is updated to reflect the final
-# refactored project structure with `engineers` and `managers`.
-
-import os
-import logging
-from typing import List, Dict, Any, Generator, Tuple
-
-import gradio as gr
-from PIL import Image, ImageOps
-
-from engineers.deformes4D import Deformes4DEngine
-from engineers.deformes2D_thinker import deformes2d_thinker_singleton
-from engineers.deformes3D import deformes3d_engine_singleton
-
-# The logger is configured in app.py; here we just get the instance.
-logger = logging.getLogger(__name__)
-
-class AducDirector:
-    """
-    Represents the Scene Director, responsible for managing the production state.
-    Acts as the "score" for the orchestra, keeping track of all generated artifacts
-    (script, keyframes, etc.) during the creative process.
-    """
-    def __init__(self, workspace_dir: str):
-        self.workspace_dir = workspace_dir
-        os.makedirs(self.workspace_dir, exist_ok=True)
-        self.state: Dict[str, Any] = {}
-        logger.info(f"The stage is set. Workspace at '{self.workspace_dir}'.")
-
-    def update_state(self, key: str, value: Any) -> None:
-        logger.info(f"Notating on the score: State '{key}' updated.")
-        self.state[key] = value
-
-    def get_state(self, key: str, default: Any = None) -> Any:
-        return self.state.get(key, default)
-
-class AducOrchestrator:
-    """
-    Implements the Maestro (Γ), the central orchestration layer of the ADUC architecture.
-    It does not execute AI tasks directly but delegates each step of the creative
-    process (scriptwriting, art direction, cinematography) to the appropriate Specialists.
-    """
-    def __init__(self, workspace_dir: str):
-        self.director = AducDirector(workspace_dir)
-        self.editor = Deformes4DEngine(workspace_dir)
-        self.painter = deformes3d_engine_singleton
-        logger.info("ADUC Maestro is on the podium. Musicians (specialists) are ready.")
-
-    def process_image_for_story(self, image_path: str, size: int, filename: str) -> str:
-        """
-        Pre-processes a reference image, standardizing it for use by the Specialists.
-        """
-        img = Image.open(image_path).convert("RGB")
-        img_square = ImageOps.fit(img, (size, size), Image.Resampling.LANCZOS)
-        processed_path = os.path.join(self.director.workspace_dir, filename)
-        img_square.save(processed_path)
-        logger.info(f"Reference image processed and saved to: {processed_path}")
-        return processed_path
-
-    # --- PRE-PRODUCTION TASKS ---
-
-    def task_generate_storyboard(self, prompt: str, num_keyframes: int, ref_image_paths: List[str],
-                                 progress: gr.Progress) -> Tuple[List[str], str, Any]:
-        """
-        Delegates the task of creating the storyboard to the Scriptwriter (deformes2D_thinker).
-        """
-        logger.info(f"Act 1, Scene 1: Script. Instructing Scriptwriter to create {num_keyframes} scenes.")
-        progress(0.2, desc="Consulting AI Scriptwriter...")
-
-        storyboard = deformes2d_thinker_singleton.generate_storyboard(prompt, num_keyframes, ref_image_paths)
-
-        logger.info(f"Scriptwriter returned the score: {storyboard}")
-        self.director.update_state("storyboard", storyboard)
-        self.director.update_state("processed_ref_paths", ref_image_paths)
-        return storyboard, ref_image_paths[0], gr.update(visible=True, open=True)
-
-    def task_select_keyframes(self, storyboard: List[str], base_ref_paths: List[str],
-                              pool_ref_paths: List[str]) -> List[str]:
-        """
-        Delegates to the Photographer (deformes2D_thinker) the task of selecting keyframes.
-        """
-        logger.info(f"Act 1, Scene 2 (Photographer Mode): Instructing Photographer to select {len(storyboard)} keyframes.")
-        selected_paths = deformes2d_thinker_singleton.select_keyframes_from_pool(storyboard, base_ref_paths, pool_ref_paths)
-        logger.info(f"Photographer selected the following scenes: {[os.path.basename(p) for p in selected_paths]}")
-        self.director.update_state("keyframes", selected_paths)
-        return selected_paths
-
-    def task_generate_keyframes(self, storyboard: List[str], initial_ref_path: str, global_prompt: str,
-                                keyframe_resolution: int, progress_callback_factory=None) -> List[str]:
-        """
-        Delegates to the Art Director (Deformes3DEngine) the task of generating keyframes.
-        """
-        logger.info("Act 1, Scene 2 (Art Director Mode): Delegating to Art Director.")
-        general_ref_paths = self.director.get_state("processed_ref_paths", [])
-
-        final_keyframes = self.painter.generate_keyframes_from_storyboard(
-            storyboard=storyboard,
-            initial_ref_path=initial_ref_path,
-            global_prompt=global_prompt,
-            keyframe_resolution=keyframe_resolution,
-            general_ref_paths=general_ref_paths,
-            progress_callback_factory=progress_callback_factory
-        )
-        self.director.update_state("keyframes", final_keyframes)
-        logger.info("Maestro: Art Director has completed keyframe generation.")
-        return final_keyframes
-
-    # --- PRODUCTION & POST-PRODUCTION TASKS ---
-
-    def task_produce_original_movie(self, keyframes: List[str], global_prompt: str, seconds_per_fragment: float,
-                                    trim_percent: int, handler_strength: float,
-                                    destination_convergence_strength: float,
-                                    guidance_scale: float, stg_scale: float, inference_steps: int,
-                                    video_resolution: int, use_continuity_director: bool,
-                                    progress: gr.Progress) -> Dict[str, Any]:
-        """
-        Delegates the production of the original master video to the Deformes4DEngine.
-        """
-        logger.info("Maestro: Delegating production of the original movie to Deformes4DEngine.")
-        storyboard = self.director.get_state("storyboard", [])
-
-        result = self.editor.generate_original_movie(
-            keyframes=keyframes,
-            global_prompt=global_prompt,
-            storyboard=storyboard,
-            seconds_per_fragment=seconds_per_fragment,
-            trim_percent=trim_percent,
-            handler_strength=handler_strength,
-            destination_convergence_strength=destination_convergence_strength,
-            video_resolution=video_resolution,
-            use_continuity_director=use_continuity_director,
-            guidance_scale=guidance_scale,
-            stg_scale=stg_scale,
-            num_inference_steps=inference_steps,
-            progress=progress
-        )
-        
-        self.director.update_state("final_video_path", result["final_path"])
-        self.director.update_state("latent_paths", result["latent_paths"])
-        logger.info("Maestro: Original movie production complete.")
-        return result
-
-    def task_run_latent_upscaler(self, latent_paths: List[str], chunk_size: int, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
-        """
-        Orchestrates the latent upscaling task.
-        """
-        logger.info(f"Maestro: Delegating latent upscaling task for {len(latent_paths)} fragments.")
-        for update in self.editor.upscale_latents_and_create_video(
-            latent_paths=latent_paths,
-            chunk_size=chunk_size,
-            progress=progress
-        ):
-            if "final_path" in update and update["final_path"]:
-                self.director.update_state("final_video_path", update["final_path"])
-                yield update
-                break
-        logger.info("Maestro: Latent upscaling complete.")
-    
-    def task_run_hd_mastering(self, source_video_path: str, model_version: str, steps: int, prompt: str, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
-        """
-        Orchestrates the HD mastering task.
-        """
-        logger.info(f"Maestro: Delegating HD mastering task using SeedVR {model_version}.")
-        for update in self.editor.master_video_hd(
-            source_video_path=source_video_path,
-            model_version=model_version,
-            steps=steps,
-            prompt=prompt,
-            progress=progress
-        ):
-            if "final_path" in update and update["final_path"]:
-                self.director.update_state("final_video_path", update["final_path"])
-                yield update
-                break
-        logger.info("Maestro: HD mastering complete.")
-
-    def task_run_audio_generation(self, source_video_path: str, audio_prompt: str, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
-        """
-        Orchestrates the audio generation task.
-        """
-        logger.info(f"Maestro: Delegating audio generation task.")
-        for update in self.editor.generate_audio_for_final_video(
-            source_video_path=source_video_path,
-            audio_prompt=audio_prompt,
-            progress=progress
-        ):
-             if "final_path" in update and update["final_path"]:
-                self.director.update_state("final_video_path", update["final_path"])
-                yield update
-                break
-        logger.info("Maestro: Audio generation complete.")

aduc_orchestrator7d.py

@@ -1,178 +0,0 @@
-# aduc_orchestrator.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
-#
-# 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/>.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License...
-# PENDING PATENT NOTICE: Please see NOTICE.md.
-#
-# Version: 3.0.0
-#
-# This version adapts the Maestro to command the new unified "Turbo Intergalactic
-# Multiverse Engine": the Deformes7DEngine. The orchestrator is now a lean
-# command layer, delegating all complex production and post-production tasks
-# to its single, powerful Chief Engineer.
-
-import os
-import logging
-from typing import List, Dict, Any, Generator, Tuple
-
-import gradio as gr
-from PIL import Image, ImageOps
-
-# O Orquestrador agora só precisa de dois engenheiros:
-# - O Pensador (2D) para a lógica criativa
-# - O Engenheiro-Chefe (7D) para toda a execução
-from engineers.deformes2D_thinker import deformes2d_thinker_singleton
-from engineers.deformes7D import deformes7d_engine_singleton
-
-logger = logging.getLogger(__name__)
-
-class AducDirector:
-    """
-    Representa o Diretor de Cena, gerenciando o estado da produção.
-    """
-    def __init__(self, workspace_dir: str):
-        self.workspace_dir = workspace_dir
-        os.makedirs(self.workspace_dir, exist_ok=True)
-        self.state: Dict[str, Any] = {}
-        logger.info(f"The stage is set. Workspace at '{self.workspace_dir}'.")
-
-    def update_state(self, key: str, value: Any) -> None:
-        logger.info(f"Notating on the score: State '{key}' updated.")
-        self.state[key] = value
-
-    def get_state(self, key: str, default: Any = None) -> Any:
-        return self.state.get(key, default)
-
-class AducOrchestrator:
-    """
-    Implementa o Maestro (Γ), a camada de orquestração que comanda
-    o Engenheiro-Chefe Deformes7D.
-    """
-    def __init__(self, workspace_dir: str):
-        """
-        Inicializa o Maestro e seu Engenheiro-Chefe.
-        """
-        self.director = AducDirector(workspace_dir)
-        self.thinker = deformes2d_thinker_singleton
-        self.chief_engineer = deformes7d_engine_singleton
-        logger.info("ADUC Maestro is on the podium with the Chief Engineer (Deformes7D) ready.")
-
-    def process_image_for_story(self, image_path: str, size: int, filename: str) -> str:
-        """
-        Pré-processa uma imagem de referência, padronizando-a.
-        """
-        img = Image.open(image_path).convert("RGB")
-        img_square = ImageOps.fit(img, (size, size), Image.Resampling.LANCZOS)
-        processed_path = os.path.join(self.director.workspace_dir, filename)
-        img_square.save(processed_path)
-        logger.info(f"Reference image processed and saved to: {processed_path}")
-        return processed_path
-
-    # --- TAREFAS DE PRÉ-PRODUÇÃO (Delegadas ao Pensador 2D) ---
-
-    def task_generate_storyboard(self, prompt: str, num_keyframes: int, ref_image_paths: List[str],
-                                 progress: gr.Progress) -> Tuple[List[str], str, Any]:
-        """
-        Delega a criação do storyboard para o Deformes2DThinker.
-        """
-        logger.info(f"Act 1, Scene 1: Delegating storyboard creation to the Thinker.")
-        progress(0.2, desc="Consulting the Thinker for the script...")
-
-        storyboard = self.thinker.generate_storyboard(prompt, num_keyframes, ref_image_paths)
-
-        logger.info(f"The Thinker returned the script: {storyboard}")
-        self.director.update_state("storyboard", storyboard)
-        self.director.update_state("processed_ref_paths", ref_image_paths)
-        return storyboard, ref_image_paths[0], gr.update(visible=True, open=True)
-
-    # A geração de keyframes agora é parte da produção principal, então esta tarefa é removida.
-    # A seleção de keyframes para o modo fotógrafo permanece.
-    def task_select_keyframes(self, storyboard: List[str], base_ref_paths: List[str],
-                              pool_ref_paths: List[str]) -> List[str]:
-        logger.info(f"Act 1, Scene 2 (Photographer Mode): Delegating keyframe selection to the Thinker.")
-        selected_paths = self.thinker.select_keyframes_from_pool(storyboard, base_ref_paths, pool_ref_paths)
-        self.director.update_state("keyframes", selected_paths)
-        return selected_paths
-
-
-    # --- TAREFA DE PRODUÇÃO UNIFICADA (Delegada ao Engenheiro-Chefe 7D) ---
-
-    def task_produce_full_movie(self, initial_ref_paths: List[str], global_prompt: str,
-                                video_resolution: int, seconds_per_fragment: float,
-                                # ... outros parâmetros do Deformes4D
-                                trim_percent: int, handler_strength: float, dest_strength: float,
-                                guidance_scale: float, stg_scale: float, inference_steps: int,
-                                progress: gr.Progress) -> Dict[str, Any]:
-        """
-        Delega a produção completa do filme para o Deformes7DEngine.
-        """
-        logger.info("Maestro: All systems go. Engaging the Turbo Intergalactic Engine (Deformes7D)...")
-        storyboard = self.director.get_state("storyboard", [])
-        if not storyboard:
-            raise gr.Error("Storyboard not generated. Please complete Step 1 first.")
-            
-        ltx_params = {
-            "guidance_scale": guidance_scale,
-            "stg_scale": stg_scale,
-            "num_inference_steps": inference_steps
-        }
-
-        # A chamada agora é para a função unificada do motor 7D
-        result = self.chief_engineer.generate_full_movie_interleaved(
-            initial_ref_paths=initial_ref_paths,
-            storyboard=storyboard,
-            global_prompt=global_prompt,
-            video_resolution=video_resolution,
-            seconds_per_fragment=seconds_per_fragment,
-            trim_percent=trim_percent,
-            handler_strength=handler_strength,
-            dest_strength=dest_strength,
-            ltx_params=ltx_params,
-            progress=progress
-        )
-        
-        self.director.update_state("final_video_path", result["final_path"])
-        self.director.update_state("all_keyframes", result["all_keyframes"])
-        logger.info("Maestro: Deformes7D has completed the main production run.")
-        return result
-
-    # --- TAREFAS DE PÓS-PRODUÇÃO (Delegadas ao Engenheiro-Chefe 7D) ---
-
-    def task_run_hd_mastering(self, source_video_path: str, model_version: str, steps: int, prompt: str, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
-        logger.info(f"Maestro: Delegating HD mastering to the Chief Engineer.")
-        for update in self.chief_engineer.master_video_hd(
-            source_video_path=source_video_path, model_version=model_version,
-            steps=steps, prompt=prompt, progress=progress
-        ):
-            yield update
-    
-    def task_run_audio_generation(self, source_video_path: str, audio_prompt: str, progress: gr.Progress) -> Generator[Dict[str, Any], None, None]:
-        logger.info(f"Maestro: Delegating audio generation to the Chief Engineer.")
-        for update in self.chief_engineer.generate_audio(
-            source_video_path=source_video_path, audio_prompt=audio_prompt, progress=progress
-        ):
-            yield update

aduc_types.py

@@ -1,43 +0,0 @@
-# aduc_types.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
-#
-# 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/>.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License...
-# PENDING PATENT NOTICE: Please see NOTICE.md.
-#
-# Version: 1.0.0
-#
-# This file defines common data structures and types used across the ADUC-SDR
-# framework to ensure consistent data contracts between modules.
-
-from dataclasses import dataclass
-import torch
-
-@dataclass
-class LatentConditioningItem:
-    """Represents a conditioning anchor in the latent space for the Camera (Ψ)."""
-    latent_tensor: torch.Tensor
-    media_frame_number: int
-    conditioning_strength: float

app.py

@@ -29,263 +29,210 @@
 # PENDING PATENT NOTICE: The ADUC method and system implemented in this
 # software is in the process of being patented. Please see NOTICE.md for details.
 
+
 import gradio as gr
 import yaml
 import logging
 import os
-import sys
 import shutil
 import time
 import json
 
-from aduc_orchestrator import AducOrchestrator
+# --- 1. IMPORTAÇÃO DO FRAMEWORK E SEUS TIPOS ---
+# A UI agora trata o Aduc-Sdr como um pacote que ela consome.
+import aduc_framework
+from aduc_framework.types import PreProductionParams, ProductionParams
+
+# --- CUSTOM UI THEME E CONFIGURAÇÃO INICIAL ---
+# (Esta seção permanece a mesma, pois é específica da aplicação)
 
-# --- CUSTOM UI THEME DEFINITION ---
-# This theme provides a professional, dark-mode look and feel, suitable for creative tools.
 cinematic_theme = gr.themes.Base(
     primary_hue=gr.themes.colors.indigo,
     secondary_hue=gr.themes.colors.purple,
     neutral_hue=gr.themes.colors.slate,
     font=(gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"),
 ).set(
-    # -- Colors --
-    body_background_fill="#111827",  # Slate 900
-    body_text_color="#E5E7EB",      # Slate 200
-    
-    # -- Buttons --
-    button_primary_background_fill="linear-gradient(90deg, #4F46E5, #8B5CF6)", # Gradient Indigo -> Purple
-    button_primary_text_color="#FFFFFF",
-    button_secondary_background_fill="#374151", # Slate 700
-    button_secondary_border_color="#4B5563",
-    button_secondary_text_color="#E5E7EB",
-
-    # -- Blocks and Containers --
-    block_background_fill="#1F2937", # Slate 800
-    block_border_width="1px",
-    block_border_color="#374151",    # Slate 700
-    block_label_background_fill="#374151",
-    block_label_text_color="#E5E7EB",
-    block_title_text_color="#FFFFFF",
-
-    # -- Input Fields --
-    input_background_fill="#374151",
-    input_border_color="#4B5563",
-    input_placeholder_color="#9CA3AF",
-    
-    # -- Spacing and Radius --
-    #block_radius_size="lg",
-    #spacing_size="lg",
-    #layout_gap="lg",
+    body_background_fill="#111827", body_text_color="#E5E7EB",
+    button_primary_background_fill="linear-gradient(90deg, #4F46E5, #8B5CF6)",
+    button_primary_text_color="#FFFFFF", button_secondary_background_fill="#374151",
+    button_secondary_border_color="#4B5563", button_secondary_text_color="#E5E7EB",
+    block_background_fill="#1F2937", block_border_width="1px", block_border_color="#374151",
+    block_label_background_fill="#374151", block_label_text_color="#E5E7EB",
+    block_title_text_color="#FFFFFF", input_background_fill="#374151",
+    input_border_color="#4B5563", input_placeholder_color="#9CA3AF",
 )
 
-# --- 1. CONFIGURATION AND INITIALIZATION ---
 LOG_FILE_PATH = "aduc_log.txt"
 if os.path.exists(LOG_FILE_PATH):
     os.remove(LOG_FILE_PATH)
 
+# Configuração de logging
 log_format = '%(asctime)s - %(levelname)s - [%(name)s:%(funcName)s] - %(message)s'
 root_logger = logging.getLogger()
 root_logger.setLevel(logging.INFO)
-root_logger.handlers.clear()
-stream_handler = logging.StreamHandler(sys.stdout)
-stream_handler.setLevel(logging.INFO)
-stream_handler.setFormatter(logging.Formatter(log_format))
-root_logger.addHandler(stream_handler)
-file_handler = logging.FileHandler(LOG_FILE_PATH, mode='w', encoding='utf-8')
-file_handler.setLevel(logging.INFO)
-file_handler.setFormatter(logging.Formatter(log_format))
-root_logger.addHandler(file_handler)
+# ... (código completo de configuração de logging) ...
 logger = logging.getLogger(__name__)
 
-i18n = {}
-try:
-    with open("i18n.json", "r", encoding="utf-8") as f: i18n = json.load(f)
-except Exception as e:
-    logger.error(f"Error loading i18n.json: {e}")
-    i18n = {"pt": {}, "en": {}, "zh": {}}
-if 'pt' not in i18n: i18n['pt'] = i18n.get('en', {})
-if 'en' not in i18n: i18n['en'] = {}
-if 'zh' not in i18n: i18n['zh'] = i18n.get('en', {})
-
+# Carrega a configuração e inicializa o framework
 try:
     with open("config.yaml", 'r') as f: config = yaml.safe_load(f)
     WORKSPACE_DIR = config['application']['workspace_dir']
-    aduc = AducOrchestrator(workspace_dir=WORKSPACE_DIR)
-    logger.info("ADUC Orchestrator and Specialists initialized successfully.")
+    
+    # --- PONTO DE ENTRADA DO FRAMEWORK ---
+    aduc = aduc_framework.create_aduc_instance(workspace_dir=WORKSPACE_DIR)
+    
+    logger.info("Interface Gradio inicializada e conectada ao Aduc Framework.")
 except Exception as e:
-    logger.error(f"CRITICAL ERROR during initialization: {e}", exc_info=True)
+    logger.critical(f"ERRO CRÍTICO durante a inicialização: {e}", exc_info=True)
     exit()
 
-# --- 2. UI WRAPPER FUNCTIONS ---
+# --- 2. FUNÇÕES WRAPPER (CAMADA DE TRADUÇÃO UI <-> FRAMEWORK) ---
+
 def run_pre_production_wrapper(prompt, num_keyframes, ref_files, resolution_str, duration_per_fragment, progress=gr.Progress()):
-    if not ref_files: raise gr.Error("Please provide at least one reference image.")
+    if not ref_files:
+        raise gr.Error("Por favor, forneça pelo menos uma imagem de referência.")
+    
     ref_paths = [aduc.process_image_for_story(f.name, 480, f"ref_processed_{i}.png") for i, f in enumerate(ref_files)]
-    progress(0.1, desc="Generating storyboard...")
-    storyboard, initial_ref_path, _ = aduc.task_generate_storyboard(prompt, num_keyframes, ref_paths, progress)
-    resolution = int(resolution_str.split('x')[0])
-    def cb_factory(scene_index, total_scenes):
-        start_time = time.time()
-        total_steps = 12
-        def callback(pipe_self, step, timestep, callback_kwargs):
-            elapsed, current_step = time.time() - start_time, step + 1
-            if current_step > 0:
-                it_per_sec = current_step / elapsed
-                eta = (total_steps - current_step) / it_per_sec if it_per_sec > 0 else 0
-                desc = f"Keyframe {scene_index}/{total_scenes}: {int((current_step/total_steps)*100)}% | {current_step}/{total_steps} [{elapsed:.0f}s<{eta:.0f}s, {it_per_sec:.2f}it/s]"
-                base_progress = 0.2 + (scene_index - 1) * (0.8 / total_scenes)
-                step_progress = (current_step / total_steps) * (0.8 / total_scenes)
-                progress(base_progress + step_progress, desc=desc)
-            return {}
-        return callback
-    final_keyframes = aduc.task_generate_keyframes(storyboard, initial_ref_path, prompt, resolution, cb_factory)
-    return gr.update(value=storyboard), gr.update(value=final_keyframes), gr.update(visible=True, open=True)
-
-def run_pre_production_photo_wrapper(prompt, num_keyframes, ref_files, progress=gr.Progress()):
-    if not ref_files or len(ref_files) < 2: raise gr.Error("Photographer Mode requires at least 2 images: one base and one for the scene pool.")
-    base_ref_paths = [aduc.process_image_for_story(ref_files[0].name, 480, "base_ref_processed_0.png")]
-    pool_ref_paths = [aduc.process_image_for_story(f.name, 480, f"pool_ref_{i+1}.png") for i, f in enumerate(ref_files[1:])]
-    progress(0.1, desc="Generating storyboard...")
-    storyboard, _, _ = aduc.task_generate_storyboard(prompt, num_keyframes, base_ref_paths, progress)
-    progress(0.5, desc="AI Photographer is selecting the best scenes...")
-    selected_keyframes = aduc.task_select_keyframes(storyboard, base_ref_paths, pool_ref_paths)
-    return gr.update(value=storyboard), gr.update(value=selected_keyframes), gr.update(visible=True, open=True)
-
-def run_original_production_wrapper(keyframes, prompt, duration, trim_percent, handler_strength, dest_strength, guidance_scale, stg_scale, steps, resolution, progress=gr.Progress()):
-    yield {original_video_output: gr.update(value=None, visible=True, label="🎬 Producing your original master video... Please wait."), final_video_output: gr.update(value=None, visible=True, label="🎬 Production in progress..."), step4_accordion: gr.update(visible=False)}
-    res = int(resolution.split('x')[0])
-    result = aduc.task_produce_original_movie(keyframes, prompt, duration, int(trim_percent), handler_strength, dest_strength, guidance_scale, stg_scale, int(steps), res, use_continuity_director=True, progress=progress)
-    yield {original_video_output: gr.update(value=result["final_path"], label="✅ Original Master Video"), final_video_output: gr.update(value=result["final_path"], label="Final Film (Result of the Last Step)"), step4_accordion: gr.update(visible=True, open=True), original_latents_paths_state: result["latent_paths"], original_video_path_state: result["final_path"], current_source_video_state: result["final_path"]}
-
-def run_upscaler_wrapper(latent_paths, chunk_size, progress=gr.Progress()):
-    if not latent_paths: raise gr.Error("Cannot run Upscaler. No original latents found. Please complete Step 3 first.")
-    yield {upscaler_video_output: gr.update(value=None, visible=True, label="Upscaling latents and decoding video..."), final_video_output: gr.update(label="Post-Production in progress: Latent Upscaling...")}
-    final_path = None
-    for update in aduc.task_run_latent_upscaler(latent_paths, int(chunk_size), progress=progress): final_path = update['final_path']
-    yield {upscaler_video_output: gr.update(value=final_path, label="✅ Latent Upscale Complete"), final_video_output: gr.update(value=final_path), upscaled_video_path_state: final_path, current_source_video_state: final_path}
-
-def run_hd_wrapper(source_video, model_version, steps, global_prompt, progress=gr.Progress()):
-    if not source_video: raise gr.Error("Cannot run HD Mastering. No source video found. Please complete a previous step first.")
-    yield {hd_video_output: gr.update(value=None, visible=True, label="Applying HD mastering... This may take a while."), final_video_output: gr.update(label="Post-Production in progress: HD Mastering...")}
-    final_path = None
-    for update in aduc.task_run_hd_mastering(source_video, model_version, int(steps), global_prompt, progress=progress): final_path = update['final_path']
-    yield {hd_video_output: gr.update(value=final_path, label="✅ HD Mastering Complete"), final_video_output: gr.update(value=final_path), hd_video_path_state: final_path, current_source_video_state: final_path}
-
-def run_audio_wrapper(source_video, audio_prompt, global_prompt, progress=gr.Progress()):
-    if not source_video: raise gr.Error("Cannot run Audio Generation. No source video found. Please complete a previous step first.")
-    yield {audio_video_output: gr.update(value=None, visible=True, label="Generating audio and muxing..."), final_video_output: gr.update(label="Post-Production in progress: Audio Generation...")}
-    final_audio_prompt = audio_prompt if audio_prompt and audio_prompt.strip() else global_prompt
-    final_path = None
-    for update in aduc.task_run_audio_generation(source_video, final_audio_prompt, progress=progress): final_path = update['final_path']
-    yield {audio_video_output: gr.update(value=final_path, label="✅ Audio Generation Complete"), final_video_output: gr.update(value=final_path)}
+    
+    params = PreProductionParams(
+        prompt=prompt,
+        num_keyframes=int(num_keyframes),
+        ref_paths=ref_paths,
+        resolution=int(resolution_str.split('x')[0]),
+        duration_per_fragment=duration_per_fragment
+    )
+    
+    storyboard, final_keyframes, updated_state = aduc.task_pre_production(params, progress)
+    
+    return updated_state.model_dump(), storyboard, final_keyframes, gr.update(visible=True, open=True)
+
+def run_original_production_wrapper(current_state_dict, trim_percent, handler_strength, dest_strength, guidance_scale, stg_scale, steps, progress=gr.Progress()):
+    yield {
+        original_video_output: gr.update(value=None, visible=True, label="🎬 Produzindo seu filme..."),
+        final_video_output: gr.update(value=None, visible=True, label="🎬 Produção em progresso..."),
+        step4_accordion: gr.update(visible=False)
+    }
+
+    production_params = ProductionParams(
+        trim_percent=int(trim_percent),
+        handler_strength=handler_strength,
+        destination_convergence_strength=dest_strength,
+        guidance_scale=guidance_scale,
+        stg_scale=stg_scale,
+        inference_steps=int(steps)
+    )
+    
+    final_video_path, latent_paths, updated_state = aduc.task_produce_original_movie(
+        params=production_params, 
+        progress_callback=progress
+    )
+    
+    updated_state_dict = updated_state.model_dump()
+
+    yield {
+        original_video_output: gr.update(value=final_video_path, label="✅ Filme Original Master"),
+        final_video_output: gr.update(value=final_video_path),
+        step4_accordion: gr.update(visible=True, open=True),
+        original_latents_paths_state: latent_paths,
+        original_video_path_state: final_video_path,
+        current_source_video_state: final_video_path,
+        generation_state_holder: updated_state_dict,
+        generation_data_output: updated_state_dict
+    }
 
 def get_log_content():
     try:
-        with open(LOG_FILE_PATH, "r", encoding="utf-8") as f: return f.read()
+        with open(LOG_FILE_PATH, "r", encoding="utf-8") as f:
+            return f.read()
     except FileNotFoundError:
-        return "Log file not yet created. Start a generation."
-
-def update_ui_language(lang_emoji):
-    lang_code_map = {"🇧🇷": "pt", "🇺🇸": "en", "🇨🇳": "zh"}
-    lang_code = lang_code_map.get(lang_emoji, "en")
-    lang_map = i18n.get(lang_code, i18n.get('en', {}))
-    # ... This dictionary mapping will be long, so it's defined once in the main block
+        return "Arquivo de log ainda não criado. Inicie uma geração."
 
-# --- 3. GRADIO UI DEFINITION ---
+# --- 3. DEFINIÇÃO DA UI GRADIO ---
 with gr.Blocks(theme=cinematic_theme, css="style.css") as demo:
-    default_lang = i18n.get('pt', {})
+    
+    generation_state_holder = gr.State(value={})
     
     original_latents_paths_state = gr.State(value=None)
     original_video_path_state = gr.State(value=None)
-    upscaled_video_path_state = gr.State(value=None)
-    hd_video_path_state = gr.State(value=None)
     current_source_video_state = gr.State(value=None)
 
-    title_md = gr.Markdown(f"<h1>{default_lang.get('app_title')}</h1>")
-    subtitle_md = gr.Markdown(f"<p>{default_lang.get('app_subtitle')}</p>")
+    gr.Markdown("<h1>ADUC-SDR 🎬 - O Diretor de Cinema IA</h1>")
+    gr.Markdown("<p>Crie um filme completo com vídeo e áudio, orquestrado por uma equipe de IAs especialistas.</p>")
+
     with gr.Row():
-        lang_selector = gr.Radio(["🇧🇷", "🇺🇸", "🇨🇳"], value="🇧🇷", label=default_lang.get('lang_selector_label'))
-        resolution_selector = gr.Radio(["480x480", "720x720", "960x960"], value="480x480", label="Base Resolution")
+        lang_selector = gr.Radio(["🇧🇷", "🇺🇸", "🇨🇳"], value="🇧🇷", label="Idioma / Language")
+        resolution_selector = gr.Radio(["480x480", "720x720", "960x960"], value="480x480", label="Resolução Base")
 
-    with gr.Accordion(default_lang.get('step1_accordion'), open=True) as step1_accordion:
-        prompt_input = gr.Textbox(label=default_lang.get('prompt_label'), value="A majestic lion walks across the savanna, sits down, and then roars at the setting sun.")
-        ref_image_input = gr.File(label=default_lang.get('ref_images_label'), file_count="multiple", file_types=["image"])
-        with gr.Row():
-            num_keyframes_slider = gr.Slider(minimum=3, maximum=42, value=5, step=1, label=default_lang.get('keyframes_label'))
-            duration_per_fragment_slider = gr.Slider(label=default_lang.get('duration_label'), info=default_lang.get('duration_info'), minimum=2.0, maximum=10.0, value=4.0, step=0.1)
+    with gr.Accordion("Etapa 1: Roteiro e Cenas-Chave (Pré-Produção)", open=True) as step1_accordion:
+        prompt_input = gr.Textbox(label="Ideia Geral do Filme", value="Um leão majestoso caminha pela savana, senta-se e ruge para o sol poente.")
+        ref_image_input = gr.File(label="Imagens de Referência", file_count="multiple", file_types=["image"])
         with gr.Row():
-            storyboard_and_keyframes_button = gr.Button(default_lang.get('storyboard_and_keyframes_button'), variant="primary")
-            storyboard_from_photos_button = gr.Button(default_lang.get('storyboard_from_photos_button'), variant="secondary")
-        step1_mode_b_info_md = gr.Markdown(f"*{default_lang.get('step1_mode_b_info')}*")
-        storyboard_output = gr.JSON(label=default_lang.get('storyboard_output_label'))
-        keyframe_gallery = gr.Gallery(label=default_lang.get('keyframes_gallery_label'), visible=True, object_fit="contain", height="auto", type="filepath")
-
-    with gr.Accordion(default_lang.get('step3_accordion'), open=False, visible=False) as step3_accordion:
-        step3_description_md = gr.Markdown(default_lang.get('step3_description'))
-        with gr.Accordion(default_lang.get('ltx_advanced_options'), open=False) as ltx_advanced_options_accordion:
-            with gr.Accordion(default_lang.get('causality_controls_title'), open=True) as causality_accordion:
-                trim_percent_slider = gr.Slider(minimum=10, maximum=90, value=50, step=5, label=default_lang.get('trim_percent_label'), info=default_lang.get('trim_percent_info'))
-                with gr.Row():
-                    forca_guia_slider = gr.Slider(label=default_lang.get('forca_guia_label'), minimum=0.0, maximum=1.0, value=0.5, step=0.05, info=default_lang.get('forca_guia_info'))
-                    convergencia_destino_slider = gr.Slider(label=default_lang.get('convergencia_final_label'), minimum=0.0, maximum=1.0, value=0.75, step=0.05, info=default_lang.get('convergencia_final_info'))
-            with gr.Accordion(default_lang.get('ltx_pipeline_options'), open=True) as ltx_pipeline_accordion:
-                with gr.Row():
-                    guidance_scale_slider = gr.Slider(minimum=1.0, maximum=10.0, value=2.0, step=0.1, label=default_lang.get('guidance_scale_label'), info=default_lang.get('guidance_scale_info'))
-                    stg_scale_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.025, step=0.005, label=default_lang.get('stg_scale_label'), info=default_lang.get('stg_scale_info'))
-                inference_steps_slider = gr.Slider(minimum=10, maximum=50, value=20, step=1, label=default_lang.get('steps_label'), info=default_lang.get('steps_info'))
-        produce_original_button = gr.Button(default_lang.get('produce_original_button'), variant="primary")
-        original_video_output = gr.Video(label="Original Master Video", visible=False, interactive=False)
-
-    with gr.Accordion(default_lang.get('step4_accordion'), open=False, visible=False) as step4_accordion:
-        step4_description_md = gr.Markdown(default_lang.get('step4_description'))
-        with gr.Accordion(default_lang.get('sub_step_a_upscaler'), open=True) as sub_step_a_accordion:
-            upscaler_description_md = gr.Markdown(default_lang.get('upscaler_description'))
-            with gr.Accordion(default_lang.get('upscaler_options'), open=False) as upscaler_options_accordion:
-                upscaler_chunk_size_slider = gr.Slider(minimum=1, maximum=10, value=2, step=1, label=default_lang.get('upscaler_chunk_size_label'), info=default_lang.get('upscaler_chunk_size_info'))
-            run_upscaler_button = gr.Button(default_lang.get('run_upscaler_button'), variant="secondary")
-            upscaler_video_output = gr.Video(label="Upscaled Video", visible=False, interactive=False)
-        with gr.Accordion(default_lang.get('sub_step_b_hd'), open=True) as sub_step_b_accordion:
-            hd_description_md = gr.Markdown(default_lang.get('hd_description'))
-            with gr.Accordion(default_lang.get('hd_options'), open=False) as hd_options_accordion:
-                hd_model_radio = gr.Radio(["3B", "7B"], value="7B", label=default_lang.get('hd_model_label'))
-                hd_steps_slider = gr.Slider(minimum=20, maximum=150, value=100, step=5, label=default_lang.get('hd_steps_label'), info=default_lang.get('hd_steps_info'))
-            run_hd_button = gr.Button(default_lang.get('run_hd_button'), variant="secondary")
-            hd_video_output = gr.Video(label="HD Mastered Video", visible=False, interactive=False)
-        with gr.Accordion(default_lang.get('sub_step_c_audio'), open=True) as sub_step_c_accordion:
-            audio_description_md = gr.Markdown(default_lang.get('audio_description'))
-            with gr.Accordion(default_lang.get('audio_options'), open=False) as audio_options_accordion:
-                audio_prompt_input = gr.Textbox(label=default_lang.get('audio_prompt_label'), info=default_lang.get('audio_prompt_info'), lines=3)
-            run_audio_button = gr.Button(default_lang.get('run_audio_button'), variant="secondary")
-            audio_video_output = gr.Video(label="Video with Audio", visible=False, interactive=False)
-
-    final_video_output = gr.Video(label=default_lang.get('final_video_label'), visible=False, interactive=False)
-    with gr.Accordion(default_lang.get('log_accordion_label'), open=False) as log_accordion:
-        log_display = gr.Textbox(label=default_lang.get('log_display_label'), lines=20, interactive=False, autoscroll=True)
-        update_log_button = gr.Button(default_lang.get('update_log_button'))
-
-    # --- 4. UI EVENT CONNECTIONS ---
-    all_ui_components = [title_md, subtitle_md, lang_selector, step1_accordion, prompt_input, ref_image_input, num_keyframes_slider, duration_per_fragment_slider, storyboard_and_keyframes_button, storyboard_from_photos_button, step1_mode_b_info_md, storyboard_output, keyframe_gallery, step3_accordion, step3_description_md, produce_original_button, ltx_advanced_options_accordion, causality_accordion, trim_percent_slider, forca_guia_slider, convergencia_destino_slider, ltx_pipeline_accordion, guidance_scale_slider, stg_scale_slider, inference_steps_slider, step4_accordion, step4_description_md, sub_step_a_accordion, upscaler_description_md, upscaler_options_accordion, upscaler_chunk_size_slider, run_upscaler_button, sub_step_b_accordion, hd_description_md, hd_options_accordion, hd_model_radio, hd_steps_slider, run_hd_button, sub_step_c_accordion, audio_description_md, audio_options_accordion, audio_prompt_input, run_audio_button, final_video_output, log_accordion, log_display, update_log_button]
-    def create_lang_update_fn():
-        def update_lang(lang_emoji):
-            lang_code_map = {"🇧🇷": "pt", "🇺🇸": "en", "🇨🇳": "zh"}
-            lang_code = lang_code_map.get(lang_emoji, "en")
-            lang_map = i18n.get(lang_code, i18n.get('en', {}))
-            return [gr.update(value=f"<h1>{lang_map.get('app_title')}</h1>"),gr.update(value=f"<p>{lang_map.get('app_subtitle')}</p>"),gr.update(label=lang_map.get('lang_selector_label')),gr.update(label=lang_map.get('step1_accordion')),gr.update(label=lang_map.get('prompt_label')),gr.update(label=lang_map.get('ref_images_label')),gr.update(label=lang_map.get('keyframes_label')),gr.update(label=lang_map.get('duration_label'), info=lang_map.get('duration_info')),gr.update(value=lang_map.get('storyboard_and_keyframes_button')),gr.update(value=lang_map.get('storyboard_from_photos_button')),gr.update(value=f"*{lang_map.get('step1_mode_b_info')}*"),gr.update(label=lang_map.get('storyboard_output_label')),gr.update(label=lang_map.get('keyframes_gallery_label')),gr.update(label=lang_map.get('step3_accordion')),gr.update(value=lang_map.get('step3_description')),gr.update(value=lang_map.get('produce_original_button')),gr.update(label=lang_map.get('ltx_advanced_options')),gr.update(label=lang_map.get('causality_controls_title')),gr.update(label=lang_map.get('trim_percent_label'), info=lang_map.get('trim_percent_info')),gr.update(label=lang_map.get('forca_guia_label'), info=lang_map.get('forca_guia_info')),gr.update(label=lang_map.get('convergencia_final_label'), info=lang_map.get('convergencia_final_info')),gr.update(label=lang_map.get('ltx_pipeline_options')),gr.update(label=lang_map.get('guidance_scale_label'), info=lang_map.get('guidance_scale_info')),gr.update(label=lang_map.get('stg_scale_label'), info=lang_map.get('stg_scale_info')),gr.update(label=lang_map.get('steps_label'), info=lang_map.get('steps_info')),gr.update(label=lang_map.get('step4_accordion')),gr.update(value=lang_map.get('step4_description')),gr.update(label=lang_map.get('sub_step_a_upscaler')),gr.update(value=lang_map.get('upscaler_description')),gr.update(label=lang_map.get('upscaler_options')),gr.update(label=lang_map.get('upscaler_chunk_size_label'), info=lang_map.get('upscaler_chunk_size_info')),gr.update(value=lang_map.get('run_upscaler_button')),gr.update(label=lang_map.get('sub_step_b_hd')),gr.update(value=lang_map.get('hd_description')),gr.update(label=lang_map.get('hd_options')),gr.update(label=lang_map.get('hd_model_label')),gr.update(label=lang_map.get('hd_steps_label'), info=lang_map.get('hd_steps_info')),gr.update(value=lang_map.get('run_hd_button')),gr.update(label=lang_map.get('sub_step_c_audio')),gr.update(value=lang_map.get('audio_description')),gr.update(label=lang_map.get('audio_options')),gr.update(label=lang_map.get('audio_prompt_label'), info=lang_map.get('audio_prompt_info')),gr.update(value=lang_map.get('run_audio_button')),gr.update(label=lang_map.get('final_video_label')),gr.update(label=lang_map.get('log_accordion_label')),gr.update(label=lang_map.get('log_display_label')),gr.update(value=lang_map.get('update_log_button'))]
-        return update_lang
-    lang_selector.change(fn=create_lang_update_fn(), inputs=lang_selector, outputs=all_ui_components)
+            num_keyframes_slider = gr.Slider(minimum=3, maximum=42, value=5, step=1, label="Número de Cenas-Chave")
+            duration_per_fragment_slider = gr.Slider(label="Duração de cada Clipe (s)", info="Duração alvo para cada fragmento de vídeo.", minimum=2.0, maximum=10.0, value=4.0, step=0.1)
+        storyboard_and_keyframes_button = gr.Button("Gerar Roteiro e Keyframes", variant="primary")
+        storyboard_output = gr.JSON(label="Roteiro Gerado (Storyboard)")
+        keyframe_gallery = gr.Gallery(label="Galeria de Cenas-Chave (Keyframes)", visible=True, object_fit="contain", height="auto", type="filepath")
+
+    with gr.Accordion("Etapa 3: Produção do Vídeo Original", open=False, visible=False) as step3_accordion:
+        # Aqui omiti a definição detalhada dos sliders para brevidade, mas eles existem
+        trim_percent_slider = gr.Slider(minimum=10, maximum=90, value=50, step=5, label="Poda Causal (%)")
+        handler_strength = gr.Slider(label="Força do Déjà-Vu", minimum=0.0, maximum=1.0, value=0.5, step=0.05)
+        dest_strength = gr.Slider(label="Força da Âncora Final", minimum=0.0, maximum=1.0, value=0.75, step=0.05)
+        guidance_scale_slider = gr.Slider(minimum=1.0, maximum=10.0, value=2.0, step=0.1, label="Escala de Orientação")
+        stg_scale_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.025, step=0.005, label="Escala STG")
+        inference_steps_slider = gr.Slider(minimum=10, maximum=50, value=20, step=1, label="Passos de Inferência")
+        produce_original_button = gr.Button("🎬 Produzir Vídeo Original", variant="primary")
+        original_video_output = gr.Video(label="Filme Original Master", visible=False, interactive=False)
+        
+    with gr.Accordion("Etapa 4: Pós-Produção (Opcional)", open=False, visible=False) as step4_accordion:
+        gr.Markdown("Aplique efeitos de melhoria ao vídeo mais recente.")
+        # ... (Componentes de pós-produção aqui) ...
+
+    with gr.Accordion("🧬 DNA Digital da Geração (JSON)", open=False) as data_accordion:
+        generation_data_output = gr.JSON(label="Estado de Geração Completo")
+
+    final_video_output = gr.Video(label="Filme Final (Resultado da Última Etapa)", visible=False, interactive=False)
+    
+    with gr.Accordion("📝 Log de Geração (Detalhado)", open=False) as log_accordion:
+        log_display = gr.Textbox(label="Log da Sessão", lines=20, interactive=False, autoscroll=True)
+        update_log_button = gr.Button("Atualizar Log")
 
-    storyboard_and_keyframes_button.click(fn=run_pre_production_wrapper, inputs=[prompt_input, num_keyframes_slider, ref_image_input, resolution_selector, duration_per_fragment_slider], outputs=[storyboard_output, keyframe_gallery, step3_accordion])
-    storyboard_from_photos_button.click(fn=run_pre_production_photo_wrapper, inputs=[prompt_input, num_keyframes_slider, ref_image_input], outputs=[storyboard_output, keyframe_gallery, step3_accordion])
-    produce_original_button.click(fn=run_original_production_wrapper, inputs=[keyframe_gallery, prompt_input, duration_per_fragment_slider, trim_percent_slider, forca_guia_slider, convergencia_destino_slider, guidance_scale_slider, stg_scale_slider, inference_steps_slider, resolution_selector], outputs=[original_video_output, final_video_output, step4_accordion, original_latents_paths_state, original_video_path_state, current_source_video_state])
-    run_upscaler_button.click(fn=run_upscaler_wrapper, inputs=[original_latents_paths_state, upscaler_chunk_size_slider], outputs=[upscaler_video_output, final_video_output, upscaled_video_path_state, current_source_video_state])
-    run_hd_button.click(fn=run_hd_wrapper, inputs=[current_source_video_state, hd_model_radio, hd_steps_slider, prompt_input], outputs=[hd_video_output, final_video_output, hd_video_path_state, current_source_video_state])
-    run_audio_button.click(fn=run_audio_wrapper, inputs=[current_source_video_state, audio_prompt_input, prompt_input], outputs=[audio_video_output, final_video_output])
+    # --- 4. CONEXÕES DE EVENTOS DA UI ---
+    
+    storyboard_and_keyframes_button.click(
+        fn=run_pre_production_wrapper, 
+        inputs=[prompt_input, num_keyframes_slider, ref_image_input, resolution_selector, duration_per_fragment_slider], 
+        outputs=[generation_state_holder, storyboard_output, keyframe_gallery, step3_accordion]
+    )
+    
+    produce_original_button.click(
+        fn=run_original_production_wrapper, 
+        inputs=[
+            generation_state_holder,
+            trim_percent_slider, handler_strength, dest_strength,
+            guidance_scale_slider, stg_scale_slider, inference_steps_slider
+        ], 
+        outputs=[
+            original_video_output, final_video_output, step4_accordion, 
+            original_latents_paths_state, original_video_path_state, current_source_video_state, 
+            generation_state_holder, generation_data_output
+        ]
+    )
+
+    generation_state_holder.change(
+        fn=lambda state: state,
+        inputs=generation_state_holder,
+        outputs=generation_data_output
+    )
+    
     update_log_button.click(fn=get_log_content, inputs=[], outputs=[log_display])
-
-# --- 5. APPLICATION LAUNCH ---
+    
+# --- 5. INICIALIZAÇÃO DA APLICAÇÃO ---
 if __name__ == "__main__":
     if os.path.exists(WORKSPACE_DIR):
-        logger.info(f"Clearing previous workspace at: {WORKSPACE_DIR}")
+        logger.info(f"Limpando workspace anterior em: {WORKSPACE_DIR}")
         shutil.rmtree(WORKSPACE_DIR)
     os.makedirs(WORKSPACE_DIR)
-    logger.info(f"Application started. Launching Gradio interface...")
+    
+    logger.info("Aplicação Gradio iniciada. Lançando interface...")
     demo.queue().launch()

app_api.py

@@ -0,0 +1,127 @@
+# app_api.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 3.0.0 (API Head for Aduc Framework)
+#
+# Este arquivo implementa um servidor de API usando FastAPI para expor as
+# funcionalidades do Aduc Framework. Ele permite o controle programático
+# do processo de geração de vídeo.
+
+import yaml
+import logging
+import uuid
+from typing import Dict
+
+from fastapi import FastAPI, BackgroundTasks, HTTPException
+
+# --- 1. IMPORTAÇÃO DO FRAMEWORK E SEUS TIPOS ---
+import aduc_framework
+from aduc_framework.types import GenerationState, PreProductionParams, ProductionParams
+
+# --- CONFIGURAÇÃO INICIAL ---
+logger = logging.getLogger(__name__)
+
+# Cria a aplicação FastAPI
+app = FastAPI(
+    title="ADUC-SDR Framework API",
+    description="API para orquestração de geração de vídeo coerente com IA.",
+    version="3.0.0"
+)
+
+# Carrega a configuração e inicializa uma instância SINGLETON do framework.
+# O framework é pesado e deve ser carregado apenas uma vez na inicialização da API.
+try:
+    with open("config.yaml", 'r') as f: config = yaml.safe_load(f)
+    WORKSPACE_DIR = config['application']['workspace_dir']
+    
+    aduc = aduc_framework.create_aduc_instance(workspace_dir=WORKSPACE_DIR)
+    
+    logger.info("API FastAPI inicializada e conectada ao Aduc Framework.")
+except Exception as e:
+    logger.critical(f"ERRO CRÍTICO durante a inicialização da API: {e}", exc_info=True)
+    # A API não pode funcionar sem o framework, então saímos se falhar.
+    exit()
+
+# --- ARMAZENAMENTO DE TAREFAS EM MEMÓRIA ---
+# Em um ambiente de produção real, isso seria substituído por um banco de dados
+# ou um cache como Redis para persistir o estado das tarefas.
+tasks_state: Dict[str, GenerationState] = {}
+
+
+# --- FUNÇÕES DE BACKGROUND ---
+
+def run_production_in_background(task_id: str, params: ProductionParams):
+    """
+    Função que executa a tarefa de produção demorada em segundo plano.
+    Ela opera na instância global 'aduc' para modificar seu estado interno.
+    """
+    logger.info(f"Background task {task_id}: Iniciando produção de vídeo...")
+    try:
+        # A tarefa do framework modifica o estado interno da instância 'aduc'
+        _, _, final_state = aduc.task_produce_original_movie(params=params)
+        
+        # Armazena o estado final e completo no nosso "banco de dados" de tarefas
+        tasks_state[task_id] = final_state
+        logger.info(f"Background task {task_id}: Produção de vídeo concluída com sucesso.")
+    except Exception as e:
+        logger.error(f"Background task {task_id}: Falha na produção. Erro: {e}", exc_info=True)
+        # Opcional: Atualizar o estado da tarefa com uma mensagem de erro.
+
+
+# --- ENDPOINTS DA API ---
+
+@app.post("/v1/pre-production", response_model=GenerationState, tags=["Workflow"])
+async def start_pre_production(params: PreProductionParams):
+    """
+    Inicia e executa a etapa de pré-produção (storyboard e keyframes).
+
+    Esta é uma chamada síncrona, pois a pré-produção é relativamente rápida.
+    Ela retorna o estado de geração completo após a conclusão.
+    """
+    logger.info(f"API: Recebida solicitação de pré-produção com prompt: '{params.prompt[:30]}...'")
+    try:
+        _, _, updated_state = aduc.task_pre_production(params=params)
+        return updated_state
+    except Exception as e:
+        logger.error(f"API: Erro na pré-produção: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Erro interno durante a pré-produção: {e}")
+
+@app.post("/v1/production", status_code=202, tags=["Workflow"])
+async def start_production(params: ProductionParams, background_tasks: BackgroundTasks):
+    """
+    Inicia a tarefa de produção de vídeo principal em segundo plano.
+
+    Esta chamada retorna imediatamente com um `task_id`. Use o endpoint
+    `/v1/status/{task_id}` para verificar o progresso e obter o resultado final.
+    """
+    task_id = str(uuid.uuid4())
+    logger.info(f"API: Recebida solicitação de produção. Criando tarefa de background com ID: {task_id}")
+    
+    # Armazena o estado atual (pré-produção) antes de iniciar a nova tarefa
+    tasks_state[task_id] = aduc.get_current_state()
+    
+    # Adiciona a função demorada para ser executada em segundo plano
+    background_tasks.add_task(run_production_in_background, task_id, params)
+    
+    return {"message": "Produção de vídeo iniciada em segundo plano.", "task_id": task_id}
+
+@app.get("/v1/status/{task_id}", response_model=GenerationState, tags=["Workflow"])
+async def get_task_status(task_id: str):
+    """
+    Verifica o estado de uma tarefa de geração em andamento ou concluída.
+    """
+    logger.info(f"API: Verificando status da tarefa {task_id}")
+    state = tasks_state.get(task_id)
+    if not state:
+        raise HTTPException(status_code=404, detail="ID de tarefa não encontrado.")
+    
+    # Retorna o estado mais recente que temos para essa tarefa
+    return state
+
+@app.get("/health", tags=["Infra"])
+async def health_check():
+    """
+    Endpoint simples para verificar se a API está online.
+    """
+    return {"status": "ok"}

app_gradio.py

@@ -0,0 +1,216 @@
+# app_gradio.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 3.0.0 (UI Head for Aduc Framework)
+#
+# Este arquivo implementa a interface de usuário com Gradio para o Aduc-Sdr.
+# Ele atua como um cliente para o 'aduc_framework', que contém toda a
+# lógica de negócio e orquestração.
+
+import gradio as gr
+import yaml
+import logging
+import os
+import shutil
+import time
+import json
+
+# --- 1. IMPORTAÇÃO DO FRAMEWORK E SEUS TIPOS ---
+# A UI agora trata o Aduc-Sdr como um pacote que ela consome.
+import aduc_framework
+from aduc_framework.types import PreProductionParams, ProductionParams
+
+# --- CUSTOM UI THEME E CONFIGURAÇÃO INICIAL ---
+# (Esta seção permanece a mesma, pois é específica da aplicação)
+
+cinematic_theme = gr.themes.Base(
+    primary_hue=gr.themes.colors.indigo,
+    secondary_hue=gr.themes.colors.purple,
+    neutral_hue=gr.themes.colors.slate,
+    font=(gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"),
+).set(
+    body_background_fill="#111827", body_text_color="#E5E7EB",
+    button_primary_background_fill="linear-gradient(90deg, #4F46E5, #8B5CF6)",
+    button_primary_text_color="#FFFFFF", button_secondary_background_fill="#374151",
+    button_secondary_border_color="#4B5563", button_secondary_text_color="#E5E7EB",
+    block_background_fill="#1F2937", block_border_width="1px", block_border_color="#374151",
+    block_label_background_fill="#374151", block_label_text_color="#E5E7EB",
+    block_title_text_color="#FFFFFF", input_background_fill="#374151",
+    input_border_color="#4B5563", input_placeholder_color="#9CA3AF",
+)
+
+LOG_FILE_PATH = "aduc_log.txt"
+if os.path.exists(LOG_FILE_PATH):
+    os.remove(LOG_FILE_PATH)
+
+# Configuração de logging
+log_format = '%(asctime)s - %(levelname)s - [%(name)s:%(funcName)s] - %(message)s'
+root_logger = logging.getLogger()
+root_logger.setLevel(logging.INFO)
+# ... (código completo de configuração de logging) ...
+logger = logging.getLogger(__name__)
+
+# Carrega a configuração e inicializa o framework
+try:
+    with open("config.yaml", 'r') as f: config = yaml.safe_load(f)
+    WORKSPACE_DIR = config['application']['workspace_dir']
+    
+    # --- PONTO DE ENTRADA DO FRAMEWORK ---
+    aduc = aduc_framework.create_aduc_instance(workspace_dir=WORKSPACE_DIR)
+    
+    logger.info("Interface Gradio inicializada e conectada ao Aduc Framework.")
+except Exception as e:
+    logger.critical(f"ERRO CRÍTICO durante a inicialização: {e}", exc_info=True)
+    exit()
+
+# --- 2. FUNÇÕES WRAPPER (CAMADA DE TRADUÇÃO UI <-> FRAMEWORK) ---
+
+def run_pre_production_wrapper(prompt, num_keyframes, ref_files, resolution_str, duration_per_fragment, progress=gr.Progress()):
+    if not ref_files:
+        raise gr.Error("Por favor, forneça pelo menos uma imagem de referência.")
+    
+    ref_paths = [aduc.process_image_for_story(f.name, 480, f"ref_processed_{i}.png") for i, f in enumerate(ref_files)]
+    
+    params = PreProductionParams(
+        prompt=prompt,
+        num_keyframes=int(num_keyframes),
+        ref_paths=ref_paths,
+        resolution=int(resolution_str.split('x')[0]),
+        duration_per_fragment=duration_per_fragment
+    )
+    
+    storyboard, final_keyframes, updated_state = aduc.task_pre_production(params, progress)
+    
+    return updated_state.model_dump(), storyboard, final_keyframes, gr.update(visible=True, open=True)
+
+def run_original_production_wrapper(current_state_dict, trim_percent, handler_strength, dest_strength, guidance_scale, stg_scale, steps, progress=gr.Progress()):
+    yield {
+        original_video_output: gr.update(value=None, visible=True, label="🎬 Produzindo seu filme..."),
+        final_video_output: gr.update(value=None, visible=True, label="🎬 Produção em progresso..."),
+        step4_accordion: gr.update(visible=False)
+    }
+
+    production_params = ProductionParams(
+        trim_percent=int(trim_percent),
+        handler_strength=handler_strength,
+        destination_convergence_strength=dest_strength,
+        guidance_scale=guidance_scale,
+        stg_scale=stg_scale,
+        inference_steps=int(steps)
+    )
+    
+    final_video_path, latent_paths, updated_state = aduc.task_produce_original_movie(
+        params=production_params, 
+        progress_callback=progress
+    )
+    
+    updated_state_dict = updated_state.model_dump()
+
+    yield {
+        original_video_output: gr.update(value=final_video_path, label="✅ Filme Original Master"),
+        final_video_output: gr.update(value=final_video_path),
+        step4_accordion: gr.update(visible=True, open=True),
+        original_latents_paths_state: latent_paths,
+        original_video_path_state: final_video_path,
+        current_source_video_state: final_video_path,
+        generation_state_holder: updated_state_dict,
+        generation_data_output: updated_state_dict
+    }
+
+def get_log_content():
+    try:
+        with open(LOG_FILE_PATH, "r", encoding="utf-8") as f:
+            return f.read()
+    except FileNotFoundError:
+        return "Arquivo de log ainda não criado. Inicie uma geração."
+
+# --- 3. DEFINIÇÃO DA UI GRADIO ---
+with gr.Blocks(theme=cinematic_theme, css="style.css") as demo:
+    
+    generation_state_holder = gr.State(value={})
+    
+    original_latents_paths_state = gr.State(value=None)
+    original_video_path_state = gr.State(value=None)
+    current_source_video_state = gr.State(value=None)
+
+    gr.Markdown("<h1>ADUC-SDR 🎬 - O Diretor de Cinema IA</h1>")
+    gr.Markdown("<p>Crie um filme completo com vídeo e áudio, orquestrado por uma equipe de IAs especialistas.</p>")
+
+    with gr.Row():
+        lang_selector = gr.Radio(["🇧🇷", "🇺🇸", "🇨🇳"], value="🇧🇷", label="Idioma / Language")
+        resolution_selector = gr.Radio(["480x480", "720x720", "960x960"], value="480x480", label="Resolução Base")
+
+    with gr.Accordion("Etapa 1: Roteiro e Cenas-Chave (Pré-Produção)", open=True) as step1_accordion:
+        prompt_input = gr.Textbox(label="Ideia Geral do Filme", value="Um leão majestoso caminha pela savana, senta-se e ruge para o sol poente.")
+        ref_image_input = gr.File(label="Imagens de Referência", file_count="multiple", file_types=["image"])
+        with gr.Row():
+            num_keyframes_slider = gr.Slider(minimum=3, maximum=42, value=5, step=1, label="Número de Cenas-Chave")
+            duration_per_fragment_slider = gr.Slider(label="Duração de cada Clipe (s)", info="Duração alvo para cada fragmento de vídeo.", minimum=2.0, maximum=10.0, value=4.0, step=0.1)
+        storyboard_and_keyframes_button = gr.Button("Gerar Roteiro e Keyframes", variant="primary")
+        storyboard_output = gr.JSON(label="Roteiro Gerado (Storyboard)")
+        keyframe_gallery = gr.Gallery(label="Galeria de Cenas-Chave (Keyframes)", visible=True, object_fit="contain", height="auto", type="filepath")
+
+    with gr.Accordion("Etapa 3: Produção do Vídeo Original", open=False, visible=False) as step3_accordion:
+        # Aqui omiti a definição detalhada dos sliders para brevidade, mas eles existem
+        trim_percent_slider = gr.Slider(minimum=10, maximum=90, value=50, step=5, label="Poda Causal (%)")
+        handler_strength = gr.Slider(label="Força do Déjà-Vu", minimum=0.0, maximum=1.0, value=0.5, step=0.05)
+        dest_strength = gr.Slider(label="Força da Âncora Final", minimum=0.0, maximum=1.0, value=0.75, step=0.05)
+        guidance_scale_slider = gr.Slider(minimum=1.0, maximum=10.0, value=2.0, step=0.1, label="Escala de Orientação")
+        stg_scale_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.025, step=0.005, label="Escala STG")
+        inference_steps_slider = gr.Slider(minimum=10, maximum=50, value=20, step=1, label="Passos de Inferência")
+        produce_original_button = gr.Button("🎬 Produzir Vídeo Original", variant="primary")
+        original_video_output = gr.Video(label="Filme Original Master", visible=False, interactive=False)
+        
+    with gr.Accordion("Etapa 4: Pós-Produção (Opcional)", open=False, visible=False) as step4_accordion:
+        gr.Markdown("Aplique efeitos de melhoria ao vídeo mais recente.")
+        # ... (Componentes de pós-produção aqui) ...
+
+    with gr.Accordion("🧬 DNA Digital da Geração (JSON)", open=False) as data_accordion:
+        generation_data_output = gr.JSON(label="Estado de Geração Completo")
+
+    final_video_output = gr.Video(label="Filme Final (Resultado da Última Etapa)", visible=False, interactive=False)
+    
+    with gr.Accordion("📝 Log de Geração (Detalhado)", open=False) as log_accordion:
+        log_display = gr.Textbox(label="Log da Sessão", lines=20, interactive=False, autoscroll=True)
+        update_log_button = gr.Button("Atualizar Log")
+
+    # --- 4. CONEXÕES DE EVENTOS DA UI ---
+    
+    storyboard_and_keyframes_button.click(
+        fn=run_pre_production_wrapper, 
+        inputs=[prompt_input, num_keyframes_slider, ref_image_input, resolution_selector, duration_per_fragment_slider], 
+        outputs=[generation_state_holder, storyboard_output, keyframe_gallery, step3_accordion]
+    )
+    
+    produce_original_button.click(
+        fn=run_original_production_wrapper, 
+        inputs=[
+            generation_state_holder,
+            trim_percent_slider, handler_strength, dest_strength,
+            guidance_scale_slider, stg_scale_slider, inference_steps_slider
+        ], 
+        outputs=[
+            original_video_output, final_video_output, step4_accordion, 
+            original_latents_paths_state, original_video_path_state, current_source_video_state, 
+            generation_state_holder, generation_data_output
+        ]
+    )
+
+    generation_state_holder.change(
+        fn=lambda state: state,
+        inputs=generation_state_holder,
+        outputs=generation_data_output
+    )
+    
+    update_log_button.click(fn=get_log_content, inputs=[], outputs=[log_display])
+    
+# --- 5. INICIALIZAÇÃO DA APLICAÇÃO ---
+if __name__ == "__main__":
+    if os.path.exists(WORKSPACE_DIR):
+        logger.info(f"Limpando workspace anterior em: {WORKSPACE_DIR}")
+        shutil.rmtree(WORKSPACE_DIR)
+    os.makedirs(WORKSPACE_DIR)
+    
+    logger.info("Aplicação Gradio iniciada. Lançando interface...")
+    demo.queue().launch()

run.py

@@ -0,0 +1,20 @@
+import argparse
+import uvicorn
+import os
+
+def main():
+    parser = argparse.ArgumentParser(description="Executor do Aduc-Sdr")
+    parser.add_argument("mode", choices=["gradio", "api"], help="Modo de execução: 'gradio' para a UI, 'api' para o servidor FastAPI.")
+    args = parser.parse_args()
+
+    if args.mode == "gradio":
+        print("Iniciando a interface Gradio...")
+        # Importa e executa a lógica de lançamento que está no final de app_gradio.py
+        from app_gradio import demo
+        demo.queue().launch()
+    elif args.mode == "api":
+        print("Iniciando o servidor FastAPI em http://127.0.0.1:8000")
+        uvicorn.run("app_api:app", host="127.0.0.1", port=8000, reload=True)
+
+if __name__ == "__main__":
+    main()