Update app.py

app.py

@@ -690,7 +690,7 @@ if df_local.empty:
 df_local['created_month'] = df_local['created_at'].dt.to_period('M')
 
 
-# ─── Helper: Hitung rasio per nama (Reporter) ────────────────────────────────
+# ─── Helper: Hitung rasio per division (reporter) ─────────────────────────────
 def compute_reporter_ratio_by_nama(df):
     if 'nama' not in df.columns:
         return pd.DataFrame()
@@ -707,18 +707,7 @@ def compute_reporter_ratio_by_nama(df):
     return avg_ratio_per_nama
 
 
-# ─── Helper: Hitung lead time per nama (Executor) ───────────────────────────
-def compute_executor_leadtime_by_nama(df):
-    if 'nama' not in df.columns or 'days_to_close' not in df.columns:
-        return pd.DataFrame()
-    
-    leadtime_by_nama_month = df.groupby(['created_month', 'nama'])['days_to_close'].mean().reset_index(name='avg_leadtime')
-    avg_leadtime_nama = leadtime_by_nama_month.groupby('nama')['avg_leadtime'].mean().reset_index(name='avg_monthly_leadtime')
-    avg_leadtime_nama = avg_leadtime_nama.dropna(subset=['avg_monthly_leadtime'])
-    return avg_leadtime_nama
-
-
-# ─── Helper: Hitung rasio per creator_name ──────────────────────────────────
+# ─── Helper: Hitung rata-rata temuan per reporter (individu) ─────────────────
 def compute_reporter_rate_by_creator(df):
     if 'creator_name' not in df.columns:
         return pd.DataFrame()
@@ -735,335 +724,261 @@ def compute_reporter_rate_by_creator(df):
     return avg_rate_per_creator
 
 
-# ─── Helper: Hitung lead time per nama_pic ──────────────────────────────────
-def compute_executor_leadtime_by_pic(df):
-    if 'nama_pic' not in df.columns or 'days_to_close' not in df.columns:
+# ─── Helper: Hitung lead time per division (executor) ───────────────────────
+def compute_executor_leadtime_by_nama(df):
+    if 'nama' not in df.columns or 'days_to_close' not in df.columns:
         return pd.DataFrame()
     
-    leadtime_by_executor_month = df.groupby(['created_month', 'nama_pic'])['days_to_close'].mean().reset_index(name='avg_leadtime')
-    active_months_by_executor = leadtime_by_executor_month.groupby('nama_pic')['created_month'].nunique().reset_index(name='active_months')
-    total_leadtime_by_executor = leadtime_by_executor_month.groupby('nama_pic')['avg_leadtime'].sum().reset_index()
-    merged_exec_pic = total_leadtime_by_executor.merge(active_months_by_executor, on='nama_pic', how='outer')
-    merged_exec_pic = merged_exec_pic.fillna({'avg_leadtime': 0, 'active_months': 0})
-    merged_exec_pic = merged_exec_pic[merged_exec_pic['active_months'] > 0]
-    merged_exec_pic['avg_monthly_leadtime'] = merged_exec_pic['avg_leadtime'] / merged_exec_pic['active_months']
-    merged_exec_pic['avg_monthly_leadtime'] = merged_exec_pic['avg_monthly_leadtime'].replace([np.inf, -np.inf], np.nan)
-    avg_leadtime_per_executor = merged_exec_pic.dropna(subset=['avg_monthly_leadtime'])
-    return avg_leadtime_per_executor
+    # Filter hanya data dengan lead time valid
+    df_valid = df[df['days_to_close'].notna() & (df['days_to_close'] >= 0)]
+    
+    leadtime_by_nama_month = df_valid.groupby(['created_month', 'nama'])['days_to_close'].mean().reset_index(name='avg_leadtime')
+    avg_leadtime_nama = leadtime_by_nama_month.groupby('nama')['avg_leadtime'].mean().reset_index(name='avg_monthly_leadtime')
+    avg_leadtime_nama = avg_leadtime_nama.dropna(subset=['avg_monthly_leadtime'])
+    return avg_leadtime_nama
 
 
-# ─── Data untuk 3a & 3c ──────────────────────────────────────────────────────
-avg_ratio_per_nama = compute_reporter_ratio_by_nama(df_local)
-avg_rate_per_creator = compute_reporter_rate_by_creator(df_local)
+# ─── Helper: Hitung lead time per individu executor (deteksi kolom otomatis) ─
+def compute_executor_leadtime_by_individual(df, name_col='creator_name'):
+    if name_col not in df.columns or 'days_to_close' not in df.columns:
+        return pd.DataFrame()
+    
+    df_valid = df[df['days_to_close'].notna() & (df['days_to_close'] >= 0)]
+    
+    leadtime_by_indiv_month = df_valid.groupby(['created_month', name_col])['days_to_close'].mean().reset_index(name='avg_leadtime')
+    avg_leadtime_indiv = leadtime_by_indiv_month.groupby(name_col)['avg_leadtime'].mean().reset_index(name='avg_monthly_leadtime')
+    avg_leadtime_indiv = avg_leadtime_indiv.dropna(subset=['avg_monthly_leadtime'])
+    return avg_leadtime_indiv
+
+
+# ─── Deteksi kolom executor individu ────────────────────────────────────────
+EXECUTOR_INDIV_COL = None
+candidate_executor_cols = ['pic', 'pic_name', 'responsible', 'responsible_name', 'assigned_to', 'closed_by', 'executor_name', 'executor']
+for col in candidate_executor_cols:
+    if col in df_local.columns:
+        EXECUTOR_INDIV_COL = col
+        break
+
+if EXECUTOR_INDIV_COL is None:
+    # Fallback — gunakan creator_name (dengan warning transparan)
+    EXECUTOR_INDIV_COL = 'creator_name'
+    st.warning(
+        "⚠️ No dedicated executor column (e.g., 'pic', 'responsible') found. "
+        "Using 'creator_name' as proxy for executor — insights may conflate reporters & executors. "
+        "Consider adding an executor identifier column for accuracy."
+    )
 
-# ─── Data untuk 3b & 3d ──────────────────────────────────────────────────────
-avg_leadtime_nama = compute_executor_leadtime_by_nama(df_local)
-avg_leadtime_per_executor = compute_executor_leadtime_by_pic(df_local)
 
+# ─── Hitung semua metrik ─────────────────────────────────────────────────────
+avg_ratio_per_nama = compute_reporter_ratio_by_nama(df_local)          # 3a
+avg_rate_per_creator = compute_reporter_rate_by_creator(df_local)      # 3c
+avg_leadtime_nama = compute_executor_leadtime_by_nama(df_local)        # 3b
+avg_leadtime_per_indiv = compute_executor_leadtime_by_individual(df_local, name_col=EXECUTOR_INDIV_COL)  # 3d
 
-# Helper: Dapatkan warna berdasarkan ranking global (bukan lokal subset)
+
+# ─── Helper: Warna berdasarkan ranking global ───────────────────────────────
 def add_color_by_global_rank(df, value_col, top_n=5, worst_n=5, high_is_good=True):
-    """
-    Menambahkan kolom 'color' berdasarkan ranking global.
-    - Jika high_is_good=True (e.g., ratio): top_n → hijau, worst_n → default
-    - Jika high_is_good=False (e.g., lead time): worst_n (tertinggi) → merah, top_n (terendah) → default
-    """
     df = df.copy()
-    df = df.sort_values(value_col, ascending=not high_is_good).reset_index(drop=True)  # descending if high_is_good
     df['color'] = '#1f77b4'  # default biru
     
+    if len(df) == 0:
+        return df
+    
     if high_is_good:
-        # Nilai tinggi = baik → top 5 hijau
-        top_idx = df.head(top_n).index
-        df.loc[top_idx, 'color'] = '#4CAF50'
+        # Nilai tinggi = baik → top N → hijau
+        top_names = df.nlargest(top_n, value_col)['nama' if 'nama' in df.columns else df.columns[0]]
+        df.loc[df[df.columns[0]].isin(top_names), 'color'] = '#4CAF50'
     else:
-        # Nilai tinggi = buruk → top 5 (tertinggi) = merah
-        # → Urut ascending, ambil tail 5 (tertinggi)
-        df_asc = df.sort_values(value_col, ascending=True)
-        worst_idx = df_asc.tail(worst_n).index
-        df.loc[worst_idx, 'color'] = '#D32F2F'
+        # Nilai tinggi = buruk (e.g., lead time) → worst N (tertinggi) → merah
+        worst_names = df.nlargest(worst_n, value_col)['nama' if 'nama' in df.columns else df.columns[0]]
+        df.loc[df[df.columns[0]].isin(worst_names), 'color'] = '#D32F2F'
+    
     return df
 
 
-# ─── Layout: 2 Baris — 3a & 3c di baris pertama, 3b & 3d di baris kedua ─────
-# Baris 1: 3a & 3c
+# ─── Layout: 2 baris × 2 kolom ───────────────────────────────────────────────
 col_3a, col_3c = st.columns(2)
 
+# ─── 3a: Reporter by Division (Rasio Temuan/Orang) ───────────────────────────
 with col_3a:
-    st.markdown("<h5>3a. Average Finding by Division (Reporter)</h5>", unsafe_allow_html=True)
+    st.markdown("<h5 style='text-align:center;'>3a. Avg Finding/Person Ratio by Division (Reporter)</h5>", unsafe_allow_html=True)
     if avg_ratio_per_nama.empty:
-        st.warning("No data for reporter analysis by division.")
+        st.warning("No data for division-level reporter analysis.")
     else:
-        sort_option_3a = st.selectbox("Show 3a:", ["Top 10", "Bottom 10"], key='sort_3a')
+        sort_opt = st.selectbox("Show:", ["Top 10", "Bottom 10"], key='sort_3a')
         
-        # Full data sorted descending (high ratio = good)
-        sorted_all_3a = avg_ratio_per_nama.sort_values('avg_monthly_ratio', ascending=False).reset_index(drop=True)
+        full_sorted = avg_ratio_per_nama.sort_values('avg_monthly_ratio', ascending=False)
+        subset = full_sorted.head(10) if sort_opt == "Top 10" else full_sorted.tail(10).sort_values('avg_monthly_ratio', ascending=True)
         
-        # Subset sesuai pilihan user
-        if sort_option_3a == "Top 10":
-            subset_data = sorted_all_3a.head(10)
-        else:  # Bottom 10
-            subset_data = sorted_all_3a.tail(10).sort_values('avg_monthly_ratio', ascending=True)  # ascending dalam subset
+        # Tambahkan warna: top 5 → hijau
+        colored = add_color_by_global_rank(avg_ratio_per_nama, 'avg_monthly_ratio', top_n=5, high_is_good=True)
+        subset = subset.merge(colored[['nama', 'color']], on='nama', how='left').fillna({'color': '#1f77b4'})
         
-        # Tambahkan warna berdasarkan rank global
-        avg_ratio_per_nama_colored = add_color_by_global_rank(
-            avg_ratio_per_nama, 'avg_monthly_ratio', top_n=5, high_is_good=True
-        )
-        subset_data = subset_data.merge(
-            avg_ratio_per_nama_colored[['nama', 'color']], on='nama', how='left'
-        ).fillna({'color': '#1f77b4'})
+        # Reverse untuk visual (tertinggi di atas)
+        if sort_opt == "Top 10":
+            subset = subset.iloc[::-1]
         
-        # Reverse order for better visual (low at bottom)
-        if sort_option_3a == "Top 10":
-            subset_data = subset_data.iloc[::-1]  # descending (tertinggi di atas)
-        else:
-            subset_data = subset_data  # ascending (terendah di atas)
-
-        fig_rep_nama = px.bar(
-            subset_data,
-            x='avg_monthly_ratio',
-            y='nama',
-            orientation='h',
-            title=f'Avg Monthly Finding/Person Ratio — {sort_option_3a}',
+        fig = px.bar(
+            subset, x='avg_monthly_ratio', y='nama', orientation='h',
+            title=f'{sort_opt} Divisions',
             labels={'avg_monthly_ratio': 'Avg Monthly Ratio', 'nama': 'Division'},
-            color='color',
-            color_discrete_map={c: c for c in subset_data['color'].unique()},
-            text=subset_data['avg_monthly_ratio'].apply(lambda x: f'{x:.2f}')
+            color='color', color_discrete_map={c: c for c in subset['color'].unique()},
+            text=subset['avg_monthly_ratio'].apply(lambda x: f'{x:.2f}')
         )
-        fig_rep_nama.update_layout(
-            yaxis={'categoryorder': 'array', 'categoryarray': subset_data['nama'].tolist()},
-            height=500,
-            showlegend=False
-        )
-        fig_rep_nama.update_traces(textposition='auto')
-        st.plotly_chart(fig_rep_nama, use_container_width=True)
+        fig.update_layout(height=450, showlegend=False, yaxis={'categoryorder': 'array', 'categoryarray': subset['nama'].tolist()})
+        fig.update_traces(textposition='auto')
+        st.plotly_chart(fig, use_container_width=True)
         
-        # 🔥 INSIGHT: SELALU dari FULL DATA, stabil
-        if len(sorted_all_3a) >= 2:
-            min_val = sorted_all_3a['avg_monthly_ratio'].min()
-            max_val = sorted_all_3a['avg_monthly_ratio'].max()
-            mean_val = sorted_all_3a['avg_monthly_ratio'].mean()
-            median_val = sorted_all_3a['avg_monthly_ratio'].median()
-            best_div = sorted_all_3a.iloc[0]['nama']
-            worst_div = sorted_all_3a.iloc[-1]['nama']
-            
-            insight_text = (
+        # 🔍 Insight (dari full data)
+        if len(full_sorted) >= 2:
+            min_r, max_r, mean_r = full_sorted['avg_monthly_ratio'].min(), full_sorted['avg_monthly_ratio'].max(), full_sorted['avg_monthly_ratio'].mean()
+            best, worst = full_sorted.iloc[0]['nama'], full_sorted.iloc[-1]['nama']
+            st.markdown(
                 f"<div class='ai-insight'>"
-                f"<strong>Overall (all {len(sorted_all_3a)} divisions)</strong>: Ratio ranges from <strong>{min_val:.2f}</strong> "
-                f"to <strong>{max_val:.2f}</strong> (mean: <strong>{mean_val:.2f}</strong>, median: <strong>{median_val:.2f}</strong>). "
-                f"<strong>{best_div}</strong> is the most active division (highest ratio), while <strong>{worst_div}</strong> is the least. "
-                f"<strong>Recommendation:</strong> Investigate root causes in low-activity divisions (e.g., training, tool access, workload); replicate workflows from top performers like {best_div}."
-                f"</div>"
+                f"<strong>Insight:</strong> Division reporting efficiency ranges from {min_r:.2f} to {max_r:.2f} (avg: {mean_r:.2f}). "
+                f"<strong>{best}</strong> leads; <strong>{worst}</strong> lags. "
+                f"<strong>Recommendation:</strong> Benchmark processes from {best}; assess capacity/tooling gaps in {worst}."
+                f"</div>",
+                unsafe_allow_html=True
             )
-        else:
-            insight_text = "<div class='ai-insight'>Insufficient data for insight.</div>"
-        st.markdown(insight_text, unsafe_allow_html=True)
 
 
+# ─── 3c: Reporter by Individual ──────────────────────────────────────────────
 with col_3c:
-    st.markdown("<h5>3b. Average Finding Rate per Reporter (Name)</h5>", unsafe_allow_html=True)
+    st.markdown("<h5 style='text-align:center;'>3c. Avg Monthly Findings per Reporter (Individual)</h5>", unsafe_allow_html=True)
     if avg_rate_per_creator.empty:
-        st.warning("No data for reporter analysis by creator_name.")
+        st.warning("No data for individual reporter analysis.")
     else:
-        sort_option_3c = st.selectbox("Show 3c:", ["Top 10", "Bottom 10"], key='sort_3c')
+        sort_opt = st.selectbox("Show:", ["Top 10", "Bottom 10"], key='sort_3c')
         
-        sorted_all_3c = avg_rate_per_creator.sort_values('avg_monthly_rate', ascending=False).reset_index(drop=True)
+        full_sorted = avg_rate_per_creator.sort_values('avg_monthly_rate', ascending=False)
+        subset = full_sorted.head(10) if sort_opt == "Top 10" else full_sorted.tail(10).sort_values('avg_monthly_rate', ascending=True)
         
-        if sort_option_3c == "Top 10":
-            subset_data = sorted_all_3c.head(10)
-        else:
-            subset_data = sorted_all_3c.tail(10).sort_values('avg_monthly_rate', ascending=True)
+        colored = add_color_by_global_rank(avg_rate_per_creator, 'avg_monthly_rate', top_n=5, high_is_good=True)
+        subset = subset.merge(colored[['creator_name', 'color']], on='creator_name', how='left').fillna({'color': '#1f77b4'})
         
-        # Warna global: top 5 tertinggi → hijau
-        avg_rate_per_creator_colored = add_color_by_global_rank(
-            avg_rate_per_creator, 'avg_monthly_rate', top_n=5, high_is_good=True
-        )
-        subset_data = subset_data.merge(
-            avg_rate_per_creator_colored[['creator_name', 'color']], on='creator_name', how='left'
-        ).fillna({'color': '#1f77b4'})
+        if sort_opt == "Top 10":
+            subset = subset.iloc[::-1]
         
-        if sort_option_3c == "Top 10":
-            subset_data = subset_data.iloc[::-1]
-
-        fig_rep_creator = px.bar(
-            subset_data,
-            x='avg_monthly_rate',
-            y='creator_name',
-            orientation='h',
-            title=f'Avg Monthly Finding Rate — {sort_option_3c}',
+        fig = px.bar(
+            subset, x='avg_monthly_rate', y='creator_name', orientation='h',
+            title=f'{sort_opt} Reporters',
             labels={'avg_monthly_rate': 'Avg Monthly Findings', 'creator_name': 'Reporter'},
-            color='color',
-            color_discrete_map={c: c for c in subset_data['color'].unique()},
-            text=subset_data['avg_monthly_rate'].apply(lambda x: f'{x:.2f}')
-        )
-        fig_rep_creator.update_layout(
-            yaxis={'categoryorder': 'array', 'categoryarray': subset_data['creator_name'].tolist()},
-            height=500,
-            showlegend=False
+            color='color', color_discrete_map={c: c for c in subset['color'].unique()},
+            text=subset['avg_monthly_rate'].apply(lambda x: f'{x:.2f}')
         )
-        fig_rep_creator.update_traces(textposition='auto')
-        st.plotly_chart(fig_rep_creator, use_container_width=True)
+        fig.update_layout(height=450, showlegend=False, yaxis={'categoryorder': 'array', 'categoryarray': subset['creator_name'].tolist()})
+        fig.update_traces(textposition='auto')
+        st.plotly_chart(fig, use_container_width=True)
         
-        # 🔥 INSIGHT: dari FULL DATA
-        if len(sorted_all_3c) >= 2:
-            min_val = sorted_all_3c['avg_monthly_rate'].min()
-            max_val = sorted_all_3c['avg_monthly_rate'].max()
-            mean_val = sorted_all_3c['avg_monthly_rate'].mean()
-            median_val = sorted_all_3c['avg_monthly_rate'].median()
-            best_reporter = sorted_all_3c.iloc[0]['creator_name']
-            worst_reporter = sorted_all_3c.iloc[-1]['creator_name']
-            
-            insight_text = (
+        if len(full_sorted) >= 2:
+            min_r, max_r, mean_r = full_sorted['avg_monthly_rate'].min(), full_sorted['avg_monthly_rate'].max(), full_sorted['avg_monthly_rate'].mean()
+            top_reporter = full_sorted.iloc[0]['creator_name']
+            st.markdown(
                 f"<div class='ai-insight'>"
-                f"<strong>Overall (all {len(sorted_all_3c)} reporters)</strong>: Monthly rate ranges from <strong>{min_val:.2f}</strong> "
-                f"to <strong>{max_val:.2f}</strong> (mean: <strong>{mean_val:.2f}</strong>). "
-                f"<strong>{best_reporter}</strong> is the top reporter; <strong>{worst_reporter}</strong> reports least frequently. "
-                f"<strong>Recommendation:</strong> Conduct 1:1 coaching for reporters with <0.5 findings/month; recognize top contributors publicly to motivate peers."
-                f"</div>"
+                f"<strong>Insight:</strong> Individual reporting ranges from {min_r:.2f} to {max_r:.2f} findings/month (avg: {mean_r:.2f}). "
+                f"<strong>{top_reporter}</strong> is the most active contributor. "
+                f"<strong>Recommendation:</strong> Recognize top reporters; investigate causes of low activity (<0.5/month) via 1:1 review."
+                f"</div>",
+                unsafe_allow_html=True
             )
-        else:
-            insight_text = "<div class='ai-insight'>Insufficient data for insight.</div>"
-        st.markdown(insight_text, unsafe_allow_html=True)
 
 
-# Baris 2: 3b & 3d
+# ─── Baris 2: Executor ─────────���─────────────────────────────────────────────
 col_3b, col_3d = st.columns(2)
 
+# ─── 3b: Executor by Division (Lead Time) ────────────────────────────────────
 with col_3b:
-    st.markdown("<h5>3c. Average Lead Time by Division (Executor)</h5>", unsafe_allow_html=True)
+    st.markdown("<h5 style='text-align:center;'>3b. Avg Lead Time by Division (Executor)</h5>", unsafe_allow_html=True)
     if avg_leadtime_nama.empty:
-        st.warning("No data for executor analysis by division.")
+        st.warning("No data for division-level executor analysis.")
     else:
-        sort_option_3b = st.selectbox("Show 3b:", ["Top 10", "Bottom 10"], key='sort_3b')
-        
-        # Full data: ascending (low = fast = good)
-        sorted_all_3b = avg_leadtime_nama.sort_values('avg_monthly_leadtime', ascending=True).reset_index(drop=True)
+        sort_opt = st.selectbox("Show:", ["Fastest 10", "Slowest 10"], key='sort_3b')
         
-        if sort_option_3b == "Top 10":
-            # Top 10 tercepat (terendah)
-            subset_data = sorted_all_3b.head(10).sort_values('avg_monthly_leadtime', ascending=False) 
+        full_sorted = avg_leadtime_nama.sort_values('avg_monthly_leadtime', ascending=True)  # cepat → lambat
+        if sort_opt == "Fastest 10":
+            subset = full_sorted.head(10).sort_values('avg_monthly_leadtime', ascending=False)  # descending dalam subset (cepat di bawah)
         else:
-            # Bottom 10 = terlama (tertinggi)
-            subset_data = sorted_all_3b.tail(10).sort_values('avg_monthly_leadtime', ascending=False)  # descending dalam subset
+            subset = full_sorted.tail(10).sort_values('avg_monthly_leadtime', ascending=False)  # lambat di atas
         
-        # Warna global: 5 division dengan lead time TERPANJANG → merah
-        avg_leadtime_nama_colored = add_color_by_global_rank(
-            avg_leadtime_nama, 'avg_monthly_leadtime', worst_n=5, high_is_good=False
-        )
-        subset_data = subset_data.merge(
-            avg_leadtime_nama_colored[['nama', 'color']], on='nama', how='left'
-        ).fillna({'color': '#1f77b4'})
+        # Warna: 5 terlama → merah
+        colored = add_color_by_global_rank(avg_leadtime_nama, 'avg_monthly_leadtime', worst_n=5, high_is_good=False)
+        subset = subset.merge(colored[['nama', 'color']], on='nama', how='left').fillna({'color': '#1f77b4'})
+        
+        # Reverse agar Slowest 10: tertinggi di atas
+        if sort_opt == "Slowest 10":
+            subset = subset.iloc[::-1]
         
-        # Reverse untuk visual yang intuitif (lama di atas)
-        if sort_option_3b == "Bottom 10":
-            subset_data = subset_data.iloc[::-1]  # biar tertinggi di atas
-
-        fig_exec_nama = px.bar(
-            subset_data,
-            x='avg_monthly_leadtime',
-            y='nama',
-            orientation='h',
-            title=f'Avg Monthly Lead Time (Days) — {sort_option_3b}',
+        fig = px.bar(
+            subset, x='avg_monthly_leadtime', y='nama', orientation='h',
+            title=f'{sort_opt}',
             labels={'avg_monthly_leadtime': 'Avg Lead Time (Days)', 'nama': 'Division'},
-            color='color',
-            color_discrete_map={c: c for c in subset_data['color'].unique()},
-            text=subset_data['avg_monthly_leadtime'].apply(lambda x: f'{x:.2f}')
-        )
-        fig_exec_nama.update_layout(
-            yaxis={'categoryorder': 'array', 'categoryarray': subset_data['nama'].tolist()},
-            height=500,
-            showlegend=False
+            color='color', color_discrete_map={c: c for c in subset['color'].unique()},
+            text=subset['avg_monthly_leadtime'].apply(lambda x: f'{x:.1f}')
         )
-        fig_exec_nama.update_traces(textposition='auto')
-        st.plotly_chart(fig_exec_nama, use_container_width=True)
+        fig.update_layout(height=450, showlegend=False, yaxis={'categoryorder': 'array', 'categoryarray': subset['nama'].tolist()})
+        fig.update_traces(textposition='auto')
+        st.plotly_chart(fig, use_container_width=True)
         
-        # 🔥 INSIGHT: dari FULL DATA
-        if len(sorted_all_3b) >= 2:
-            min_lt = sorted_all_3b['avg_monthly_leadtime'].min()
-            max_lt = sorted_all_3b['avg_monthly_leadtime'].max()
-            mean_lt = sorted_all_3b['avg_monthly_leadtime'].mean()
-            median_lt = sorted_all_3b['avg_monthly_leadtime'].median()
-            fastest_div = sorted_all_3b.iloc[0]['nama']
-            slowest_div = sorted_all_3b.iloc[-1]['nama']
-            
-            insight_text = (
+        if len(full_sorted) >= 2:
+            min_lt, max_lt, mean_lt = full_sorted['avg_monthly_leadtime'].min(), full_sorted['avg_monthly_leadtime'].max(), full_sorted['avg_monthly_leadtime'].mean()
+            fastest, slowest = full_sorted.iloc[0]['nama'], full_sorted.iloc[-1]['nama']
+            st.markdown(
                 f"<div class='ai-insight'>"
-                f"<strong>Overall (all {len(sorted_all_3b)} divisions)</strong>: Resolution time ranges from <strong>{min_lt:.1f}</strong> "
-                f"to <strong>{max_lt:.1f}</strong> days (mean: <strong>{mean_lt:.1f}</strong>, median: <strong>{median_lt:.1f}</strong>). "
-                f"<strong>{slowest_div}</strong> has the longest lead time; <strong>{fastest_div}</strong> resolves fastest. "
-                f"<strong>Recommendation:</strong> Escalate SLA breach risk for divisions >7 days; initiate root-cause analysis for {slowest_div} and replicate efficiency from {fastest_div}."
-                f"</div>"
+                f"<strong>Insight:</strong> Resolution time ranges from {min_lt:.1f} to {max_lt:.1f} days (avg: {mean_lt:.1f}). "
+                f"<strong>{slowest}</strong> has highest risk of SLA breach. "
+                f"<strong>Recommendation:</strong> Initiate RCA for {slowest}; replicate workflow from {fastest}. Set SLA threshold at 7 days."
+                f"</div>",
+                unsafe_allow_html=True
             )
-        else:
-            insight_text = "<div class='ai-insight'>Insufficient data for insight.</div>"
-        st.markdown(insight_text, unsafe_allow_html=True)
 
 
+# ─── 3d: Executor by Individual ──────────────────────────────────────────────
 with col_3d:
-    st.markdown("<h5>3d. Average Lead Time by Executor (Name)</h5>", unsafe_allow_html=True)
-    if avg_leadtime_per_executor.empty:
-        st.warning("No data for executor analysis by nama_pic.")
+    st.markdown(f"<h5 style='text-align:center;'>3d. Avg Lead Time per Executor ({EXECUTOR_INDIV_COL})</h5>", unsafe_allow_html=True)
+    if avg_leadtime_per_indiv.empty:
+        st.warning(f"No data for individual executor analysis (column: '{EXECUTOR_INDIV_COL}').")
     else:
-        sort_option_3d = st.selectbox("Show 3d:", ["Top 10", "Bottom 10"], key='sort_3d')
-        
-        sorted_all_3d = avg_leadtime_per_executor.sort_values('avg_monthly_leadtime', ascending=True).reset_index(drop=True)
+        sort_opt = st.selectbox("Show:", ["Fastest 10", "Slowest 10"], key='sort_3d')
         
-        if sort_option_3d == "Top 10":
-            subset_data = sorted_all_3b.head(10).sort_values('avg_monthly_leadtime', ascending=False) 
+        full_sorted = avg_leadtime_per_indiv.sort_values('avg_monthly_leadtime', ascending=True)
+        if sort_opt == "Fastest 10":
+            subset = full_sorted.head(10).sort_values('avg_monthly_leadtime', ascending=False)
         else:
-            subset_data = sorted_all_3d.tail(10).sort_values('avg_monthly_leadtime', ascending=False)
+            subset = full_sorted.tail(10).sort_values('avg_monthly_leadtime', ascending=False)
         
-        # Warna global: 5 eksekutor TERLAMBAT → merah
-        avg_leadtime_per_executor_colored = add_color_by_global_rank(
-            avg_leadtime_per_executor, 'avg_monthly_leadtime', worst_n=5, high_is_good=False
-        )
-        subset_data = subset_data.merge(
-            avg_leadtime_per_executor_colored[['nama_pic', 'color']], on='nama_pic', how='left'
-        ).fillna({'color': '#1f77b4'})
+        # Warna: 5 terlama → merah
+        colored = add_color_by_global_rank(avg_leadtime_per_indiv, 'avg_monthly_leadtime', worst_n=5, high_is_good=False)
+        id_col = EXECUTOR_INDIV_COL
+        subset = subset.merge(colored[[id_col, 'color']], on=id_col, how='left').fillna({'color': '#1f77b4'})
         
-        if sort_option_3d == "Bottom 10":
-            subset_data = subset_data.iloc[::-1]
-
-        fig_exec_pic = px.bar(
-            subset_data,
-            x='avg_monthly_leadtime',
-            y='nama_pic',
-            orientation='h',
-            title=f'Avg Monthly Lead Time (Days) — {sort_option_3d}',
-            labels={'avg_monthly_leadtime': 'Avg Lead Time (Days)', 'nama_pic': 'Executor'},
-            color='color',
-            color_discrete_map={c: c for c in subset_data['color'].unique()},
-            text=subset_data['avg_monthly_leadtime'].apply(lambda x: f'{x:.2f}')
-        )
-        fig_exec_pic.update_layout(
-            yaxis={'categoryorder': 'array', 'categoryarray': subset_data['nama_pic'].tolist()},
-            height=500,
-            showlegend=False
+        if sort_opt == "Slowest 10":
+            subset = subset.iloc[::-1]
+        
+        fig = px.bar(
+            subset, x='avg_monthly_leadtime', y=id_col, orientation='h',
+            title=f'{sort_opt}',
+            labels={'avg_monthly_leadtime': 'Avg Lead Time (Days)', id_col: 'Executor'},
+            color='color', color_discrete_map={c: c for c in subset['color'].unique()},
+            text=subset['avg_monthly_leadtime'].apply(lambda x: f'{x:.1f}')
         )
-        fig_exec_pic.update_traces(textposition='auto')
-        st.plotly_chart(fig_exec_pic, use_container_width=True)
+        fig.update_layout(height=450, showlegend=False, yaxis={'categoryorder': 'array', 'categoryarray': subset[id_col].tolist()})
+        fig.update_traces(textposition='auto')
+        st.plotly_chart(fig, use_container_width=True)
         
-        # 🔥 INSIGHT: dari FULL DATA
-        if len(sorted_all_3d) >= 2:
-            min_lt = sorted_all_3d['avg_monthly_leadtime'].min()
-            max_lt = sorted_all_3d['avg_monthly_leadtime'].max()
-            mean_lt = sorted_all_3d['avg_monthly_leadtime'].mean()
-            median_lt = sorted_all_3d['avg_monthly_leadtime'].median()
-            fastest_exec = sorted_all_3d.iloc[0]['nama_pic']
-            slowest_exec = sorted_all_3d.iloc[-1]['nama_pic']
-            
-            insight_text = (
+        if len(full_sorted) >= 2:
+            min_lt, max_lt, mean_lt = full_sorted['avg_monthly_leadtime'].min(), full_sorted['avg_monthly_leadtime'].max(), full_sorted['avg_monthly_leadtime'].mean()
+            slowest_exec = full_sorted.iloc[-1][id_col]
+            st.markdown(
                 f"<div class='ai-insight'>"
-                f"<strong>Overall (all {len(sorted_all_3d)} executors)</strong>: Lead time ranges from <strong>{min_lt:.1f}</strong> "
-                f"to <strong>{max_lt:.1f}</strong> days (mean: <strong>{mean_lt:.1f}</strong>). "
-                f"<strong>{slowest_exec}</strong> has the longest resolution time; <strong>{fastest_exec}</strong> is most efficient. "
-                f"<strong>Recommendation:</strong> Assign mentor to executors with >7-day average; document and share best practices from {fastest_exec} across the team."
-                f"</div>"
+                f"<strong>Insight:</strong> Executor performance ranges from {min_lt:.1f} to {max_lt:.1f} days (avg: {mean_lt:.1f}). "
+                f"<strong>{slowest_exec}</strong> requires support to meet SLA. "
+                f"<strong>Recommendation:</strong> Assign mentor to executors >7 days; document & share best practices from top performers."
+                f"</div>",
+                unsafe_allow_html=True
             )
-        else:
-            insight_text = "<div class='ai-insight'>Insufficient data for insight.</div>"
-        st.markdown(insight_text, unsafe_allow_html=True)
 
+#Objective 4
 try:
     from wordcloud import WordCloud
     import matplotlib.pyplot as plt