Update app.py

app.py

@@ -1,27 +1,15 @@
 # -*- coding: utf-8 -*-
 """
 IPLM 2025 — FINAL (NO UPLOAD)
-Penalti Coverage 68% DITERAPKAN SETELAH AGREGAT (bukan per entitas perpustakaan)
-+ Bell Curve (berbasis agregat wilayah)
-+ Analisis LLM (Word)
-+ Download (tanpa upload box)
-
-PERMINTAAN PERBAIKAN:
-1) Hilangkan tombol "Reload Data" dari tampilan UI.
-2) Tabel "Ringkasan (per Jenis)" harus berisi: sub-dimensi, dimensi, dan nilai indeks pasca-penalty (Final agregat).
-3) Pastikan individu perpustakaan tidak terkena penalti (penalti hanya di level agregat wilayah×jenis).
-4) Penalti = rasio (n_sampel / target_68%) dengan batas maksimum 1.0.
-   - jika n_sampel >= 0.68*pop => bobot = 1
-   - jika n_sampel < 0.68*pop => bobot = n_sampel/(0.68*pop)
-   - perpustakaan khusus: bobot = 1 (tanpa penalti)
-   - jika populasi tidak valid/missing/0: bobot = 1 (tanpa penalti)
-
-Konsep:
-1) Hitung Indeks_Real per perpustakaan: YJ + minmax nasional + sub/dim + bobot dim
-2) Agregasi wilayah×jenis: mean(sub/dim/Indeks_Real)
-3) Hitung target_68 dan bobot_coverage per wilayah×jenis (khusus bobot=1)
-4) Indeks_Final_Agregat = Indeks_Real_Agregat * bobot_coverage
-5) Detail entitas menampilkan Indeks_Final_0_100 = Indeks_Final_Agregat sesuai group (bukan penalti per-row)
+✅ Khusus digabung ke "Keseluruhan" (tidak tampil sebagai jenis terpisah)
+✅ Sanksi 68% berbasis TOTAL pengumpulan data wilayah:
+   bobot_sanksi = min(n_total_terkumpul / target_total_68, 1.0)
+   Indeks_Final = Indeks_Real_Agregat * bobot_sanksi
+✅ Sanksi diterapkan SETELAH agregat (bukan per entitas)
+✅ Detail entitas: Indeks_Final_0_100 menempel dari Indeks_Final_Wilayah (bukan penalti per-row)
+✅ Bell curve berbasis Indeks_Final_Wilayah (agregat wilayah)
+✅ LLM analysis + Word
+✅ Download (tanpa upload box)
 """
 
 import os
@@ -48,9 +36,8 @@ 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"))
+W_KEPATUHAN = float(os.getenv("W_KEPATUHAN", "0.30"))
+W_KINERJA   = float(os.getenv("W_KINERJA",   "0.70"))
 
 USE_LLM = True
 LLM_MODEL_NAME = os.getenv("LLM_MODEL_NAME", "meta-llama/Meta-Llama-3-8B-Instruct")
@@ -152,29 +139,20 @@ def norm_kab_label(s):
     return re.sub(r"[^A-Z0-9]+", "", t)
 
 def safe_div(num, den):
-    if den is None or pd.isna(den) or den <= 0:
+    if den is None or pd.isna(den) or float(den) <= 0:
         return np.nan
     return float(num) / float(den)
 
-def cap_bobot_from_counts(n_sampel: float, pop: float) -> float:
+def bobot_sanksi_total(n_total: float, target_total: float) -> float:
     """
-    Bobot coverage berdasarkan JUMLAH sampel terhadap target 68% populasi.
-    bobot = min( n_sampel / (0.68*pop), 1.0 )
+    bobot = min(n_total_terkumpul / target_total_68, 1.0)
+    Jika target invalid/missing/0 -> bobot = 1 (tanpa sanksi)
     """
-    if pop is None or pd.isna(pop) or pop <= 0:
-        return np.nan
-    target_n = TARGET_COVERAGE * float(pop)
-    if target_n <= 0:
-        return np.nan
-    if n_sampel is None or pd.isna(n_sampel) or n_sampel < 0:
-        n_sampel = 0.0
-    return float(min(float(n_sampel) / target_n, 1.0))
-
-def _bobot_or_one(b):
-    # jika pop missing/0/NaN -> bobot=1 (tanpa penalti)
-    if b is None or pd.isna(b) or b <= 0:
+    if target_total is None or pd.isna(target_total) or float(target_total) <= 0:
         return 1.0
-    return float(b)
+    if n_total is None or pd.isna(n_total) or float(n_total) < 0:
+        n_total = 0.0
+    return float(min(float(n_total) / float(target_total), 1.0))
 
 
 # ============================================================
@@ -237,7 +215,7 @@ alias_map = {_canon(k): v for k, v in alias_map_raw.items()}
 # 4) PIPELINE NASIONAL (ENTITAS): YJ + MINMAX + SUBDIM/DIM/INDEKS REAL
 # ============================================================
 
-def penalized_mean(row, cols):
+def _mean_norm_cols(row, cols):
     vals = []
     for c in cols:
         k = f"norm_{c}"
@@ -284,10 +262,10 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
         df[f"norm_{c}"] = minmax_norm(pd.Series(transformed, index=df.index))
 
     # subdim & dim (entitas)
-    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["sub_koleksi"]     = df.apply(lambda r: _mean_norm_cols(r, [c for c in koleksi_cols if c in available]), axis=1)
+    df["sub_sdm"]         = df.apply(lambda r: _mean_norm_cols(r, [c for c in sdm_cols if c in available]), axis=1)
+    df["sub_pelayanan"]   = df.apply(lambda r: _mean_norm_cols(r, [c for c in pelayanan_cols if c in available]), axis=1)
+    df["sub_pengelolaan"] = df.apply(lambda r: _mean_norm_cols(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)
@@ -340,7 +318,7 @@ def load_default_files(force=False):
         _CACHE.update({"key": key, "df_all": None, "pop_kab": None, "pop_prov": None, "meta": {}, "info": info})
         return None, None, None, {}, info
 
-    # mapping jenis
+    # mapping jenis -> sekolah / umum / khusus
     val_map_jenis = {
         "PERPUSTAKAAN SEKOLAH": "sekolah", "SEKOLAH": "sekolah",
         "PERPUSTAKAAN UMUM": "umum", "UMUM": "umum", "PERPUSTAKAAN DAERAH": "umum",
@@ -368,52 +346,54 @@ def load_default_files(force=False):
     df_raw = df_raw.drop_duplicates(subset=["_row_key"], keep="first").copy()
     after = len(df_raw)
 
-    # POP KAB
+    # POP KAB: target total 68% pakai kolom "sampel_total"
     pk = pd.read_excel(POP_KAB)
     c_kab  = pick_col(pk, ["KABUPATEN_KOTA","Kab/Kota","Kabupaten/Kota","KAB/KOTA","Kabupaten_Kota"])
     c_prov = pick_col(pk, ["PROVINSI","Provinsi"])
-    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."
+    c_target_total = pick_col(pk, ["sampel_total","Sampel_total","Sampel Total","TOTAL_SAMPEL","total_sampel"])
+    c_pop_total = pick_col(pk, ["total_populasi","Total Populasi","POPULASI","populasi"])  # opsional utk coverage %
+    if c_kab is None or c_target_total is None:
+        info = "❌ POP_KAB: wajib ada kolom Kab/Kota dan sampel_total (target 68%)."
         _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,
+        "Target68_Total": pk[c_target_total].apply(coerce_num),
+        "Pop_Total": pk[c_pop_total].apply(coerce_num) if c_pop_total 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",
+        "Target68_Total":"max",
+        "Pop_Total":"max",
     })
 
-    # POP PROV
+    # POP PROV: target total 68% pakai kolom "total _sampel"
     pp = pd.read_excel(POP_PROV)
     c_pr = pick_col(pp, ["Provinsi","PROVINSI","provinsi"])
-    c_total = pick_col(pp, ["Pop_Sekolah_Prov","pop_sekolah_prov","TOTAL_SMA","total_sma","SMA","Total SMA","total_pend","TOTAL_PEND"])
-    if c_pr is None or c_total is None:
-        info = "❌ Populasi Provinsi: kolom Provinsi / total populasi sekolah tidak ditemukan."
+    c_target_total = pick_col(pp, ["total _sampel","total_sampel","TOTAL_SAMPEL","Total Sampel"])
+    c_pop_total = pick_col(pp, ["total_populasi","Total Populasi","TOTAL_PEND","total_pend","populasi"])  # opsional
+    if c_pr is None or c_target_total is None:
+        info = "❌ POP_PROV: wajib ada kolom Provinsi dan total _sampel (target 68%)."
         _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),
+        "Target68_Total_Prov": pp[c_target_total].apply(coerce_num),
+        "Pop_Total_Prov": pp[c_pop_total].apply(coerce_num) if c_pop_total else np.nan,
     })
     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",
+        "Target68_Total_Prov":"max",
+        "Pop_Total_Prov":"max",
     })
 
-    # pipeline nasional
+    # pipeline nasional (entitas)
     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)
@@ -421,8 +401,8 @@ def load_default_files(force=False):
     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"✅ POP_KAB: <b>{Path(POP_KAB).name}</b> (n={len(pop_kab)}) — target 68% via <code>sampel_total</code><br>"
+        f"✅ POP_PROV: <b>{Path(POP_PROV).name}</b> (n={len(pop_prov)}) — target 68% via <code>total _sampel</code><br>"
         f"🕒 mtime: DM={time.ctime(_mtime(DATA_FILE))} | Kab={time.ctime(_mtime(POP_KAB))} | Prov={time.ctime(_mtime(POP_PROV))}"
     )
 
@@ -431,151 +411,125 @@ def load_default_files(force=False):
 
 
 # ============================================================
-# 6) COVERAGE + BOBOT (LEVEL AGREGAT WILAYAH×JENIS)
+# 6) AGREGAT WILAYAH (KESSELURUHAN) + SANKSI TOTAL
 # ============================================================
 
-def build_verif_and_weights(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, pop_prov: pd.DataFrame, kew_value: str):
+def build_agg_wilayah_total(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, pop_prov: pd.DataFrame, kew_value: str):
     """
     Output:
-    - weights_df: group_key, Jenis, bobot_coverage, coverage, target_68_n
-    - verif_df: tabel verifikasi (dibulatkan tanpa koma)
+    - agg_total: satu baris per wilayah
+      berisi mean sub/dim, mean Indeks_Real, n_total, target_total_68, bobot_sanksi, Indeks_Final_Wilayah
     """
     if df_filtered is None or df_filtered.empty:
-        return pd.DataFrame(), pd.DataFrame()
+        return pd.DataFrame()
 
     kew_norm = str(kew_value or "").upper()
     df = df_filtered.copy()
 
-    # group_key tergantung kewenangan filter
     if "KAB" in kew_norm or "KOTA" in kew_norm:
-        level = "kab"
         key_col = "kab_key"
-        name_col = "Kab/Kota"
+        label_col = "KAB_DISP"
+        label_name = "Kab/Kota"
+        pop = pop_kab.set_index("kab_key") if (pop_kab is not None and not pop_kab.empty) else pd.DataFrame().set_index(pd.Index([]))
+        target_field = "Target68_Total"
+        pop_field = "Pop_Total"
+        name_field = "Kab_Kota_Label"
     elif "PROV" in kew_norm:
-        level = "prov"
         key_col = "prov_key"
-        name_col = "Provinsi"
+        label_col = "PROV_DISP"
+        label_name = "Provinsi"
+        pop = pop_prov.set_index("prov_key") if (pop_prov is not None and not pop_prov.empty) else pd.DataFrame().set_index(pd.Index([]))
+        target_field = "Target68_Total_Prov"
+        pop_field = "Pop_Total_Prov"
+        name_field = "Provinsi_Label"
     else:
-        # default
-        level = "kab"
         key_col = "kab_key"
-        name_col = "Kab/Kota"
-
-    # hitung sampel per group×jenis
-    g = df.groupby([key_col, "_dataset"]).size().rename("n_sampel").reset_index()
-    g_piv = g.pivot(index=key_col, columns="_dataset", values="n_sampel").fillna(0)
-
-    rows = []
-    weights_rows = []
-
-    if level == "kab":
+        label_col = "KAB_DISP"
+        label_name = "Kab/Kota"
         pop = pop_kab.set_index("kab_key") if (pop_kab is not None and not pop_kab.empty) else pd.DataFrame().set_index(pd.Index([]))
+        target_field = "Target68_Total"
+        pop_field = "Pop_Total"
+        name_field = "Kab_Kota_Label"
 
-        for kk in g_piv.index:
-            # sampel
-            n_sek = float(g_piv.loc[kk].get("sekolah", 0))
-            n_um  = float(g_piv.loc[kk].get("umum", 0))
-            n_kh  = float(g_piv.loc[kk].get("khusus", 0))
-
-            pop_sek = pop.loc[kk, "Pop_Sekolah"] if kk in pop.index else np.nan
-            pop_um  = pop.loc[kk, "Pop_Umum"] if kk in pop.index else np.nan
-
-            cov_sek = safe_div(n_sek, pop_sek)
-            cov_um  = safe_div(n_um,  pop_um)
-
-            # bobot berdasarkan JUMLAH sampel vs target_68%
-            b_sek = _bobot_or_one(cap_bobot_from_counts(n_sek, pop_sek))
-            b_um  = _bobot_or_one(cap_bobot_from_counts(n_um,  pop_um))
-            b_kh  = 1.0  # khusus tanpa penalti
-
-            target_sek = (TARGET_COVERAGE * pop_sek) if not pd.isna(pop_sek) else np.nan
-            target_um  = (TARGET_COVERAGE * pop_um)  if not pd.isna(pop_um)  else np.nan
-
-            weights_rows += [
-                {"group_key": kk, "Jenis": "sekolah", "bobot_coverage": b_sek, "coverage": cov_sek, "target_68_n": target_sek},
-                {"group_key": kk, "Jenis": "umum",    "bobot_coverage": b_um,  "coverage": cov_um,  "target_68_n": target_um},
-                {"group_key": kk, "Jenis": "khusus",  "bobot_coverage": 1.0,   "coverage": np.nan,  "target_68_n": np.nan},
-            ]
-
-            kab_name = pop.loc[kk, "Kab_Kota_Label"] if kk in pop.index else kk
-
-            rows.append({
-                name_col: kab_name,
-                "Pop_Sekolah": pop_sek,
-                "Target_68_Sekolah": target_sek,
-                "Sampel_Sekolah": n_sek,
-                "Coverage_Sekolah_%": (cov_sek * 100) if not pd.isna(cov_sek) else np.nan,
-                "Bobot_Sekolah_(Sampel/Target68)": (b_sek * 100),
-                "GAP_Ke_Target68_Sekolah": max(target_sek - n_sek, 0) if not pd.isna(target_sek) else np.nan,
-
-                "Pop_Umum": pop_um,
-                "Target_68_Umum": target_um,
-                "Sampel_Umum": n_um,
-                "Coverage_Umum_%": (cov_um * 100) if not pd.isna(cov_um) else np.nan,
-                "Bobot_Umum_(Sampel/Target68)": (b_um * 100),
-                "GAP_Ke_Target68_Umum": max(target_um - n_um, 0) if not pd.isna(target_um) else np.nan,
-
-                "Catatan": (
-                    ("Pop_Sekolah_tidak_valid; " if (pd.isna(pop_sek) or pop_sek <= 0) else "")
-                    + ("Pop_Umum_tidak_valid; " if (pd.isna(pop_um) or pop_um <= 0) else "")
-                )
-            })
-
-    else:
-        pop = pop_prov.set_index("prov_key") if (pop_prov is not None and not pop_prov.empty) else pd.DataFrame().set_index(pd.Index([]))
+    agg = df.groupby([key_col, label_col], dropna=False).agg(
+        n_total=("Indeks_Real_0_100", "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"),
+        Indeks_Real_Agregat_0_100=("Indeks_Real_0_100", "mean"),
+    ).reset_index()
 
-        for pk in g_piv.index:
-            n_sek = float(g_piv.loc[pk].get("sekolah", 0))
-            pop_sek = pop.loc[pk, "Pop_Sekolah_Prov"] if pk in pop.index else np.nan
-            cov_sek = safe_div(n_sek, pop_sek)
+    agg = agg.rename(columns={key_col: "group_key", label_col: label_name})
+
+    # join target_total_68
+    target_vals = []
+    pop_vals = []
+    label_fix = []
+    for _, r in agg.iterrows():
+        gk = r["group_key"]
+        if gk in pop.index:
+            target_total = pop.loc[gk, target_field] if target_field in pop.columns else np.nan
+            pop_total = pop.loc[gk, pop_field] if pop_field in pop.columns else np.nan
+            nm = pop.loc[gk, name_field] if name_field in pop.columns else r[label_name]
+        else:
+            target_total = np.nan
+            pop_total = np.nan
+            nm = r[label_name]
+        target_vals.append(target_total)
+        pop_vals.append(pop_total)
+        label_fix.append(nm)
+
+    agg[label_name] = label_fix
+    agg["target_total_68"] = pd.to_numeric(pd.Series(target_vals), errors="coerce")
+    agg["pop_total"] = pd.to_numeric(pd.Series(pop_vals), errors="coerce")
+
+    # bobot_sanksi berbasis TOTAL pengumpulan
+    agg["bobot_sanksi"] = [
+        bobot_sanksi_total(n, t) for n, t in zip(agg["n_total"].astype(float).tolist(), agg["target_total_68"].tolist())
+    ]
 
-            b_sek = _bobot_or_one(cap_bobot_from_counts(n_sek, pop_sek))
+    # coverage % opsional (kalau pop_total ada)
+    agg["coverage_total_%"] = [
+        (safe_div(n, p) * 100) if (p is not None and not pd.isna(p) and float(p) > 0) else np.nan
+        for n, p in zip(agg["n_total"].astype(float).tolist(), agg["pop_total"].tolist())
+    ]
 
-            target_sek = (TARGET_COVERAGE * pop_sek) if not pd.isna(pop_sek) else np.nan
-            prov_name = pop.loc[pk, "Provinsi_Label"] if pk in pop.index else pk
+    # FINAL wilayah
+    agg["Indeks_Final_Wilayah_0_100"] = agg["Indeks_Real_Agregat_0_100"] * agg["bobot_sanksi"]
 
-            weights_rows += [
-                {"group_key": pk, "Jenis": "sekolah", "bobot_coverage": b_sek, "coverage": cov_sek, "target_68_n": target_sek},
-                {"group_key": pk, "Jenis": "khusus",  "bobot_coverage": 1.0,   "coverage": np.nan, "target_68_n": np.nan},
-                {"group_key": pk, "Jenis": "umum",    "bobot_coverage": 1.0,   "coverage": np.nan, "target_68_n": np.nan},
-            ]
+    # rounding
+    for c in [
+        "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
+        "Rata2_dim_kepatuhan","Rata2_dim_kinerja"
+    ]:
+        if c in agg.columns:
+            agg[c] = agg[c].apply(lambda x: round(float(x), 3) if pd.notna(x) else 0.0)
 
-            rows.append({
-                name_col: prov_name,
-                "Pop_Sekolah": pop_sek,
-                "Target_68_Sekolah": target_sek,
-                "Sampel_Sekolah": n_sek,
-                "Coverage_Sekolah_%": (cov_sek * 100) if not pd.isna(cov_sek) else np.nan,
-                "Bobot_Sekolah_(Sampel/Target68)": (b_sek * 100),
-                "GAP_Ke_Target68_Sekolah": max(target_sek - n_sek, 0) if not pd.isna(target_sek) else np.nan,
-                "Catatan": ("Pop_Sekolah_tidak_valid; " if (pd.isna(pop_sek) or pop_sek <= 0) else "")
-            })
+    for c in ["Indeks_Real_Agregat_0_100","Indeks_Final_Wilayah_0_100","bobot_sanksi","target_total_68","coverage_total_%","pop_total"]:
+        if c in agg.columns:
+            agg[c] = pd.to_numeric(agg[c], errors="coerce")
 
-    verif_df = pd.DataFrame(rows)
-    weights_df = pd.DataFrame(weights_rows)
+    for c in ["Indeks_Real_Agregat_0_100","Indeks_Final_Wilayah_0_100"]:
+        if c in agg.columns:
+            agg[c] = agg[c].apply(lambda x: round(float(x), 2) if pd.notna(x) else 0.0)
 
-    # pembulatan verif tanpa koma
-    if not verif_df.empty:
-        for c in verif_df.columns:
-            if c in ["Catatan", name_col]:
-                continue
-            if c.endswith("%") or c.endswith("_%"):
-                verif_df[c] = verif_df[c].fillna(0).round(0).astype(int)
-            else:
-                verif_df[c] = pd.to_numeric(verif_df[c], errors="coerce").fillna(0).round(0).astype(int)
+    if "bobot_sanksi" in agg.columns:
+        agg["bobot_sanksi"] = agg["bobot_sanksi"].apply(lambda x: round(float(x), 3) if pd.notna(x) else 1.0)
 
-    return weights_df, verif_df
+    return agg
 
 
 # ============================================================
-# 7) AGREGAT WILAYAH×JENIS + FINAL (penalti setelah agregat)
+# 7) AGREGAT WILAYAH × JENIS (HANYA sekolah & umum) + FINAL pakai bobot wilayah
 # ============================================================
 
-def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, weights_df: pd.DataFrame, kew_value: str):
+def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, agg_total: pd.DataFrame, kew_value: str):
     """
-    Output:
-    - agg_df: satu baris per wilayah×jenis
-      berisi mean sub/dim, mean Indeks_Real, bobot_coverage, Indeks_Final_Agregat
+    Jenis yang tampil hanya: sekolah, umum (khusus digabung ke keseluruhan).
+    Final per jenis = Indeks_Real_Jenis * bobot_sanksi_wilayah
     """
     if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
@@ -596,7 +550,11 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, weights_df: pd.DataFrame,
         label_col = "KAB_DISP"
         label_name = "Kab/Kota"
 
-    # agregat di level wilayah×jenis
+    # tampilkan hanya sekolah & umum
+    df = df[df["_dataset"].isin(["sekolah", "umum"])].copy()
+    if df.empty:
+        return pd.DataFrame()
+
     agg = df.groupby([key_col, label_col, "_dataset"], dropna=False).agg(
         Jumlah=("Indeks_Real_0_100", "size"),
         Rata2_sub_koleksi=("sub_koleksi", "mean"),
@@ -608,23 +566,17 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, weights_df: pd.DataFrame,
         Indeks_Real_Agregat_0_100=("Indeks_Real_0_100", "mean"),
     ).reset_index()
 
-    agg = agg.rename(columns={label_col: label_name, "_dataset": "Jenis", key_col: "group_key"})
+    agg = agg.rename(columns={key_col: "group_key", label_col: label_name, "_dataset": "Jenis"})
 
-    # join bobot
-    if weights_df is None or weights_df.empty:
-        agg["bobot_coverage"] = 1.0
-        agg["coverage"] = np.nan
-        agg["target_68_n"] = np.nan
+    # join bobot wilayah
+    if agg_total is None or agg_total.empty:
+        agg["bobot_sanksi"] = 1.0
+        agg["Indeks_Final_Agregat_0_100"] = agg["Indeks_Real_Agregat_0_100"]
     else:
-        agg = agg.merge(weights_df, on=["group_key", "Jenis"], how="left")
-        agg["bobot_coverage"] = agg["bobot_coverage"].fillna(1.0)
-        if "coverage" not in agg.columns:
-            agg["coverage"] = np.nan
-        if "target_68_n" not in agg.columns:
-            agg["target_68_n"] = np.nan
-
-    # FINAL diterapkan di agregat (bukan per entitas)
-    agg["Indeks_Final_Agregat_0_100"] = agg["Indeks_Real_Agregat_0_100"] * agg["bobot_coverage"]
+        m = agg_total[["group_key", "bobot_sanksi"]].copy()
+        agg = agg.merge(m, on="group_key", how="left")
+        agg["bobot_sanksi"] = agg["bobot_sanksi"].fillna(1.0)
+        agg["Indeks_Final_Agregat_0_100"] = agg["Indeks_Real_Agregat_0_100"] * agg["bobot_sanksi"]
 
     # rounding
     for c in [
@@ -634,26 +586,80 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, weights_df: pd.DataFrame,
         if c in agg.columns:
             agg[c] = agg[c].apply(lambda x: round(float(x), 3) if pd.notna(x) else 0.0)
 
-    for c in ["Indeks_Real_Agregat_0_100","Indeks_Final_Agregat_0_100","bobot_coverage","coverage","target_68_n"]:
-        if c in agg.columns:
-            agg[c] = pd.to_numeric(agg[c], errors="coerce")
-
-    # indeks dua desimal
-    for c in ["Indeks_Real_Agregat_0_100", "Indeks_Final_Agregat_0_100"]:
+    for c in ["Indeks_Real_Agregat_0_100","Indeks_Final_Agregat_0_100","bobot_sanksi"]:
         if c in agg.columns:
             agg[c] = agg[c].apply(lambda x: round(float(x), 2) if pd.notna(x) else 0.0)
 
-    # bobot 3 desimal
-    if "bobot_coverage" in agg.columns:
-        agg["bobot_coverage"] = agg["bobot_coverage"].apply(lambda x: round(float(x), 3) if pd.notna(x) else 1.0)
-
     return agg
 
 
-def attach_final_to_detail(df_filtered: pd.DataFrame, agg_df: pd.DataFrame, meta: dict, kew_value: str):
+# ============================================================
+# 8) SUMMARY (PER JENIS) + KESELURUHAN
+# ============================================================
+
+def build_summary_per_jenis(agg_jenis: pd.DataFrame, agg_total: pd.DataFrame):
+    """
+    Ringkasan per jenis:
+    - sekolah, umum: rata2 final (sudah pakai bobot wilayah)
+    - keseluruhan: diambil dari agg_total (final wilayah)
+    """
+    rows = []
+
+    if agg_jenis is not None and not agg_jenis.empty:
+        for jenis in ["sekolah", "umum"]:
+            sub = agg_jenis[agg_jenis["Jenis"] == jenis].copy()
+            if sub.empty:
+                continue
+            rows.append({
+                "Jenis": jenis,
+                "Jumlah_Wilayah": int(sub.shape[0]),
+                "Total_Perpus": int(sub["Jumlah"].sum()),
+                "Rata2_sub_koleksi": float(sub["Rata2_sub_koleksi"].mean()),
+                "Rata2_sub_sdm": float(sub["Rata2_sub_sdm"].mean()),
+                "Rata2_sub_pelayanan": float(sub["Rata2_sub_pelayanan"].mean()),
+                "Rata2_sub_pengelolaan": float(sub["Rata2_sub_pengelolaan"].mean()),
+                "Rata2_dim_kepatuhan": float(sub["Rata2_dim_kepatuhan"].mean()),
+                "Rata2_dim_kinerja": float(sub["Rata2_dim_kinerja"].mean()),
+                "Indeks_Pasca_Sanksi_0_100": float(sub["Indeks_Final_Agregat_0_100"].mean()),
+            })
+
+    # keseluruhan: termasuk khusus (karena agg_total dibangun dari semua entitas)
+    if agg_total is not None and not agg_total.empty:
+        rows.append({
+            "Jenis": "keseluruhan",
+            "Jumlah_Wilayah": int(agg_total.shape[0]),
+            "Total_Perpus": int(agg_total["n_total"].sum()),
+            "Rata2_sub_koleksi": float(agg_total["Rata2_sub_koleksi"].mean()),
+            "Rata2_sub_sdm": float(agg_total["Rata2_sub_sdm"].mean()),
+            "Rata2_sub_pelayanan": float(agg_total["Rata2_sub_pelayanan"].mean()),
+            "Rata2_sub_pengelolaan": float(agg_total["Rata2_sub_pengelolaan"].mean()),
+            "Rata2_dim_kepatuhan": float(agg_total["Rata2_dim_kepatuhan"].mean()),
+            "Rata2_dim_kinerja": float(agg_total["Rata2_dim_kinerja"].mean()),
+            "Indeks_Pasca_Sanksi_0_100": float(agg_total["Indeks_Final_Wilayah_0_100"].mean()),
+        })
+
+    out = pd.DataFrame(rows)
+    if out.empty:
+        return out
+
+    for c in [
+        "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
+        "Rata2_dim_kepatuhan","Rata2_dim_kinerja"
+    ]:
+        out[c] = out[c].apply(lambda x: round(float(x), 3) if pd.notna(x) else 0.0)
+    out["Indeks_Pasca_Sanksi_0_100"] = out["Indeks_Pasca_Sanksi_0_100"].apply(lambda x: round(float(x), 2) if pd.notna(x) else 0.0)
+
+    return out
+
+
+# ============================================================
+# 9) DETAIL ENTITAS: Final menempel dari agg_total (wilayah)
+# ============================================================
+
+def attach_final_to_detail(df_filtered: pd.DataFrame, agg_total: pd.DataFrame, meta: dict, kew_value: str):
     """
-    Detail tetap entitas, tapi Indeks_Final_0_100 = final agregat group (wilayah×jenis).
-    (jadi individu tidak pernah dihitung penalti sendiri)
+    Indeks_Final_0_100 = Indeks_Final_Wilayah_0_100 (menempel per wilayah),
+    sehingga individu TIDAK dihitung penalti sendiri.
     """
     if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
@@ -671,14 +677,13 @@ def attach_final_to_detail(df_filtered: pd.DataFrame, agg_df: pd.DataFrame, meta
         key_col = "kab_key"
         label_cols = ("PROV_DISP", "KAB_DISP")
 
-    if agg_df is None or agg_df.empty:
+    if agg_total is None or agg_total.empty:
         df["Indeks_Final_0_100"] = df["Indeks_Real_0_100"]
     else:
-        m = agg_df[["group_key","Jenis","Indeks_Final_Agregat_0_100"]].copy()
-        m = m.rename(columns={"Jenis":"_dataset"})
-        df = df.merge(m, left_on=[key_col,"_dataset"], right_on=["group_key","_dataset"], how="left")
-        df["Indeks_Final_0_100"] = df["Indeks_Final_Agregat_0_100"].fillna(df["Indeks_Real_0_100"])
-        df = df.drop(columns=[c for c in ["group_key","Indeks_Final_Agregat_0_100"] if c in df.columns])
+        m = agg_total[["group_key", "Indeks_Final_Wilayah_0_100"]].copy()
+        df = df.merge(m, left_on=key_col, right_on="group_key", how="left")
+        df["Indeks_Final_0_100"] = df["Indeks_Final_Wilayah_0_100"].fillna(df["Indeks_Real_0_100"])
+        df = df.drop(columns=[c for c in ["group_key","Indeks_Final_Wilayah_0_100"] if c in df.columns])
 
     base_cols = [label_cols[0], label_cols[1], "KEW_NORM", "_dataset"]
     if meta.get("nama_col") and meta["nama_col"] in df.columns:
@@ -696,7 +701,6 @@ def attach_final_to_detail(df_filtered: pd.DataFrame, agg_df: pd.DataFrame, meta
     out = df[keep].copy()
     out = out.rename(columns={label_cols[0]:"Provinsi", label_cols[1]:"Kab/Kota", "_dataset":"Jenis"})
 
-    # rounding
     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)
@@ -707,78 +711,69 @@ def attach_final_to_detail(df_filtered: pd.DataFrame, agg_df: pd.DataFrame, meta
     return out
 
 
-def build_summary_per_jenis_from_agg(agg_df: pd.DataFrame):
+# ============================================================
+# 10) VERIFIKASI TOTAL (tanpa koma)
+# ============================================================
+
+def build_verif_total(agg_total: pd.DataFrame, kew_value: str):
     """
-    RINGKASAN (PER JENIS) — harus berisi sub-dimensi, dimensi, dan indeks pasca-penalty.
-    Ringkasan berbasis agregat wilayah (bukan entitas).
+    Tabel verifikasi total: n_total, target_total_68, bobot, gap, coverage% (jika ada pop).
+    Dibulatkan tanpa koma.
     """
-    if agg_df is None or agg_df.empty:
+    if agg_total is None or agg_total.empty:
         return pd.DataFrame()
 
-    grp = agg_df.groupby("Jenis", dropna=False).agg(
-        Jumlah_Wilayah=("Jenis","size"),
-        Total_Perpus=("Jumlah","sum"),
-
-        Rata2_sub_koleksi=("Rata2_sub_koleksi","mean"),
-        Rata2_sub_sdm=("Rata2_sub_sdm","mean"),
-        Rata2_sub_pelayanan=("Rata2_sub_pelayanan","mean"),
-        Rata2_sub_pengelolaan=("Rata2_sub_pengelolaan","mean"),
-
-        Rata2_dim_kepatuhan=("Rata2_dim_kepatuhan","mean"),
-        Rata2_dim_kinerja=("Rata2_dim_kinerja","mean"),
-
-        Indeks_Pasca_Penalti_0_100=("Indeks_Final_Agregat_0_100","mean"),
-    ).reset_index()
-
-    # keseluruhan
-    overall = {
-        "Jenis": "Rata-rata keseluruhan",
-        "Jumlah_Wilayah": int(agg_df.shape[0]),
-        "Total_Perpus": int(agg_df["Jumlah"].sum()),
-
-        "Rata2_sub_koleksi": float(agg_df["Rata2_sub_koleksi"].mean()),
-        "Rata2_sub_sdm": float(agg_df["Rata2_sub_sdm"].mean()),
-        "Rata2_sub_pelayanan": float(agg_df["Rata2_sub_pelayanan"].mean()),
-        "Rata2_sub_pengelolaan": float(agg_df["Rata2_sub_pengelolaan"].mean()),
-
-        "Rata2_dim_kepatuhan": float(agg_df["Rata2_dim_kepatuhan"].mean()),
-        "Rata2_dim_kinerja": float(agg_df["Rata2_dim_kinerja"].mean()),
-
-        "Indeks_Pasca_Penalti_0_100": float(agg_df["Indeks_Final_Agregat_0_100"].mean()),
-    }
-    grp = pd.concat([grp, pd.DataFrame([overall])], ignore_index=True)
+    df = agg_total.copy()
+    # kolom label dinamis
+    label_col = "Kab/Kota" if "Kab/Kota" in df.columns else ("Provinsi" if "Provinsi" in df.columns else "Wilayah")
+
+    out = pd.DataFrame({
+        label_col: df[label_col].astype(str),
+        "Pop_Total": df.get("pop_total", np.nan),
+        "Target_68_Total": df.get("target_total_68", np.nan),
+        "Sampel_Total_Terkumpul": df.get("n_total", 0),
+        "Coverage_Total_%": df.get("coverage_total_%", np.nan),
+        "Bobot_Sanksi_(Sampel/Target68)": df.get("bobot_sanksi", 1.0) * 100,
+        "GAP_Ke_Target68_Total": [
+            max(t - n, 0) if (t is not None and not pd.isna(t)) else np.nan
+            for n, t in zip(df["n_total"].astype(float).tolist(), df["target_total_68"].tolist())
+        ],
+        "Catatan": [
+            ("Target68_Total_tidak_valid" if (t is None or pd.isna(t) or float(t) <= 0) else "")
+            for t in df["target_total_68"].tolist()
+        ]
+    })
 
-    # rounding
-    for c in [
-        "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
-        "Rata2_dim_kepatuhan","Rata2_dim_kinerja"
-    ]:
-        if c in grp.columns:
-            grp[c] = grp[c].apply(lambda x: round(float(x), 3) if pd.notna(x) else 0.0)
-    if "Indeks_Pasca_Penalti_0_100" in grp.columns:
-        grp["Indeks_Pasca_Penalti_0_100"] = grp["Indeks_Pasca_Penalti_0_100"].apply(lambda x: round(float(x), 2) if pd.notna(x) else 0.0)
+    # pembulatan tanpa koma
+    for c in out.columns:
+        if c in [label_col, "Catatan"]:
+            continue
+        if c.endswith("%") or c.endswith("_%"):
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
+        else:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
 
-    return grp
+    return out
 
 
 # ============================================================
-# 8) BELL CURVE (BERBASIS AGREGAT WILAYAH)
+# 11) BELL CURVE (BERBASIS FINAL WILAYAH)
 # ============================================================
 
-def make_bell_figure_from_agg(agg_df: pd.DataFrame, title: str, min_points: int = 5, label_field: str = "Wilayah"):
+def make_bell_figure_from_total(agg_total: pd.DataFrame, title: str, min_points: int = 5):
     fig = go.Figure()
-    fig.update_layout(title=title, xaxis_title="Indeks FINAL Agregat (0–100)", yaxis_title="Kepadatan (relatif)")
+    fig.update_layout(title=title, xaxis_title="Indeks FINAL Wilayah (0–100)", yaxis_title="Kepadatan (relatif)")
 
-    if agg_df is None or agg_df.empty or "Indeks_Final_Agregat_0_100" not in agg_df.columns:
+    if agg_total is None or agg_total.empty or "Indeks_Final_Wilayah_0_100" not in agg_total.columns:
         return fig
 
-    dfp = agg_df.dropna(subset=["Indeks_Final_Agregat_0_100"]).copy()
+    dfp = agg_total.dropna(subset=["Indeks_Final_Wilayah_0_100"]).copy()
     if len(dfp) < min_points:
         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 = dfp["Indeks_Final_Agregat_0_100"].astype(float).values
+    x = dfp["Indeks_Final_Wilayah_0_100"].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)
@@ -787,15 +782,19 @@ def make_bell_figure_from_agg(agg_df: pd.DataFrame, title: str, min_points: int
     pdf = (1.0 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((xs - mu) / sigma) ** 2)
     pdf = pdf / max(pdf.max(), 1e-9)
 
-    # label hover
-    if label_field in dfp.columns:
-        hover = [f"{w}<br>Final: {v:.2f}<br>Real: {r:.2f}<br>Bobot: {b:.3f}"
-                 for w, v, r, b in zip(
-                     dfp[label_field].astype(str).tolist(),
-                     dfp["Indeks_Final_Agregat_0_100"].astype(float).tolist(),
-                     dfp["Indeks_Real_Agregat_0_100"].astype(float).tolist() if "Indeks_Real_Agregat_0_100" in dfp.columns else [np.nan]*len(dfp),
-                     dfp["bobot_coverage"].astype(float).tolist() if "bobot_coverage" in dfp.columns else [1.0]*len(dfp),
-                 )]
+    label_col = "Kab/Kota" if "Kab/Kota" in dfp.columns else ("Provinsi" if "Provinsi" in dfp.columns else None)
+    if label_col:
+        hover = [
+            f"{w}<br>Final: {v:.2f}<br>Real: {r:.2f}<br>Bobot: {b:.3f}<br>n_total: {int(n)}<br>target_68: {t if pd.notna(t) else 'NA'}"
+            for w, v, r, b, n, t in zip(
+                dfp[label_col].astype(str).tolist(),
+                dfp["Indeks_Final_Wilayah_0_100"].astype(float).tolist(),
+                dfp["Indeks_Real_Agregat_0_100"].astype(float).tolist(),
+                dfp["bobot_sanksi"].astype(float).tolist(),
+                dfp["n_total"].astype(float).tolist(),
+                dfp["target_total_68"].tolist(),
+            )
+        ]
     else:
         hover = [f"Final: {v:.2f}" for v in x]
 
@@ -820,7 +819,7 @@ def make_bell_figure_from_agg(agg_df: pd.DataFrame, title: str, min_points: int
 
 
 # ============================================================
-# 9) LLM + WORD
+# 12) LLM + WORD
 # ============================================================
 
 _HF_CLIENT = None
@@ -836,49 +835,47 @@ def get_llm_client():
         _HF_CLIENT = None
         return None
 
-def build_context_from_agg(summary_jenis: pd.DataFrame, agg_wilayah: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
+def build_context(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, verif_total: pd.DataFrame, wilayah: str, kew: str) -> str:
     lines = []
     lines.append(f"Wilayah filter: {wilayah}")
     lines.append(f"Kewenangan: {kew}")
-    lines.append("Catatan metode: Penalti coverage 68% diterapkan setelah indeks agregat wilayah×jenis dihitung; individu tidak dipenalti.")
-    lines.append("Definisi bobot coverage: bobot = min(n_sampel / (0.68*populasi), 1.0). Khusus = 1. Populasi invalid = 1.")
+    lines.append("Metode: Indeks real dihitung per entitas (YJ+minmax nasional), lalu diagregasi per wilayah. Setelah itu diberlakukan sanksi 68% berbasis TOTAL pengumpulan wilayah.")
+    lines.append("Rumus sanksi: bobot = min(total_terkumpul / target_total_68, 1.0); Indeks_Final = Indeks_Real_Agregat × bobot.")
+    lines.append("Catatan: Perpustakaan khusus digabung ke indeks keseluruhan (tidak tampil sebagai jenis terpisah).")
 
     if summary_jenis is not None and not summary_jenis.empty:
-        lines.append("\nRingkasan (per jenis) — berbasis agregat wilayah:")
+        lines.append("\nRingkasan (jenis + keseluruhan):")
         for _, r in summary_jenis.iterrows():
-            if str(r.get("Jenis","")) == "Rata-rata keseluruhan":
-                continue
             lines.append(
                 f"- {r['Jenis']}: wilayah={int(r['Jumlah_Wilayah'])}, total_perpus={int(r['Total_Perpus'])}, "
                 f"dim_kepatuhan={float(r['Rata2_dim_kepatuhan']):.3f}, dim_kinerja={float(r['Rata2_dim_kinerja']):.3f}, "
-                f"final_pasca_penalti={float(r['Indeks_Pasca_Penalti_0_100']):.2f}"
+                f"final_pasca_sanksi={float(r['Indeks_Pasca_Sanksi_0_100']):.2f}"
             )
 
-    if agg_wilayah is not None and not agg_wilayah.empty:
-        lines.append("\nTop 5 wilayah (Final agregat tertinggi):")
-        top = agg_wilayah.sort_values("Indeks_Final_Agregat_0_100", ascending=False).head(5)
+    if agg_total is not None and not agg_total.empty:
+        label_col = "Kab/Kota" if "Kab/Kota" in agg_total.columns else ("Provinsi" if "Provinsi" in agg_total.columns else None)
+        lines.append("\nTop 5 wilayah (Final tertinggi):")
+        top = agg_total.sort_values("Indeks_Final_Wilayah_0_100", ascending=False).head(5)
         for _, r in top.iterrows():
-            wl = r.get("Kab/Kota", r.get("Provinsi","(wilayah)"))
+            wl = r.get(label_col, "(wilayah)") if label_col else "(wilayah)"
             lines.append(
-                f"- {wl} ({r['Jenis']}): Final={float(r['Indeks_Final_Agregat_0_100']):.2f} "
-                f"| Bobot={float(r.get('bobot_coverage', 1.0)):.3f} | Jumlah={int(r.get('Jumlah', 0))}"
+                f"- {wl}: Final={float(r['Indeks_Final_Wilayah_0_100']):.2f} | Bobot={float(r.get('bobot_sanksi', 1.0)):.3f} | total={int(r.get('n_total', 0))}"
             )
 
-        lines.append("\nTop 5 wilayah (GAP menuju target 68% terbesar):")
-        if verif_df is not None and not verif_df.empty:
-            gap_cols = [c for c in verif_df.columns if c.startswith("GAP_Ke_Target68")]
-            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():
-                    nm = r.get("Kab/Kota", r.get("Provinsi",""))
-                    lines.append(f"- {nm}: GAP maks={int(r['GAP_MAX'])}")
+    if verif_total is not None and not verif_total.empty:
+        gap_col = "GAP_Ke_Target68_Total"
+        if gap_col in verif_total.columns:
+            lines.append("\nTop 5 wilayah (GAP ke target 68% terbesar):")
+            tmp = verif_total.sort_values(gap_col, ascending=False).head(5)
+            name_col = "Kab/Kota" if "Kab/Kota" in tmp.columns else ("Provinsi" if "Provinsi" in tmp.columns else None)
+            for _, r in tmp.iterrows():
+                nm = r.get(name_col, "") if name_col else ""
+                lines.append(f"- {nm}: GAP={int(r[gap_col])}")
 
     return "\n".join(lines)
 
-def generate_llm_analysis(summary_jenis: pd.DataFrame, agg_wilayah: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
-    ctx = build_context_from_agg(summary_jenis, agg_wilayah, verif_df, wilayah, kew)
+def generate_llm_analysis(summary_jenis, agg_total, verif_total, wilayah, kew):
+    ctx = build_context(summary_jenis, agg_total, verif_total, wilayah, kew)
     client = get_llm_client()
     if client is None or not USE_LLM:
         return "Analisis otomatis (LLM) tidak tersedia. Pastikan token HuggingFace tersedia dan model bisa diakses."
@@ -888,20 +885,20 @@ def generate_llm_analysis(summary_jenis: pd.DataFrame, agg_wilayah: pd.DataFrame
         "Tugas Anda menyusun analisis berbasis data IPLM secara formal, tajam, dan operasional."
     )
     user_prompt = f"""
-DATA RINGKAS IPLM (PENALTI COVERAGE SETELAH AGREGAT):
+DATA RINGKAS IPLM (SANKSI 68% BERBASIS TOTAL WILAYAH):
 
 {ctx}
 
 TULISKAN ANALISIS BAHASA INDONESIA FORMAL, STRUKTUR:
-1) Gambaran umum hasil agregat (1 paragraf).
-2) Analisis per jenis perpustakaan (sub-dimensi/dimensi dan indeks pasca-penalti) (2 paragraf).
-3) Analisis coverage (target 68%) dan implikasi pada indeks final agregat (1 paragraf).
-4) Rekomendasi program 3–5 tahun (2 paragraf, konkret, bisa dieksekusi).
+1) Gambaran umum hasil wilayah (1 paragraf).
+2) Analisis jenis sekolah & umum serta indeks keseluruhan (sub-dimensi/dimensi dan indeks pasca-sanksi) (2 paragraf).
+3) Analisis dampak sanksi 68% (berdasarkan total pengumpulan) terhadap indeks final wilayah (1 paragraf).
+4) Rekomendasi program 3–5 tahun (2 paragraf, konkret dan dapat dieksekusi).
 
 ATURAN:
-- Jangan pakai label menilai eksplisit seperti "rendah/sedang/tinggi".
-- Gunakan frasa netral: "masih memiliki ruang penguatan", "memerlukan konsolidasi", dst.
-- Fokus pada Indeks FINAL AGREGAT (pasca penalti), bukan individu.
+- Jangan memakai label eksplisit "rendah/sedang/tinggi".
+- Pakai frasa netral: "memerlukan penguatan", "memerlukan konsolidasi", dsb.
+- Fokus pada Indeks FINAL WILAYAH (pasca sanksi), bukan individu.
 """
     try:
         resp = client.chat_completion(
@@ -916,15 +913,15 @@ ATURAN:
     except Exception as e:
         return f"⚠️ Error saat memanggil LLM: {repr(e)}"
 
-def generate_word_report(detail_df: pd.DataFrame, summary_jenis: pd.DataFrame, agg_wilayah: pd.DataFrame, verif_df: pd.DataFrame,
-                         wilayah: str, kew: str, analysis_text: str) -> str:
+def generate_word_report(detail_df, summary_jenis, agg_total, agg_jenis, verif_total, wilayah, kew, analysis_text):
     doc = Document()
     doc.add_heading(f"Laporan IPLM — {wilayah}", level=1)
     doc.add_paragraph(f"Kewenangan: {kew}")
-    doc.add_paragraph("Metode: Penalti coverage 68% diterapkan setelah indeks agregat wilayah×jenis dihitung (bukan per entitas perpustakaan).")
-    doc.add_paragraph("Bobot coverage: bobot = min(n_sampel / (0.68*populasi), 1.0). Perpustakaan khusus = 1. Populasi invalid/missing = 1.")
+    doc.add_paragraph("Metode: Indeks real dihitung per entitas (YJ+minmax nasional), diagregasi per wilayah, lalu dikenakan sanksi 68% berbasis TOTAL pengumpulan wilayah.")
+    doc.add_paragraph("Rumus sanksi: bobot = min(total_terkumpul / target_total_68, 1.0). Indeks_Final = Indeks_Real_Agregat × bobot.")
+    doc.add_paragraph("Catatan: Perpustakaan khusus digabung ke indeks keseluruhan (tidak tampil sebagai jenis terpisah).")
 
-    doc.add_heading("Ringkasan (per jenis) — sub-dimensi, dimensi, indeks pasca penalti", level=2)
+    doc.add_heading("Ringkasan (Jenis + Keseluruhan) — sub-dimensi, dimensi, indeks pasca sanksi", level=2)
     if summary_jenis is not None and not summary_jenis.empty:
         table = doc.add_table(rows=1, cols=len(summary_jenis.columns))
         hdr = table.rows[0].cells
@@ -935,13 +932,11 @@ def generate_word_report(detail_df: pd.DataFrame, summary_jenis: pd.DataFrame, a
             for i, c in enumerate(summary_jenis.columns):
                 cells[i].text = str(row[c])
     else:
-        doc.add_paragraph("Ringkasan agregat tidak tersedia.")
-
-    doc.add_heading("Agregat Wilayah × Jenis (Final setelah penalti)", level=2)
-    if agg_wilayah is not None and not agg_wilayah.empty:
-        show = agg_wilayah.copy()
-        show = show.sort_values("Indeks_Final_Agregat_0_100", ascending=False).head(200)
+        doc.add_paragraph("Ringkasan tidak tersedia.")
 
+    doc.add_heading("Agregat Wilayah (Keseluruhan) — Final setelah sanksi", level=2)
+    if agg_total is not None and not agg_total.empty:
+        show = agg_total.sort_values("Indeks_Final_Wilayah_0_100", ascending=False).head(300)
         table = doc.add_table(rows=1, cols=len(show.columns))
         hdr = table.rows[0].cells
         for i, c in enumerate(show.columns):
@@ -953,22 +948,36 @@ def generate_word_report(detail_df: pd.DataFrame, summary_jenis: pd.DataFrame, a
     else:
         doc.add_paragraph("Agregat wilayah tidak tersedia.")
 
-    doc.add_heading("Verifikasi Coverage & GAP menuju target 68% (tanpa angka koma)", level=2)
-    if verif_df is not None and not verif_df.empty:
-        table = doc.add_table(rows=1, cols=len(verif_df.columns))
+    doc.add_heading("Agregat Wilayah × Jenis (Sekolah & Umum) — Final memakai bobot wilayah", level=2)
+    if agg_jenis is not None and not agg_jenis.empty:
+        show = agg_jenis.sort_values("Indeks_Final_Agregat_0_100", ascending=False).head(300)
+        table = doc.add_table(rows=1, cols=len(show.columns))
         hdr = table.rows[0].cells
-        for i, c in enumerate(verif_df.columns):
+        for i, c in enumerate(show.columns):
             hdr[i].text = str(c)
-        for _, row in verif_df.iterrows():
+        for _, row in show.iterrows():
             cells = table.add_row().cells
-            for i, c in enumerate(verif_df.columns):
+            for i, c in enumerate(show.columns):
                 cells[i].text = str(row[c])
     else:
-        doc.add_paragraph("Tidak ada tabel verifikasi untuk filter ini.")
+        doc.add_paragraph("Agregat jenis tidak tersedia (atau tidak ada sekolah/umum di filter).")
 
-    doc.add_heading("Detail Entitas (Indeks Final menempel pada agregat wilayah×jenis)", level=2)
+    doc.add_heading("Verifikasi Total (Target 68% berbasis kolom Excel, tanpa koma)", level=2)
+    if verif_total is not None and not verif_total.empty:
+        table = doc.add_table(rows=1, cols=len(verif_total.columns))
+        hdr = table.rows[0].cells
+        for i, c in enumerate(verif_total.columns):
+            hdr[i].text = str(c)
+        for _, row in verif_total.iterrows():
+            cells = table.add_row().cells
+            for i, c in enumerate(verif_total.columns):
+                cells[i].text = str(row[c])
+    else:
+        doc.add_paragraph("Verifikasi tidak tersedia.")
+
+    doc.add_heading("Detail Entitas (Final menempel dari wilayah)", level=2)
     if detail_df is not None and not detail_df.empty:
-        show = detail_df.copy().head(200)
+        show = detail_df.head(250)
         table = doc.add_table(rows=1, cols=len(show.columns))
         hdr = table.rows[0].cells
         for i, c in enumerate(show.columns):
@@ -991,16 +1000,16 @@ def generate_word_report(detail_df: pd.DataFrame, summary_jenis: pd.DataFrame, a
 
 
 # ============================================================
-# 10) CORE RUN
+# 13) CORE RUN
 # ============================================================
 
 def _empty_outputs(msg="⚠️ Data belum siap."):
     empty = pd.DataFrame()
     empty_fig = go.Figure()
     return (
-        empty, empty, empty, empty,
+        empty, empty, empty, empty, empty,
         None, None, None, None,
-        empty_fig, empty_fig, empty_fig, empty_fig,
+        empty_fig,
         msg, "Analisis belum tersedia."
     )
 
@@ -1022,45 +1031,23 @@ def run_calc(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, meta):
         if df.empty:
             return _empty_outputs("Tidak ada data untuk filter ini.")
 
-        # coverage & weights (AGREGAT)
-        weights_df, verif_df = build_verif_and_weights(df, pop_kab, pop_prov, kew_value or "(Semua)")
+        # 1) agregat wilayah keseluruhan (termasuk khusus)
+        agg_total = build_agg_wilayah_total(df, pop_kab, pop_prov, kew_value or "(Semua)")
 
-        # agregat wilayah×jenis + final (penalti setelah agregat)
-        agg_wilayah = build_agg_wilayah_jenis(df, weights_df, kew_value or "(Semua)")
+        # 2) agregat wilayah×jenis (hanya sekolah & umum) + final pakai bobot wilayah
+        agg_jenis = build_agg_wilayah_jenis(df, agg_total, kew_value or "(Semua)")
 
-        # ringkasan per jenis (sub/dim + indeks pasca penalti)
-        summary_jenis = build_summary_per_jenis_from_agg(agg_wilayah)
+        # 3) ringkasan jenis + keseluruhan (khusus tergabung)
+        summary_jenis = build_summary_per_jenis(agg_jenis, agg_total)
 
-        # detail entitas: final menempel pada agregat group
-        detail_view = attach_final_to_detail(df, agg_wilayah, meta, kew_value or "(Semua)")
+        # 4) verifikasi total (tanpa koma)
+        verif_total = build_verif_total(agg_total, kew_value or "(Semua)")
 
-        # bell curve berbasis agregat wilayah
-        label_field = "Kab/Kota" if "Kab/Kota" in agg_wilayah.columns else ("Provinsi" if "Provinsi" in agg_wilayah.columns else "Wilayah")
+        # 5) detail entitas: final menempel dari wilayah
+        detail_view = attach_final_to_detail(df, agg_total, meta, kew_value or "(Semua)")
 
-        fig_all = make_bell_figure_from_agg(
-            agg_wilayah.assign(Wilayah=agg_wilayah.get(label_field, "")),
-            "Bell Curve Final Agregat — Semua Jenis",
-            min_points=5,
-            label_field="Wilayah"
-        )
-        fig_sek = make_bell_figure_from_agg(
-            agg_wilayah[agg_wilayah["Jenis"]=="sekolah"].assign(Wilayah=agg_wilayah.get(label_field, "")),
-            "Bell Curve Final Agregat — Sekolah",
-            min_points=3,
-            label_field="Wilayah"
-        )
-        fig_um = make_bell_figure_from_agg(
-            agg_wilayah[agg_wilayah["Jenis"]=="umum"].assign(Wilayah=agg_wilayah.get(label_field, "")),
-            "Bell Curve Final Agregat — Umum",
-            min_points=3,
-            label_field="Wilayah"
-        )
-        fig_kh = make_bell_figure_from_agg(
-            agg_wilayah[agg_wilayah["Jenis"]=="khusus"].assign(Wilayah=agg_wilayah.get(label_field, "")),
-            "Bell Curve Final Agregat — Khusus",
-            min_points=3,
-            label_field="Wilayah"
-        )
+        # 6) bell curve (final wilayah)
+        fig_total = make_bell_figure_from_total(agg_total, "Bell Curve — Indeks FINAL Wilayah (Keseluruhan, pasca sanksi)", min_points=5)
 
         # output files
         tmpdir = tempfile.mkdtemp()
@@ -1068,29 +1055,31 @@ def run_calc(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, meta):
         kab_slug  = (_canon(kab_value  or "SEMUA").upper() or "SEMUA")
         kew_slug  = (_canon(kew_value  or "SEMUA").upper() or "SEMUA")
 
-        summary_path = str(Path(tmpdir) / f"IPLM_RingkasanJenis_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        wilayah_path = str(Path(tmpdir) / f"IPLM_AgregatWilayahJenis_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        detail_path  = str(Path(tmpdir) / f"IPLM_DetailEntitas_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        verif_path   = str(Path(tmpdir) / f"IPLM_VerifikasiCoverage_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_summary = str(Path(tmpdir) / f"IPLM_RingkasanJenisKeseluruhan_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_total   = str(Path(tmpdir) / f"IPLM_AgregatWilayah_Keseluruhan_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_jenis   = str(Path(tmpdir) / f"IPLM_AgregatWilayah_Jenis_SekUm_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_detail  = str(Path(tmpdir) / f"IPLM_DetailEntitas_FinalMenempelWilayah_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        p_verif   = str(Path(tmpdir) / f"IPLM_VerifikasiTotal68_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
 
-        summary_jenis.to_excel(summary_path, index=False)
-        agg_wilayah.to_excel(wilayah_path, index=False)
-        detail_view.to_excel(detail_path, index=False)
-        verif_df.to_excel(verif_path, index=False)
+        summary_jenis.to_excel(p_summary, index=False)
+        agg_total.to_excel(p_total, index=False)
+        agg_jenis.to_excel(p_jenis, index=False)
+        detail_view.to_excel(p_detail, index=False)
+        verif_total.to_excel(p_verif, index=False)
 
         wilayah_txt = 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(summary_jenis, agg_wilayah, verif_df, wilayah_txt, kew_value or "(Semua)")
-        word_path = generate_word_report(detail_view, summary_jenis, agg_wilayah, verif_df, wilayah_txt, kew_value or "(Semua)", analysis_text)
+        analysis_text = generate_llm_analysis(summary_jenis, agg_total, verif_total, wilayah_txt, kew_value or "(Semua)")
+        word_path = generate_word_report(detail_view, summary_jenis, agg_total, agg_jenis, verif_total, wilayah_txt, kew_value or "(Semua)", analysis_text)
 
         msg = (
-            f"✅ Selesai: entitas={len(detail_view)} | agregat_wilayah×jenis={len(agg_wilayah)} | "
-            f"penalti diterapkan setelah agregat (individu tidak dipenalti)"
+            f"✅ Selesai: entitas={len(detail_view)} | wilayah(keseluruhan)={len(agg_total)} | "
+            f"jenis(sekolah+umum)={len(agg_jenis)} | sanksi=total_terkumpul/target_total_68 (cap 1.0)"
         )
 
         return (
-            summary_jenis, agg_wilayah, detail_view, verif_df,
-            summary_path, wilayah_path, detail_path, word_path,
-            fig_all, fig_sek, fig_um, fig_kh,
+            summary_jenis, agg_total, agg_jenis, detail_view, verif_total,
+            p_summary, p_total, p_detail, word_path,
+            fig_total,
             msg, analysis_text
         )
 
@@ -1099,7 +1088,7 @@ def run_calc(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, meta):
 
 
 # ============================================================
-# 11) UI (NO UPLOAD) — TANPA TOMBOL RELOAD
+# 14) UI (NO UPLOAD) — TANPA TOMBOL RELOAD
 # ============================================================
 
 def ui_load(force=False):
@@ -1138,16 +1127,16 @@ def on_prov_change(prov_value):
 
 with gr.Blocks() as demo:
     gr.Markdown(f"""
-# IPLM 2025 — Final (Penalti Coverage 68% Setelah Agregat)
+# IPLM 2025 — Final (Sanksi 68% Berbasis TOTAL Pengumpulan Wilayah)
 **Mode NO UPLOAD (cache aktif).** File dibaca dari repo/server:
 - `DATA_FILE` = **{DATA_FILE}**
-- `POP_KAB`   = **{POP_KAB}**
-- `POP_PROV`  = **{POP_PROV}**
+- `POP_KAB`   = **{POP_KAB}** (target 68%: kolom **sampel_total**)
+- `POP_PROV`  = **{POP_PROV}** (target 68%: kolom **total _sampel**)
 
-**Metode penalti (SESUI PERMINTAAN):**
-- Hitung indeks real per entitas → agregasi wilayah×jenis → terapkan bobot coverage pada AGREGAT.
-- Bobot coverage = `min(n_sampel / (0.68*populasi), 1.0)`; jika populasi tidak valid → bobot=1.
-- Perpustakaan **khusus** tidak dipenalti (bobot=1).
+**Aturan penting:**
+- Hitung indeks real per entitas (YJ+minmax nasional) → agregasi wilayah (keseluruhan) → **baru sanksi**.
+- Sanksi 68% memakai total pengumpulan wilayah: `bobot = min(n_total_terkumpul / target_total_68, 1.0)`.
+- Perpustakaan **khusus digabung ke indeks keseluruhan** (tidak tampil sebagai jenis terpisah).
 """)
 
     state_df = gr.State(None)
@@ -1167,33 +1156,30 @@ with gr.Blocks() as demo:
     run_btn = gr.Button("Jalankan Perhitungan")
     msg_out = gr.Markdown()
 
-    gr.Markdown("## Ringkasan (per Jenis) — sub-dimensi, dimensi, indeks pasca penalti (berbasis agregat wilayah)")
+    gr.Markdown("## Ringkasan (Jenis + Keseluruhan) — sub-dimensi, dimensi, indeks pasca sanksi")
     out_summary = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Agregat Wilayah × Jenis (Final setelah penalti)")
-    out_agg_wilayah = gr.DataFrame(interactive=False)
+    gr.Markdown("## Agregat Wilayah (Keseluruhan, termasuk khusus) — Final setelah sanksi")
+    out_agg_total = gr.DataFrame(interactive=False)
+
+    gr.Markdown("## Agregat Wilayah × Jenis (Sekolah & Umum) — Final memakai bobot wilayah")
+    out_agg_jenis = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Detail Entitas (Indeks Final menempel pada agregat wilayah×jenis; individu tidak dipenalti)")
+    gr.Markdown("## Detail Entitas (Final menempel dari wilayah; individu tidak dipenalti per-row)")
     out_detail = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Verifikasi Coverage & GAP menuju target 68% (tanpa angka koma)")
+    gr.Markdown("## Verifikasi Total 68% (tanpa angka koma)")
     out_verif = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Bell Curve Final Agregat — Semua Jenis")
-    bell_all = gr.Plot()
-    gr.Markdown("## Bell Curve Final Agregat — Sekolah")
-    bell_sek = gr.Plot()
-    gr.Markdown("## Bell Curve Final Agregat — Umum")
-    bell_um = gr.Plot()
-    gr.Markdown("## Bell Curve Final Agregat — Khusus")
-    bell_kh = gr.Plot()
+    gr.Markdown("## Bell Curve — Indeks FINAL Wilayah (Keseluruhan)")
+    bell_total = gr.Plot()
 
     gr.Markdown("## Analisis Otomatis (LLM)")
     analysis_out = gr.Markdown()
 
     with gr.Row():
-        dl_summary = gr.DownloadButton(label="Download Ringkasan Jenis (.xlsx)")
-        dl_wilayah = gr.DownloadButton(label="Download Agregat Wilayah×Jenis (.xlsx)")
+        dl_summary = gr.DownloadButton(label="Download Ringkasan (.xlsx)")
+        dl_total   = gr.DownloadButton(label="Download Agregat Wilayah Keseluruhan (.xlsx)")
         dl_detail  = gr.DownloadButton(label="Download Detail Entitas (.xlsx)")
         dl_word    = gr.DownloadButton(label="Download Laporan Word (.docx)")
 
@@ -1201,9 +1187,9 @@ with gr.Blocks() as demo:
         fn=run_calc,
         inputs=[dd_prov, dd_kab, dd_kew, state_df, state_pop_kab, state_pop_prov, state_meta],
         outputs=[
-            out_summary, out_agg_wilayah, out_detail, out_verif,
-            dl_summary, dl_wilayah, dl_detail, dl_word,
-            bell_all, bell_sek, bell_um, bell_kh,
+            out_summary, out_agg_total, out_agg_jenis, out_detail, out_verif,
+            dl_summary, dl_total, dl_detail, dl_word,
+            bell_total,
             msg_out, analysis_out
         ]
     )