Update app.py

app.py

@@ -58,17 +58,16 @@ except ImportError as e:
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
 
 # 1. Set Vertex AI usage preference (if applicable)
-os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False" 
+os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False"
 
 # 2. Get your API key from your chosen environment variable name
-#    Replace "YOUR_GEMINI_API_KEY_ENV_NAME" with the actual name you use, e.g., "GEMINI_API_KEY" or "GOOGLE_API_KEY"
-user_provided_api_key = os.environ.get("GEMINI_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 YOUR_GEMINI_API_KEY_ENV_NAME.")
+    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 'YOUR_GEMINI_API_KEY_ENV_NAME' 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. The application may not function correctly.")
 
 
 # --- Gradio UI Blocks ---
@@ -91,9 +90,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
     # --- NEW STATES FOR AGENTIC PIPELINE ---
     orchestration_raw_results_st = gr.State(None)
-    # Stores list of dicts: {'okr_index', 'kr_index', 'okr_objective', 'kr_description', 'unique_kr_id'}
     key_results_for_selection_st = gr.State([])
-    # Stores list of unique_kr_id strings that are selected by the user
     selected_key_result_ids_st = gr.State([])
 
 
@@ -107,10 +104,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
     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)
-        # Initial call to populate analytics plots with default "Sempre"
-        # This will now also trigger the agentic pipeline for the first time.
-        # However, the outputs for agentic tabs are handled by apply_filter_btn.click and sync.then
-        # So, we don't need to return agentic UI updates from here directly.
         return status_msg, new_state, btn_update, dashboard_content
 
     with gr.Tabs() as tabs:
@@ -120,28 +113,25 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             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>")
 
-            org_urn_display.change(
-                fn=initial_load_sequence,
-                inputs=[url_user_token_display, org_urn_display, token_state],
-                outputs=[status_box, token_state, sync_data_btn, dashboard_display_html],
-                show_progress="full"
-            )
+            # Initial load sequence will be defined later with .then() for agentic pipeline
+            # org_urn_display.change(...)
 
         with gr.TabItem("2️⃣ Analisi", id="tab_analytics"):
             gr.Markdown("## 📈 Analisi Performance LinkedIn")
-            gr.Markdown("Seleziona un intervallo di date. Clicca i pulsanti (💣 Insights, ƒ Formula, 🧭 Esplora) su un grafico per azioni.")
-            analytics_status_md = gr.Markdown("Stato analisi...")
+            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...")
+            # Agentic pipeline status will be moved to Tab 5
 
             with gr.Row():
                 date_filter_selector = gr.Radio(
                     ["Sempre", "Ultimi 7 Giorni", "Ultimi 30 Giorni", "Intervallo Personalizzato"],
-                    label="Seleziona Intervallo Date", value="Sempre", scale=3
+                    label="Seleziona Intervallo Date per Grafici", value="Sempre", scale=3 # Clarified label
                 )
                 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 Analisi", variant="primary")
+            apply_filter_btn = gr.Button("🔍 Applica Filtro & Aggiorna Grafici", variant="primary") # Clarified button text
 
             def toggle_custom_date_pickers(selection):
                 is_custom = selection == "Intervallo Personalizzato"
@@ -179,11 +169,11 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             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) 
+            active_panel_action_state = gr.State(None)
+            explored_plot_id_state = gr.State(None)
 
-            plot_ui_objects = {} 
-            section_titles_map = {} 
+            plot_ui_objects = {}
+            section_titles_map = {}
 
             with gr.Row(equal_height=False):
                 with gr.Column(scale=8) as plots_area_col:
@@ -194,15 +184,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                             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)") 
+                                    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: 
+                        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: 
+                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,
@@ -221,140 +211,82 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     formula_display_markdown_ui = gr.Markdown(
                         "I dettagli sulla formula/metodologia appariranno qui.", visible=False
                     )
-                    formula_close_hint_md = gr.Markdown( # Component for the hint's visibility
-                        "<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>", 
+                    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 HANDLERS FOR ANALYTICS TAB ---
             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 
+                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_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 
+                    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"]
+                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) 
+                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 = []
+                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) 
+                    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: 
+                    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, 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)) 
-                        
+                        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: # Toggling ON a new action or switching actions
-                    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 
+                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: 
+                    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))
-                    
+                        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: 
+                        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) # This is your existing LLM call
-                            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) 
-                        
+                            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) 
+                        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']])
+                        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, # Corrected from formula_close_hint_md
-                    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)     
-                
+                        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
 
@@ -363,160 +295,84 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     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 = [] 
-
+                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) # Existing LLM
+                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):
-                # This function remains synchronous as per original
                 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: 
+                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 
+                    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 = []
+                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 
+                    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: 
+                    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))
-                    
+                    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) 
-                        # Reset bomb and formula buttons to non-active
-                        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: # No active panel, so no need to reset bomb/formula buttons beyond what explore does
-                        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)
-                
+                        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 
-            ]
+            _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_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)
+                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}"
-                        ) 
+                    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")
@@ -526,313 +382,225 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             refresh_mentions_display_btn = gr.Button("🔄 Aggiorna Visualizzazione Menzioni", variant="secondary")
             mentions_html = gr.HTML("Dati menzioni...")
             mentions_sentiment_dist_plot = gr.Plot(label="Distribuzione Sentiment Menzioni")
-            refresh_mentions_display_btn.click(
-                fn=run_mentions_tab_display, inputs=[token_state],
-                outputs=[mentions_html, mentions_sentiment_dist_plot],
-                show_progress="full"
-            )
+            refresh_mentions_display_btn.click(fn=run_mentions_tab_display, inputs=[token_state], outputs=[mentions_html, mentions_sentiment_dist_plot], show_progress="full")
 
         with gr.TabItem("4️⃣ Statistiche Follower", id="tab_follower_stats"):
             refresh_follower_stats_btn = gr.Button("🔄 Aggiorna Visualizzazione Statistiche Follower", variant="secondary")
             follower_stats_html = gr.HTML("Statistiche follower...")
-            with gr.Row():
-                fs_plot_monthly_gains = gr.Plot(label="Guadagni Mensili Follower")
-            with gr.Row():
-                fs_plot_seniority = gr.Plot(label="Follower per Anzianità (Top 10 Organici)")
-                fs_plot_industry = gr.Plot(label="Follower per Settore (Top 10 Organici)")
-            
-            refresh_follower_stats_btn.click(
-                fn=run_follower_stats_tab_display, inputs=[token_state],
-                outputs=[follower_stats_html, fs_plot_monthly_gains, fs_plot_seniority, fs_plot_industry],
-                show_progress="full"
-            )
+            with gr.Row(): fs_plot_monthly_gains = gr.Plot(label="Guadagni Mensili Follower")
+            with gr.Row(): fs_plot_seniority = gr.Plot(label="Follower per Anzianità (Top 10 Organici)"); fs_plot_industry = gr.Plot(label="Follower per Settore (Top 10 Organici)")
+            refresh_follower_stats_btn.click(fn=run_follower_stats_tab_display, inputs=[token_state], outputs=[follower_stats_html, fs_plot_monthly_gains, fs_plot_seniority, fs_plot_industry], show_progress="full")
         
-        # --- NEW TABS FOR AGENTIC PIPELINE RESULTS ---
         with gr.TabItem("5️⃣ Agentic Analysis Report", id="tab_agentic_report", visible=AGENTIC_MODULES_LOADED):
             gr.Markdown("## 🤖 Comprehensive Analysis Report (AI Generated)")
-            gr.Markdown("This report is generated by an AI agent based on the selected date range. Please review critically.")
-            agentic_report_display_md = gr.Markdown("Apply a date filter in Tab 2 to generate the report.")
-            if not AGENTIC_MODULES_LOADED:
-                 gr.Markdown("🔴 **Error:** Agentic pipeline modules could not be loaded. This tab is disabled.")
-
+            # Moved agentic_pipeline_status_md here
+            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("6️⃣ Agentic OKRs & Tasks", id="tab_agentic_okrs", visible=AGENTIC_MODULES_LOADED):
-            gr.Markdown("## 🎯 AI Generated OKRs and Actionable Tasks")
-            gr.Markdown("Based on the analysis, the AI agent has proposed the following Objectives and Key Results (OKRs), along with actionable tasks. Select Key Results you want to focus on to see detailed tasks.")
-            if not AGENTIC_MODULES_LOADED:
-                 gr.Markdown("🔴 **Error:** Agentic pipeline modules could not be loaded. This tab is disabled.")
-            
+            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")
-                    key_results_cbg = gr.CheckboxGroup(
-                        label="Select Key Results", 
-                        choices=[], # Will be populated dynamically
-                        value=[],
-                        interactive=True
-                    )
+                    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("Select Key Results from the left to see details, or apply a date filter in Tab 2 to generate OKRs.")
-
+                    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):
-                """
-                Updates the Markdown display for OKRs based on selected Key Results.
-                If no KRs are selected, it might show all, or a prompt.
-                """
-                if not raw_orchestration_results or not AGENTIC_MODULES_LOADED:
-                    return gr.update(value="No orchestration data available or agentic modules not loaded. Apply a date filter first.")
-
+                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="No OKRs found in the orchestration results.")
-
+                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"]
-                
-                # Create a mapping from unique_kr_id to (okr_idx, kr_idx)
-                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
-                }
-
-                # Determine which KRs are selected for each OKR
-                # okr_idx -> list of selected kr_indices for that OKR
+                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: # If specific KRs are selected
+                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)
-                
+                        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("No OKRs were generated.")
+                if not okrs_list: output_md_parts.append("Nessun OKR generato.")
                 else:
                     for okr_idx, okr_data in enumerate(okrs_list):
-                        # If specific KRs were selected, only display OKRs that have at least one selected KR,
-                        # or if no KRs are selected at all, display all OKRs with all their KRs.
-                        accepted_indices_for_this_okr = selected_krs_by_okr_idx.get(okr_idx) # This will be None if no KRs from this OKR are selected
-                        
-                        if selected_kr_unique_ids: # User has made a selection
-                            if accepted_indices_for_this_okr is not None : # Only show this OKR if some of its KRs are selected
-                                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: # No KRs selected by user, show all OKRs with all their KRs
-                             output_md_parts.append(format_single_okr_for_display(
-                                okr_data,
-                                accepted_kr_indices=None, # None means show all KRs for this OKR
-                                okr_main_index=okr_idx
-                            ))
-                
-                if not output_md_parts and selected_kr_unique_ids: # User made selection, but no matching OKRs displayed
-                    final_md = "No OKRs match the current Key Result selection, or the selected Key Results do not have detailed tasks."
-                elif not output_md_parts and not selected_kr_unique_ids: # No user selection and no OKRs at all
-                    final_md = "No OKRs generated. Please apply a filter in Tab 2."
-                else:
-                    final_md = "\n\n---\n\n".join(output_md_parts)
-                
+                        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]
-                )
-        
-        # --- END NEW TABS ---
+                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])
 
-    # --- REFRESH ANALYTICS (NOW ASYNC and includes AGENTIC PIPELINE) ---
-    async def refresh_all_analytics_ui_elements(current_token_state_val, date_filter_val, custom_start_val, custom_end_val, current_chat_histories_val):
-        logging.info("Refreshing all analytics UI elements and resetting actions/chat.")
+    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()
-
-        # 1. Standard Analytics Plot Generation
         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))]) 
-        
-        # UI Resets for Analytics Tab Action Panel
-        all_updates.extend([ 
-            gr.update(visible=False), # global_actions_column_ui
-            gr.update(value=[], visible=False), # insights_chatbot_ui (value & visibility)
-            gr.update(value="", visible=False), # insights_chat_input_ui (value & visibility)
-            gr.update(visible=False), # insights_suggestions_row_ui
-            gr.update(value="S1"), gr.update(value="S2"), gr.update(value="S3"), # suggestion_btns
-            gr.update(value="Formula details here.", visible=False), # formula_display_markdown_ui (value & visibility)
-            gr.update(visible=False) # formula_close_hint_md
-        ]) 
-        
-        # State Resets for Analytics Tab
-        all_updates.extend([ 
-            None, # active_panel_action_state
-            None, # current_chat_plot_id_st
-            {},   # chat_histories_st (resetting, new insights will be generated if panel opened)
-            new_summaries # plot_data_for_chatbot_st
-        ]) 
-        
-        # Plot button and panel visibility resets for Analytics Tab
-        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) # panel_component visibility
-            ]) 
-        
-        all_updates.append(None) # explored_plot_id_state reset
-        all_updates.extend([gr.update(visible=True)] * num_unique_sections) # section_title visibility reset
-        
-        # 2. Agentic Pipeline Execution
-        agentic_status_update = "Agentic pipeline processing..."
-        # Placeholder for agentic UI updates initially
-        agentic_report_md_update = gr.update(value="Analisi AI in corso...")
-        key_results_cbg_update = gr.update(choices=[], value=[], interactive=False)
-        okr_detail_display_md_update = gr.update(value="Dettagli OKR in corso di generazione...")
-        orchestration_results_update = None
-        selected_krs_update = []
-        krs_for_selection_update = []
-
-        if AGENTIC_MODULES_LOADED:
-            try:
-                logging.info("Starting agentic pipeline...")
-                orchestration_output = await run_full_analytics_orchestration(
-                    current_token_state_val, date_filter_val, custom_start_val, custom_end_val
-                )
-                agentic_status_update = "Agentic pipeline completed."
-                logging.info(f"Agentic pipeline finished. Output keys: {orchestration_output.keys() if orchestration_output else 'None'}")
-
-
-                if orchestration_output:
-                    orchestration_results_update = orchestration_output # Store raw results
-
-                    # Format report for Tab 5
-                    report_str = orchestration_output.get('comprehensive_analysis_report')
-                    agentic_report_md_update = gr.update(value=format_report_to_markdown(report_str))
-
-                    # Prepare KRs for Tab 6
-                    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 # Store for later use in event handler
-
-                    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)
-                    
-                    # Initially display all OKRs in Tab 6
-                    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.")
-                    else:
-                        okr_detail_display_md_update = gr.update(value="\n\n---\n\n".join(all_okrs_md_parts))
-                    selected_krs_update = [] # Reset selection
-
-                else:
-                    agentic_report_md_update = gr.update(value="Nessun report generato dalla pipeline AI.")
-                    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.")
-                    orchestration_results_update = None
-                    selected_krs_update = []
-                    krs_for_selection_update = []
-
-            except Exception as e:
-                logging.error(f"Error during agentic pipeline execution: {e}", exc_info=True)
-                agentic_status_update = f"Errore pipeline AI: {e}"
-                agentic_report_md_update = gr.update(value=f"Errore durante la generazione del report AI: {e}")
-                key_results_cbg_update = gr.update(choices=[], value=[], interactive=False)
-                okr_detail_display_md_update = gr.update(value=f"Errore durante la generazione degli OKR AI: {e}")
-                orchestration_results_update = None
-                selected_krs_update = []
-                krs_for_selection_update = []
-        else: # AGENTIC_MODULES_LOADED is False
-            agentic_status_update = "Moduli AI non caricati. Pipeline saltata."
-            agentic_report_md_update = gr.update(value="Moduli AI non caricati. Report non disponibile.")
-            key_results_cbg_update = gr.update(choices=[], value=[], interactive=False, visible=False) # Hide if not loaded
-            okr_detail_display_md_update = gr.update(value="Moduli AI non caricati. OKR non disponibili.", visible=False) # Hide
-            orchestration_results_update = None
-            selected_krs_update = []
-            krs_for_selection_update = []
-
-
-        # Append agentic pipeline updates to all_updates
-        # Order must match apply_filter_and_sync_outputs_list extension
-        all_updates.extend([
-            agentic_report_md_update,       # For agentic_report_display_md
-            key_results_cbg_update,         # For key_results_cbg
-            okr_detail_display_md_update,   # For okr_detail_display_md
-            orchestration_results_update,   # For orchestration_raw_results_st
-            selected_krs_update,            # For selected_key_result_ids_st
-            krs_for_selection_update        # For key_results_for_selection_st
-        ])
-        
+        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 and Agentic refresh took {end_time - start_time:.2f} seconds.")
-        logging.info(f"Prepared {len(all_updates)} updates for analytics refresh. Expected {15 + 5*len(plot_configs) + num_unique_sections + 6}.")
-        # The status_msg from plot_gen_results is the first item. We can augment it.
-        all_updates[0] = f"{status_msg} | {agentic_status_update}"
-
-        return tuple(all_updates) # Return as tuple for Gradio
-
-    # Define the list of outputs for apply_filter_btn and sync.then
-    apply_filter_and_sync_outputs_list = [analytics_status_md] 
-    apply_filter_and_sync_outputs_list.extend([plot_ui_objects.get(pc["id"], {}).get("plot_component", gr.update()) for pc in plot_configs]) 
-    
-    _ui_resets_for_filter = [
-        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 
-    ]
-    apply_filter_and_sync_outputs_list.extend(_ui_resets_for_filter)
-    
-    _state_resets_for_filter = [active_panel_action_state, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
-    apply_filter_and_sync_outputs_list.extend(_state_resets_for_filter)
-
-    for pc in plot_configs: 
-        pid = pc["id"]
-        apply_filter_and_sync_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()) 
-        ])
-    
-    apply_filter_and_sync_outputs_list.append(explored_plot_id_state) 
-    
-    apply_filter_and_sync_outputs_list.extend([section_titles_map.get(s_name, gr.update()) for s_name in unique_ordered_sections]) 
+        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, request: gr.Request):
+        # Added request: gr.Request to check if it's the initial call or subsequent.
+        # This is a simple way to prevent multiple rapid fires if not needed,
+        # though ideally Gradio's event system handles this.
+        # For more robust control, a separate state could track if the pipeline has run for current data.
+        client_ip = request.client.host if request else "unknown_client"
+        logging.info(f"Agentic pipeline check triggered for token_state update from {client_ip}. 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 ( # Yield initial "waiting" state if token not ready
+                gr.update(value="Pipeline AI: In attesa dei dati necessari..."), # agentic_report_display_md
+                gr.update(choices=[], value=[], interactive=False), # key_results_cbg
+                gr.update(value="Pipeline AI: In attesa dei dati necessari..."), # okr_detail_display_md
+                None, # orchestration_raw_results_st
+                [],   # selected_key_result_ids_st
+                [],   # key_results_for_selection_st
+                "Pipeline AI: In attesa dei dati..." # agentic_pipeline_status_md
+            )
+            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..."),
+            None, # orchestration_raw_results_st (don't overwrite with None if it already has results)
+            [],   # selected_key_result_ids_st
+            [],   # key_results_for_selection_st
+            "Esecuzione pipeline AI (Sempre)..."
+        )
+
+        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)
+
+    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])
+
+    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]
     
-    # --- Add new outputs for agentic tabs and states ---
-    apply_filter_and_sync_outputs_list.extend([
-        agentic_report_display_md,    # Tab 5 UI
-        key_results_cbg,              # Tab 6 UI (CheckboxGroup)
-        okr_detail_display_md,        # Tab 6 UI (Markdown display)
-        orchestration_raw_results_st, # New State
-        selected_key_result_ids_st,   # New State
-        key_results_for_selection_st  # New State
-    ])
-    # --- End new outputs ---
-            
+    graph_refresh_inputs = [token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st]
+    agentic_pipeline_inputs = [token_state] # Removed request for now, can be added back if needed for advanced logic
+
+    # Event for Apply Filter Button (only refreshes graphs)
     apply_filter_btn.click(
-        fn=refresh_all_analytics_ui_elements, # Now async
-        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
-        outputs=apply_filter_and_sync_outputs_list, show_progress="full"
+        fn=refresh_analytics_graphs_ui,
+        inputs=graph_refresh_inputs,
+        outputs=graph_refresh_outputs_list,
+        show_progress="full"
     )
 
-    # --- Sync Events (at the end of the app's 'with gr.Blocks()' context) ---
-    sync_event_part1 = sync_data_btn.click(fn=sync_all_linkedin_data_orchestrator, inputs=[token_state], outputs=[sync_status_html_output, token_state], show_progress="full")
-    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)
-    sync_event_part3 = sync_event_part2.then(fn=display_main_dashboard, inputs=[token_state], outputs=[dashboard_display_html], show_progress=False)
-    sync_event_final = sync_event_part3.then(
-        fn=refresh_all_analytics_ui_elements, # Now async
-        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st], 
-        outputs=apply_filter_and_sync_outputs_list, 
+    # --- Event Chains for Initial Load and Sync ---
+    # Initial Load
+    initial_load_event = org_urn_display.change(
+        fn=initial_load_sequence,
+        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 graphs AND run agentic pipeline
+    initial_load_event.then(
+        fn=refresh_analytics_graphs_ui, # Refresh graphs with default "Sempre" filter
+        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st], # date_filter_selector will provide "Sempre"
+        outputs=graph_refresh_outputs_list,
+        show_progress="full"
+    ).then(
+        fn=run_agentic_pipeline_autonomously, # Run agentic pipeline
+        inputs=agentic_pipeline_inputs, # Uses token_state
+        outputs=agentic_pipeline_outputs_list,
+        show_progress="minimal"
+    )
+
+    # Sync Process
+    sync_event_part1 = sync_data_btn.click(
+        fn=sync_all_linkedin_data_orchestrator,
+        inputs=[token_state],
+        outputs=[sync_status_html_output, token_state],
+        show_progress="full"
+    )
+    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], # token_state is updated here
+        show_progress=False
+    )
+    # After token_state is updated by sync, run agentic pipeline
+    sync_event_part2.then(
+        fn=run_agentic_pipeline_autonomously,
+        inputs=agentic_pipeline_inputs, # Uses updated token_state
+        outputs=agentic_pipeline_outputs_list,
+        show_progress="minimal"
+    )
+    # Separately, update dashboard and graphs after sync
+    sync_event_part3 = sync_event_part2.then(
+        fn=display_main_dashboard,
+        inputs=[token_state],
+        outputs=[dashboard_display_html],
+        show_progress=False
+    )
+    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,
         show_progress="full"
     )
 
@@ -841,13 +609,8 @@ 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 (run_agentic_pipeline.py, insights_ui_generator.py) failed to load. Tabs 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 5 e 6 potrebbe non funzionare.")
-
+    if not AGENTIC_MODULES_LOADED: logging.warning("CRITICAL: Agentic pipeline modules failed to load. Tabs 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 5 e 6 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)