Update app.py

app.py

@@ -1,5 +1,19 @@
+# -*- coding: utf-8 -*-
+"""
+app.py — IPLM 2025 (Merged)
+- Pipeline nasional (transformasi & normalisasi sekali secara nasional)
+- RealScore + Normatif + Confidence
+- Penalti sampling 68% (RULE FINAL):
+    * KAB/KOTA: sekolah penalti vs SD+SMP; umum penalti vs (kec+desa/kel); khusus tidak penalti
+    * PROVINSI: sekolah menengah penalti vs (SMA+SMK+SLB); umum & khusus tidak penalti
+- Verifikasi sampel (Kab/Kota & Provinsi) -> target 68%, kurang menuju 68%, sampling factor
+- Analisis Otomatis (LLM + rule-based fallback)
+- Download Excel (agregat, detail, raw subset) + Word report (jika python-docx tersedia)
+"""
+
 import os
 import re
+import math
 import tempfile
 from pathlib import Path
 
@@ -14,10 +28,12 @@ from sklearn.preprocessing import PowerTransformer
 # 1. KONFIGURASI FILE & PARAMETER
 # ============================================================
 
-DATA_FILE       = "DM.xlsx" # data utama perpustakaan
-META_KAB_FILE   = "jumlahdesa_fixed.xlsx"         # kecamatan & desa/kel per kab/kota
-META_SDSMP_FILE = "jumlah_SD_SMP.xlsx"            # jumlah SD & SMP per kab/kota
-META_SMA_FILE   = "Data_SMA_propinsi_update.xlsx" # jumlah SMA per provinsi
+DATA_FILE         = "DM_001.xlsx"
+META_KAB_FILE     = "jumlahdesa_fixed.xlsx"      # kecamatan & desa/kel per kab/kota
+META_SDSMP_FILE   = "jumlah_SD_SMP.xlsx"         # jumlah SD & SMP per kab/kota
+META_MENENGAH_FILE= "SMA (2).xlsx"               # kab/kota: PROVINSI + (SMA, SMK, SLB)  <-- sesuai file Anda terbaru
+
+TARGET_FRAC = 0.68
 
 # Kelompok indikator IPLM
 koleksi_cols = [
@@ -42,16 +58,15 @@ pengelolaan_cols = [
 ]
 all_indicators = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
 
-# Bobot indeks IPLM
+# Bobot indeks IPLM (rumus awal)
 w_kepatuhan = 0.30
 w_kinerja   = 0.70
 
 # Bobot untuk Confidence
 W_DATA   = 0.7
 W_SAMPLE = 0.3
-SAMPLE_THRESHOLD = 10   # ambang jumlah perpus per kab/kota
 
-# Target normatif per jenis perpustakaan
+# Target normatif per jenis perpustakaan (tetap dihitung, tapi disembunyikan di UI)
 TARGETS = {
     "sekolah": {
         "JudulTercetak": 1000,
@@ -80,29 +95,19 @@ TARGETS = {
 # ============================================================
 
 USE_LLM = True
-
-# Pilih salah satu model yang kompatibel
 LLM_MODEL_NAME = "meta-llama/Meta-Llama-3-8B-Instruct"
-# LLM_MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.2"
 
 HF_TOKEN = (
     os.getenv("HF_TOKEN")
     or os.getenv("HUGGINGFACEHUB_API_TOKEN")
     or os.getenv("HF_API_TOKEN")
 )
-
 _HF_CLIENT = None
 
-
 def get_llm_client():
-    """
-    Inisialisasi InferenceClient sekali, lalu dipakai ulang.
-    Kalau gagal (misal token salah / model tidak support), kembalikan None.
-    """
     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)
@@ -113,14 +118,23 @@ def get_llm_client():
         _HF_CLIENT = None
         return None
 
-
 # ============================================================
-# 2. FUNGSI UTIL
+# 2. UTIL
 # ============================================================
 
 def _canon(s: str) -> str:
     return re.sub(r"[^a-z0-9]+", "", str(s).lower())
 
+def pick_col(df, candidates):
+    for c in candidates:
+        if c in df.columns:
+            return c
+    can_map = {_canon(c): c for c in df.columns}
+    for c in candidates:
+        k = _canon(c)
+        if k in can_map:
+            return can_map[k]
+    return None
 
 def coerce_num(val):
     if pd.isna(val):
@@ -143,7 +157,6 @@ 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)
@@ -151,24 +164,6 @@ def minmax_norm(s: pd.Series) -> pd.Series:
         return pd.Series(0.0, index=s.index)
     return (x - mn) / (mx - mn)
 
-
-def pick_col(df, candidates):
-    """
-    Pilih kolom dari daftar kandidat dengan:
-    1) Cocok nama persis dulu
-    2) Kalau tidak ada, pakai versi canonical (_canon)
-    """
-    for c in candidates:
-        if c in df.columns:
-            return c
-    can_map = {_canon(c): c for c in df.columns}
-    for c in candidates:
-        k = _canon(c)
-        if k in can_map:
-            return can_map[k]
-    return None
-
-
 def norm_kew(v):
     if pd.isna(v):
         return None
@@ -181,34 +176,12 @@ def norm_kew(v):
         return "PUSAT"
     return t
 
-
 def _norm_text(x):
     if pd.isna(x):
         return None
     t = str(x).strip().upper()
     return " ".join(t.split())
 
-
-def penalized_mean(row, cols):
-    vals = []
-    for c in cols:
-        colname = f"norm_{c}"
-        if colname in row.index:
-            v = row[colname]
-            if pd.isna(v):
-                v = 0.0
-            vals.append(v)
-    if not vals:
-        return np.nan
-    return float(np.sum(vals) / len(vals))
-
-
-def skor_normatif(value, target):
-    if pd.isna(value):
-        return 0.0
-    return min(float(value) / target, 1.0)
-
-
 def slugify(s: str) -> str:
     if s is None:
         return "NA"
@@ -217,60 +190,72 @@ def slugify(s: str) -> str:
         return "NA"
     return _canon(t).upper()
 
-
-def norm_prov_label(s):
-    """
-    Normalisasi nama provinsi agar konsisten di semua file:
-    - Hilangkan kata 'PROVINSI' / 'PROPINSI'
-    - Hilangkan spasi ganda & non-alnum
-    - Uppercase
-    """
+def norm_prov_key(s):
     if pd.isna(s):
         return None
-    t = str(s).upper()
-    for bad in ["PROVINSI", "PROPINSI"]:
-        t = t.replace(bad, "")
+    t = str(s).upper().strip()
     t = " ".join(t.split())
+    t = re.sub(r"^PROVINSI\s+", "", t)
     return re.sub(r"[^A-Z0-9]+", "", t)
 
-
-def norm_kab_label(s):
-    """
-    Normalisasi nama Kab/Kota tapi tetap membedakan:
-    - 'Kabupaten Bandung' -> 'KABBANDUNG'
-    - 'Kota Bandung'      -> 'KOTABANDUNG'
-    Dipakai untuk:
-    - DM.xlsx
-    - jumlahdesa_fixed.xlsx
-    - jumlah_SD_SMP.xlsx
-    """
+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("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_mean_row(row, cols):
+    vals = []
+    for c in cols:
+        if c in row.index:
+            v = row[c]
+            if pd.notna(v):
+                vals.append(float(v))
+    return float(np.mean(vals)) if vals else np.nan
+
+def penalized_mean_norm(row, cols):
+    # mean dari norm_* dengan missing dianggap 0 (sesuai gaya app lama Anda)
+    vals = []
+    for c in cols:
+        colname = f"norm_{c}"
+        if colname in row.index:
+            v = row[colname]
+            if pd.isna(v):
+                v = 0.0
+            vals.append(float(v))
+    if not vals:
+        return np.nan
+    return float(np.sum(vals) / len(vals))
+
+def skor_normatif(value, target):
+    if pd.isna(value):
+        return 0.0
+    return min(float(value) / float(target), 1.0)
+
+def samp_factor(sample, target):
+    # target 68% optimum=1. di atas itu tetap 1.
+    if pd.isna(target) or target <= 0:
+        return 1.0
+    if pd.isna(sample) or sample < 0:
+        sample = 0
+    return float(min(sample / target, 1.0))
 
 # ============================================================
-# 3. LOAD DATA DM.xlsx + META
+# 3) LOAD DATA DM (multi-sheet) + META
 # ============================================================
 
 DATA_INFO = ""
 df_all_raw = None
-meta_kab_df = None
-meta_sma_df = None
+
+meta_kab_df = None          # kab_key + kec/desa + SD/SMP + targets
+meta_menengah_prov = None   # prov_key + SMA/SMK/SLB totals + target menengah
 
 prov_col_glob = kab_col_glob = kew_col_glob = jenis_col_glob = nama_col_glob = None
 
+# --- Load DM ---
 try:
     fp = Path(DATA_FILE)
     if not fp.exists():
@@ -291,6 +276,7 @@ try:
     else:
         df_all_raw["KEW_NORM"] = None
 
+    # dataset mapping
     val_map_jenis = {
         "PERPUSTAKAAN SEKOLAH": "sekolah",
         "SEKOLAH": "sekolah",
@@ -305,70 +291,46 @@ try:
     else:
         df_all_raw["_dataset"] = None
 
-    def all_prov_choices():
-        if prov_col_glob is None:
-            return ["(Semua)"]
-        s = df_all_raw[prov_col_glob].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 kab_col_glob is None:
-            return ["(Semua)"]
-        if prov_value is None or prov_value == "(Semua)" or prov_col_glob is None:
-            s = df_all_raw[kab_col_glob].dropna().astype(str).str.strip()
-        else:
-            m = df_all_raw[prov_col_glob].astype(str).str.strip() == prov_value
-            s = df_all_raw.loc[m, kab_col_glob].dropna().astype(str).str.strip()
-        vals = sorted([x for x in s.unique() if x != ""])
-        return ["(Semua)"] + vals
-
-    def all_kew_choices():
-        s = df_all_raw["KEW_NORM"].dropna().astype(str).str.strip()
-        vals = sorted([o for o in s.unique() if o != ""])
-        if not vals:
-            return ["(Semua)"]
-        return ["(Semua)"] + vals
-
-    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]
-
-    DATA_INFO = f"Data terbaca dari: **{DATA_FILE}** | Jumlah baris: **{len(df_all_raw)}**"
+    # keys
+    if kab_col_glob:
+        df_all_raw["kab_key"] = df_all_raw[kab_col_glob].apply(norm_kab_key)
+    else:
+        df_all_raw["kab_key"] = None
+    if prov_col_glob:
+        df_all_raw["prov_key"] = df_all_raw[prov_col_glob].apply(norm_prov_key)
+    else:
+        df_all_raw["prov_key"] = None
+
+    DATA_INFO = f"Data terbaca dari: **{DATA_FILE}** | Jumlah baris: **{len(df_all_raw)}** | Sheets: **{len(xls.sheet_names)}**"
 except Exception as e:
     df_all_raw = None
-    prov_choices = kab_choices = kew_choices = ["(Semua)"]
-    default_kew = "(Semua)"
     DATA_INFO = f"⚠️ Gagal memuat data dari file: `{DATA_FILE}`\n\nError: `{e}`"
 
-# 3b. META KECAMATAN/DESA + SD/SMP + SMA
+# --- META Kab: kec/desa + SD/SMP -> targets 68% ---
 extra_info = []
-
-# --- jumlah kecamatan & desa/kel per kab/kota ---
 try:
     meta_kab_raw = pd.read_excel(META_KAB_FILE)
     col_kab = pick_col(meta_kab_raw, ["Kab/Kota", "Kab_Kota", "kab/kota", "kabupaten_kota"])
-    col_kec = pick_col(meta_kab_raw, ["Kecamatan", "jml_kecamatan", "jumlah_kecamatan"])
-    col_des = pick_col(meta_kab_raw, ["Desa/Kel", "Desa Kelurahan", "Desa", "Desa_kel"])
-
-    if col_kab and col_kec and col_des:
-        meta_kab_df = pd.DataFrame({
-            "Kab_Kota_Label": meta_kab_raw[col_kab].astype(str).str.strip(),
-            "Jml_Kecamatan":  meta_kab_raw[col_kec].apply(coerce_num),
-            "Jml_DesaKel":    meta_kab_raw[col_des].apply(coerce_num),
-        })
-        meta_kab_df["kab_key"] = meta_kab_df["Kab_Kota_Label"].apply(norm_kab_label)
-        extra_info.append(f"Verifikasi Kab/Kota (Kec/Desa) dari **{META_KAB_FILE}** (n={len(meta_kab_df)})")
-    else:
-        meta_kab_df = None
-        extra_info.append(f"Verifikasi Kab/Kota: kolom kunci tidak lengkap di `{META_KAB_FILE}`")
-except Exception as e:
-    meta_kab_df = None
-    extra_info.append(f"⚠️ Gagal memuat `{META_KAB_FILE}` ({e})")
+    col_kec = pick_col(meta_kab_raw, ["Kecamatan", "jml_kecamatan", "jumlah_kecamatan", "Jml_Kecamatan", "Jumlah Kecamatan"])
+    col_des = pick_col(meta_kab_raw, ["Desa/Kel", "Desa Kelurahan", "Desa_kel", "Jml_DesaKel", "Jumlah Desa/Kel", "Jumlah Desa Kelurahan"])
+
+    if col_kab is None:
+        raise ValueError("Kolom Kab/Kota tidak ditemukan di META_KAB_FILE.")
+
+    meta_desa = pd.DataFrame({
+        "Kab_Kota_Label": meta_kab_raw[col_kab].astype(str).str.strip(),
+        "Jml_Kecamatan": pd.to_numeric(meta_kab_raw[col_kec], errors="coerce") if col_kec else 0,
+        "Jml_DesaKel":   pd.to_numeric(meta_kab_raw[col_des], errors="coerce") if col_des else 0,
+    })
+    meta_desa["Jml_Kecamatan"] = meta_desa["Jml_Kecamatan"].fillna(0)
+    meta_desa["Jml_DesaKel"]   = meta_desa["Jml_DesaKel"].fillna(0)
+    meta_desa["kab_key"] = meta_desa["Kab_Kota_Label"].apply(norm_kab_key)
+    meta_desa = meta_desa.groupby("kab_key", as_index=False).agg({
+        "Kab_Kota_Label":"first",
+        "Jml_Kecamatan":"sum",
+        "Jml_DesaKel":"sum"
+    })
 
-# --- jumlah SD & SMP per kab/kota ---
-try:
     sd_smp_raw = pd.read_excel(META_SDSMP_FILE)
     col_kab2 = pick_col(sd_smp_raw, [
         "Kabupaten/Kota_Kabupaten/Kota", "Kabupaten/Kota",
@@ -377,113 +339,100 @@ try:
     col_sd   = pick_col(sd_smp_raw, ["SD", "Jumlah SD", "Total SD", "SD_Total", "jml_sd", "Jml_SD"])
     col_smp  = pick_col(sd_smp_raw, ["SMP", "Jumlah SMP", "Total SMP", "SMP_Total", "jml_smp", "Jml_SMP"])
 
-    if col_kab2 and (col_sd or col_smp):
-        df_sd_smp = pd.DataFrame({
-            "Kab_Kota_Label_SD": sd_smp_raw[col_kab2].astype(str).str.strip(),
-        })
-        df_sd_smp["Jml_SD"]  = sd_smp_raw[col_sd].apply(coerce_num) if col_sd else 0.0
-        df_sd_smp["Jml_SMP"] = sd_smp_raw[col_smp].apply(coerce_num) if col_smp else 0.0
+    if col_kab2 is None:
+        raise ValueError("Kolom Kab/Kota tidak ditemukan di META_SDSMP_FILE.")
+    if (col_sd is None) and (col_smp is None):
+        raise ValueError("Kolom SD/SMP tidak ditemukan di META_SDSMP_FILE.")
 
-        df_sd_smp["kab_key"] = df_sd_smp["Kab_Kota_Label_SD"].apply(norm_kab_label)
+    meta_sdsmp = pd.DataFrame({
+        "Kab_Kota_Label_SD": sd_smp_raw[col_kab2].astype(str).str.strip(),
+        "Jml_SD":  pd.to_numeric(sd_smp_raw[col_sd], errors="coerce") if col_sd else 0,
+        "Jml_SMP": pd.to_numeric(sd_smp_raw[col_smp], errors="coerce") if col_smp else 0,
+    })
+    meta_sdsmp["Jml_SD"]  = meta_sdsmp["Jml_SD"].fillna(0)
+    meta_sdsmp["Jml_SMP"] = meta_sdsmp["Jml_SMP"].fillna(0)
+    meta_sdsmp["kab_key"] = meta_sdsmp["Kab_Kota_Label_SD"].apply(norm_kab_key)
+    meta_sdsmp = meta_sdsmp.groupby("kab_key", as_index=False).agg({"Jml_SD":"sum","Jml_SMP":"sum"})
 
-        df_sd_smp_grp = df_sd_smp.groupby("kab_key", as_index=False).agg({
-            "Jml_SD": "sum",
-            "Jml_SMP": "sum",
-        })
+    meta_kab_df = meta_desa.merge(meta_sdsmp, on="kab_key", how="left")
+    meta_kab_df["Jml_SD"]  = meta_kab_df["Jml_SD"].fillna(0)
+    meta_kab_df["Jml_SMP"] = meta_kab_df["Jml_SMP"].fillna(0)
 
-        if meta_kab_df is not None:
-            meta_kab_df = meta_kab_df.merge(
-                df_sd_smp_grp,
-                on="kab_key",
-                how="left"
-            )
-        else:
-            meta_kab_df = df_sd_smp_grp.copy()
-            meta_kab_df["Kab_Kota_Label"] = df_sd_smp.groupby("kab_key")["Kab_Kota_Label_SD"].first().values
+    meta_kab_df["Pop_Sekolah_SD_SMP"] = (meta_kab_df["Jml_SD"] + meta_kab_df["Jml_SMP"]).astype(float)
+    meta_kab_df["Pop_Admin_Kec_Desa"] = (meta_kab_df["Jml_Kecamatan"] + meta_kab_df["Jml_DesaKel"]).astype(float)
 
-        extra_info.append(
-            f"Data SD/SMP per Kab/Kota dari **{META_SDSMP_FILE}** ditambahkan (n={len(df_sd_smp_grp)})"
-        )
-    else:
-        extra_info.append(f"Data SD/SMP: kolom kunci tidak lengkap di `{META_SDSMP_FILE}`")
+    meta_kab_df["Target_Sekolah_68"] = np.ceil(TARGET_FRAC * meta_kab_df["Pop_Sekolah_SD_SMP"]).astype("Int64")
+    meta_kab_df["Target_Umum_68"]    = np.ceil(TARGET_FRAC * meta_kab_df["Pop_Admin_Kec_Desa"]).astype("Int64")
+
+    extra_info.append(f"Meta Kab/Kota siap (kec/desa + SD/SMP + target 68%): n={len(meta_kab_df)}")
 except Exception as e:
-    extra_info.append(f"⚠️ Gagal memuat `{META_SDSMP_FILE}` ({e})")
+    meta_kab_df = None
+    extra_info.append(f"⚠️ Gagal memuat meta Kab/Kota/SD-SMP: {e}")
 
-# --- jumlah SMA per provinsi ---
+# --- META menengah per prov (SMA+SMK+SLB) dari file kab/kota ---
 try:
-    meta_sma_raw = pd.read_excel(META_SMA_FILE)
-
-    col_prov_sma = pick_col(meta_sma_raw, [
-        "Provinsi", "provinsi", "PROVINSI", "NAMA_PROVINSI", "Nama Provinsi",
-        "nm_prov", "nm_provinsi", "prov"
-    ])
-    # Fokus pada kolom TOTAL / Jml_SMA / SMA / Total SMA / SMA_Total
-    col_sma = pick_col(meta_sma_raw, [
-        "Total SMA", "TOTAL_SMA", "TOTAL", "total",
-        "Jml_SMA", "Jumlah SMA", "SMA", "SMA_Total",
-        "jumlah_sma", "total_sma", "jml_sma"
-    ])
-
-    if col_prov_sma is None:
-        raise ValueError("Kolom provinsi tidak ditemukan dalam file SMA.")
-    if col_sma is None:
-        raise ValueError("Kolom total jumlah SMA tidak ditemukan.")
-
-    meta_sma_df = pd.DataFrame({
-        "Provinsi_Label": meta_sma_raw[col_prov_sma].astype(str).str.strip(),
-        "Jml_SMA":        meta_sma_raw[col_sma].apply(coerce_num),
-    })
-    # Normalisasi nama provinsi agar konsisten dengan DM
-    meta_sma_df["prov_key"] = meta_sma_df["Provinsi_Label"].apply(norm_prov_label)
-    # Jika ada duplikat (misal variasi penulisan), agregasi ke total per prov_key
-    meta_sma_df = meta_sma_df.groupby(["prov_key", "Provinsi_Label"], as_index=False).agg(
-        {"Jml_SMA": "sum"}
+    fp2 = Path(META_MENENGAH_FILE)
+    if not fp2.exists():
+        raise FileNotFoundError(f"File menengah tidak ditemukan: {META_MENENGAH_FILE}")
+
+    men = pd.read_excel(fp2)
+    c_prov = pick_col(men, ["PROVINSI","Provinsi","provinsi"])
+    c_sma  = pick_col(men, ["SMA","Jumlah SMA","Total SMA","Jml_SMA","jml_sma"])
+    c_smk  = pick_col(men, ["SMK","Jumlah SMK","Total SMK","Jml_SMK","jml_smk"])
+    c_slb  = pick_col(men, ["SLB","Jumlah SLB","Total SLB","Jml_SLB","jml_slb"])
+
+    if c_prov is None or (c_sma is None and c_smk is None and c_slb is None):
+        raise ValueError("Kolom PROVINSI atau SMA/SMK/SLB tidak terdeteksi pada META_MENENGAH_FILE.")
+
+    tmp = men.copy()
+    tmp["prov_key"] = tmp[c_prov].apply(norm_prov_key)
+    tmp["SMA"] = pd.to_numeric(tmp[c_sma], errors="coerce").fillna(0) if c_sma else 0
+    tmp["SMK"] = pd.to_numeric(tmp[c_smk], errors="coerce").fillna(0) if c_smk else 0
+    tmp["SLB"] = pd.to_numeric(tmp[c_slb], errors="coerce").fillna(0) if c_slb else 0
+
+    meta_menengah_prov = tmp.groupby("prov_key", as_index=False).agg(
+        Total_SMA=("SMA","sum"),
+        Total_SMK=("SMK","sum"),
+        Total_SLB=("SLB","sum")
     )
+    meta_menengah_prov["Total_Menengah"] = meta_menengah_prov["Total_SMA"] + meta_menengah_prov["Total_SMK"] + meta_menengah_prov["Total_SLB"]
+    meta_menengah_prov["Target_Menengah_68"] = np.ceil(TARGET_FRAC * meta_menengah_prov["Total_Menengah"]).astype("Int64")
 
-    extra_info.append(f"Verifikasi SMA per Provinsi berhasil dimuat ({len(meta_sma_df)} provinsi).")
+    extra_info.append(f"Meta Prov Menengah (SMA+SMK+SLB + target 68%): n={len(meta_menengah_prov)}")
 except Exception as e:
-    meta_sma_df = None
-    extra_info.append(f"⚠️ Gagal memuat file SMA: {e}")
+    meta_menengah_prov = None
+    extra_info.append(f"⚠️ Gagal memuat meta menengah prov (SMA+SMK+SLB): {e}")
 
 if extra_info:
     DATA_INFO = DATA_INFO + "<br>" + "<br>".join(extra_info)
 
-
 # ============================================================
-# 4. BELL CURVE
+# 4) BELL CURVE (pakai indeks yang dipilih)
 # ============================================================
 
 def make_bell_figure(df_all: pd.DataFrame,
                      title: str,
-                     index_col: str = "Indeks_Real_0_100",
+                     index_col: str,
                      name_col: str = None,
                      min_points: int = 5) -> go.Figure:
-
     fig = go.Figure()
 
-    if index_col not in df_all.columns:
-        fig.update_layout(
-            title=title,
-            xaxis_title="Indeks (0–100)",
-            yaxis_title="Kepadatan (relatif)",
-        )
+    if df_all is None or df_all.empty or index_col not in df_all.columns:
+        fig.update_layout(title=title, xaxis_title="Indeks (0–100)", yaxis_title="Kepadatan (relatif)")
         return fig
 
     df_plot = df_all.copy()
     df_plot = df_plot[pd.notna(df_plot[index_col])]
-
     if df_plot.empty or len(df_plot) < 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)
-                )
-            ]
+            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)
+            )]
         )
         return fig
 
@@ -494,40 +443,24 @@ def make_bell_figure(df_all: pd.DataFrame,
     xs = np.linspace(max(0, x_vals.min() - 5), min(100, x_vals.max() + 5), 200)
     pdf = (1.0 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((xs - mu) / sigma) ** 2)
     pdf = pdf / pdf.max()
-    y_max = 1.0
 
     if name_col and name_col in df_plot.columns:
-        hover_text = [
-            f"{str(n)}<br>Indeks: {v:.2f}"
-            for n, v in zip(df_plot[name_col], x_vals)
-        ]
+        hover_text = [f"{str(n)}<br>Indeks: {v:.2f}" for n, v in zip(df_plot[name_col], x_vals)]
     else:
         hover_text = [f"Indeks: {v:.2f}" for v in x_vals]
 
+    fig.add_trace(go.Scatter(x=xs, y=pdf, mode="lines", name="Bell curve", hoverinfo="skip"))
     fig.add_trace(go.Scatter(
-        x=xs,
-        y=pdf,
-        mode="lines",
-        name="Bell curve",
-        hoverinfo="skip"
-    ))
-
-    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=x_vals, y=np.zeros_like(x_vals),
+        mode="markers", name="Perpustakaan",
+        hovertext=hover_text, 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")]:
         fig.add_trace(go.Scatter(
-            x=[q, q],
-            y=[0, y_max * 1.05],
-            mode="lines",
-            name=label,
+            x=[q, q], y=[0, 1.05],
+            mode="lines", name=label,
             hovertemplate=f"{label}: {q:.2f}<extra></extra>"
         ))
 
@@ -535,52 +468,141 @@ def make_bell_figure(df_all: pd.DataFrame,
         title=title,
         xaxis_title="Indeks IPLM (0–100)",
         yaxis_title="Kepadatan (relatif)",
-        yaxis=dict(showticklabels=False, zeroline=True, range=[0, y_max * 1.2]),
+        yaxis=dict(showticklabels=False, zeroline=True, range=[0, 1.2]),
         margin=dict(l=40, r=20, t=60, b=40),
         hovermode="x"
     )
-
     return fig
 
-
 # ============================================================
-# 5. PIPELINE REALSCORE + NORMATIF
+# 5) PIPELINE GLOBAL (NASIONAL): Real + Normatif + Confidence + Penalti 68%
 # ============================================================
 
-def run_pipeline_core(df_subset: pd.DataFrame, kab_name=None, kew_name=None):
-    df = df_subset.copy()
-    df_raw = df_subset.copy()
+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()}
 
-    canonical_targets = set(all_indicators)
-    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()}
+def compute_sampling_verification(df_all: pd.DataFrame):
+    """
+    Menghasilkan:
+    - ver_kab: target 68% sekolah & umum (khusus no target), sampling factor per kab_key
+    - ver_prov: target 68% menengah (SMA+SMK+SLB), sampling factor prov untuk dataset sekolah
+    """
+    ver_kab = pd.DataFrame()
+    ver_prov = pd.DataFrame()
+
+    if df_all is None or df_all.empty:
+        return ver_kab, ver_prov
+
+    # ---------- KAB/KOTA ----------
+    if meta_kab_df is not None and "kab_key" in df_all.columns:
+        kab = df_all[df_all["KEW_NORM"] == "KAB/KOTA"].copy()
+        if not kab.empty:
+            g = kab.groupby(["kab_key","_dataset"]).size().unstack(fill_value=0).reset_index()
+            for col in ["sekolah","umum","khusus"]:
+                if col not in g.columns:
+                    g[col] = 0
+            g = g.rename(columns={
+                "sekolah":"Sampel_Sekolah_DM",
+                "umum":"Sampel_Umum_DM",
+                "khusus":"Sampel_Khusus_DM"
+            })
 
+            ver_kab = g.merge(
+                meta_kab_df[["kab_key","Kab_Kota_Label","Pop_Sekolah_SD_SMP","Pop_Admin_Kec_Desa","Target_Sekolah_68","Target_Umum_68"]],
+                on="kab_key", how="left"
+            )
+
+            for c in ["Target_Sekolah_68","Target_Umum_68","Sampel_Sekolah_DM","Sampel_Umum_DM","Sampel_Khusus_DM"]:
+                ver_kab[c] = pd.to_numeric(ver_kab[c], errors="coerce").fillna(0)
+
+            ver_kab["SamplingFactor_Sekolah"] = ver_kab.apply(lambda r: samp_factor(r["Sampel_Sekolah_DM"], r["Target_Sekolah_68"]), axis=1)
+            ver_kab["SamplingFactor_Umum"]    = ver_kab.apply(lambda r: samp_factor(r["Sampel_Umum_DM"],    r["Target_Umum_68"]), axis=1)
+            ver_kab["SamplingFactor_Khusus"]  = 1.0
+
+            ver_kab["Kurang_Sekolah_Menuju_68"] = np.maximum(ver_kab["Target_Sekolah_68"] - ver_kab["Sampel_Sekolah_DM"], 0).astype(int)
+            ver_kab["Kurang_Umum_Menuju_68"]    = np.maximum(ver_kab["Target_Umum_68"]    - ver_kab["Sampel_Umum_DM"],    0).astype(int)
+
+            # factor total tertimbang target sekolah+umum (khusus tidak ikut)
+            def weighted_factor(row):
+                ts = float(row.get("Target_Sekolah_68", 0) or 0)
+                tu = float(row.get("Target_Umum_68", 0) or 0)
+                denom = ts + tu
+                if denom <= 0:
+                    return 1.0
+                return float((row["SamplingFactor_Sekolah"]*ts + row["SamplingFactor_Umum"]*tu) / denom)
+
+            ver_kab["SamplingFactor_Total_Kab"] = ver_kab.apply(weighted_factor, axis=1)
+
+    # ---------- PROVINSI: hanya sekolah (menengah) ----------
+    if meta_menengah_prov is not None and "prov_key" in df_all.columns:
+        prov = df_all[df_all["KEW_NORM"] == "PROVINSI"].copy()
+        if not prov.empty:
+            # detect menengah dengan sub_jenis_perpus jika ada, else fallback dataset sekolah
+            subjenis_col = pick_col(prov, ["sub_jenis_perpus","SUB_JENIS_PERPUS","Sub Jenis Perpustakaan","sub jenis perpus"])
+            if subjenis_col:
+                patt = r"\b(SMA|SMK|SLB)\b"
+                prov["_is_menengah"] = prov[subjenis_col].astype(str).str.upper().str.contains(patt, na=False, regex=True)
+            else:
+                prov["_is_menengah"] = (prov["_dataset"] == "sekolah")
+
+            samp = prov.groupby("prov_key")["_is_menengah"].sum().reset_index().rename(columns={"_is_menengah":"Sampel_Menengah_DM"})
+            samp["Sampel_Menengah_DM"] = pd.to_numeric(samp["Sampel_Menengah_DM"], errors="coerce").fillna(0)
+
+            ver_prov = samp.merge(
+                meta_menengah_prov[["prov_key","Total_SMA","Total_SMK","Total_SLB","Total_Menengah","Target_Menengah_68"]],
+                on="prov_key", how="left"
+            )
+            for c in ["Total_Menengah","Target_Menengah_68","Sampel_Menengah_DM"]:
+                ver_prov[c] = pd.to_numeric(ver_prov[c], errors="coerce").fillna(0)
+
+            ver_prov["SamplingFactor_Prov_Sekolah"] = ver_prov.apply(lambda r: samp_factor(r["Sampel_Menengah_DM"], r["Target_Menengah_68"]), axis=1)
+            ver_prov["Kurang_Menengah_Menuju_68"]   = np.maximum(ver_prov["Target_Menengah_68"] - ver_prov["Sampel_Menengah_DM"], 0).astype(int)
+
+    return ver_kab, ver_prov
+
+def prepare_global_ipml(df_src: pd.DataFrame):
+    """
+    Menghitung:
+    - Indeks_Real_0_100 (YJ+MinMax nasional)
+    - Indeks_Normatif_0_100 (berdasarkan target per jenis)
+    - Confidence_Data
+    - SamplingFactor_Total (aturan penalti 68% FINAL)
+    - Indeks_Final_0_100 = Indeks_Real_0_100 * SamplingFactor_Total
+    - Confidence_IPLM = gabungan data+sample (sample = SamplingFactor_Total)
+    """
+    if df_src is None or df_src.empty:
+        return df_src, pd.DataFrame(), pd.DataFrame()
+
+    df = df_src.copy()
+
+    # 1) Rename indikator -> kanonik
+    canonical_targets = set(all_indicators)
     rename_map = {}
     for col in list(df.columns):
         ccol = _canon(col)
@@ -594,14 +616,13 @@ def run_pipeline_core(df_subset: pd.DataFrame, kab_name=None, kew_name=None):
     if rename_map:
         df = df.rename(columns=rename_map)
 
+    # 2) Coerce numeric
     available_indicators = [c for c in all_indicators if c in df.columns]
     for c in available_indicators:
         df[c] = df[c].apply(coerce_num)
 
-    # Yeo–Johnson + MinMax
-    yj_cols = []
+    # 3) YJ nasional + MinMax nasional
     for c in available_indicators:
-        yj_col = f"yj_{c}"
         x = df[c].astype(float).values
         mask = ~np.isnan(x)
         transformed = np.full_like(x, np.nan, dtype=float)
@@ -610,111 +631,122 @@ def run_pipeline_core(df_subset: pd.DataFrame, kab_name=None, kew_name=None):
             transformed[mask] = pt.fit_transform(x[mask].reshape(-1, 1)).ravel()
         else:
             transformed[mask] = x[mask]
-        df[yj_col] = transformed
-        yj_cols.append(yj_col)
-
-    for yj_col in yj_cols:
-        base = yj_col[3:]
-        df[f"norm_{base}"] = minmax_norm(df[yj_col])
+        df[f"yj_{c}"] = transformed
+        df[f"norm_{c}"] = minmax_norm(df[f"yj_{c}"])
 
-    # Sub-indeks real
-    df["sub_koleksi"]     = df.apply(lambda r: penalized_mean(r, [c for c in koleksi_cols    if c in available_indicators]), axis=1)
-    df["sub_sdm"]         = df.apply(lambda r: penalized_mean(r, [c for c in sdm_cols        if c in available_indicators]), axis=1)
-    df["sub_pelayanan"]   = df.apply(lambda r: penalized_mean(r, [c for c in pelayanan_cols  if c in available_indicators]), axis=1)
-    df["sub_pengelolaan"] = df.apply(lambda r: penalized_mean(r, [c for c in pengelolaan_cols if c in available_indicators]), axis=1)
+    # 4) Sub-indeks real (mean norm_*, missing=0)
+    df["sub_koleksi"]     = df.apply(lambda r: penalized_mean_norm(r, [c for c in koleksi_cols if c in available_indicators]), axis=1)
+    df["sub_sdm"]         = df.apply(lambda r: penalized_mean_norm(r, [c for c in sdm_cols if c in available_indicators]), axis=1)
+    df["sub_pelayanan"]   = df.apply(lambda r: penalized_mean_norm(r, [c for c in pelayanan_cols if c in available_indicators]), axis=1)
+    df["sub_pengelolaan"] = df.apply(lambda r: penalized_mean_norm(r, [c for c in pengelolaan_cols if c in available_indicators]), 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["Indeks_Real_0_100"] = 100 * (w_kepatuhan * df["dim_kepatuhan"] + w_kinerja * df["dim_kinerja"])
+    df["Indeks_Real_0_100"] = 100.0 * (w_kepatuhan*df["dim_kepatuhan"] + w_kinerja*df["dim_kinerja"])
 
-    # Confidence
+    # 5) Confidence data
     df["n_ind_filled"] = df[available_indicators].notna().sum(axis=1)
     df["n_ind_total"]  = len(available_indicators)
+    df["Confidence_Data"] = np.where(df["n_ind_total"] > 0, df["n_ind_filled"]/df["n_ind_total"], np.nan)
 
-    df["Confidence_Data"] = np.where(
-        df["n_ind_total"] > 0,
-        df["n_ind_filled"] / df["n_ind_total"],
-        np.nan
-    )
-
-    if kab_col_glob and kab_col_glob in df.columns:
-        df["_Kab_norm"] = df[kab_col_glob].astype(str).str.upper().str.strip()
-        freq_kab = df["_Kab_norm"].value_counts()
-        df["Jml_Perpus_Kab"] = df["_Kab_norm"].map(freq_kab)
-        df["Confidence_Sample"] = (df["Jml_Perpus_Kab"] / SAMPLE_THRESHOLD).clip(0, 1)
-    else:
-        df["Jml_Perpus_Kab"] = np.nan
-        df["Confidence_Sample"] = 1.0
-
-    df["Confidence_IPLM"] = (
-        W_DATA   * df["Confidence_Data"].fillna(0) +
-        W_SAMPLE * df["Confidence_Sample"].fillna(0)
-    )
-
-    df["Indeks_Real_AdjData"] = df["Indeks_Real_0_100"] * df["Confidence_Data"].fillna(0)
-    df["Indeks_Real_AdjConf"] = df["Indeks_Real_0_100"] * df["Confidence_IPLM"].fillna(0)
-
-    # Indeks normatif
+    # 6) Normatif (tetap dihitung)
     df["Indeks_Normatif_0_100"] = np.nan
-    df["sub_koleksi_n"] = np.nan
-    df["sub_sdm_n"] = np.nan
-    df["sub_pelayanan_n"] = np.nan
-    df["sub_pengelolaan_n"] = np.nan
-    df["dim_kepatuhan_n"] = np.nan
-    df["dim_kinerja_n"] = np.nan
-
     for i, row in df.iterrows():
         jenis = row.get("_dataset", None)
         if jenis not in TARGETS:
             continue
         t = TARGETS[jenis]
-
         skor_ind = {}
         for ind, target in t.items():
             if ind in df.columns:
                 skor_ind[ind] = skor_normatif(row[ind], target)
 
-        sub_koleksi_n = np.mean([
-            skor_ind.get("JudulTercetak", 0),
-            skor_ind.get("EksemplarTercetak", 0)
-        ])
+        sub_koleksi_n = np.mean([skor_ind.get("JudulTercetak", 0), skor_ind.get("EksemplarTercetak", 0)])
         sub_sdm_n = skor_ind.get("TenagaKualifikasiIlmuPerpustakaan", 0)
-        sub_pelayanan_n = np.mean([
-            skor_ind.get("PemustakaLuringDaring", 0),
-            skor_ind.get("KegiatanBudayaBaca", 0)
-        ])
+        sub_pelayanan_n = np.mean([skor_ind.get("PemustakaLuringDaring", 0), skor_ind.get("KegiatanBudayaBaca", 0)])
         sub_pengelolaan_n = skor_ind.get("VariasiLayanan", 0)
 
         dim_kepatuhan_n = np.mean([sub_koleksi_n, sub_sdm_n])
-        dim_kinerja_n   = np.mean([sub_pelayanan_n, sub_pengelolaan_n])
+        dim_kinerja_n = np.mean([sub_pelayanan_n, sub_pengelolaan_n])
+
+        df.at[i, "Indeks_Normatif_0_100"] = 100.0 * (w_kepatuhan*dim_kepatuhan_n + w_kinerja*dim_kinerja_n)
+
+    # 7) Verifikasi sampling 68% + penalti factor sesuai RULE
+    ver_kab, ver_prov = compute_sampling_verification(df)
+
+    df["SamplingFactor_Total"] = 1.0
+
+    # map kab factors (sekolah & umum saja)
+    if not ver_kab.empty:
+        kab_f_sekolah = ver_kab.set_index("kab_key")["SamplingFactor_Sekolah"].to_dict()
+        kab_f_umum    = ver_kab.set_index("kab_key")["SamplingFactor_Umum"].to_dict()
+
+        mask_kab = (df["KEW_NORM"] == "KAB/KOTA")
+        mask_kab_sekolah = mask_kab & (df["_dataset"] == "sekolah")
+        mask_kab_umum    = mask_kab & (df["_dataset"] == "umum")
+        mask_kab_khusus  = mask_kab & (df["_dataset"] == "khusus")
 
-        indeks_normatif = 100 * (w_kepatuhan * dim_kepatuhan_n + w_kinerja * dim_kinerja_n)
+        df.loc[mask_kab_sekolah, "SamplingFactor_Total"] = df.loc[mask_kab_sekolah, "kab_key"].map(kab_f_sekolah).fillna(1.0)
+        df.loc[mask_kab_umum,    "SamplingFactor_Total"] = df.loc[mask_kab_umum,    "kab_key"].map(kab_f_umum).fillna(1.0)
+        df.loc[mask_kab_khusus,  "SamplingFactor_Total"] = 1.0
 
-        df.at[i, "sub_koleksi_n"]     = sub_koleksi_n
-        df.at[i, "sub_sdm_n"]         = sub_sdm_n
-        df.at[i, "sub_pelayanan_n"]   = sub_pelayanan_n
-        df.at[i, "sub_pengelolaan_n"] = sub_pengelolaan_n
-        df.at[i, "dim_kepatuhan_n"]   = dim_kepatuhan_n
-        df.at[i, "dim_kinerja_n"]     = dim_kinerja_n
-        df.at[i, "Indeks_Normatif_0_100"] = indeks_normatif
+    # map prov factor (hanya sekolah menengah)
+    if not ver_prov.empty:
+        prov_f_school = ver_prov.set_index("prov_key")["SamplingFactor_Prov_Sekolah"].to_dict()
+        mask_prov = (df["KEW_NORM"] == "PROVINSI")
+        mask_prov_school = mask_prov & (df["_dataset"] == "sekolah")
+        df.loc[mask_prov_school, "SamplingFactor_Total"] = df.loc[mask_prov_school, "prov_key"].map(prov_f_school).fillna(1.0)
+        # umum/khusus tetap 1.0 (default)
 
+    # 8) Confidence sample = sampling factor (lebih logis, target-based)
+    df["Confidence_Sample"] = df["SamplingFactor_Total"].clip(0,1)
+
+    df["Confidence_IPLM"] = (
+        W_DATA   * df["Confidence_Data"].fillna(0) +
+        W_SAMPLE * df["Confidence_Sample"].fillna(0)
+    )
+
+    # 9) Final index (penalti)
+    df["Indeks_Final_0_100"] = df["Indeks_Real_0_100"] * df["SamplingFactor_Total"]
+
+    # tambahan (opsional)
+    df["Indeks_Real_AdjData"] = df["Indeks_Real_0_100"] * df["Confidence_Data"].fillna(0)
+    df["Indeks_Real_AdjConf"] = df["Indeks_Real_0_100"] * df["Confidence_IPLM"].fillna(0)
     df["Indeks_Normatif_AdjConf"] = df["Indeks_Normatif_0_100"] * df["Confidence_IPLM"].fillna(0)
 
-    # DETAIL untuk tampilan (lengkap, nanti di-view akan di-hide kolom tertentu)
+    return df, ver_kab, ver_prov
+
+# Jalankan pipeline nasional sekali
+df_all_ipml, ver_kab_global, ver_prov_global = (None, pd.DataFrame(), pd.DataFrame())
+if df_all_raw is not None and not df_all_raw.empty:
+    df_all_ipml, ver_kab_global, ver_prov_global = prepare_global_ipml(df_all_raw)
+
+# ============================================================
+# 6) AGREGAT + DOWNLOAD + BELL CURVE
+# ============================================================
+
+def run_pipeline_core(df_subset: pd.DataFrame, kab_name=None, kew_name=None):
+    if df_subset is None or df_subset.empty:
+        empty = pd.DataFrame()
+        return (empty, empty, None, None, None, None, None, None, None)
+
+    df = df_subset.copy()
+    df_raw = df_subset.copy()
+
+    # DETAIL untuk tampilan (tetap lengkap; nanti view disembunyikan di run_app)
     detail_cols = []
-    if prov_col_glob and prov_col_glob in df.columns:
-        detail_cols.append(prov_col_glob)
-    if kab_col_glob and kab_col_glob in df.columns:
-        detail_cols.append(kab_col_glob)
-    if nama_col_glob and nama_col_glob in df.columns:
-        detail_cols.append(nama_col_glob)
+    if prov_col_glob and prov_col_glob in df.columns: detail_cols.append(prov_col_glob)
+    if kab_col_glob and kab_col_glob in df.columns:  detail_cols.append(kab_col_glob)
+    if nama_col_glob and nama_col_glob in df.columns: detail_cols.append(nama_col_glob)
 
     detail_cols += [
-        "_dataset",
-        "sub_koleksi", "sub_sdm", "sub_pelayanan", "sub_pengelolaan",
-        "dim_kepatuhan", "dim_kinerja",
+        "_dataset", "KEW_NORM",
+        "sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan",
+        "dim_kepatuhan","dim_kinerja",
         "Indeks_Real_0_100",
+        "SamplingFactor_Total",
+        "Indeks_Final_0_100",
         "Indeks_Real_AdjData",
         "Indeks_Real_AdjConf",
         "Indeks_Normatif_0_100",
@@ -724,16 +756,11 @@ def run_pipeline_core(df_subset: pd.DataFrame, kab_name=None, kew_name=None):
         "Confidence_IPLM",
     ]
     detail_cols = [c for c in detail_cols if c in df.columns]
-
     detail_df = df[detail_cols].copy().round(3)
 
-    # AGREGAT per jenis
+    # AGREGAT per jenis: gunakan Indeks_Final_0_100 sebagai utama
     expected_ds = ["sekolah", "umum", "khusus"]
-    label_map = {
-        "sekolah": "Perpustakaan Sekolah",
-        "umum": "Perpustakaan Umum",
-        "khusus": "Perpustakaan Khusus"
-    }
+    label_map = {"sekolah":"Perpustakaan Sekolah","umum":"Perpustakaan Umum","khusus":"Perpustakaan Khusus"}
 
     rows = []
     for ds in expected_ds:
@@ -744,257 +771,165 @@ def run_pipeline_core(df_subset: pd.DataFrame, kab_name=None, kew_name=None):
                 "Jumlah Perpustakaan": 0,
                 "Rata2_DimKepatuhan": 0.0,
                 "Rata2_DimKinerja": 0.0,
-                "Rata2_Indeks_IPLM_0_100": 0.0,
+                "Rata2_Indeks_Asli_0_100": 0.0,
+                "Rata2_SamplingFactor": 1.0,
+                "Rata2_Indeks_Final_0_100": 0.0,
             })
         else:
             rows.append({
                 "Jenis Perpustakaan": label_map.get(ds, ds),
-                "Jumlah Perpustakaan": len(dsub),
-                "Rata2_DimKepatuhan": dsub["dim_kepatuhan"].mean(skipna=True),
-                "Rata2_DimKinerja": dsub["dim_kinerja"].mean(skipna=True),
-                "Rata2_Indeks_IPLM_0_100": dsub["Indeks_Real_0_100"].mean(skipna=True),
+                "Jumlah Perpustakaan": int(len(dsub)),
+                "Rata2_DimKepatuhan": float(dsub["dim_kepatuhan"].mean(skipna=True)),
+                "Rata2_DimKinerja": float(dsub["dim_kinerja"].mean(skipna=True)),
+                "Rata2_Indeks_Asli_0_100": float(dsub["Indeks_Real_0_100"].mean(skipna=True)),
+                "Rata2_SamplingFactor": float(dsub["SamplingFactor_Total"].mean(skipna=True)),
+                "Rata2_Indeks_Final_0_100": float(dsub["Indeks_Final_0_100"].mean(skipna=True)),
             })
 
-    if rows:
-        base_rows = rows[:len(expected_ds)]
-        total_jumlah = int(sum(r["Jumlah Perpustakaan"] for r in base_rows))
-        mean_dim_kep     = float(np.mean([r["Rata2_DimKepatuhan"] for r in base_rows]))
-        mean_dim_kinerja = float(np.mean([r["Rata2_DimKinerja"] for r in base_rows]))
-        mean_indeks      = float(np.mean([r["Rata2_Indeks_IPLM_0_100"] for r in base_rows]))
-
-        rows.append({
-            "Jenis Perpustakaan": "Rata-rata keseluruhan",
-            "Jumlah Perpustakaan": total_jumlah,
-            "Rata2_DimKepatuhan": mean_dim_kep,
-            "Rata2_DimKinerja": mean_dim_kinerja,
-            "Rata2_Indeks_IPLM_0_100": mean_indeks,
-        })
+    total_jumlah = int(sum(r["Jumlah Perpustakaan"] for r in rows))
+    mean_dim_kep = float(np.mean([r["Rata2_DimKepatuhan"] for r in rows])) if rows else 0.0
+    mean_dim_kin = float(np.mean([r["Rata2_DimKinerja"] for r in rows])) if rows else 0.0
+    mean_asli    = float(np.mean([r["Rata2_Indeks_Asli_0_100"] for r in rows])) if rows else 0.0
+    mean_sf      = float(np.mean([r["Rata2_SamplingFactor"] for r in rows])) if rows else 1.0
+    mean_final   = float(np.mean([r["Rata2_Indeks_Final_0_100"] for r in rows])) if rows else 0.0
+
+    rows.append({
+        "Jenis Perpustakaan": "Rata-rata keseluruhan",
+        "Jumlah Perpustakaan": total_jumlah,
+        "Rata2_DimKepatuhan": mean_dim_kep,
+        "Rata2_DimKinerja": mean_dim_kin,
+        "Rata2_Indeks_Asli_0_100": mean_asli,
+        "Rata2_SamplingFactor": mean_sf,
+        "Rata2_Indeks_Final_0_100": mean_final,
+    })
 
     agg_view = pd.DataFrame(rows).round(3)
 
-    # Simpan Excel (AGG, DETAIL, RAW)
+    # Simpan Excel
     kab_slug = slugify(kab_name) if kab_name else "SEMUA_KAB"
     kew_slug = slugify(kew_name) if kew_name else "SEMUA_KEW"
     tmpdir = tempfile.mkdtemp()
 
-    agg_path    = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Agregat_{kab_slug}_{kew_slug}.xlsx")
-    detail_path = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Detail_{kab_slug}_{kew_slug}.xlsx")
-    raw_path    = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Raw_{kab_slug}_{kew_slug}.xlsx")
+    agg_path = os.path.join(tmpdir, f"IPLM_Agregat_{kab_slug}_{kew_slug}.xlsx")
+    detail_path = os.path.join(tmpdir, f"IPLM_Detail_{kab_slug}_{kew_slug}.xlsx")
+    raw_path = os.path.join(tmpdir, f"IPLM_Raw_{kab_slug}_{kew_slug}.xlsx")
 
     agg_view.to_excel(agg_path, index=False)
     df.to_excel(detail_path, index=False)
     df_raw.to_excel(raw_path, index=False)
 
-    # Bell curve
+    # Bell curve pakai Final index
     name_col = nama_col_glob if (nama_col_glob and nama_col_glob in detail_df.columns) else None
 
-    fig_all = make_bell_figure(detail_df, "Sebaran Indeks RealScore – Semua Perpustakaan",
-                               index_col="Indeks_Real_0_100", name_col=name_col)
-
-    fig_sekolah = make_bell_figure(
-        detail_df[detail_df["_dataset"] == "sekolah"],
-        "Sebaran Indeks RealScore – Perpustakaan Sekolah",
-        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
-    )
-
-    fig_umum = make_bell_figure(
-        detail_df[detail_df["_dataset"] == "umum"],
-        "Sebaran Indeks RealScore – Perpustakaan Umum",
-        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
-    )
-
-    fig_khusus = make_bell_figure(
-        detail_df[detail_df["_dataset"] == "khusus"],
-        "Sebaran Indeks RealScore – Perpustakaan Khusus",
-        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
-    )
-
-    return (
-        agg_view,
-        detail_df,
-        agg_path,
-        detail_path,
-        raw_path,
-        fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
-    )
+    fig_all = make_bell_figure(detail_df, "Sebaran Indeks (Final, setelah penalti 68%) – Semua", "Indeks_Final_0_100", name_col=name_col)
+    fig_sek = make_bell_figure(detail_df[detail_df["_dataset"]=="sekolah"], "Sebaran Indeks Final – Sekolah", "Indeks_Final_0_100", name_col=name_col, min_points=3)
+    fig_um  = make_bell_figure(detail_df[detail_df["_dataset"]=="umum"],    "Sebaran Indeks Final – Umum",    "Indeks_Final_0_100", name_col=name_col, min_points=3)
+    fig_kh  = make_bell_figure(detail_df[detail_df["_dataset"]=="khusus"],  "Sebaran Indeks Final – Khusus",  "Indeks_Final_0_100", name_col=name_col, min_points=3)
 
+    return agg_view, detail_df, agg_path, detail_path, raw_path, fig_all, fig_sek, fig_um, fig_kh
 
 # ============================================================
-# 6. VERIFIKASI SAMPEL
+# 7) VERIFIKASI SAMPEL (untuk filter yang dipilih)
 # ============================================================
 
-def compute_verification(df_filtered: pd.DataFrame, kew_value):
-    if df_filtered is None or len(df_filtered) == 0:
+def compute_verification(df_filtered: pd.DataFrame, kew_value: str):
+    if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
 
     kew_norm = str(kew_value or "").upper()
 
-    # ---------- Kewenangan KAB/KOTA ----------
-    if ("KAB" in kew_norm or "KOTA" in kew_norm) and (kab_col_glob is not None) and (meta_kab_df is not None):
-        tmp = df_filtered.copy()
-        tmp = tmp[pd.notna(tmp[kab_col_glob])]
-        if tmp.empty:
-            return pd.DataFrame()
-
-        tmp["kab_key"] = tmp[kab_col_glob].apply(norm_kab_label)
-
-        # total perpus
-        g_total = tmp.groupby("kab_key").size().rename("jml_perpus_sampel_total").reset_index()
-
-        # klasifikasi jenjang sekolah (kalau ada)
-        if "sub_jenis_perpus" in tmp.columns:
-            def jenjang(x):
-                if pd.isna(x):
-                    return "OTHER"
-                t = str(x).upper()
-                if " SD " in f" {t} " or " SD/" in t or " MI " in f" {t} ":
-                    return "SD"
-                if " SMP " in f" {t} " or " SMP/" in t or " MTS " in f" {t} ":
-                    return "SMP"
-                return "OTHER"
-            tmp["jenjang_sekolah"] = tmp["sub_jenis_perpus"].apply(jenjang)
-        else:
-            tmp["jenjang_sekolah"] = "OTHER"
-
-        if "_dataset" in tmp.columns:
-            mask_sek = tmp["_dataset"] == "sekolah"
-        else:
-            mask_sek = True
-
-        tmp_sek = tmp[mask_sek].copy()
-        tmp_sd  = tmp_sek[tmp_sek["jenjang_sekolah"] == "SD"].copy()
-        tmp_smp = tmp_sek[tmp_sek["jenjang_sekolah"] == "SMP"].copy()
-
-        g_sd      = tmp_sd.groupby("kab_key").size().rename("jml_perpus_sd_sampel").reset_index()
-        g_smp     = tmp_smp.groupby("kab_key").size().rename("jml_perpus_smp_sampel").reset_index()
-        g_sekolah = tmp_sek.groupby("kab_key").size().rename("jml_perpus_sekolah_total").reset_index()
-
-        if "_dataset" in tmp.columns:
-            tmp_umum = tmp[tmp["_dataset"] == "umum"].copy()
-        else:
-            tmp_umum = tmp.copy()
-        g_umum = tmp_umum.groupby("kab_key").size().rename("jml_perpus_umum_sampel").reset_index()
-
-        use_cols = ["kab_key", "Kab_Kota_Label", "Jml_Kecamatan", "Jml_DesaKel", "Jml_SD", "Jml_SMP"]
-        use_cols = [c for c in use_cols if (meta_kab_df is not None and c in meta_kab_df.columns)]
-
-        merged = (
-            g_total
-            .merge(g_sd,      on="kab_key", how="left")
-            .merge(g_smp,     on="kab_key", how="left")
-            .merge(g_sekolah, on="kab_key", how="left")
-            .merge(g_umum,    on="kab_key", how="left")
-            .merge(meta_kab_df[use_cols], on="kab_key", how="left")
+    # --- KAB/KOTA ---
+    if "KAB" in kew_norm or "KOTA" in kew_norm:
+        if meta_kab_df is None:
+            return pd.DataFrame({"Info": ["Meta kab/kota tidak tersedia."]})
+        if "kab_key" not in df_filtered.columns:
+            return pd.DataFrame({"Info": ["kab_key tidak tersedia di data."]})
+
+        kab = df_filtered[df_filtered["KEW_NORM"]=="KAB/KOTA"].copy()
+        if kab.empty:
+            return pd.DataFrame({"Info": ["Tidak ada data untuk KAB/KOTA pada filter ini."]})
+
+        g = kab.groupby(["kab_key","_dataset"]).size().unstack(fill_value=0).reset_index()
+        for col in ["sekolah","umum","khusus"]:
+            if col not in g.columns:
+                g[col] = 0
+        g = g.rename(columns={"sekolah":"Sampel_Sekolah_DM","umum":"Sampel_Umum_DM","khusus":"Sampel_Khusus_DM"})
+
+        out = g.merge(
+            meta_kab_df[["kab_key","Kab_Kota_Label","Pop_Sekolah_SD_SMP","Pop_Admin_Kec_Desa","Target_Sekolah_68","Target_Umum_68"]],
+            on="kab_key", how="left"
         )
 
-        for c in ["jml_perpus_sampel_total", "jml_perpus_sd_sampel",
-                  "jml_perpus_smp_sampel", "jml_perpus_sekolah_total",
-                  "jml_perpus_umum_sampel"]:
-            if c in merged.columns:
-                merged[c] = merged[c].fillna(0).astype(int)
-
-        def safe_pct(num, den):
-            if pd.isna(den) or den <= 0:
-                return np.nan
-            return 100.0 * float(num) / float(den)
+        for c in ["Target_Sekolah_68","Target_Umum_68","Sampel_Sekolah_DM","Sampel_Umum_DM","Sampel_Khusus_DM"]:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0)
 
-        # sekolah SD+SMP
-        if "Jml_SD" in merged.columns or "Jml_SMP" in merged.columns:
-            merged["total_sd_smp"] = merged[["Jml_SD", "Jml_SMP"]].sum(axis=1, skipna=True)
-        else:
-            merged["total_sd_smp"] = np.nan
-
-        merged["cov_sekolah_total_%"] = merged.apply(
-            lambda r: safe_pct(r["jml_perpus_sekolah_total"], r.get("total_sd_smp", np.nan)),
-            axis=1
-        )
+        out["SamplingFactor_Sekolah"] = out.apply(lambda r: samp_factor(r["Sampel_Sekolah_DM"], r["Target_Sekolah_68"]), axis=1)
+        out["SamplingFactor_Umum"]    = out.apply(lambda r: samp_factor(r["Sampel_Umum_DM"],    r["Target_Umum_68"]), axis=1)
+        out["SamplingFactor_Khusus"]  = 1.0
 
-        # umum vs kombinasi (Kecamatan + Desa/Kel)
-        merged["total_kec_desakel"] = merged.get("Jml_Kecamatan", np.nan) + merged.get("Jml_DesaKel", np.nan)
-        merged["cov_umum_vs_kec_desakel_%"] = merged.apply(
-            lambda r: safe_pct(r["jml_perpus_umum_sampel"], r.get("total_kec_desakel", np.nan)),
-            axis=1
-        )
+        out["Kurang_Sekolah_Menuju_68"] = np.maximum(out["Target_Sekolah_68"] - out["Sampel_Sekolah_DM"], 0).astype(int)
+        out["Kurang_Umum_Menuju_68"]    = np.maximum(out["Target_Umum_68"]    - out["Sampel_Umum_DM"],    0).astype(int)
 
-        out = pd.DataFrame({
-            "Kab/Kota": merged["Kab_Kota_Label"],
-            "Perpus Sampel (Total)": merged["jml_perpus_sampel_total"],
-            "Perpus Sampel – SD": merged["jml_perpus_sd_sampel"],
-            "Perpus Sampel – SMP": merged["jml_perpus_smp_sampel"],
-            "Perpus Sampel – Sekolah (Total SD+SMP)": merged["jml_perpus_sekolah_total"],
-            "Sekolah (SD+SMP)": merged.get("total_sd_smp", np.nan),
-            "Coverage Perpus Sekolah vs Sekolah (%)": merged["cov_sekolah_total_%"],
-            "Perpus Sampel – Umum": merged["jml_perpus_umum_sampel"],
-            "Jumlah Kecamatan": merged.get("Jml_Kecamatan", np.nan),
-            "Jumlah Desa/Kel": merged.get("Jml_DesaKel", np.nan),
-            "Coverage Perpus Umum vs Kec+Desa/Kel (%)": merged["cov_umum_vs_kec_desakel_%"],
+        out = out.rename(columns={
+            "Kab_Kota_Label":"Kab/Kota",
+            "Pop_Sekolah_SD_SMP":"Populasi SD+SMP",
+            "Pop_Admin_Kec_Desa":"Populasi Kec+Desa/Kel",
         })
 
-        return out.sort_values("Kab/Kota").reset_index(drop=True).round(3)
-
-    # ---------- Kewenangan PROVINSI ----------
-    if ("PROV" in kew_norm) and (meta_sma_df is not None):
-        tmp = df_filtered.copy()
-
-        if prov_col_glob is None:
-            possible = [c for c in tmp.columns if "prov" in c.lower()]
-            if possible:
-                prov_use = possible[0]
-            else:
-                return pd.DataFrame({"Info": ["Kolom provinsi tidak ditemukan di DM.xlsx"]})
-        else:
-            prov_use = prov_col_glob
-
-        tmp = tmp[pd.notna(tmp[prov_use])]
-        if tmp.empty:
-            return pd.DataFrame({"Info": ["Tidak ada data perpustakaan pada kewenangan provinsi."]})
-
-        # Normalisasi provinsi di DM agar konsisten dengan meta_sma_df
-        tmp["prov_key"] = tmp[prov_use].apply(norm_prov_label)
-
-        g_total = tmp.groupby("prov_key").size().rename("Jumlah_Perpus_Sampel").reset_index()
-
-        if "_dataset" in tmp.columns:
-            tmp_sek = tmp[tmp["_dataset"] == "sekolah"].copy()
+        cols = [
+            "Kab/Kota",
+            "Sampel_Sekolah_DM","Target_Sekolah_68","SamplingFactor_Sekolah","Kurang_Sekolah_Menuju_68",
+            "Sampel_Umum_DM","Target_Umum_68","SamplingFactor_Umum","Kurang_Umum_Menuju_68",
+            "Sampel_Khusus_DM","SamplingFactor_Khusus",
+            "Populasi SD+SMP","Populasi Kec+Desa/Kel",
+        ]
+        return out[[c for c in cols if c in out.columns]].sort_values("Kab/Kota").reset_index(drop=True).round(3)
+
+    # --- PROVINSI ---
+    if "PROV" in kew_norm:
+        if meta_menengah_prov is None:
+            return pd.DataFrame({"Info": ["Meta prov menengah (SMA+SMK+SLB) tidak tersedia."]})
+        if "prov_key" not in df_filtered.columns:
+            return pd.DataFrame({"Info": ["prov_key tidak tersedia di data."]})
+
+        prov = df_filtered[df_filtered["KEW_NORM"]=="PROVINSI"].copy()
+        if prov.empty:
+            return pd.DataFrame({"Info": ["Tidak ada data untuk PROVINSI pada filter ini."]})
+
+        subjenis_col = pick_col(prov, ["sub_jenis_perpus","SUB_JENIS_PERPUS","Sub Jenis Perpustakaan","sub jenis perpus"])
+        if subjenis_col:
+            patt = r"\b(SMA|SMK|SLB)\b"
+            prov["_is_menengah"] = prov[subjenis_col].astype(str).str.upper().str.contains(patt, na=False, regex=True)
         else:
-            tmp_sek = tmp.copy()
-        g_sek = tmp_sek.groupby("prov_key").size().rename("Jml_Perpus_SMA_Sampel").reset_index()
-
-        merged = g_total.merge(g_sek, on="prov_key", how="left") \
-                        .merge(meta_sma_df[["prov_key", "Provinsi_Label", "Jml_SMA"]],
-                               on="prov_key", how="left")
+            prov["_is_menengah"] = (prov["_dataset"]=="sekolah")
 
-        merged["Jml_Perpus_SMA_Sampel"] = merged["Jml_Perpus_SMA_Sampel"].fillna(0).astype(int)
+        samp = prov.groupby("prov_key")["_is_menengah"].sum().reset_index().rename(columns={"_is_menengah":"Sampel_Menengah_DM"})
+        samp["Sampel_Menengah_DM"] = pd.to_numeric(samp["Sampel_Menengah_DM"], errors="coerce").fillna(0)
 
-        def cov_sma(row):
-            tot = row.get("Jml_SMA", np.nan)
-            if pd.isna(tot) or tot <= 0:
-                return np.nan
-            return 100.0 * row["Jml_Perpus_SMA_Sampel"] / tot
+        out = samp.merge(
+            meta_menengah_prov[["prov_key","Total_SMA","Total_SMK","Total_SLB","Total_Menengah","Target_Menengah_68"]],
+            on="prov_key", how="left"
+        )
+        for c in ["Total_Menengah","Target_Menengah_68","Sampel_Menengah_DM"]:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0)
 
-        merged["Coverage_Perpus_SMA_vs_SMA_%"] = merged.apply(cov_sma, axis=1)
+        out["SamplingFactor_Prov_Sekolah"] = out.apply(lambda r: samp_factor(r["Sampel_Menengah_DM"], r["Target_Menengah_68"]), axis=1)
+        out["Kurang_Menengah_Menuju_68"]   = np.maximum(out["Target_Menengah_68"] - out["Sampel_Menengah_DM"], 0).astype(int)
 
-        cols_out = [
-            "Provinsi_Label",
-            "Jumlah_Perpus_Sampel",
-            "Jml_Perpus_SMA_Sampel",
-            "Jml_SMA",
-            "Coverage_Perpus_SMA_vs_SMA_%",
-        ]
-        exists = [c for c in cols_out if c in merged.columns]
-        if not exists:
-            return pd.DataFrame()
+        # tampilkan label prov jika tersedia
+        if prov_col_glob and prov_col_glob in df_filtered.columns:
+            prov_labels = df_filtered.dropna(subset=["prov_key", prov_col_glob]).groupby("prov_key")[prov_col_glob].first().reset_index()
+            out = out.merge(prov_labels, on="prov_key", how="left")
+            out = out.rename(columns={prov_col_glob: "Provinsi"})
 
-        return merged[exists].sort_values("Provinsi_Label").reset_index(drop=True).round(3)
+        cols = ["Provinsi","Sampel_Menengah_DM","Total_Menengah","Target_Menengah_68","SamplingFactor_Prov_Sekolah","Kurang_Menengah_Menuju_68","Total_SMA","Total_SMK","Total_SLB"]
+        cols = [c for c in cols if c in out.columns]
+        return out[cols].sort_values(cols[0]).reset_index(drop=True).round(3)
 
     return pd.DataFrame()
 
-
 # ============================================================
-# 7. KONTEKS RINGKAS UNTUK LLM (RAG MINI)
+# 8) ANALISIS (LLM + fallback)
 # ============================================================
 
 def build_context_for_llm(detail_df: pd.DataFrame,
@@ -1010,118 +945,52 @@ def build_context_for_llm(detail_df: pd.DataFrame,
     lines.append(f"Wilayah: {wilayah}")
     lines.append(f"Jumlah perpustakaan sampel: {len(detail_df)}")
 
-    # Rata-rata indeks: utamakan baris "Rata-rata keseluruhan" di agg_df
-    mean_ind = np.nan
+    mean_final = np.nan
     if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
         mask_total = agg_df["Jenis Perpustakaan"].astype(str).str.lower().str.startswith("rata-rata")
         if mask_total.any():
             try:
-                mean_ind = float(
-                    agg_df.loc[mask_total, "Rata2_Indeks_IPLM_0_100"].iloc[0]
-                )
+                mean_final = float(agg_df.loc[mask_total, "Rata2_Indeks_Final_0_100"].iloc[0])
             except Exception:
-                mean_ind = np.nan
+                mean_final = np.nan
+    if np.isnan(mean_final) and "Indeks_Final_0_100" in detail_df.columns:
+        mean_final = detail_df["Indeks_Final_0_100"].mean(skipna=True)
 
-    # Fallback ke rata-rata detail bila agregat tidak tersedia
-    if (np.isnan(mean_ind) or mean_ind == 0) and "Indeks_Real_0_100" in detail_df.columns:
-        mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
+    if not np.isnan(mean_final):
+        lines.append(f"Rata-rata Indeks IPLM Final (0-100): {mean_final:.2f}")
 
-    if not np.isnan(mean_ind):
-        lines.append(f"Rata-rata Indeks IPLM 0-100: {mean_ind:.2f}")
-
-    # Dimensi kepatuhan & kinerja
-    mean_kep = np.nan
-    mean_kin = np.nan
     if "dim_kepatuhan" in detail_df.columns:
-        mean_kep = detail_df["dim_kepatuhan"].mean(skipna=True)
-        lines.append(f"Rata-rata dimensi kepatuhan (0-1): {mean_kep:.3f}")
+        lines.append(f"Rata-rata dimensi kepatuhan (0–1): {detail_df['dim_kepatuhan'].mean(skipna=True):.3f}")
     if "dim_kinerja" in detail_df.columns:
-        mean_kin = detail_df["dim_kinerja"].mean(skipna=True)
-        lines.append(f"Rata-rata dimensi kinerja (0-1): {mean_kin:.3f}")
-
-    # Confidence
-    if "Confidence_IPLM" in detail_df.columns:
-        mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
-        if not np.isnan(mean_conf):
-            lines.append(f"Rata-rata Confidence_IPLM (0-1): {mean_conf:.2f}")
+        lines.append(f"Rata-rata dimensi kinerja (0–1): {detail_df['dim_kinerja'].mean(skipna=True):.3f}")
+    if "SamplingFactor_Total" in detail_df.columns:
+        lines.append(f"Rata-rata SamplingFactor_Total (0–1): {detail_df['SamplingFactor_Total'].mean(skipna=True):.3f}")
 
-    # Ringkasan per jenis perpustakaan
     if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
         lines.append("\nRingkasan per jenis perpustakaan:")
         for _, r in agg_df.iterrows():
-            jp = str(r.get("Jenis Perpustakaan", "") or "")
+            jp = str(r.get("Jenis Perpustakaan","") or "")
             if jp.lower().startswith("rata-rata"):
                 continue
-            n = r.get("Jumlah Perpustakaan", np.nan)
-            idx = r.get("Rata2_Indeks_IPLM_0_100", np.nan)
+            n = r.get("Jumlah Perpustakaan", 0)
+            idx = r.get("Rata2_Indeks_Final_0_100", np.nan)
+            sf  = r.get("Rata2_SamplingFactor", np.nan)
             if pd.isna(idx):
                 continue
-            lines.append(f"- {jp}: jumlah sampel={int(n)}, rata-rata indeks={idx:.2f}")
-
-    # Contoh perpustakaan dengan indeks yang bervariasi (top-3 dan bottom-3)
-    if "Indeks_Real_0_100" in detail_df.columns:
-        df_valid = detail_df.dropna(subset=["Indeks_Real_0_100"]).copy()
-
-        if "Confidence_IPLM" in df_valid.columns:
-            df_valid = df_valid.sort_values("Confidence_IPLM", ascending=False)
-
-        col_nama = nama_col_glob if (nama_col_glob and nama_col_glob in df_valid.columns) else None
-        if not df_valid.empty and col_nama:
-            top3 = df_valid.sort_values("Indeks_Real_0_100", ascending=False).head(3)
-            bottom3 = df_valid.sort_values("Indeks_Real_0_100", ascending=True).head(3)
-
-            lines.append("\nContoh perpustakaan dengan indeks relatif lebih tinggi:")
-            for _, r in top3.iterrows():
-                lines.append(
-                    f"- {str(r[col_nama])}: indeks={r['Indeks_Real_0_100']:.2f}, "
-                    f"kepatuhan={r['dim_kepatuhan']:.3f}, kinerja={r['dim_kinerja']:.3f}"
-                )
-
-            lines.append("\nContoh perpustakaan dengan indeks yang masih perlu penguatan:")
-            for _, r in bottom3.iterrows():
-                lines.append(
-                    f"- {str(r[col_nama])}: indeks={r['Indeks_Real_0_100']:.2f}, "
-                    f"kepatuhan={r['dim_kepatuhan']:.3f}, kinerja={r['dim_kinerja']:.3f}"
-                )
-
-    # Ringkasan coverage (kalau ada verif_df)
+            lines.append(f"- {jp}: n={int(n)}, indeks final={idx:.2f}, sampling factor rata-rata={float(sf):.3f}")
+
     if verif_df is not None and not verif_df.empty:
-        try:
-            if "Coverage Perpus Sekolah vs Sekolah (%)" in verif_df.columns:
-                cov_sek = verif_df["Coverage Perpus Sekolah vs Sekolah (%)"]
-                if len(cov_sek.dropna()) > 0:
-                    avg_cov_sek = cov_sek.mean()
-                    lines.append(
-                        f"Rata-rata coverage perpustakaan sekolah terhadap SD+SMP: {avg_cov_sek:.2f}%"
-                    )
-            if "Coverage Perpus Umum vs Kec+Desa/Kel (%)" in verif_df.columns:
-                cov_umum = verif_df["Coverage Perpus Umum vs Kec+Desa/Kel (%)"]
-                if len(cov_umum.dropna()) > 0:
-                    avg_cov_umum = cov_umum.mean()
-                    lines.append(
-                        f"Rata-rata coverage perpustakaan umum terhadap kecamatan+desa/kelurahan: {avg_cov_umum:.2f}%"
-                    )
-        except Exception:
-            pass
+        lines.append("\nRingkasan verifikasi sampel (target 68%):")
+        # ambil rata-rata kekurangan jika ada
+        for c in ["Kurang_Sekolah_Menuju_68","Kurang_Umum_Menuju_68","Kurang_Menengah_Menuju_68"]:
+            if c in verif_df.columns:
+                try:
+                    lines.append(f"- Rata-rata {c}: {float(pd.to_numeric(verif_df[c], errors='coerce').fillna(0).mean()):.2f}")
+                except Exception:
+                    pass
 
     return "\n".join(lines)
 
-
-# ============================================================
-# 7a. RULE-BASED ANALYSIS (FALLBACK)
-# ============================================================
-
-def classify_level(x):
-    # dipertahankan hanya sebagai placeholder; tidak dipakai untuk teks penilaian
-    if pd.isna(x):
-        return "tidak tersedia"
-    if x < 40:
-        return "-"
-    if x < 60:
-        return "-"
-    return "-"
-
-
 def generate_rule_based_analysis(detail_df: pd.DataFrame,
                                  agg_df: pd.DataFrame,
                                  kab_name: str,
@@ -1133,420 +1002,246 @@ def generate_rule_based_analysis(detail_df: pd.DataFrame,
     if kew_value and kew_value != "(Semua)":
         wilayah = f"{kab_name} (kewenangan {kew_value})"
 
-    # Rata-rata indeks: utamakan baris "Rata-rata keseluruhan" di agg_df
-    if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
-        mask_total = agg_df["Jenis Perpustakaan"].astype(str).str.lower().str.startswith("rata-rata")
-        if mask_total.any():
-            try:
-                mean_ind = float(
-                    agg_df.loc[mask_total, "Rata2_Indeks_IPLM_0_100"].iloc[0]
-                )
-            except Exception:
-                mean_ind = detail_df.get("Indeks_Real_0_100", pd.Series(dtype=float)).mean(skipna=True)
-        else:
-            mean_ind = detail_df.get("Indeks_Real_0_100", pd.Series(dtype=float)).mean(skipna=True)
-    else:
-        mean_ind = detail_df.get("Indeks_Real_0_100", pd.Series(dtype=float)).mean(skipna=True)
-
+    mean_final = detail_df["Indeks_Final_0_100"].mean(skipna=True) if "Indeks_Final_0_100" in detail_df.columns else np.nan
     mean_kep = detail_df.get("dim_kepatuhan", pd.Series(dtype=float)).mean(skipna=True)
     mean_kin = detail_df.get("dim_kinerja", pd.Series(dtype=float)).mean(skipna=True)
-    mean_conf = detail_df.get("Confidence_IPLM", pd.Series(dtype=float)).mean(skipna=True)
+    mean_sf  = detail_df.get("SamplingFactor_Total", pd.Series(dtype=float)).mean(skipna=True)
 
     lines = []
     lines.append("## Analisis Otomatis & Rekomendasi Kebijakan (Rule-based)\n")
     lines.append("### Gambaran Umum Wilayah")
     lines.append(f"- Wilayah: {wilayah}")
     lines.append(f"- Jumlah perpustakaan dalam sampel: {len(detail_df)}")
-    lines.append(f"- Rata-rata Indeks IPLM 2025: {mean_ind:.2f}")
+    if not pd.isna(mean_final):
+        lines.append(f"- Rata-rata Indeks IPLM Final (setelah penalti 68%): {mean_final:.2f}")
     lines.append(f"- Rata-rata dimensi kepatuhan (0–1): {mean_kep:.3f}")
     lines.append(f"- Rata-rata dimensi kinerja (0–1): {mean_kin:.3f}")
-    if not pd.isna(mean_conf):
-        lines.append(f"- Rata-rata Confidence_IPLM: {mean_conf:.2f}")
+    if not pd.isna(mean_sf):
+        lines.append(f"- Rata-rata SamplingFactor_Total (0–1): {mean_sf:.3f}")
 
-    lines.append("\n### Capaian per Jenis Perpustakaan")
-    if agg_df is not None and not agg_df.empty:
-        for _, r in agg_df.iterrows():
-            jp = str(r.get("Jenis Perpustakaan", "") or "")
-            if not jp or jp.lower().startswith("rata-rata"):
-                continue
-            idx = r.get("Rata2_Indeks_IPLM_0_100", np.nan)
-            n = int(r.get("Jumlah Perpustakaan", 0))
-            if pd.isna(idx):
-                continue
-            lines.append(f"- {jp}: rata-rata indeks {idx:.2f} dengan {n} perpustakaan.")
-    else:
-        lines.append("- Data agregat per jenis perpustakaan tidak tersedia.")
-
-    lines.append("\n### Arah Kebijakan dan Rekomendasi Program")
+    lines.append("\n### Implikasi & Arah Kebijakan")
     lines.append(
-        "Prioritas utama adalah penguatan layanan dasar perpustakaan serta peningkatan "
-        "ketersediaan SDM dan koleksi. Pola capaian pada dimensi kepatuhan menunjukkan bahwa "
-        "aspek koleksi, kebijakan layanan, dan kualifikasi pustakawan masih memiliki ruang penguatan "
-        "dan perlu dibenahi secara terencana. Sementara itu, capaian dimensi kinerja mengindikasikan "
-        "bahwa intensitas pemanfaatan dan kegiatan literasi perlu diperluas agar perpustakaan "
-        "lebih konsisten berfungsi sebagai pusat belajar masyarakat."
+        "Hasil indeks final merefleksikan capaian kinerja layanan perpustakaan yang telah dikoreksi oleh tingkat "
+        "kecukupan sampel terhadap target 68%. Artinya, konsistensi data dan cakupan pembinaan berpengaruh langsung "
+        "terhadap interpretasi capaian wilayah. Penguatan pengisian data dan perluasan unit yang terjangkau perlu "
+        "dikelola sebagai bagian integral dari perbaikan layanan."
     )
     lines.append(
-        "Program-program yang dapat diprioritaskan antara lain: peningkatan alokasi anggaran "
-        "untuk pengembangan koleksi mutakhir, penguatan kapasitas pustakawan melalui pelatihan "
-        "berkelanjutan, perluasan kegiatan budaya baca yang menyasar komunitas rentan, serta "
-        "kolaborasi lintas sektor dengan satuan pendidikan, organisasi masyarakat, dan pelaku "
-        "usaha lokal. Seluruh intervensi perlu disertai mekanisme monitoring dan evaluasi "
-        "berbasis data IPLM agar perbaikan yang dilakukan dapat terpantau dari waktu ke waktu."
-    )
-
-    lines.append(
-        "\n> Catatan: analisis ini disusun secara otomatis berbasis data IPLM. "
-        "Untuk penetapan kebijakan, tetap diperlukan verifikasi lapangan dan kajian kualitatif tambahan."
+        "Program prioritas dapat diarahkan pada: peningkatan kelengkapan dan kualitas data indikator, "
+        "penguatan ketersediaan koleksi dan SDM, perluasan kegiatan literasi dan pemanfaatan layanan, serta "
+        "konsolidasi kolaborasi lintas sektor untuk memastikan jangkauan unit (sekolah/administratif) mendekati target."
     )
 
     return "\n".join(lines)
 
-
-# ============================================================
-# 7b. ANALISIS BERBASIS LLM (DENGAN FALLBACK RULE-BASED)
-# ============================================================
-
 def generate_llm_analysis(detail_df: pd.DataFrame,
                           agg_df: pd.DataFrame,
                           verif_df: pd.DataFrame,
                           kab_name: str,
                           kew_value: str) -> str:
-    """
-    Analisis otomatis:
-    - Jika pemanggilan LLM gagal -> fallback ke rule-based dengan pesan error ringkas.
-    """
-
     context = build_context_for_llm(detail_df, agg_df, verif_df, kab_name, kew_value)
-
     client = get_llm_client()
     if client is None or not USE_LLM:
-        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
-        return (
-            "⚠️ Terjadi kendala saat menginisialisasi model LLM, sehingga analisis otomatis "
-            "saat ini menggunakan pendekatan **rule-based**.\n\n"
-            + rb
-        )
+        return "⚠️ LLM tidak tersedia. Berikut analisis rule-based.\n\n" + generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
 
     system_prompt = (
-        "Anda adalah analis kebijakan perpustakaan dan literasi yang berpengalaman di Indonesia. "
-        "Tugas Anda adalah membaca ringkasan data Indeks Pembangunan Literasi Masyarakat (IPLM) "
-        "dan menyusun analisis kebijakan yang tajam, tetapi tetap komunikatif dan mudah dipahami "
-        "oleh pemangku kepentingan pemerintah daerah."
+        "Anda adalah analis kebijakan perpustakaan dan literasi di Indonesia. "
+        "Anda membaca ringkasan IPLM (indeks final sudah mempertimbangkan penalti sampling 68%) "
+        "dan menyusun analisis kebijakan yang tajam namun komunikatif."
     )
 
     user_prompt = f"""
-DATA RINGKAS IPLM UNTUK WILAYAH BERIKUT:
+DATA RINGKAS IPLM:
 
 {context}
 
 TULISKAN ANALISIS DALAM BAHASA INDONESIA FORMAL, DENGAN STRUKTUR:
-
-1. Gambaran umum kondisi perpustakaan di wilayah tersebut (1 paragraf).
-2. Analisis capaian indeks: soroti kekuatan dan area yang masih memerlukan penguatan, terutama perbedaan antar jenis perpustakaan dan sebutkan jenis perpustakaaannya (2 paragraf).
-3. Analisis risiko dan kesenjangan layanan, termasuk jika coverage perpustakaan terhadap satuan pendidikan atau wilayah administratif masih terbatas (1–2 paragraf).
-4. Rekomendasi program dan kebijakan prioritas yang konkret untuk 3–5 tahun ke depan. Susun dalam bentuk paragraf naratif, bukan bullet list (2 paragraf).
-
-PANDUAN GAYA:
-- Jangan hanya mengulang angka apa adanya, tetapi jelaskan maknanya.
-- Jangan menggunakan istilah penilaian eksplisit seperti "rendah", "sedang", atau "tinggi" untuk menyebut nilai indeks.
-  Gunakan frasa netral seperti "masih memiliki ruang penguatan", "belum sesuai harapan", atau "perlu konsolidasi".
-- Gunakan istilah kebijakan publik dan manajemen program perpustakaan ketika relevan.
-- Hindari kalimat terlalu panjang; gunakan kalimat efektif dan jelas.
+1) Gambaran umum (1 paragraf).
+2) Analisis capaian indeks final dan dimensi (2 paragraf).
+3) Analisis kesenjangan cakupan berbasis target 68% (1 paragraf).
+4) Rekomendasi program prioritas 3–5 tahun (2 paragraf naratif).
+
+GAYA:
+- Jangan gunakan label penilaian eksplisit "rendah/sedang/tinggi".
+- Gunakan frasa netral: "memerlukan penguatan", "perlu konsolidasi", "belum sesuai harapan".
 """
 
     try:
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ]
-
         resp = client.chat_completion(
             model=LLM_MODEL_NAME,
-            messages=messages,
-            max_tokens=1000,
+            messages=[{"role":"system","content":system_prompt},{"role":"user","content":user_prompt}],
+            max_tokens=900,
             temperature=0.25,
             top_p=0.9,
         )
-
         text = resp.choices[0].message.content.strip()
         if not text:
             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 (
-            "⚠️ Terjadi error saat memanggil model LLM, sehingga analisis berikut "
-            "dibuat menggunakan pendekatan **rule-based**.\n\n"
-            f"(Detail teknis: {repr(e)})\n\n"
-            f"{rb}"
-        )
-
+        return "⚠️ Error LLM, fallback rule-based.\n\n" + generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value) + f"\n\n(Detail teknis: {repr(e)})"
 
 # ============================================================
-# 8. WORD REPORT (Plotly Pie + Indeks + Agregat + LLM Narrative)
+# 9) WORD REPORT (opsional)
 # ============================================================
 
-from docx import Document
-from docx.shared import Inches
-import plotly.express as px
+HAS_DOCX = True
+try:
+    from docx import Document
+    from docx.shared import Inches
+except Exception:
+    HAS_DOCX = False
 
-# Cek apakah kaleido tersedia
+HAS_KALEIDO = True
 try:
     import kaleido  # noqa: F401
-    HAS_KALEIDO = True
 except Exception:
     HAS_KALEIDO = False
 
-
-def make_pie_plotly(num, den, title):
-    """
-    Generate pie chart PNG menggunakan Plotly.
-    Jika kaleido tidak tersedia / gagal, return None (tanpa error).
-    """
-    if not HAS_KALEIDO:
-        return None
-
-    if den is None or den <= 0:
-        values = [0, 1]
-        labels = ["Terjangkau", "Belum Terjangkau"]
-    else:
-        values = [num, max(den - num, 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_all(detail_df, agg_df, verif_df, prov, kab, kew, analysis_text):
-    """
-    Membuat laporan lengkap untuk wilayah yang dipilih:
-    - Ringkasan indeks
-    - Tabel agregat
-    - (opsional) Pie chart coverage
-    - Narasi otomatis (LLM/rule-based)
-    """
-    # Tidak berlaku untuk PUSAT
-    if kew == "PUSAT":
+    if not HAS_DOCX:
         return None
 
-    wilayah = kab if kab != "(Semua)" else prov
-
+    wilayah = kab if kab and kab != "(Semua)" else (prov if prov and prov != "(Semua)" else "NASIONAL")
     doc = Document()
     doc.add_heading(f"Laporan IPLM – {wilayah}", level=1)
 
-    # =====================
-    # 1. Ringkasan Indeks
-    # =====================
     doc.add_heading("Ringkasan Indeks", level=2)
-
-    # Rata-rata Indeks: pakai agregat "Rata-rata keseluruhan" agar konsisten
-    if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
-        mask_total = agg_df["Jenis Perpustakaan"].astype(str).str.lower().str.startswith("rata-rata")
-        if mask_total.any():
-            try:
-                mean_ind = float(
-                    agg_df.loc[mask_total, "Rata2_Indeks_IPLM_0_100"].iloc[0]
-                )
-            except Exception:
-                mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
-        else:
-            mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
-    else:
-        mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
-
-    mean_kep = detail_df["dim_kepatuhan"].mean(skipna=True)
-    mean_kin = detail_df["dim_kinerja"].mean(skipna=True)
-    mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
+    mean_final = float(detail_df["Indeks_Final_0_100"].mean(skipna=True)) if "Indeks_Final_0_100" in detail_df.columns else np.nan
+    mean_kep = float(detail_df["dim_kepatuhan"].mean(skipna=True)) if "dim_kepatuhan" in detail_df.columns else np.nan
+    mean_kin = float(detail_df["dim_kinerja"].mean(skipna=True)) if "dim_kinerja" in detail_df.columns else np.nan
+    mean_sf  = float(detail_df["SamplingFactor_Total"].mean(skipna=True)) if "SamplingFactor_Total" in detail_df.columns else np.nan
 
     doc.add_paragraph(f"- Jumlah perpustakaan: {len(detail_df)}")
-    doc.add_paragraph(f"- Rata-rata Indeks IPLM: {mean_ind:.2f}")
-    doc.add_paragraph(f"- Rata-rata Dimensi Kepatuhan (0–1): {mean_kep:.3f}")
-    doc.add_paragraph(f"- Rata-rata Dimensi Kinerja (0–1): {mean_kin:.3f}")
-    doc.add_paragraph(f"- Rata-rata Confidence IPLM: {mean_conf:.2f}")
-
-    # =====================
-    # 2. Tabel Agregat
-    # =====================
-    doc.add_heading("Ringkasan Agregat per Jenis Perpustakaan", level=2)
-
-    table = doc.add_table(rows=1, cols=len(agg_df.columns))
-    hdr = table.rows[0].cells
-    for i, c in enumerate(agg_df.columns):
-        hdr[i].text = str(c)
-
-    for _, row in agg_df.iterrows():
-        r = table.add_row().cells
+    if not np.isnan(mean_final): doc.add_paragraph(f"- Rata-rata Indeks IPLM Final (setelah penalti 68%): {mean_final:.2f}")
+    if not np.isnan(mean_kep):   doc.add_paragraph(f"- Rata-rata Dimensi Kepatuhan (0–1): {mean_kep:.3f}")
+    if not np.isnan(mean_kin):   doc.add_paragraph(f"- Rata-rata Dimensi Kinerja (0–1): {mean_kin:.3f}")
+    if not np.isnan(mean_sf):    doc.add_paragraph(f"- Rata-rata SamplingFactor_Total (0–1): {mean_sf:.3f}")
+
+    doc.add_heading("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
         for i, c in enumerate(agg_df.columns):
-            r[i].text = str(row[c])
+            hdr[i].text = str(c)
+        for _, row in agg_df.iterrows():
+            r = table.add_row().cells
+            for i, c in enumerate(agg_df.columns):
+                r[i].text = str(row[c])
+    else:
+        doc.add_paragraph("Agregat tidak tersedia.")
 
-    # =====================
-    # 3. PIE CHART COVERAGE (opsional)
-    # =====================
-    doc.add_heading("Coverage / Cakupan Pembinaan", level=2)
+    doc.add_heading("Verifikasi Sampel (Target 68%)", level=2)
+    if verif_df is not None and not verif_df.empty:
+        # limit baris agar docx tidak kelewat besar
+        preview = verif_df.head(50).copy()
+        table = doc.add_table(rows=1, cols=len(preview.columns))
+        hdr = table.rows[0].cells
+        for i, c in enumerate(preview.columns):
+            hdr[i].text = str(c)
+        for _, row in preview.iterrows():
+            r = table.add_row().cells
+            for i, c in enumerate(preview.columns):
+                r[i].text = str(row[c])
+        if len(verif_df) > 50:
+            doc.add_paragraph("Catatan: tabel dipotong sampai 50 baris pada laporan Word.")
+    else:
+        doc.add_paragraph("Verifikasi sampel tidak tersedia untuk filter ini.")
 
-    if not HAS_KALEIDO:
-        doc.add_paragraph(
-            "Grafik pie coverage tidak dibuat karena modul 'kaleido' "
-            "tidak tersedia di server. Hanya ringkasan teks yang ditampilkan."
-        )
-    elif verif_df is not None and not verif_df.empty:
-
-        if kew == "KAB/KOTA":
-            for _, r in verif_df.iterrows():
-                nama = r["Kab/Kota"]
-
-                # Sekolah SD+SMP
-                if "Sekolah (SD+SMP)" in verif_df.columns:
-                    img_path = make_pie_plotly(
-                        r["Perpus Sampel – Sekolah (Total SD+SMP)"],
-                        r["Sekolah (SD+SMP)"],
-                        f"Coverage Perpustakaan Sekolah – {nama}"
-                    )
-                    if img_path:
-                        doc.add_paragraph(f"Coverage Perpustakaan Sekolah – {nama}")
-                        doc.add_picture(img_path, width=Inches(4))
-
-                # Umum
-                if "Jumlah Kecamatan" in verif_df.columns and "Jumlah Desa/Kel" in verif_df.columns:
-                    denom = r["Jumlah Kecamatan"] + r["Jumlah Desa/Kel"]
-                    img_path = make_pie_plotly(
-                        r["Perpus Sampel – Umum"],
-                        denom,
-                        f"Coverage Perpustakaan Umum – {nama}"
-                    )
-                    if img_path:
-                        doc.add_paragraph(f"Coverage Perpustakaan Umum – {nama}")
-                        doc.add_picture(img_path, width=Inches(4))
-
-        elif kew == "PROVINSI":
-            for _, r in verif_df.iterrows():
-                nama = r["Provinsi_Label"]
-                img_path = make_pie_plotly(
-                    r["Jml_Perpus_SMA_Sampel"],
-                    r["Jml_SMA"],
-                    f"Coverage Perpustakaan SMA – {nama}"
-                )
-                if img_path:
-                    doc.add_paragraph(f"Coverage Perpustakaan SMA – {nama}")
-                    doc.add_picture(img_path, width=Inches(4))
-
-    # =====================
-    # 4. Narasi LLM / Rule-based
-    # =====================
     doc.add_heading("Analisis Naratif Otomatis", level=2)
     for paragraph in analysis_text.split("\n"):
         if paragraph.strip():
             doc.add_paragraph(paragraph)
 
-    # =====================
-    # Simpan
-    # =====================
     outpath = tempfile.mktemp(suffix=".docx")
     doc.save(outpath)
     return outpath
 
-
 # ============================================================
-# 8. FUNGSI GRADIO
+# 10) GRADIO UI
 # ============================================================
 
-def run_app(prov_value, kab_value, kew_value):
+def all_prov_choices():
+    if df_all_raw is None or prov_col_glob is None:
+        return ["(Semua)"]
+    s = df_all_raw[prov_col_glob].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_glob is None:
+        return ["(Semua)"]
+    if prov_value is None or prov_value == "(Semua)" or prov_col_glob is None:
+        s = df_all_raw[kab_col_glob].dropna().astype(str).str.strip()
+    else:
+        m = df_all_raw[prov_col_glob].astype(str).str.strip() == prov_value
+        s = df_all_raw.loc[m, kab_col_glob].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:
+        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 ["(Semua)"]
+
+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)")
+
+def on_prov_change(prov_value):
+    new_choices = get_kab_choices_for_prov(prov_value)
+    return gr.update(choices=new_choices, value="(Semua)")
+
+def run_app(prov_value, kab_value, kew_value):
+    if df_all_ipml is None or df_all_ipml.empty:
         empty = pd.DataFrame()
-        return (
-            empty, empty, empty,   # agg_df, detail_df, verif_df
-            None, None, None,      # agg_path, detail_path, raw_path
-            None,                  # word_path
-            None, None, None, None,  # fig_all, fig_sekolah, fig_umum, fig_khusus
-            "Data belum berhasil dimuat. Periksa kembali nama file di DATA_FILE.",
-            "Belum ada analisis otomatis yang dapat ditampilkan."
-        )
+        return (empty, empty, empty, None, None, None, None, None, None, None, None,
+                "Data belum berhasil dimuat atau pipeline nasional belum terbentuk.",
+                "Belum ada analisis otomatis.")
 
-    df = df_all_raw.copy()
+    df = df_all_ipml.copy()
 
-    # Filter provinsi
+    # filter prov
     if prov_col_glob and prov_value and prov_value != "(Semua)":
         df = df[df[prov_col_glob].astype(str).str.strip() == prov_value]
 
-    # Filter kab/kota
+    # filter kab
     if kab_col_glob and kab_value and kab_value != "(Semua)":
         df = df[df[kab_col_glob].astype(str).str.strip() == kab_value]
 
-    # Filter kewenangan
+    # filter kew
     if kew_value and kew_value != "(Semua)":
         df = df[df["KEW_NORM"] == kew_value]
 
-    if len(df) == 0:
+    if df.empty:
         empty = pd.DataFrame()
-        return (
-            empty, empty, empty,   # agg_df, detail_df, verif_df
-            None, None, None,      # agg_path, detail_path, raw_path
-            None,                  # word_path
-            None, None, None, None,  # fig_all, fig_sekolah, fig_umum, fig_khusus
-            "Tidak ada data untuk kombinasi filter yang dipilih.",
-            "Belum ada analisis otomatis yang dapat ditampilkan."
-        )
+        return (empty, empty, empty, None, None, None, None, None, None, None, None,
+                "Tidak ada data untuk kombinasi filter yang dipilih.",
+                "Belum ada analisis otomatis.")
 
     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"
 
-    (
-        agg_df,
-        detail_df,
-        agg_path,
-        detail_path,
-        raw_path,
-        fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
-    ) = run_pipeline_core(df, kab_name=kab_name, kew_name=kew_name)
+    agg_df, detail_df, agg_path, detail_path, raw_path, fig_all, fig_sek, fig_um, fig_kh = run_pipeline_core(df, kab_name=kab_name, kew_name=kew_name)
 
-    # Verifikasi sampel
     verif_df = compute_verification(df, kew_value)
 
-    # Pesan ringkas di UI (menggunakan detail_df lengkap)
-    mean_conf = None
-    if "Confidence_IPLM" in detail_df.columns:
-        mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
-
-    msg = f"Berhasil dihitung untuk {len(detail_df)} baris perpustakaan."
-    if mean_conf is not None and not np.isnan(mean_conf):
-        msg += f" | Rata-rata Confidence_IPLM: {mean_conf:.2f}"
-    if not verif_df.empty:
+    msg = f"Berhasil dihitung untuk {len(detail_df)} baris."
+    if "Indeks_Final_0_100" in detail_df.columns:
+        msg += f" | Rata-rata Indeks Final: {detail_df['Indeks_Final_0_100'].mean(skipna=True):.2f}"
+    if "SamplingFactor_Total" in detail_df.columns:
+        msg += f" | Rata-rata SamplingFactor: {detail_df['SamplingFactor_Total'].mean(skipna=True):.3f}"
+    if verif_df is not None and not verif_df.empty:
         msg += " | Verifikasi sampel tersedia."
 
-    # Analisis otomatis (LLM / rule-based) pakai detail_df lengkap
-    analysis_text = generate_llm_analysis(
-        detail_df=detail_df,
-        agg_df=agg_df,
-        verif_df=verif_df,
-        kab_name=kab_name,
-        kew_value=kew_value,
-    )
+    analysis_text = generate_llm_analysis(detail_df, agg_df, verif_df, kab_name, kew_value)
 
-    # Laporan Word (pakai detail_df lengkap)
-    word_path = generate_word_report_all(
-        detail_df, agg_df, verif_df,
-        prov_value, kab_value, kew_value,
-        analysis_text
-    )
+    word_path = generate_word_report_all(detail_df, agg_df, verif_df, prov_value, kab_value, kew_value, analysis_text)
 
-    # === VIEW UNTUK UI: sembunyikan indeks normatif & confidence ===
+    # === VIEW UNTUK UI: sembunyikan normatif & confidence & adj (sesuai kebiasaan Anda) ===
     cols_hide = [
         "Indeks_Normatif_0_100",
         "Indeks_Normatif_AdjConf",
@@ -1560,100 +1255,74 @@ def run_app(prov_value, kab_value, kew_value):
 
     return (
         agg_df,
-        detail_df_view,   # yang tampil di UI sudah tanpa kolom normatif & confidence
+        detail_df_view,
         verif_df,
         agg_path,
         detail_path,
         raw_path,
         word_path,
         fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
+        fig_sek,
+        fig_um,
+        fig_kh,
         msg,
-        analysis_text,
+        analysis_text
     )
 
-
-def on_prov_change(prov_value):
-    if df_all_raw is None or kab_col_glob is None:
-        return gr.update(choices=["(Semua)"], value="(Semua)")
-    if prov_value is None or prov_value == "(Semua)" or prov_col_glob is None:
-        s = df_all_raw[kab_col_glob].dropna().astype(str).str.strip()
-    else:
-        m = df_all_raw[prov_col_glob].astype(str).str.strip() == prov_value
-        s = df_all_raw.loc[m, kab_col_glob].dropna().astype(str).str.strip()
-    vals = sorted([x for x in s.unique() if x != ""])
-    new_choices = ["(Semua)"] + vals
-    return gr.update(choices=new_choices, value="(Semua)")
-
-
-# ============================================================
-# 9. BUILD UI GRADIO
-# ============================================================
-
 with gr.Blocks() as demo:
     gr.Markdown(
         f"""
-        # IPLM 2025 – RealScore + Normatif + Verifikasi Sampel + Analisis Otomatis (LLM + Rule-based)
-
-        Dataset diambil langsung dari file di repository (tanpa upload):
+# IPLM 2025 — RealScore (nasional) + Penalti Sampling 68% + Normatif + Analisis Otomatis
 
-        - **`{DATA_FILE}`** – Data perpustakaan (semua jenis, multi-sheet).
-        - **`{META_KAB_FILE}`** – Jumlah kecamatan & desa/kel per kab/kota.
-        - **`{META_SDSMP_FILE}`** – Jumlah SD & SMP per kab/kota.
-        - **`{META_SMA_FILE}`** – Jumlah SMA per provinsi.
+Sumber file (dibaca dari repository):
+- **`{DATA_FILE}`** — Data perpustakaan (multi-sheet OK)
+- **`{META_KAB_FILE}`** — Kecamatan & Desa/Kel per Kab/Kota
+- **`{META_SDSMP_FILE}`** — SD & SMP per Kab/Kota
+- **`{META_MENENGAH_FILE}`** — SMA+SMK+SLB per Kab/Kota (diagregasi jadi target provinsi)
 
-        {DATA_INFO}
-        """
+{DATA_INFO}
+"""
     )
 
     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=kab_choices[0])
+        dd_prov = gr.Dropdown(label="Provinsi", choices=prov_choices, value=prov_choices[0] if prov_choices else "(Semua)")
+        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=kab_choices, value="(Semua)")
         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,
-    )
+    dd_prov.change(fn=on_prov_change, inputs=dd_prov, outputs=dd_kab)
 
     run_btn = gr.Button("Jalankan Perhitungan")
     msg_out = gr.Markdown()
 
-    gr.Markdown("### Hasil Agregat (RealScore) per Jenis Perpustakaan")
+    gr.Markdown("### Hasil Agregat (Indeks Final = RealScore × Penalti 68%) per Jenis Perpustakaan")
     agg_df_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("### Detail Indeks (Real) per Perpustakaan")
+    gr.Markdown("### Detail Indeks per Perpustakaan (tampilan disederhanakan)")
     detail_df_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("### Verifikasi Kondisi Sampel di Lapangan")
-    verif_df_out = gr.DataFrame(
-        label="Perbandingan jumlah sampel dengan populasi unit (SD/SMP/SMA, Kecamatan, Desa/Kel)",
-        interactive=False
-    )
+    gr.Markdown("### Verifikasi Sampel (Target 68% + Kekurangan + Sampling Factor)")
+    verif_df_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("### Sebaran Indeks – Semua Perpustakaan (RealScore)")
+    gr.Markdown("### Sebaran Indeks Final – Semua")
     bell_all_out = gr.Plot()
 
-    gr.Markdown("### Sebaran Indeks – Perpustakaan Sekolah")
+    gr.Markdown("### Sebaran Indeks Final – Sekolah")
     bell_sekolah_out = gr.Plot()
 
-    gr.Markdown("### Sebaran Indeks – Perpustakaan Umum")
+    gr.Markdown("### Sebaran Indeks Final – Umum")
     bell_umum_out = gr.Plot()
 
-    gr.Markdown("### Sebaran Indeks – Perpustakaan Khusus")
+    gr.Markdown("### Sebaran Indeks Final – Khusus")
     bell_khusus_out = gr.Plot()
 
     gr.Markdown("### Analisis Otomatis & Rekomendasi Kebijakan")
     analysis_out = gr.Markdown()
 
     with gr.Row():
-        agg_file_out   = gr.File(label="Download File Agregat (.xlsx)")
-        detail_file_out = gr.File(label="Download File Detail (.xlsx)")
-        raw_file_out   = gr.File(label="Download Data Mentah (.xlsx)")
-        word_file_out  = gr.File(label="Download Laporan Word (.docx)")
+        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)")
 
     run_btn.click(
         fn=run_app,