Update app.py

app.py

@@ -1,23 +1,27 @@
 # -*- coding: utf-8 -*-
 """
 IPLM 2025 — Final (Target Sampel 33.88% per Jenis) — TANPA Kinerja Relatif / Percentile
-FULL REWRITE (plain code) + INSIGHT ENGINE:
-✅ Deteksi — Diagnosa — Preskripsi — Prediksi (tahun depan) berbasis output pipeline yang sudah ada
-✅ Tidak mengubah pipeline inti perhitungan indeks (tetap Yeo-Johnson + MinMax, bobot 0.30/0.70, faktor 33.88%)
-✅ Menambahkan:
-   1) Perhitungan metrik deteksi (gap dimensi, gap internal, ketergantungan jenis, risiko coverage)
-   2) Diagnosa bottleneck berbasis pola angka (tanpa label normatif)
-   3) Preskripsi operasional 2–3 butir (diturunkan dari bottleneck & gap)
-   4) Prediksi tahun depan:
-      - Baseline (point + interval heuristik)
-      - Scenario-based (3 skenario intervensi, dampak pada indeks)
-✅ Export Insight Pack:
-   - Excel sheet tambahan: INSIGHT_WILAYAH, INSIGHT_JENIS, PREDIKSI
-   - Word: Tambahan bagian "Insight Pack" (jika python-docx tersedia)
-
-CATATAN:
-- Kode ini ditulis tanpa dijalankan di mesin ini.
-- Anda tinggal tempel sebagai app.py (HF Spaces / lokal).
+UPDATE (sesuai instruksi terbaru Anda) — TANPA mengubah pipeline lain:
+
+FOKUS PEMBENAHAN (LLM + WORD):
+1) Nilai Kepatuhan, Koleksi, Tenaga, Kinerja, Pelayanan, Pengelolaan:
+   - TIDAK dikalikan 100.
+   - Ditulis APA ADANYA dari kolom agregat aplikasi:
+     Rata2_dim_kepatuhan, Rata2_sub_koleksi, Rata2_sub_sdm, Rata2_dim_kinerja,
+     Rata2_sub_pelayanan, Rata2_sub_pengelolaan.
+2) Nilai IPLM ditulis apa adanya: Indeks_Final_Wilayah_0_100.
+3) LLM mengisi Interpretasi & Rekomendasi:
+   - Interpretasi: deskriptif, kondisi riil berbasis relasi angka (lebih besar/kecil, gap, dominan, konsistensi),
+     plus pemaknaan substantif dimensi (koleksi/sdm/pelayanan/pengelolaan) TANPA label normatif.
+   - Rekomendasi: operasional, 2–3 butir ringkas, menaut ke pola angka (gap/ketimpangan/kontribusi).
+4) Di bawah tabel Word: tambah deskripsi jumlah perpustakaan sumber data (dari tabel agregat wilayah × jenis / “gambar 2”):
+   sekolah=..., umum=..., khusus=..., total=...
+
+Catatan penting:
+- Semua perhitungan dan dashboard tetap.
+- Yang diubah hanya: (a) cara mengambil nilai untuk tabel Word (tanpa *100),
+  (b) prompt LLM untuk isi interpretasi/rekomendasi agar nyambung dengan angka,
+  (c) tambahan paragraf jumlah perpustakaan di bawah tabel Word.
 """
 
 import os
@@ -27,7 +31,6 @@ import json
 import math
 import tempfile
 from pathlib import Path
-from datetime import datetime
 
 import gradio as gr
 import numpy as np
@@ -35,7 +38,7 @@ import pandas as pd
 import plotly.graph_objects as go
 from sklearn.preprocessing import PowerTransformer
 
-# python-docx (opsional untuk Word)
+# python-docx (wajib kalau mau Word)
 DOCX_AVAILABLE = True
 try:
     from docx import Document
@@ -46,7 +49,7 @@ except Exception:
     DOCX_AVAILABLE = False
     Document = None
 
-# huggingface client (opsional, untuk isi narasi)
+# huggingface client (opsional)
 HF_AVAILABLE = True
 try:
     from huggingface_hub import InferenceClient
@@ -78,13 +81,6 @@ HF_TOKEN = (
     or os.getenv("HF_API_TOKEN")
 )
 
-# Prediksi heuristik (bisa di-tuning)
-PRED_BASE_DRIFT_DEFAULT = float(os.getenv("PRED_BASE_DRIFT_DEFAULT", "0.0"))  # drift baseline default (0 = konservatif)
-PRED_INTERVAL_MIN = float(os.getenv("PRED_INTERVAL_MIN", "0.75"))            # minimal half-width interval
-PRED_INTERVAL_MAX = float(os.getenv("PRED_INTERVAL_MAX", "4.00"))            # maksimal half-width interval
-PRED_SCENARIO_DELTA_SUB_MIN = float(os.getenv("PRED_SCENARIO_DELTA_SUB_MIN", "0.03"))
-PRED_SCENARIO_DELTA_SUB_MAX = float(os.getenv("PRED_SCENARIO_DELTA_SUB_MAX", "0.07"))
-
 
 # ============================================================
 # 2) UTIL
@@ -209,22 +205,6 @@ def faktor_penyesuaian_total(n_total: float, target_total: float) -> float:
         n_total = 0.0
     return float(min(float(n_total) / float(target_total), 1.0))
 
-def _to_float(x, default=0.0):
-    try:
-        if x is None:
-            return float(default)
-        if isinstance(x, float) and math.isnan(x):
-            return float(default)
-        return float(x)
-    except Exception:
-        return float(default)
-
-def _clamp(x, lo, hi):
-    try:
-        return max(lo, min(hi, float(x)))
-    except Exception:
-        return lo
-
 
 # ============================================================
 # 3) INDIKATOR IPLM
@@ -303,7 +283,6 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
 
     df = df_src.copy()
 
-    # rename indicator columns
     rename_map = {}
     for col in df.columns:
         c = _canon(col)
@@ -317,12 +296,10 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
     if rename_map:
         df = df.rename(columns=rename_map)
 
-    # coerce numeric for available indicators
     available = [c for c in all_indicators if c in df.columns]
     for c in available:
         df[c] = df[c].apply(coerce_num)
 
-    # Yeo-Johnson transform then MinMax
     for c in available:
         x = pd.to_numeric(df[c], errors="coerce").astype(float).values
         mask = ~np.isnan(x)
@@ -334,17 +311,14 @@ def prepare_global(df_src: pd.DataFrame) -> pd.DataFrame:
             transformed[mask] = x[mask]
         df[f"norm_{c}"] = minmax_norm(pd.Series(transformed, index=df.index))
 
-    # sub dimensions
     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)
 
-    # dimensions
     df["dim_kepatuhan"] = df[["sub_koleksi","sub_sdm"]].mean(axis=1)
     df["dim_kinerja"]   = df[["sub_pelayanan","sub_pengelolaan"]].mean(axis=1)
 
-    # base index 0–100
     df["Indeks_Dasar_0_100"] = 100 * (W_KEPATUHAN * df["dim_kepatuhan"] + W_KINERJA * df["dim_kinerja"])
 
     for c in ["sub_koleksi","sub_sdm","sub_pelayanan","sub_pengelolaan","dim_kepatuhan","dim_kinerja","Indeks_Dasar_0_100"]:
@@ -463,7 +437,6 @@ def load_default_files(force=False):
     df_raw["prov_key"]  = df_raw["PROV_DISP"].apply(norm_prov_label)
     df_raw["kab_key"]   = df_raw["KAB_DISP"].apply(norm_kab_label)
 
-    # Dedup row key
     if nama_col and nama_col in df_raw.columns:
         kcols = [prov_col, kab_col, kew_col, jenis_col, nama_col]
     else:
@@ -711,11 +684,6 @@ def build_agg_wilayah_jenis(df_filtered, faktor_wilayah_jenis, kew_value):
 
     if faktor_wilayah_jenis is None or faktor_wilayah_jenis.empty:
         agg["faktor_penyesuaian_jenis"] = 1.0
-        agg["target_total_33_88_jenis"] = 0
-        agg["pop_total_jenis"] = 0
-        agg["coverage_jenis_%"] = 0.0
-        agg["gap_target33_88_jenis"] = 0
-        agg["n_jenis"] = agg["Jumlah"].copy()
     else:
         fw = faktor_wilayah_jenis.copy()
         fw["Jenis"] = fw["Jenis"].astype(str).str.lower().str.strip()
@@ -737,7 +705,6 @@ def build_agg_wilayah_jenis(df_filtered, faktor_wilayah_jenis, kew_value):
     ]:
         if c in agg.columns:
             agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0).round(3)
-
     for c in ["Indeks_Dasar_Agregat_0_100","Indeks_Final_Agregat_0_100"]:
         if c in agg.columns:
             agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0).round(2)
@@ -750,7 +717,7 @@ def build_agg_wilayah_jenis(df_filtered, faktor_wilayah_jenis, kew_value):
 # 8) AGREGAT WILAYAH (KESELURUHAN) — avg3 dari 3 jenis
 # ============================================================
 
-def build_agg_wilayah_total_from_jenis(agg_jenis, kew_value):
+def build_agg_wilayah_total_from_jenis(agg_jenis, faktor_wilayah_jenis, kew_value):
     if agg_jenis is None or agg_jenis.empty:
         return pd.DataFrame()
 
@@ -774,7 +741,6 @@ def build_agg_wilayah_total_from_jenis(agg_jenis, kew_value):
 
     full = full.merge(a[["group_key", label_name, "Jenis"] + cols_present],
                       on=["group_key", label_name, "Jenis"], how="left")
-
     for c in cols_present:
         full[c] = pd.to_numeric(full[c], errors="coerce").fillna(0.0)
 
@@ -975,6 +941,7 @@ def build_verif_jenis(faktor_wilayah_jenis, kew_value):
         "pop_total_jenis", "target_total_33_88_jenis", "n_jenis",
         "coverage_jenis_%", "faktor_penyesuaian_jenis", "gap_target33_88_jenis"
     ] if c in out.columns]
+
     out = out[keep].copy()
 
     for c in ["pop_total_jenis", "target_total_33_88_jenis", "n_jenis", "gap_target33_88_jenis"]:
@@ -1144,22 +1111,60 @@ def get_llm_client():
         _HF_CLIENT = None
         return None
 
-def summarize_jumlah_perpus_dari_agg_jenis(agg_jenis_full):
-    if agg_jenis_full is None or agg_jenis_full.empty or "Jenis" not in agg_jenis_full.columns:
+def _to_float(x, default=0.0):
+    try:
+        if x is None:
+            return float(default)
+        if isinstance(x, float) and math.isnan(x):
+            return float(default)
+        return float(x)
+    except Exception:
+        return float(default)
+
+def summarize_jumlah_perpus_dari_agg_jenis(agg_jenis_full, wilayah_label, kew_value):
+    """
+    Ambil jumlah perpustakaan sumber data dari tabel agregat wilayah × jenis (gambar 2).
+    Untuk filter 1 wilayah (kab/prov), agg_jenis_full biasanya 3 baris (sekolah/umum/khusus).
+    Untuk nasional/semua wilayah, ini akan menjumlahkan seluruh wilayah per jenis.
+    """
+    if agg_jenis_full is None or agg_jenis_full.empty:
         return {"sekolah": 0, "umum": 0, "khusus": 0, "total": 0}
+
     a = agg_jenis_full.copy()
+    if "Jenis" not in a.columns:
+        return {"sekolah": 0, "umum": 0, "khusus": 0, "total": 0}
+
     a["Jenis"] = a["Jenis"].astype(str).str.lower().str.strip()
     if "Jumlah" in a.columns:
         a["Jumlah"] = pd.to_numeric(a["Jumlah"], errors="coerce").fillna(0).astype(int)
     else:
         a["Jumlah"] = 0
-    out = {j: int(a.loc[a["Jenis"].eq(j), "Jumlah"].sum()) for j in ["sekolah", "umum", "khusus"]}
+
+    out = {}
+    for j in ["sekolah", "umum", "khusus"]:
+        out[j] = int(a.loc[a["Jenis"].eq(j), "Jumlah"].sum())
     out["total"] = int(out["sekolah"] + out["umum"] + out["khusus"])
     return out
 
 def build_interpretasi_table_values(agg_total, wilayah_label, target_ratio):
+    """
+    MENGAMBIL NILAI APA ADANYA (tanpa *100) dari hasil aplikasi (agg_total):
+    - Kepatuhan = Rata2_dim_kepatuhan
+    - Koleksi   = Rata2_sub_koleksi
+    - Tenaga    = Rata2_sub_sdm
+    - Kinerja   = Rata2_dim_kinerja
+    - Pelayanan = Rata2_sub_pelayanan
+    - Pengelolaan = Rata2_sub_pengelolaan
+    - Nilai IPLM = Indeks_Final_Wilayah_0_100
+
+    Jika agg_total > 1 baris (mis. nasional), diambil mean kolom-kolom tersebut.
+    """
     if agg_total is None or agg_total.empty:
-        base = {"kepatuhan": 0.0, "koleksi": 0.0, "tenaga": 0.0, "kinerja": 0.0, "pelayanan": 0.0, "pengelolaan": 0.0, "iplm": 0.0}
+        base = {
+            "kepatuhan": 0.0, "koleksi": 0.0, "tenaga": 0.0,
+            "kinerja": 0.0, "pelayanan": 0.0, "pengelolaan": 0.0,
+            "iplm": 0.0
+        }
     else:
         a = agg_total.copy()
         cols_needed = [
@@ -1176,6 +1181,7 @@ def build_interpretasi_table_values(agg_total, wilayah_label, target_ratio):
                 a[c] = pd.to_numeric(a[c], errors="coerce").fillna(0.0)
             else:
                 a[c] = 0.0
+
         base = {
             "kepatuhan": float(a["Rata2_dim_kepatuhan"].mean()),
             "koleksi": float(a["Rata2_sub_koleksi"].mean()),
@@ -1186,6 +1192,8 @@ def build_interpretasi_table_values(agg_total, wilayah_label, target_ratio):
             "iplm": float(a["Indeks_Final_Wilayah_0_100"].mean()),
         }
 
+    # pembulatan display (nilai tetap "apa adanya", hanya format)
+    # untuk sub/dim (0–1) biasanya 3 desimal; untuk IPLM (0–100) 2 desimal.
     base_disp = {
         "kepatuhan": round(_to_float(base["kepatuhan"]), 3),
         "koleksi": round(_to_float(base["koleksi"]), 3),
@@ -1213,6 +1221,14 @@ def build_interpretasi_table_values(agg_total, wilayah_label, target_ratio):
     return header, rows
 
 def llm_fill_interpretasi_rekomendasi(header, rows, wilayah_label, kew_label, jumlah_perpus_by_jenis):
+    """
+    LLM diminta mengisi kolom Interpretasi dan Rekomendasi dengan narasi yang NYAMBUNG ke angka:
+    - Interpretasi: jelaskan apa arti angka untuk kondisi operasional perpustakaan (koleksi/sdm/pelayanan/pengelolaan),
+      memakai relasi angka antardimensi (lebih besar/kecil, selisih, dominan, gap, konsistensi) TANPA label normatif.
+    - Rekomendasi: 2–3 aksi teknis per baris yang langsung meng-address pola angka (misal dimensi lebih kecil → prioritas aktivitas),
+      serta mengaitkan dengan volume data (jumlah perpustakaan per jenis) bila relevan.
+    Output wajib JSON.
+    """
     client = get_llm_client()
     if client is None or (not USE_LLM):
         out = []
@@ -1227,7 +1243,8 @@ def llm_fill_interpretasi_rekomendasi(header, rows, wilayah_label, kew_label, ju
         "jumlah_perpustakaan_sumber_data": jumlah_perpus_by_jenis,
         "catatan_skala": (
             "Baris Kepatuhan/Koleksi/Tenaga/Kinerja/Pelayanan/Pengelolaan memakai nilai agregat 'apa adanya' "
-            "(umumnya rentang 0–1). Baris 'Nilai IPLM' memakai Indeks_Final_Wilayah_0_100 (0–100)."
+            "(umumnya rentang 0–1 karena berasal dari sub/dim hasil normalisasi). "
+            "Baris 'Nilai IPLM' memakai Indeks_Final_Wilayah_0_100 (rentang 0–100)."
         ),
         "baris": rows
     }
@@ -1236,12 +1253,18 @@ def llm_fill_interpretasi_rekomendasi(header, rows, wilayah_label, kew_label, ju
         "Anda adalah analis kebijakan perpustakaan di Indonesia.\n"
         "Tugas: isi kolom Interpretasi dan Rekomendasi untuk setiap baris tabel.\n"
         "ATURAN WAJIB:\n"
-        "1) Jangan mengubah nilai angka.\n"
-        "2) Netral-deskriptif: dilarang memakai label normatif seperti baik/buruk, tinggi/sedang/rendah, memuaskan/kurang.\n"
-        "3) Interpretasi harus nyambung langsung ke angka dan relasinya antardimensi: lebih besar/kecil, selisih, gap, dominan, konsisten.\n"
-        "4) Jelaskan pemaknaan substantif dimensi (koleksi/sdm/pelayanan/pengelolaan) tanpa menghakimi.\n"
-        "5) Rekomendasi operasional 2–3 butir per baris, menaut ke pola angka.\n"
-        "6) Output HARUS JSON valid saja.\n"
+        "1) Jangan mengubah nilai angka. Jangan menghitung ulang skor.\n"
+        "2) Netral-deskriptif: dilarang memakai label normatif seperti baik/buruk, tinggi/sedang/rendah, memuaskan/kurang, optimal/tidak optimal.\n"
+        "3) Interpretasi harus nyambung langsung ke angka dan relasinya antardimensi: gunakan istilah lebih besar/kecil, selisih, gap, dominan, konsisten/tidak konsisten, kontribusi, proporsi.\n"
+        "4) Interpretasi juga harus menjelaskan kondisi riil berbasis dimensi:\n"
+        "   - Koleksi: pengembangan, ketersediaan, pemanfaatan koleksi (sebagai fungsi layanan),\n"
+        "   - Tenaga: kecukupan/kapasitas SDM dan pengembangan kompetensi,\n"
+        "   - Pelayanan: aktivitas layanan dan pemanfaatan layanan,\n"
+        "   - Pengelolaan: tata kelola, kebijakan, kolaborasi, dukungan anggaran layanan,\n"
+        "   - Kepatuhan = gabungan koleksi+tenaga; Kinerja = gabungan pelayanan+pengelolaan.\n"
+        "   Jelaskan tanpa menghakimi; fokus pada apa yang angka itu representasikan.\n"
+        "5) Rekomendasi harus operasional dan spesifik (2–3 butir singkat) untuk tiap baris. Gunakan pola angka untuk menurunkan aksi.\n"
+        "6) Output HARUS JSON valid saja (tanpa teks tambahan), dengan struktur persis.\n"
     )
 
     user = (
@@ -1252,14 +1275,17 @@ def llm_fill_interpretasi_rekomendasi(header, rows, wilayah_label, kew_label, ju
         "  ]\n"
         "}\n"
         "- Urutan dan jumlah baris harus sama.\n"
-        "- 'Rekomendasi' boleh bullet '-' dalam satu string.\n\n"
+        "- 'Rekomendasi' boleh berupa bullet dengan tanda '-' dalam satu string.\n\n"
         f"INPUT:\n{json.dumps(payload, ensure_ascii=False)}"
     )
 
     try:
         resp = client.chat_completion(
             model=LLM_MODEL_NAME,
-            messages=[{"role": "system", "content": system}, {"role": "user", "content": user}],
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
             max_tokens=1100,
             temperature=0.2,
             top_p=0.9,
@@ -1274,7 +1300,7 @@ def llm_fill_interpretasi_rekomendasi(header, rows, wilayah_label, kew_label, ju
             cleaned.append({
                 "No": str(r.get("No", rows[i]["No"])),
                 "Dimensi": str(r.get("Dimensi", rows[i]["Dimensi"])),
-                "Nilai": rows[i]["Nilai"],
+                "Nilai": rows[i]["Nilai"],  # paksa nilai dari aplikasi
                 "Interpretasi": str(r.get("Interpretasi","") or ""),
                 "Rekomendasi": str(r.get("Rekomendasi","") or ""),
             })
@@ -1285,6 +1311,7 @@ def llm_fill_interpretasi_rekomendasi(header, rows, wilayah_label, kew_label, ju
             out.append({k: r.get(k) for k in ["No","Dimensi","Nilai"]} | {"Interpretasi":"", "Rekomendasi":""})
         return out, f"LLM error: {repr(e)}"
 
+
 def _set_cell_shading(cell, fill_hex="1F1F1F"):
     tcPr = cell._tc.get_or_add_tcPr()
     shd = OxmlElement("w:shd")
@@ -1317,7 +1344,7 @@ def _set_table_borders(table):
         tblBorders.append(elem)
     tblPr.append(tblBorders)
 
-def generate_word_table_interpretasi(header, rows_filled, wilayah_label, jumlah_perpus_by_jenis, insight_pack=None):
+def generate_word_table_interpretasi(header, rows_filled, wilayah_label, jumlah_perpus_by_jenis):
     if (not DOCX_AVAILABLE) or (Document is None):
         return None
 
@@ -1350,6 +1377,10 @@ def generate_word_table_interpretasi(header, rows_filled, wilayah_label, jumlah_
         row_cells = table.add_row().cells
         row_cells[0].text = str(r.get("No",""))
         row_cells[1].text = str(r.get("Dimensi",""))
+
+        # format nilai:
+        # - sub/dim biasanya 0–1 → tampilkan 3 desimal
+        # - IPLM 0–100 → tampilkan 2 desimal
         try:
             dim = str(r.get("Dimensi","")).strip().lower()
             val = _to_float(r.get("Nilai", 0.0), 0.0)
@@ -1359,6 +1390,7 @@ def generate_word_table_interpretasi(header, rows_filled, wilayah_label, jumlah_
                 row_cells[2].text = f"{val:.3f}"
         except Exception:
             row_cells[2].text = str(r.get("Nilai",""))
+
         row_cells[3].text = str(r.get("Interpretasi","") or "")
         row_cells[4].text = str(r.get("Rekomendasi","") or "")
 
@@ -1366,8 +1398,8 @@ def generate_word_table_interpretasi(header, rows_filled, wilayah_label, jumlah_
             _set_cell_shading(c, "262626")
             _set_cell_text_color(c, "FFFFFF")
 
-    # Deskripsi jumlah perpus sumber data
-    doc.add_paragraph("")
+    # ===== tambahan: deskripsi jumlah perpustakaan sumber data (gambar 2) =====
+    doc.add_paragraph("")  # spacer
     j = jumlah_perpus_by_jenis or {"sekolah":0,"umum":0,"khusus":0,"total":0}
     p = doc.add_paragraph()
     p.add_run("Sumber data (jumlah perpustakaan pada tabel agregat wilayah × jenis): ").bold = True
@@ -1378,419 +1410,13 @@ def generate_word_table_interpretasi(header, rows_filled, wilayah_label, jumlah_
         f"total = {int(j.get('total',0))}."
     )
 
-    # Insight Pack tambahan
-    if insight_pack is not None and isinstance(insight_pack, dict) and insight_pack:
-        doc.add_paragraph("")
-        h = doc.add_paragraph()
-        rr = h.add_run("Insight Pack (Deteksi–Diagnosa–Preskripsi–Prediksi)")
-        rr.bold = True
-        rr.font.size = Pt(14)
-
-        # Deteksi
-        det = insight_pack.get("deteksi", {})
-        if det:
-            doc.add_paragraph("Deteksi", style=None)
-            for k, v in det.items():
-                doc.add_paragraph(f"- {k}: {v}")
-
-        # Diagnosa
-        diag = insight_pack.get("diagnosa", {})
-        if diag:
-            doc.add_paragraph("Diagnosa", style=None)
-            for k, v in diag.items():
-                doc.add_paragraph(f"- {k}: {v}")
-
-        # Preskripsi
-        pres = insight_pack.get("preskripsi", [])
-        if pres:
-            doc.add_paragraph("Preskripsi", style=None)
-            for it in pres:
-                doc.add_paragraph(f"- {it}")
-
-        # Prediksi
-        pred = insight_pack.get("prediksi", {})
-        if pred:
-            doc.add_paragraph("Prediksi (Tahun Depan)", style=None)
-            for k, v in pred.items():
-                doc.add_paragraph(f"- {k}: {v}")
-
     outpath = tempfile.mktemp(suffix=".docx")
     doc.save(outpath)
     return outpath
 
 
 # ============================================================
-# 15) INSIGHT ENGINE (Deteksi–Diagnosa–Preskripsi–Prediksi)
-# ============================================================
-
-def _fmt3(x):
-    try:
-        return f"{float(x):.3f}"
-    except Exception:
-        return "NA"
-
-def _fmt2(x):
-    try:
-        return f"{float(x):.2f}"
-    except Exception:
-        return "NA"
-
-def compute_coverage_risk(verif_total: pd.DataFrame) -> dict:
-    """
-    Ringkas risiko coverage:
-    - coverage_min / coverage_mean (3 jenis)
-    - gap_target_sum
-    - faktor_penyesuaian_mean
-    """
-    if verif_total is None or verif_total.empty:
-        return {
-            "coverage_min": 0.0,
-            "coverage_mean": 0.0,
-            "gap_target_sum": 0,
-            "faktor_mean": 1.0,
-        }
-
-    v = verif_total.copy()
-    v["Jenis"] = v.get("Jenis", "").astype(str).str.lower().str.strip()
-    v = v[v["Jenis"].isin(["sekolah","umum","khusus"])].copy()
-
-    cov = pd.to_numeric(v.get("coverage_jenis_%", 0.0), errors="coerce").fillna(0.0)
-    gap = pd.to_numeric(v.get("gap_target33_88_jenis", 0), errors="coerce").fillna(0).astype(int)
-    fct = pd.to_numeric(v.get("faktor_penyesuaian_jenis", 1.0), errors="coerce").fillna(1.0)
-
-    return {
-        "coverage_min": float(cov.min()) if len(cov) else 0.0,
-        "coverage_mean": float(cov.mean()) if len(cov) else 0.0,
-        "gap_target_sum": int(gap.sum()) if len(gap) else 0,
-        "faktor_mean": float(fct.mean()) if len(fct) else 1.0,
-    }
-
-def detect_signals_from_agg_total(agg_total: pd.DataFrame) -> dict:
-    """
-    Deteksi sinyal dimensi dari agg_total:
-    - gap_dim (kinerja - kepatuhan)
-    - gap internal kepatuhan (koleksi - sdm)
-    - gap internal kinerja (pelayanan - pengelolaan)
-    """
-    if agg_total is None or agg_total.empty:
-        return {
-            "kepatuhan": 0.0, "kinerja": 0.0,
-            "koleksi": 0.0, "sdm": 0.0,
-            "pelayanan": 0.0, "pengelolaan": 0.0,
-            "gap_dim": 0.0,
-            "gap_koleksi_sdm": 0.0,
-            "gap_pelayanan_pengelolaan": 0.0,
-            "iplm_final": 0.0,
-            "n_total": 0,
-        }
-
-    a = agg_total.copy()
-
-    def _col_mean(name, default=0.0):
-        if name not in a.columns:
-            return float(default)
-        return float(pd.to_numeric(a[name], errors="coerce").fillna(default).mean())
-
-    kepatuhan = _col_mean("Rata2_dim_kepatuhan", 0.0)
-    kinerja = _col_mean("Rata2_dim_kinerja", 0.0)
-    koleksi = _col_mean("Rata2_sub_koleksi", 0.0)
-    sdm = _col_mean("Rata2_sub_sdm", 0.0)
-    pelayanan = _col_mean("Rata2_sub_pelayanan", 0.0)
-    pengelolaan = _col_mean("Rata2_sub_pengelolaan", 0.0)
-    iplm = _col_mean("Indeks_Final_Wilayah_0_100", 0.0)
-    n_total = int(pd.to_numeric(a.get("n_total", 0), errors="coerce").fillna(0).sum()) if "n_total" in a.columns else int(0)
-
-    return {
-        "kepatuhan": float(kepatuhan),
-        "kinerja": float(kinerja),
-        "koleksi": float(koleksi),
-        "sdm": float(sdm),
-        "pelayanan": float(pelayanan),
-        "pengelolaan": float(pengelolaan),
-        "gap_dim": float(kinerja - kepatuhan),
-        "gap_koleksi_sdm": float(koleksi - sdm),
-        "gap_pelayanan_pengelolaan": float(pelayanan - pengelolaan),
-        "iplm_final": float(iplm),
-        "n_total": n_total,
-    }
-
-def detect_dependency_by_jenis(agg_jenis_full: pd.DataFrame) -> dict:
-    """
-    Deteksi ketergantungan jenis:
-    - kontribusi jenis mana lebih dominan berdasar Indeks_Final_Agregat_0_100 dan jumlah entitas (Jumlah)
-    """
-    if agg_jenis_full is None or agg_jenis_full.empty:
-        return {
-            "dominant_jenis_by_final": None,
-            "final_by_jenis": {"sekolah": 0.0, "umum": 0.0, "khusus": 0.0},
-            "jumlah_by_jenis": {"sekolah": 0, "umum": 0, "khusus": 0},
-        }
-
-    a = agg_jenis_full.copy()
-    a["Jenis"] = a.get("Jenis", "").astype(str).str.lower().str.strip()
-    a = a[a["Jenis"].isin(["sekolah","umum","khusus"])].copy()
-
-    def _mean_by(j, col, default=0.0):
-        sub = a[a["Jenis"].eq(j)].copy()
-        if sub.empty or col not in sub.columns:
-            return float(default)
-        return float(pd.to_numeric(sub[col], errors="coerce").fillna(default).mean())
-
-    def _sum_by(j, col, default=0):
-        sub = a[a["Jenis"].eq(j)].copy()
-        if sub.empty or col not in sub.columns:
-            return int(default)
-        return int(pd.to_numeric(sub[col], errors="coerce").fillna(0).sum())
-
-    final_by = {j: _mean_by(j, "Indeks_Final_Agregat_0_100", 0.0) for j in ["sekolah","umum","khusus"]}
-    jumlah_by = {j: _sum_by(j, "Jumlah", 0) for j in ["sekolah","umum","khusus"]}
-
-    dominant = max(final_by.keys(), key=lambda k: final_by[k]) if final_by else None
-
-    return {
-        "dominant_jenis_by_final": dominant,
-        "final_by_jenis": final_by,
-        "jumlah_by_jenis": jumlah_by,
-    }
-
-def diagnose_bottleneck(signals: dict) -> dict:
-    """
-    Diagnosa bottleneck berbasis nilai sub/dim terendah & gap internal.
-    Output: bottleneck utama + alasan berbasis relasi angka.
-    """
-    koleksi = float(signals.get("koleksi", 0.0))
-    sdm = float(signals.get("sdm", 0.0))
-    pelayanan = float(signals.get("pelayanan", 0.0))
-    pengelolaan = float(signals.get("pengelolaan", 0.0))
-    kepatuhan = float(signals.get("kepatuhan", 0.0))
-    kinerja = float(signals.get("kinerja", 0.0))
-
-    candidates = {
-        "Koleksi": koleksi,
-        "SDM": sdm,
-        "Pelayanan": pelayanan,
-        "Pengelolaan": pengelolaan,
-        "Kepatuhan (gabungan Koleksi+SDM)": kepatuhan,
-        "Kinerja (gabungan Pelayanan+Pengelolaan)": kinerja,
-    }
-    bottleneck = min(candidates.keys(), key=lambda k: candidates[k]) if candidates else "NA"
-    bottleneck_val = float(candidates.get(bottleneck, 0.0))
-
-    reasons = []
-    reasons.append(f"Variabel/dimensi dengan nilai paling kecil adalah {bottleneck} = {_fmt3(bottleneck_val)}.")
-    # gap reasoning
-    gd = float(signals.get("gap_dim", 0.0))
-    gks = float(signals.get("gap_koleksi_sdm", 0.0))
-    gpp = float(signals.get("gap_pelayanan_pengelolaan", 0.0))
-
-    reasons.append(f"Gap dimensi (Kinerja - Kepatuhan) = {_fmt3(gd)}.")
-    reasons.append(f"Gap internal Kepatuhan (Koleksi - SDM) = {_fmt3(gks)}.")
-    reasons.append(f"Gap internal Kinerja (Pelayanan - Pengelolaan) = {_fmt3(gpp)}.")
-
-    return {
-        "bottleneck": bottleneck,
-        "bottleneck_value": bottleneck_val,
-        "alasan": " ".join(reasons),
-    }
-
-def prescribe_actions(diagnosis: dict, dep_jenis: dict, coverage_risk: dict) -> list:
-    """
-    Preskripsi 2–3 aksi ringkas, menaut ke bottleneck, ketergantungan jenis, dan risiko coverage.
-    """
-    bottleneck = str(diagnosis.get("bottleneck", "")).lower()
-    dominant_jenis = dep_jenis.get("dominant_jenis_by_final", None)
-    cov_min = float(coverage_risk.get("coverage_min", 0.0))
-    gap_sum = int(coverage_risk.get("gap_target_sum", 0))
-
-    actions = []
-
-    # Coverage-oriented action (jika ada risiko)
-    if cov_min < 50.0 or gap_sum > 0:
-        actions.append(
-            "Penguatan coverage data: prioritas penambahan entri pada jenis dengan gap target terbesar "
-            "(sinkronisasi daftar perpustakaan, verifikasi duplikasi, dan dorongan pelaporan pada unit yang belum masuk)."
-        )
-
-    if "sdm" in bottleneck:
-        actions.append("Paket penguatan SDM: pemetaan kompetensi + penugasan fungsi minimal (layanan, pengolahan, pengelolaan) pada unit dengan skor terendah.")
-        actions.append("Klinik teknis 6–8 minggu: pendampingan pencatatan layanan, pengelolaan koleksi, dan pelaporan indikator untuk memperkecil gap SDM terhadap variabel lain.")
-    elif "koleksi" in bottleneck:
-        actions.append("Optimalisasi siklus koleksi: seleksi–pengadaan–penyiangan–promosi berbasis pemanfaatan (koleksi yang dipakai), agar selisih dengan SDM/Kinerja mengecil.")
-        actions.append("Paket koleksi minimum per layanan: susun daftar kebutuhan koleksi per segmen sasaran dan integrasikan dengan program layanan (read-aloud/kelas literasi/klub baca).")
-    elif "pengelolaan" in bottleneck:
-        actions.append("Perkuat tata kelola: SOP layanan, kebijakan, dan pencatatan output; pastikan program layanan terhubung dengan dokumen kebijakan dan dukungan anggaran.")
-        actions.append("Dorong kolaborasi: minimal 1–2 kemitraan aktif yang menghasilkan kegiatan layanan/budaya baca dan tercatat sebagai output pengelolaan.")
-    elif "pelayanan" in bottleneck:
-        actions.append("Aktivasi layanan: program rutin bulanan (kelas literasi, klub baca, layanan digital/keliling) untuk menaikkan pemustaka & pemanfaatan koleksi.")
-        actions.append("Segmentasi sasaran: pilih 2 segmen prioritas (pelajar, keluarga, komunitas/ASN) dan susun paket layanan minimum sesuai jenis perpustakaan.")
-    else:
-        actions.append("Konsolidasi program lintas variabel: susun rencana 90 hari (quick wins) pada variabel dengan nilai paling kecil dan rencana 6–12 bulan untuk penyeimbangan dimensi.")
-
-    # Dependency note
-    if dominant_jenis in ["sekolah", "umum", "khusus"]:
-        actions.append(
-            f"Penajaman per jenis: saat ini indeks final relatif lebih dominan pada jenis '{dominant_jenis}'. "
-            "Gunakan pola ini untuk mengarahkan replikasi praktik ke jenis lain yang tertinggal."
-        )
-
-    # keep 2–5 actions, trim if too long
-    if len(actions) > 5:
-        actions = actions[:5]
-    if len(actions) < 2:
-        actions = actions + ["Susun target operasional per variabel (koleksi/SDM/pelayanan/pengelolaan) dan monitoring triwulanan."]
-
-    return actions
-
-def compute_prediction(signals: dict, coverage_risk: dict, dep_jenis: dict) -> dict:
-    """
-    Prediksi tahun depan:
-    - baseline: point + interval (P10/P90) heuristik dari coverage & sebaran sederhana
-    - scenario: 3 skenario intervensi (SDM, Pengelolaan+Pelayanan, Koleksi+Aktivasi)
-    """
-    iplm = float(signals.get("iplm_final", 0.0))
-    cov_min = float(coverage_risk.get("coverage_min", 0.0))
-    faktor_mean = float(coverage_risk.get("faktor_mean", 1.0))
-
-    # interval half-width: makin rendah coverage/faktor makin "sensitif" -> interval lebih lebar
-    # normalize risk: coverage in [0..100], faktor in [0..1]
-    risk = 0.0
-    risk += (1.0 - _clamp(cov_min, 0, 100) / 100.0) * 0.6
-    risk += (1.0 - _clamp(faktor_mean, 0, 1)) * 0.4
-    half_width = PRED_INTERVAL_MIN + (PRED_INTERVAL_MAX - PRED_INTERVAL_MIN) * _clamp(risk, 0, 1)
-
-    drift = float(PRED_BASE_DRIFT_DEFAULT)
-    baseline_point = iplm + drift
-    p10 = baseline_point - half_width
-    p90 = baseline_point + half_width
-
-    # scenario deltas: translate improvement in sub/dim to index scale
-    # Index = 100*(0.30*kepatuhan + 0.70*kinerja) * faktor.
-    # If we add delta on a sub that feeds a dim (mean of two), we approximate:
-    # - Improve SDM or Koleksi by delta -> Kepatuhan increases by delta/2
-    # - Improve Pelayanan or Pengelolaan by delta -> Kinerja increases by delta/2
-    # Choose delta in [min,max] but scaled by risk (if risk high, conservative delta)
-    base_delta = PRED_SCENARIO_DELTA_SUB_MIN + (PRED_SCENARIO_DELTA_SUB_MAX - PRED_SCENARIO_DELTA_SUB_MIN) * (1.0 - _clamp(risk, 0, 1))
-    base_delta = _clamp(base_delta, PRED_SCENARIO_DELTA_SUB_MIN, PRED_SCENARIO_DELTA_SUB_MAX)
-
-    # Scenario 1: SDM focus -> kepatuhan + delta/2
-    delta_idx_sdm = 100.0 * (W_KEPATUHAN * (base_delta / 2.0)) * faktor_mean
-    # Scenario 2: Pengelolaan+Pelayanan focus -> kinerja + delta/2 (approx one sub improved)
-    delta_idx_kinerja = 100.0 * (W_KINERJA * (base_delta / 2.0)) * faktor_mean
-    # Scenario 3: Koleksi + Aktivasi pemanfaatan -> improve koleksi (kepatuhan) + pelayanan (kinerja)
-    delta_idx_combo = 100.0 * ((W_KEPATUHAN * (base_delta / 2.0)) + (W_KINERJA * (base_delta / 2.0))) * faktor_mean
-
-    scen = {
-        "Skenario_SDMPrioritas": baseline_point + delta_idx_sdm,
-        "Skenario_KinerjaPrioritas": baseline_point + delta_idx_kinerja,
-        "Skenario_KoleksiPlusAktivasi": baseline_point + delta_idx_combo,
-    }
-
-    # clamp predictions to 0..100
-    baseline_point = _clamp(baseline_point, 0, 100)
-    p10 = _clamp(p10, 0, 100)
-    p90 = _clamp(p90, 0, 100)
-    for k in list(scen.keys()):
-        scen[k] = _clamp(scen[k], 0, 100)
-
-    return {
-        "baseline_point": float(baseline_point),
-        "baseline_P10": float(p10),
-        "baseline_P90": float(p90),
-        "half_width": float(half_width),
-        "risk_index_0_1": float(_clamp(risk, 0, 1)),
-        "scenario_delta_sub_used": float(base_delta),
-        "scenario_predictions": scen,
-    }
-
-def build_insight_pack(wilayah_label: str, agg_total: pd.DataFrame, agg_jenis_full: pd.DataFrame, verif_total: pd.DataFrame) -> dict:
-    """
-    Master insight pack untuk 1 konteks filter (wilayah).
-    """
-    signals = detect_signals_from_agg_total(agg_total)
-    dep_jenis = detect_dependency_by_jenis(agg_jenis_full)
-    coverage_risk = compute_coverage_risk(verif_total)
-
-    diagnosis = diagnose_bottleneck(signals)
-    preskripsi = prescribe_actions(diagnosis, dep_jenis, coverage_risk)
-    prediksi = compute_prediction(signals, coverage_risk, dep_jenis)
-
-    # Deteksi summary strings
-    deteksi = {
-        "Nilai IPLM Final (0–100)": _fmt2(signals.get("iplm_final", 0.0)),
-        "Kepatuhan (0–1)": _fmt3(signals.get("kepatuhan", 0.0)),
-        "Kinerja (0–1)": _fmt3(signals.get("kinerja", 0.0)),
-        "Gap Dimensi (Kinerja - Kepatuhan)": _fmt3(signals.get("gap_dim", 0.0)),
-        "Gap Internal Kepatuhan (Koleksi - SDM)": _fmt3(signals.get("gap_koleksi_sdm", 0.0)),
-        "Gap Internal Kinerja (Pelayanan - Pengelolaan)": _fmt3(signals.get("gap_pelayanan_pengelolaan", 0.0)),
-        "Dominasi jenis (berdasar indeks final jenis)": str(dep_jenis.get("dominant_jenis_by_final", "")),
-        "Coverage min (%)": _fmt2(coverage_risk.get("coverage_min", 0.0)),
-        "Coverage mean (%)": _fmt2(coverage_risk.get("coverage_mean", 0.0)),
-        "Gap target total (unit)": str(coverage_risk.get("gap_target_sum", 0)),
-        "Faktor penyesuaian mean": _fmt3(coverage_risk.get("faktor_mean", 1.0)),
-    }
-
-    diagnosa = {
-        "Bottleneck utama": str(diagnosis.get("bottleneck", "")),
-        "Alasan berbasis angka": str(diagnosis.get("alasan", "")),
-    }
-
-    pred = {
-        "Baseline (point)": _fmt2(prediksi.get("baseline_point", 0.0)),
-        "Baseline interval (P10–P90)": f"{_fmt2(prediksi.get('baseline_P10',0.0))} – {_fmt2(prediksi.get('baseline_P90',0.0))}",
-        "Risk index (0–1)": _fmt3(prediksi.get("risk_index_0_1", 0.0)),
-        "Scenario SDM": _fmt2(prediksi.get("scenario_predictions", {}).get("Skenario_SDMPrioritas", 0.0)),
-        "Scenario Kinerja": _fmt2(prediksi.get("scenario_predictions", {}).get("Skenario_KinerjaPrioritas", 0.0)),
-        "Scenario Koleksi+Aktivasi": _fmt2(prediksi.get("scenario_predictions", {}).get("Skenario_KoleksiPlusAktivasi", 0.0)),
-        "Delta sub/dim yang dipakai": _fmt3(prediksi.get("scenario_delta_sub_used", 0.0)),
-    }
-
-    return {
-        "wilayah": wilayah_label,
-        "deteksi": deteksi,
-        "diagnosa": diagnosa,
-        "preskripsi": preskripsi,
-        "prediksi": pred,
-        "raw": {
-            "signals": signals,
-            "dependency": dep_jenis,
-            "coverage_risk": coverage_risk,
-            "diagnosis": diagnosis,
-            "prediction_struct": prediksi,
-        }
-    }
-
-def insight_pack_to_tables(insight_pack: dict) -> tuple:
-    """
-    Konversi insight_pack menjadi 3 tabel DataFrame:
-    - INSIGHT_WILAYAH (deteksi + diagnosa ringkas)
-    - PRESKRIPSI (list)
-    - PREDIKSI (baseline + scenario)
-    """
-    wilayah = insight_pack.get("wilayah", "")
-    det = insight_pack.get("deteksi", {}) or {}
-    diag = insight_pack.get("diagnosa", {}) or {}
-    pres = insight_pack.get("preskripsi", []) or []
-    pred = insight_pack.get("prediksi", {}) or {}
-
-    row = {"Wilayah": wilayah}
-    for k, v in det.items():
-        row[f"Deteksi__{k}"] = v
-    for k, v in diag.items():
-        row[f"Diagnosa__{k}"] = v
-    df_insight = pd.DataFrame([row])
-
-    df_pres = pd.DataFrame([{"Wilayah": wilayah, "Preskripsi": p} for p in pres]) if pres else pd.DataFrame([{"Wilayah": wilayah, "Preskripsi": ""}])
-
-    rowp = {"Wilayah": wilayah}
-    for k, v in pred.items():
-        rowp[f"Prediksi__{k}"] = v
-    df_pred = pd.DataFrame([rowp])
-
-    return df_insight, df_pres, df_pred
-
-
-# ============================================================
-# 16) CORE RUN
+# 15) CORE RUN
 # ============================================================
 
 def _empty_outputs(msg="Data belum siap."):
@@ -1798,12 +1424,11 @@ def _empty_outputs(msg="Data belum siap."):
     empty_fig = go.Figure()
     return (
         "",  # kpi_md
-        empty, empty, empty, empty, empty,  # tables
-        None, None, None, None, None, None,  # downloads (6)
-        empty_fig, empty_fig, empty_fig,     # figs
-        empty, empty, empty,                 # insight dfs
+        empty, empty, empty, empty, empty,
+        None, None, None, None, None,
+        empty_fig, empty_fig, empty_fig,
         msg,  # msg
-        "LLM belum tersedia.",  # llm status
+        "LLM belum tersedia.",  # status llm
         None  # word path
     )
 
@@ -1826,7 +1451,7 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
         kew_norm = kew_value if (kew_value and kew_value != "(Semua)") else "(Semua)"
         faktor_wilayah_jenis = build_faktor_wilayah_jenis(df, pop_kab, pop_prov, pop_khusus, kew_norm)
         agg_jenis_full = build_agg_wilayah_jenis(df, faktor_wilayah_jenis, kew_norm)
-        agg_total = build_agg_wilayah_total_from_jenis(agg_jenis_full, kew_norm)
+        agg_total = build_agg_wilayah_total_from_jenis(agg_jenis_full, faktor_wilayah_jenis, kew_norm)
 
         summary_jenis = build_summary_per_jenis(agg_jenis_full, agg_total)
         verif_total = build_verif_jenis(faktor_wilayah_jenis, kew_norm)
@@ -1884,12 +1509,7 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
 
         kpi_md = build_kpi_markdown(summary_jenis)
 
-        # ===== INSIGHT PACK =====
-        wilayah_txt = kab_value if (kab_value and kab_value != "(Semua)") else (prov_value if (prov_value and prov_value != "(Semua)") else "Nasional/All")
-        insight_pack = build_insight_pack(wilayah_txt, agg_total, agg_jenis_full, verif_total)
-        df_insight, df_pres, df_pred = insight_pack_to_tables(insight_pack)
-
-        # Export xlsx (6 file + 1 insight workbook optional)
+        # Export xlsx
         tmpdir = tempfile.mkdtemp()
         prov_slug = (_canon(prov_value or "SEMUA").upper() or "SEMUA")
         kab_slug = (_canon(kab_value or "SEMUA").upper() or "SEMUA")
@@ -1900,7 +1520,6 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
         p_raw     = str(Path(tmpdir) / f"IPLM_RAW_DATA_{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_KecukupanSampel_33_88_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
-        p_insight = str(Path(tmpdir) / f"IPLM_InsightPack_{prov_slug}_{kab_slug}_{kew_slug}.xlsx")
 
         summary_jenis.to_excel(p_summary, index=False)
         agg_total.to_excel(p_total, index=False)
@@ -1908,19 +1527,12 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
         detail_view.to_excel(p_detail, index=False)
         verif_total.to_excel(p_verif, index=False)
 
-        # Insight workbook multi-sheet
-        with pd.ExcelWriter(p_insight, engine="openpyxl") as xw:
-            df_insight.to_excel(xw, sheet_name="INSIGHT_WILAYAH", index=False)
-            df_pres.to_excel(xw, sheet_name="PRESKRIPSI", index=False)
-            df_pred.to_excel(xw, sheet_name="PREDIKSI", index=False)
-            # Optional: include agg tables
-            agg_total.to_excel(xw, sheet_name="AGG_TOTAL", index=False)
-            agg_jenis_full.to_excel(xw, sheet_name="AGG_JENIS", index=False)
-            verif_total.to_excel(xw, sheet_name="VERIF", index=False)
-
-        # ===== Word tabel interpretasi & rekomendasi (+ insight pack) =====
+        # ====== Word tabel interpretasi & rekomendasi ======
+        wilayah_txt = kab_value if (kab_value and kab_value != "(Semua)") else (prov_value if (prov_value and prov_value != "(Semua)") else "Nasional/All")
         header, rows = build_interpretasi_table_values(agg_total, wilayah_txt, TARGET_RATIO)
-        jumlah_perpus = summarize_jumlah_perpus_dari_agg_jenis(agg_jenis_full)
+
+        # jumlah perpustakaan sumber data (gambar 2)
+        jumlah_perpus = summarize_jumlah_perpus_dari_agg_jenis(agg_jenis_full, wilayah_txt, kew_norm)
 
         rows_filled, llm_status = llm_fill_interpretasi_rekomendasi(
             header=header,
@@ -1929,7 +1541,7 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
             kew_label=(kew_value or "(Semua)"),
             jumlah_perpus_by_jenis=jumlah_perpus
         )
-        word_path = generate_word_table_interpretasi(header, rows_filled, wilayah_txt, jumlah_perpus, insight_pack=insight_pack)
+        word_path = generate_word_table_interpretasi(header, rows_filled, wilayah_txt, jumlah_perpus)
 
         msg = (
             f"Selesai (TARGET {TARGET_RATIO*100:.2f}%): raw={len(raw)} | entitas={len(detail_view)} | "
@@ -1940,9 +1552,8 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
         return (
             kpi_md,
             summary_jenis, agg_total, agg_jenis_view, detail_view, verif_total,
-            p_summary, p_total, p_raw, p_detail, p_verif, p_insight,
+            p_summary, p_total, p_raw, p_detail, p_verif,
             fig_umum, fig_sekolah, fig_khusus,
-            df_insight, df_pres, df_pred,
             msg,
             llm_status,
             (word_path if word_path else None)
@@ -1953,7 +1564,7 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
 
 
 # ============================================================
-# 17) UI (NO UPLOAD)
+# 16) UI (NO UPLOAD)
 # ============================================================
 
 def ui_load(force=False):
@@ -2012,11 +1623,6 @@ UPDATE LLM + WORD:
 - Tabel Word "Interpretasi & Rekomendasi" memakai NILAI APA ADANYA (tanpa dikali 100) untuk sub/dim.
 - Baris "Nilai IPLM" memakai Indeks_Final_Wilayah_0_100 apa adanya.
 - Di bawah tabel Word ditambahkan ringkasan jumlah perpustakaan sumber data (sekolah/umum/khusus/total) dari tabel agregat wilayah × jenis.
-- Ditambah Insight Pack: Deteksi–Diagnosa–Preskripsi–Prediksi (tahun depan) berbasis output pipeline.
-
-Prediksi:
-- Baseline + interval (heuristik berbasis risiko coverage)
-- 3 skenario intervensi (SDM / Kinerja / Koleksi+Aktivasi)
 """)
 
     state_df = gr.State(None)
@@ -2065,11 +1671,6 @@ Prediksi:
     gr.Markdown("### Perpustakaan Khusus")
     bell_khusus = gr.Plot(scale=1)
 
-    gr.Markdown("## Insight Pack (Deteksi–Diagnosa–Preskripsi–Prediksi)")
-    out_insight = gr.DataFrame(interactive=False)
-    out_pres = gr.DataFrame(interactive=False)
-    out_pred = gr.DataFrame(interactive=False)
-
     gr.Markdown("## Status LLM (Isi Interpretasi & Rekomendasi)")
     llm_status_out = gr.Markdown()
 
@@ -2079,8 +1680,7 @@ Prediksi:
         dl_raw = gr.DownloadButton(label="Download Data Mentah (.xlsx)")
         dl_detail = gr.DownloadButton(label="Download Detail Entitas (.xlsx)")
         dl_verif = gr.DownloadButton(label="Download Kecukupan Sampel (.xlsx)")
-        dl_insight = gr.DownloadButton(label="Download Insight Pack (.xlsx)")
-        dl_word = gr.DownloadButton(label="Download Word: Interpretasi & Insight (.docx)" if DOCX_AVAILABLE else "Download Word (OFF)")
+        dl_word = gr.DownloadButton(label="Download Word: Interpretasi & Rekomendasi (.docx)" if DOCX_AVAILABLE else "Download Word (OFF)")
 
     run_btn.click(
         fn=run_calc,
@@ -2088,9 +1688,8 @@ Prediksi:
         outputs=[
             kpi_out,
             out_summary, out_agg_total, out_agg_jenis, out_detail, out_verif,
-            dl_summary, dl_total, dl_raw, dl_detail, dl_verif, dl_insight,
+            dl_summary, dl_total, dl_raw, dl_detail, dl_verif,
             bell_umum, bell_sekolah, bell_khusus,
-            out_insight, out_pres, out_pred,
             msg_out,
             llm_status_out,
             dl_word