Update app.py

app.py

@@ -1976,202 +1976,213 @@ else:
 
 st.markdown("<h3 class='section-title'>OBJECTIVE 7 - Insight and Recommendation</h3>", unsafe_allow_html=True)
 
-def compute_ai_insights(df: pd.DataFrame) -> List[dict]:
+
+def compute_risk_mitigation_insights(df: pd.DataFrame) -> List[dict]:
     """
-    Generates insights and recommendations based on the current data and average monthly ratios.
-    Returns a list of dictionaries, each containing an 'insight' and a 'recommendation'.
+    Generates *risk-mitigation-focused* insights and recommendations across:
+    - Locations & Coverage Equity
+    - Divisional Reporting Load (people & frequency)
+    - Agentic Safety Behaviors (proactive vs reactive)
+    - Wordcloud-based Emerging Risk Detection
+    - Actionable coverage-balancing strategies
     """
-    insight_recommendations = []
+    insights = []
 
     if df.empty:
-        return insight_recommendations
+        return insights
+
+    # --- Helper: Detect risk terms from wordcloud (simulate via keyword freq in 'uraian_temuan' or similar) ---
+    def detect_emerging_risks(df):
+        # Assume 'uraian_temuan' or 'temuan_uraian' contains free text
+        text_col = None
+        for col in ['uraian_temuan', 'temuan_uraian', 'keterangan', 'catatan']:
+            if col in df.columns and df[col].notna().any():
+                text_col = col
+                break
+        if text_col is None:
+            return [], []
+
+        # Combine all text (non-null)
+        all_text = ' '.join(df[text_col].dropna().astype(str).str.lower())
+        # Define risk lexicon (adjust based on domain)
+        risk_keywords = [
+            'terbuka', 'tidak terkunci', 'tanpa izin', 'tanpa alat', 'tanpa pelindung',
+            'overload', 'short circuit', 'grounding', 'exposed', 'fall', 'slip',
+            'fire hazard', 'unauthorized', 'no ppe', 'unsecured', 'untrained'
+        ]
+        found_risks = [kw for kw in risk_keywords if kw in all_text]
+        return risk_keywords, found_risks
+
+    # --- 1. Coverage Equity by Location (Spatial Risk Mapping) ---
+    if 'nama_lokasi_full' in df.columns and 'creator_nid' in df.columns:
+        loc_activity = df.groupby('nama_lokasi_full').agg(
+            findings_count=('temuan_id', 'count'),
+            unique_reporters=('creator_nid', 'nunique')
+        ).reset_index()
+        total_locations = loc_activity.shape[0]
+        low_coverage_locs = loc_activity[loc_activity['unique_reporters'] <= 1]
+        high_volume_locs = loc_activity[loc_activity['findings_count'] > loc_activity['findings_count'].quantile(0.75)]
+
+        # Risk: High findings + low reporters = under-coverage bias
+        risky_high_low = loc_activity[
+            (loc_activity['findings_count'] > loc_activity['findings_count'].median()) &
+            (loc_activity['unique_reporters'] <= 2)
+        ]
 
-    total_findings = len(df)
-    total_locations = df['nama_lokasi_full'].nunique() if 'nama_lokasi_full' in df.columns else 0
-    total_companies = df['nama_perusahaan'].nunique() if 'nama_perusahaan' in df.columns else 0
-    total_divisions = df['nama'].nunique() if 'nama' in df.columns else 0
+        if not risky_high_low.empty:
+            loc_list = risky_high_low['nama_lokasi_full'].tolist()[:3]
+            loc_names = ', '.join(loc_list)
+            insight = (
+                f"Locations {loc_names} show high finding volume but rely on ≤2 reporters, indicating potential blind spots "
+                f"and over-dependence on few individuals — a coverage equity risk."
+            )
+            recommendation = (
+                f"Redistribute inspection assignments using rotation schedules. Deploy 'buddy auditing' for high-risk locations. "
+                f"Introduce anonymous near-miss reporting channels to supplement formal findings."
+            )
+            insights.append({"insight": insight, "recommendation": recommendation})
 
-    # --- 1. Insight & Recommendation: Rata-rata Bulanan Ratio Temuan/Orang Perusahaan ---
-    if 'nama_perusahaan' in df.columns and 'creator_nid' in df.columns:
-        df_with_month = df.copy()
-        df_with_month['created_month'] = df_with_month['created_at'].dt.to_period('M')
-        
-        # Hitung temuan per bulan per perusahaan
-        findings_by_company_month = df_with_month.groupby(['created_month', 'nama_perusahaan']).size().reset_index(name='findings_count')
-        # Hitung jumlah orang unik per bulan per perusahaan
-        creators_by_company_month = df_with_month.groupby(['created_month', 'nama_perusahaan'])['creator_nid'].nunique().reset_index(name='unique_creators')
-        # Gabung
-        merged_ratio = findings_by_company_month.merge(creators_by_company_month, on=['created_month', 'nama_perusahaan'], how='outer')
-        # Filter untuk menghindari pembagian dengan nol
-        merged_ratio = merged_ratio[merged_ratio['unique_creators'] > 0]
-        # Hitung rasio (ignore NaN)
-        merged_ratio['ratio'] = merged_ratio['findings_count'] / merged_ratio['unique_creators']
-        merged_ratio['ratio'] = merged_ratio['ratio'].replace([np.inf, -np.inf], np.nan)
-
-        # Rata-rata bulanan per perusahaan
-        avg_ratio_per_company = merged_ratio.groupby('nama_perusahaan')['ratio'].mean().reset_index(name='avg_monthly_ratio')
-        # Filter hasil akhir untuk menghindari NaN
-        avg_ratio_per_company = avg_ratio_per_company.dropna(subset=['avg_monthly_ratio'])
-
-        if not avg_ratio_per_company.empty:
-            # Temukan perusahaan dengan rasio tertinggi dan terendah
-            top_company_ratio = avg_ratio_per_company.loc[avg_ratio_per_company['avg_monthly_ratio'].idxmax()]
-            low_company_ratio = avg_ratio_per_company.loc[avg_ratio_per_company['avg_monthly_ratio'].idxmin()]
-            
-            insight_text = (
-                f"Based on the average monthly finding-to-person ratio, "
-                f"Company '{top_company_ratio['nama_perusahaan']}' has the highest activity level ({top_company_ratio['avg_monthly_ratio']:.2f} findings/person/month), "
-                f"while '{low_company_ratio['nama_perusahaan']}' has the lowest ({low_company_ratio['avg_monthly_ratio']:.2f} findings/person/month)."
+        if not low_coverage_locs.empty and len(low_coverage_locs) > total_locations * 0.3:
+            insight = (
+                f"Over 30% of locations ({len(low_coverage_locs)}/{total_locations}) are covered by only 1 reporter, "
+                f"increasing the risk of unreported hazards due to observer fatigue or familiarity bias."
+            )
+            recommendation = (
+                f"Implement mandatory location rotation for auditors every 2 months. "
+                f"Use geotagged photo evidence to validate field presence and ensure physical coverage."
+            )
+            insights.append({"insight": insight, "recommendation": recommendation})
+
+    # --- 2. Divisional Load & Frequency Risk (Over/Under-Reporting) ---
+    if 'nama' in df.columns and 'created_at' in df.columns:  # `nama` = divisi (per permintaan user)
+        div_summary = df.groupby('nama').agg(
+            total_findings=('temuan_id', 'count'),
+            unique_people=('creator_nid', 'nunique'),
+            first_report=('created_at', 'min'),
+            last_report=('created_at', 'max')
+        )
+        div_summary['reporting_span_days'] = (div_summary['last_report'] - div_summary['first_report']).dt.days + 1
+        div_summary['avg_freq_per_person'] = div_summary['total_findings'] / div_summary['unique_people']
+        div_summary['findings_per_day'] = div_summary['total_findings'] / div_summary['reporting_span_days']
+
+        # Define thresholds (adjust as needed)
+        HIGH_LOAD_THRESHOLD = 8   # avg > 8 findings/person
+        LOW_ACTIVITY_THRESHOLD = 0.2  # < 0.2 findings/day
+
+        high_load_div = div_summary[div_summary['avg_freq_per_person'] >= HIGH_LOAD_THRESHOLD]
+        low_activity_div = div_summary[div_summary['findings_per_day'] <= LOW_ACTIVITY_THRESHOLD]
+
+        if not high_load_div.empty:
+            top_div = high_load_div['avg_freq_per_person'].idxmax()
+            insight = (
+                f"Division '{top_div}' has an elevated reporting load ({high_load_div.loc[top_div, 'avg_freq_per_person']:.1f} findings/person), "
+                f"which may lead to fatigue, rushed inspections, or selective reporting."
             )
-            recommendation_text = (
-                f"For '{top_company_ratio['nama_perusahaan']}': Investigate the underlying reasons for the high ratio. Is it due to active reporting, higher risk, or more personnel? "
-                f"For '{low_company_ratio['nama_perusahaan']}': Verify if the low ratio reflects effective risk management or potential under-reporting."
+            recommendation = (
+                f"Augment the division’s safety team with cross-trained support staff. "
+                f"Introduce AI-assisted checklist validation to reduce cognitive load. "
+                f"Monitor for declining finding quality (e.g., vague descriptions)."
             )
-            insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
+            insights.append({"insight": insight, "recommendation": recommendation})
+
+        if not low_activity_div.empty:
+            low_divs = low_activity_div.index.tolist()[:3]
+            div_names = ', '.join(low_divs)
+            insight = (
+                f"Divisions {div_names} show persistently low reporting frequency (<0.2 findings/day), "
+                f"suggesting either excellent safety performance or significant under-reporting."
+            )
+            recommendation = (
+                f"Conduct a *silent audit* (observation-only, no prior notice) in these divisions to validate safety status. "
+                f"Review training records and psychological safety survey scores — fear of blame suppresses reporting."
+            )
+            insights.append({"insight": insight, "recommendation": recommendation})
 
-    # --- 2. Insight & Recommendation: Distribusi Temuan (Umum) ---
+    # --- 3. Agentic Safety Mitigation (Proactive vs Reactive Behavior) ---
     if 'temuan_kategori' in df.columns:
-        cat_counts = df['temuan_kategori'].value_counts()
-        top_cat = cat_counts.index[0] if not cat_counts.empty else "N/A"
-        top_cat_count = cat_counts.iloc[0] if not cat_counts.empty else 0
-        if top_cat != "N/A":
-            perc = (top_cat_count / total_findings) * 100
-            if top_cat == "Positive":
-                insight_text = (
-                    f"The majority of findings ({top_cat_count} or {perc:.1f}%) are categorized as 'Positive'. "
-                    f"This indicates a strong culture of recognizing and reporting good practices and safety compliance."
-                )
-                recommendation_text = (
-                    f"Maintain and reinforce the positive reporting culture. "
-                    f"Consider using these 'Positive' examples as best practice case studies for training and awareness programs."
-                )
-            else:
-                insight_text = (
-                    f"The most frequent finding category is '{top_cat}' ({top_cat_count} instances, {perc:.1f}% of total). "
-                    f"This highlights a specific area requiring focused attention."
-                )
-                recommendation_text = (
-                    f"Conduct a root-cause analysis for the '{top_cat}' category. "
-                    f"Develop targeted corrective actions and preventive measures to address the underlying issues."
-                )
-            insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
-
-    # --- 3. Insight & Recommendation: Aktivitas Lokasi (Umum) ---
-    if 'nama_lokasi_full' in df.columns and total_locations > 0:
-        loc_counts = df['nama_lokasi_full'].value_counts()
-        top_loc = loc_counts.index[0] if not loc_counts.empty else "N/A"
-        top_loc_count = loc_counts.iloc[0] if not loc_counts.empty else 0
-        if top_loc != "N/A":
-            insight_text = (
-                f"Location '{top_loc}' has the highest number of findings ({top_loc_count}). "
-                f"This could indicate higher activity, more scrutiny, or potentially higher risk in this area."
+        # Assume: 'Positive' = proactive (e.g., good housekeeping, initiative)
+        # Others (e.g., 'Unsafe Condition', 'Unsafe Act') = reactive
+        total = len(df)
+        proactive = (df['temuan_kategori'] == 'Positive').sum()
+        reactive = total - proactive
+        proactive_rate = proactive / total if total > 0 else 0
+
+        insight = (
+            f"Only {proactive_rate:.1%} of findings reflect *proactive* safety behaviors (e.g., positive interventions, improvements). "
+            f"The remaining {100 - proactive_rate*100:.1f}% are *reactive* (hazards already present)."
+        )
+        recommendation = (
+            f"Shift incentives from 'finding count' to 'prevention impact'. "
+            f"Launch an *Agentic Safety Program*: reward near-miss reports, safety suggestions, and coaching moments. "
+            f"Track % of proactive findings monthly as a leading KPI."
+        )
+        insights.append({"insight": insight, "recommendation": recommendation})
+
+    # --- 4. Emerging Risk Detection via Wordcloud (Cloud = Risk Signal) ---
+    all_risk_terms, detected_terms = detect_emerging_risks(df)
+    if detected_terms:
+        missing_terms = set(all_risk_terms) - set(detected_terms)
+        # If *some* high-severity terms appear, but not all → partial risk cloud
+        high_sev_terms = ['exposed', 'fire hazard', 'fall', 'short circuit', 'unauthorized']
+        detected_high = [t for t in detected_terms if t in high_sev_terms]
+        if detected_high:
+            terms_str = ', '.join(detected_high)
+            insight = (
+                f"Wordcloud analysis indicates emerging high-severity risks: *{terms_str}*. "
+                f"These signal active hazards (e.g., exposed conductors, fall risks) not yet fully mitigated."
             )
-            recommendation_text = (
-                f"Perform a detailed review of activities in '{top_loc}'. "
-                f"Determine if the high volume is due to increased activity or specific risk factors. "
-                f"Ensure adequate resources and controls are in place."
+            recommendation = (
+                f"Launch a 14-day *Targeted Risk Blitz* on locations reporting these terms. "
+                f"Require immediate photo evidence of corrective actions. "
+                f"Update inspection checklists to prioritize these items."
             )
-            insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
-
-    # --- 4. Insight & Recommendation: Kinerja Resolusi (Umum) ---
-    if 'days_to_close' in df.columns:
-        closed_df = df.dropna(subset=['days_to_close'])
-        if not closed_df.empty:
-            avg_close_time = closed_df['days_to_close'].mean()
-            median_close_time = closed_df['days_to_close'].median()
-            # Ambang batas SLA, misal 7 hari
-            sla_threshold = 7
-            slow_findings = closed_df[closed_df['days_to_close'] > sla_threshold]
-            slow_count = len(slow_findings)
-            slow_percentage = (slow_count / len(closed_df)) * 100 if len(closed_df) > 0 else 0
-
-            insight_text = (
-                f"The average time to close findings is {avg_close_time:.1f} days (median: {median_close_time:.1f} days). "
-                f"{slow_count} findings ({slow_percentage:.1f}%) exceeded the {sla_threshold}-day SLA."
+            insights.append({"insight": insight, "recommendation": recommendation})
+
+        # Cloud still exists → why?
+        if missing_terms and len(detected_terms) > 3:
+            insight = (
+                f"Despite mitigation efforts, the risk 'cloud' persists — likely due to: "
+                f"(1) Recurring root causes (e.g., contractor turnover), "
+                f"(2) Incomplete closure verification, or "
+                f"(3) Findings reappearing in new locations after fixes in old ones."
             )
-            if slow_percentage > 20:
-                recommendation_text = (
-                    f"The resolution performance is below target. Investigate bottlenecks in the closure process. "
-                    f"Prioritize findings that are taking longer than {sla_threshold} days. Consider implementing an escalation matrix."
-                )
-            else:
-                recommendation_text = (
-                    f"The resolution performance is generally good, but there's room for improvement. "
-                    f"Focus on reducing the backlog of findings that exceed the {sla_threshold}-day SLA."
-                )
-            insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
-
-    # --- 5. Insight & Recommendation: Tren Bulanan (Umum) ---
-    if 'created_at' in df.columns:
-        monthly_trend = df.set_index('created_at').resample('M').size()
-        if len(monthly_trend) >= 2:
-            last_month_count = monthly_trend.iloc[-1]
-            prev_month_count = monthly_trend.iloc[-2]
-            if prev_month_count > 0:
-                change_pct = (last_month_count - prev_month_count) / prev_month_count * 100
-                trend_word = "increase" if change_pct > 0 else "decrease"
-                insight_text = (
-                    f"There was a {change_pct:+.1f}% {trend_word} in finding volume between the last two months "
-                    f"({monthly_trend.index[-2].strftime('%b %Y')} and {monthly_trend.index[-1].strftime('%b %Y')})."
-                )
-                if abs(change_pct) > 20: # Jika perubahan besar
-                    recommendation_text = (
-                        f"Investigate the cause of this significant {trend_word} in findings. "
-                        f"Review operational changes, contractor activities, or audit focus shifts that occurred recently."
-                    )
-                else:
-                    recommendation_text = (
-                        f"Monitor the trend over the next few weeks to see if this change represents a new pattern or a temporary fluctuation."
-                    )
-                insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
-
-    # --- 6. Insight & Recommendation: Aktivitas Pelapor (Umum) ---
-    if 'creator_nid' in df.columns:
-        active_reporters = df['creator_nid'].nunique()
-        total_reports = len(df)
-        avg_reports_per_person = total_reports / active_reporters if active_reporters > 0 else 0
-        # Cek apakah ada reporter dominan
-        top_reporter_counts = df['creator_nid'].value_counts()
-        if not top_reporter_counts.empty:
-            top_reporter_id = top_reporter_counts.index[0]
-            top_reporter_count = top_reporter_counts.iloc[0]
-            if top_reporter_count / total_reports > 0.15: # Jika satu orang membuat > 15% laporan
-                insight_text = (
-                    f"Reporter with ID '{top_reporter_id}' has submitted a disproportionately high number of findings ({top_reporter_count}). "
-                    f"They account for {top_reporter_count/total_reports*100:.1f}% of the total volume."
-                )
-                recommendation_text = (
-                    f"Recognize the active reporter. Also, ensure reporting is distributed across the team "
-                    f"to provide a more comprehensive view of risks across all areas and activities."
-                )
-                insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
-
-    return insight_recommendations
+            recommendation = (
+                f"Adopt *closed-loop verification*: require geo-tagged before/after photos + supervisor sign-off. "
+                f"Map recurring findings to contractor IDs — hold vendors accountable via SLA penalties. "
+                f"Use AI to cluster similar findings across time/location to detect systemic failures."
+            )
+            insights.append({"insight": insight, "recommendation": recommendation})
+
+    # --- 5. Coverage Balancing Strategy (How to Achieve Equitable Coverage) ---
+    # Based on location & reporter distribution
+    if 'nama_lokasi_full' in df.columns and 'creator_nid' in df.columns:
+        reporters_per_location = df.groupby('nama_lokasi_full')['creator_nid'].nunique()
+        coverage_gini = (reporters_per_location.std() / reporters_per_location.mean()) if reporters_per_location.mean() > 0 else 0
+
+        if coverage_gini > 0.6:  # High inequality
+            insight = (
+                f"Coverage inequality (Gini ≈ {coverage_gini:.2f}) is high — a few locations dominate reporting effort. "
+                f"This creates surveillance deserts in low-coverage zones."
+            )
+            recommendation = (
+                f"1. Assign *minimum 2 unique reporters per high-risk location* monthly. "
+                f"2. Use route optimization (e.g., VRP algorithm) to balance travel + inspection load. "
+                f"3. Deploy mobile micro-checklists for non-auditors (e.g., operators) to increase eyes-on-ground."
+            )
+            insights.append({"insight": insight, "recommendation": recommendation})
 
-# Panggil fungsi untuk mendapatkan insight dan rekomendasi
-ai_insights_and_recs = compute_ai_insights(df_filtered)
+    return insights
 
-# Tampilkan hasil
+# Generate and display
+risk_insights = compute_risk_mitigation_insights(df_filtered)
 
-if ai_insights_and_recs:
-    for i, item in enumerate(ai_insights_and_recs):
-        insight = item["insight"]
-        recommendation = item["recommendation"]
-        # Tampilkan Insight
-        st.markdown(f'<div class="ai-insight"><strong>Insight {i+1}:</strong> {insight}</div>', unsafe_allow_html=True)
-        # Tampilkan Recommendation
-        st.markdown(f'<div class="ai-recommendation"><strong>Recommendation {i+1}:</strong> {recommendation}</div>', unsafe_allow_html=True)
+if risk_insights:
+    for i, ir in enumerate(risk_insights, 1):
+        st.markdown(f"<div class='ai-insight'><strong>Insight {i}:</strong> {ir['insight']}</div>", unsafe_allow_html=True)
+        st.markdown(f"<div class='ai-recommendation'><strong>Action {i}:</strong> {ir['recommendation']}</div>", unsafe_allow_html=True)
 else:
-    # Jika tidak ada insight yang dihasilkan, mungkin karena data kosong atau kolom tidak ditemukan
-    st.markdown('<div class="ai-insight">No significant AI insights could be generated. This might be due to insufficient data or missing required columns after filtering.</div>', unsafe_allow_html=True)
-
-# =================== FOOTER ===================
-st.markdown("---")
-st.markdown(
-    """
-    <div style="text-align:center; color:#757575; font-size:0.9em;">
-        <strong> Special Design for PLN </strong> •  © 2025 PT Bukit Technology
-    </div>
-    """,
-    unsafe_allow_html=True
-)
+    st.markdown(
+        "<div class='ai-insight'>No risk-mitigation insights generated. Ensure key columns are present: "
+        "<code>nama_lokasi_full</code>, <code>nama</code> (division), <code>creator_nid</code>, <code>temuan_kategori</code>, and free-text field (e.g., <code>uraian_temuan</code>).</div>",
+        unsafe_allow_html=True
+    )