Update app.py

app.py

@@ -1,293 +1,303 @@
-# =======================================================================================
-# Artisan Nexus v1.0 - "Genesis"
-# Tu Estudio Personal de Ingeniería de Prompts
+# ==================================================================================================
+# SYNAPSE v0.9 (Codename: "Prometheus")
+# The Dynamic Prompting Environment
 #
-# Creado para constructores, artesanos y pioneros del futuro digital.
-# Este no es un generador. Es una forja.
-# =======================================================================================
+# PHILOSOPHY:
+# We don't generate prompts. We architect instructions. We build workflows.
+# This is not a tool, it is a laboratory for command and control of generative AI.
+# ==================================================================================================
 
 import gradio as gr
-
-# ---------------------------------------------------------------------------------------
-# I. CONSTANTES Y CONFIGURACIÓN DEL ESTUDIO
-# Define la identidad y la estructura de la aplicación.
-# ---------------------------------------------------------------------------------------
-
-APP_VERSION = "1.0 - Genesis"
-APP_TITLE = f"Artisan Nexus ({APP_VERSION})"
-
-# Define la paleta de colores para una apariencia profesional y única.
-THEME_COLOR_PRIMARY = "#4A90E2"      # Un azul tecnológico y confiable
-THEME_COLOR_SECONDARY = "#50E3C2"    # Un verde menta para la innovación
-THEME_COLOR_NEUTRAL = "#B8B8B8"      # Gris claro para el texto
-THEME_FONT = ["'Segoe UI'", "system-ui", "sans-serif"]
-THEME_FONT_MONO = ["'SF Mono'", "'Consolas'", "monospace"]
-
-# Bloques de texto reutilizables para mantener la consistencia del marketing.
-MARKDOWN_HEADER = f"""
-<div style="text-align: center; margin-bottom: 20px;">
-    <h1 style="color: {THEME_COLOR_PRIMARY}; font-size: 3em; margin-bottom: 0px;">Artisan Nexus</h1>
-    <p style="color: {THEME_COLOR_NEUTRAL}; font-size: 1.2em; margin-top: 5px;">Tu Estudio Personal de Ingeniería de Prompts</p>
-</div>
-"""
-
-MARKDOWN_FOOTER = """
-<hr>
-<div style="text-align: center; margin-top: 20px;">
-    <p style="color: #B8B8B8; font-size: 0.9em;">
-        Creado con ❤️ por un artesano digital.
-        <br>
-        ¿Quieres integrar esta filosofía en tu equipo o empresa? 
-        <a href="https://www.linkedin.com/" target="_blank" style="color: #50E3C2; text-decoration: none;">Hablemos.</a>
-    </p>
+import uuid
+import json
+
+# --------------------------------------------------------------------------------------------------
+# I. CORE BLUEPRINTS & CONFIGURATION
+# The DNA of the Synapse Environment. Defines the capabilities of each Node.
+# --------------------------------------------------------------------------------------------------
+
+class NodeBlueprint:
+    """Defines the structure and capabilities of a functional node in the Synapse chain."""
+    
+    NODE_TEMPLATES = {
+        "strategic_comm": {
+            "name": "Strategic Communicator",
+            "description": "For crafting complex, high-stakes communication (emails, memos, announcements).",
+            "icon": "📨",
+            "inputs": [
+                {"label": "Audience Profile", "placeholder": "E.g., 'C-Suite Executives, skeptical but data-driven'"},
+                {"label": "Primary Objective", "placeholder": "E.g., 'Secure funding for Project Phoenix'"},
+                {"label": "Key Information Payloads (one per line)", "lines": 4, "placeholder": "- Q2 results exceeded projections by 15%.\n- The project has a 6-month ROI timeline.\n- We have a lead engineer ready to start."},
+                {"label": "Desired Tone & Voice", "choices": ["Assertive & Confident", "Empathetic & Collaborative", "Urgent & Action-Oriented", "Formal & Deferential"], "value": "Assertive & Confident"},
+            ],
+            "refinement_actions": ["make_more_concise", "increase_persuasion", "add_data_focus", "soften_tone"]
+        },
+        "creative_ideation": {
+            "name": "Creative Ideation Engine",
+            "description": "For brainstorming and generating novel concepts from a single spark.",
+            "icon": "💡",
+            "inputs": [
+                {"label": "Core Concept or Theme", "placeholder": "E.g., 'The future of decentralized cities'"},
+                {"label": "Output Format", "choices": ["5 Blog Post Titles", "3 YouTube Video Concepts", "10 Tweet-sized Ideas", "A one-paragraph story starter"], "value": "5 Blog Post Titles"},
+                {"label": "Creative Constraint", "placeholder": "E.g., 'Must be optimistic in tone', 'Avoid using tech jargon'"},
+            ],
+            "refinement_actions": ["make_more_provocative", "explore_contrarian_angle", "target_a_niche_audience", "simplify_for_beginners"]
+        },
+        "technical_architect": {
+            "name": "Technical Architect",
+            "description": "For designing code logic, solving bugs, and explaining complex systems.",
+            "icon": "⚙️",
+            "inputs": [
+                {"label": "Programming Language / Tech Stack", "value": "Python"},
+                {"label": "Core Task or Problem", "lines": 3, "placeholder": "E.g., 'Design a Python function to asynchronously fetch data from multiple APIs and aggregate the results.'"},
+                {"label": "Key Constraints or Requirements", "placeholder": "E.g., 'Must use the asyncio library, must include error handling for failed requests.'"},
+            ],
+            "refinement_actions": ["add_step_by_step_explanation", "generate_code_comments", "write_testing_plan", "optimize_for_performance"]
+        }
+    }
+
+# --------------------------------------------------------------------------------------------------
+# II. THE SYNAPSE ENGINE
+# The core logic that powers the creation and refinement of prompt chains.
+# --------------------------------------------------------------------------------------------------
+
+class SynapseEngine:
+    """The intelligent engine that translates user intent into architected prompt instructions."""
+
+    def _render_prompt_anatomy(self, prompt_text: str) -> str:
+        """Visualizes the prompt's structure with Markdown and HTML for clarity."""
+        # This is a simplified visualization. A more complex version could use regex to tag parts.
+        return f"""
+<div style="border: 1px solid #444; padding: 15px; border-radius: 8px; background-color: #1a1a1a;">
+<details>
+<summary><strong>🔬 Ver Anatomía del Prompt</strong></summary>
+<pre><code style="color: #e0e0e0; white-space: pre-wrap;">{prompt_text}</code></pre>
+</details>
 </div>
-"""
+        """
 
-# ---------------------------------------------------------------------------------------
-# II. EL MOTOR DE LA FORJA (CORE LOGIC)
-# Aquí reside la inteligencia del artesano. Cada función es una herramienta especializada.
-# ---------------------------------------------------------------------------------------
+    def craft_node_output(self, node_id: str, *args) -> dict:
+        """Crafts a single, structured node for the chain."""
+        template = NodeBlueprint.NODE_TEMPLATES.get(node_id)
+        if not template: return None
 
-class PromptCraftsman:
-    """El Maestro Artesano que contiene la lógica para forjar los prompts."""
+        # Basic validation
+        if not all(str(arg).strip() for arg in args):
+            return None 
 
-    def _generate_output_blocks(self, crafted_prompt: str, insight: str, pro_tip: str) -> tuple:
-        """
-        Genera los bloques de salida estandarizados para la UI.
-        Este método asegura consistencia en toda la aplicación.
-        """
-        # Bloque del Prompt Forjado
-        prompt_block = gr.Textbox(
-            label="✅ PROMPT FORJADO (Listo para copiar y pegar en tu IA favorita)",
-            value=crafted_prompt,
-            lines=10,
-            interactive=False,
-            show_copy_button=True,
-            visible=True
-        )
-        # Bloque de la Visión del Artesano
-        insight_block = gr.Markdown(
-            f"""
-            ### 🔬 Visión del Artesano: ¿Por qué funciona este prompt?
-            {insight}
-            """,
-            visible=True
-        )
-        # Bloque del Consejo Profesional
-        pro_tip_block = gr.Markdown(
-            f"""
-            ### 💡 Consejo Profesional:
-            *"{pro_tip}"*
-            """,
-            visible=True
-        )
-        return prompt_block, insight_block, pro_tip_block
-
-    def craft_diplomatic_email(self, recipient: str, role: str, goal: str, key_points: str, tone: str) -> tuple:
-        """Forja un prompt para emails complejos y diplomáticos."""
-        if not all([recipient, role, goal, key_points, tone]):
-            return gr.Textbox(visible=False), gr.Markdown(visible=False), gr.Markdown(visible=False)
-
-        crafted_prompt = f"""
-Actúa como un experto estratega en comunicación corporativa y redacción de emails. Tu misión es redactar un borrador de email claro, conciso y diplomático.
-
-**CONTEXTO DEL EMAIL:**
-- **Destinatario:** {recipient}
-- **Mi Rol:** {role}
-- **Objetivo Principal:** {goal}
-- **Tono Requerido:** {tone}
-
-**CONTENIDO OBLIGATORIO:**
-El email debe abordar, de manera estructurada y lógica, los siguientes puntos clave:
-{key_points}
-
-**INSTRUCCIONES DE FORMATO:**
-1.  **Asunto:** Crea un asunto breve y descriptivo que refleje el propósito del email.
-2.  **Apertura:** Comienza con un saludo profesional y una breve introducción que establezca el contexto.
-3.  **Cuerpo:** Desarrolla los puntos clave de forma clara y separada. Utiliza párrafos cortos.
-4.  **Cierre:** Concluye con un resumen de la acción deseada o el siguiente paso, y un cierre profesional.
-5.  **Revisión:** Asegúrate de que el lenguaje sea constructivo y esté alineado con el objetivo y el tono solicitados. Evita la ambigüedad.
-"""
-        insight = """
-        Este prompt es eficaz porque utiliza la técnica **"Rol, Contexto, Instrucción"**.
-        1.  **Rol (`Actúa como...`):** Pone a la IA en un modo experto específico.
-        2.  **Contexto (`CONTEXTO DEL EMAIL`):** Le proporciona toda la información de fondo necesaria para evitar respuestas genéricas.
-        3.  **Instrucción (`CONTENIDO OBLIGATORIO`, `INSTRUCCIONES DE FORMATO`):** Le da una estructura rígida y requisitos claros, forzando una salida de alta calidad y bien organizada.
-        """
-        pro_tip = "La IA proporciona el 90% del camino. Siempre lee el borrador en voz alta para ajustarlo a tu voz personal antes de enviarlo. El toque humano final es insustituible."
-
-        return self._generate_output_blocks(crafted_prompt, insight, pro_tip)
-
-    def craft_creative_content(self, topic: str, content_format: str, audience: str, style: str, goals: str) -> tuple:
-        """Forja un prompt para la creación de contenido original."""
-        if not all([topic, content_format, audience, style, goals]):
-            return gr.Textbox(visible=False), gr.Markdown(visible=False), gr.Markdown(visible=False)
-
-        crafted_prompt = f"""
-Actúa como un creador de contenido de clase mundial y estratega de marketing digital. Tu tarea es generar un borrador para una pieza de contenido excepcional.
-
-**BRIEF CREATIVO:**
-- **Tema Central:** {topic}
-- **Formato del Contenido:** {content_format}
-- **Audiencia Objetivo:** {audience}
-- **Estilo de Escritura Deseado:** {style}
-- **Objetivos de la Pieza (¿Qué quiero que la audiencia piense, sienta o haga?):** {goals}
-
-**DIRECTRICES DE CREACIÓN:**
-1.  **Gancho Inicial:** Comienza con una frase o párrafo de apertura que sea extremadamente cautivador y relevante para la audiencia objetivo.
-2.  **Desarrollo Estructurado:** Organiza el contenido de forma lógica. Si es un artículo, usa subtítulos. Si es un guion, usa escenas.
-3.  **Voz y Tono:** Mantén el estilo de escritura `{style}` de manera consistente en toda la pieza.
-4.  **Llamada a la Acción (CTA):** Integra de forma natural una llamada a la acción que se alinee con los objetivos definidos.
-5.  **Originalidad:** Evita clichés y frases comunes. Busca ángulos únicos y perspectivas frescas sobre el tema.
-"""
-        insight = """
-        La clave de este prompt es el **"Brief Creativo"**. Al igual que en una agencia de publicidad, le damos a la IA un brief completo.
-        - Definir la **Audiencia** y los **Objetivos** obliga a la IA a pensar no solo en el *qué* (el tema), sino en el *para quién* y el *para qué*.
-        - Esto transforma una simple solicitud de texto en una tarea estratégica, resultando en un contenido mucho más enfocado y efectivo.
-        """
-        pro_tip = "Usa la primera respuesta de la IA como una lluvia de ideas. Pídele que te dé '10 ganchos iniciales alternativos' o '3 estructuras diferentes para este contenido'. La primera idea no siempre es la mejor."
-
-    def craft_code_solution(self, language: str, task: str, constraints: str, code_snippet: str) -> tuple:
-        """Forja un prompt para solucionar problemas de programación."""
-        if not all([language, task]):
-            return gr.Textbox(visible=False), gr.Markdown(visible=False), gr.Markdown(visible=False)
-
-        context_code = f"\n**CÓDIGO EXISTENTE (para referencia o depuración):**\n```\n{code_snippet}\n```" if code_snippet else ""
-        context_constraints = f"\n**RESTRICCIONES O REQUISITOS:**\n{constraints}" if constraints else ""
-
-        crafted_prompt = f"""
-Actúa como un ingeniero de software senior experto en el lenguaje de programación **{language}**. Tu especialidad es escribir código limpio, eficiente y bien documentado.
-
-**TAREA A REALIZAR:**
-{task}
-{context_constraints}
-{context_code}
-
-**INSTRUCCIONES DE ENTREGA:**
-1.  **Solución en Código:** Proporciona el bloque de código completo y funcional en `{language}`.
-2.  **Explicación Detallada:** Debajo del código, añade una sección `### EXPLICACIÓN` donde describas paso a paso cómo funciona tu solución, las decisiones clave que tomaste y por qué.
-3.  **Buenas Prácticas:** Asegúrate de que el código siga las mejores prácticas del lenguaje, incluyendo nombres de variables claros y comentarios donde sea necesario.
-4.  **Eficiencia:** Considera la eficiencia (complejidad temporal y espacial) si es relevante para la tarea.
-"""
-        insight = """
-        Este prompt funciona por su **rigurosa estructura de entrega**.
-        - No solo pide el código, exige una **Explicación Detallada**. Esto obliga a la IA a "pensar en voz alta", lo que a menudo conduce a soluciones más correctas y robustas.
-        - Separar la **Tarea** de las **Restricciones** y el **Código Existente** ayuda a la IA a organizar la información de entrada de manera más efectiva.
-        """
-        pro_tip = "Nunca copies y pegues código de una IA directamente en producción. Úsalo como un compañero de pair programming. Entiende cada línea que te da, cuestiónala y adáptala a tu proyecto."
+        prompt = f"## PROMPT DIRECTIVE: ACT AS {template['name'].upper()} ##\n\n"
+        prompt += f"**MISSION CONTEXT:**\n"
+        for i, input_field in enumerate(template['inputs']):
+            prompt += f"- {input_field['label']}: {args[i]}\n"
+        
+        prompt += f"\n**PRIMARY EXECUTION DIRECTIVE:**\nBased on the context, generate the specified output, adhering strictly to the defined format and constraints. The output must be of expert-level quality, demonstrating deep domain knowledge and strategic insight."
+        
+        explanation = f"This node establishes a high-level **Expert Persona** ('{template['name']}') and provides a structured **Mission Context**. This forces the AI to move beyond generic responses and adopt a specific, professional mindset, leading to vastly superior results."
+
+        return {
+            "id": str(uuid.uuid4()),
+            "node_type": template['name'],
+            "icon": template['icon'],
+            "prompt": prompt,
+            "explanation": explanation,
+            "refinements_applied": []
+        }
+
+    def refine_node_prompt(self, prompt: str, action: str) -> str:
+        """Applies a refinement action to an existing prompt string."""
+        refinement_map = {
+            "make_more_concise": "\n\n**REFINEMENT DIRECTIVE:** Review the entire response and condense it by 25-40% without losing critical information. Prioritize clarity and impact.",
+            "increase_persuasion": "\n\n**REFINEMENT DIRECTIVE:** Re-evaluate the prompt's output to maximize its persuasive power. Employ rhetorical devices, strengthen the call-to-action, and appeal directly to the audience's motivations.",
+            "add_data_focus": "\n\n**REFINEMENT DIRECTIVE:** Enhance the output by integrating real or hypothetical quantitative data and metrics to support all claims. The tone should be analytical and evidence-based.",
+            "soften_tone": "\n\n**REFINEMENT DIRECTIVE:** Adjust the language to be more collaborative, empathetic, and less confrontational. Use inclusive phrasing and acknowledge potential alternative viewpoints.",
+            "make_more_provocative": "\n\n**REFINEMENT DIRECTIVE:** Inject a bold, contrarian, or highly provocative element into the output. Challenge a common assumption. The goal is to spark debate and capture attention.",
+            "add_step_by_step_explanation": "\n\n**REFINEMENT DIRECTIVE:** Append a detailed, step-by-step explanation to the primary output. Assume the reader is intelligent but a novice in this specific domain. Use analogies.",
+        }
+        # Add a placeholder for unimplemented actions
+        refinement_instruction = refinement_map.get(action, f"\n\n**REFINEMENT DIRECTIVE:** Apply the concept of '{action.replace('_', ' ')}' to the output.")
+        
+        # Avoid duplicating refinement instructions
+        if refinement_instruction in prompt:
+            return prompt
+            
+        return prompt + refinement_instruction
 
+# --------------------------------------------------------------------------------------------------
+# III. THE LAB ENVIRONMENT (UI)
+# The Gradio interface. Designed to feel like a professional, dynamic workspace.
+# --------------------------------------------------------------------------------------------------
 
-# ---------------------------------------------------------------------------------------
-# III. EL ESTUDIO (USER INTERFACE)
-# La construcción de la interfaz con Gradio. Es el espacio de trabajo del artesano.
-# ---------------------------------------------------------------------------------------
+class SynapseUI:
+    """Builds and manages the Gradio user interface for the Synapse Environment."""
 
-class UIBuilder:
-    """Construye la interfaz de usuario completa para Artisan Nexus."""
     def __init__(self):
-        self.craftsman = PromptCraftsman()
-        self.theme = gr.themes.Soft(
-            primary_hue=gr.themes.colors.blue,
-            secondary_hue=gr.themes.colors.cyan,
-            font=THEME_FONT,
-            font_mono=THEME_FONT_MONO
+        self.engine = SynapseEngine()
+        self.css = """
+            :root { --syn-c-primary: #00A9FF; --syn-c-secondary: #89CFF3; --syn-c-background: #0d1117; --syn-c-surface: #161b22; --syn-c-text: #c9d1d9; }
+            body, .gradio-container { background-color: var(--syn-c-background); color: var(--syn-c-text); font-family: 'Inter', sans-serif; }
+            #chain_display { border: 1px solid #30363d; border-radius: 8px; padding: 1em; min-height: 400px; background-color: var(--syn-c-surface); }
+            .node-card { border: 1px solid #30363d; border-radius: 12px; padding: 1em; margin-bottom: 1em; background-color: rgba(0, 169, 255, 0.05); }
+            .node-header { display: flex; align-items: center; font-size: 1.5em; font-weight: 600; color: var(--syn-c-secondary); }
+            .node-icon { font-size: 1.5em; margin-right: 0.5em; }
+            button { border-radius: 8px !important; }
+        """
+        self.theme = gr.themes.Base(
+            primary_hue="blue",
+            secondary_hue="cyan",
+            font="'Inter', sans-serif"
+        ).set(
+            body_background_fill="var(--syn-c-background)",
+            block_background_fill="var(--syn-c-surface)",
+            block_border_width="0px",
+            body_text_color="var(--syn-c-text)",
+            button_primary_background_fill="var(--syn-c-primary)",
+            button_primary_text_color="#FFFFFF",
+            button_secondary_background_fill="#30363d",
+            button_secondary_text_color="#FFFFFF",
         )
 
-    def build_output_components(self):
-        """Crea los componentes de salida, inicialmente invisibles."""
-        with gr.Blocks() as output_area:
-            with gr.Column(visible=False) as self.output_group:
-                self.crafted_prompt_output = gr.Textbox(label="✅ PROMPT FORJADO", interactive=False)
-                self.insight_output = gr.Markdown(visible=False)
-                self.pro_tip_output = gr.Markdown(visible=False)
-        return self.crafted_prompt_output, self.insight_output, self.pro_tip_output
-
-    def build_diplomat_workbench(self):
-        """Construye la interfaz para el Banco de Trabajo del Diplomático."""
-        with gr.Tab("✉️ El Banco del Diplomático (Emails)"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### 1. Define tu Misión Diplomática")
-                    recipient_input = gr.Textbox(label="¿Quién es el destinatario?", placeholder="Ej: Director de Marketing, Cliente potencial, etc.")
-                    role_input = gr.Textbox(label="¿Cuál es tu rol o relación con él?", placeholder="Ej: Analista de su equipo, Proveedor externo, etc.")
-                    goal_input = gr.Textbox(label="¿Cuál es tu objetivo principal?", placeholder="Ej: Conseguir aprobación para un proyecto, Resolver una queja, etc.")
-                    key_points_input = gr.Textbox(label="Puntos Clave a Incluir (uno por línea)", lines=4, placeholder="Ej:\n- Recordar el deadline del proyecto.\n- Solicitar los datos del informe Q3.\n- Proponer una breve reunión de 15 min.")
-                    tone_input = gr.Dropdown(label="Tono Deseado", choices=["Persuasivo", "Directo y al grano", "Empático y comprensivo", "Extremadamente formal", "Amistoso pero profesional"], value="Persuasivo")
-                    craft_button = gr.Button("Forjar Prompt de Email", variant="primary")
-                with gr.Column(scale=2):
-                    gr.Markdown("### 2. El Resultado de la Forja")
-                    prompt, insight, tip = self.build_output_components()
+    def _render_chain_display(self, chain_data: list) -> str:
+        """Renders the current prompt chain as a rich Markdown string."""
+        if not chain_data:
+            return "<div style='text-align: center; padding: 5em 0;'><p style='font-size: 1.2em; color: #888;'>Your Prompt Chain is empty.</p><p style='color: #666;'>Select a Node Type from the Workshop to begin.</p></div>"
+        
+        html = ""
+        for i, node in enumerate(chain_data):
+            refinements_str = ", ".join(r.replace("_", " ").title() for r in node['refinements_applied'])
+            refinements_html = f"<p style='color: #89CFF3; font-size: 0.9em;'><strong>Refinements:</strong> {refinements_str}</p>" if refinements_str else ""
+
+            html += f"""
+            <div class='node-card'>
+                <div class='node-header'><span class='node-icon'>{node['icon']}</span><span>Node {i+1}: {node['node_type']}</span></div>
+                <hr style='border-color: #30363d;'>
+                <p><strong>// Rationale //</strong><br>{node['explanation']}</p>
+                {refinements_html}
+                {self.engine._render_prompt_anatomy(node['prompt'])}
+            </div>
+            """
+            if i < len(chain_data) - 1:
+                html += "<div style='text-align: center; font-size: 2em; color: #444; margin: -0.5em 0;'>↓</div>"
+
+        return html
 
-            craft_button.click(
-                fn=self.craftsman.craft_diplomatic_email,
-                inputs=[recipient_input, role_input, goal_input, key_points_input, tone_input],
-                outputs=[prompt, insight, tip]
-            )
+    def launch(self):
+        """Builds and launches the full Gradio application."""
+        with gr.Blocks(theme=self.theme, css=self.css, title="SYNAPSE") as app:
+            # STATE MANAGEMENT
+            chain_state = gr.State([]) # Holds the list of node dicts
+            active_node_id = gr.State(None)
+
+            # HEADER
+            gr.HTML("""<div style='text-align: center; padding: 2rem 0;'><h1 style='color: #00A9FF; font-size: 3rem; font-weight: 800; margin: 0;'>S Y N A P S E</h1><p style='color: #89CFF3; font-size: 1.2rem;'>The Dynamic Prompting Environment</p></div>""")
 
-    def build_creator_workbench(self):
-        """Construye la interfaz para el Banco de Trabajo del Creador."""
-        with gr.Tab("🎨 El Estudio del Creador (Contenido)"):
             with gr.Row():
+                # LEFT COLUMN: THE WORKSHOP (INPUTS)
                 with gr.Column(scale=1):
-                    gr.Markdown("### 1. Prepara tu Lienzo Creativo")
-                    topic_input = gr.Textbox(label="¿Cuál es el tema central?", placeholder="Ej: El futuro del trabajo remoto")
-                    format_input = gr.Dropdown(label="Formato del Contenido", choices=["Artículo de Blog", "Guion para video de YouTube (5 min)", "Hilo para Twitter/X", "Post de LinkedIn", "Letra de una canción"], value="Artículo de Blog")
-                    audience_input = gr.Textbox(label="¿Para quién es?", placeholder="Ej: Jóvenes profesionales de la tecnología")
-                    style_input = gr.Textbox(label="Estilo de Escritura Deseado", placeholder="Ej: Inspirador y visionario, Técnico y detallado, Divertido e irreverente")
-                    goals_input = gr.Textbox(label="Objetivos (¿Qué debe pensar/sentir/hacer la audiencia?)", placeholder="Ej: Sentirse optimistas sobre el futuro, Compartir el post, etc.")
-                    craft_button = gr.Button("Forjar Prompt Creativo", variant="primary")
+                    gr.Markdown("### <strong>1. The Workshop</strong>")
+                    node_selector = gr.Dropdown(
+                        label="Select Node Type to Add",
+                        choices=[(d['name'], k) for k, d in NodeBlueprint.NODE_TEMPLATES.items()],
+                        value=None
+                    )
+                    
+                    # Create input groups for all node types, initially hidden
+                    input_groups = {}
+                    for node_id, template in NodeBlueprint.NODE_TEMPLATES.items():
+                        with gr.Group(visible=False) as input_groups[node_id]:
+                            gr.Markdown(f"#### {template['icon']} {template['name']}")
+                            gr.Markdown(f"<p style='font-size:0.9em; color:#888;'>{template['description']}</p>")
+                            inputs = []
+                            for field in template['inputs']:
+                                if 'choices' in field:
+                                    inputs.append(gr.Dropdown(label=field['label'], choices=field['choices'], value=field.get('value')))
+                                else:
+                                    inputs.append(gr.Textbox(label=field['label'], placeholder=field.get('placeholder', ''), lines=field.get('lines', 1)))
+                        input_groups[node_id].__setattr__("inputs", inputs)
+
+                    add_node_button = gr.Button("Add Node to Chain", variant="primary", visible=False)
+
+                    # REFINEMENT WORKBENCH (dynamically populated)
+                    with gr.Group(visible=False) as refinement_group:
+                        gr.Markdown("### <strong>3. Refinement Workbench</strong>")
+                        gr.Markdown("<p style='font-size:0.9em; color:#888;'>Mutate the **last node** in the chain.</p>")
+                        refinement_buttons = []
+                        all_actions = set(a for t in NodeBlueprint.NODE_TEMPLATES.values() for a in t['refinement_actions'])
+                        for action in all_actions:
+                            btn = gr.Button(action.replace("_", " ").title(), visible=False)
+                            refinement_buttons.append((action, btn))
+                    
+                    clear_chain_button = gr.Button("Clear Entire Chain", variant="secondary")
+
+                # RIGHT COLUMN: THE CHAIN DISPLAY
                 with gr.Column(scale=2):
-                    gr.Markdown("### 2. La Obra Maestra")
-                    prompt, insight, tip = self.build_output_components()
-
-            craft_button.click(
-                fn=self.craftsman.craft_creative_content,
-                inputs=[topic_input, format_input, audience_input, style_input, goals_input],
-                outputs=[prompt, insight, tip]
+                    gr.Markdown("### <strong>2. The Prompt Chain</strong>")
+                    chain_display = gr.HTML(self._render_chain_display([]), elem_id="chain_display")
+
+            # EVENT HANDLING LOGIC
+            def on_node_select(node_id):
+                active_node_id.value = node_id
+                updates = {group: gr.update(visible=k==node_id) for k, group in input_groups.items()}
+                updates[add_node_button] = gr.update(visible=bool(node_id))
+                return updates
+
+            def add_node_to_chain(chain_data, node_id, *inputs):
+                node_output = self.engine.craft_node_output(node_id, *inputs)
+                if node_output:
+                    chain_data.append(node_output)
+                
+                # Update refinement buttons visibility
+                refinement_updates = {}
+                last_node_actions = set(NodeBlueprint.NODE_TEMPLATES[node_id]['refinement_actions'])
+                for action, btn in refinement_buttons:
+                    refinement_updates[btn] = gr.update(visible=action in last_node_actions)
+
+                return {
+                    chain_state: chain_data,
+                    chain_display: self._render_chain_display(chain_data),
+                    refinement_group: gr.update(visible=True),
+                    **refinement_updates
+                }
+
+            def apply_refinement(chain_data, action):
+                if not chain_data: return chain_data, self._render_chain_display(chain_data)
+                
+                last_node = chain_data[-1]
+                # Avoid applying the same refinement twice
+                if action not in last_node["refinements_applied"]:
+                    original_prompt = last_node["prompt"]
+                    refined_prompt = self.engine.refine_node_prompt(original_prompt, action)
+                    last_node["prompt"] = refined_prompt
+                    last_node["refinements_applied"].append(action)
+                
+                return chain_data, self._render_chain_display(chain_data)
+
+            # Connect events to functions
+            node_selector.change(on_node_select, inputs=node_selector, outputs=[active_node_id, add_node_button] + list(input_groups.values()))
+
+            add_node_button.click(
+                add_node_to_chain, 
+                inputs=[chain_state, active_node_id] + list(inp for grp in input_groups.values() for inp in grp.inputs),
+                outputs=[chain_state, chain_display, refinement_group] + [b for _, b in refinement_buttons]
             )
 
-    def build_coder_workbench(self):
-        """Construye la interfaz para el Banco de Trabajo del Programador."""
-        with gr.Tab("🛠️ La Forja del Programador (Código)"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### 1. Define el Plano Técnico")
-                    lang_input = gr.Dropdown(label="Lenguaje de Programación", choices=["Python", "JavaScript", "SQL", "Java", "C++", "HTML/CSS", "Bash"], value="Python")
-                    task_input = gr.Textbox(label="Describe la tarea de programación", placeholder="Ej: Crear una función que lea un CSV y devuelva el promedio de una columna.", lines=3)
-                    constraints_input = gr.Textbox(label="Restricciones o Requisitos (Opcional)", placeholder="Ej: No usar la librería pandas, La función debe manejar archivos grandes, etc.")
-                    snippet_input = gr.Code(label="Pega aquí tu código existente (Opcional)", language="python", lines=5)
-                    craft_button = gr.Button("Forjar Prompt de Código", variant="primary")
-                with gr.Column(scale=2):
-                    gr.Markdown("### 2. La Solución Compilada")
-                    prompt, insight, tip = self.build_output_components()
+            for action, btn in refinement_buttons:
+                btn.click(
+                    apply_refinement,
+                    inputs=[chain_state, gr.State(action)],
+                    outputs=[chain_state, chain_display]
+                )
             
-            # Actualizar dinámicamente el lenguaje del snippet
-            lang_input.change(lambda x: gr.Code(language=x.lower()), inputs=lang_input, outputs=snippet_input)
-
-            craft_button.click(
-                fn=self.craftsman.craft_code_solution,
-                inputs=[lang_input, task_input, constraints_input, snippet_input],
-                outputs=[prompt, insight, tip]
+            clear_chain_button.click(
+                lambda: ([], self._render_chain_display([]), gr.update(visible=False)), 
+                None, 
+                [chain_state, chain_display, refinement_group]
             )
+            
+            # FOOTER
+            gr.Markdown("<hr style='border-color:#30363d;'><div style='text-align:center;color:#888;'>SYNAPSE v0.9 // Forging the future of human-AI interaction. <a href='https://www.linkedin.com/' target='_blank' style='color:#00A9FF;'>Let's connect.</a></div>")
 
-    def launch(self):
-        """Construye y lanza la aplicación Gradio completa."""
-        with gr.Blocks(theme=self.theme, title=APP_TITLE) as app:
-            gr.Markdown(MARKDOWN_HEADER)
-            with gr.Tabs():
-                self.build_diplomat_workbench()
-                self.build_creator_workbench()
-                self.build_coder_workbench()
-            gr.Markdown(MARKDOWN_FOOTER)
-        
-        # Lanza la aplicación con la cola habilitada para manejar múltiples usuarios.
         app.queue().launch(show_error=True)
 
-# ---------------------------------------------------------------------------------------
-# IV. PUNTO DE ENTRADA DE LA APLICACIÓN
-# El "main" que enciende la forja.
-# ---------------------------------------------------------------------------------------
-
 if __name__ == "__main__":
-    studio = UIBuilder()
-    studio.launch()
+    ui = SynapseUI()
+    ui.launch()