Update app.py

app.py

@@ -1,17 +1,17 @@
 # -*- coding: utf-8 -*-
 """
-app.py — IPLM 2025 (FULL)
+app.py — IPLM 2025 (FULL, FIX DUPLICATE + FULL INDICATORS)
 - Pipeline nasional: Yeo-Johnson + MinMax (sekali nasional)
-- RealScore + (FinalScore = RealScore * bobot_coverage_68)
-- Bobot coverage:
-    * 68% = bobot 1.0
-    * <68% = coverage/0.68
-    * 0% = 0.0
+- FinalScore = RealScore * bobot_coverage_68 (internal)
+- 68% coverage = bobot 1.0 ; <68% bobot = coverage/0.68
 - Populasi resmi:
-    * KAB/KOTA: Data_populasi_Kab_kota.xlsx
-    * PROVINSI: Data_populasi_propinsi.xlsx
-- Verifikasi: coverage, gap menuju 68%, bobot
-- Export: agregat/detail/raw + Word report
+    * Kab/Kota: Data_populasi_Kab_kota.xlsx
+    * Provinsi: Data_populasi_propinsi.xlsx
+- FIX:
+    * Dropdown prov/kab tidak dobel (PROV_DISP/KAB_DISP)
+    * Dedup record (prov,kab,nama,kew,dataset)
+    * Detail: tampilkan semua indikator, sembunyikan bobot_coverage & coverage
+    * Agregat: tampilkan semua indikator, tanpa Mean_Real/Mean_Final
 """
 
 import os
@@ -30,11 +30,11 @@ from sklearn.preprocessing import PowerTransformer
 # 1) KONFIGURASI FILE
 # ============================================================
 
-DATA_FILE   = "IPLM_clean_manual_131225.xlsx"
-POP_KAB     = "Data_populasi_Kab_kota.xlsx"
-POP_PROV    = "Data_populasi_propinsi.xlsx"
+DATA_FILE = "IPLM_clean_manual_131225.xlsx"  # sesuaikan jika nama file DM kamu berbeda
+POP_KAB   = "Data_populasi_Kab_kota.xlsx"
+POP_PROV  = "Data_populasi_propinsi.xlsx"
 
-TARGET_COVERAGE = 0.68  # 68% = 100%
+TARGET_COVERAGE = 0.68
 W_KEPATUHAN = 0.30
 W_KINERJA   = 0.70
 
@@ -61,10 +61,7 @@ def get_llm_client():
         _HF_CLIENT = None
         return None
     try:
-        if HF_TOKEN:
-            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME, token=HF_TOKEN)
-        else:
-            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME)
+        _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME, token=HF_TOKEN) if HF_TOKEN else InferenceClient(model=LLM_MODEL_NAME)
         return _HF_CLIENT
     except Exception:
         _HF_CLIENT = None
@@ -77,6 +74,14 @@ def get_llm_client():
 def _canon(s: str) -> str:
     return re.sub(r"[^a-z0-9]+", "", str(s).lower())
 
+def _disp_text(x):
+    """Uppercase + rapihin spasi (biar dropdown tidak dobel)."""
+    if pd.isna(x):
+        return None
+    t = str(x).strip().upper()
+    t = " ".join(t.split())
+    return t
+
 def coerce_num(val):
     if pd.isna(val):
         return np.nan
@@ -138,7 +143,7 @@ def norm_prov_label(s):
     if pd.isna(s):
         return None
     t = str(s).upper()
-    for bad in ["PROVINSI", "PROPINSI", "PROVINS "]:
+    for bad in ["PROVINSI", "PROPINSI"]:
         t = t.replace(bad, "")
     t = " ".join(t.split())
     return re.sub(r"[^A-Z0-9]+", "", t)
@@ -177,7 +182,6 @@ def penalized_mean(row, cols):
     return float(np.mean(vals))
 
 def cap_bobot(cov: float) -> float:
-    # 68% = 1.0 ; kurang -> proporsional; 0 -> 0
     if cov is None or pd.isna(cov) or cov <= 0:
         return 0.0
     return float(min(cov / TARGET_COVERAGE, 1.0))
@@ -188,7 +192,7 @@ def safe_div(num, den):
     return float(num) / float(den)
 
 # ============================================================
-# 3) DEFINISI INDIKATOR IPLM (REAL)
+# 3) INDIKATOR IPLM
 # ============================================================
 
 koleksi_cols = [
@@ -213,7 +217,6 @@ pengelolaan_cols = [
 ]
 all_indicators = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
 
-# DM alias -> kanonik
 alias_map_raw = {
     "j_judul_koleksi_tercetak": "JudulTercetak",
     "j_eksemplar_koleksi_tercetak": "EksemplarTercetak",
@@ -244,7 +247,7 @@ alias_map_raw = {
 alias_map = {_canon(k): v for k, v in alias_map_raw.items()}
 
 # ============================================================
-# 4) LOAD DM + POPULASI (KAB & PROV)
+# 4) LOAD DM + POPULASI
 # ============================================================
 
 DATA_INFO = ""
@@ -268,7 +271,7 @@ try:
     kab_col   = pick_col(df_all_raw, ["kab_kota", "Kab_Kota", "Kab/Kota", "KAB/KOTA", "kabupaten_kota", "kota"])
     kew_col   = pick_col(df_all_raw, ["kewenangan", "jenis_kewenangan", "Kewenangan", "KEWENANGAN"])
     jenis_col = pick_col(df_all_raw, ["jenis_perpustakaan", "JENIS_PERPUSTAKAAN", "Jenis Perpustakaan", "jenis perpustakaan"])
-    nama_col  = pick_col(df_all_raw, ["nama_perpustakaan", "nm_perpustakaan", "nm_instansi_lembaga", "Nama Perpustakaan"])
+    nama_col  = pick_col(df_all_raw, ["nm_perpustakaan","nama_perpustakaan", "nm_instansi_lembaga", "Nama Perpustakaan"])
 
     df_all_raw["KEW_NORM"] = df_all_raw[kew_col].apply(norm_kew) if kew_col else None
 
@@ -283,13 +286,24 @@ try:
     }
     df_all_raw["_dataset"] = df_all_raw[jenis_col].apply(_norm_text).map(val_map_jenis) if jenis_col else None
 
+    # kolom tampilan konsisten (buat dropdown + filter)
+    if prov_col:
+        df_all_raw["PROV_DISP"] = df_all_raw[prov_col].apply(_disp_text)
+    else:
+        df_all_raw["PROV_DISP"] = None
+    if kab_col:
+        df_all_raw["KAB_DISP"] = df_all_raw[kab_col].apply(_disp_text)
+    else:
+        df_all_raw["KAB_DISP"] = None
+
     DATA_INFO = f"✅ DM terbaca: **{DATA_FILE}** | Baris: **{len(df_all_raw)}**"
 except Exception as e:
     df_all_raw = None
     DATA_INFO = f"⚠️ Gagal memuat DM: `{e}`"
 
-# ---- POPULASI KAB/KOTA ----
 POP_INFO = []
+
+# ---- POP KAB ----
 try:
     pk = pd.read_excel(POP_KAB)
     c_prov = pick_col(pk, ["PROVINSI", "Provinsi"])
@@ -302,7 +316,7 @@ try:
     c_pop_sekolah = pick_col(pk, ["jumlah_populasi_sekolah"])
 
     if c_kab is None:
-        raise ValueError("Kolom Kab/Kota tidak ditemukan di file populasi kab/kota.")
+        raise ValueError("Kolom Kab/Kota tidak ditemukan di populasi kab/kota.")
 
     df_pop_kab = pd.DataFrame({
         "Provinsi_Label": pk[c_prov].astype(str).str.strip() if c_prov else None,
@@ -316,7 +330,6 @@ try:
     })
     df_pop_kab["kab_key"] = df_pop_kab["Kab_Kota_Label"].apply(norm_kab_label)
 
-    # fallback populasi bila kolom total tidak ada / kosong
     if df_pop_kab["Pop_Umum"].isna().all():
         df_pop_kab["Pop_Umum"] = df_pop_kab[["Jml_Kecamatan","Jml_DesaKel"]].sum(axis=1, skipna=True)
     if df_pop_kab["Pop_Sekolah"].isna().all():
@@ -327,16 +340,17 @@ except Exception as e:
     df_pop_kab = None
     POP_INFO.append(f"⚠️ Gagal memuat populasi Kab/Kota: `{e}`")
 
-# ---- POPULASI PROVINSI ----
+# ---- POP PROV ----
 try:
     pp = pd.read_excel(POP_PROV)
     c_prov = pick_col(pp, ["Provinsi", "PROVINSI"])
     c_total_pend = pick_col(pp, ["total_pend", "TOTAL_PEND", "total pend"])
-    c_sma = pick_col(pp, ["sma", "sma "])  # ada spasi di file
+    c_sma = pick_col(pp, ["sma", "sma "])
+
     if c_prov is None:
-        raise ValueError("Kolom Provinsi tidak ditemukan di file populasi provinsi.")
+        raise ValueError("Kolom Provinsi tidak ditemukan di populasi provinsi.")
     if c_total_pend is None and c_sma is None:
-        raise ValueError("Kolom total_pend / sma tidak ditemukan di file populasi provinsi.")
+        raise ValueError("Kolom total_pend/sma tidak ditemukan di populasi provinsi.")
 
     df_pop_prov = pd.DataFrame({
         "Provinsi_Label": pp[c_prov].astype(str).str.strip(),
@@ -357,7 +371,7 @@ if POP_INFO:
     DATA_INFO = DATA_INFO + "<br>" + "<br>".join(POP_INFO)
 
 # ============================================================
-# 5) PIPELINE NASIONAL: REALSCORE (YJ + MINMAX)
+# 5) PIPELINE NASIONAL: REALSCORE
 # ============================================================
 
 def prepare_global_iplm(df_src: pd.DataFrame) -> pd.DataFrame:
@@ -381,7 +395,6 @@ def prepare_global_iplm(df_src: pd.DataFrame) -> pd.DataFrame:
     if rename_map:
         df = df.rename(columns=rename_map)
 
-    # numeric coercion
     available = [c for c in all_indicators if c in df.columns]
     for c in available:
         df[c] = df[c].apply(coerce_num)
@@ -410,7 +423,6 @@ def prepare_global_iplm(df_src: pd.DataFrame) -> pd.DataFrame:
 
     df["Indeks_Real_0_100"] = 100 * (W_KEPATUHAN * df["dim_kepatuhan"] + W_KINERJA * df["dim_kinerja"])
 
-    # paksa tidak NaN
     for c in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja","Indeks_Real_0_100"]:
         df[c] = df[c].fillna(0.0)
 
@@ -419,15 +431,10 @@ def prepare_global_iplm(df_src: pd.DataFrame) -> pd.DataFrame:
 df_all_ipml = prepare_global_iplm(df_all_raw) if df_all_raw is not None else None
 
 # ============================================================
-# 6) HITUNG COVERAGE + BOBOT (68%) + FINAL SCORE
+# 6) COVERAGE + BOBOT + FINAL (INTERNAL)
 # ============================================================
 
 def compute_coverage_and_weight(df_filtered: pd.DataFrame, kew_value: str):
-    """
-    Return:
-    - df_out: df_filtered + bobot_coverage + Indeks_Final
-    - verif_df: tabel verifikasi coverage, gap menuju 68%
-    """
     if df_filtered is None or df_filtered.empty:
         return df_filtered, pd.DataFrame()
 
@@ -436,14 +443,12 @@ def compute_coverage_and_weight(df_filtered: pd.DataFrame, kew_value: str):
 
     df["bobot_coverage"] = 1.0
     df["coverage"] = np.nan
-    df["gap_to_68"] = np.nan
 
-    # --- KAB/KOTA ---
+    # KAB/KOTA
     if ("KAB" in kew_norm or "KOTA" in kew_norm) and kab_col and df_pop_kab is not None:
         tmp = df.copy()
-        tmp["kab_key"] = tmp[kab_col].apply(norm_kab_label)
+        tmp["kab_key"] = tmp["KAB_DISP"].apply(norm_kab_label) if "KAB_DISP" in tmp.columns else tmp[kab_col].apply(norm_kab_label)
 
-        # sampel per kab per dataset
         g = tmp.groupby(["kab_key","_dataset"]).size().rename("n_sampel").reset_index()
         g_piv = g.pivot(index="kab_key", columns="_dataset", values="n_sampel").fillna(0)
 
@@ -472,24 +477,27 @@ def compute_coverage_and_weight(df_filtered: pd.DataFrame, kew_value: str):
 
             rows.append({
                 "Kab/Kota": kab_label,
-                "Pop Sekolah (SD+SMP)": pop_sek,
-                "Sampel Sekolah": n_sek,
-                "Coverage Sekolah": cov_sek,
-                "Bobot Sekolah (68%)": bobot_sek,
-                "GAP ke 68% (Sekolah)": gap_sek,
-
-                "Pop Umum (Kec+Desa/Kel)": pop_um,
-                "Sampel Umum": n_um,
-                "Coverage Umum": cov_um,
-                "Bobot Umum (68%)": bobot_um,
-                "GAP ke 68% (Umum)": gap_um,
+                "Pop_Sekolah": pop_sek,
+                "Sampel_Sekolah": n_sek,
+                "Coverage_Sekolah": cov_sek,
+                "Bobot_Sekolah_68": bobot_sek,
+                "GAP_Ke_68_Sekolah": gap_sek,
+
+                "Pop_Umum": pop_um,
+                "Sampel_Umum": n_um,
+                "Coverage_Umum": cov_um,
+                "Bobot_Umum_68": bobot_um,
+                "GAP_Ke_68_Umum": gap_um,
             })
 
         verif_df = pd.DataFrame(rows)
 
-        # map bobot per baris perpustakaan
-        bobot_map_sek = {norm_kab_label(r["Kab/Kota"]): r["Bobot Sekolah (68%)"] for _, r in verif_df.iterrows()}
-        bobot_map_um  = {norm_kab_label(r["Kab/Kota"]): r["Bobot Umum (68%)"]    for _, r in verif_df.iterrows()}
+        bobot_map_sek = {norm_kab_label(r["Kab/Kota"]): r["Bobot_Sekolah_68"] for _, r in verif_df.iterrows()}
+        bobot_map_um  = {norm_kab_label(r["Kab/Kota"]): r["Bobot_Umum_68"]    for _, r in verif_df.iterrows()}
+        cov_map_sek   = {norm_kab_label(r["Kab/Kota"]): r["Coverage_Sekolah"] for _, r in verif_df.iterrows()}
+        cov_map_um    = {norm_kab_label(r["Kab/Kota"]): r["Coverage_Umum"]    for _, r in verif_df.iterrows()}
+
+        df["kab_key"] = df["KAB_DISP"].apply(norm_kab_label) if "KAB_DISP" in df.columns else df[kab_col].apply(norm_kab_label)
 
         def row_weight(r):
             ds = r.get("_dataset", None)
@@ -502,27 +510,22 @@ def compute_coverage_and_weight(df_filtered: pd.DataFrame, kew_value: str):
                 return float(bobot_map_um.get(kk, 0.0))
             return 1.0
 
-        df["kab_key"] = df[kab_col].apply(norm_kab_label)
-        df["bobot_coverage"] = df.apply(row_weight, axis=1)
-
-        # coverage per row (opsional untuk detail)
         def row_cov(r):
             ds = r.get("_dataset", None)
             kk = r.get("kab_key", None)
             if ds == "sekolah":
-                # cari coverage sekolah dari verif_df
-                v = verif_df.loc[verif_df["Kab/Kota"].apply(norm_kab_label)==kk, "Coverage Sekolah"]
-                return float(v.iloc[0]) if len(v) else np.nan
+                return float(cov_map_sek.get(kk, np.nan))
             if ds == "umum":
-                v = verif_df.loc[verif_df["Kab/Kota"].apply(norm_kab_label)==kk, "Coverage Umum"]
-                return float(v.iloc[0]) if len(v) else np.nan
+                return float(cov_map_um.get(kk, np.nan))
             return np.nan
+
+        df["bobot_coverage"] = df.apply(row_weight, axis=1)
         df["coverage"] = df.apply(row_cov, axis=1)
 
-    # --- PROVINSI ---
+    # PROVINSI
     elif ("PROV" in kew_norm) and prov_col and df_pop_prov is not None:
         tmp = df.copy()
-        tmp["prov_key"] = tmp[prov_col].apply(norm_prov_label)
+        tmp["prov_key"] = tmp["PROV_DISP"].apply(norm_prov_label) if "PROV_DISP" in tmp.columns else tmp[prov_col].apply(norm_prov_label)
 
         g = tmp.groupby(["prov_key","_dataset"]).size().rename("n_sampel").reset_index()
         g_piv = g.pivot(index="prov_key", columns="_dataset", values="n_sampel").fillna(0)
@@ -536,7 +539,6 @@ def compute_coverage_and_weight(df_filtered: pd.DataFrame, kew_value: str):
 
             cov_sek = safe_div(n_sek, pop_sek)
             bobot_sek = cap_bobot(cov_sek)
-
             target_sek = (TARGET_COVERAGE * pop_sek) if not pd.isna(pop_sek) else np.nan
             gap_sek = max(target_sek - n_sek, 0) if not pd.isna(target_sek) else np.nan
 
@@ -544,16 +546,19 @@ def compute_coverage_and_weight(df_filtered: pd.DataFrame, kew_value: str):
 
             rows.append({
                 "Provinsi": prov_label,
-                "Pop Sekolah (Total Pend)": pop_sek,
-                "Sampel Sekolah": n_sek,
-                "Coverage Sekolah": cov_sek,
-                "Bobot Sekolah (68%)": bobot_sek,
-                "GAP ke 68% (Sekolah)": gap_sek,
+                "Pop_Sekolah": pop_sek,
+                "Sampel_Sekolah": n_sek,
+                "Coverage_Sekolah": cov_sek,
+                "Bobot_Sekolah_68": bobot_sek,
+                "GAP_Ke_68_Sekolah": gap_sek,
             })
 
         verif_df = pd.DataFrame(rows)
 
-        bobot_map = {norm_prov_label(r["Provinsi"]): r["Bobot Sekolah (68%)"] for _, r in verif_df.iterrows()}
+        bobot_map = {norm_prov_label(r["Provinsi"]): r["Bobot_Sekolah_68"] for _, r in verif_df.iterrows()}
+        cov_map   = {norm_prov_label(r["Provinsi"]): r["Coverage_Sekolah"] for _, r in verif_df.iterrows()}
+
+        df["prov_key"] = df["PROV_DISP"].apply(norm_prov_label) if "PROV_DISP" in df.columns else df[prov_col].apply(norm_prov_label)
 
         def row_weight(r):
             ds = r.get("_dataset", None)
@@ -563,26 +568,22 @@ def compute_coverage_and_weight(df_filtered: pd.DataFrame, kew_value: str):
                 return float(bobot_map.get(r.get("prov_key", None), 0.0))
             return 1.0
 
-        df["prov_key"] = df[prov_col].apply(norm_prov_label)
-        df["bobot_coverage"] = df.apply(row_weight, axis=1)
-
         def row_cov(r):
             if r.get("_dataset", None) != "sekolah":
                 return np.nan
-            v = verif_df.loc[verif_df["Provinsi"].apply(norm_prov_label)==r.get("prov_key", None), "Coverage Sekolah"]
-            return float(v.iloc[0]) if len(v) else np.nan
+            return float(cov_map.get(r.get("prov_key", None), np.nan))
+
+        df["bobot_coverage"] = df.apply(row_weight, axis=1)
         df["coverage"] = df.apply(row_cov, axis=1)
 
     else:
         verif_df = pd.DataFrame()
 
-    # Final score
     df["Indeks_Final_0_100"] = (df["Indeks_Real_0_100"].fillna(0.0) * df["bobot_coverage"].fillna(0.0)).fillna(0.0)
-
     return df, verif_df
 
 # ============================================================
-# 7) BELL CURVE (REAL & FINAL)
+# 7) BELL CURVE
 # ============================================================
 
 def make_bell_figure(df_all: pd.DataFrame, title: str, index_col: str, name_col: str = None, min_points: int = 5) -> go.Figure:
@@ -633,123 +634,62 @@ def make_bell_figure(df_all: pd.DataFrame, title: str, index_col: str, name_col:
     return fig
 
 # ============================================================
-# 8) EXPORT EXCEL + WORD REPORT
+# 8) ANALISIS (RULE / LLM)
 # ============================================================
 
-from docx import Document
-from docx.shared import Inches
-
-# kaleido for plotly image export (optional)
-try:
-    import kaleido  # noqa: F401
-    HAS_KALEIDO = True
-except Exception:
-    HAS_KALEIDO = False
-
-def make_pie_plotly(num, den, title):
-    if not HAS_KALEIDO:
-        return None
-    if den is None or pd.isna(den) or den <= 0:
-        values = [0, 1]
-        labels = ["Terjangkau", "Belum Terjangkau"]
-    else:
-        values = [float(num), max(float(den) - float(num), 0.0)]
-        labels = ["Terjangkau", "Belum Terjangkau"]
-    fig = px.pie(values=values, names=labels, title=title, hole=0.3)
-    tmp = tempfile.mktemp(suffix=".png")
-    try:
-        fig.write_image(tmp, scale=2)
-        return tmp
-    except Exception:
-        return None
-
-def build_analysis_rule(detail_df, agg_df, verif_df, wilayah, kew):
-    mean_real = float(detail_df["Indeks_Real_0_100"].mean()) if "Indeks_Real_0_100" in detail_df.columns else np.nan
-    mean_final = float(detail_df["Indeks_Final_0_100"].mean()) if "Indeks_Final_0_100" in detail_df.columns else np.nan
+def build_analysis_rule(df2, agg_df, verif_df, wilayah, kew):
+    mean_real = float(df2["Indeks_Real_0_100"].mean()) if "Indeks_Real_0_100" in df2.columns else np.nan
+    mean_final = float(df2["Indeks_Final_0_100"].mean()) if "Indeks_Final_0_100" in df2.columns else np.nan
     lines = []
     lines.append("## Analisis Otomatis (Rule-based)")
     lines.append(f"- Wilayah: {wilayah} | Kewenangan: {kew}")
-    lines.append(f"- Jumlah unit sampel: {len(detail_df)}")
+    lines.append(f"- Jumlah unit sampel (setelah dedup): {len(df2)}")
     if not pd.isna(mean_real):
         lines.append(f"- Rata-rata Indeks Real: {mean_real:.2f}")
     if not pd.isna(mean_final):
-        lines.append(f"- Rata-rata Indeks Final (setelah penalti 68%): {mean_final:.2f}")
-
+        lines.append(f"- Rata-rata Indeks Final (penalti 68%): {mean_final:.2f}")
     if verif_df is not None and not verif_df.empty:
-        lines.append("")
-        lines.append("### Catatan Coverage (68% = bobot 1)")
-        # ambil ringkas: rata-rata coverage & gap
-        cand_cov = [c for c in verif_df.columns if "Coverage" in c]
-        if cand_cov:
-            for c in cand_cov:
-                v = verif_df[c].dropna()
-                if len(v):
-                    lines.append(f"- Rata-rata {c}: {(100*v.mean()):.2f}%")
-        cand_gap = [c for c in verif_df.columns if "GAP" in c]
-        if cand_gap:
-            for c in cand_gap:
-                v = verif_df[c].dropna()
-                if len(v):
-                    lines.append(f"- Total {c}: {v.sum():.0f} unit")
-
+        gap_cols = [c for c in verif_df.columns if "GAP" in c]
+        if gap_cols:
+            g0 = gap_cols[0]
+            lines.append(f"- Total GAP (contoh kolom {g0}): {verif_df[g0].dropna().sum():.0f} unit")
     lines.append("")
-    lines.append("### Rekomendasi Program (ringkas)")
-    lines.append(
-        "Fokus penguatan diarahkan pada konsolidasi cakupan sampel agar mendekati standar 68% sehingga pembobotan tidak menurunkan skor final, "
-        "serta perbaikan indikator layanan dan pengelolaan yang mendorong pemanfaatan. "
-        "Prioritas implementasi dapat dilakukan melalui penguatan pembinaan berbasis wilayah dengan target unit yang masih memiliki GAP tinggi."
-    )
+    lines.append("Rekomendasi: fokus menutup GAP unit menuju 68% pada wilayah dengan kekurangan terbesar, sehingga pembobotan tidak menurunkan skor final.")
     return "\n".join(lines)
 
-def build_analysis_llm(detail_df, agg_df, verif_df, wilayah, kew):
-    # fallback rule-based jika LLM gagal
-    rb = build_analysis_rule(detail_df, agg_df, verif_df, wilayah, kew)
+def build_analysis_llm(df2, agg_df, verif_df, wilayah, kew):
+    rb = build_analysis_rule(df2, agg_df, verif_df, wilayah, kew)
     if not USE_LLM:
         return rb
     client = get_llm_client()
     if client is None:
         return "⚠️ LLM tidak tersedia, memakai rule-based.\n\n" + rb
 
-    # context singkat
-    mean_real = float(detail_df["Indeks_Real_0_100"].mean()) if "Indeks_Real_0_100" in detail_df.columns else np.nan
-    mean_final = float(detail_df["Indeks_Final_0_100"].mean()) if "Indeks_Final_0_100" in detail_df.columns else np.nan
-
-    ctx = [
-        f"Wilayah: {wilayah}",
-        f"Kewenangan: {kew}",
-        f"Jumlah unit sampel: {len(detail_df)}",
-        f"Rata-rata Indeks Real: {mean_real:.2f}" if not pd.isna(mean_real) else "",
-        f"Rata-rata Indeks Final (penalti 68%): {mean_final:.2f}" if not pd.isna(mean_final) else "",
-    ]
+    mean_real = float(df2["Indeks_Real_0_100"].mean())
+    mean_final = float(df2["Indeks_Final_0_100"].mean())
+
+    ctx = [f"Wilayah: {wilayah}", f"Kew: {kew}", f"Unit: {len(df2)}", f"Mean Real: {mean_real:.2f}", f"Mean Final: {mean_final:.2f}"]
     if verif_df is not None and not verif_df.empty:
-        # ambil 5 baris gap terbesar bila ada
         gap_cols = [c for c in verif_df.columns if "GAP" in c]
         if gap_cols:
             g0 = gap_cols[0]
-            vv = verif_df[[c for c in verif_df.columns if c in gap_cols or c in ["Kab/Kota","Provinsi"]]].copy()
-            vv = vv.sort_values(g0, ascending=False).head(5)
-            ctx.append("Contoh GAP terbesar (top 5):")
+            vv = verif_df.sort_values(g0, ascending=False).head(5)
+            ctx.append("Top 5 GAP:")
             ctx.append(vv.to_string(index=False))
 
-    system_prompt = (
-        "Anda adalah analis kebijakan perpustakaan dan literasi di Indonesia. "
-        "Tugas Anda menyusun analisis ringkas, komunikatif, dan berbasis data."
-    )
+    system_prompt = "Anda adalah analis kebijakan perpustakaan dan literasi di Indonesia."
     user_prompt = f"""
-DATA RINGKAS:
-{chr(10).join([x for x in ctx if x])}
-
-TULISKAN:
-1) Gambaran umum (1 paragraf).
-2) Dampak penalti coverage 68% terhadap skor final (1 paragraf).
-3) Rekomendasi prioritas 12–24 bulan (2 paragraf), fokus menutup GAP unit.
-Gunakan bahasa Indonesia formal, kalimat efektif, tanpa label "rendah/sedang/tinggi".
+DATA:
+{chr(10).join(ctx)}
+
+Tulis analisis ringkas (3–5 paragraf) tentang dampak penalti coverage 68% dan rekomendasi prioritas menutup GAP.
+Bahasa Indonesia formal, tanpa label 'rendah/sedang/tinggi'.
 """
     try:
         resp = client.chat_completion(
             model=LLM_MODEL_NAME,
             messages=[{"role":"system","content":system_prompt},{"role":"user","content":user_prompt}],
-            max_tokens=900,
+            max_tokens=700,
             temperature=0.25,
             top_p=0.9,
         )
@@ -758,18 +698,46 @@ Gunakan bahasa Indonesia formal, kalimat efektif, tanpa label "rendah/sedang/tin
     except Exception as e:
         return f"⚠️ Gagal memanggil LLM ({repr(e)}), memakai rule-based.\n\n{rb}"
 
-def generate_word_report(detail_df, agg_df, verif_df, wilayah, kew, analysis_text):
+# ============================================================
+# 9) WORD REPORT (opsional pie)
+# ============================================================
+
+from docx import Document
+from docx.shared import Inches
+
+try:
+    import kaleido  # noqa
+    HAS_KALEIDO = True
+except Exception:
+    HAS_KALEIDO = False
+
+def make_pie_plotly(num, den, title):
+    if not HAS_KALEIDO:
+        return None
+    if den is None or pd.isna(den) or den <= 0:
+        values = [0, 1]
+        labels = ["Terjangkau", "Belum Terjangkau"]
+    else:
+        values = [float(num), max(float(den) - float(num), 0.0)]
+        labels = ["Terjangkau", "Belum Terjangkau"]
+    fig = px.pie(values=values, names=labels, title=title, hole=0.3)
+    tmp = tempfile.mktemp(suffix=".png")
+    try:
+        fig.write_image(tmp, scale=2)
+        return tmp
+    except Exception:
+        return None
+
+def generate_word_report(df2, agg_df, verif_df, wilayah, kew, analysis_text):
     doc = Document()
     doc.add_heading(f"Laporan IPLM – {wilayah}", level=1)
 
-    doc.add_heading("Ringkasan Indeks", level=2)
-    doc.add_paragraph(f"- Jumlah unit sampel: {len(detail_df)}")
-    if "Indeks_Real_0_100" in detail_df.columns:
-        doc.add_paragraph(f"- Rata-rata Indeks Real: {detail_df['Indeks_Real_0_100'].mean():.2f}")
-    if "Indeks_Final_0_100" in detail_df.columns:
-        doc.add_paragraph(f"- Rata-rata Indeks Final (penalti 68%): {detail_df['Indeks_Final_0_100'].mean():.2f}")
+    doc.add_heading("Ringkasan", level=2)
+    doc.add_paragraph(f"- Unit (setelah dedup): {len(df2)}")
+    doc.add_paragraph(f"- Rata-rata Indeks Real: {df2['Indeks_Real_0_100'].mean():.2f}")
+    doc.add_paragraph(f"- Rata-rata Indeks Final: {df2['Indeks_Final_0_100'].mean():.2f}")
 
-    doc.add_heading("Agregat per Jenis Perpustakaan", level=2)
+    doc.add_heading("Agregat per Jenis", level=2)
     if agg_df is not None and not agg_df.empty:
         table = doc.add_table(rows=1, cols=len(agg_df.columns))
         hdr = table.rows[0].cells
@@ -780,44 +748,21 @@ def generate_word_report(detail_df, agg_df, verif_df, wilayah, kew, analysis_tex
             for i, c in enumerate(agg_df.columns):
                 r[i].text = str(row[c])
 
-    doc.add_heading("Coverage / Cakupan (68% = bobot 1)", level=2)
+    doc.add_heading("Verifikasi Coverage & GAP (68%)", level=2)
     if verif_df is None or verif_df.empty:
         doc.add_paragraph("Tidak ada tabel verifikasi coverage untuk filter ini.")
     else:
-        # Pie chart ringkas: total sekolah / total populasi sekolah (kalau tersedia)
         if HAS_KALEIDO:
-            if "Kab/Kota" in verif_df.columns:
-                # total sekolah
-                if "Pop Sekolah (SD+SMP)" in verif_df.columns and "Sampel Sekolah" in verif_df.columns:
-                    img = make_pie_plotly(
-                        verif_df["Sampel Sekolah"].sum(),
-                        verif_df["Pop Sekolah (SD+SMP)"].sum(),
-                        "Coverage Sekolah (Total)"
-                    )
-                    if img:
-                        doc.add_picture(img, width=Inches(4))
-                if "Pop Umum (Kec+Desa/Kel)" in verif_df.columns and "Sampel Umum" in verif_df.columns:
-                    img = make_pie_plotly(
-                        verif_df["Sampel Umum"].sum(),
-                        verif_df["Pop Umum (Kec+Desa/Kel)"].sum(),
-                        "Coverage Umum (Total)"
-                    )
-                    if img:
-                        doc.add_picture(img, width=Inches(4))
-            elif "Provinsi" in verif_df.columns:
-                if "Pop Sekolah (Total Pend)" in verif_df.columns and "Sampel Sekolah" in verif_df.columns:
-                    img = make_pie_plotly(
-                        verif_df["Sampel Sekolah"].sum(),
-                        verif_df["Pop Sekolah (Total Pend)"].sum(),
-                        "Coverage Sekolah Provinsi (Total)"
-                    )
-                    if img:
-                        doc.add_picture(img, width=Inches(4))
+            # ringkas total sekolah & umum bila ada
+            if "Pop_Sekolah" in verif_df.columns and "Sampel_Sekolah" in verif_df.columns:
+                img = make_pie_plotly(verif_df["Sampel_Sekolah"].sum(), verif_df["Pop_Sekolah"].sum(), "Coverage Sekolah (Total)")
+                if img: doc.add_picture(img, width=Inches(4))
+            if "Pop_Umum" in verif_df.columns and "Sampel_Umum" in verif_df.columns:
+                img = make_pie_plotly(verif_df["Sampel_Umum"].sum(), verif_df["Pop_Umum"].sum(), "Coverage Umum (Total)")
+                if img: doc.add_picture(img, width=Inches(4))
         else:
             doc.add_paragraph("Pie chart tidak dibuat karena 'kaleido' tidak tersedia.")
 
-        # tabel verifikasi
-        doc.add_paragraph("Tabel Verifikasi Coverage:")
         vtab = doc.add_table(rows=1, cols=len(verif_df.columns))
         vh = vtab.rows[0].cells
         for i, c in enumerate(verif_df.columns):
@@ -827,7 +772,7 @@ def generate_word_report(detail_df, agg_df, verif_df, wilayah, kew, analysis_tex
             for i, c in enumerate(verif_df.columns):
                 rr[i].text = str(row[c])
 
-    doc.add_heading("Analisis Naratif Otomatis", level=2)
+    doc.add_heading("Analisis Naratif", level=2)
     for p in analysis_text.split("\n"):
         if p.strip():
             doc.add_paragraph(p)
@@ -837,79 +782,110 @@ def generate_word_report(detail_df, agg_df, verif_df, wilayah, kew, analysis_tex
     return out
 
 # ============================================================
-# 9) CORE PIPELINE PER FILTER: AGG + DETAIL + EXPORT + BELL
+# 10) AGREGAT (TANPA Mean_Real/Mean_Final) + FULL INDIKATOR
 # ============================================================
 
-def build_agg(detail_df: pd.DataFrame) -> pd.DataFrame:
-    expected_ds = ["sekolah", "umum", "khusus"]
+def build_agg_full(df2: pd.DataFrame) -> pd.DataFrame:
+    """
+    Output:
+    - Jenis, Jumlah
+    - Rata2 semua indikator raw yang tersedia
+    - Rata2 sub/dim
+    - Rata2_Indeks_Real_0_100, Rata2_Indeks_Final_0_100
+    """
     label_map = {"sekolah":"Perpustakaan Sekolah","umum":"Perpustakaan Umum","khusus":"Perpustakaan Khusus"}
+    out_rows = []
+
+    available_ind = [c for c in all_indicators if c in df2.columns]
+
+    def summarize(sub, jenis_label):
+        row = {"Jenis": jenis_label, "Jumlah": int(len(sub))}
+        # indikator raw
+        for c in available_ind:
+            row[f"Rata2_{c}"] = float(sub[c].mean(skipna=True)) if len(sub) else 0.0
+        # sub/dim
+        for c in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja"]:
+            if c in sub.columns:
+                row[f"Rata2_{c}"] = float(sub[c].mean(skipna=True)) if len(sub) else 0.0
+        # indeks
+        row["Rata2_Indeks_Real_0_100"] = float(sub["Indeks_Real_0_100"].mean(skipna=True)) if "Indeks_Real_0_100" in sub.columns and len(sub) else 0.0
+        row["Rata2_Indeks_Final_0_100"] = float(sub["Indeks_Final_0_100"].mean(skipna=True)) if "Indeks_Final_0_100" in sub.columns and len(sub) else 0.0
+        return row
+
+    for ds in ["sekolah","umum","khusus"]:
+        sub = df2[df2["_dataset"] == ds].copy() if "_dataset" in df2.columns else df2.iloc[0:0]
+        out_rows.append(summarize(sub, label_map.get(ds, ds)))
+
+    out_rows.append(summarize(df2, "Rata-rata keseluruhan"))
+    return pd.DataFrame(out_rows).round(4)
 
-    rows = []
-    for ds in expected_ds:
-        d = detail_df[detail_df["_dataset"] == ds].copy() if "_dataset" in detail_df.columns else pd.DataFrame()
-        if d.empty:
-            rows.append({"Jenis": label_map.get(ds, ds), "Jumlah": 0, "Mean_Real": 0.0, "Mean_Final": 0.0})
-        else:
-            rows.append({
-                "Jenis": label_map.get(ds, ds),
-                "Jumlah": int(len(d)),
-                "Mean_Real": float(d["Indeks_Real_0_100"].mean()) if "Indeks_Real_0_100" in d.columns else 0.0,
-                "Mean_Final": float(d["Indeks_Final_0_100"].mean()) if "Indeks_Final_0_100" in d.columns else 0.0,
-            })
-    # total
-    rows.append({
-        "Jenis":"Rata-rata keseluruhan",
-        "Jumlah": int(len(detail_df)),
-        "Mean_Real": float(detail_df["Indeks_Real_0_100"].mean()) if "Indeks_Real_0_100" in detail_df.columns else 0.0,
-        "Mean_Final": float(detail_df["Indeks_Final_0_100"].mean()) if "Indeks_Final_0_100" in detail_df.columns else 0.0,
-    })
-    return pd.DataFrame(rows).round(3)
+# ============================================================
+# 11) PIPELINE FILTERED: DEDUP + DETAIL FULL INDIKATOR
+# ============================================================
 
 def run_pipeline_filtered(prov_value, kab_value, kew_value):
     if df_all_ipml is None or df_all_ipml.empty:
         return (pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
                 None, None, None, None,
-                None, None, None, None,
+                None, None, None, None, None,
                 "Data DM belum siap / gagal diproses.", "Tidak ada analisis.")
 
     df = df_all_ipml.copy()
 
-    # filter
-    if prov_col and prov_value and prov_value != "(Semua)":
-        df = df[df[prov_col].astype(str).str.strip() == prov_value]
-    if kab_col and kab_value and kab_value != "(Semua)":
-        df = df[df[kab_col].astype(str).str.strip() == kab_value]
+    # FILTER pakai PROV_DISP/KAB_DISP agar stabil & tidak dobel
+    if "PROV_DISP" in df.columns and prov_value and prov_value != "(Semua)":
+        df = df[df["PROV_DISP"] == prov_value]
+    if "KAB_DISP" in df.columns and kab_value and kab_value != "(Semua)":
+        df = df[df["KAB_DISP"] == kab_value]
     if kew_value and kew_value != "(Semua)":
         df = df[df["KEW_NORM"] == kew_value]
 
     if df.empty:
         return (pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
                 None, None, None, None,
-                None, None, None, None,
+                None, None, None, None, None,
                 "Tidak ada data untuk kombinasi filter.", "Tidak ada analisis.")
 
     wilayah = kab_value if kab_value and kab_value != "(Semua)" else (prov_value if prov_value and prov_value != "(Semua)" else "NASIONAL")
     kew = kew_value if kew_value and kew_value != "(Semua)" else "SEMUA"
 
-    # coverage + bobot + final
+    # Coverage + bobot + final
     df2, verif_df = compute_coverage_and_weight(df, kew_value)
 
-    # detail view
-    base_cols = []
-    if prov_col and prov_col in df2.columns: base_cols.append(prov_col)
-    if kab_col and kab_col in df2.columns: base_cols.append(kab_col)
-    if nama_col and nama_col in df2.columns: base_cols.append(nama_col)
-    base_cols += ["KEW_NORM","_dataset","dim_kepatuhan","dim_kinerja","Indeks_Real_0_100","bobot_coverage","Indeks_Final_0_100","coverage"]
-    detail_cols = [c for c in base_cols if c in df2.columns]
-    detail_df = df2[detail_cols].copy().round(4)
+    # DEDUP: prov,kab,nama,kew,dataset
+    # (ini yang bikin tidak dobel di detail & agregat)
+    kcols = []
+    for c in ["PROV_DISP","KAB_DISP","KEW_NORM","_dataset"]:
+        if c in df2.columns:
+            kcols.append(c)
+    if nama_col and nama_col in df2.columns:
+        kcols.append(nama_col)
+
+    if kcols:
+        df2 = df2.drop_duplicates(subset=kcols, keep="first").copy()
+
+    # AGREGAT (FULL INDIKATOR) — tanpa Mean_*
+    agg_df = build_agg_full(df2)
+
+    # DETAIL (FULL INDIKATOR) — sembunyikan bobot_coverage & coverage
+    available_ind = [c for c in all_indicators if c in df2.columns]
 
-    # agg
-    agg_df = build_agg(df2)
+    base_cols = ["PROV_DISP","KAB_DISP"]
+    base_cols = [c for c in base_cols if c in df2.columns]
+    if nama_col and nama_col in df2.columns:
+        base_cols.append(nama_col)
+
+    base_cols += ["KEW_NORM","_dataset",
+                  "sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan",
+                  "dim_kepatuhan","dim_kinerja",
+                  "Indeks_Real_0_100","Indeks_Final_0_100"]
+
+    detail_cols = [c for c in base_cols if c in df2.columns] + available_ind
+    detail_df = df2[detail_cols].copy().round(4)
 
-    # export excel
+    # EXPORT
     tmpdir = tempfile.mkdtemp()
     slug = slugify(wilayah) + "_" + slugify(kew)
-
     agg_path = os.path.join(tmpdir, f"IPLM_Agregat_{slug}.xlsx")
     detail_path = os.path.join(tmpdir, f"IPLM_Detail_{slug}.xlsx")
     raw_path = os.path.join(tmpdir, f"IPLM_Raw_{slug}.xlsx")
@@ -918,23 +894,20 @@ def run_pipeline_filtered(prov_value, kab_value, kew_value):
     detail_df.to_excel(detail_path, index=False)
     df2.to_excel(raw_path, index=False)
 
-    # bells
-    name_for_hover = nama_col if (nama_col and nama_col in df2.columns) else None
-
-    fig_real_all = make_bell_figure(df2, "Bell Curve — Indeks REAL (Semua)", "Indeks_Real_0_100", name_col=name_for_hover)
-    fig_final_all = make_bell_figure(df2, "Bell Curve — Indeks FINAL (Penalti 68%) (Semua)", "Indeks_Final_0_100", name_col=name_for_hover)
+    # BELL
+    hover_name = nama_col if (nama_col and nama_col in df2.columns) else None
+    fig_real_all  = make_bell_figure(df2, "Bell Curve — Indeks REAL (Semua)", "Indeks_Real_0_100", name_col=hover_name)
+    fig_final_all = make_bell_figure(df2, "Bell Curve — Indeks FINAL (Semua)", "Indeks_Final_0_100", name_col=hover_name)
 
-    fig_final_sek = make_bell_figure(df2[df2["_dataset"]=="sekolah"], "FINAL — Sekolah", "Indeks_Final_0_100", name_col=name_for_hover, min_points=3)
-    fig_final_um  = make_bell_figure(df2[df2["_dataset"]=="umum"], "FINAL — Umum", "Indeks_Final_0_100", name_col=name_for_hover, min_points=3)
-    fig_final_kh  = make_bell_figure(df2[df2["_dataset"]=="khusus"], "FINAL — Khusus", "Indeks_Final_0_100", name_col=name_for_hover, min_points=3)
+    fig_final_sek = make_bell_figure(df2[df2["_dataset"]=="sekolah"], "FINAL — Sekolah", "Indeks_Final_0_100", name_col=hover_name, min_points=3)
+    fig_final_um  = make_bell_figure(df2[df2["_dataset"]=="umum"], "FINAL — Umum", "Indeks_Final_0_100", name_col=hover_name, min_points=3)
+    fig_final_kh  = make_bell_figure(df2[df2["_dataset"]=="khusus"], "FINAL — Khusus", "Indeks_Final_0_100", name_col=hover_name, min_points=3)
 
-    # analisis
-    analysis_text = build_analysis_llm(detail_df=df2, agg_df=agg_df, verif_df=verif_df, wilayah=wilayah, kew=kew_value)
+    # Analisis + Word
+    analysis_text = build_analysis_llm(df2=df2, agg_df=agg_df, verif_df=verif_df, wilayah=wilayah, kew=kew_value)
+    word_path = generate_word_report(df2, agg_df, verif_df, wilayah, kew_value, analysis_text)
 
-    # word report
-    word_path = generate_word_report(detail_df=df2, agg_df=agg_df, verif_df=verif_df, wilayah=wilayah, kew=kew_value, analysis_text=analysis_text)
-
-    msg = f"✅ Selesai. Unit: {len(df2)} | Wilayah: {wilayah} | Kew: {kew_value} | Mean Final: {df2['Indeks_Final_0_100'].mean():.2f}"
+    msg = f"✅ Selesai. Unit (dedup): {len(df2)} | Wilayah: {wilayah} | Kew: {kew_value} | Mean Final: {df2['Indeks_Final_0_100'].mean():.2f}"
 
     return (agg_df, detail_df, verif_df,
             agg_path, detail_path, raw_path, word_path,
@@ -942,32 +915,31 @@ def run_pipeline_filtered(prov_value, kab_value, kew_value):
             msg, analysis_text)
 
 # ============================================================
-# 10) UI GRADIO
+# 12) DROPDOWN CHOICES (NO DUPLICATE)
 # ============================================================
 
 def all_prov_choices():
-    if df_all_raw is None or prov_col is None:
+    if df_all_raw is None or "PROV_DISP" not in df_all_raw.columns:
         return ["(Semua)"]
-    s = df_all_raw[prov_col].dropna().astype(str).str.strip()
-    vals = sorted([o for o in s.unique() if o != ""])
+    vals = df_all_raw["PROV_DISP"].dropna()
+    vals = sorted(list(dict.fromkeys([v for v in vals.tolist() if str(v).strip() != ""])))
     return ["(Semua)"] + vals
 
 def get_kab_choices_for_prov(prov_value):
-    if df_all_raw is None or kab_col is None:
+    if df_all_raw is None or "KAB_DISP" not in df_all_raw.columns:
         return ["(Semua)"]
-    if prov_value is None or prov_value == "(Semua)" or prov_col is None:
-        s = df_all_raw[kab_col].dropna().astype(str).str.strip()
-    else:
-        m = df_all_raw[prov_col].astype(str).str.strip() == prov_value
-        s = df_all_raw.loc[m, kab_col].dropna().astype(str).str.strip()
-    vals = sorted([x for x in s.unique() if x != ""])
+    tmp = df_all_raw.copy()
+    if prov_value and prov_value != "(Semua)" and "PROV_DISP" in tmp.columns:
+        tmp = tmp[tmp["PROV_DISP"] == prov_value]
+    vals = tmp["KAB_DISP"].dropna()
+    vals = sorted(list(dict.fromkeys([v for v in vals.tolist() if str(v).strip() != ""])))
     return ["(Semua)"] + vals
 
 def all_kew_choices():
-    if df_all_raw is None:
+    if df_all_raw is None or "KEW_NORM" not in df_all_raw.columns:
         return ["(Semua)"]
-    s = df_all_raw["KEW_NORM"].dropna().astype(str).str.strip()
-    vals = sorted([o for o in s.unique() if o != ""])
+    vals = df_all_raw["KEW_NORM"].dropna().astype(str).str.strip()
+    vals = sorted(list(dict.fromkeys([v for v in vals.tolist() if v != ""])))
     return ["(Semua)"] + (vals if vals else ["KAB/KOTA","PROVINSI"])
 
 prov_choices = all_prov_choices()
@@ -979,16 +951,20 @@ def on_prov_change(prov_value):
     new_choices = get_kab_choices_for_prov(prov_value)
     return gr.update(choices=new_choices, value="(Semua)")
 
+# ============================================================
+# 13) UI
+# ============================================================
+
 with gr.Blocks() as demo:
     gr.Markdown(
         f"""
-# IPLM 2025 — FULL (RealScore + Penalti Coverage 68% + Verifikasi + Export + Word + Analisis)
+# IPLM 2025 — FULL (DEDUP + FULL INDICATORS)
 **Aturan penalti**: 68% coverage dianggap 100% (bobot=1). Jika kurang, bobot = coverage/0.68.
 
 **Sumber data**:
 - DM: `{DATA_FILE}`
-- Populasi Kab/Kota: `{POP_KAB}`
-- Populasi Provinsi: `{POP_PROV}`
+- Pop Kab/Kota: `{POP_KAB}`
+- Pop Provinsi: `{POP_PROV}`
 
 {DATA_INFO}
 """
@@ -1004,13 +980,13 @@ with gr.Blocks() as demo:
     run_btn = gr.Button("Jalankan Perhitungan")
     msg_out = gr.Markdown()
 
-    gr.Markdown("## Agregat (Mean Real & Mean Final) per Jenis")
+    gr.Markdown("## Agregat (FULL indikator, tanpa kolom Mean_*)")
     agg_df_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Detail (Real, Coverage, Bobot, Final)")
+    gr.Markdown("## Detail (FULL indikator) — tanpa bobot_coverage & coverage")
     detail_df_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Verifikasi Coverage + GAP menuju 68%")
+    gr.Markdown("## Verifikasi Coverage & GAP menuju 68%")
     verif_df_out = gr.DataFrame(interactive=False)
 
     gr.Markdown("## Bell Curve — REAL (Semua)")
@@ -1031,8 +1007,8 @@ with gr.Blocks() as demo:
     with gr.Row():
         agg_file_out    = gr.File(label="Download Agregat (.xlsx)")
         detail_file_out = gr.File(label="Download Detail (.xlsx)")
-        raw_file_out    = gr.File(label="Download Raw Subset (.xlsx)")
-        word_file_out   = gr.File(label="Download Laporan Word (.docx)")
+        raw_file_out    = gr.File(label="Download Raw (.xlsx)")
+        word_file_out   = gr.File(label="Download Word (.docx)")
 
     run_btn.click(
         fn=run_pipeline_filtered,