Update app.py

app.py

@@ -5,52 +5,30 @@ import os
 import logging
 import matplotlib
 matplotlib.use('Agg') # Set backend for Matplotlib to avoid GUI conflicts with Gradio
-import matplotlib.pyplot as plt
-import time # For profiling if needed
-from datetime import datetime, timedelta # Added timedelta
-import numpy as np
-from collections import OrderedDict, defaultdict # To maintain section order and for OKR processing
-import asyncio # For async operations
+# import time # No longer directly used here for profiling
+from datetime import datetime, timedelta
+# import numpy as np # No longer directly used here
+# from collections import OrderedDict, defaultdict # Moved or not needed directly
 
 # --- Module Imports ---
 from utils.gradio_utils import get_url_user_token
-# Functions from newly created/refactored modules
 from config import (
     LINKEDIN_CLIENT_ID_ENV_VAR, BUBBLE_APP_NAME_ENV_VAR,
-    BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR,
-    PLOT_ID_TO_FORMULA_KEY_MAP)
+    BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR) # PLOT_ID_TO_FORMULA_KEY_MAP moved
 from services.state_manager import process_and_store_bubble_token
 from services.sync_logic import sync_all_linkedin_data_orchestrator
-from ui.ui_generators import (
-    display_main_dashboard,
-    build_analytics_tab_plot_area, # EXPECTED TO RETURN: plot_ui_objects, section_titles_map
-    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON
-)
-from ui.analytics_plot_generator import update_analytics_plots_figures, create_placeholder_plot
-from formulas import PLOT_FORMULAS
+from ui.ui_generators import display_main_dashboard # Other UI generators moved or used internally by new modules
 
-# --- EXISTING CHATBOT MODULE IMPORTS ---
-from features.chatbot.chatbot_prompts import get_initial_insight_prompt_and_suggestions # MODIFIED IMPORT
-from features.chatbot.chatbot_handler import generate_llm_response
-# --- END EXISTING CHATBOT MODULE IMPORTS ---
+# --- NEW UI MODULE IMPORTS ---
+from ui import analytics_tab
+from ui import agentic_module
 
-# --- NEW AGENTIC PIPELINE IMPORTS ---
-try:
-    from run_agentic_pipeline import run_full_analytics_orchestration
-    from ui.insights_ui_generator import (
-        format_report_to_markdown,
-        extract_key_results_for_selection,
-        format_single_okr_for_display
-    )
-    AGENTIC_MODULES_LOADED = True
-except ImportError as e:
-    logging.error(f"Could not import agentic pipeline modules: {e}. Tabs 3 and 4 (formerly 5 and 6) will be disabled.")
-    AGENTIC_MODULES_LOADED = False
-    # Define placeholder functions if modules are not loaded to avoid NameErrors
-    async def run_full_analytics_orchestration(*args, **kwargs): return None
-    def format_report_to_markdown(report_string): return "Agentic modules not loaded. Report unavailable."
-    def extract_key_results_for_selection(okrs_dict): return []
-    def format_single_okr_for_display(okr_data, **kwargs): return "Agentic modules not loaded. OKR display unavailable."
+# --- EXISTING CHATBOT MODULE IMPORTS (used by analytics_tab) ---
+# from features.chatbot.chatbot_prompts import get_initial_insight_prompt_and_suggestions # Used in analytics_tab
+# from features.chatbot.chatbot_handler import generate_llm_response # Used in analytics_tab
+
+# --- AGENTIC PIPELINE IMPORTS (used by agentic_module) ---
+# AGENTIC_MODULES_LOADED is handled within agentic_module.py
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
@@ -58,532 +36,177 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 # 1. Set Vertex AI usage preference (if applicable)
 os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False"
 
-# 2. Get your API key from your chosen environment variable name
+# 2. Get your API key
 user_provided_api_key = os.environ.get("GEMINI_API_KEY")
-
 if user_provided_api_key:
     os.environ["GOOGLE_API_KEY"] = user_provided_api_key
     logging.info("GOOGLE_API_KEY environment variable has been set from GEMINI_API_KEY.")
 else:
-    logging.error(f"CRITICAL ERROR: The API key environment variable 'GEMINI_API_KEY' was not found. The application may not function correctly.")
+    logging.error(f"CRITICAL ERROR: The API key environment variable 'GEMINI_API_KEY' was not found.")
 
 
 # --- Gradio UI Blocks ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
-                title="LinkedIn Organization Dashboard") as app:
+               title="LinkedIn Organization Dashboard") as app:
+    
+    # --- Core States ---
     token_state = gr.State(value={
         "token": None, "client_id": None, "org_urn": None,
         "bubble_posts_df": pd.DataFrame(), "bubble_post_stats_df": pd.DataFrame(),
-        "bubble_mentions_df": pd.DataFrame(), # Data still in state, but not used by UI
-        "bubble_follower_stats_df": pd.DataFrame(), # Data still in state, but not used by UI
+        "bubble_mentions_df": pd.DataFrame(), "bubble_follower_stats_df": pd.DataFrame(),
         "fetch_count_for_api": 0, "url_user_token_temp_storage": None,
         "config_date_col_posts": "published_at", "config_date_col_mentions": "date",
         "config_date_col_followers": "date", "config_media_type_col": "media_type",
         "config_eb_labels_col": "li_eb_label"
     })
 
-    # States for existing analytics tab chatbot
+    # States for analytics tab chatbot (passed to analytics_tab module)
     chat_histories_st = gr.State({})
     current_chat_plot_id_st = gr.State(None)
-    plot_data_for_chatbot_st = gr.State({})
+    plot_data_for_chatbot_st = gr.State({}) # Populated by analytics_tab.handle_refresh_analytics_graphs
+    active_panel_action_state = gr.State(None) # For insights/formula panel
+    explored_plot_id_state = gr.State(None) # For explore plot view
 
-    # --- NEW STATES FOR AGENTIC PIPELINE ---
+    # States for Agentic Pipeline (passed to agentic_module)
     orchestration_raw_results_st = gr.State(None)
-    key_results_for_selection_st = gr.State([])
-    selected_key_result_ids_st = gr.State([])
-
+    key_results_for_selection_st = gr.State([]) # Stores the list of dicts for choices
+    selected_key_result_ids_st = gr.State([]) # Stores the selected unique_kr_ids
 
+    # --- Top Level UI ---
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
     url_user_token_display = gr.Textbox(label="User Token (Nascosto)", interactive=False, visible=False)
     status_box = gr.Textbox(label="Stato Generale Token LinkedIn", interactive=False, value="Inizializzazione...")
     org_urn_display = gr.Textbox(label="URN Organizzazione (Nascosto)", interactive=False, visible=False)
 
+    # Load URL parameters on app load
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display], api_name="get_url_params", show_progress=False)
 
-    def initial_load_sequence(url_token, org_urn_val, current_state):
-        status_msg, new_state, btn_update = process_and_store_bubble_token(url_token, org_urn_val, current_state)
-        dashboard_content = display_main_dashboard(new_state)
-        return status_msg, new_state, btn_update, dashboard_content
-
+    # --- Tabs ---
     with gr.Tabs() as tabs:
+        # --- Tab 1: Dashboard & Sync ---
         with gr.TabItem("1️⃣ Dashboard & Sync", id="tab_dashboard_sync"):
             gr.Markdown("Il sistema controlla i dati esistenti da Bubble. 'Sincronizza' si attiva se sono necessari nuovi dati.")
             sync_data_btn = gr.Button("🔄 Sincronizza Dati LinkedIn", variant="primary", visible=False, interactive=False)
             sync_status_html_output = gr.HTML("<p style='text-align:center;'>Stato sincronizzazione...</p>")
             dashboard_display_html = gr.HTML("<p style='text-align:center;'>Caricamento dashboard...</p>")
 
-        with gr.TabItem("2️⃣ Analisi Grafici", id="tab_analytics"): # Renamed for clarity
-            gr.Markdown("## 📈 Analisi Performance LinkedIn")
-            gr.Markdown("Seleziona un intervallo di date per i grafici. Clicca i pulsanti (💣 Insights, ƒ Formula, 🧭 Esplora) su un grafico per azioni.")
-            analytics_status_md = gr.Markdown("Stato analisi grafici...")
-
-            with gr.Row():
-                date_filter_selector = gr.Radio(
-                    ["Sempre", "Ultimi 7 Giorni", "Ultimi 30 Giorni", "Intervallo Personalizzato"],
-                    label="Seleziona Intervallo Date per Grafici", value="Sempre", scale=3
-                )
-                with gr.Column(scale=2):
-                    custom_start_date_picker = gr.DateTime(label="Data Inizio", visible=False, include_time=False, type="datetime")
-                    custom_end_date_picker = gr.DateTime(label="Data Fine", visible=False, include_time=False, type="datetime")
-
-            apply_filter_btn = gr.Button("🔍 Applica Filtro & Aggiorna Grafici", variant="primary")
-
-            def toggle_custom_date_pickers(selection):
-                is_custom = selection == "Intervallo Personalizzato"
-                return gr.update(visible=is_custom), gr.update(visible=is_custom)
-
-            date_filter_selector.change(
-                fn=toggle_custom_date_pickers,
-                inputs=[date_filter_selector],
-                outputs=[custom_start_date_picker, custom_end_date_picker]
+        # --- Tab 2: Analisi Grafici ---
+        with gr.TabItem("2️⃣ Analisi Grafici", id="tab_analytics"):
+            # Build UI and wire internal events within analytics_tab module
+            (apply_filter_btn_analytics, date_filter_selector_analytics, 
+             custom_start_date_picker_analytics, custom_end_date_picker_analytics,
+             analytics_status_md_ref, # Reference to the status markdown in analytics tab
+             analytics_refresh_outputs_components, # list of components for refresh handler output
+             analytics_refresh_outputs_plus_states # list of components + states for refresh handler output
+            ) = analytics_tab.build_and_wire_tab(
+                token_state, chat_histories_st, current_chat_plot_id_st, 
+                plot_data_for_chatbot_st, active_panel_action_state, explored_plot_id_state
             )
-
-            plot_configs = [
-                {"label": "Numero di Follower nel Tempo", "id": "followers_count", "section": "Dinamiche dei Follower"},
-                {"label": "Tasso di Crescita Follower", "id": "followers_growth_rate", "section": "Dinamiche dei Follower"},
-                {"label": "Follower per Località", "id": "followers_by_location", "section": "Demografia Follower"},
-                {"label": "Follower per Ruolo (Funzione)", "id": "followers_by_role", "section": "Demografia Follower"},
-                {"label": "Follower per Settore", "id": "followers_by_industry", "section": "Demografia Follower"},
-                {"label": "Follower per Anzianità", "id": "followers_by_seniority", "section": "Demografia Follower"},
-                {"label": "Tasso di Engagement nel Tempo", "id": "engagement_rate", "section": "Approfondimenti Performance Post"},
-                {"label": "Copertura nel Tempo", "id": "reach_over_time", "section": "Approfondimenti Performance Post"},
-                {"label": "Visualizzazioni nel Tempo", "id": "impressions_over_time", "section": "Approfondimenti Performance Post"},
-                {"label": "Reazioni (Like) nel Tempo", "id": "likes_over_time", "section": "Approfondimenti Performance Post"},
-                {"label": "Click nel Tempo", "id": "clicks_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
-                {"label": "Condivisioni nel Tempo", "id": "shares_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
-                {"label": "Commenti nel Tempo", "id": "comments_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
-                {"label": "Ripartizione Commenti per Sentiment", "id": "comments_sentiment", "section": "Engagement Dettagliato Post nel Tempo"},
-                {"label": "Frequenza Post", "id": "post_frequency_cs", "section": "Analisi Strategia Contenuti"},
-                {"label": "Ripartizione Contenuti per Formato", "id": "content_format_breakdown_cs", "section": "Analisi Strategia Contenuti"},
-                {"label": "Ripartizione Contenuti per Argomenti", "id": "content_topic_breakdown_cs", "section": "Analisi Strategia Contenuti"},
-                {"label": "Volume Menzioni nel Tempo (Dettaglio)", "id": "mention_analysis_volume", "section": "Analisi Menzioni (Dettaglio)"}, # This plot might need data from the removed mentions tab. Consider if this plot should also be removed or if its data source is independent.
-                {"label": "Ripartizione Menzioni per Sentiment (Dettaglio)", "id": "mention_analysis_sentiment", "section": "Analisi Menzioni (Dettaglio)"} # Same as above.
-            ]
-            # IMPORTANT: Review if 'mention_analysis_volume' and 'mention_analysis_sentiment' plots
-            # can still be generated without the dedicated mentions data processing.
-            # If not, they should also be removed from plot_configs.
-            # For now, I am assuming they might draw from a general data pool in token_state.
-
-            assert len(plot_configs) == 19, "Mancata corrispondenza in plot_configs e grafici attesi. (If mentions plots were removed, adjust this number)"
-            
-            unique_ordered_sections = list(OrderedDict.fromkeys(pc["section"] for pc in plot_configs))
-            num_unique_sections = len(unique_ordered_sections)
-
-            active_panel_action_state = gr.State(None)
-            explored_plot_id_state = gr.State(None)
-
-            plot_ui_objects = {}
-            section_titles_map = {}
-
-            with gr.Row(equal_height=False):
-                with gr.Column(scale=8) as plots_area_col:
-                    ui_elements_tuple = build_analytics_tab_plot_area(plot_configs)
-                    if isinstance(ui_elements_tuple, tuple) and len(ui_elements_tuple) == 2:
-                        plot_ui_objects, section_titles_map = ui_elements_tuple
-                        if not all(sec_name in section_titles_map for sec_name in unique_ordered_sections):
-                            logging.error("section_titles_map from build_analytics_tab_plot_area is incomplete.")
-                            for sec_name in unique_ordered_sections:
-                                if sec_name not in section_titles_map:
-                                    section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
-                    else:
-                        logging.error("build_analytics_tab_plot_area did not return a tuple of (plot_ui_objects, section_titles_map).")
-                        plot_ui_objects = ui_elements_tuple if isinstance(ui_elements_tuple, dict) else {}
-                        for sec_name in unique_ordered_sections:
-                            section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
-
-
-                with gr.Column(scale=4, visible=False) as global_actions_column_ui:
-                    gr.Markdown("### 💡 Azioni Contestuali Grafico")
-                    insights_chatbot_ui = gr.Chatbot(
-                        label="Chat Insights", type="messages", height=450,
-                        bubble_full_width=False, visible=False, show_label=False,
-                        placeholder="L'analisi AI del grafico apparirà qui. Fai domande di approfondimento!"
-                    )
-                    insights_chat_input_ui = gr.Textbox(
-                        label="La tua domanda:", placeholder="Chiedi all'AI riguardo a questo grafico...",
-                        lines=2, visible=False, show_label=False
-                    )
-                    with gr.Row(visible=False) as insights_suggestions_row_ui:
-                        insights_suggestion_1_btn = gr.Button(value="Suggerimento 1", size="sm", min_width=50)
-                        insights_suggestion_2_btn = gr.Button(value="Suggerimento 2", size="sm", min_width=50)
-                        insights_suggestion_3_btn = gr.Button(value="Suggerimento 3", size="sm", min_width=50)
-
-                    formula_display_markdown_ui = gr.Markdown(
-                        "I dettagli sulla formula/metodologia appariranno qui.", visible=False
-                    )
-                    formula_close_hint_md = gr.Markdown(
-                        "<p style='font-size:0.9em; text-align:center; margin-top:10px;'><em>Click the active ƒ button on the plot again to close this panel.</em></p>",
-                        visible=False
-                    )
-
-            async def handle_panel_action(
-                plot_id_clicked: str, action_type: str, current_active_action_from_state: dict,
-                current_chat_histories: dict, current_chat_plot_id: str,
-                current_plot_data_for_chatbot: dict, current_explored_plot_id: str
-            ):
-                logging.info(f"Panel Action: '{action_type}' for plot '{plot_id_clicked}'. Active: {current_active_action_from_state}, Explored: {current_explored_plot_id}")
-                clicked_plot_config = next((p for p in plot_configs if p["id"] == plot_id_clicked), None)
-                if not clicked_plot_config:
-                    logging.error(f"Config not found for plot_id {plot_id_clicked}")
-                    num_plots = len(plot_configs)
-                    error_list_len = 15 + (4 * num_plots) + num_unique_sections
-                    error_list = [gr.update()] * error_list_len
-                    error_list[11] = current_active_action_from_state; error_list[12] = current_chat_plot_id
-                    error_list[13] = current_chat_histories; error_list[14] = current_explored_plot_id
-                    return error_list
-                clicked_plot_label = clicked_plot_config["label"]; clicked_plot_section = clicked_plot_config["section"]
-                hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
-                is_toggling_off = current_active_action_from_state == hypothetical_new_active_state
-                action_col_visible_update = gr.update(visible=False)
-                insights_chatbot_visible_update, insights_chat_input_visible_update, insights_suggestions_row_visible_update = gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
-                formula_display_visible_update = gr.update(visible=False); formula_close_hint_visible_update = gr.update(visible=False)
-                chatbot_content_update, s1_upd, s2_upd, s3_upd, formula_content_update = gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
-                new_active_action_state_to_set, new_current_chat_plot_id = None, current_chat_plot_id
-                updated_chat_histories, new_explored_plot_id_to_set = current_chat_histories, current_explored_plot_id
-                generated_panel_vis_updates = []; generated_bomb_btn_updates = []; generated_formula_btn_updates = []; generated_explore_btn_updates = []
-                section_title_vis_updates = [gr.update()] * num_unique_sections
-                if is_toggling_off:
-                    new_active_action_state_to_set = None; action_col_visible_update = gr.update(visible=False)
-                    logging.info(f"Toggling OFF panel {action_type} for {plot_id_clicked}.")
-                    for _ in plot_configs: generated_bomb_btn_updates.append(gr.update(value=BOMB_ICON)); generated_formula_btn_updates.append(gr.update(value=FORMULA_ICON))
-                    if current_explored_plot_id:
-                        explored_cfg = next((p for p in plot_configs if p["id"] == current_explored_plot_id), None)
-                        explored_sec = explored_cfg["section"] if explored_cfg else None
-                        for i, sec_name in enumerate(unique_ordered_sections): section_title_vis_updates[i] = gr.update(visible=(sec_name == explored_sec))
-                        for cfg in plot_configs: is_exp = (cfg["id"] == current_explored_plot_id); generated_panel_vis_updates.append(gr.update(visible=is_exp)); generated_explore_btn_updates.append(gr.update(value=ACTIVE_ICON if is_exp else EXPLORE_ICON))
-                    else:
-                        for i in range(num_unique_sections): section_title_vis_updates[i] = gr.update(visible=True)
-                        for _ in plot_configs: generated_panel_vis_updates.append(gr.update(visible=True)); generated_explore_btn_updates.append(gr.update(value=EXPLORE_ICON))
-                    if action_type == "insights": new_current_chat_plot_id = None
-                else:
-                    new_active_action_state_to_set = hypothetical_new_active_state; action_col_visible_update = gr.update(visible=True)
-                    new_explored_plot_id_to_set = None
-                    logging.info(f"Toggling ON panel {action_type} for {plot_id_clicked}. Cancelling explore view if any.")
-                    for i, sec_name in enumerate(unique_ordered_sections): section_title_vis_updates[i] = gr.update(visible=(sec_name == clicked_plot_section))
-                    for cfg in plot_configs: generated_panel_vis_updates.append(gr.update(visible=(cfg["id"] == plot_id_clicked))); generated_explore_btn_updates.append(gr.update(value=EXPLORE_ICON))
-                    for cfg_btn in plot_configs:
-                        is_act_ins = new_active_action_state_to_set == {"plot_id": cfg_btn["id"], "type": "insights"}
-                        is_act_for = new_active_action_state_to_set == {"plot_id": cfg_btn["id"], "type": "formula"}
-                        generated_bomb_btn_updates.append(gr.update(value=ACTIVE_ICON if is_act_ins else BOMB_ICON)); generated_formula_btn_updates.append(gr.update(value=ACTIVE_ICON if is_act_for else FORMULA_ICON))
-                    if action_type == "insights":
-                        insights_chatbot_visible_update, insights_chat_input_visible_update, insights_suggestions_row_visible_update = gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)
-                        new_current_chat_plot_id = plot_id_clicked
-                        history = current_chat_histories.get(plot_id_clicked, [])
-                        summary = current_plot_data_for_chatbot.get(plot_id_clicked, f"No summary for '{clicked_plot_label}'.")
-                        if not history:
-                            prompt, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary)
-                            llm_hist = [{"role": "user", "content": prompt}]
-                            resp = await generate_llm_response(prompt, plot_id_clicked, clicked_plot_label, llm_hist, summary)
-                            history = [{"role": "assistant", "content": resp}]; updated_chat_histories = {**current_chat_histories, plot_id_clicked: history}
-                        else: _, sugg = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, summary)
-                        chatbot_content_update = gr.update(value=history)
-                        s1_upd,s2_upd,s3_upd = gr.update(value=sugg[0] if sugg else "N/A"),gr.update(value=sugg[1] if len(sugg)>1 else "N/A"),gr.update(value=sugg[2] if len(sugg)>2 else "N/A")
-                    elif action_type == "formula":
-                        formula_display_visible_update = gr.update(visible=True); formula_close_hint_visible_update = gr.update(visible=True)
-                        f_key = PLOT_ID_TO_FORMULA_KEY_MAP.get(plot_id_clicked)
-                        f_text = f"**Formula/Methodology for: {clicked_plot_label}** (ID: `{plot_id_clicked}`)\n\n"
-                        if f_key and f_key in PLOT_FORMULAS: f_data = PLOT_FORMULAS[f_key]; f_text += f"### {f_data['title']}\n\n{f_data['description']}\n\n**Calculation:**\n" + "\n".join([f"- {s}" for s in f_data['calculation_steps']])
-                        else: f_text += "(No detailed formula information found.)"
-                        formula_content_update = gr.update(value=f_text); new_current_chat_plot_id = None
-                final_updates = [action_col_visible_update, insights_chatbot_visible_update, chatbot_content_update, insights_chat_input_visible_update, insights_suggestions_row_visible_update, s1_upd, s2_upd, s3_upd, formula_display_visible_update, formula_content_update, formula_close_hint_visible_update, new_active_action_state_to_set, new_current_chat_plot_id, updated_chat_histories, new_explored_plot_id_to_set]
-                final_updates.extend(generated_panel_vis_updates); final_updates.extend(generated_bomb_btn_updates); final_updates.extend(generated_formula_btn_updates); final_updates.extend(generated_explore_btn_updates); final_updates.extend(section_title_vis_updates)
-                logging.debug(f"handle_panel_action returning {len(final_updates)} updates. Expected {15 + 4*len(plot_configs) + num_unique_sections}.")
-                return final_updates
-
-            async def handle_chat_message_submission(user_message: str, current_plot_id: str, chat_histories: dict, current_plot_data_for_chatbot: dict ):
-                if not current_plot_id or not user_message.strip():
-                    current_history_for_plot = chat_histories.get(current_plot_id, [])
-                    if not isinstance(current_history_for_plot, list): current_history_for_plot = []
-                    yield current_history_for_plot, gr.update(value=""), chat_histories; return
-                cfg = next((p for p in plot_configs if p["id"] == current_plot_id), None)
-                lbl = cfg["label"] if cfg else "Selected Plot"
-                summary = current_plot_data_for_chatbot.get(current_plot_id, f"No summary for '{lbl}'.")
-                hist_for_plot = chat_histories.get(current_plot_id, [])
-                if not isinstance(hist_for_plot, list): hist_for_plot = []
-                hist = hist_for_plot.copy() + [{"role": "user", "content": user_message}]
-                yield hist, gr.update(value=""), chat_histories
-                resp = await generate_llm_response(user_message, current_plot_id, lbl, hist, summary)
-                hist.append({"role": "assistant", "content": resp})
-                updated_chat_histories = {**chat_histories, current_plot_id: hist}
-                yield hist, "", updated_chat_histories
-
-            async def handle_suggested_question_click(suggestion_text: str, current_plot_id: str, chat_histories: dict, current_plot_data_for_chatbot: dict):
-                if not current_plot_id or not suggestion_text.strip() or suggestion_text == "N/A":
-                    current_history_for_plot = chat_histories.get(current_plot_id, [])
-                    if not isinstance(current_history_for_plot, list): current_history_for_plot = []
-                    yield current_history_for_plot, gr.update(value=""), chat_histories; return
-                async for update_chunk in handle_chat_message_submission(suggestion_text, current_plot_id, chat_histories, current_plot_data_for_chatbot):
-                    yield update_chunk
-
-            def handle_explore_click(plot_id_clicked, current_explored_plot_id_from_state, current_active_panel_action_state):
-                logging.info(f"Explore Click: Plot '{plot_id_clicked}'. Current Explored: {current_explored_plot_id_from_state}. Active Panel: {current_active_panel_action_state}")
-                num_plots = len(plot_configs)
-                if not plot_ui_objects:
-                    logging.error("plot_ui_objects not populated for handle_explore_click.")
-                    error_list_len = 4 + (4 * num_plots) + num_unique_sections; error_list = [gr.update()] * error_list_len
-                    error_list[0] = current_explored_plot_id_from_state; error_list[2] = current_active_panel_action_state
-                    return error_list
-                new_explored_id_to_set = None
-                is_toggling_off_explore = (plot_id_clicked == current_explored_plot_id_from_state)
-                action_col_upd = gr.update(); new_active_panel_state_upd = current_active_panel_action_state; formula_hint_upd = gr.update(visible=False)
-                panel_vis_updates = []; explore_btns_updates = []; bomb_btns_updates = []; formula_btns_updates = []
-                section_title_vis_updates = [gr.update()] * num_unique_sections
-                clicked_cfg = next((p for p in plot_configs if p["id"] == plot_id_clicked), None)
-                sec_of_clicked = clicked_cfg["section"] if clicked_cfg else None
-                if is_toggling_off_explore:
-                    new_explored_id_to_set = None
-                    logging.info(f"Stopping explore for {plot_id_clicked}. All plots/sections to be visible.")
-                    for i in range(num_unique_sections): section_title_vis_updates[i] = gr.update(visible=True)
-                    for _ in plot_configs: panel_vis_updates.append(gr.update(visible=True)); explore_btns_updates.append(gr.update(value=EXPLORE_ICON)); bomb_btns_updates.append(gr.update()); formula_btns_updates.append(gr.update())
-                else:
-                    new_explored_id_to_set = plot_id_clicked
-                    logging.info(f"Exploring {plot_id_clicked}. Hiding other plots/sections.")
-                    for i, sec_name in enumerate(unique_ordered_sections): section_title_vis_updates[i] = gr.update(visible=(sec_name == sec_of_clicked))
-                    for cfg in plot_configs: is_target = (cfg["id"] == new_explored_id_to_set); panel_vis_updates.append(gr.update(visible=is_target)); explore_btns_updates.append(gr.update(value=ACTIVE_ICON if is_target else EXPLORE_ICON))
-                    if current_active_panel_action_state:
-                        logging.info("Closing active insight/formula panel due to explore click.")
-                        action_col_upd = gr.update(visible=False); new_active_panel_state_upd = None; formula_hint_upd = gr.update(visible=False)
-                        bomb_btns_updates = [gr.update(value=BOMB_ICON) for _ in plot_configs]; formula_btns_updates = [gr.update(value=FORMULA_ICON) for _ in plot_configs]
-                    else: bomb_btns_updates = [gr.update() for _ in plot_configs]; formula_btns_updates = [gr.update() for _ in plot_configs]
-                final_explore_updates = [new_explored_id_to_set, action_col_upd, new_active_panel_state_upd, formula_hint_upd]
-                final_explore_updates.extend(panel_vis_updates); final_explore_updates.extend(explore_btns_updates); final_explore_updates.extend(bomb_btns_updates); final_explore_updates.extend(formula_btns_updates); final_explore_updates.extend(section_title_vis_updates)
-                logging.debug(f"handle_explore_click returning {len(final_explore_updates)} updates. Expected {4 + 4*len(plot_configs) + num_unique_sections}.")
-                return final_explore_updates
-
-            _base_action_panel_ui_outputs = [global_actions_column_ui, insights_chatbot_ui, insights_chatbot_ui, insights_chat_input_ui, insights_suggestions_row_ui, insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn, formula_display_markdown_ui, formula_display_markdown_ui, formula_close_hint_md]
-            _action_panel_state_outputs = [active_panel_action_state, current_chat_plot_id_st, chat_histories_st, explored_plot_id_state]
-            action_panel_outputs_list = _base_action_panel_ui_outputs + _action_panel_state_outputs
-            action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in plot_configs]); action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in plot_configs]); action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in plot_configs]); action_panel_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in plot_configs]); action_panel_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections])
-            _explore_base_outputs = [explored_plot_id_state, global_actions_column_ui, active_panel_action_state, formula_close_hint_md]
-            explore_outputs_list = _explore_base_outputs
-            explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("panel_component", gr.update()) for pc in plot_configs]); explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("explore_button", gr.update()) for pc in plot_configs]); explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("bomb_button", gr.update()) for pc in plot_configs]); explore_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in plot_configs]); explore_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections])
-            action_click_inputs = [active_panel_action_state, chat_histories_st, current_chat_plot_id_st, plot_data_for_chatbot_st, explored_plot_id_state]
-            explore_click_inputs = [explored_plot_id_state, active_panel_action_state]
-            def create_panel_action_handler(p_id, action_type_str):
-                async def _handler(curr_active_val, curr_chats_val, curr_chat_pid, curr_plot_data, curr_explored_id): return await handle_panel_action(p_id, action_type_str, curr_active_val, curr_chats_val, curr_chat_pid, curr_plot_data, curr_explored_id)
-                return _handler
-            for config_item in plot_configs:
-                plot_id = config_item["id"]
-                if plot_id in plot_ui_objects:
-                    ui_obj = plot_ui_objects[plot_id]
-                    if ui_obj.get("bomb_button"): ui_obj["bomb_button"].click(fn=create_panel_action_handler(plot_id, "insights"), inputs=action_click_inputs, outputs=action_panel_outputs_list, api_name=f"action_insights_{plot_id}")
-                    if ui_obj.get("formula_button"): ui_obj["formula_button"].click(fn=create_panel_action_handler(plot_id, "formula"), inputs=action_click_inputs, outputs=action_panel_outputs_list, api_name=f"action_formula_{plot_id}")
-                    if ui_obj.get("explore_button"): ui_obj["explore_button"].click(fn=lambda current_explored_val, current_active_panel_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val, current_active_panel_val), inputs=explore_click_inputs, outputs=explore_outputs_list, api_name=f"action_explore_{plot_id}")
-                else: logging.warning(f"UI object for plot_id '{plot_id}' not found for click handlers.")
-            chat_submission_outputs = [insights_chatbot_ui, insights_chat_input_ui, chat_histories_st]
-            chat_submission_inputs = [insights_chat_input_ui, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
-            insights_chat_input_ui.submit(fn=handle_chat_message_submission, inputs=chat_submission_inputs, outputs=chat_submission_outputs, api_name="submit_chat_message")
-            suggestion_click_inputs_base = [current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
-            insights_suggestion_1_btn.click(fn=handle_suggested_question_click, inputs=[insights_suggestion_1_btn] + suggestion_click_inputs_base, outputs=chat_submission_outputs, api_name="click_suggestion_1")
-            insights_suggestion_2_btn.click(fn=handle_suggested_question_click, inputs=[insights_suggestion_2_btn] + suggestion_click_inputs_base, outputs=chat_submission_outputs, api_name="click_suggestion_2")
-            insights_suggestion_3_btn.click(fn=handle_suggested_question_click, inputs=[insights_suggestion_3_btn] + suggestion_click_inputs_base, outputs=chat_submission_outputs, api_name="click_suggestion_3")
-
-        # Tab 3 (Menzioni) and Tab 4 (Statistiche Follower) are removed.
-
-        with gr.TabItem("3️⃣ Agentic Analysis Report", id="tab_agentic_report", visible=AGENTIC_MODULES_LOADED): # Renumbered from 5
-            gr.Markdown("## 🤖 Comprehensive Analysis Report (AI Generated)")
-            agentic_pipeline_status_md = gr.Markdown("Stato Pipeline AI (filtro 'Sempre'): In attesa...", visible=True)
-            gr.Markdown("Questo report è generato da un agente AI con filtro 'Sempre' sui dati disponibili. Rivedi criticamente.")
-            agentic_report_display_md = gr.Markdown("La pipeline AI si avvierà automaticamente dopo il caricamento iniziale dei dati o dopo una sincronizzazione.")
-            if not AGENTIC_MODULES_LOADED: gr.Markdown("🔴 **Error:** Agentic pipeline modules could not be loaded. This tab is disabled.")
-
-        with gr.TabItem("4️⃣ Agentic OKRs & Tasks", id="tab_agentic_okrs", visible=AGENTIC_MODULES_LOADED): # Renumbered from 6
-            gr.Markdown("## 🎯 AI Generated OKRs and Actionable Tasks (filtro 'Sempre')")
-            gr.Markdown("Basato sull'analisi AI (filtro 'Sempre'), l'agente ha proposto i seguenti OKR e task. Seleziona i Key Results per dettagli.")
-            if not AGENTIC_MODULES_LOADED: gr.Markdown("🔴 **Error:** Agentic pipeline modules could not be loaded. This tab is disabled.")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### Suggested Key Results (da analisi 'Sempre')")
-                    key_results_cbg = gr.CheckboxGroup(label="Select Key Results", choices=[], value=[], interactive=True)
-                with gr.Column(scale=3):
-                    gr.Markdown("### Detailed OKRs and Tasks for Selected Key Results")
-                    okr_detail_display_md = gr.Markdown("I dettagli OKR appariranno qui dopo l'esecuzione della pipeline AI.")
-            def update_okr_display_on_selection(selected_kr_unique_ids: list, raw_orchestration_results: dict, all_krs_for_selection: list):
-                if not raw_orchestration_results or not AGENTIC_MODULES_LOADED: return gr.update(value="Nessun dato dalla pipeline AI o moduli non caricati.")
-                actionable_okrs_dict = raw_orchestration_results.get("actionable_okrs_and_tasks")
-                if not actionable_okrs_dict or not isinstance(actionable_okrs_dict.get("okrs"), list): return gr.update(value="Nessun OKR trovato nei risultati della pipeline.")
-                okrs_list = actionable_okrs_dict["okrs"]
-                kr_id_to_indices = {kr_info['unique_kr_id']: (kr_info['okr_index'], kr_info['kr_index']) for kr_info in all_krs_for_selection}
-                selected_krs_by_okr_idx = defaultdict(list)
-                if selected_kr_unique_ids:
-                    for kr_unique_id in selected_kr_unique_ids:
-                        if kr_unique_id in kr_id_to_indices: okr_idx, kr_idx = kr_id_to_indices[kr_unique_id]; selected_krs_by_okr_idx[okr_idx].append(kr_idx)
-                output_md_parts = []
-                if not okrs_list: output_md_parts.append("Nessun OKR generato.")
-                else:
-                    for okr_idx, okr_data in enumerate(okrs_list):
-                        accepted_indices_for_this_okr = selected_krs_by_okr_idx.get(okr_idx)
-                        if selected_kr_unique_ids:
-                            if accepted_indices_for_this_okr is not None: output_md_parts.append(format_single_okr_for_display(okr_data, accepted_kr_indices=accepted_indices_for_this_okr, okr_main_index=okr_idx))
-                        else: output_md_parts.append(format_single_okr_for_display(okr_data, accepted_kr_indices=None, okr_main_index=okr_idx))
-                if not output_md_parts and selected_kr_unique_ids: final_md = "Nessun OKR corrisponde alla selezione corrente o i KR selezionati non hanno task dettagliati."
-                elif not output_md_parts and not selected_kr_unique_ids: final_md = "Nessun OKR generato."
-                else: final_md = "\n\n---\n\n".join(output_md_parts)
-                return gr.update(value=final_md)
-            if AGENTIC_MODULES_LOADED:
-                key_results_cbg.change(fn=update_okr_display_on_selection, inputs=[key_results_cbg, orchestration_raw_results_st, key_results_for_selection_st], outputs=[okr_detail_display_md])
-
-    async def refresh_analytics_graphs_ui(current_token_state_val, date_filter_val, custom_start_val, custom_end_val, current_chat_histories_val):
-        logging.info("Refreshing analytics graph UI elements and resetting actions/chat.")
-        start_time = time.time()
-        plot_gen_results = update_analytics_plots_figures(current_token_state_val, date_filter_val, custom_start_val, custom_end_val, plot_configs)
-        status_msg, gen_figs, new_summaries = plot_gen_results[0], plot_gen_results[1:-1], plot_gen_results[-1]
-        all_updates = [status_msg]
-        all_updates.extend(gen_figs if len(gen_figs) == len(plot_configs) else [create_placeholder_plot("Error", f"Fig missing {i}") for i in range(len(plot_configs))])
-        all_updates.extend([gr.update(visible=False), gr.update(value=[], visible=False), gr.update(value="", visible=False), gr.update(visible=False), gr.update(value="S1"), gr.update(value="S2"), gr.update(value="S3"), gr.update(value="Formula details here.", visible=False), gr.update(visible=False)])
-        all_updates.extend([None, None, {}, new_summaries])
-        for _ in plot_configs: all_updates.extend([gr.update(value=BOMB_ICON), gr.update(value=FORMULA_ICON), gr.update(value=EXPLORE_ICON), gr.update(visible=True)])
-        all_updates.append(None)
-        all_updates.extend([gr.update(visible=True)] * num_unique_sections)
-        end_time = time.time()
-        logging.info(f"Analytics graph refresh took {end_time - start_time:.2f} seconds.")
-        expected_len = 15 + 5 * len(plot_configs) + num_unique_sections
-        logging.info(f"Prepared {len(all_updates)} updates for graph refresh. Expected {expected_len}.")
-        return tuple(all_updates)
-
-    async def run_agentic_pipeline_autonomously(current_token_state_val): # Removed request: gr.Request for simplicity
-        logging.info(f"Agentic pipeline check triggered for token_state update. Current token: {'Set' if current_token_state_val.get('token') else 'Not Set'}")
-
-        if not current_token_state_val or not current_token_state_val.get("token"):
-            logging.info("Agentic pipeline: Token not available in token_state. Skipping.")
-            yield (
-                gr.update(value="Pipeline AI: In attesa dei dati necessari..."),
-                gr.update(choices=[], value=[], interactive=False),
-                gr.update(value="Pipeline AI: In attesa dei dati necessari..."),
-                None, [], [], "Pipeline AI: In attesa dei dati..."
-            )
-            return
-
-        logging.info("Agentic pipeline starting autonomously with 'Sempre' filter.")
-        yield (
-            gr.update(value="Analisi AI (Sempre) in corso..."),
-            gr.update(choices=[], value=[], interactive=False),
-            gr.update(value="Dettagli OKR (Sempre) in corso di generazione..."),
-            orchestration_raw_results_st.value, # Preserve existing results if any during processing
-            selected_key_result_ids_st.value,
-            key_results_for_selection_st.value,
-            "Esecuzione pipeline AI (Sempre)..."
+        
+        # --- Tabs 3 & 4: Agentic Pipeline ---
+        # build_and_wire_tabs will create TabItems internally
+        agentic_pipeline_output_components = agentic_module.build_and_wire_tabs(
+            orchestration_raw_results_st, 
+            key_results_for_selection_st, 
+            selected_key_result_ids_st
         )
 
-        if not AGENTIC_MODULES_LOADED:
-            logging.warning("Agentic modules not loaded. Skipping autonomous pipeline.")
-            yield (
-                gr.update(value="Moduli AI non caricati. Report non disponibile."),
-                gr.update(choices=[], value=[], interactive=False),
-                gr.update(value="Moduli AI non caricati. OKR non disponibili."),
-                None, [], [], "Pipeline AI: Moduli non caricati."
-            )
-            return
 
-        try:
-            date_filter_val_agentic = "Sempre"; custom_start_val_agentic = None; custom_end_val_agentic = None
-            orchestration_output = await run_full_analytics_orchestration(current_token_state_val, date_filter_val_agentic, custom_start_val_agentic, custom_end_val_agentic)
-            agentic_status_text = "Pipeline AI (Sempre) completata."
-            logging.info(f"Autonomous agentic pipeline finished. Output keys: {orchestration_output.keys() if orchestration_output else 'None'}")
-            if orchestration_output:
-                orchestration_results_update = orchestration_output
-                report_str = orchestration_output.get('comprehensive_analysis_report')
-                agentic_report_md_update = gr.update(value=format_report_to_markdown(report_str))
-                actionable_okrs = orchestration_output.get('actionable_okrs_and_tasks')
-                krs_for_ui_selection_list = extract_key_results_for_selection(actionable_okrs)
-                krs_for_selection_update = krs_for_ui_selection_list
-                kr_choices_for_cbg = [(kr['kr_description'], kr['unique_kr_id']) for kr in krs_for_ui_selection_list]
-                key_results_cbg_update = gr.update(choices=kr_choices_for_cbg, value=[], interactive=True)
-                all_okrs_md_parts = []
-                if actionable_okrs and isinstance(actionable_okrs.get("okrs"), list):
-                    for okr_idx, okr_item in enumerate(actionable_okrs["okrs"]): all_okrs_md_parts.append(format_single_okr_for_display(okr_item, accepted_kr_indices=None, okr_main_index=okr_idx))
-                if not all_okrs_md_parts: okr_detail_display_md_update = gr.update(value="Nessun OKR generato o trovato (Sempre).")
-                else: okr_detail_display_md_update = gr.update(value="\n\n---\n\n".join(all_okrs_md_parts))
-                selected_krs_update = []
-            else:
-                agentic_report_md_update = gr.update(value="Nessun report generato dalla pipeline AI (Sempre).")
-                key_results_cbg_update = gr.update(choices=[], value=[], interactive=False)
-                okr_detail_display_md_update = gr.update(value="Nessun OKR generato o errore nella pipeline AI (Sempre).")
-                orchestration_results_update = None; selected_krs_update = []; krs_for_selection_update = []
-            yield (agentic_report_md_update, key_results_cbg_update, okr_detail_display_md_update, orchestration_results_update, selected_krs_update, krs_for_selection_update, agentic_status_text)
-        except Exception as e:
-            logging.error(f"Error during autonomous agentic pipeline execution: {e}", exc_info=True)
-            agentic_status_text = f"Errore pipeline AI (Sempre): {str(e)}"
-            yield (gr.update(value=f"Errore generazione report AI (Sempre): {str(e)}"), gr.update(choices=[], value=[], interactive=False), gr.update(value=f"Errore generazione OKR AI (Sempre): {str(e)}"), None, [], [], agentic_status_text)
+    # --- Event Chaining & Orchestration ---
 
-    graph_refresh_outputs_list = [analytics_status_md]
-    graph_refresh_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("plot_component", gr.update()) for pc in plot_configs])
-    _ui_resets_for_graphs = [global_actions_column_ui, insights_chatbot_ui, insights_chat_input_ui, insights_suggestions_row_ui, insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn, formula_display_markdown_ui, formula_close_hint_md]
-    graph_refresh_outputs_list.extend(_ui_resets_for_graphs)
-    _state_resets_for_graphs = [active_panel_action_state, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
-    graph_refresh_outputs_list.extend(_state_resets_for_graphs)
-    for pc in plot_configs: pid = pc["id"]; graph_refresh_outputs_list.extend([plot_ui_objects.get(pid, {}).get("bomb_button", gr.update()), plot_ui_objects.get(pid, {}).get("formula_button", gr.update()), plot_ui_objects.get(pid, {}).get("explore_button", gr.update()), plot_ui_objects.get(pid, {}).get("panel_component", gr.update())])
-    graph_refresh_outputs_list.append(explored_plot_id_state)
-    graph_refresh_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections])
+    # Initial Load Sequence (Simplified: direct calls, complex logic in handlers)
+    def initial_load_sequence_wrapper(url_token, org_urn_val, current_state):
+        # This function is primarily for the first tab's initial state.
+        status_msg, new_state, btn_update = process_and_store_bubble_token(url_token, org_urn_val, current_state)
+        dashboard_content = display_main_dashboard(new_state) # From ui_generators
+        return status_msg, new_state, btn_update, dashboard_content
 
-    agentic_pipeline_outputs_list = [agentic_report_display_md, key_results_cbg, okr_detail_display_md, orchestration_raw_results_st, selected_key_result_ids_st, key_results_for_selection_st, agentic_pipeline_status_md]
-    
-    graph_refresh_inputs = [token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st]
-    agentic_pipeline_inputs = [token_state]
+    # Outputs for the agentic pipeline handler
+    # Order: report_display, key_results_cbg, okr_detail_display, 
+    #        orchestration_raw_results_st, selected_key_result_ids_st, key_results_for_selection_st, 
+    #        agentic_pipeline_status_md
+    agentic_pipeline_full_outputs_list = agentic_pipeline_output_components[:3] + \
+                                         [orchestration_raw_results_st, selected_key_result_ids_st, key_results_for_selection_st] + \
+                                         [agentic_pipeline_output_components[3]]
 
-    apply_filter_btn.click(
-        fn=refresh_analytics_graphs_ui,
-        inputs=graph_refresh_inputs,
-        outputs=graph_refresh_outputs_list,
-        show_progress="full"
-    )
 
     initial_load_event = org_urn_display.change(
-        fn=initial_load_sequence,
+        fn=initial_load_sequence_wrapper,
         inputs=[url_user_token_display, org_urn_display, token_state],
         outputs=[status_box, token_state, sync_data_btn, dashboard_display_html],
         show_progress="full"
     )
+    
+    # After initial load, refresh analytics graphs
     initial_load_event.then(
-        fn=refresh_analytics_graphs_ui,
-        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
-        outputs=graph_refresh_outputs_list,
+        fn=analytics_tab.handle_refresh_analytics_graphs,
+        inputs=[token_state, date_filter_selector_analytics, custom_start_date_picker_analytics, custom_end_date_picker_analytics, chat_histories_st],
+        outputs=analytics_refresh_outputs_plus_states, # Use the list from analytics_tab
         show_progress="full"
-    ).then(
-        fn=run_agentic_pipeline_autonomously,
-        inputs=agentic_pipeline_inputs,
-        outputs=agentic_pipeline_outputs_list,
+    ).then( # Then run agentic pipeline
+        fn=agentic_module.handle_run_agentic_pipeline,
+        inputs=[token_state, orchestration_raw_results_st, key_results_for_selection_st, selected_key_result_ids_st], # Pass states
+        outputs=agentic_pipeline_full_outputs_list,
         show_progress="minimal"
     )
 
+    # Sync Data Event Chain
     sync_event_part1 = sync_data_btn.click(
         fn=sync_all_linkedin_data_orchestrator,
         inputs=[token_state],
-        outputs=[sync_status_html_output, token_state],
+        outputs=[sync_status_html_output, token_state], # token_state is updated here
         show_progress="full"
     )
+    
+    # After sync, re-process token and update dashboard display (Tab 1)
     sync_event_part2 = sync_event_part1.then(
-        fn=process_and_store_bubble_token,
-        inputs=[url_user_token_display, org_urn_display, token_state],
-        outputs=[status_box, token_state, sync_data_btn],
-        show_progress=False
+        fn=process_and_store_bubble_token, # This updates token_state again
+        inputs=[url_user_token_display, org_urn_display, token_state], # Pass the updated token_state
+        outputs=[status_box, token_state, sync_data_btn], # token_state updated again
+        show_progress=False 
     )
-    sync_event_part2.then( # This will now use the updated token_state from process_and_store_bubble_token
-        fn=run_agentic_pipeline_autonomously,
-        inputs=agentic_pipeline_inputs, # token_state is the first element
-        outputs=agentic_pipeline_outputs_list,
+    
+    # After token processing, re-run agentic pipeline with potentially new data
+    sync_event_part2.then(
+        fn=agentic_module.handle_run_agentic_pipeline,
+        inputs=[token_state, orchestration_raw_results_st, key_results_for_selection_st, selected_key_result_ids_st], # Pass the latest token_state
+        outputs=agentic_pipeline_full_outputs_list,
         show_progress="minimal"
     )
+    
+    # Then, update the main dashboard display on Tab 1
     sync_event_part3 = sync_event_part2.then(
         fn=display_main_dashboard,
-        inputs=[token_state],
+        inputs=[token_state], # Use the latest token_state
         outputs=[dashboard_display_html],
         show_progress=False
     )
+    
+    # Finally, refresh analytics graphs on Tab 2
     sync_event_graphs_after_sync = sync_event_part3.then(
-        fn=refresh_analytics_graphs_ui,
-        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
-        outputs=graph_refresh_outputs_list,
+        fn=analytics_tab.handle_refresh_analytics_graphs,
+        inputs=[token_state, date_filter_selector_analytics, custom_start_date_picker_analytics, custom_end_date_picker_analytics, chat_histories_st],
+        outputs=analytics_refresh_outputs_plus_states, # Use the list from analytics_tab
         show_progress="full"
     )
 
-
+# --- App Launch ---
 if __name__ == "__main__":
     if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR): logging.warning(f"ATTENZIONE: '{LINKEDIN_CLIENT_ID_ENV_VAR}' non impostata.")
     if not all(os.environ.get(var) for var in [BUBBLE_APP_NAME_ENV_VAR, BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR]):
         logging.warning("ATTENZIONE: Variabili Bubble non impostate.")
-    if not AGENTIC_MODULES_LOADED: logging.warning("CRITICAL: Agentic pipeline modules failed to load. Tabs 3 and 4 (formerly 5 and 6) will be non-functional.")
-    if not os.environ.get("GEMINI_API_KEY") and AGENTIC_MODULES_LOADED: logging.warning("ATTENZIONE: 'GEMINI_API_KEY' non impostata. La pipeline AI per le tab 3 e 4 potrebbe non funzionare.")
-    try: logging.info(f"Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
-    except ImportError: logging.warning("Matplotlib non trovato.")
-    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    
+    # AGENTIC_MODULES_LOADED is now checked within agentic_module.py, log from there if needed.
+    # We can add a check here based on the import success if desired for app startup.
+    if not agentic_module.AGENTIC_MODULES_LOADED: # Check the flag from the module
+         logging.warning("CRITICAL: Agentic pipeline modules failed to load. Tabs 3 and 4 will be non-functional.")
+    if not os.environ.get("GEMINI_API_KEY") and agentic_module.AGENTIC_MODULES_LOADED:
+        logging.warning("ATTENZIONE: 'GEMINI_API_KEY' non impostata. La pipeline AI per le tab 3 e 4 potrebbe non funzionare.")
+    
+    try:
+        logging.info(f"Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
+    except ImportError:
+        logging.warning("Matplotlib non trovato.")
+        
+    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+