Update app.py

app.py

@@ -6,10 +6,20 @@ Penalti Coverage 68% DITERAPKAN SETELAH AGREGAT (bukan per entitas perpustakaan)
 + 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(Indeks_Real)
-3) Hitung coverage & bobot_coverage per wilayah×jenis (khusus bobot=1)
+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)
 """
@@ -146,14 +156,22 @@ def safe_div(num, den):
         return np.nan
     return float(num) / float(den)
 
-def cap_bobot(cov: float) -> float:
-    # <68% -> cov/0.68 ; >=68% -> 1
-    if cov is None or pd.isna(cov) or cov <= 0:
+def cap_bobot_from_counts(n_sampel: float, pop: float) -> float:
+    """
+    Bobot coverage berdasarkan JUMLAH sampel terhadap target 68% populasi.
+    bobot = min( n_sampel / (0.68*pop), 1.0 )
+    """
+    if pop is None or pd.isna(pop) or pop <= 0:
         return np.nan
-    return float(min(cov / TARGET_COVERAGE, 1.0))
+    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 -> bobot=1 (tanpa penalti)
+    # jika pop missing/0/NaN -> bobot=1 (tanpa penalti)
     if b is None or pd.isna(b) or b <= 0:
         return 1.0
     return float(b)
@@ -419,7 +437,7 @@ def load_default_files(force=False):
 def build_verif_and_weights(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, pop_prov: pd.DataFrame, kew_value: str):
     """
     Output:
-    - weights_df: berisi group_key, Jenis, bobot_coverage_raw, coverage_raw
+    - weights_df: group_key, Jenis, bobot_coverage, coverage, target_68_n
     - verif_df: tabel verifikasi (dibulatkan tanpa koma)
     """
     if df_filtered is None or df_filtered.empty:
@@ -438,8 +456,7 @@ def build_verif_and_weights(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
         key_col = "prov_key"
         name_col = "Provinsi"
     else:
-        # kalau (Semua) kewenangan, kita tetap pakai kab untuk umum/sekolah kabkota,
-        # tapi ini riskan; untuk sederhana: treat as kab (paling umum di data)
+        # default
         level = "kab"
         key_col = "kab_key"
         name_col = "Kab/Kota"
@@ -466,36 +483,38 @@ def build_verif_and_weights(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
             cov_sek = safe_div(n_sek, pop_sek)
             cov_um  = safe_div(n_um,  pop_um)
 
-            bobot_sek = _bobot_or_one(cap_bobot(cov_sek))
-            bobot_um  = _bobot_or_one(cap_bobot(cov_um))
-            bobot_kh  = 1.0
-
-            # weights per jenis
-            weights_rows += [
-                {"group_key": kk, "Jenis": "sekolah", "bobot_coverage": bobot_sek, "coverage": cov_sek},
-                {"group_key": kk, "Jenis": "umum",    "bobot_coverage": bobot_um,  "coverage": cov_um},
-                {"group_key": kk, "Jenis": "khusus",  "bobot_coverage": bobot_kh,  "coverage": np.nan},
-            ]
+            # 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
 
-            # verifikasi row (untuk tampilan)
             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_68_%": (bobot_sek * 100),
-                "GAP_Ke_68_Sekolah": max(target_sek - n_sek, 0) if not pd.isna(target_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_68_%": (bobot_um * 100),
-                "GAP_Ke_68_Umum": max(target_um - n_um, 0) if not pd.isna(target_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 "")
@@ -507,30 +526,28 @@ def build_verif_and_weights(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
 
         for pk in g_piv.index:
             n_sek = float(g_piv.loc[pk].get("sekolah", 0))
-            n_kh  = float(g_piv.loc[pk].get("khusus", 0))
-            n_um  = float(g_piv.loc[pk].get("umum", 0))  # biasanya 0 untuk prov
-
             pop_sek = pop.loc[pk, "Pop_Sekolah_Prov"] if pk in pop.index else np.nan
             cov_sek = safe_div(n_sek, pop_sek)
-            bobot_sek = _bobot_or_one(cap_bobot(cov_sek))
 
-            # weights
-            weights_rows += [
-                {"group_key": pk, "Jenis": "sekolah", "bobot_coverage": bobot_sek, "coverage": cov_sek},
-                {"group_key": pk, "Jenis": "khusus",  "bobot_coverage": 1.0,       "coverage": np.nan},
-                {"group_key": pk, "Jenis": "umum",    "bobot_coverage": 1.0,       "coverage": np.nan},
-            ]
+            b_sek = _bobot_or_one(cap_bobot_from_counts(n_sek, pop_sek))
 
             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
 
+            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},
+            ]
+
             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_68_%": (bobot_sek * 100),
-                "GAP_Ke_68_Sekolah": max(target_sek - n_sek, 0) if not pd.isna(target_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 "")
             })
 
@@ -545,7 +562,6 @@ def build_verif_and_weights(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
             if c.endswith("%") or c.endswith("_%"):
                 verif_df[c] = verif_df[c].fillna(0).round(0).astype(int)
             else:
-                # angka populasi/sampel/gap
                 verif_df[c] = pd.to_numeric(verif_df[c], errors="coerce").fillna(0).round(0).astype(int)
 
     return weights_df, verif_df
@@ -557,7 +573,7 @@ def build_verif_and_weights(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
 
 def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, weights_df: pd.DataFrame, kew_value: str):
     """
-    Menghasilkan:
+    Output:
     - agg_df: satu baris per wilayah×jenis
       berisi mean sub/dim, mean Indeks_Real, bobot_coverage, Indeks_Final_Agregat
     """
@@ -576,12 +592,11 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, weights_df: pd.DataFrame,
         label_col = "PROV_DISP"
         label_name = "Provinsi"
     else:
-        # default pakai kab
         key_col = "kab_key"
         label_col = "KAB_DISP"
         label_name = "Kab/Kota"
 
-    # agregat indikator di level wilayah×jenis
+    # agregat di level wilayah×jenis
     agg = df.groupby([key_col, label_col, "_dataset"], dropna=False).agg(
         Jumlah=("Indeks_Real_0_100", "size"),
         Rata2_sub_koleksi=("sub_koleksi", "mean"),
@@ -599,30 +614,46 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, weights_df: pd.DataFrame,
     if weights_df is None or weights_df.empty:
         agg["bobot_coverage"] = 1.0
         agg["coverage"] = np.nan
+        agg["target_68_n"] = np.nan
     else:
         agg = agg.merge(weights_df, on=["group_key", "Jenis"], how="left")
         agg["bobot_coverage"] = agg["bobot_coverage"].fillna(1.0)
-        # coverage boleh NaN utk khusus
         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
+    # FINAL diterapkan di agregat (bukan per entitas)
     agg["Indeks_Final_Agregat_0_100"] = agg["Indeks_Real_Agregat_0_100"] * agg["bobot_coverage"]
 
     # rounding
     for c in [
         "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
-        "Rata2_dim_kepatuhan","Rata2_dim_kinerja","Indeks_Real_Agregat_0_100","Indeks_Final_Agregat_0_100"
+        "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)
 
+    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"]:
+        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):
     """
     Detail tetap entitas, tapi Indeks_Final_0_100 = final agregat group (wilayah×jenis).
+    (jadi individu tidak pernah dihitung penalti sendiri)
     """
     if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
@@ -640,7 +671,6 @@ def attach_final_to_detail(df_filtered: pd.DataFrame, agg_df: pd.DataFrame, meta
         key_col = "kab_key"
         label_cols = ("PROV_DISP", "KAB_DISP")
 
-    # siapkan map final agregat
     if agg_df is None or agg_df.empty:
         df["Indeks_Final_0_100"] = df["Indeks_Real_0_100"]
     else:
@@ -677,9 +707,10 @@ def attach_final_to_detail(df_filtered: pd.DataFrame, agg_df: pd.DataFrame, meta
     return out
 
 
-def build_aggregate_summary_from_agg(agg_df: pd.DataFrame):
+def build_summary_per_jenis_from_agg(agg_df: pd.DataFrame):
     """
-    Ringkasan nasional per jenis menggunakan agregat wilayah (bukan entitas).
+    RINGKASAN (PER JENIS) — harus berisi sub-dimensi, dimensi, dan indeks pasca-penalty.
+    Ringkasan berbasis agregat wilayah (bukan entitas).
     """
     if agg_df is None or agg_df.empty:
         return pd.DataFrame()
@@ -687,28 +718,45 @@ def build_aggregate_summary_from_agg(agg_df: pd.DataFrame):
     grp = agg_df.groupby("Jenis", dropna=False).agg(
         Jumlah_Wilayah=("Jenis","size"),
         Total_Perpus=("Jumlah","sum"),
-        Rata2_Indeks_Real_Agregat=("Indeks_Real_Agregat_0_100","mean"),
-        Rata2_Bobot_Coverage=("bobot_coverage","mean"),
-        Rata2_Indeks_Final_Agregat=("Indeks_Final_Agregat_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)
+        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_Indeks_Real_Agregat": float(agg_df["Indeks_Real_Agregat_0_100"].mean()),
-        "Rata2_Bobot_Coverage": float(agg_df["bobot_coverage"].mean()),
-        "Rata2_Indeks_Final_Agregat": float(agg_df["Indeks_Final_Agregat_0_100"].mean()),
+
+        "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)
 
-    for c in grp.columns:
-        if c.startswith("Rata2_"):
+    # 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)
 
     return grp
 
@@ -745,8 +793,8 @@ def make_bell_figure_from_agg(agg_df: pd.DataFrame, title: str, min_points: int
                  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(),
-                     dfp["bobot_coverage"].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),
                  )]
     else:
         hover = [f"Final: {v:.2f}" for v in x]
@@ -788,21 +836,22 @@ def get_llm_client():
         _HF_CLIENT = None
         return None
 
-def build_context_from_agg(agg_summary: pd.DataFrame, agg_wilayah: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
+def build_context_from_agg(summary_jenis: pd.DataFrame, agg_wilayah: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
     lines = []
     lines.append(f"Wilayah filter: {wilayah}")
     lines.append(f"Kewenangan: {kew}")
-    lines.append(f"Catatan metode: Penalti coverage 68% diterapkan setelah indeks agregat wilayah×jenis dihitung.")
-    if agg_summary is not None and not agg_summary.empty:
-        lines.append("\nRingkasan agregat (per jenis):")
-        for _, r in agg_summary.iterrows():
+    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.")
+
+    if summary_jenis is not None and not summary_jenis.empty:
+        lines.append("\nRingkasan (per jenis) — berbasis agregat wilayah:")
+        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"Real_agregat={float(r['Rata2_Indeks_Real_Agregat']):.2f}, "
-                f"Bobot_avg={float(r['Rata2_Bobot_Coverage']):.3f}, "
-                f"Final_agregat={float(r['Rata2_Indeks_Final_Agregat']):.2f}"
+                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}"
             )
 
     if agg_wilayah is not None and not agg_wilayah.empty:
@@ -810,11 +859,14 @@ def build_context_from_agg(agg_summary: pd.DataFrame, agg_wilayah: pd.DataFrame,
         top = agg_wilayah.sort_values("Indeks_Final_Agregat_0_100", ascending=False).head(5)
         for _, r in top.iterrows():
             wl = r.get("Kab/Kota", r.get("Provinsi","(wilayah)"))
-            lines.append(f"- {wl} ({r['Jenis']}): Final={float(r['Indeks_Final_Agregat_0_100']):.2f} | Bobot={float(r['bobot_coverage']):.3f}")
+            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))}"
+            )
 
-        lines.append("\nTop 5 wilayah (GAP menuju 68% terbesar):")
+        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_68")]
+            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)
@@ -825,8 +877,8 @@ def build_context_from_agg(agg_summary: pd.DataFrame, agg_wilayah: pd.DataFrame,
 
     return "\n".join(lines)
 
-def generate_llm_analysis(agg_summary: pd.DataFrame, agg_wilayah: pd.DataFrame, verif_df: pd.DataFrame, wilayah: str, kew: str) -> str:
-    ctx = build_context_from_agg(agg_summary, agg_wilayah, verif_df, wilayah, kew)
+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)
     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."
@@ -842,14 +894,14 @@ DATA RINGKAS IPLM (PENALTI COVERAGE SETELAH AGREGAT):
 
 TULISKAN ANALISIS BAHASA INDONESIA FORMAL, STRUKTUR:
 1) Gambaran umum hasil agregat (1 paragraf).
-2) Analisis per jenis perpustakaan berdasarkan indeks agregat (2 paragraf).
-3) Analisis coverage 68% dan implikasi pada indeks final 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).
 
 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 (bukan individu).
+- Fokus pada Indeks FINAL AGREGAT (pasca penalti), bukan individu.
 """
     try:
         resp = client.chat_completion(
@@ -864,22 +916,23 @@ ATURAN:
     except Exception as e:
         return f"⚠️ Error saat memanggil LLM: {repr(e)}"
 
-def generate_word_report(detail_df: pd.DataFrame, agg_summary: pd.DataFrame, agg_wilayah: pd.DataFrame, verif_df: pd.DataFrame,
+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:
     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_heading("Ringkasan Agregat (per jenis)", level=2)
-    if agg_summary is not None and not agg_summary.empty:
-        table = doc.add_table(rows=1, cols=len(agg_summary.columns))
+    doc.add_heading("Ringkasan (per jenis) — sub-dimensi, dimensi, indeks pasca penalti", 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
-        for i, c in enumerate(agg_summary.columns):
+        for i, c in enumerate(summary_jenis.columns):
             hdr[i].text = str(c)
-        for _, row in agg_summary.iterrows():
+        for _, row in summary_jenis.iterrows():
             cells = table.add_row().cells
-            for i, c in enumerate(agg_summary.columns):
+            for i, c in enumerate(summary_jenis.columns):
                 cells[i].text = str(row[c])
     else:
         doc.add_paragraph("Ringkasan agregat tidak tersedia.")
@@ -887,7 +940,6 @@ def generate_word_report(detail_df: pd.DataFrame, agg_summary: pd.DataFrame, agg
     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()
-        # batasi agar docx tidak terlalu berat
         show = show.sort_values("Indeks_Final_Agregat_0_100", ascending=False).head(200)
 
         table = doc.add_table(rows=1, cols=len(show.columns))
@@ -901,7 +953,7 @@ def generate_word_report(detail_df: pd.DataFrame, agg_summary: pd.DataFrame, agg
     else:
         doc.add_paragraph("Agregat wilayah tidak tersedia.")
 
-    doc.add_heading("Verifikasi Coverage & GAP menuju 68%", level=2)
+    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))
         hdr = table.rows[0].cells
@@ -914,7 +966,7 @@ def generate_word_report(detail_df: pd.DataFrame, agg_summary: pd.DataFrame, agg
     else:
         doc.add_paragraph("Tidak ada tabel verifikasi untuk filter ini.")
 
-    doc.add_heading("Detail Entitas (menempel pada Final Agregat group)", level=2)
+    doc.add_heading("Detail Entitas (Indeks Final menempel pada agregat wilayah×jenis)", level=2)
     if detail_df is not None and not detail_df.empty:
         show = detail_df.copy().head(200)
         table = doc.add_table(rows=1, cols=len(show.columns))
@@ -955,7 +1007,7 @@ def _empty_outputs(msg="⚠️ Data belum siap."):
 def run_calc(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, meta):
     try:
         if df_all is None or df_all.empty:
-            return _empty_outputs("⚠️ Data belum ter-load. Klik Reload Data.")
+            return _empty_outputs("⚠️ Data belum ter-load. Pastikan file tersedia di repo/server.")
 
         df = df_all.copy()
 
@@ -970,36 +1022,44 @@ 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)
+        # coverage & weights (AGREGAT)
         weights_df, verif_df = build_verif_and_weights(df, pop_kab, pop_prov, kew_value or "(Semua)")
 
-        # agregat wilayah×jenis + final
+        # agregat wilayah×jenis + final (penalti setelah agregat)
         agg_wilayah = build_agg_wilayah_jenis(df, weights_df, kew_value or "(Semua)")
 
-        # ringkasan per jenis
-        agg_summary = build_aggregate_summary_from_agg(agg_wilayah)
+        # ringkasan per jenis (sub/dim + indeks pasca penalti)
+        summary_jenis = build_summary_per_jenis_from_agg(agg_wilayah)
 
-        # detail entitas menempel final agregat group
+        # detail entitas: final menempel pada agregat group
         detail_view = attach_final_to_detail(df, agg_wilayah, meta, kew_value or "(Semua)")
 
         # bell curve berbasis agregat wilayah
-        # tentukan label field wilayah
         label_field = "Kab/Kota" if "Kab/Kota" in agg_wilayah.columns else ("Provinsi" if "Provinsi" in agg_wilayah.columns else "Wilayah")
 
-        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_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"
+            "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"
+            "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"
+            "Bell Curve Final Agregat — Khusus",
+            min_points=3,
+            label_field="Wilayah"
         )
 
         # output files
@@ -1008,23 +1068,27 @@ 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_Summary_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        wilayah_path = str(Path(tmpdir) / f"IPLM_Agregat_Wilayah_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        detail_path  = str(Path(tmpdir) / f"IPLM_Detail_Entitas_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
+        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")
 
-        agg_summary.to_excel(summary_path, index=False)
+        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)
 
         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(agg_summary, agg_wilayah, verif_df, wilayah_txt, kew_value or "(Semua)")
-        word_path = generate_word_report(detail_view, agg_summary, agg_wilayah, verif_df, wilayah_txt, kew_value or "(Semua)", analysis_text)
+        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)
+
+        msg = (
+            f"✅ Selesai: entitas={len(detail_view)} | agregat_wilayah×jenis={len(agg_wilayah)} | "
+            f"penalti diterapkan setelah agregat (individu tidak dipenalti)"
+        )
 
-        msg = f"✅ Selesai: entitas={len(detail_view)} | agregat_wilayah×jenis={len(agg_wilayah)} | penalti diterapkan setelah agregat"
         return (
-            agg_summary, agg_wilayah, detail_view, verif_df,
+            summary_jenis, agg_wilayah, detail_view, verif_df,
             summary_path, wilayah_path, detail_path, word_path,
             fig_all, fig_sek, fig_um, fig_kh,
             msg, analysis_text
@@ -1035,7 +1099,7 @@ def run_calc(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, meta):
 
 
 # ============================================================
-# 11) UI (NO UPLOAD) + Dropdown aman
+# 11) UI (NO UPLOAD) — TANPA TOMBOL RELOAD
 # ============================================================
 
 def ui_load(force=False):
@@ -1080,7 +1144,10 @@ with gr.Blocks() as demo:
 - `POP_KAB`   = **{POP_KAB}**
 - `POP_PROV`  = **{POP_PROV}**
 
-**Metode penalti:** hitung indeks real per entitas → agregasi wilayah×jenis → terapkan bobot coverage 68% di agregat.
+**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).
 """)
 
     state_df = gr.State(None)
@@ -1088,9 +1155,7 @@ with gr.Blocks() as demo:
     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()
+    info_box = gr.Markdown()
 
     with gr.Row():
         dd_prov = gr.Dropdown(label="Provinsi", choices=["(Semua)"], value="(Semua)")
@@ -1102,16 +1167,16 @@ with gr.Blocks() as demo:
     run_btn = gr.Button("Jalankan Perhitungan")
     msg_out = gr.Markdown()
 
-    gr.Markdown("## Ringkasan (per Jenis) — berbasis agregat wilayah")
+    gr.Markdown("## Ringkasan (per Jenis) — sub-dimensi, dimensi, indeks pasca penalti (berbasis agregat wilayah)")
     out_summary = gr.DataFrame(interactive=False)
 
     gr.Markdown("## Agregat Wilayah × Jenis (Final setelah penalti)")
     out_agg_wilayah = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Detail Entitas (Final menempel pada agregat wilayah×jenis)")
+    gr.Markdown("## Detail Entitas (Indeks Final menempel pada agregat wilayah×jenis; individu tidak dipenalti)")
     out_detail = gr.DataFrame(interactive=False)
 
-    gr.Markdown("## Verifikasi Coverage & GAP menuju 68% (tanpa angka koma)")
+    gr.Markdown("## Verifikasi Coverage & GAP menuju target 68% (tanpa angka koma)")
     out_verif = gr.DataFrame(interactive=False)
 
     gr.Markdown("## Bell Curve Final Agregat — Semua Jenis")
@@ -1127,8 +1192,8 @@ with gr.Blocks() as demo:
     analysis_out = gr.Markdown()
 
     with gr.Row():
-        dl_summary = gr.DownloadButton(label="Download Summary (.xlsx)")
-        dl_wilayah = gr.DownloadButton(label="Download Agregat Wilayah (.xlsx)")
+        dl_summary = gr.DownloadButton(label="Download Ringkasan Jenis (.xlsx)")
+        dl_wilayah = gr.DownloadButton(label="Download Agregat Wilayah×Jenis (.xlsx)")
         dl_detail  = gr.DownloadButton(label="Download Detail Entitas (.xlsx)")
         dl_word    = gr.DownloadButton(label="Download Laporan Word (.docx)")
 
@@ -1149,10 +1214,4 @@ with gr.Blocks() as demo:
         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()