Update app.py

app.py

@@ -1,18 +1,18 @@
 # -*- coding: utf-8 -*-
 """
-app.py — IPLM 2025 (RINGKAS OUTPUT: SUBDIM+DIM+FINAL SAJA + BELL CURVE FINAL)
-- Nasional: Yeo-Johnson + MinMax sekali nasional
-- RealScore dihitung internal
-- FinalScore = RealScore * bobot_coverage_68 (internal)
-- OUTPUT UI:
-  * Agregat: sub-dimensi + dimensi + Rata2_Indeks_Final_0_100
-  * Detail : sub-dimensi + dimensi + Indeks_Final_0_100
-  * Verifikasi: coverage/bobot dalam % integer, GAP integer (tanpa koma)
-  * Bell curve FINAL: all + per jenis
+IPLM 2025 — FINAL (NO UPLOAD)
+Penalti Coverage 68% + Bell Curve + Analisis LLM (Word)
+
+FIX UTAMA:
+1) Dropdown tidak error (callback tidak tergantung state None).
+2) Download tanpa upload: gunakan gr.DownloadButton (bukan gr.File).
+3) Cache loader berbasis mtime (hindari baca ulang).
+4) Penalti coverage aman: populasi missing/0 -> bobot=1 (tanpa penalti).
 """
 
 import os
 import re
+import time
 import tempfile
 from pathlib import Path
 
@@ -22,22 +22,39 @@ import pandas as pd
 import plotly.graph_objects as go
 from sklearn.preprocessing import PowerTransformer
 
+from docx import Document
+from huggingface_hub import InferenceClient
+
+
 # ============================================================
-# 1) KONFIGURASI FILE
+# 1) KONFIGURASI FILE & PARAMETER
 # ============================================================
 
-DATA_FILE = "IPLM_clean_manual_131225.xlsx"
-POP_KAB   = "Data_populasi_Kab_kota.xlsx"
-POP_PROV  = "Data_populasi_propinsi.xlsx"
+DATA_FILE = os.getenv("DATA_FILE", "IPLM_clean_manual_131225.xlsx")
+POP_KAB   = os.getenv("POP_KAB",   "Data_populasi_Kab_kota.xlsx")
+POP_PROV  = os.getenv("POP_PROV",  "Data_populasi_propinsi.xlsx")
+
+TARGET_COVERAGE = float(os.getenv("TARGET_COVERAGE", "0.68"))
+W_KEPATUHAN     = float(os.getenv("W_KEPATUHAN", "0.30"))
+W_KINERJA       = float(os.getenv("W_KINERJA",   "0.70"))
 
-TARGET_COVERAGE = 0.68
-W_KEPATUHAN = 0.30
-W_KINERJA   = 0.70
+USE_LLM = True
+LLM_MODEL_NAME = os.getenv("LLM_MODEL_NAME", "meta-llama/Meta-Llama-3-8B-Instruct")
+HF_TOKEN = (
+    os.getenv("HF_SECRET")
+    or os.getenv("HF_TOKEN")
+    or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    or os.getenv("HF_API_TOKEN")
+)
 
 # ============================================================
 # 2) UTIL
 # ============================================================
 
+def _mtime(path_str: str):
+    p = Path(path_str)
+    return p.stat().st_mtime if p.exists() else None
+
 def _canon(s: str) -> str:
     return re.sub(r"[^a-z0-9]+", "", str(s).lower())
 
@@ -48,9 +65,11 @@ def _disp_text(x):
     return " ".join(t.split())
 
 def pick_col(df, candidates):
+    # exact
     for c in candidates:
         if c in df.columns:
             return c
+    # canon
     can_map = {_canon(c): c for c in df.columns}
     for c in candidates:
         k = _canon(c)
@@ -125,10 +144,17 @@ def safe_div(num, den):
     return float(num) / float(den)
 
 def cap_bobot(cov: float) -> float:
+    # bobot normal: <68% -> cov/0.68, >=68% -> 1
     if cov is None or pd.isna(cov) or cov <= 0:
-        return 0.0
+        return np.nan
     return float(min(cov / TARGET_COVERAGE, 1.0))
 
+def safe_round2(x):
+    try:
+        return round(float(x), 2)
+    except Exception:
+        return 0.0
+
 def penalized_mean(row, cols):
     vals = []
     for c in cols:
@@ -140,11 +166,6 @@ def penalized_mean(row, cols):
             vals.append(float(v))
     return float(np.mean(vals)) if vals else 0.0
 
-def slugify(s: str) -> str:
-    if s is None:
-        return "NA"
-    t = str(s).strip()
-    return re.sub(r"[^A-Z0-9]+", "", t.upper()) or "NA"
 
 # ============================================================
 # 3) INDIKATOR IPLM
@@ -201,98 +222,9 @@ alias_map_raw = {
 }
 alias_map = {_canon(k): v for k, v in alias_map_raw.items()}
 
-# ============================================================
-# 4) LOAD DATA
-# ============================================================
-
-DATA_INFO = ""
-df_all_raw = None
-df_pop_kab = None
-df_pop_prov = None
-
-prov_col = kab_col = kew_col = jenis_col = nama_col = None
-
-# --- DM ---
-try:
-    fp = Path(DATA_FILE)
-    if not fp.exists():
-        raise FileNotFoundError(f"File tidak ditemukan: {DATA_FILE}")
-
-    xls = pd.ExcelFile(fp)
-    frames = [pd.read_excel(fp, sheet_name=s) for s in xls.sheet_names]
-    df_all_raw = pd.concat(frames, ignore_index=True, sort=False)
-
-    prov_col  = pick_col(df_all_raw, ["provinsi", "Provinsi", "PROVINSI"])
-    kab_col   = pick_col(df_all_raw, ["kab_kota", "Kab_Kota", "Kab/Kota", "KAB/KOTA", "kabupaten_kota"])
-    kew_col   = pick_col(df_all_raw, ["kewenangan", "jenis_kewenangan", "Kewenangan", "KEWENANGAN"])
-    jenis_col = pick_col(df_all_raw, ["jenis_perpustakaan", "Jenis Perpustakaan", "JENIS_PERPUSTAKAAN"])
-    nama_col  = pick_col(df_all_raw, ["nm_perpustakaan","nama_perpustakaan", "Nama Perpustakaan", "nm_instansi_lembaga"])
-
-    df_all_raw["KEW_NORM"] = df_all_raw[kew_col].apply(norm_kew) if kew_col else None
-
-    val_map_jenis = {
-        "PERPUSTAKAAN SEKOLAH": "sekolah", "SEKOLAH": "sekolah",
-        "PERPUSTAKAAN UMUM": "umum", "UMUM": "umum", "PERPUSTAKAAN DAERAH": "umum",
-        "PERPUSTAKAAN KHUSUS": "khusus", "KHUSUS": "khusus",
-    }
-    df_all_raw["_dataset"] = df_all_raw[jenis_col].astype(str).str.strip().str.upper().map(val_map_jenis) if jenis_col else None
-
-    df_all_raw["PROV_DISP"] = df_all_raw[prov_col].apply(_disp_text) if prov_col else None
-    df_all_raw["KAB_DISP"]  = df_all_raw[kab_col].apply(_disp_text)  if kab_col else None
-
-    DATA_INFO = f"✅ DM terbaca: **{DATA_FILE}** | Baris: **{len(df_all_raw)}**"
-except Exception as e:
-    df_all_raw = None
-    DATA_INFO = f"⚠️ Gagal memuat DM: `{e}`"
-
-# --- Pop Kab/Kota ---
-POP_INFO = []
-try:
-    pk = pd.read_excel(POP_KAB)
-    c_prov = pick_col(pk, ["PROVINSI","Provinsi"])
-    c_kab  = pick_col(pk, ["KABUPATEN_KOTA","Kab/Kota","Kabupaten/Kota","KAB/KOTA"])
-    c_pop_umum    = pick_col(pk, ["Pop_Umum","pop_umum","jumlah_populasi_umum"])
-    c_pop_sekolah = pick_col(pk, ["Pop_Sekolah","pop_sekolah","jumlah_populasi_sekolah"])
-
-    if c_kab is None:
-        raise ValueError("Kolom Kab/Kota tidak ditemukan di populasi kab/kota.")
-
-    df_pop_kab = pd.DataFrame({
-        "Provinsi_Label": pk[c_prov].astype(str).str.strip() if c_prov else None,
-        "Kab_Kota_Label": pk[c_kab].astype(str).str.strip(),
-        "Pop_Umum": pk[c_pop_umum].apply(coerce_num) if c_pop_umum else np.nan,
-        "Pop_Sekolah": pk[c_pop_sekolah].apply(coerce_num) if c_pop_sekolah else np.nan,
-    })
-    df_pop_kab["kab_key"] = df_pop_kab["Kab_Kota_Label"].apply(norm_kab_label)
-    POP_INFO.append(f"✅ Populasi Kab/Kota terbaca: **{POP_KAB}** (n={len(df_pop_kab)})")
-except Exception as e:
-    df_pop_kab = None
-    POP_INFO.append(f"⚠️ Gagal memuat populasi Kab/Kota: `{e}`")
-
-# --- Pop Provinsi ---
-try:
-    pp = pd.read_excel(POP_PROV)
-    c_prov = pick_col(pp, ["Provinsi","PROVINSI"])
-    c_total = pick_col(pp, ["total_pend","TOTAL_PEND","Pop_Sekolah_Prov","pop_sekolah_prov","sma"])
-    if c_prov is None or c_total is None:
-        raise ValueError("Kolom Provinsi / total_pend (atau ekuivalen) tidak ditemukan di populasi provinsi.")
-
-    df_pop_prov = pd.DataFrame({
-        "Provinsi_Label": pp[c_prov].astype(str).str.strip(),
-        "Pop_Sekolah_Prov": pp[c_total].apply(coerce_num),
-    })
-    df_pop_prov["prov_key"] = df_pop_prov["Provinsi_Label"].apply(norm_prov_label)
-    df_pop_prov = df_pop_prov.groupby("prov_key", as_index=False).agg({"Provinsi_Label":"first","Pop_Sekolah_Prov":"sum"})
-    POP_INFO.append(f"✅ Populasi Provinsi terbaca: **{POP_PROV}** (n={len(df_pop_prov)})")
-except Exception as e:
-    df_pop_prov = None
-    POP_INFO.append(f"⚠️ Gagal memuat populasi Provinsi: `{e}`")
-
-if POP_INFO:
-    DATA_INFO = DATA_INFO + "<br>" + "<br>".join(POP_INFO)
 
 # ============================================================
-# 5) PIPELINE NASIONAL: YJ + MINMAX + DIM/SUBDIM + REAL
+# 4) PIPELINE NASIONAL: YJ + MINMAX + SUBDIM/DIM/REAL
 # ============================================================
 
 def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
@@ -300,6 +232,7 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
         return df_src
     df = df_src.copy()
 
+    # rename indikator ke baku
     rename_map = {}
     for col in df.columns:
         c = _canon(col)
@@ -314,9 +247,11 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
         df = df.rename(columns=rename_map)
 
     available = [c for c in all_indicators if c in df.columns]
+
     for c in available:
         df[c] = df[c].apply(coerce_num)
 
+    # YJ + minmax nasional
     for c in available:
         x = df[c].astype(float).values
         mask = ~np.isnan(x)
@@ -328,27 +263,163 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
             transformed[mask] = x[mask]
         df[f"norm_{c}"] = minmax_norm(pd.Series(transformed, index=df.index))
 
-    df["sub_koleksi"] = df.apply(lambda r: penalized_mean(r, [c for c in koleksi_cols if c in available]), axis=1)
-    df["sub_sdm"] = df.apply(lambda r: penalized_mean(r, [c for c in sdm_cols if c in available]), axis=1)
-    df["sub_pelayanan"] = df.apply(lambda r: penalized_mean(r, [c for c in pelayanan_cols if c in available]), axis=1)
+    df["sub_koleksi"]     = df.apply(lambda r: penalized_mean(r, [c for c in koleksi_cols if c in available]), axis=1)
+    df["sub_sdm"]         = df.apply(lambda r: penalized_mean(r, [c for c in sdm_cols if c in available]), axis=1)
+    df["sub_pelayanan"]   = df.apply(lambda r: penalized_mean(r, [c for c in pelayanan_cols if c in available]), axis=1)
     df["sub_pengelolaan"] = df.apply(lambda r: penalized_mean(r, [c for c in pengelolaan_cols if c in available]), axis=1)
 
     df["dim_kepatuhan"] = df[["sub_koleksi","sub_sdm"]].mean(axis=1)
     df["dim_kinerja"]   = df[["sub_pelayanan","sub_pengelolaan"]].mean(axis=1)
 
     df["Indeks_Real_0_100"] = 100 * (W_KEPATUHAN * df["dim_kepatuhan"] + W_KINERJA * df["dim_kinerja"])
+
     for c in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja","Indeks_Real_0_100"]:
         df[c] = df[c].fillna(0.0)
 
     return df
 
-df_all = prepare_global(df_all_raw) if df_all_raw is not None else None
 
 # ============================================================
-# 6) COVERAGE -> FINAL + VERIF (NO DECIMALS)
+# 5) CACHE LOADER (NO UPLOAD)
+# ============================================================
+
+_CACHE = {
+    "key": None,
+    "df_all": None,
+    "pop_kab": None,
+    "pop_prov": None,
+    "meta": None,
+    "info": None,
+}
+
+def load_default_files(force=False):
+    key = (DATA_FILE, POP_KAB, POP_PROV, _mtime(DATA_FILE), _mtime(POP_KAB), _mtime(POP_PROV))
+
+    if (not force) and _CACHE["key"] == key and _CACHE["df_all"] is not None:
+        return _CACHE["df_all"], _CACHE["pop_kab"], _CACHE["pop_prov"], _CACHE["meta"], _CACHE["info"]
+
+    # cek file
+    for p, label in [(DATA_FILE, "DM"), (POP_KAB, "POP_KAB"), (POP_PROV, "POP_PROV")]:
+        if not Path(p).exists():
+            info = f"❌ File {label} tidak ditemukan: `{p}`"
+            _CACHE.update({"key": key, "df_all": None, "pop_kab": None, "pop_prov": None, "meta": {}, "info": info})
+            return None, None, None, {}, info
+
+    # baca DM multi-sheet
+    fp = Path(DATA_FILE)
+    xls = pd.ExcelFile(fp)
+    frames = [pd.read_excel(fp, sheet_name=s) for s in xls.sheet_names]
+    df_raw = pd.concat(frames, ignore_index=True, sort=False)
+
+    prov_col  = pick_col(df_raw, ["provinsi", "Provinsi", "PROVINSI"])
+    kab_col   = pick_col(df_raw, ["kab_kota", "Kab/Kota", "Kab_Kota", "KAB/KOTA", "kabupaten_kota", "kota"])
+    kew_col   = pick_col(df_raw, ["kewenangan", "jenis_kewenangan", "Kewenangan", "KEWENANGAN"])
+    jenis_col = pick_col(df_raw, ["jenis_perpustakaan", "Jenis Perpustakaan", "JENIS_PERPUSTAKAAN"])
+    nama_col  = pick_col(df_raw, ["nm_perpustakaan","nama_perpustakaan", "Nama Perpustakaan", "nm_instansi_lembaga","nm_perpus"])
+
+    missing = []
+    if prov_col is None:  missing.append("Provinsi")
+    if kab_col is None:   missing.append("Kab/Kota")
+    if kew_col is None:   missing.append("Kewenangan")
+    if jenis_col is None: missing.append("Jenis Perpustakaan")
+    if missing:
+        info = f"❌ Kolom wajib tidak ditemukan di DM: {', '.join(missing)}"
+        _CACHE.update({"key": key, "df_all": None, "pop_kab": None, "pop_prov": None, "meta": {}, "info": info})
+        return None, None, None, {}, info
+
+    # normalisasi jenis
+    val_map_jenis = {
+        "PERPUSTAKAAN SEKOLAH": "sekolah", "SEKOLAH": "sekolah",
+        "PERPUSTAKAAN UMUM": "umum", "UMUM": "umum", "PERPUSTAKAAN DAERAH": "umum",
+        "PERPUSTAKAAN KHUSUS": "khusus", "KHUSUS": "khusus",
+    }
+
+    df_raw["KEW_NORM"]  = df_raw[kew_col].apply(norm_kew)
+    df_raw["_dataset"]  = df_raw[jenis_col].astype(str).str.strip().str.upper().map(val_map_jenis)
+    df_raw["PROV_DISP"] = df_raw[prov_col].apply(_disp_text)
+    df_raw["KAB_DISP"]  = df_raw[kab_col].apply(_disp_text)
+
+    # DEDUP
+    if nama_col and nama_col in df_raw.columns:
+        kcols = [prov_col, kab_col, kew_col, jenis_col, nama_col]
+    else:
+        kcols = [prov_col, kab_col, kew_col, jenis_col]
+
+    tmp = df_raw[kcols].astype(str).fillna("").apply(lambda s: s.str.strip(), axis=0)
+    df_raw["_row_key"] = tmp.apply(lambda r: "||".join(r.values.tolist()), axis=1).apply(_canon)
+    before = len(df_raw)
+    df_raw = df_raw.drop_duplicates(subset=["_row_key"], keep="first").copy()
+    after = len(df_raw)
+
+    # POP KAB
+    pk = pd.read_excel(POP_KAB)
+    c_prov = pick_col(pk, ["PROVINSI","Provinsi"])
+    c_kab  = pick_col(pk, ["KABUPATEN_KOTA","Kab/Kota","Kabupaten/Kota","KAB/KOTA","Kabupaten_Kota"])
+    c_pop_umum    = pick_col(pk, ["Pop_Umum","pop_umum","jumlah_populasi_umum","POP_UMUM"])
+    c_pop_sekolah = pick_col(pk, ["Pop_Sekolah","pop_sekolah","jumlah_populasi_sekolah","POP_SEKOLAH"])
+
+    if c_kab is None:
+        info = "❌ Populasi Kab/Kota: kolom Kab/Kota tidak ditemukan."
+        _CACHE.update({"key": key, "df_all": None, "pop_kab": None, "pop_prov": None, "meta": {}, "info": info})
+        return None, None, None, {}, info
+
+    pop_kab = pd.DataFrame({
+        "Provinsi_Label": pk[c_prov].astype(str).str.strip() if c_prov else "",
+        "Kab_Kota_Label": pk[c_kab].astype(str).str.strip(),
+        "Pop_Umum": pk[c_pop_umum].apply(coerce_num) if c_pop_umum else np.nan,
+        "Pop_Sekolah": pk[c_pop_sekolah].apply(coerce_num) if c_pop_sekolah else np.nan,
+    })
+    pop_kab["kab_key"] = pop_kab["Kab_Kota_Label"].apply(norm_kab_label)
+    pop_kab = pop_kab.groupby("kab_key", as_index=False).agg({
+        "Kab_Kota_Label":"first",
+        "Provinsi_Label":"first",
+        "Pop_Umum":"max",
+        "Pop_Sekolah":"max",
+    })
+
+    # POP PROV
+    pp = pd.read_excel(POP_PROV)
+    c_pr = pick_col(pp, ["Provinsi","PROVINSI","provinsi"])
+    c_total = pick_col(pp, ["total_pend","TOTAL_PEND","Pop_Sekolah_Prov","pop_sekolah_prov","sma","SMA","TOTAL_SMA","total_sma"])
+    if c_pr is None or c_total is None:
+        info = "❌ Populasi Provinsi: kolom Provinsi / total populasi sekolah tidak ditemukan."
+        _CACHE.update({"key": key, "df_all": None, "pop_kab": None, "pop_prov": None, "meta": {}, "info": info})
+        return None, None, None, {}, info
+
+    pop_prov = pd.DataFrame({
+        "Provinsi_Label": pp[c_pr].astype(str).str.strip(),
+        "Pop_Sekolah_Prov": pp[c_total].apply(coerce_num),
+    })
+    pop_prov["prov_key"] = pop_prov["Provinsi_Label"].apply(norm_prov_label)
+    pop_prov = pop_prov.groupby("prov_key", as_index=False).agg({
+        "Provinsi_Label":"first",
+        "Pop_Sekolah_Prov":"sum",
+    })
+
+    # PIPELINE NASIONAL (sekali)
+    df_all = prepare_global(df_raw)
+
+    meta = dict(
+        prov_col=prov_col, kab_col=kab_col, kew_col=kew_col, jenis_col=jenis_col, nama_col=nama_col
+    )
+
+    info = (
+        f"✅ Mode NO UPLOAD (cache aktif)<br>"
+        f"✅ DM: <b>{fp.name}</b> | Baris: {before} → dedup: {after}<br>"
+        f"✅ Pop Kab/Kota: <b>{Path(POP_KAB).name}</b> (n={len(pop_kab)})<br>"
+        f"✅ Pop Provinsi: <b>{Path(POP_PROV).name}</b> (n={len(pop_prov)})<br>"
+        f"🕒 mtime: DM={time.ctime(_mtime(DATA_FILE))} | Kab={time.ctime(_mtime(POP_KAB))} | Prov={time.ctime(_mtime(POP_PROV))}"
+    )
+
+    _CACHE.update({"key": key, "df_all": df_all, "pop_kab": pop_kab, "pop_prov": pop_prov, "meta": meta, "info": info})
+    return df_all, pop_kab, pop_prov, meta, info
+
+
+# ============================================================
+# 6) PENALTI 68% -> FINAL + VERIF (NO DECIMALS)
 # ============================================================
 
-def compute_final(df_filtered: pd.DataFrame, kew_value: str):
+def apply_penalty_68(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, pop_prov: pd.DataFrame, kew_value: str):
     if df_filtered is None or df_filtered.empty:
         return df_filtered, pd.DataFrame()
 
@@ -357,15 +428,22 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
 
     df["bobot_coverage"] = 1.0
     df["coverage"] = np.nan
+    verif_df = pd.DataFrame()
+
+    def _bobot_or_one(b):
+        if b is None or pd.isna(b):
+            return 1.0
+        return float(b)
 
-    if ("KAB" in kew_norm or "KOTA" in kew_norm) and kab_col and df_pop_kab is not None:
+    # --- KAB/KOTA ---
+    if ("KAB" in kew_norm or "KOTA" in kew_norm) and pop_kab is not None and not pop_kab.empty:
         tmp = df.copy()
         tmp["kab_key"] = tmp["KAB_DISP"].apply(norm_kab_label)
 
         g = tmp.groupby(["kab_key","_dataset"]).size().rename("n_sampel").reset_index()
         g_piv = g.pivot(index="kab_key", columns="_dataset", values="n_sampel").fillna(0)
 
-        pop = df_pop_kab.set_index("kab_key")
+        pop = pop_kab.set_index("kab_key")
 
         rows = []
         for kk in g_piv.index:
@@ -400,8 +478,10 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
             })
 
         verif_df = pd.DataFrame(rows)
+        verif_df["Catatan"] = ""
+        verif_df.loc[verif_df["Pop_Sekolah"].isna() | (verif_df["Pop_Sekolah"] <= 0), "Catatan"] += "Pop_Sekolah_tidak_valid; "
+        verif_df.loc[verif_df["Pop_Umum"].isna() | (verif_df["Pop_Umum"] <= 0), "Catatan"] += "Pop_Umum_tidak_valid; "
 
-        # bulatkan TANPA koma
         int_cols = ["Pop_Sekolah","Sampel_Sekolah","GAP_Ke_68_Sekolah","Pop_Umum","Sampel_Umum","GAP_Ke_68_Umum"]
         pct_cols = ["Coverage_Sekolah_%","Bobot_Sekolah_68_%","Coverage_Umum_%","Bobot_Umum_68_%"]
         for c in int_cols:
@@ -411,11 +491,11 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
             if c in verif_df.columns:
                 verif_df[c] = verif_df[c].fillna(0).round(0).astype(int)
 
-        bobot_map_sek = {norm_kab_label(r["Kab/Kota"]): float(r["Bobot_Sekolah_68_%"]) / 100.0 for _, r in verif_df.iterrows()}
-        bobot_map_um  = {norm_kab_label(r["Kab/Kota"]): float(r["Bobot_Umum_68_%"]) / 100.0    for _, r in verif_df.iterrows()}
+        bobot_map_sek = {norm_kab_label(r["Kab/Kota"]): _bobot_or_one(float(r["Bobot_Sekolah_68_%"]) / 100.0) for _, r in verif_df.iterrows()}
+        bobot_map_um  = {norm_kab_label(r["Kab/Kota"]): _bobot_or_one(float(r["Bobot_Umum_68_%"]) / 100.0)    for _, r in verif_df.iterrows()}
 
-        cov_map_sek = {norm_kab_label(r["Kab/Kota"]): float(r["Coverage_Sekolah_%"]) / 100.0 for _, r in verif_df.iterrows()}
-        cov_map_um  = {norm_kab_label(r["Kab/Kota"]): float(r["Coverage_Umum_%"]) / 100.0    for _, r in verif_df.iterrows()}
+        cov_map_sek = {norm_kab_label(r["Kab/Kota"]): (float(r["Coverage_Sekolah_%"]) / 100.0) for _, r in verif_df.iterrows()}
+        cov_map_um  = {norm_kab_label(r["Kab/Kota"]): (float(r["Coverage_Umum_%"]) / 100.0)    for _, r in verif_df.iterrows()}
 
         df["kab_key"] = df["KAB_DISP"].apply(norm_kab_label)
 
@@ -425,9 +505,9 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
             if ds == "khusus":
                 return 1.0
             if ds == "sekolah":
-                return float(bobot_map_sek.get(kk, 0.0))
+                return float(bobot_map_sek.get(kk, 1.0))
             if ds == "umum":
-                return float(bobot_map_um.get(kk, 0.0))
+                return float(bobot_map_um.get(kk, 1.0))
             return 1.0
 
         def row_cov(r):
@@ -442,20 +522,23 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
         df["bobot_coverage"] = df.apply(row_weight, axis=1)
         df["coverage"] = df.apply(row_cov, axis=1)
 
-    elif ("PROV" in kew_norm) and prov_col and df_pop_prov is not None:
+    # --- PROVINSI ---
+    elif ("PROV" in kew_norm) and pop_prov is not None and not pop_prov.empty:
         tmp = df.copy()
         tmp["prov_key"] = tmp["PROV_DISP"].apply(norm_prov_label)
 
         g = tmp.groupby(["prov_key","_dataset"]).size().rename("n_sampel").reset_index()
         g_piv = g.pivot(index="prov_key", columns="_dataset", values="n_sampel").fillna(0)
-        pop = df_pop_prov.set_index("prov_key")
+        pop = pop_prov.set_index("prov_key")
 
         rows = []
         for pk in g_piv.index:
             pop_sek = pop.loc[pk, "Pop_Sekolah_Prov"] if pk in pop.index else np.nan
             n_sek = float(g_piv.loc[pk].get("sekolah", 0))
+
             cov_sek = safe_div(n_sek, pop_sek)
             bobot_sek = cap_bobot(cov_sek)
+
             target_sek = (TARGET_COVERAGE * pop_sek) if not pd.isna(pop_sek) else np.nan
 
             rows.append({
@@ -468,6 +551,8 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
             })
 
         verif_df = pd.DataFrame(rows)
+        verif_df["Catatan"] = ""
+        verif_df.loc[verif_df["Pop_Sekolah"].isna() | (verif_df["Pop_Sekolah"] <= 0), "Catatan"] += "Pop_Sekolah_tidak_valid; "
 
         int_cols = ["Pop_Sekolah","Sampel_Sekolah","GAP_Ke_68_Sekolah"]
         pct_cols = ["Coverage_Sekolah_%","Bobot_Sekolah_68_%"]
@@ -478,8 +563,8 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
             if c in verif_df.columns:
                 verif_df[c] = verif_df[c].fillna(0).round(0).astype(int)
 
-        bobot_map = {norm_prov_label(r["Provinsi"]): float(r["Bobot_Sekolah_68_%"]) / 100.0 for _, r in verif_df.iterrows()}
-        cov_map   = {norm_prov_label(r["Provinsi"]): float(r["Coverage_Sekolah_%"]) / 100.0 for _, r in verif_df.iterrows()}
+        bobot_map = {norm_prov_label(r["Provinsi"]): _bobot_or_one(float(r["Bobot_Sekolah_68_%"]) / 100.0) for _, r in verif_df.iterrows()}
+        cov_map   = {norm_prov_label(r["Provinsi"]): (float(r["Coverage_Sekolah_%"]) / 100.0) for _, r in verif_df.iterrows()}
 
         df["prov_key"] = df["PROV_DISP"].apply(norm_prov_label)
 
@@ -488,7 +573,7 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
             if ds == "khusus":
                 return 1.0
             if ds == "sekolah":
-                return float(bobot_map.get(r.get("prov_key", None), 0.0))
+                return float(bobot_map.get(r.get("prov_key", None), 1.0))
             return 1.0
 
         def row_cov(r):
@@ -499,57 +584,118 @@ def compute_final(df_filtered: pd.DataFrame, kew_value: str):
         df["bobot_coverage"] = df.apply(row_weight, axis=1)
         df["coverage"] = df.apply(row_cov, axis=1)
 
-    else:
-        verif_df = pd.DataFrame()
-
-    df["Indeks_Final_0_100"] = (df["Indeks_Real_0_100"].fillna(0.0) * df["bobot_coverage"].fillna(0.0)).fillna(0.0)
+    # FINAL
+    df["Indeks_Final_0_100"] = (df["Indeks_Real_0_100"].fillna(0.0) * df["bobot_coverage"].fillna(1.0)).fillna(0.0)
     return df, verif_df
 
+
+# ============================================================
+# 7) VIEW: DETAIL + AGREGAT
+# ============================================================
+
+def build_views(df: pd.DataFrame, meta: dict):
+    if df is None or df.empty:
+        return pd.DataFrame()
+
+    base_cols = ["PROV_DISP", "KAB_DISP", "KEW_NORM", "_dataset"]
+    if meta.get("nama_col") and meta["nama_col"] in df.columns:
+        df = df.copy()
+        df["nm_perpustakaan"] = df[meta["nama_col"]].astype(str)
+        base_cols.insert(2, "nm_perpustakaan")
+
+    keep = base_cols + [
+        "sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan",
+        "dim_kepatuhan","dim_kinerja",
+        "Indeks_Final_0_100"
+    ]
+    keep = [c for c in keep if c in df.columns]
+    out = df[keep].copy()
+    out = out.rename(columns={"PROV_DISP":"Provinsi","KAB_DISP":"Kab/Kota","_dataset":"Jenis"})
+
+    out["Indeks_Final_0_100"] = out["Indeks_Final_0_100"].apply(safe_round2)
+    for c in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja"]:
+        if c in out.columns:
+            out[c] = out[c].apply(lambda x: round(float(x), 3) if pd.notna(x) else 0.0)
+
+    return out
+
+def build_aggregate(df_view: pd.DataFrame):
+    if df_view is None or df_view.empty:
+        return pd.DataFrame()
+
+    grp = df_view.groupby("Jenis", dropna=False).agg(
+        Jumlah=("Jenis","size"),
+        Rata2_sub_koleksi=("sub_koleksi","mean"),
+        Rata2_sub_sdm=("sub_sdm","mean"),
+        Rata2_sub_pelayanan=("sub_pelayanan","mean"),
+        Rata2_sub_pengelolaan=("sub_pengelolaan","mean"),
+        Rata2_dim_kepatuhan=("dim_kepatuhan","mean"),
+        Rata2_dim_kinerja=("dim_kinerja","mean"),
+        Rata2_Indeks_Final_0_100=("Indeks_Final_0_100","mean"),
+    ).reset_index()
+
+    for c in grp.columns:
+        if c.startswith("Rata2_"):
+            grp[c] = grp[c].apply(lambda x: round(float(x), 3) if pd.notna(x) else 0.0)
+
+    overall = {
+        "Jenis":"Rata-rata keseluruhan",
+        "Jumlah": int(df_view.shape[0]),
+        "Rata2_sub_koleksi": float(df_view["sub_koleksi"].mean()),
+        "Rata2_sub_sdm": float(df_view["sub_sdm"].mean()),
+        "Rata2_sub_pelayanan": float(df_view["sub_pelayanan"].mean()),
+        "Rata2_sub_pengelolaan": float(df_view["sub_pengelolaan"].mean()),
+        "Rata2_dim_kepatuhan": float(df_view["dim_kepatuhan"].mean()),
+        "Rata2_dim_kinerja": float(df_view["dim_kinerja"].mean()),
+        "Rata2_Indeks_Final_0_100": float(df_view["Indeks_Final_0_100"].mean()),
+    }
+    grp = pd.concat([grp, pd.DataFrame([overall])], ignore_index=True)
+
+    for c in grp.columns:
+        if c.startswith("Rata2_"):
+            grp[c] = grp[c].apply(lambda x: round(float(x), 3) if pd.notna(x) else 0.0)
+
+    return grp
+
+
 # ============================================================
-# 7) BELL CURVE (FINAL) — all + per jenis
+# 8) BELL CURVE
 # ============================================================
 
-def make_bell_figure(df_in: pd.DataFrame, title: str, index_col="Indeks_Final_0_100", name_col=None, min_points=5) -> go.Figure:
+def make_bell_figure(df_all: pd.DataFrame, title: str, index_col: str, name_col: str = None, min_points: int = 5) -> go.Figure:
     fig = go.Figure()
-    if df_in is None or df_in.empty or index_col not in df_in.columns:
-        fig.update_layout(title=title, xaxis_title="Indeks (0–100)", yaxis_title="Kepadatan (relatif)")
+    fig.update_layout(title=title, xaxis_title="Indeks (0–100)", yaxis_title="Kepadatan (relatif)")
+
+    if df_all is None or df_all.empty or index_col not in df_all.columns:
         return fig
 
-    dfp = df_in[pd.notna(df_in[index_col])].copy()
+    dfp = df_all.dropna(subset=[index_col]).copy()
     if dfp.empty or len(dfp) < min_points:
-        fig.update_layout(
-            title=title,
-            xaxis_title="Indeks (0–100)",
-            yaxis_title="Kepadatan (relatif)",
-            annotations=[dict(text="Grafik tidak ditampilkan (data terlalu sedikit).",
-                              x=0.5, y=0.5, xref="paper", yref="paper",
-                              showarrow=False, font=dict(size=14))]
+        fig.add_annotation(
+            text="Grafik tidak ditampilkan (data terlalu sedikit).",
+            x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False
         )
         return fig
 
-    x_vals = dfp[index_col].astype(float).values
-    mu = float(np.mean(x_vals))
-    sigma = float(np.std(x_vals, ddof=1)) if len(x_vals) > 1 else 1.0
-    if sigma <= 1e-9:
-        sigma = 1.0
+    x = dfp[index_col].astype(float).values
+    mu = float(np.mean(x))
+    sigma = float(np.std(x, ddof=1)) if len(x) > 1 else 1.0
+    sigma = max(sigma, 1e-6)
 
-    xs = np.linspace(max(0, np.min(x_vals) - 5), min(100, np.max(x_vals) + 5), 200)
+    xs = np.linspace(max(0, np.min(x) - 5), min(100, np.max(x) + 5), 200)
     pdf = (1.0 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((xs - mu) / sigma) ** 2)
-    pdf = pdf / (pdf.max() if pdf.max() > 0 else 1.0)
+    pdf = pdf / max(pdf.max(), 1e-9)
 
     if name_col and name_col in dfp.columns:
-        hover_text = [f"{str(n)}<br>Indeks Final: {v:.2f}" for n, v in zip(dfp[name_col], x_vals)]
+        hover = [f"{str(n)}<br>Indeks: {v:.2f}" for n, v in zip(dfp[name_col], x)]
     else:
-        hover_text = [f"Indeks Final: {v:.2f}" for v in x_vals]
+        hover = [f"Indeks: {v:.2f}" for v in x]
 
     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>"
-    ))
+    fig.add_trace(go.Scatter(x=x, y=np.zeros_like(x), mode="markers", name="Perpustakaan",
+                             hovertext=hover, hovertemplate="%{hovertext}<extra></extra>"))
 
-    q1, q2, q3 = np.quantile(x_vals, [0.25, 0.5, 0.75])
+    q1, q2, q3 = np.quantile(x, [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, 1.05],
@@ -558,546 +704,356 @@ def make_bell_figure(df_in: pd.DataFrame, title: str, index_col="Indeks_Final_0_
         ))
 
     fig.update_layout(
-        title=title,
-        xaxis_title="Indeks IPLM FINAL (0–100)",
-        yaxis_title="Kepadatan (relatif)",
-        yaxis=dict(showticklabels=False, zeroline=True, range=[0, 1.2]),
+        xaxis_title="Indeks FINAL IPLM (0–100)",
+        yaxis=dict(showticklabels=False, range=[0, 1.2]),
         margin=dict(l=40, r=20, t=60, b=40),
         hovermode="x"
     )
     return fig
 
+
 # ============================================================
-# 7c. LLM DATA ANALYTICS (NARASI LEBIH DATA-DRIVEN) + WORD DOCX
-# (TAMBAHAN SAJA — TIDAK MENGUBAH PIPELINE YANG ADA)
+# 9) LLM
 # ============================================================
 
-def _safe_table_text(df: pd.DataFrame, max_rows: int = 12) -> str:
-    if df is None or df.empty:
-        return "(kosong)"
-    tmp = df.copy()
-    # batasi kolom & baris biar prompt tidak meledak
-    tmp = tmp.head(max_rows)
-    return tmp.to_string(index=False)
-
-
-def summarize_distribution(detail_df: pd.DataFrame):
-    """
-    Ringkas distribusi indeks final untuk LLM:
-    - pakai Indeks_Final_0_100 kalau ada, kalau tidak fallback ke Indeks_Real_0_100
-    """
-    idx_col = "Indeks_Final_0_100" if (detail_df is not None and "Indeks_Final_0_100" in detail_df.columns) else "Indeks_Real_0_100"
-    if detail_df is None or detail_df.empty or idx_col not in detail_df.columns:
-        return {"idx_col": idx_col, "all": {}, "by_type": {}}
-
-    out = {"idx_col": idx_col, "all": {}, "by_type": {}}
-
-    def stats_for(s: pd.Series):
-        s = pd.to_numeric(s, errors="coerce").dropna()
-        if len(s) == 0:
-            return {}
-        q1, q2, q3 = np.quantile(s.values, [0.25, 0.5, 0.75])
-        return {
-            "n": int(len(s)),
-            "mean": float(s.mean()),
-            "std": float(s.std(ddof=1)) if len(s) > 1 else 0.0,
-            "min": float(s.min()),
-            "q1": float(q1),
-            "median": float(q2),
-            "q3": float(q3),
-            "max": float(s.max()),
-        }
-
-    out["all"] = stats_for(detail_df[idx_col])
-
-    if "_dataset" in detail_df.columns:
-        for ds in ["sekolah", "umum", "khusus"]:
-            dsub = detail_df[detail_df["_dataset"] == ds]
-            out["by_type"][ds] = stats_for(dsub[idx_col])
-
-    return out
-
+_HF_CLIENT = None
 
-def generate_llm_data_analytics(detail_df: pd.DataFrame,
-                                agg_df: pd.DataFrame,
-                                verif_df: pd.DataFrame,
-                                kab_name: str,
-                                kew_value: str) -> str:
-    """
-    Narasi LLM yang fokus ke:
-    - indeks FINAL (sudah penalti 68% kalau ada)
-    - distribusi (mean, Q1/median/Q3)
-    - gap coverage (kalau ada)
-    """
-    wilayah = kab_name
-    if kew_value and kew_value != "(Semua)":
-        wilayah = f"{kab_name} (kewenangan {kew_value})"
-
-    dist = summarize_distribution(detail_df)
-    idx_col = dist.get("idx_col", "Indeks_Final_0_100")
-
-    # ringkas angka utama biar prompt padat
-    all_stats = dist.get("all", {})
-    by_type = dist.get("by_type", {})
-
-    def fmt_stats(d):
-        if not d:
-            return "(tidak tersedia)"
-        return (
-            f"n={d['n']}, mean={d['mean']:.2f}, sd={d['std']:.2f}, "
-            f"min={d['min']:.2f}, Q1={d['q1']:.2f}, median={d['median']:.2f}, Q3={d['q3']:.2f}, max={d['max']:.2f}"
-        )
+def get_llm_client():
+    global _HF_CLIENT
+    if _HF_CLIENT is not None:
+        return _HF_CLIENT
+    try:
+        _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME, token=HF_TOKEN) if HF_TOKEN else InferenceClient(model=LLM_MODEL_NAME)
+        return _HF_CLIENT
+    except Exception:
+        _HF_CLIENT = None
+        return None
 
+def build_context(detail_df: pd.DataFrame, agg_df: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
     lines = []
     lines.append(f"Wilayah: {wilayah}")
-    lines.append(f"Indeks yang dianalisis: {idx_col} (0–100)")
-    lines.append(f"Distribusi keseluruhan: {fmt_stats(all_stats)}")
-    if by_type:
-        for ds, st in by_type.items():
-            lines.append(f"Distribusi {ds}: {fmt_stats(st)}")
+    lines.append(f"Kewenangan: {kew}")
+    lines.append(f"Jumlah perpustakaan sampel: {len(detail_df)}")
+    if "Indeks_Final_0_100" in detail_df.columns:
+        lines.append(f"Rata-rata Indeks FINAL: {detail_df['Indeks_Final_0_100'].mean(skipna=True):.2f}")
+    for col in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja"]:
+        if col in detail_df.columns:
+            lines.append(f"Rata-rata {col}: {detail_df[col].mean(skipna=True):.3f}")
 
-    agg_txt = _safe_table_text(agg_df, max_rows=8)
-    ver_txt = _safe_table_text(verif_df, max_rows=12)
+    if agg_df is not None and not agg_df.empty:
+        lines.append("\nRingkasan per jenis:")
+        for _, r in agg_df.iterrows():
+            jenis = r.get("Jenis", "")
+            if jenis == "Rata-rata keseluruhan":
+                continue
+            lines.append(f"- {jenis}: n={int(r['Jumlah'])}, Indeks_FINAL={float(r['Rata2_Indeks_Final_0_100']):.2f}")
 
+    if verif_df is not None and not verif_df.empty:
+        lines.append("\nCatatan verifikasi coverage 68% (ringkas):")
+        gap_cols = [c for c in verif_df.columns if c.startswith("GAP_Ke_68")]
+        if gap_cols:
+            tmp = verif_df.copy()
+            tmp["GAP_MAX"] = tmp[gap_cols].max(axis=1)
+            tmp = tmp.sort_values("GAP_MAX", ascending=False).head(5)
+            for _, r in tmp.iterrows():
+                name = r.get("Kab/Kota", r.get("Provinsi",""))
+                lines.append(f"- {name}: GAP maks={int(r['GAP_MAX'])}")
+
+        if "Catatan" in verif_df.columns:
+            n_bad = (verif_df["Catatan"].astype(str).str.contains("tidak_valid", na=False)).sum()
+            if n_bad > 0:
+                lines.append(f"\nCatatan data: ada {int(n_bad)} wilayah dengan populasi tidak valid → bobot diset 1 (tanpa penalti).")
+
+    return "\n".join(lines)
+
+def generate_llm_analysis(detail_df: pd.DataFrame, agg_df: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
+    ctx = build_context(detail_df, agg_df, verif_df, wilayah, kew)
     client = get_llm_client()
     if client is None or not USE_LLM:
-        # fallback: pakai yang sudah ada (rule-based)
-        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
-        return (
-            "⚠️ LLM tidak tersedia, analisis menggunakan rule-based.\n\n" + rb
-        )
+        return "Analisis otomatis (LLM) tidak tersedia. Pastikan token HuggingFace tersedia dan model bisa diakses."
 
     system_prompt = (
-        "Anda adalah analis data & kebijakan perpustakaan. "
-        "Anda menulis analisis resmi untuk pemangku kepentingan pemerintah daerah. "
-        "Anda harus menggunakan pendekatan berbasis data, jelas, dan ringkas."
+        "Anda adalah analis kebijakan perpustakaan dan literasi di Indonesia. "
+        "Tugas Anda menyusun analisis berbasis data IPLM secara formal, tajam, dan operasional."
     )
-
     user_prompt = f"""
-DATA RINGKAS IPLM (FINAL) UNTUK ANALISIS:
-
-RINGKASAN STATISTIK (indeks final & distribusi):
-{chr(10).join(lines)}
-
-TABEL AGREGAT (ringkas):
-{agg_txt}
+DATA RINGKAS IPLM (SETELAH PENALTI COVERAGE 68%):
 
-TABEL VERIFIKASI COVERAGE & GAP (ringkas):
-{ver_txt}
+{ctx}
 
-TUGAS:
-Tulis analisis dalam Bahasa Indonesia formal, struktur:
+TULISKAN ANALISIS BAHASA INDONESIA FORMAL, STRUKTUR:
+1) Gambaran umum kondisi wilayah (1 paragraf).
+2) Analisis capaian subdimensi & dimensi (2 paragraf). Jelaskan arti angka secara substantif.
+3) Analisis risiko/kesenjangan coverage 68% dan implikasinya (1 paragraf).
+4) Rekomendasi program 3–5 tahun (2 paragraf naratif). Harus konkret dan bisa dieksekusi.
 
-A. Ringkasan eksekutif (1 paragraf) — fokus pada indeks FINAL setelah penalti 68%.
-B. Diagnostik berbasis data (2–3 paragraf):
-   - Jelaskan distribusi (Q1/Median/Q3), variasi antar jenis perpustakaan.
-   - Jelaskan implikasi kualitas/representasi data bila coverage belum 68%.
-C. Prioritas intervensi 12–18 bulan (1–2 paragraf) — fokus pada program pembinaan yang realistis.
-D. Rekomendasi kebijakan 3–5 tahun (1–2 paragraf) — penataan tata kelola data, pembinaan, standardisasi.
-
-GAYA:
-- Jangan menyebut "rendah/sedang/tinggi". Gunakan frasa netral: "ruang penguatan", "belum konsisten", dll.
-- Hindari kalimat terlalu panjang.
-- Jangan membuat data baru di luar yang tersedia.
+ATURAN:
+- Jangan pakai label menilai eksplisit seperti "rendah/sedang/tinggi".
+- Gunakan frasa netral: "masih memiliki ruang penguatan", "memerlukan konsolidasi", dst.
+- Fokus pada Indeks FINAL (setelah penalti 68%).
 """
-
     try:
         resp = client.chat_completion(
             model=LLM_MODEL_NAME,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt},
-            ],
-            max_tokens=1200,
+            messages=[{"role":"system","content":system_prompt},{"role":"user","content":user_prompt}],
+            max_tokens=1100,
             temperature=0.25,
             top_p=0.9,
         )
         text = resp.choices[0].message.content.strip()
-        if not text:
-            raise ValueError("Respon LLM kosong.")
-        return text
+        return text if text else "LLM mengembalikan respon kosong."
     except Exception as e:
-        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
-        return (
-            "⚠️ Gagal memanggil LLM untuk data analytics, fallback rule-based.\n\n"
-            f"(Detail teknis: {repr(e)})\n\n{rb}"
-        )
-
+        return f"⚠️ Error saat memanggil LLM: {repr(e)}"
 
-def generate_word_report_llm_analytics(detail_df, agg_df, verif_df, prov, kab, kew, analytics_text):
-    """
-    Word report yang menaruh:
-    - Ringkasan indeks FINAL (statistik & kuartil)
-    - Tabel agregat ringkas
-    - Tabel verifikasi coverage (dibulatkan TANPA koma)
-    - Narasi LLM data analytics
-    """
-    if kew == "PUSAT":
-        return None
 
-    wilayah = kab if kab != "(Semua)" else prov
-    dist = summarize_distribution(detail_df)
-    idx_col = dist.get("idx_col", "Indeks_Final_0_100")
-    all_stats = dist.get("all", {})
+# ============================================================
+# 10) WORD
+# ============================================================
 
+def generate_word_report(detail_df: pd.DataFrame, agg_df: pd.DataFrame, verif_df: pd.DataFrame,
+                         wilayah: str, kew: str, analysis_text: str) -> str:
     doc = Document()
-    doc.add_heading(f"Laporan Analisis IPLM (FINAL) – {wilayah}", level=1)
-    doc.add_paragraph(
-        "Laporan ini menyajikan analisis Indeks IPLM FINAL (0–100) setelah penerapan penalti "
-        "kecukupan sampel 68% (untuk perpustakaan sekolah dan umum, sesuai konfigurasi aplikasi)."
-    )
+    doc.add_heading(f"Laporan IPLM (FINAL) — {wilayah}", level=1)
+    doc.add_paragraph(f"Kewenangan: {kew}")
+    doc.add_paragraph("Catatan: Indeks FINAL memperhitungkan penalti coverage 68% (perpustakaan khusus tidak dikenai penalti).")
+    doc.add_paragraph("Jika populasi wilayah tidak valid/tidak ditemukan, bobot coverage diset 1 (tanpa penalti) dan dicatat pada tabel verifikasi.")
 
-    doc.add_heading("1. Ringkasan Statistik Indeks FINAL", level=2)
-    if all_stats:
-        doc.add_paragraph(f"- Indeks yang digunakan: {idx_col}")
-        doc.add_paragraph(f"- Jumlah perpustakaan: {int(all_stats.get('n', 0))}")
-        doc.add_paragraph(f"- Rata-rata: {all_stats.get('mean', 0.0):.2f}")
-        doc.add_paragraph(f"- Q1: {all_stats.get('q1', 0.0):.2f}")
-        doc.add_paragraph(f"- Median: {all_stats.get('median', 0.0):.2f}")
-        doc.add_paragraph(f"- Q3: {all_stats.get('q3', 0.0):.2f}")
-        doc.add_paragraph(f"- Minimum–Maksimum: {all_stats.get('min', 0.0):.2f} – {all_stats.get('max', 0.0):.2f}")
-    else:
-        doc.add_paragraph("Statistik distribusi tidak tersedia (data indeks tidak ditemukan).")
+    doc.add_heading("Ringkasan Utama", level=2)
+    if detail_df is not None and not detail_df.empty and "Indeks_Final_0_100" in detail_df.columns:
+        doc.add_paragraph(f"Jumlah perpustakaan: {len(detail_df)}")
+        doc.add_paragraph(f"Rata-rata Indeks FINAL: {detail_df['Indeks_Final_0_100'].mean(skipna=True):.2f}")
 
-    doc.add_heading("2. Ringkasan Agregat per Jenis Perpustakaan", level=2)
+    doc.add_heading("Agregat (sub/dim + Indeks FINAL)", 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):
             hdr[i].text = str(c)
         for _, row in agg_df.iterrows():
-            r = table.add_row().cells
+            cells = table.add_row().cells
             for i, c in enumerate(agg_df.columns):
-                r[i].text = str(row[c])
+                cells[i].text = str(row[c])
     else:
-        doc.add_paragraph("Tabel agregat tidak tersedia.")
+        doc.add_paragraph("Agregat tidak tersedia.")
 
-    doc.add_heading("3. Verifikasi Coverage & GAP menuju 68% (Kontrol Mutu)", level=2)
+    doc.add_heading("Verifikasi Coverage & GAP menuju 68%", level=2)
     if verif_df is not None and not verif_df.empty:
-        v = verif_df.copy()
-
-        # BULATKAN TANPA KOMa: semua numerik -> integer
-        for c in v.columns:
-            if pd.api.types.is_numeric_dtype(v[c]):
-                v[c] = pd.to_numeric(v[c], errors="coerce").fillna(0).round(0).astype(int)
-
-        table = doc.add_table(rows=1, cols=len(v.columns))
+        table = doc.add_table(rows=1, cols=len(verif_df.columns))
         hdr = table.rows[0].cells
-        for i, c in enumerate(v.columns):
+        for i, c in enumerate(verif_df.columns):
             hdr[i].text = str(c)
-        for _, row in v.iterrows():
-            r = table.add_row().cells
-            for i, c in enumerate(v.columns):
-                r[i].text = str(row[c])
+        for _, row in verif_df.iterrows():
+            cells = table.add_row().cells
+            for i, c in enumerate(verif_df.columns):
+                cells[i].text = str(row[c])
     else:
-        doc.add_paragraph("Tidak ada tabel verifikasi coverage untuk wilayah ini.")
+        doc.add_paragraph("Tidak ada tabel verifikasi untuk filter ini.")
 
-    doc.add_heading("4. Analisis Naratif Otomatis (LLM Data Analytics)", level=2)
-    for paragraph in str(analytics_text).split("\n"):
-        if paragraph.strip():
-            doc.add_paragraph(paragraph.strip())
+    doc.add_heading("Analisis Naratif (LLM)", level=2)
+    for p in (analysis_text or "").split("\n"):
+        if p.strip():
+            doc.add_paragraph(p.strip())
 
     outpath = tempfile.mktemp(suffix=".docx")
     doc.save(outpath)
     return outpath
 
+
 # ============================================================
-# 8) OUTPUT TABEL: AGREGAT RINGKAS + DETAIL RINGKAS
+# 11) CORE RUN
 # ============================================================
 
-def build_agg_ringkas(df2: pd.DataFrame) -> pd.DataFrame:
-    label_map = {"sekolah":"Perpustakaan Sekolah","umum":"Perpustakaan Umum","khusus":"Perpustakaan Khusus"}
-    rows = []
-
-    def summarize(sub, jenis_label):
-        row = {
-            "Jenis": jenis_label,
-            "Jumlah": int(len(sub)),
-            "Rata2_sub_koleksi": float(sub["sub_koleksi"].mean()) if len(sub) else 0.0,
-            "Rata2_sub_sdm": float(sub["sub_sdm"].mean()) if len(sub) else 0.0,
-            "Rata2_sub_pelayanan": float(sub["sub_pelayanan"].mean()) if len(sub) else 0.0,
-            "Rata2_sub_pengelolaan": float(sub["sub_pengelolaan"].mean()) if len(sub) else 0.0,
-            "Rata2_dim_kepatuhan": float(sub["dim_kepatuhan"].mean()) if len(sub) else 0.0,
-            "Rata2_dim_kinerja": float(sub["dim_kinerja"].mean()) if len(sub) else 0.0,
-            "Rata2_Indeks_Final_0_100": float(sub["Indeks_Final_0_100"].mean()) if len(sub) else 0.0,
-        }
-        return row
-
-    for ds in ["sekolah","umum","khusus"]:
-        sub = df2[df2["_dataset"] == ds] if "_dataset" in df2.columns else df2.iloc[0:0]
-        rows.append(summarize(sub, label_map.get(ds, ds)))
-
-    rows.append(summarize(df2, "Rata-rata keseluruhan"))
-    return pd.DataFrame(rows).round(4)
-
-def build_detail_ringkas(df2: pd.DataFrame, nama_col: str):
-    cols = ["PROV_DISP","KAB_DISP"]
-    if nama_col and nama_col in df2.columns:
-        cols.append(nama_col)
-    cols += ["KEW_NORM","_dataset",
-             "sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan",
-             "dim_kepatuhan","dim_kinerja",
-             "Indeks_Final_0_100"]
-    cols = [c for c in cols if c in df2.columns]
-    return df2[cols].copy().round(4)
+def _empty_outputs(msg="⚠️ Data belum siap."):
+    empty = pd.DataFrame()
+    empty_fig = go.Figure()
+    return (
+        empty, empty, empty,
+        None, None, None, None,
+        empty_fig, empty_fig, empty_fig, empty_fig,
+        msg, "Analisis belum tersedia."
+    )
+
+def run_calc(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, meta):
+    try:
+        if df_all is None or (isinstance(df_all, pd.DataFrame) and df_all.empty):
+            return _empty_outputs("⚠️ Data belum ter-load. Klik Reload Data.")
 
-# ============================================================
-# 9) PIPELINE FILTERED (DEDUP) + EXPORT + BELL CURVE
-# ============================================================
+        df = df_all.copy()
 
-def run_pipeline_filtered(prov_value, kab_value, kew_value):
-    if df_all is None or df_all.empty:
-        return (pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
-                None, None, None,
-                go.Figure(), go.Figure(), go.Figure(), go.Figure(),
-                "Data DM belum siap.")
-
-    df = df_all.copy()
-
-    if "PROV_DISP" in df.columns and prov_value and prov_value != "(Semua)":
-        df = df[df["PROV_DISP"] == prov_value]
-    if "KAB_DISP" in df.columns and kab_value and kab_value != "(Semua)":
-        df = df[df["KAB_DISP"] == kab_value]
-    if kew_value and kew_value != "(Semua)":
-        df = df[df["KEW_NORM"] == kew_value]
-
-    if df.empty:
-        return (pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
-                None, None, None,
-                go.Figure(), go.Figure(), go.Figure(), go.Figure(),
-                "Tidak ada data untuk kombinasi filter.")
-
-    df2, verif_df = compute_final(df, kew_value)
-
-    # DEDUP kunci (prov,kab,nama,kew,dataset)
-    kcols = [c for c in ["PROV_DISP","KAB_DISP","KEW_NORM","_dataset"] if c in df2.columns]
-    if nama_col and nama_col in df2.columns:
-        kcols.append(nama_col)
-    if kcols:
-        df2 = df2.drop_duplicates(subset=kcols, keep="first").copy()
-
-    agg_df = build_agg_ringkas(df2)
-    detail_df = build_detail_ringkas(df2, nama_col)
-
-    # Bell curves (FINAL)
-    ncol = nama_col if (nama_col and nama_col in df2.columns) else None
-    fig_all = make_bell_figure(df2, "Bell Curve Indeks FINAL — Semua Perpustakaan", name_col=ncol, min_points=5)
-    fig_sek = make_bell_figure(df2[df2["_dataset"]=="sekolah"], "Bell Curve Indeks FINAL — Perpustakaan Sekolah", name_col=ncol, min_points=3)
-    fig_um  = make_bell_figure(df2[df2["_dataset"]=="umum"], "Bell Curve Indeks FINAL — Perpustakaan Umum", name_col=ncol, min_points=3)
-    fig_kh  = make_bell_figure(df2[df2["_dataset"]=="khusus"], "Bell Curve Indeks FINAL — Perpustakaan Khusus", name_col=ncol, min_points=3)
-
-    tmpdir = tempfile.mkdtemp()
-    wilayah = kab_value if kab_value and kab_value != "(Semua)" else (prov_value if prov_value and prov_value != "(Semua)" else "NASIONAL")
-    slug = slugify(wilayah) + "_" + slugify(kew_value)
-    agg_path = os.path.join(tmpdir, f"IPLM_Agregat_RINGKAS_{slug}.xlsx")
-    detail_path = os.path.join(tmpdir, f"IPLM_Detail_RINGKAS_{slug}.xlsx")
-    verif_path = os.path.join(tmpdir, f"IPLM_VerifikasiCoverage_{slug}.xlsx")
-
-    agg_df.to_excel(agg_path, index=False)
-    detail_df.to_excel(detail_path, index=False)
-    (verif_df if verif_df is not None else pd.DataFrame()).to_excel(verif_path, index=False)
-
-    msg = f"✅ Selesai. Unit (dedup): {len(df2)} | Wilayah: {wilayah} | Kew: {kew_value} | Mean Final: {df2['Indeks_Final_0_100'].mean():.2f}"
-    return agg_df, detail_df, verif_df, agg_path, detail_path, verif_path, fig_all, fig_sek, fig_um, fig_kh, msg
-
-
-#===========================================================
-# 9b. WRAPPER: PAKAI LLM DATA ANALYTICS + WORD (tanpa ubah run_app lama)
-# ============================================================
+        if prov_value and prov_value != "(Semua)":
+            df = df[df["PROV_DISP"] == prov_value]
+        if kab_value and kab_value != "(Semua)":
+            df = df[df["KAB_DISP"] == kab_value]
+        if kew_value and kew_value != "(Semua)":
+            df = df[df["KEW_NORM"] == kew_value]
 
-if "run_app" in globals():
-    _run_app_base = run_app  # simpan fungsi asli
-def run_app(prov_value, kab_value, kew_value):
-    # jalankan versi asli dulu
-    (
-        agg_df,
-        detail_df_view,
-        verif_df,
-        agg_path,
-        detail_path,
-        raw_path,
-        word_path,
-        fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
-        msg,
-        analysis_text,
-    ) = _run_app_base(prov_value, kab_value, kew_value)
-
-    # kalau kosong, langsung return
-    if detail_df_view is None or (hasattr(detail_df_view, "empty") and detail_df_view.empty):
-        return (
-            agg_df, detail_df_view, verif_df,
-            agg_path, detail_path, raw_path,
-            word_path,
-            fig_all, fig_sekolah, fig_umum, fig_khusus,
-            msg,
-            analysis_text
-        )
+        if df.empty:
+            return _empty_outputs("Tidak ada data untuk filter ini.")
 
-    # BUTUH detail_df LENGKAP (bukan view) agar punya _dataset + indeks final kalau ada
-    # Ambil ulang subset yang sama dari df_all_ipml (supaya lengkap) dengan filter yang sama
-    df = df_all_ipml.copy() if df_all_ipml is not None else None
-    if df is None or df.empty:
-        return (
-            agg_df, detail_df_view, verif_df,
-            agg_path, detail_path, raw_path,
-            word_path,
-            fig_all, fig_sekolah, fig_umum, fig_khusus,
-            msg,
-            analysis_text
-        )
+        df_pen, verif_df = apply_penalty_68(df, pop_kab, pop_prov, kew_value)
+        detail_view = build_views(df_pen, meta)
+        agg_view = build_aggregate(detail_view)
 
-    if prov_col_glob and prov_value and prov_value != "(Semua)":
-        df = df[df[prov_col_glob].astype(str).str.strip() == prov_value]
-    if kab_col_glob and kab_value and kab_value != "(Semua)":
-        df = df[df[kab_col_glob].astype(str).str.strip() == kab_value]
-    if kew_value and kew_value != "(Semua)":
-        df = df[df["KEW_NORM"] == kew_value]
+        name_col = "nm_perpustakaan" if "nm_perpustakaan" in detail_view.columns else None
 
-    if df is None or df.empty:
+        fig_all = make_bell_figure(detail_view, "Bell Curve Indeks FINAL — Semua Perpustakaan", "Indeks_Final_0_100", name_col=name_col, min_points=5)
+        fig_sek = make_bell_figure(detail_view[detail_view["Jenis"]=="sekolah"], "Bell Curve Indeks FINAL — Perpustakaan Sekolah", "Indeks_Final_0_100", name_col=name_col, min_points=3)
+        fig_um  = make_bell_figure(detail_view[detail_view["Jenis"]=="umum"], "Bell Curve Indeks FINAL — Perpustakaan Umum", "Indeks_Final_0_100", name_col=name_col, min_points=3)
+        fig_kh  = make_bell_figure(detail_view[detail_view["Jenis"]=="khusus"], "Bell Curve Indeks FINAL — Perpustakaan Khusus", "Indeks_Final_0_100", name_col=name_col, min_points=3)
+
+        tmpdir = tempfile.mkdtemp()
+        prov_slug = (_canon(prov_value or "SEMUA").upper() or "SEMUA")
+        kab_slug  = (_canon(kab_value  or "SEMUA").upper() or "SEMUA")
+        kew_slug  = (_canon(kew_value  or "SEMUA").upper() or "SEMUA")
+
+        agg_path = str(Path(tmpdir) / f"IPLM_Agregat_RINGKAS_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        det_path = str(Path(tmpdir) / f"IPLM_Detail_RINGKAS_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        ver_path = str(Path(tmpdir) / f"IPLM_VerifikasiCoverage_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+
+        agg_view.to_excel(agg_path, index=False)
+        detail_view.to_excel(det_path, index=False)
+        (verif_df if verif_df is not None else pd.DataFrame()).to_excel(ver_path, index=False)
+
+        wilayah = kab_value if (kab_value and kab_value != "(Semua)") else (prov_value if (prov_value and prov_value != "(Semua)") else "Nasional/All")
+        analysis_text = generate_llm_analysis(detail_view, agg_view, verif_df, wilayah, kew_value or "(Semua)")
+        word_path = generate_word_report(detail_view, agg_view, verif_df, wilayah, kew_value or "(Semua)", analysis_text)
+
+        msg = f"✅ Berhasil dihitung: {len(detail_view)} perpustakaan | Output: Indeks FINAL (penalti 68%)"
         return (
-            agg_df, detail_df_view, verif_df,
-            agg_path, detail_path, raw_path,
-            word_path,
-            fig_all, fig_sekolah, fig_umum, fig_khusus,
-            msg,
-            analysis_text
+            agg_view, detail_view, verif_df,
+            agg_path, det_path, ver_path, word_path,
+            fig_all, fig_sek, fig_um, fig_kh,
+            msg, analysis_text
         )
+    except Exception as e:
+        return _empty_outputs(f"⚠️ Runtime error: {repr(e)}")
 
-    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"
 
-    # Bikin ulang detail_df LENGKAP memakai run_pipeline_core supaya konsisten
-    (agg_df2, detail_df_full, *_rest) = run_pipeline_core(df, kab_name=kab_name, kew_name=kew_name)
+# ============================================================
+# 12) UI (NO UPLOAD) — AUTO LOAD + RELOAD BUTTON
+# ============================================================
 
-    # LLM data analytics text (lebih data-driven)
-    analytics_text = generate_llm_data_analytics(
-        detail_df=detail_df_full,
-        agg_df=agg_df2 if (agg_df2 is not None and not agg_df2.empty) else agg_df,
-        verif_df=verif_df,
-        kab_name=kab_name,
-        kew_value=kew_value,
-    )
+def ui_load(force=False):
+    df_all, pop_kab, pop_prov, meta, info = load_default_files(force=force)
 
-    # Word report pakai analytics_text (LLM)
-    word_path2 = generate_word_report_llm_analytics(
-        detail_df_full,
-        (agg_df2 if (agg_df2 is not None and not agg_df2.empty) else agg_df),
-        verif_df,
-        prov_value, kab_value, kew_value,
-        analytics_text
-    )
+    if df_all is None or (isinstance(df_all, pd.DataFrame) and df_all.empty):
+        return (
+            None, None, None, {}, info,
+            gr.update(choices=["(Semua)"], value="(Semua)"),
+            gr.update(choices=["(Semua)"], value="(Semua)"),
+            gr.update(choices=["(Semua)"], value="(Semua)")
+        )
+
+    prov_choices = ["(Semua)"] + sorted([x for x in df_all["PROV_DISP"].dropna().unique().tolist() if x])
+    kab_choices  = ["(Semua)"] + sorted([x for x in df_all["KAB_DISP"].dropna().unique().tolist() if x])
+    kew_choices  = ["(Semua)"] + sorted([x for x in df_all["KEW_NORM"].dropna().unique().tolist() if x])
+
+    default_kew = "KAB/KOTA" if "KAB/KOTA" in kew_choices else "(Semua)"
 
-    # Kembalikan output yang sama seperti run_app asli
     return (
-        agg_df,
-        detail_df_view,
-        verif_df,
-        agg_path,
-        detail_path,
-        raw_path,
-        (word_path2 or word_path),
-        fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
-        msg,
-        analytics_text  # replace analysis_out dengan versi data analytics
+        df_all, pop_kab, pop_prov, meta, info,
+        gr.update(choices=prov_choices, value="(Semua)"),
+        gr.update(choices=kab_choices, value="(Semua)"),
+        gr.update(choices=kew_choices, value=default_kew)
     )
 
-# ============================================================
-# 10) DROPDOWN (NO DUPLICATE)
-# ============================================================
+def on_prov_change(prov_value):
+    # Aman: ambil dari cache loader langsung, bukan state_df (yang bisa None saat load)
+    df_all, _, _, _, _ = load_default_files(force=False)
+    if df_all is None or df_all.empty:
+        return gr.update(choices=["(Semua)"], value="(Semua)")
 
-def all_prov_choices():
-    if df_all_raw is None or "PROV_DISP" not in df_all_raw.columns:
-        return ["(Semua)"]
-    vals = df_all_raw["PROV_DISP"].dropna()
-    vals = sorted(list(dict.fromkeys([v for v in vals.tolist() if str(v).strip() != ""])))
-    return ["(Semua)"] + vals
-
-def get_kab_choices_for_prov(prov_value):
-    if df_all_raw is None or "KAB_DISP" not in df_all_raw.columns:
-        return ["(Semua)"]
-    tmp = df_all_raw.copy()
-    if prov_value and prov_value != "(Semua)":
-        tmp = tmp[tmp["PROV_DISP"] == prov_value]
-    vals = tmp["KAB_DISP"].dropna()
-    vals = sorted(list(dict.fromkeys([v for v in vals.tolist() if str(v).strip() != ""])))
-    return ["(Semua)"] + vals
-
-def all_kew_choices():
-    if df_all_raw is None or "KEW_NORM" not in df_all_raw.columns:
-        return ["(Semua)"]
-    vals = df_all_raw["KEW_NORM"].dropna().astype(str).str.strip()
-    vals = sorted(list(dict.fromkeys([v for v in vals.tolist() if v != ""])))
-    return ["(Semua)"] + (vals if vals else ["KAB/KOTA","PROVINSI"])
-
-prov_choices = all_prov_choices()
-kab_choices = get_kab_choices_for_prov(prov_choices[0] if prov_choices else "(Semua)")
-kew_choices = all_kew_choices()
-default_kew = "KAB/KOTA" if "KAB/KOTA" in kew_choices else (kew_choices[1] if len(kew_choices) > 1 else "(Semua)")
+    if prov_value is None or prov_value == "(Semua)":
+        vals = df_all["KAB_DISP"].dropna().unique().tolist()
+    else:
+        vals = df_all.loc[df_all["PROV_DISP"] == prov_value, "KAB_DISP"].dropna().unique().tolist()
 
-def on_prov_change(prov_value):
-    new_choices = get_kab_choices_for_prov(prov_value)
-    return gr.update(choices=new_choices, value="(Semua)")
+    vals = sorted([v for v in vals if v])
+    return gr.update(choices=["(Semua)"] + vals, value="(Semua)")
 
-# ============================================================
-# 11) UI
-# ============================================================
 
 with gr.Blocks() as demo:
-    gr.Markdown(
-        f"""
-# IPLM 2025 — Output Ringkas (Sub-dimensi + Dimensi + FINAL saja)
-**Final** sudah termasuk sanksi coverage 68% (internal).
-Verifikasi ditampilkan dalam integer (tanpa koma) agar bersih.
+    gr.Markdown(f"""
+# IPLM 2025 — Indeks FINAL (Penalti Coverage 68%) + Bell Curve + Analisis LLM (Word)
 
-{DATA_INFO}
-"""
-    )
+**Mode: NO UPLOAD (cache aktif).**  
+File dibaca dari server/repo:
+- `DATA_FILE` = **{DATA_FILE}**
+- `POP_KAB`   = **{POP_KAB}**
+- `POP_PROV`  = **{POP_PROV}**
+""")
+
+    state_df = gr.State(None)
+    state_pop_kab = gr.State(None)
+    state_pop_prov = gr.State(None)
+    state_meta = gr.State({})
+
+    with gr.Row():
+        btn_reload = gr.Button("Reload Data (paksa baca ulang file)")
+        info_box = gr.Markdown()
 
     with gr.Row():
-        dd_prov = gr.Dropdown(label="Provinsi", choices=prov_choices, value=prov_choices[0])
-        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=kab_choices, value="(Semua)")
-        dd_kew  = gr.Dropdown(label="Kewenangan", choices=kew_choices, value=default_kew)
+        dd_prov = gr.Dropdown(label="Provinsi", choices=["(Semua)"], value="(Semua)")
+        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=["(Semua)"], value="(Semua)")
+        dd_kew  = gr.Dropdown(label="Kewenangan", choices=["(Semua)"], value="(Semua)")
 
-    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("## Agregat (ringkas)")
+    gr.Markdown("## Agregat (sub/dim + Indeks FINAL)")
     agg_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Detail (ringkas)")
+    gr.Markdown("## Detail (sub/dim + Indeks FINAL)")
     detail_out = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Verifikasi Coverage & GAP menuju 68% (kontrol mutu) — tanpa koma")
+    gr.Markdown("## Verifikasi Coverage & GAP menuju 68% (kontrol mutu) — tanpa angka koma")
     verif_out = gr.DataFrame(interactive=False)
 
     gr.Markdown("## Bell Curve Indeks FINAL — Semua Perpustakaan")
     bell_all = gr.Plot()
 
-    gr.Markdown("## Bell Curve Indeks FINAL — Per Jenis Perpustakaan")
+    gr.Markdown("## Bell Curve Indeks FINAL — Sekolah")
     bell_sek = gr.Plot()
-    bell_um  = gr.Plot()
-    bell_kh  = gr.Plot()
 
+    gr.Markdown("## Bell Curve Indeks FINAL — Umum")
+    bell_um = gr.Plot()
+
+    gr.Markdown("## Bell Curve Indeks FINAL — Khusus")
+    bell_kh = gr.Plot()
+
+    gr.Markdown("## Analisis Otomatis (LLM)")
+    analysis_out = gr.Markdown()
+
+    # DOWNLOAD-ONLY (tanpa upload area)
     with gr.Row():
-        agg_file = gr.File(label="Download Agregat Ringkas (.xlsx)")
-        detail_file = gr.File(label="Download Detail Ringkas (.xlsx)")
-        verif_file = gr.File(label="Download Verifikasi Coverage (.xlsx)")
+        agg_dl  = gr.DownloadButton(label="Download Agregat (.xlsx)")
+        det_dl  = gr.DownloadButton(label="Download Detail (.xlsx)")
+        ver_dl  = gr.DownloadButton(label="Download Verifikasi Coverage (.xlsx)")
+        word_dl = gr.DownloadButton(label="Download Analisis Word (.docx)")
 
     run_btn.click(
-        fn=run_pipeline_filtered,
-        inputs=[dd_prov, dd_kab, dd_kew],
-        outputs=[agg_out, detail_out, verif_out,
-                 agg_file, detail_file, verif_file,
-                 bell_all, bell_sek, bell_um, bell_kh,
-                 msg_out],
+        fn=run_calc,
+        inputs=[dd_prov, dd_kab, dd_kew, state_df, state_pop_kab, state_pop_prov, state_meta],
+        outputs=[
+            agg_out, detail_out, verif_out,
+            agg_dl, det_dl, ver_dl, word_dl,
+            bell_all, bell_sek, bell_um, bell_kh,
+            msg_out, analysis_out
+        ]
+    )
+
+    demo.load(
+        fn=lambda: ui_load(force=False),
+        inputs=[],
+        outputs=[state_df, state_pop_kab, state_pop_prov, state_meta, info_box, dd_prov, dd_kab, dd_kew]
+    )
+
+    btn_reload.click(
+        fn=lambda: ui_load(force=True),
+        inputs=[],
+        outputs=[state_df, state_pop_kab, state_pop_prov, state_meta, info_box, dd_prov, dd_kab, dd_kew]
     )
 
 demo.launch()