Update app.py

app.py

@@ -1,14 +1,20 @@
 # -*- coding: utf-8 -*-
 """
-app.py — IPLM 2025 (RINGKAS OUTPUT: SUBDIM+DIM+FINAL SAJA + BELL CURVE FINAL)
-- Nasional: Yeo-Johnson + MinMax sekali nasional
-- RealScore dihitung internal
-- FinalScore = RealScore * bobot_coverage_68 (internal)
-- OUTPUT UI:
-  * Agregat: sub-dimensi + dimensi + Rata2_Indeks_Final_0_100
-  * Detail : sub-dimensi + dimensi + Indeks_Final_0_100
-  * Verifikasi: coverage/bobot dalam % integer, GAP integer (tanpa koma)
-  * Bell curve FINAL: all + per jenis
+app.py — IPLM 2025 (FINAL)
+- Pipeline nasional: Yeo–Johnson (nasional) + MinMax (nasional)
+- Sub-dimensi: Koleksi, SDM, Pelayanan, Pengelolaan
+- Dimensi: Kepatuhan (Koleksi+SDM), Kinerja (Pelayanan+Pengelolaan)
+- Indeks Real (0–100) -> Indeks Final (0–100) dengan sanksi coverage 68%
+  * Sekolah & Umum: kena sanksi 68% (68% dianggap 100%)
+  * Khusus: tidak kena sanksi (bobot=1) karena populasi pembanding belum baku
+- Sumber populasi:
+  * Kab/Kota: Data_populasi_Kab_kota.xlsx
+  * Provinsi: Data_populasi_propinsi.xlsx
+- Output:
+  * Tabel agregat: sub/dim + Indeks FINAL (integer)
+  * Tabel detail: sub/dim + Indeks FINAL (integer)
+  * Bell curve: semua + per jenis (pakai Indeks FINAL)
+  * Download: agregat/detail/raw + Word (LLM)
 """
 
 import os
@@ -22,30 +28,104 @@ import pandas as pd
 import plotly.graph_objects as go
 from sklearn.preprocessing import PowerTransformer
 
+# Word + LLM
+from docx import Document
+from huggingface_hub import InferenceClient
+
+
 # ============================================================
 # 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 = "DM_001.xlsx"
 
-TARGET_COVERAGE = 0.68
+POP_KAB_FILE  = "Data_populasi_Kab_kota.xlsx"
+POP_PROV_FILE = "Data_populasi_propinsi.xlsx"
+
+# Bobot indeks
 W_KEPATUHAN = 0.30
 W_KINERJA   = 0.70
 
+# Target coverage: 68% dianggap 100%
+TARGET_COVERAGE = 0.68
+
+# LLM
+USE_LLM = True
+LLM_MODEL_NAME = "meta-llama/Meta-Llama-3-8B-Instruct"
+HF_TOKEN = (
+    os.getenv("HF_SECRET")
+    or os.getenv("HF_TOKEN")
+    or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    or os.getenv("HF_API_TOKEN")
+)
+
+_HF_CLIENT = None
+
+
 # ============================================================
-# 2) UTIL
+# 2) KELOMPOK INDIKATOR (untuk pipeline real-score)
+# ============================================================
+
+koleksi_cols = [
+    "JudulTercetak","EksemplarTercetak","JudulElektronik","EksemplarElektronik",
+    "TambahJudulTercetak","TambahEksemplarTercetak",
+    "TambahJudulElektronik","TambahEksemplarElektronik",
+    "KomitmenAnggaranKoleksi"
+]
+sdm_cols = [
+    "TenagaKualifikasiIlmuPerpustakaan",
+    "TenagaFungsionalProfesional",
+    "TenagaPKB",
+    "AnggaranTenaga"
+]
+pelayanan_cols = [
+    "PesertaBudayaBaca","PemustakaLuringDaring","PemustakaFasilitasTIK",
+    "PemanfaatanJudulTercetak","PemanfaatanEksemplarTercetak",
+    "PemanfaatanJudulElektronik","PemanfaatanEksemplarElektronik"
+]
+pengelolaan_cols = [
+    "KegiatanBudayaBaca","KegiatanKerjasama","VariasiLayanan","Kebijakan","AnggaranLayanan"
+]
+all_indicators = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
+
+# Alias mapping dari DM (raw) -> canonical indikator
+alias_map_raw = {
+    "j_judul_koleksi_tercetak": "JudulTercetak",
+    "j_eksemplar_koleksi_tercetak": "EksemplarTercetak",
+    "j_judul_koleksi_digital": "JudulElektronik",
+    "j_eksemplar_koleksi_digital": "EksemplarElektronik",
+    "tambah_judul_koleksi_tercetak": "TambahJudulTercetak",
+    "tambah_eksemplar_koleksi_tercetak": "TambahEksemplarTercetak",
+    "tambah_judul_koleksi_digital": "TambahJudulElektronik",
+    "tambah_eksemplar_koleksi_digital": "TambahEksemplarElektronik",
+    "j_anggaran_koleksi": "KomitmenAnggaranKoleksi",
+    "j_tenaga_ilmu_perpus": "TenagaKualifikasiIlmuPerpustakaan",
+    "j_tenaga_nonilmu_perpus": "TenagaFungsionalProfesional",
+    "j_tenaga_pkb": "TenagaPKB",
+    "j_anggaran_diklat_perpus": "AnggaranTenaga",
+    "j_peserta_budaya_baca": "PesertaBudayaBaca",
+    "j_pemustaka_luring_daring": "PemustakaLuringDaring",
+    "j_pemustaka_fasilitas_tik": "PemustakaFasilitasTIK",
+    "j_judul_koleksi_tercetak_termanfaat": "PemanfaatanJudulTercetak",
+    "j_eksemplar_koleksi_tercetak_termanfaat": "PemanfaatanEksemplarTercetak",
+    "j_judul_koleksi_digital_termanfaat": "PemanfaatanJudulElektronik",
+    "j_eksemplar_koleksi_digital_termanfaat": "PemanfaatanEksemplarElektronik",
+    "j_kegiatan_budaya_baca_peningkatan_literasi": "KegiatanBudayaBaca",
+    "j_kerjasama_pengembangan_perpus": "KegiatanKerjasama",
+    "j_variasi_layanan": "VariasiLayanan",
+    "j_kebijakan_prosedur_pelayanan": "Kebijakan",
+    "j_anggaran_peningkatan_pelayanan": "AnggaranLayanan",
+}
+# ============================================================
+# 3) UTIL
 # ============================================================
 
 def _canon(s: str) -> str:
     return re.sub(r"[^a-z0-9]+", "", str(s).lower())
 
-def _disp_text(x):
-    if pd.isna(x):
-        return None
-    t = str(x).strip().upper()
-    return " ".join(t.split())
+
+alias_map = {_canon(k): v for k, v in alias_map_raw.items()}
+
 
 def pick_col(df, candidates):
     for c in candidates:
@@ -58,6 +138,7 @@ def pick_col(df, candidates):
             return can_map[k]
     return None
 
+
 def coerce_num(val):
     if pd.isna(val):
         return np.nan
@@ -79,6 +160,7 @@ def coerce_num(val):
     except Exception:
         return np.nan
 
+
 def minmax_norm(s: pd.Series) -> pd.Series:
     x = s.astype(float)
     mn, mx = x.min(skipna=True), x.max(skipna=True)
@@ -86,6 +168,21 @@ def minmax_norm(s: pd.Series) -> pd.Series:
         return pd.Series(0.0, index=s.index)
     return (x - mn) / (mx - mn)
 
+
+def penalized_mean(row, cols):
+    vals = []
+    for c in cols:
+        cn = f"norm_{c}"
+        if cn in row.index:
+            v = row[cn]
+            if pd.isna(v):
+                v = 0.0
+            vals.append(float(v))
+    if not vals:
+        return 0.0
+    return float(np.mean(vals))
+
+
 def norm_kew(v):
     if pd.isna(v):
         return None
@@ -98,7 +195,24 @@ def norm_kew(v):
         return "PUSAT"
     return t
 
-def norm_prov_label(s):
+
+def _norm_text(x):
+    if pd.isna(x):
+        return None
+    t = str(x).strip().upper()
+    return " ".join(t.split())
+
+
+def slugify(s: str) -> str:
+    if s is None:
+        return "NA"
+    t = str(s).strip()
+    if t == "":
+        return "NA"
+    return re.sub(r"[^A-Z0-9]+", "", t.upper())
+
+
+def norm_prov_key(s):
     if pd.isna(s):
         return None
     t = str(s).upper()
@@ -107,113 +221,42 @@ def norm_prov_label(s):
     t = " ".join(t.split())
     return re.sub(r"[^A-Z0-9]+", "", t)
 
-def norm_kab_label(s):
+
+def norm_kab_key(s):
     if pd.isna(s):
         return None
     t = str(s).upper()
-    t = t.replace("KABUPATEN", "KAB")
-    t = t.replace("KAB.", "KAB")
-    t = t.replace("KOTA ADMINISTRASI", "KOTA")
-    t = t.replace("KOTA ADM.", "KOTA")
-    t = t.replace("KOTA.", "KOTA")
+    t = t.replace("KABUPATEN", "KAB").replace("KAB.", "KAB")
+    t = t.replace("KOTA ADMINISTRASI", "KOTA").replace("KOTA.", "KOTA")
     t = " ".join(t.split())
     return re.sub(r"[^A-Z0-9]+", "", t)
 
-def safe_div(num, den):
-    if den is None or pd.isna(den) or den <= 0:
-        return np.nan
-    return float(num) / float(den)
-
-def cap_bobot(cov: float) -> float:
-    if cov is None or pd.isna(cov) or cov <= 0:
-        return 0.0
-    return float(min(cov / TARGET_COVERAGE, 1.0))
-
-def penalized_mean(row, cols):
-    vals = []
-    for c in cols:
-        k = f"norm_{c}"
-        if k in row.index:
-            v = row[k]
-            if pd.isna(v):
-                v = 0.0
-            vals.append(float(v))
-    return float(np.mean(vals)) if vals else 0.0
-
-def slugify(s: str) -> str:
-    if s is None:
-        return "NA"
-    t = str(s).strip()
-    return re.sub(r"[^A-Z0-9]+", "", t.upper()) or "NA"
-
-# ============================================================
-# 3) INDIKATOR IPLM
-# ============================================================
 
-koleksi_cols = [
-    "JudulTercetak","EksemplarTercetak","JudulElektronik","EksemplarElektronik",
-    "TambahJudulTercetak","TambahEksemplarTercetak",
-    "TambahJudulElektronik","TambahEksemplarElektronik",
-    "KomitmenAnggaranKoleksi"
-]
-sdm_cols = [
-    "TenagaKualifikasiIlmuPerpustakaan",
-    "TenagaFungsionalProfesional",
-    "TenagaPKB",
-    "AnggaranTenaga"
-]
-pelayanan_cols = [
-    "PesertaBudayaBaca","PemustakaLuringDaring","PemustakaFasilitasTIK",
-    "PemanfaatanJudulTercetak","PemanfaatanEksemplarTercetak",
-    "PemanfaatanJudulElektronik","PemanfaatanEksemplarElektronik"
-]
-pengelolaan_cols = [
-    "KegiatanBudayaBaca","KegiatanKerjasama","VariasiLayanan","Kebijakan","AnggaranLayanan"
-]
-all_indicators = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
+def round_int_df(df: pd.DataFrame) -> pd.DataFrame:
+    if df is None or df.empty:
+        return df
+    out = df.copy()
+    for c in out.columns:
+        if pd.api.types.is_numeric_dtype(out[c]):
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
+    return out
 
-alias_map_raw = {
-    "j_judul_koleksi_tercetak": "JudulTercetak",
-    "j_eksemplar_koleksi_tercetak": "EksemplarTercetak",
-    "j_judul_koleksi_digital": "JudulElektronik",
-    "j_eksemplar_koleksi_digital": "EksemplarElektronik",
-    "tambah_judul_koleksi_tercetak": "TambahJudulTercetak",
-    "tambah_eksemplar_koleksi_tercetak": "TambahEksemplarTercetak",
-    "tambah_judul_koleksi_digital": "TambahJudulElektronik",
-    "tambah_eksemplar_koleksi_digital": "TambahEksemplarElektronik",
-    "j_anggaran_koleksi": "KomitmenAnggaranKoleksi",
-    "j_tenaga_ilmu_perpus": "TenagaKualifikasiIlmuPerpustakaan",
-    "j_tenaga_nonilmu_perpus": "TenagaFungsionalProfesional",
-    "j_tenaga_pkb": "TenagaPKB",
-    "j_anggaran_diklat_perpus": "AnggaranTenaga",
-    "j_peserta_budaya_baca": "PesertaBudayaBaca",
-    "j_pemustaka_luring_daring": "PemustakaLuringDaring",
-    "j_pemustaka_fasilitas_tik": "PemustakaFasilitasTIK",
-    "j_judul_koleksi_tercetak_termanfaat": "PemanfaatanJudulTercetak",
-    "j_eksemplar_koleksi_tercetak_termanfaat": "PemanfaatanEksemplarTercetak",
-    "j_judul_koleksi_digital_termanfaat": "PemanfaatanJudulElektronik",
-    "j_eksemplar_koleksi_digital_termanfaat": "PemanfaatanEksemplarElektronik",
-    "j_kegiatan_budaya_baca_peningkatan_literasi": "KegiatanBudayaBaca",
-    "j_kerjasama_pengembangan_perpus": "KegiatanKerjasama",
-    "j_variasi_layanan": "VariasiLayanan",
-    "j_kebijakan_prosedur_pelayanan": "Kebijakan",
-    "j_anggaran_peningkatan_pelayanan": "AnggaranLayanan",
-}
-alias_map = {_canon(k): v for k, v in alias_map_raw.items()}
 
 # ============================================================
-# 4) LOAD DATA
+# 4) LOAD DATA + POPULASI
 # ============================================================
 
 DATA_INFO = ""
 df_all_raw = None
-df_pop_kab = None
-df_pop_prov = None
 
 prov_col = kab_col = kew_col = jenis_col = nama_col = None
 
-# --- DM ---
+# Populasi
+pop_kab = None
+pop_prov = None
+
 try:
+    # --- DM ---
     fp = Path(DATA_FILE)
     if not fp.exists():
         raise FileNotFoundError(f"File tidak ditemukan: {DATA_FILE}")
@@ -222,376 +265,431 @@ try:
     frames = [pd.read_excel(fp, sheet_name=s) for s in xls.sheet_names]
     df_all_raw = pd.concat(frames, ignore_index=True, sort=False)
 
-    prov_col  = pick_col(df_all_raw, ["provinsi", "Provinsi", "PROVINSI"])
-    kab_col   = pick_col(df_all_raw, ["kab_kota", "Kab_Kota", "Kab/Kota", "KAB/KOTA", "kabupaten_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"])
-    nama_col  = pick_col(df_all_raw, ["nm_perpustakaan","nama_perpustakaan", "Nama Perpustakaan", "nm_instansi_lembaga"])
+    prov_col = pick_col(df_all_raw, ["provinsi", "Provinsi", "PROVINSI"])
+    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"])
 
     df_all_raw["KEW_NORM"] = df_all_raw[kew_col].apply(norm_kew) if kew_col else None
 
     val_map_jenis = {
-        "PERPUSTAKAAN SEKOLAH": "sekolah", "SEKOLAH": "sekolah",
-        "PERPUSTAKAAN UMUM": "umum", "UMUM": "umum", "PERPUSTAKAAN DAERAH": "umum",
-        "PERPUSTAKAAN KHUSUS": "khusus", "KHUSUS": "khusus",
+        "PERPUSTAKAAN SEKOLAH": "sekolah",
+        "SEKOLAH": "sekolah",
+        "PERPUSTAKAAN UMUM": "umum",
+        "UMUM": "umum",
+        "PERPUSTAKAAN DAERAH": "umum",
+        "PERPUSTAKAAN KHUSUS": "khusus",
+        "KHUSUS": "khusus",
     }
-    df_all_raw["_dataset"] = df_all_raw[jenis_col].astype(str).str.strip().str.upper().map(val_map_jenis) if jenis_col else None
+    df_all_raw["_dataset"] = df_all_raw[jenis_col].apply(_norm_text).map(val_map_jenis) if jenis_col else None
 
-    df_all_raw["PROV_DISP"] = df_all_raw[prov_col].apply(_disp_text) if prov_col else None
-    df_all_raw["KAB_DISP"]  = df_all_raw[kab_col].apply(_disp_text)  if kab_col else None
+    # keys
+    if prov_col:
+        df_all_raw["prov_key"] = df_all_raw[prov_col].apply(norm_prov_key)
+    else:
+        df_all_raw["prov_key"] = 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}`"
+    if kab_col:
+        df_all_raw["kab_key"] = df_all_raw[kab_col].apply(norm_kab_key)
+    else:
+        df_all_raw["kab_key"] = None
+
+    # --- POP KAB/KOTA ---
+    pk = pd.read_excel(POP_KAB_FILE)
+    # Kolom expected:
+    # PROVINSI, KABUPATEN_KOTA, jumlah_populasi_umum, jumlah_populasi_sekolah (dan lain-lain)
+    col_pkab = pick_col(pk, ["KABUPATEN_KOTA","Kabupaten_Kota","Kab/Kota","Kabupaten/Kota"])
+    col_pprov= pick_col(pk, ["PROVINSI","Provinsi"])
+    col_pop_umum = pick_col(pk, ["jumlah_populasi_umum","jumlah populasi umum","pop_umum"])
+    col_pop_sek  = pick_col(pk, ["jumlah_populasi_sekolah","jumlah populasi sekolah","pop_sekolah"])
+
+    if col_pkab is None or (col_pop_umum is None and col_pop_sek is None):
+        raise ValueError("Kolom populasi kab/kota tidak lengkap pada Data_populasi_Kab_kota.xlsx")
+
+    pop_kab = pd.DataFrame({
+        "kab_key": pk[col_pkab].astype(str).str.strip().apply(norm_kab_key),
+        "Kab_Kota_Label": pk[col_pkab].astype(str).str.strip(),
+    })
+    if col_pprov:
+        pop_kab["Provinsi_Label"] = pk[col_pprov].astype(str).str.strip()
+    pop_kab["pop_umum"] = pk[col_pop_umum].apply(coerce_num) if col_pop_umum else np.nan
+    pop_kab["pop_sekolah"] = pk[col_pop_sek].apply(coerce_num) if col_pop_sek else np.nan
+
+    # dedup by kab_key (ambil max agar aman)
+    pop_kab = pop_kab.groupby("kab_key", as_index=False).agg({
+        "Kab_Kota_Label":"first",
+        "Provinsi_Label":"first" if "Provinsi_Label" in pop_kab.columns else "first",
+        "pop_umum":"max",
+        "pop_sekolah":"max",
+    })
 
-# --- Pop Kab/Kota ---
-POP_INFO = []
-try:
-    pk = pd.read_excel(POP_KAB)
-    c_prov = pick_col(pk, ["PROVINSI","Provinsi"])
-    c_kab  = pick_col(pk, ["KABUPATEN_KOTA","Kab/Kota","Kabupaten/Kota","KAB/KOTA"])
-    c_pop_umum    = pick_col(pk, ["Pop_Umum","pop_umum","jumlah_populasi_umum"])
-    c_pop_sekolah = pick_col(pk, ["Pop_Sekolah","pop_sekolah","jumlah_populasi_sekolah"])
-
-    if c_kab is None:
-        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,
-        "Kab_Kota_Label": pk[c_kab].astype(str).str.strip(),
-        "Pop_Umum": pk[c_pop_umum].apply(coerce_num) if c_pop_umum else np.nan,
-        "Pop_Sekolah": pk[c_pop_sekolah].apply(coerce_num) if c_pop_sekolah else np.nan,
+    # --- POP PROV ---
+    pp = pd.read_excel(POP_PROV_FILE)
+    col_pr = pick_col(pp, ["Provinsi","PROVINSI","provinsi"])
+    col_pop_pend = pick_col(pp, ["total_pend","total pend","total_pendidikan","total_pend "])
+    col_target_samp = pick_col(pp, ["total _sampel","total_sampel","total sampel"])
+
+    if col_pr is None:
+        raise ValueError("Kolom Provinsi tidak ditemukan pada Data_populasi_propinsi.xlsx")
+
+    pop_prov = pd.DataFrame({
+        "prov_key": pp[col_pr].astype(str).str.strip().apply(norm_prov_key),
+        "Provinsi_Label": pp[col_pr].astype(str).str.strip(),
     })
-    df_pop_kab["kab_key"] = df_pop_kab["Kab_Kota_Label"].apply(norm_kab_label)
-    POP_INFO.append(f"✅ Populasi Kab/Kota terbaca: **{POP_KAB}** (n={len(df_pop_kab)})")
-except Exception as e:
-    df_pop_kab = None
-    POP_INFO.append(f"⚠️ Gagal memuat populasi Kab/Kota: `{e}`")
 
-# --- Pop Provinsi ---
-try:
-    pp = pd.read_excel(POP_PROV)
-    c_prov = pick_col(pp, ["Provinsi","PROVINSI"])
-    c_total = pick_col(pp, ["total_pend","TOTAL_PEND","Pop_Sekolah_Prov","pop_sekolah_prov","sma"])
-    if c_prov is None or c_total is None:
-        raise ValueError("Kolom Provinsi / total_pend (atau ekuivalen) tidak ditemukan di populasi provinsi.")
-
-    df_pop_prov = pd.DataFrame({
-        "Provinsi_Label": pp[c_prov].astype(str).str.strip(),
-        "Pop_Sekolah_Prov": pp[c_total].apply(coerce_num),
+    # gunakan total_pend sebagai populasi; kalau tidak ada, fallback dari total_sampel/0.68
+    if col_pop_pend:
+        pop_prov["pop_sekolah_prov"] = pp[col_pop_pend].apply(coerce_num)
+    elif col_target_samp:
+        pop_prov["pop_sekolah_prov"] = pp[col_target_samp].apply(coerce_num) / TARGET_COVERAGE
+    else:
+        pop_prov["pop_sekolah_prov"] = np.nan
+
+    pop_prov = pop_prov.groupby("prov_key", as_index=False).agg({
+        "Provinsi_Label":"first",
+        "pop_sekolah_prov":"max",
     })
-    df_pop_prov["prov_key"] = df_pop_prov["Provinsi_Label"].apply(norm_prov_label)
-    df_pop_prov = df_pop_prov.groupby("prov_key", as_index=False).agg({"Provinsi_Label":"first","Pop_Sekolah_Prov":"sum"})
-    POP_INFO.append(f"✅ Populasi Provinsi terbaca: **{POP_PROV}** (n={len(df_pop_prov)})")
+
+    DATA_INFO = f"✅ Data: **{DATA_FILE}** | Baris: **{len(df_all_raw)}**"
+    DATA_INFO += f"<br>✅ Populasi Kab/Kota: **{POP_KAB_FILE}** (n={len(pop_kab)})"
+    DATA_INFO += f"<br>✅ Populasi Provinsi: **{POP_PROV_FILE}** (n={len(pop_prov)})"
+
 except Exception as e:
-    df_pop_prov = None
-    POP_INFO.append(f"⚠️ Gagal memuat populasi Provinsi: `{e}`")
+    df_all_raw = None
+    pop_kab = None
+    pop_prov = None
+    DATA_INFO = f"⚠️ Gagal load data: `{repr(e)}`"
+
+
+def all_prov_choices():
+    if df_all_raw is None or prov_col is None:
+        return ["(Semua)"]
+    s = df_all_raw[prov_col].dropna().astype(str).str.strip()
+    vals = sorted([o for o in s.unique() if o != ""])
+    return ["(Semua)"] + vals
+
+
+def get_kab_choices_for_prov(prov_value):
+    if df_all_raw is None or kab_col is None:
+        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 != ""])
+    return ["(Semua)"] + vals
+
+
+def all_kew_choices():
+    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 != ""])
+    return ["(Semua)"] + (vals if vals else [])
+
+
+prov_choices = all_prov_choices()
+kab_choices  = get_kab_choices_for_prov(prov_choices[0] if prov_choices else "(Semua)")
+kew_choices  = all_kew_choices()
+default_kew  = "KAB/KOTA" if "KAB/KOTA" in kew_choices else (kew_choices[0] if kew_choices else "(Semua)")
 
-if POP_INFO:
-    DATA_INFO = DATA_INFO + "<br>" + "<br>".join(POP_INFO)
 
 # ============================================================
-# 5) PIPELINE NASIONAL: YJ + MINMAX + DIM/SUBDIM + REAL
+# 5) PIPELINE NASIONAL: YJ + MinMax + Sub/Dim + Indeks Real
 # ============================================================
 
-def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
+def prepare_global_pipeline(df_src: pd.DataFrame) -> pd.DataFrame:
     if df_src is None or df_src.empty:
         return df_src
+
     df = df_src.copy()
 
+    # rename ke canonical indikator
     rename_map = {}
-    for col in df.columns:
-        c = _canon(col)
-        if c in alias_map:
-            rename_map[col] = alias_map[c]
+    canonical_targets = set(all_indicators)
+    for col in list(df.columns):
+        ccol = _canon(col)
+        if ccol in alias_map:
+            rename_map[col] = alias_map[ccol]
         else:
-            for tgt in all_indicators:
-                if c == _canon(tgt):
+            for tgt in canonical_targets:
+                if ccol == _canon(tgt):
                     rename_map[col] = tgt
                     break
     if rename_map:
         df = df.rename(columns=rename_map)
 
     available = [c for c in all_indicators if c in df.columns]
+
+    # numeric
     for c in available:
         df[c] = df[c].apply(coerce_num)
 
+    # Yeo–Johnson (nasional) + MinMax (nasional)
     for c in available:
         x = df[c].astype(float).values
         mask = ~np.isnan(x)
-        transformed = np.full_like(x, np.nan, dtype=float)
+        y = np.full_like(x, np.nan, dtype=float)
+
         if mask.sum() > 1:
             pt = PowerTransformer(method="yeo-johnson", standardize=False)
-            transformed[mask] = pt.fit_transform(x[mask].reshape(-1, 1)).ravel()
+            y[mask] = pt.fit_transform(x[mask].reshape(-1, 1)).ravel()
         else:
-            transformed[mask] = x[mask]
-        df[f"norm_{c}"] = minmax_norm(pd.Series(transformed, index=df.index))
+            y[mask] = x[mask]
+
+        df[f"yj_{c}"] = y
+        df[f"norm_{c}"] = minmax_norm(pd.Series(y, index=df.index))
 
+    # sub-dimensi (0–1) penalized mean
     df["sub_koleksi"] = df.apply(lambda r: penalized_mean(r, [c for c in koleksi_cols if c in available]), axis=1)
     df["sub_sdm"] = df.apply(lambda r: penalized_mean(r, [c for c in sdm_cols if c in available]), axis=1)
     df["sub_pelayanan"] = df.apply(lambda r: penalized_mean(r, [c for c in pelayanan_cols if c in available]), axis=1)
     df["sub_pengelolaan"] = df.apply(lambda r: penalized_mean(r, [c for c in pengelolaan_cols if c in available]), axis=1)
 
-    df["dim_kepatuhan"] = df[["sub_koleksi","sub_sdm"]].mean(axis=1)
-    df["dim_kinerja"]   = df[["sub_pelayanan","sub_pengelolaan"]].mean(axis=1)
+    df["dim_kepatuhan"] = df[["sub_koleksi","sub_sdm"]].mean(axis=1).fillna(0.0)
+    df["dim_kinerja"]   = df[["sub_pelayanan","sub_pengelolaan"]].mean(axis=1).fillna(0.0)
 
-    df["Indeks_Real_0_100"] = 100 * (W_KEPATUHAN * df["dim_kepatuhan"] + W_KINERJA * df["dim_kinerja"])
-    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)
+    df["Indeks_Real_0_100"] = (
+        100 * (W_KEPATUHAN * df["dim_kepatuhan"] + W_KINERJA * df["dim_kinerja"])
+    ).fillna(0.0)
 
     return df
 
-df_all = prepare_global(df_all_raw) if df_all_raw is not None else None
-
-# ============================================================
-# 6) COVERAGE -> FINAL + VERIF (NO DECIMALS)
-# ============================================================
-
-def compute_final(df_filtered: pd.DataFrame, kew_value: str):
-    if df_filtered is None or df_filtered.empty:
-        return df_filtered, pd.DataFrame()
-
-    df = df_filtered.copy()
-    kew_norm = str(kew_value or "").upper()
-
-    df["bobot_coverage"] = 1.0
-    df["coverage"] = np.nan
-
-    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_DISP"].apply(norm_kab_label)
-
-        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)
 
-        pop = df_pop_kab.set_index("kab_key")
+df_all = prepare_global_pipeline(df_all_raw) if df_all_raw is not None else None
 
-        rows = []
-        for kk in g_piv.index:
-            pop_sek = pop.loc[kk, "Pop_Sekolah"] if kk in pop.index else np.nan
-            pop_um  = pop.loc[kk, "Pop_Umum"] if kk in pop.index else np.nan
 
-            n_sek = float(g_piv.loc[kk].get("sekolah", 0))
-            n_um  = float(g_piv.loc[kk].get("umum", 0))
-
-            cov_sek = safe_div(n_sek, pop_sek)
-            cov_um  = safe_div(n_um,  pop_um)
+# ============================================================
+# 6) PENALTI COVERAGE 68% -> INDEKS FINAL
+# ============================================================
 
-            bobot_sek = cap_bobot(cov_sek)
-            bobot_um  = cap_bobot(cov_um)
+def compute_coverage_weight(df_subset: pd.DataFrame, kew_value: str) -> pd.Series:
+    """
+    Bobot coverage per baris:
+    - KAB/KOTA:
+        sekolah: n_sampel sekolah per kab / pop_sekolah kab
+        umum  : n_sampel umum per kab / pop_umum kab
+        khusus: 1.0
+    - PROVINSI:
+        sekolah: n_sampel sekolah per prov / pop_sekolah_prov
+        umum/khusus: 1.0 (untuk umum provinsi tidak didefinisikan di populasi ini)
+    """
+    if df_subset is None or df_subset.empty:
+        return pd.Series([], dtype=float)
 
-            target_sek = (TARGET_COVERAGE * pop_sek) if not pd.isna(pop_sek) else np.nan
-            target_um  = (TARGET_COVERAGE * pop_um)  if not pd.isna(pop_um)  else np.nan
+    df = df_subset.copy()
+    w = pd.Series(1.0, index=df.index, dtype=float)
 
-            rows.append({
-                "Kab/Kota": pop.loc[kk,"Kab_Kota_Label"] if kk in pop.index else kk,
-                "Pop_Sekolah": pop_sek,
-                "Sampel_Sekolah": n_sek,
-                "Coverage_Sekolah_%": (cov_sek * 100) if not pd.isna(cov_sek) else np.nan,
-                "Bobot_Sekolah_68_%": (bobot_sek * 100) if not pd.isna(bobot_sek) else np.nan,
-                "GAP_Ke_68_Sekolah": max(target_sek - n_sek, 0) if not pd.isna(target_sek) else np.nan,
-
-                "Pop_Umum": pop_um,
-                "Sampel_Umum": n_um,
-                "Coverage_Umum_%": (cov_um * 100) if not pd.isna(cov_um) else np.nan,
-                "Bobot_Umum_68_%": (bobot_um * 100) if not pd.isna(bobot_um) else np.nan,
-                "GAP_Ke_68_Umum": max(target_um - n_um, 0) if not pd.isna(target_um) else np.nan,
-            })
+    def cap(cov):
+        if pd.isna(cov) or cov <= 0:
+            return 0.0
+        return float(min(cov / TARGET_COVERAGE, 1.0))
 
-        verif_df = pd.DataFrame(rows)
+    kew_norm = str(kew_value or "").upper()
 
-        # bulatkan TANPA koma
-        int_cols = ["Pop_Sekolah","Sampel_Sekolah","GAP_Ke_68_Sekolah","Pop_Umum","Sampel_Umum","GAP_Ke_68_Umum"]
-        pct_cols = ["Coverage_Sekolah_%","Bobot_Sekolah_68_%","Coverage_Umum_%","Bobot_Umum_68_%"]
-        for c in int_cols:
-            if c in verif_df.columns:
-                verif_df[c] = verif_df[c].fillna(0).round(0).astype(int)
-        for c in pct_cols:
-            if c in verif_df.columns:
-                verif_df[c] = verif_df[c].fillna(0).round(0).astype(int)
+    # KAB/KOTA
+    if ("KAB" in kew_norm or "KOTA" in kew_norm) and pop_kab is not None and "kab_key" in df.columns:
+        g = df.groupby(["kab_key","_dataset"]).size().unstack(fill_value=0)
 
-        bobot_map_sek = {norm_kab_label(r["Kab/Kota"]): float(r["Bobot_Sekolah_68_%"]) / 100.0 for _, r in verif_df.iterrows()}
-        bobot_map_um  = {norm_kab_label(r["Kab/Kota"]): float(r["Bobot_Umum_68_%"]) / 100.0    for _, r in verif_df.iterrows()}
+        # join populasi
+        j = pop_kab.merge(g.reset_index(), on="kab_key", how="left").fillna(0)
 
-        cov_map_sek = {norm_kab_label(r["Kab/Kota"]): float(r["Coverage_Sekolah_%"]) / 100.0 for _, r in verif_df.iterrows()}
-        cov_map_um  = {norm_kab_label(r["Kab/Kota"]): float(r["Coverage_Umum_%"]) / 100.0    for _, r in verif_df.iterrows()}
+        # coverage
+        cov_sek = np.where(j["pop_sekolah"].replace(0, np.nan).notna(),
+                           j.get("sekolah", 0) / j["pop_sekolah"].replace(0, np.nan),
+                           np.nan)
+        cov_um  = np.where(j["pop_umum"].replace(0, np.nan).notna(),
+                           j.get("umum", 0) / j["pop_umum"].replace(0, np.nan),
+                           np.nan)
 
-        df["kab_key"] = df["KAB_DISP"].apply(norm_kab_label)
+        map_sek = dict(zip(j["kab_key"], pd.Series(cov_sek).apply(cap).fillna(0.0)))
+        map_um  = dict(zip(j["kab_key"], pd.Series(cov_um).apply(cap).fillna(0.0)))
 
-        def row_weight(r):
+        def row_w(r):
             ds = r.get("_dataset", None)
-            kk = r.get("kab_key", None)
             if ds == "khusus":
                 return 1.0
-            if ds == "sekolah":
-                return float(bobot_map_sek.get(kk, 0.0))
-            if ds == "umum":
-                return float(bobot_map_um.get(kk, 0.0))
-            return 1.0
-
-        def row_cov(r):
-            ds = r.get("_dataset", None)
             kk = r.get("kab_key", None)
             if ds == "sekolah":
-                return float(cov_map_sek.get(kk, np.nan))
+                return float(map_sek.get(kk, 0.0))
             if ds == "umum":
-                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)
-
-    elif ("PROV" in kew_norm) and prov_col and df_pop_prov is not None:
-        tmp = df.copy()
-        tmp["prov_key"] = tmp["PROV_DISP"].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)
-        pop = df_pop_prov.set_index("prov_key")
-
-        rows = []
-        for pk in g_piv.index:
-            pop_sek = pop.loc[pk, "Pop_Sekolah_Prov"] if pk in pop.index else np.nan
-            n_sek = float(g_piv.loc[pk].get("sekolah", 0))
-            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
+                return float(map_um.get(kk, 0.0))
+            return 1.0
 
-            rows.append({
-                "Provinsi": pop.loc[pk, "Provinsi_Label"] if pk in pop.index else pk,
-                "Pop_Sekolah": pop_sek,
-                "Sampel_Sekolah": n_sek,
-                "Coverage_Sekolah_%": (cov_sek * 100) if not pd.isna(cov_sek) else np.nan,
-                "Bobot_Sekolah_68_%": (bobot_sek * 100) if not pd.isna(bobot_sek) else np.nan,
-                "GAP_Ke_68_Sekolah": max(target_sek - n_sek, 0) if not pd.isna(target_sek) else np.nan,
-            })
+        w = df.apply(row_w, axis=1)
 
-        verif_df = pd.DataFrame(rows)
+    # PROVINSI
+    if ("PROV" in kew_norm) and pop_prov is not None and "prov_key" in df.columns:
+        g = df.groupby(["prov_key","_dataset"]).size().unstack(fill_value=0)
 
-        int_cols = ["Pop_Sekolah","Sampel_Sekolah","GAP_Ke_68_Sekolah"]
-        pct_cols = ["Coverage_Sekolah_%","Bobot_Sekolah_68_%"]
-        for c in int_cols:
-            if c in verif_df.columns:
-                verif_df[c] = verif_df[c].fillna(0).round(0).astype(int)
-        for c in pct_cols:
-            if c in verif_df.columns:
-                verif_df[c] = verif_df[c].fillna(0).round(0).astype(int)
+        j = pop_prov.merge(g.reset_index(), on="prov_key", how="left").fillna(0)
 
-        bobot_map = {norm_prov_label(r["Provinsi"]): float(r["Bobot_Sekolah_68_%"]) / 100.0 for _, r in verif_df.iterrows()}
-        cov_map   = {norm_prov_label(r["Provinsi"]): float(r["Coverage_Sekolah_%"]) / 100.0 for _, r in verif_df.iterrows()}
+        cov = np.where(j["pop_sekolah_prov"].replace(0, np.nan).notna(),
+                       j.get("sekolah", 0) / j["pop_sekolah_prov"].replace(0, np.nan),
+                       np.nan)
 
-        df["prov_key"] = df["PROV_DISP"].apply(norm_prov_label)
+        map_cov = dict(zip(j["prov_key"], pd.Series(cov).apply(cap).fillna(0.0)))
 
-        def row_weight(r):
+        def row_w2(r):
             ds = r.get("_dataset", None)
             if ds == "khusus":
                 return 1.0
             if ds == "sekolah":
-                return float(bobot_map.get(r.get("prov_key", None), 0.0))
+                return float(map_cov.get(r.get("prov_key", None), 0.0))
             return 1.0
 
-        def row_cov(r):
-            if r.get("_dataset", None) != "sekolah":
-                return np.nan
-            return float(cov_map.get(r.get("prov_key", None), np.nan))
+        w = df.apply(row_w2, axis=1)
 
-        df["bobot_coverage"] = df.apply(row_weight, axis=1)
-        df["coverage"] = df.apply(row_cov, axis=1)
+    return pd.Series(w, index=df.index, dtype=float)
 
-    else:
-        verif_df = pd.DataFrame()
 
-    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
+def apply_penalty_and_final(df_subset: pd.DataFrame, kew_value: str) -> pd.DataFrame:
+    if df_subset is None or df_subset.empty:
+        return df_subset
+
+    df = df_subset.copy()
+    weights = compute_coverage_weight(df, kew_value)
+
+    df["DimKepatuhan_Final"] = (df["dim_kepatuhan"].fillna(0.0) * weights).fillna(0.0)
+    df["DimKinerja_Final"]   = (df["dim_kinerja"].fillna(0.0) * weights).fillna(0.0)
+    df["Indeks_Final_0_100"] = (df["Indeks_Real_0_100"].fillna(0.0) * weights).fillna(0.0)
+
+    return df
+
 
 # ============================================================
-# 7) BELL CURVE (FINAL) — all + per jenis
+# 7) BELL CURVE (Plotly)
 # ============================================================
 
-def make_bell_figure(df_in: pd.DataFrame, title: str, index_col="Indeks_Final_0_100", name_col=None, min_points=5) -> go.Figure:
+def make_bell_figure(df_plot: pd.DataFrame, title: str, idx_col: str, hover_name: str = None) -> go.Figure:
     fig = go.Figure()
-    if df_in is None or df_in.empty or index_col not in df_in.columns:
-        fig.update_layout(title=title, xaxis_title="Indeks (0–100)", yaxis_title="Kepadatan (relatif)")
+    fig.update_layout(
+        title=title,
+        xaxis_title="Indeks (0–100)",
+        yaxis_title="Kepadatan (relatif)",
+        yaxis=dict(showticklabels=False),
+        margin=dict(l=40, r=20, t=60, b=40),
+        hovermode="x"
+    )
+
+    if df_plot is None or df_plot.empty or idx_col not in df_plot.columns:
+        fig.add_annotation(text="Data tidak tersedia.", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
         return fig
 
-    dfp = df_in[pd.notna(df_in[index_col])].copy()
-    if dfp.empty or len(dfp) < min_points:
-        fig.update_layout(
-            title=title,
-            xaxis_title="Indeks (0–100)",
-            yaxis_title="Kepadatan (relatif)",
-            annotations=[dict(text="Grafik tidak ditampilkan (data terlalu sedikit).",
-                              x=0.5, y=0.5, xref="paper", yref="paper",
-                              showarrow=False, font=dict(size=14))]
-        )
+    x = pd.to_numeric(df_plot[idx_col], errors="coerce").dropna().values.astype(float)
+    if len(x) < 3:
+        fig.add_annotation(text="Data terlalu sedikit untuk bell curve.", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)
         return fig
 
-    x_vals = dfp[index_col].astype(float).values
-    mu = float(np.mean(x_vals))
-    sigma = float(np.std(x_vals, ddof=1)) if len(x_vals) > 1 else 1.0
-    if sigma <= 1e-9:
+    mu = x.mean()
+    sigma = x.std(ddof=1) if len(x) > 1 else 1.0
+    if sigma <= 0:
         sigma = 1.0
 
-    xs = np.linspace(max(0, np.min(x_vals) - 5), min(100, np.max(x_vals) + 5), 200)
+    xs = np.linspace(max(0, x.min() - 5), min(100, x.max() + 5), 200)
     pdf = (1.0 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((xs - mu) / sigma) ** 2)
-    pdf = pdf / (pdf.max() if pdf.max() > 0 else 1.0)
-
-    if name_col and name_col in dfp.columns:
-        hover_text = [f"{str(n)}<br>Indeks Final: {v:.2f}" for n, v in zip(dfp[name_col], x_vals)]
-    else:
-        hover_text = [f"Indeks Final: {v:.2f}" for v in x_vals]
+    pdf = pdf / pdf.max()
 
+    # line
     fig.add_trace(go.Scatter(x=xs, y=pdf, mode="lines", name="Bell curve", hoverinfo="skip"))
+
+    # points
+    if hover_name and hover_name in df_plot.columns:
+        hv = [f"{n}<br>Indeks: {v:.0f}" for n, v in zip(df_plot[hover_name].astype(str).fillna(""), df_plot[idx_col].fillna(0))]
+    else:
+        hv = [f"Indeks: {v:.0f}" for v in df_plot[idx_col].fillna(0)]
     fig.add_trace(go.Scatter(
-        x=x_vals, y=np.zeros_like(x_vals),
-        mode="markers", name="Perpustakaan",
-        hovertext=hover_text, hovertemplate="%{hovertext}<extra></extra>"
+        x=df_plot[idx_col].fillna(0),
+        y=np.zeros(len(df_plot)),
+        mode="markers",
+        name="Perpustakaan",
+        hovertext=hv,
+        hovertemplate="%{hovertext}<extra></extra>"
     ))
 
-    q1, q2, q3 = np.quantile(x_vals, [0.25, 0.5, 0.75])
-    for q, label in [(q1, "Q1"), (q2, "Q2 (Median)"), (q3, "Q3")]:
+    # quartiles
+    q1, q2, q3 = np.quantile(x, [0.25, 0.5, 0.75])
+    for q, label in [(q1, "Q1"), (q2, "Median"), (q3, "Q3")]:
         fig.add_trace(go.Scatter(
-            x=[q, q], y=[0, 1.05],
-            mode="lines", name=label,
+            x=[q, q],
+            y=[0, 1.05],
+            mode="lines",
+            name=label,
             hovertemplate=f"{label}: {q:.2f}<extra></extra>"
         ))
 
-    fig.update_layout(
-        title=title,
-        xaxis_title="Indeks IPLM FINAL (0–100)",
-        yaxis_title="Kepadatan (relatif)",
-        yaxis=dict(showticklabels=False, zeroline=True, range=[0, 1.2]),
-        margin=dict(l=40, r=20, t=60, b=40),
-        hovermode="x"
-    )
     return fig
 
+
 # ============================================================
-# 7c. LLM DATA ANALYTICS (NARASI LEBIH DATA-DRIVEN) + WORD DOCX
-# (TAMBAHAN SAJA — TIDAK MENGUBAH PIPELINE YANG ADA)
+# 8) VERIFIKASI (opsional untuk kontrol mutu)
+#    - kita tetap hitung ringkas untuk Word, tapi TIDAK ditampilkan di detail.
 # ============================================================
 
-def _safe_table_text(df: pd.DataFrame, max_rows: int = 12) -> str:
-    if df is None or df.empty:
-        return "(kosong)"
-    tmp = df.copy()
-    # batasi kolom & baris biar prompt tidak meledak
-    tmp = tmp.head(max_rows)
-    return tmp.to_string(index=False)
+def compute_verification_table(df_subset: pd.DataFrame, kew_value: str) -> pd.DataFrame:
+    if df_subset is None or df_subset.empty:
+        return pd.DataFrame()
 
+    kew_norm = str(kew_value or "").upper()
 
-def summarize_distribution(detail_df: pd.DataFrame):
-    """
-    Ringkas distribusi indeks final untuk LLM:
-    - pakai Indeks_Final_0_100 kalau ada, kalau tidak fallback ke Indeks_Real_0_100
-    """
+    # Kab/Kota
+    if ("KAB" in kew_norm or "KOTA" in kew_norm) and pop_kab is not None and "kab_key" in df_subset.columns:
+        g = df_subset.groupby(["kab_key","_dataset"]).size().unstack(fill_value=0).reset_index()
+        j = pop_kab.merge(g, on="kab_key", how="left").fillna(0)
+
+        out = pd.DataFrame({
+            "Kab/Kota": j["Kab_Kota_Label"],
+            "Sampel_Sekolah": j.get("sekolah", 0).astype(int),
+            "Pop_Sekolah": pd.to_numeric(j["pop_sekolah"], errors="coerce").fillna(0).astype(int),
+            "Sampel_Umum": j.get("umum", 0).astype(int),
+            "Pop_Umum": pd.to_numeric(j["pop_umum"], errors="coerce").fillna(0).astype(int),
+        })
+        out["Coverage_Sekolah_%"] = np.where(out["Pop_Sekolah"] > 0, (100*out["Sampel_Sekolah"]/out["Pop_Sekolah"]), 0)
+        out["Coverage_Umum_%"]    = np.where(out["Pop_Umum"] > 0, (100*out["Sampel_Umum"]/out["Pop_Umum"]), 0)
+        return out.sort_values("Kab/Kota").reset_index(drop=True)
+
+    # Provinsi
+    if ("PROV" in kew_norm) and pop_prov is not None and "prov_key" in df_subset.columns:
+        g = df_subset.groupby(["prov_key","_dataset"]).size().unstack(fill_value=0).reset_index()
+        j = pop_prov.merge(g, on="prov_key", how="left").fillna(0)
+
+        out = pd.DataFrame({
+            "Provinsi": j["Provinsi_Label"],
+            "Sampel_Sekolah": j.get("sekolah", 0).astype(int),
+            "Pop_Sekolah": pd.to_numeric(j["pop_sekolah_prov"], errors="coerce").fillna(0).astype(int),
+        })
+        out["Coverage_Sekolah_%"] = np.where(out["Pop_Sekolah"] > 0, (100*out["Sampel_Sekolah"]/out["Pop_Sekolah"]), 0)
+        return out.sort_values("Provinsi").reset_index(drop=True)
+
+    return pd.DataFrame()
+
+
+# ============================================================
+# 9) LLM CLIENT + ANALYSIS + WORD
+# ============================================================
+
+def get_llm_client():
+    global _HF_CLIENT
+    if _HF_CLIENT is not None:
+        return _HF_CLIENT
+    try:
+        if HF_TOKEN:
+            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME, token=HF_TOKEN)
+        else:
+            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME)
+        return _HF_CLIENT
+    except Exception:
+        _HF_CLIENT = None
+        return None
+
+
+def summarize_distribution(detail_df: pd.DataFrame) -> dict:
     idx_col = "Indeks_Final_0_100" if (detail_df is not None and "Indeks_Final_0_100" in detail_df.columns) else "Indeks_Real_0_100"
     if detail_df is None or detail_df.empty or idx_col not in detail_df.columns:
         return {"idx_col": idx_col, "all": {}, "by_type": {}}
 
-    out = {"idx_col": idx_col, "all": {}, "by_type": {}}
-
     def stats_for(s: pd.Series):
         s = pd.to_numeric(s, errors="coerce").dropna()
         if len(s) == 0:
@@ -600,7 +698,6 @@ def summarize_distribution(detail_df: pd.DataFrame):
         return {
             "n": int(len(s)),
             "mean": float(s.mean()),
-            "std": float(s.std(ddof=1)) if len(s) > 1 else 0.0,
             "min": float(s.min()),
             "q1": float(q1),
             "median": float(q2),
@@ -608,105 +705,94 @@ def summarize_distribution(detail_df: pd.DataFrame):
             "max": float(s.max()),
         }
 
-    out["all"] = stats_for(detail_df[idx_col])
-
+    out = {"idx_col": idx_col, "all": stats_for(detail_df[idx_col]), "by_type": {}}
     if "_dataset" in detail_df.columns:
-        for ds in ["sekolah", "umum", "khusus"]:
-            dsub = detail_df[detail_df["_dataset"] == ds]
-            out["by_type"][ds] = stats_for(dsub[idx_col])
-
+        for ds in ["sekolah","umum","khusus"]:
+            out["by_type"][ds] = stats_for(detail_df.loc[detail_df["_dataset"] == ds, idx_col])
     return out
 
 
-def generate_llm_data_analytics(detail_df: pd.DataFrame,
-                                agg_df: pd.DataFrame,
-                                verif_df: pd.DataFrame,
-                                kab_name: str,
-                                kew_value: str) -> str:
-    """
-    Narasi LLM yang fokus ke:
-    - indeks FINAL (sudah penalti 68% kalau ada)
-    - distribusi (mean, Q1/median/Q3)
-    - gap coverage (kalau ada)
-    """
-    wilayah = kab_name
-    if kew_value and kew_value != "(Semua)":
-        wilayah = f"{kab_name} (kewenangan {kew_value})"
-
+def generate_rule_based_analytics(detail_df: pd.DataFrame, agg_df: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
     dist = summarize_distribution(detail_df)
-    idx_col = dist.get("idx_col", "Indeks_Final_0_100")
-
-    # ringkas angka utama biar prompt padat
-    all_stats = dist.get("all", {})
+    idx_col = dist["idx_col"]
+    st = dist.get("all", {})
+    lines = []
+    lines.append("## Analisis Otomatis (Fallback Rule-based)\n")
+    lines.append(f"Wilayah: {wilayah} | Kewenangan: {kew}")
+    lines.append(f"Indeks yang digunakan: {idx_col} (FINAL setelah penalti 68% bila berlaku)")
+    if st:
+        lines.append(f"- Jumlah sampel: {st['n']}")
+        lines.append(f"- Rata-rata indeks: {st['mean']:.2f}")
+        lines.append(f"- Q1/Median/Q3: {st['q1']:.2f} / {st['median']:.2f} / {st['q3']:.2f}")
+        lines.append(f"- Minimum–Maksimum: {st['min']:.2f} – {st['max']:.2f}")
+    lines.append("\nCatatan kebijakan: nilai indeks FINAL akan terdampak bila coverage sampel belum mencapai 68% pada perpustakaan sekolah/umum.")
+    lines.append("Rekomendasi umum: percepat peningkatan cakupan pelaporan, serta fokus pembinaan pada sub-dimensi yang paling tertinggal.")
+    return "\n".join(lines)
+
+
+def generate_llm_analytics(detail_df: pd.DataFrame, agg_df: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
+    dist = summarize_distribution(detail_df)
+    idx_col = dist["idx_col"]
+    st_all = dist.get("all", {})
     by_type = dist.get("by_type", {})
 
-    def fmt_stats(d):
-        if not d:
+    client = get_llm_client()
+    if (client is None) or (not USE_LLM):
+        return generate_rule_based_analytics(detail_df, agg_df, verif_df, wilayah, kew)
+
+    def fmt(st):
+        if not st:
             return "(tidak tersedia)"
-        return (
-            f"n={d['n']}, mean={d['mean']:.2f}, sd={d['std']:.2f}, "
-            f"min={d['min']:.2f}, Q1={d['q1']:.2f}, median={d['median']:.2f}, Q3={d['q3']:.2f}, max={d['max']:.2f}"
-        )
+        return f"n={st['n']}, mean={st['mean']:.2f}, min={st['min']:.2f}, Q1={st['q1']:.2f}, median={st['median']:.2f}, Q3={st['q3']:.2f}, max={st['max']:.2f}"
 
     lines = []
     lines.append(f"Wilayah: {wilayah}")
-    lines.append(f"Indeks yang dianalisis: {idx_col} (0–100)")
-    lines.append(f"Distribusi keseluruhan: {fmt_stats(all_stats)}")
-    if by_type:
-        for ds, st in by_type.items():
-            lines.append(f"Distribusi {ds}: {fmt_stats(st)}")
-
-    agg_txt = _safe_table_text(agg_df, max_rows=8)
-    ver_txt = _safe_table_text(verif_df, max_rows=12)
+    lines.append(f"Kewenangan: {kew}")
+    lines.append(f"Indeks: {idx_col} (0–100)")
+    lines.append(f"Distribusi keseluruhan: {fmt(st_all)}")
+    for ds in ["sekolah","umum","khusus"]:
+        if ds in by_type:
+            lines.append(f"Distribusi {ds}: {fmt(by_type[ds])}")
 
-    client = get_llm_client()
-    if client is None or not USE_LLM:
-        # fallback: pakai yang sudah ada (rule-based)
-        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
-        return (
-            "⚠️ LLM tidak tersedia, analisis menggunakan rule-based.\n\n" + rb
-        )
+    # ringkas table utk prompt
+    agg_txt = agg_df.to_string(index=False) if agg_df is not None and not agg_df.empty else "(kosong)"
+    ver_txt = verif_df.head(12).to_string(index=False) if verif_df is not None and not verif_df.empty else "(kosong)"
 
     system_prompt = (
-        "Anda adalah analis data & kebijakan perpustakaan. "
-        "Anda menulis analisis resmi untuk pemangku kepentingan pemerintah daerah. "
-        "Anda harus menggunakan pendekatan berbasis data, jelas, dan ringkas."
+        "Anda adalah analis data dan kebijakan perpustakaan. "
+        "Tuliskan analisis resmi berbasis data untuk pemangku kepentingan pemerintah daerah."
     )
 
     user_prompt = f"""
-DATA RINGKAS IPLM (FINAL) UNTUK ANALISIS:
+DATA RINGKAS IPLM:
 
-RINGKASAN STATISTIK (indeks final & distribusi):
+STATISTIK DISTRIBUSI (INDeks FINAL):
 {chr(10).join(lines)}
 
-TABEL AGREGAT (ringkas):
+TABEL AGREGAT (sub/dim + indeks final):
 {agg_txt}
 
-TABEL VERIFIKASI COVERAGE & GAP (ringkas):
+VERIFIKASI COVERAGE (kontrol mutu):
 {ver_txt}
 
 TUGAS:
-Tulis analisis dalam Bahasa Indonesia formal, struktur:
-
-A. Ringkasan eksekutif (1 paragraf) — fokus pada indeks FINAL setelah penalti 68%.
-B. Diagnostik berbasis data (2–3 paragraf):
-   - Jelaskan distribusi (Q1/Median/Q3), variasi antar jenis perpustakaan.
-   - Jelaskan implikasi kualitas/representasi data bila coverage belum 68%.
-C. Prioritas intervensi 12–18 bulan (1–2 paragraf) — fokus pada program pembinaan yang realistis.
-D. Rekomendasi kebijakan 3–5 tahun (1–2 paragraf) — penataan tata kelola data, pembinaan, standardisasi.
+Tulis analisis Bahasa Indonesia formal, struktur:
+A) Ringkasan eksekutif (1 paragraf).
+B) Diagnostik berbasis data (2–3 paragraf): variasi antar jenis perpustakaan, makna Q1/Median/Q3, implikasi penalti 68%.
+C) Prioritas intervensi 12–18 bulan (1–2 paragraf).
+D) Rekomendasi kebijakan 3–5 tahun (1–2 paragraf).
 
 GAYA:
-- Jangan menyebut "rendah/sedang/tinggi". Gunakan frasa netral: "ruang penguatan", "belum konsisten", dll.
-- Hindari kalimat terlalu panjang.
-- Jangan membuat data baru di luar yang tersedia.
+- Jangan pakai kata "rendah/sedang/tinggi". Pakai frasa netral: "ruang penguatan", "belum konsisten", dll.
+- Jangan membuat angka baru di luar data.
 """
 
     try:
         resp = client.chat_completion(
             model=LLM_MODEL_NAME,
             messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt},
+                {"role":"system","content":system_prompt},
+                {"role":"user","content":user_prompt},
             ],
             max_tokens=1200,
             temperature=0.25,
@@ -714,354 +800,269 @@ GAYA:
         )
         text = resp.choices[0].message.content.strip()
         if not text:
-            raise ValueError("Respon LLM kosong.")
+            raise ValueError("Respon LLM kosong")
         return text
-    except Exception as e:
-        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
-        return (
-            "⚠️ Gagal memanggil LLM untuk data analytics, fallback rule-based.\n\n"
-            f"(Detail teknis: {repr(e)})\n\n{rb}"
-        )
-
-
-def generate_word_report_llm_analytics(detail_df, agg_df, verif_df, prov, kab, kew, analytics_text):
-    """
-    Word report yang menaruh:
-    - Ringkasan indeks FINAL (statistik & kuartil)
-    - Tabel agregat ringkas
-    - Tabel verifikasi coverage (dibulatkan TANPA koma)
-    - Narasi LLM data analytics
-    """
-    if kew == "PUSAT":
-        return None
+    except Exception:
+        return generate_rule_based_analytics(detail_df, agg_df, verif_df, wilayah, kew)
 
-    wilayah = kab if kab != "(Semua)" else prov
-    dist = summarize_distribution(detail_df)
-    idx_col = dist.get("idx_col", "Indeks_Final_0_100")
-    all_stats = dist.get("all", {})
 
+def build_word_report(detail_df_full: pd.DataFrame,
+                      agg_df: pd.DataFrame,
+                      verif_df: pd.DataFrame,
+                      wilayah: str,
+                      kew: str,
+                      analysis_text: str) -> str:
     doc = Document()
     doc.add_heading(f"Laporan Analisis IPLM (FINAL) – {wilayah}", level=1)
+
     doc.add_paragraph(
-        "Laporan ini menyajikan analisis Indeks IPLM FINAL (0–100) setelah penerapan penalti "
-        "kecukupan sampel 68% (untuk perpustakaan sekolah dan umum, sesuai konfigurasi aplikasi)."
+        "Dokumen ini menyajikan analisis Indeks IPLM FINAL (0–100) setelah penerapan penalti "
+        "kecukupan sampel 68% (untuk perpustakaan sekolah dan umum). Perpustakaan khusus tidak "
+        "dikenai penalti karena populasi pembanding belum baku secara nasional."
     )
 
+    dist = summarize_distribution(detail_df_full)
+    idx_col = dist["idx_col"]
+    st = dist.get("all", {})
+
     doc.add_heading("1. Ringkasan Statistik Indeks FINAL", level=2)
-    if all_stats:
-        doc.add_paragraph(f"- Indeks yang digunakan: {idx_col}")
-        doc.add_paragraph(f"- Jumlah perpustakaan: {int(all_stats.get('n', 0))}")
-        doc.add_paragraph(f"- Rata-rata: {all_stats.get('mean', 0.0):.2f}")
-        doc.add_paragraph(f"- Q1: {all_stats.get('q1', 0.0):.2f}")
-        doc.add_paragraph(f"- Median: {all_stats.get('median', 0.0):.2f}")
-        doc.add_paragraph(f"- Q3: {all_stats.get('q3', 0.0):.2f}")
-        doc.add_paragraph(f"- Minimum–Maksimum: {all_stats.get('min', 0.0):.2f} – {all_stats.get('max', 0.0):.2f}")
+    if st:
+        doc.add_paragraph(f"- Indeks: {idx_col}")
+        doc.add_paragraph(f"- Jumlah sampel: {st['n']}")
+        doc.add_paragraph(f"- Rata-rata: {st['mean']:.2f}")
+        doc.add_paragraph(f"- Q1 / Median / Q3: {st['q1']:.2f} / {st['median']:.2f} / {st['q3']:.2f}")
+        doc.add_paragraph(f"- Minimum–Maksimum: {st['min']:.2f} – {st['max']:.2f}")
     else:
-        doc.add_paragraph("Statistik distribusi tidak tersedia (data indeks tidak ditemukan).")
+        doc.add_paragraph("Statistik tidak tersedia.")
 
-    doc.add_heading("2. Ringkasan Agregat per Jenis Perpustakaan", level=2)
+    doc.add_heading("2. Agregat per Jenis Perpustakaan", 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
+        t = doc.add_table(rows=1, cols=len(agg_df.columns))
         for i, c in enumerate(agg_df.columns):
-            hdr[i].text = str(c)
-        for _, row in agg_df.iterrows():
-            r = table.add_row().cells
+            t.rows[0].cells[i].text = str(c)
+        for _, r in agg_df.iterrows():
+            row = t.add_row().cells
             for i, c in enumerate(agg_df.columns):
-                r[i].text = str(row[c])
+                row[i].text = str(r[c])
     else:
-        doc.add_paragraph("Tabel agregat tidak tersedia.")
+        doc.add_paragraph("Agregat tidak tersedia.")
 
-    doc.add_heading("3. Verifikasi Coverage & GAP menuju 68% (Kontrol Mutu)", level=2)
+    doc.add_heading("3. Verifikasi Coverage (Kontrol Mutu)", level=2)
     if verif_df is not None and not verif_df.empty:
         v = verif_df.copy()
-
-        # BULATKAN TANPA KOMa: semua numerik -> integer
         for c in v.columns:
             if pd.api.types.is_numeric_dtype(v[c]):
-                v[c] = pd.to_numeric(v[c], errors="coerce").fillna(0).round(0).astype(int)
-
-        table = doc.add_table(rows=1, cols=len(v.columns))
-        hdr = table.rows[0].cells
+                v[c] = pd.to_numeric(v[c], errors="coerce").fillna(0).round(0).astype(int)  # TANPA KOMA
+        t = doc.add_table(rows=1, cols=len(v.columns))
         for i, c in enumerate(v.columns):
-            hdr[i].text = str(c)
-        for _, row in v.iterrows():
-            r = table.add_row().cells
+            t.rows[0].cells[i].text = str(c)
+        for _, r in v.iterrows():
+            row = t.add_row().cells
             for i, c in enumerate(v.columns):
-                r[i].text = str(row[c])
+                row[i].text = str(r[c])
     else:
-        doc.add_paragraph("Tidak ada tabel verifikasi coverage untuk wilayah ini.")
+        doc.add_paragraph("Tidak ada tabel verifikasi untuk wilayah ini.")
 
-    doc.add_heading("4. Analisis Naratif Otomatis (LLM Data Analytics)", level=2)
-    for paragraph in str(analytics_text).split("\n"):
-        if paragraph.strip():
-            doc.add_paragraph(paragraph.strip())
+    doc.add_heading("4. Analisis Naratif Otomatis (LLM)", level=2)
+    for p in str(analysis_text).split("\n"):
+        if p.strip():
+            doc.add_paragraph(p.strip())
 
     outpath = tempfile.mktemp(suffix=".docx")
     doc.save(outpath)
     return outpath
 
+
 # ============================================================
-# 8) OUTPUT TABEL: AGREGAT RINGKAS + DETAIL RINGKAS
+# 10) CORE PIPELINE VIEW: AGREGAT + DETAIL + FILES + BELL CURVE
 # ============================================================
 
-def build_agg_ringkas(df2: pd.DataFrame) -> pd.DataFrame:
-    label_map = {"sekolah":"Perpustakaan Sekolah","umum":"Perpustakaan Umum","khusus":"Perpustakaan Khusus"}
+def build_views_and_files(df_filtered_final: pd.DataFrame, wilayah: str, kew: str):
+    if df_filtered_final is None or df_filtered_final.empty:
+        return (pd.DataFrame(), pd.DataFrame(), None, None, None, None, None, None, None)
+
+    # DETAIL FULL (untuk analitik + Word)
+    # tampilkan final saja
+    keep_detail = []
+    if prov_col and prov_col in df_filtered_final.columns:
+        keep_detail.append(prov_col)
+    if kab_col and kab_col in df_filtered_final.columns:
+        keep_detail.append(kab_col)
+    if nama_col and nama_col in df_filtered_final.columns:
+        keep_detail.append(nama_col)
+
+    keep_detail += [
+        "_dataset",
+        "sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan",
+        "dim_kepatuhan","dim_kinerja",
+        "Indeks_Final_0_100",
+    ]
+    keep_detail = [c for c in keep_detail if c in df_filtered_final.columns]
+    detail_full = df_filtered_final[keep_detail].copy()
+
+    # DETAIL VIEW UI: integer, tanpa koma
+    detail_view = detail_full.copy()
+    for c in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja"]:
+        if c in detail_view.columns:
+            detail_view[c] = (detail_view[c].fillna(0.0) * 100).round(0).astype(int)  # 0–100
+    if "Indeks_Final_0_100" in detail_view.columns:
+        detail_view["Indeks_Final_0_100"] = pd.to_numeric(detail_view["Indeks_Final_0_100"], errors="coerce").fillna(0).round(0).astype(int)
+
+    # AGREGAT: rata-rata sub/dim (pakai skala 0–100 untuk mudah dibaca) + indeks final
     rows = []
-
-    def summarize(sub, jenis_label):
-        row = {
-            "Jenis": jenis_label,
-            "Jumlah": int(len(sub)),
-            "Rata2_sub_koleksi": float(sub["sub_koleksi"].mean()) if len(sub) else 0.0,
-            "Rata2_sub_sdm": float(sub["sub_sdm"].mean()) if len(sub) else 0.0,
-            "Rata2_sub_pelayanan": float(sub["sub_pelayanan"].mean()) if len(sub) else 0.0,
-            "Rata2_sub_pengelolaan": float(sub["sub_pengelolaan"].mean()) if len(sub) else 0.0,
-            "Rata2_dim_kepatuhan": float(sub["dim_kepatuhan"].mean()) if len(sub) else 0.0,
-            "Rata2_dim_kinerja": float(sub["dim_kinerja"].mean()) if len(sub) else 0.0,
-            "Rata2_Indeks_Final_0_100": float(sub["Indeks_Final_0_100"].mean()) if len(sub) else 0.0,
-        }
-        return row
-
+    label_map = {"sekolah":"Perpustakaan Sekolah","umum":"Perpustakaan Umum","khusus":"Perpustakaan Khusus"}
     for ds in ["sekolah","umum","khusus"]:
-        sub = df2[df2["_dataset"] == ds] if "_dataset" in df2.columns else df2.iloc[0:0]
-        rows.append(summarize(sub, label_map.get(ds, ds)))
-
-    rows.append(summarize(df2, "Rata-rata keseluruhan"))
-    return pd.DataFrame(rows).round(4)
-
-def build_detail_ringkas(df2: pd.DataFrame, nama_col: str):
-    cols = ["PROV_DISP","KAB_DISP"]
-    if nama_col and nama_col in df2.columns:
-        cols.append(nama_col)
-    cols += ["KEW_NORM","_dataset",
-             "sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan",
-             "dim_kepatuhan","dim_kinerja",
-             "Indeks_Final_0_100"]
-    cols = [c for c in cols if c in df2.columns]
-    return df2[cols].copy().round(4)
-
-# ============================================================
-# 9) PIPELINE FILTERED (DEDUP) + EXPORT + BELL CURVE
-# ============================================================
-
-def run_pipeline_filtered(prov_value, kab_value, kew_value):
-    if df_all is None or df_all.empty:
-        return (pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
-                None, None, None,
-                go.Figure(), go.Figure(), go.Figure(), go.Figure(),
-                "Data DM belum siap.")
-
-    df = df_all.copy()
-
-    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]
+        dsub = df_filtered_final[df_filtered_final["_dataset"] == ds].copy() if "_dataset" in df_filtered_final.columns else df_filtered_final.copy()
+        if dsub.empty:
+            rows.append({
+                "Jenis Perpustakaan": label_map.get(ds, ds),
+                "Jumlah Perpustakaan": 0,
+                "Sub_Koleksi(0-100)": 0,
+                "Sub_SDM(0-100)": 0,
+                "Sub_Pelayanan(0-100)": 0,
+                "Sub_Pengelolaan(0-100)": 0,
+                "Dim_Kepatuhan(0-100)": 0,
+                "Dim_Kinerja(0-100)": 0,
+                "Indeks_FINAL(0-100)": 0,
+            })
+        else:
+            rows.append({
+                "Jenis Perpustakaan": label_map.get(ds, ds),
+                "Jumlah Perpustakaan": int(len(dsub)),
+                "Sub_Koleksi(0-100)": int(round(100*dsub["sub_koleksi"].mean(skipna=True))) if "sub_koleksi" in dsub.columns else 0,
+                "Sub_SDM(0-100)": int(round(100*dsub["sub_sdm"].mean(skipna=True))) if "sub_sdm" in dsub.columns else 0,
+                "Sub_Pelayanan(0-100)": int(round(100*dsub["sub_pelayanan"].mean(skipna=True))) if "sub_pelayanan" in dsub.columns else 0,
+                "Sub_Pengelolaan(0-100)": int(round(100*dsub["sub_pengelolaan"].mean(skipna=True))) if "sub_pengelolaan" in dsub.columns else 0,
+                "Dim_Kepatuhan(0-100)": int(round(100*dsub["dim_kepatuhan"].mean(skipna=True))) if "dim_kepatuhan" in dsub.columns else 0,
+                "Dim_Kinerja(0-100)": int(round(100*dsub["dim_kinerja"].mean(skipna=True))) if "dim_kinerja" in dsub.columns else 0,
+                "Indeks_FINAL(0-100)": int(round(dsub["Indeks_Final_0_100"].mean(skipna=True))) if "Indeks_Final_0_100" in dsub.columns else 0,
+            })
 
-    if df.empty:
-        return (pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
-                None, None, None,
-                go.Figure(), go.Figure(), go.Figure(), go.Figure(),
-                "Tidak ada data untuk kombinasi filter.")
-
-    df2, verif_df = compute_final(df, kew_value)
-
-    # DEDUP kunci (prov,kab,nama,kew,dataset)
-    kcols = [c for c in ["PROV_DISP","KAB_DISP","KEW_NORM","_dataset"] if c in df2.columns]
-    if nama_col and nama_col in df2.columns:
-        kcols.append(nama_col)
-    if kcols:
-        df2 = df2.drop_duplicates(subset=kcols, keep="first").copy()
-
-    agg_df = build_agg_ringkas(df2)
-    detail_df = build_detail_ringkas(df2, nama_col)
-
-    # Bell curves (FINAL)
-    ncol = nama_col if (nama_col and nama_col in df2.columns) else None
-    fig_all = make_bell_figure(df2, "Bell Curve Indeks FINAL — Semua Perpustakaan", name_col=ncol, min_points=5)
-    fig_sek = make_bell_figure(df2[df2["_dataset"]=="sekolah"], "Bell Curve Indeks FINAL — Perpustakaan Sekolah", name_col=ncol, min_points=3)
-    fig_um  = make_bell_figure(df2[df2["_dataset"]=="umum"], "Bell Curve Indeks FINAL — Perpustakaan Umum", name_col=ncol, min_points=3)
-    fig_kh  = make_bell_figure(df2[df2["_dataset"]=="khusus"], "Bell Curve Indeks FINAL — Perpustakaan Khusus", name_col=ncol, min_points=3)
+    agg_df = pd.DataFrame(rows)
 
+    # FILES
     tmpdir = tempfile.mkdtemp()
-    wilayah = kab_value if kab_value and kab_value != "(Semua)" else (prov_value if prov_value and prov_value != "(Semua)" else "NASIONAL")
-    slug = slugify(wilayah) + "_" + slugify(kew_value)
-    agg_path = os.path.join(tmpdir, f"IPLM_Agregat_RINGKAS_{slug}.xlsx")
-    detail_path = os.path.join(tmpdir, f"IPLM_Detail_RINGKAS_{slug}.xlsx")
-    verif_path = os.path.join(tmpdir, f"IPLM_VerifikasiCoverage_{slug}.xlsx")
+    agg_path = os.path.join(tmpdir, f"IPLM_FINAL_Agregat_{slugify(wilayah)}_{slugify(kew)}.xlsx")
+    detail_path = os.path.join(tmpdir, f"IPLM_FINAL_Detail_{slugify(wilayah)}_{slugify(kew)}.xlsx")
+    raw_path = os.path.join(tmpdir, f"IPLM_FINAL_Raw_{slugify(wilayah)}_{slugify(kew)}.xlsx")
 
     agg_df.to_excel(agg_path, index=False)
-    detail_df.to_excel(detail_path, index=False)
-    (verif_df if verif_df is not None else pd.DataFrame()).to_excel(verif_path, index=False)
+    detail_view.to_excel(detail_path, index=False)
+    df_filtered_final.to_excel(raw_path, index=False)
+
+    # Bell curve pakai Indeks_Final_0_100
+    hover_name = nama_col if (nama_col and nama_col in detail_full.columns) else None
 
-    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, verif_path, fig_all, fig_sek, fig_um, fig_kh, msg
+    fig_all = make_bell_figure(detail_view, "Bell Curve Indeks FINAL – Semua Perpustakaan", "Indeks_Final_0_100", hover_name)
+    fig_sek = make_bell_figure(detail_view[detail_view["_dataset"]=="sekolah"], "Bell Curve Indeks FINAL – Perpustakaan Sekolah", "Indeks_Final_0_100", hover_name)
+    fig_um  = make_bell_figure(detail_view[detail_view["_dataset"]=="umum"], "Bell Curve Indeks FINAL – Perpustakaan Umum", "Indeks_Final_0_100", hover_name)
+    fig_kh  = make_bell_figure(detail_view[detail_view["_dataset"]=="khusus"], "Bell Curve Indeks FINAL – Perpustakaan Khusus", "Indeks_Final_0_100", hover_name)
 
+    return agg_df, detail_view, agg_path, detail_path, raw_path, detail_full, fig_all, fig_sek, fig_um, fig_kh
 
-#===========================================================
-# 9b. WRAPPER: PAKAI LLM DATA ANALYTICS + WORD (tanpa ubah run_app lama)
+
+# ============================================================
+# 11) RUN APP
 # ============================================================
 
-if "run_app" in globals():
-    _run_app_base = run_app  # simpan fungsi asli
 def run_app(prov_value, kab_value, kew_value):
-    # jalankan versi asli dulu
-    (
-        agg_df,
-        detail_df_view,
-        verif_df,
-        agg_path,
-        detail_path,
-        raw_path,
-        word_path,
-        fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
-        msg,
-        analysis_text,
-    ) = _run_app_base(prov_value, kab_value, kew_value)
-
-    # kalau kosong, langsung return
-    if detail_df_view is None or (hasattr(detail_df_view, "empty") and detail_df_view.empty):
+    if df_all is None or df_all.empty:
+        empty = pd.DataFrame()
         return (
-            agg_df, detail_df_view, verif_df,
-            agg_path, detail_path, raw_path,
-            word_path,
-            fig_all, fig_sekolah, fig_umum, fig_khusus,
-            msg,
-            analysis_text
+            empty, empty, empty,
+            None, None, None, None,
+            None, None, None, None,
+            "Data belum siap.",
+            "Analisis belum tersedia."
         )
 
-    # BUTUH detail_df LENGKAP (bukan view) agar punya _dataset + indeks final kalau ada
-    # Ambil ulang subset yang sama dari df_all_ipml (supaya lengkap) dengan filter yang sama
-    df = df_all_ipml.copy() if df_all_ipml is not None else None
-    if df is None or df.empty:
-        return (
-            agg_df, detail_df_view, verif_df,
-            agg_path, detail_path, raw_path,
-            word_path,
-            fig_all, fig_sekolah, fig_umum, fig_khusus,
-            msg,
-            analysis_text
-        )
+    df = df_all.copy()
 
-    if prov_col_glob and prov_value and prov_value != "(Semua)":
-        df = df[df[prov_col_glob].astype(str).str.strip() == prov_value]
-    if kab_col_glob and kab_value and kab_value != "(Semua)":
-        df = df[df[kab_col_glob].astype(str).str.strip() == kab_value]
+    # 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]
     if kew_value and kew_value != "(Semua)":
         df = df[df["KEW_NORM"] == kew_value]
 
-    if df is None or df.empty:
+    if df.empty:
+        empty = pd.DataFrame()
         return (
-            agg_df, detail_df_view, verif_df,
-            agg_path, detail_path, raw_path,
-            word_path,
-            fig_all, fig_sekolah, fig_umum, fig_khusus,
-            msg,
-            analysis_text
+            empty, empty, empty,
+            None, None, None, None,
+            None, None, None, None,
+            "Tidak ada data untuk filter ini.",
+            "Analisis belum tersedia."
         )
 
-    kab_name = kab_value if kab_value and kab_value != "(Semua)" else "SEMUA KAB/KOTA"
-    kew_name = kew_value if kew_value and kew_value != "(Semua)" else "SEMUA KEWENANGAN"
+    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"
 
-    # Bikin ulang detail_df LENGKAP memakai run_pipeline_core supaya konsisten
-    (agg_df2, detail_df_full, *_rest) = run_pipeline_core(df, kab_name=kab_name, kew_name=kew_name)
+    # Apply penalty -> FINAL
+    df_final = apply_penalty_and_final(df, kew_value)
 
-    # LLM data analytics text (lebih data-driven)
-    analytics_text = generate_llm_data_analytics(
-        detail_df=detail_df_full,
-        agg_df=agg_df2 if (agg_df2 is not None and not agg_df2.empty) else agg_df,
-        verif_df=verif_df,
-        kab_name=kab_name,
-        kew_value=kew_value,
-    )
+    # Views + files + figs
+    agg_df, detail_view, agg_path, detail_path, raw_path, detail_full, fig_all, fig_sek, fig_um, fig_kh = build_views_and_files(df_final, wilayah, kew)
 
-    # Word report pakai analytics_text (LLM)
-    word_path2 = generate_word_report_llm_analytics(
-        detail_df_full,
-        (agg_df2 if (agg_df2 is not None and not agg_df2.empty) else agg_df),
-        verif_df,
-        prov_value, kab_value, kew_value,
-        analytics_text
-    )
+    # Verification (untuk Word)
+    verif_df = compute_verification_table(df_final, kew_value)
+
+    # LLM analytics
+    analysis_text = generate_llm_analytics(detail_full, agg_df, verif_df, wilayah, kew)
+
+    # Word
+    word_path = build_word_report(detail_full, agg_df, verif_df, wilayah, kew, analysis_text)
+
+    msg = f"✅ Berhasil dihitung: {len(detail_view)} perpustakaan | Output dibulatkan (tanpa koma)."
 
-    # Kembalikan output yang sama seperti run_app asli
     return (
         agg_df,
-        detail_df_view,
-        verif_df,
+        detail_view,
+        verif_df,      # verif tetap ditampilkan (kalau kamu mau sembunyiin di UI, tinggal remove komponen UI-nya)
         agg_path,
         detail_path,
         raw_path,
-        (word_path2 or word_path),
+        word_path,
         fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
+        fig_sek,
+        fig_um,
+        fig_kh,
         msg,
-        analytics_text  # replace analysis_out dengan versi data analytics
+        analysis_text,
     )
 
-# ============================================================
-# 10) DROPDOWN (NO DUPLICATE)
-# ============================================================
-
-def all_prov_choices():
-    if df_all_raw is None or "PROV_DISP" not in df_all_raw.columns:
-        return ["(Semua)"]
-    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_DISP" not in df_all_raw.columns:
-        return ["(Semua)"]
-    tmp = df_all_raw.copy()
-    if prov_value and prov_value != "(Semua)":
-        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 or "KEW_NORM" not in df_all_raw.columns:
-        return ["(Semua)"]
-    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()
-kab_choices = get_kab_choices_for_prov(prov_choices[0] if prov_choices else "(Semua)")
-kew_choices = all_kew_choices()
-default_kew = "KAB/KOTA" if "KAB/KOTA" in kew_choices else (kew_choices[1] if len(kew_choices) > 1 else "(Semua)")
 
 def on_prov_change(prov_value):
-    new_choices = get_kab_choices_for_prov(prov_value)
-    return gr.update(choices=new_choices, value="(Semua)")
+    return gr.update(choices=get_kab_choices_for_prov(prov_value), value="(Semua)")
+
 
 # ============================================================
-# 11) UI
+# 12) UI GRADIO
 # ============================================================
 
 with gr.Blocks() as demo:
     gr.Markdown(
         f"""
-# IPLM 2025 — Output Ringkas (Sub-dimensi + Dimensi + FINAL saja)
-**Final** sudah termasuk sanksi coverage 68% (internal).
-Verifikasi ditampilkan dalam integer (tanpa koma) agar bersih.
+# IPLM 2025 (FINAL) — Indeks FINAL + Penalti Coverage 68% + Bell Curve + Word (LLM)
+
+Sumber data:
+- **{DATA_FILE}**
+- **{POP_KAB_FILE}** (populasi Kab/Kota)
+- **{POP_PROV_FILE}** (populasi Provinsi)
 
 {DATA_INFO}
+
+Catatan:
+- Penalti coverage 68% diterapkan untuk **Sekolah & Umum**.
+- **Khusus tidak dikenai penalti** (bobot=1).
+- Output tabel dibulatkan **tanpa angka koma**.
 """
     )
 
     with gr.Row():
         dd_prov = gr.Dropdown(label="Provinsi", choices=prov_choices, value=prov_choices[0])
-        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=kab_choices, value="(Semua)")
+        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=kab_choices, value=kab_choices[0])
         dd_kew  = gr.Dropdown(label="Kewenangan", choices=kew_choices, value=default_kew)
 
     dd_prov.change(fn=on_prov_change, inputs=dd_prov, outputs=dd_kab)
@@ -1069,35 +1070,54 @@ Verifikasi ditampilkan dalam integer (tanpa koma) agar bersih.
     run_btn = gr.Button("Jalankan Perhitungan")
     msg_out = gr.Markdown()
 
-    gr.Markdown("## Agregat (ringkas)")
-    agg_out = gr.DataFrame(interactive=False)
+    gr.Markdown("## Agregat (Sub/Dimensi + Indeks FINAL)")
+    agg_df_out = gr.DataFrame(interactive=False)
+
+    gr.Markdown("## Detail (Sub/Dimensi + Indeks FINAL)")
+    detail_df_out = gr.DataFrame(interactive=False)
+
+    gr.Markdown("## Verifikasi Coverage (Kontrol Mutu)")
+    verif_df_out = gr.DataFrame(interactive=False)
+
+    gr.Markdown("## Bell Curve Indeks FINAL — Semua")
+    bell_all_out = gr.Plot()
 
-    gr.Markdown("## Detail (ringkas)")
-    detail_out = gr.DataFrame(interactive=False)
+    gr.Markdown("## Bell Curve Indeks FINAL — Sekolah")
+    bell_sekolah_out = gr.Plot()
 
-    gr.Markdown("## Verifikasi Coverage & GAP menuju 68% (kontrol mutu) — tanpa koma")
-    verif_out = gr.DataFrame(interactive=False)
+    gr.Markdown("## Bell Curve Indeks FINAL — Umum")
+    bell_umum_out = gr.Plot()
 
-    gr.Markdown("## Bell Curve Indeks FINAL — Semua Perpustakaan")
-    bell_all = gr.Plot()
+    gr.Markdown("## Bell Curve Indeks FINAL — Khusus")
+    bell_khusus_out = gr.Plot()
 
-    gr.Markdown("## Bell Curve Indeks FINAL — Per Jenis Perpustakaan")
-    bell_sek = gr.Plot()
-    bell_um  = gr.Plot()
-    bell_kh  = gr.Plot()
+    gr.Markdown("## Analisis Otomatis (LLM)")
+    analysis_out = gr.Markdown()
 
     with gr.Row():
-        agg_file = gr.File(label="Download Agregat Ringkas (.xlsx)")
-        detail_file = gr.File(label="Download Detail Ringkas (.xlsx)")
-        verif_file = gr.File(label="Download Verifikasi Coverage (.xlsx)")
+        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 (.xlsx)")
+        word_file_out   = gr.File(label="Download Analisis Word (LLM) (.docx)")
 
     run_btn.click(
-        fn=run_pipeline_filtered,
+        fn=run_app,
         inputs=[dd_prov, dd_kab, dd_kew],
-        outputs=[agg_out, detail_out, verif_out,
-                 agg_file, detail_file, verif_file,
-                 bell_all, bell_sek, bell_um, bell_kh,
-                 msg_out],
+        outputs=[
+            agg_df_out,
+            detail_df_out,
+            verif_df_out,
+            agg_file_out,
+            detail_file_out,
+            raw_file_out,
+            word_file_out,
+            bell_all_out,
+            bell_sekolah_out,
+            bell_umum_out,
+            bell_khusus_out,
+            msg_out,
+            analysis_out,
+        ],
     )
 
 demo.launch()