Upload 2 files

app (5).py

@@ -0,0 +1,1961 @@
+"""
+Space Weather - Weather Intelligence Application
+Built with Gradio, LiteLLM, Open-Meteo, and Gemini
+Compatible with Gradio 6.x
+Browser-cache version: SINGLE ENTRY (overwrite old data)
+
+Fitur: foto lahan/tanaman opsional (dikompres di memori, tidak disimpan).
+"""
+
+import html
+import json
+import logging
+import math
+import os
+import random
+import re
+import time
+import uuid
+import warnings
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+import gradio as gr
+from litellm import completion
+
+from gemini_key_manager import GeminiKeyManager, classify_gemini_error
+from image_utils import compress_image_to_data_url
+from product_search import build_recommendation_modal, preload
+
+warnings.filterwarnings("ignore", category=RuntimeWarning, message="coroutine.*was never awaited")
+warnings.filterwarnings("ignore", category=RuntimeWarning, message=".*event loop.*")
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ------------------------------------------------------------------
+# FILE LOADERS
+# ------------------------------------------------------------------
+def load_text(path: str) -> str:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception as e:
+        logger.error(f"Failed to load {path}: {e}")
+        return ""
+
+
+def load_json(path: str) -> dict:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        logger.error(f"Failed to load {path}: {e}")
+        return {}
+
+
+_SYSTEM_PROMPT: Optional[str] = None
+
+
+def get_system_prompt() -> str:
+    """System prompt dibaca sekali lalu di-cache di memori."""
+    global _SYSTEM_PROMPT
+    if not _SYSTEM_PROMPT:
+        _SYSTEM_PROMPT = load_text("prompts/system_prompt.txt")
+    return _SYSTEM_PROMPT
+
+
+# ------------------------------------------------------------------
+# CONFIGURATION
+# ------------------------------------------------------------------
+EXPORT_DIR = "/tmp/weather_exports"
+EXPORT_MAX_AGE_S = 3600
+
+SHOPEE_LINK = "https://shopee.co.id/"
+
+GEMINI_MODEL = "gemini/gemini-3.5-flash"
+GEMINI_TIMEOUT_S = 30
+GEMINI_TIMEOUT_IMAGE_S = 45
+GEMINI_TOTAL_BUDGET_S = 100   # batas total waktu satu analisis (semua key + retry)
+GEMINI_MAX_ROUNDS = 3         # putaran retry jika kena limit per menit (RPM)
+
+CONCURRENCY_LIMIT = 20        # analisis Gemini paralel
+MAX_UPLOAD_SIZE = "8mb"
+
+key_manager = GeminiKeyManager()
+preload()  # load model & embedding produk di background thread
+
+# ------------------------------------------------------------------
+# STATE MACHINE CONSTANTS
+# ------------------------------------------------------------------
+STATE_READY = "READY"
+STATE_LOCATING = "LOCATING"
+STATE_LOCATION_READY = "LOCATION_READY"
+STATE_ANALYZING = "ANALYZING"
+STATE_FETCHING_WEATHER = "FETCHING_WEATHER"
+STATE_PROCESSING_DATA = "PROCESSING_DATA"
+STATE_GENERATING_INSIGHT = "GENERATING_INSIGHT"
+STATE_VALIDATING_OUTPUT = "VALIDATING_OUTPUT"
+STATE_COMPLETED = "COMPLETED"
+STATE_ERROR = "ERROR"
+STATE_LOCKED_TODAY = "LOCKED_TODAY"
+
+PROGRESS_STEPS = {
+    STATE_FETCHING_WEATHER:   ("Step 1/5", "Getting weather data..."),
+    STATE_PROCESSING_DATA:    ("Step 2/5", "Processing weather data..."),
+    STATE_GENERATING_INSIGHT: ("Step 3/5", "Generating weather insight..."),
+    STATE_VALIDATING_OUTPUT:  ("Step 4/5", "Validating analysis..."),
+    STATE_COMPLETED:          ("Step 5/5", "Analysis complete"),
+}
+
+STEP_ORDER = [
+    STATE_FETCHING_WEATHER,
+    STATE_PROCESSING_DATA,
+    STATE_GENERATING_INSIGHT,
+    STATE_VALIDATING_OUTPUT,
+    STATE_COMPLETED,
+]
+STEP_LABELS = ["Weather Data", "Processing", "Insight", "Validation", "Complete"]
+
+STATUS_VARIANTS = {
+    STATE_READY: ("neutral", "Ready"),
+    STATE_LOCATION_READY: ("info", "Location ready"),
+    STATE_ANALYZING: ("active", "Analyzing"),
+    STATE_ERROR: ("error", "Error"),
+    STATE_LOCKED_TODAY: ("info", "Locked"),
+    STATE_COMPLETED: ("success", "Complete"),
+}
+
+VALID_SEVERITY = {"low", "medium", "high"}
+VALID_CONFIDENCE = {"low", "medium", "high"}
+VALID_PRIORITY = {"low", "medium", "high"}
+
+WEATHER_VARIABLES = [
+    # Temperature and plant development
+    "temperature_2m_max",
+    "temperature_2m_min",
+    "temperature_2m_mean",
+    "growing_degree_days_base_0_limit_50",
+
+    # Rainfall and water balance
+    "precipitation_sum",
+    "precipitation_hours",
+    "precipitation_probability_max",
+    "et0_fao_evapotranspiration",
+
+    # Humidity and disease-related conditions
+    "relative_humidity_2m_mean",
+    "relative_humidity_2m_max",
+    "dew_point_2m_mean",
+    "leaf_wetness_probability_mean",
+    "vapour_pressure_deficit_max",
+
+    # Radiation, clouds, and wind
+    "shortwave_radiation_sum",
+    "cloud_cover_mean",
+    "wind_speed_10m_max",
+    "wind_gusts_10m_max",
+]
+
+
+# ------------------------------------------------------------------
+# DATA CLASSES
+# ------------------------------------------------------------------
+@dataclass
+class AppState:
+    state: str = STATE_READY
+    is_analyzing: bool = False
+    location: Optional[Dict] = None
+    client_date: Optional[str] = None
+    client_timezone: Optional[str] = None
+    browser_date: Optional[str] = None
+    browser_timezone: Optional[str] = None
+    cache: Optional[Dict] = None  # SINGLE entry
+
+    def to_dict(self):
+        return {
+            "state": self.state,
+            "is_analyzing": self.is_analyzing,
+            "location": self.location,
+            "client_date": self.client_date,
+            "client_timezone": self.client_timezone,
+            "browser_date": self.browser_date,
+            "browser_timezone": self.browser_timezone,
+            "cache": self.cache,
+        }
+
+    @classmethod
+    def from_dict(cls, d):
+        d = d or {}
+        return cls(
+            state=d.get("state", STATE_READY),
+            is_analyzing=d.get("is_analyzing", False),
+            location=d.get("location"),
+            client_date=d.get("client_date"),
+            client_timezone=d.get("client_timezone"),
+            browser_date=d.get("browser_date"),
+            browser_timezone=d.get("browser_timezone"),
+            cache=d.get("cache"),
+        )
+
+
+# ------------------------------------------------------------------
+# UTILITY FORMATTERS
+# ------------------------------------------------------------------
+def validate_coordinates(lat: Any, lon: Any) -> Tuple[bool, str]:
+    if lat is None or lon is None:
+        return False, "Invalid location. Please enter a valid latitude and longitude."
+    try:
+        lat_f = float(lat)
+        lon_f = float(lon)
+    except (ValueError, TypeError):
+        return False, "Invalid location. Please enter a valid latitude and longitude."
+
+    if not (-90 <= lat_f <= 90):
+        return False, "Invalid location. Latitude must be between -90 and 90."
+    if not (-180 <= lon_f <= 180):
+        return False, "Invalid location. Longitude must be between -180 and 180."
+    return True, ""
+
+
+def validate_coordinates_ui(lat, lon, state_dict):
+    state = AppState.from_dict(state_dict)
+    if state.state == STATE_LOCKED_TODAY:
+        return gr.update(interactive=False)
+    if (lat is None or lat == 0) or (lon is None or lon == 0):
+        return gr.update(interactive=False)
+    return gr.update(interactive=True)
+
+
+def esc(value: Any) -> str:
+    if value is None:
+        return ""
+    return html.escape(str(value))
+
+
+def format_status(state: str, message: str = "") -> str:
+    if state in PROGRESS_STEPS and state not in STATUS_VARIANTS:
+        variant = "active"
+        label = PROGRESS_STEPS[state][1]
+    else:
+        variant, label = STATUS_VARIANTS.get(state, ("neutral", state.replace("_", " ").title()))
+
+    detail = f'<span class="status-detail">{esc(message)}</span>' if message else ""
+    return (
+        f'<div class="status-pill status-pill--{variant}">'
+        f'<span class="status-dot"></span>'
+        f'<span class="status-label">{esc(label)}</span>'
+        f'{detail}'
+        f'</div>'
+    )
+
+
+def format_location_status(source: str, accuracy: Optional[float]) -> str:
+    source_label = {"gps": "GPS", "ip": "IP geolocation"}.get(source, source or "Manual")
+    accuracy_str = f" &plusmn;{accuracy:.0f}m" if accuracy else ""
+    return (
+        f'<div class="status-pill status-pill--info">'
+        f'<span class="status-dot"></span>'
+        f'<span class="status-label">Location ready</span>'
+        f'<span class="status-detail">{esc(source_label)}{accuracy_str}</span>'
+        f'</div>'
+    )
+
+
+def render_step_tracker(state: str, error: bool = False) -> str:
+    if state not in STEP_ORDER:
+        return ""
+    idx = STEP_ORDER.index(state)
+
+    items = []
+    for i, label in enumerate(STEP_LABELS):
+        is_done = i < idx or (i == idx and state == STATE_COMPLETED)
+        if error and i == idx:
+            cls, marker = "is-error", "&times;"
+        elif is_done:
+            cls, marker = "is-done", "&check;"
+        elif i == idx:
+            cls, marker = "is-active", f"{i + 1:02d}"
+        else:
+            cls, marker = "is-pending", f"{i + 1:02d}"
+
+        items.append(
+            f'<div class="step {cls}">'
+            f'<span class="step-marker">{marker}</span>'
+            f'<span class="step-label">{esc(label)}</span>'
+            f'</div>'
+        )
+        if i < len(STEP_LABELS) - 1:
+            filled = "filled" if is_done else ""
+            items.append(f'<div class="step-connector {filled}"></div>')
+
+    return f'<div class="step-tracker">{"".join(items)}</div>'
+
+
+def format_progress(state: str, error: bool = False) -> str:
+    return render_step_tracker(state, error=error)
+
+
+def format_cache_info(cache_entry: Optional[Dict]) -> str:
+    if not cache_entry:
+        return ""
+
+    client_date = cache_entry.get("client_date", "Unknown")
+    if client_date != "Unknown":
+        try:
+            client_date = datetime.strptime(client_date, "%Y-%m-%d").strftime("%d %b %Y")
+        except Exception:
+            pass
+
+    created = cache_entry.get("created_at", "Unknown")
+    browser_tz = cache_entry.get("browser_timezone") or cache_entry.get("client_timezone") or "UTC"
+
+    if created != "Unknown":
+        try:
+            dt = datetime.fromisoformat(created)
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=timezone.utc)
+            if browser_tz and browser_tz != "UTC":
+                try:
+                    from zoneinfo import ZoneInfo
+                    dt_local = dt.astimezone(ZoneInfo(browser_tz))
+                    created = dt_local.strftime("%d %b %Y, %H:%M") + f" · {browser_tz}"
+                except Exception:
+                    created = dt.strftime("%d %b %Y, %H:%M UTC")
+            else:
+                created = dt.strftime("%d %b %Y, %H:%M UTC")
+        except Exception:
+            pass
+
+    location = cache_entry.get("location", {}) or {}
+    source = location.get("source", "manual")
+    source_label = {"gps": "GPS", "ip": "IP Geolocation", "manual": "Manual"}.get(source, source)
+
+    return (
+        f'<div class="cache-card">'
+        f'<div class="cache-card-icon">&check;</div>'
+        f'<div class="cache-card-body">'
+        f'<div class="cache-card-title">Today&rsquo;s analysis is ready</div>'
+        f'<div class="cache-card-meta">'
+        f'<span>{esc(client_date)}</span><span class="dot-sep">&middot;</span><span>{esc(source_label)}</span>'
+        f'</div>'
+        f'<div class="cache-card-meta cache-card-meta--faint">Generated {esc(created)}</div>'
+        f'</div>'
+        f'</div>'
+    )
+
+
+def render_placeholder(title: str, message: str, variant: str = "neutral") -> str:
+    return (
+        f'<div class="placeholder-card placeholder-card--{variant}">'
+        f'<div class="placeholder-mark"></div>'
+        f'<div class="placeholder-title">{esc(title)}</div>'
+        f'<div class="placeholder-message">{esc(message)}</div>'
+        f'</div>'
+    )
+
+
+def render_sponsors_html(sponsors: List[Dict]) -> str:
+    if not sponsors:
+        return '<div class="sponsor-empty">No sponsors listed.</div>'
+    items = []
+    for s in sponsors:
+        items.append(
+            f'<a class="sponsor-item" href="{esc(s.get("link", "#"))}" '
+            f'target="_blank" rel="noopener noreferrer" title="{esc(s.get("name", ""))}">'
+            f'<img class="sponsor-img" src="{esc(s.get("image", ""))}" '
+            f'alt="{esc(s.get("name", ""))}" loading="lazy">'
+            f'</a>'
+        )
+    return f'<div class="sponsor-grid">{"".join(items)}</div>'
+
+
+# ------------------------------------------------------------------
+# TAB RENDERERS
+# ------------------------------------------------------------------
+_LEVEL_CLASS = {"low": "badge--good", "medium": "badge--warn", "high": "badge--bad"}
+
+
+def severity_badge(sev: Optional[str]) -> str:
+    sev_l = (sev or "unknown").lower()
+    return f'<span class="badge {_LEVEL_CLASS.get(sev_l, "badge--neutral")}">{esc(sev_l.upper())}</span>'
+
+
+def priority_badge(pri: Optional[str]) -> str:
+    pri_l = (pri or "unknown").lower()
+    return f'<span class="badge {_LEVEL_CLASS.get(pri_l, "badge--neutral")}">{esc(pri_l.upper())} PRI.</span>'
+
+
+def confidence_badge(conf: Optional[str]) -> str:
+    conf_l = (conf or "unknown").lower()
+    cls = {"high": "badge--good", "medium": "badge--warn", "low": "badge--neutral"}.get(conf_l, "badge--neutral")
+    return f'<span class="badge {cls} badge--outline">{esc(conf_l.upper())} CONF.</span>'
+
+
+def render_summary_tab(analysis: Dict) -> str:
+    if not analysis:
+        return render_placeholder("No analysis yet", "Enter coordinates and select Analyze to generate today's insight.")
+    parts = ['<div class="insight-card">']
+    parts.append(f'<p class="insight-summary">{esc(analysis.get("summary", "No summary available."))}</p>')
+    overall = analysis.get("overall_confidence", "")
+    if overall:
+        parts.append(f'<div class="insight-footer">Overall confidence&nbsp;{confidence_badge(overall)}</div>')
+    parts.append('</div>')
+    return "".join(parts)
+
+
+def _render_period_tab(analysis: Dict, key: str, eyebrow: str, empty_title: str,
+                       empty_msg: str, nothing_msg: str) -> str:
+    """Dipakai bersama oleh tab Historical dan Forecast (mendukung format lama)."""
+    if not analysis:
+        return render_placeholder(empty_title, empty_msg)
+    block = analysis.get(key, {}) or {}
+    parts = ['<div class="insight-card"><div class="insight-section">']
+    parts.append(f'<div class="section-eyebrow">{eyebrow}</div>')
+    if block.get("condition"):
+        parts.append(f'<p class="section-text"><strong>Kondisi:</strong> {esc(block["condition"])}</p>')
+    if block.get("impact"):
+        parts.append(f'<p class="section-text"><strong>Dampak:</strong> {esc(block["impact"])}</p>')
+    # Format lama (backward-compatible)
+    if block.get("summary"):
+        parts.append(f'<p class="section-text">{esc(block["summary"])}</p>')
+    conds = block.get("key_conditions") or []
+    if conds:
+        parts.append('<ul class="condition-list">' + "".join(f'<li>{esc(c)}</li>' for c in conds) + '</ul>')
+    if not (block.get("condition") or block.get("impact") or block.get("summary") or conds):
+        parts.append(f'<p class="section-text">{nothing_msg}</p>')
+    parts.append('</div></div>')
+    return "".join(parts)
+
+
+def render_historical_tab(analysis: Dict) -> str:
+    return _render_period_tab(
+        analysis, "historical", "Historical &middot; Last 7 Days",
+        "No data yet", "Run analysis to view historical records.", "No historical data recorded.",
+    )
+
+
+def render_forecast_tab(analysis: Dict) -> str:
+    return _render_period_tab(
+        analysis, "forecast", "Forecast &middot; Next 7 Days",
+        "No data yet", "Run analysis to view forecast records.", "No forecast data recorded.",
+    )
+
+
+def render_risks_tab(analysis: Dict) -> str:
+    if not analysis:
+        return render_placeholder("No data yet", "Run analysis to view risk signals.")
+    risks = analysis.get("risks") or []
+    parts = ['<div class="insight-card"><div class="insight-section">']
+    parts.append('<div class="section-eyebrow">Risk Signals</div>')
+    if risks:
+        parts.append('<div class="risk-list">')
+        for risk in risks:
+            title = str(risk.get("title") or risk.get("type", "Unknown Risk"))
+            parts.append('<div class="risk-item">')
+            parts.append(
+                f'<div class="risk-item-head">'
+                f'<span class="risk-item-title">{esc(title)}</span>'
+                f'<span class="risk-item-badges">{severity_badge(risk.get("severity"))}</span>'
+                f'</div>'
+            )
+            if risk.get("description"):
+                parts.append(f'<p class="section-text" style="margin:6px 0 4px;font-size:13px;">{esc(risk["description"])}</p>')
+            if risk.get("evidence"):
+                parts.append(f'<p class="risk-item-evidence">{esc(risk["evidence"])}</p>')
+            if risk.get("period"):
+                parts.append(f'<p class="risk-item-evidence" style="color:var(--info);margin-top:4px;">&#128197; {esc(risk["period"])}</p>')
+            parts.append('</div>')
+        parts.append('</div>')
+    else:
+        parts.append('<p class="section-text">No significant weather risks detected.</p>')
+    parts.append('</div></div>')
+    return "".join(parts)
+
+
+def render_recommendations_tab(analysis: Dict) -> str:
+    if not analysis:
+        return render_placeholder("No data yet", "Run analysis to view recommendations.")
+    parts = ['<div class="insight-card">']
+    parts.append('<div class="insight-section insight-section--recommendation" style="margin-bottom:0;">')
+    parts.append('<div class="section-eyebrow">Recommendation</div>')
+    recs = analysis.get("recommendations") or []
+    if recs:
+        parts.append('<div class="risk-list">')
+        for rec in recs:
+            if isinstance(rec, str):  # format lama
+                action, reason, priority = rec, "", ""
+            else:
+                action = str(rec.get("action", ""))
+                reason = str(rec.get("reason", ""))
+                priority = rec.get("priority", "")
+            parts.append('<div class="risk-item" style="border-color:rgba(232,163,61,0.25);">')
+            parts.append(
+                f'<div class="risk-item-head">'
+                f'<span class="risk-item-title">{esc(action)}</span>'
+                f'<span class="risk-item-badges">{priority_badge(priority)}</span>'
+                f'</div>'
+            )
+            if reason:
+                parts.append(f'<p class="risk-item-evidence">{esc(reason)}</p>')
+            parts.append('</div>')
+        parts.append('</div>')
+    else:
+        parts.append('<p class="section-text">No immediate action indicated.</p>')
+    parts.append('</div></div>')
+    return "".join(parts)
+
+
+def render_all_tabs(analysis: Dict) -> Tuple[str, str, str, str, str]:
+    return (
+        render_summary_tab(analysis),
+        render_historical_tab(analysis),
+        render_forecast_tab(analysis),
+        render_risks_tab(analysis),
+        render_recommendations_tab(analysis),
+    )
+
+
+# ------------------------------------------------------------------
+# UI OUTPUT HELPERS (satu tempat untuk tuple 15 elemen)
+# ------------------------------------------------------------------
+def tabs_placeholder(title: str, message: str, variant: str = "neutral",
+                     rest: str = "Waiting...") -> Tuple[str, str, str, str, str]:
+    first = render_placeholder(title, message, variant)
+    other = render_placeholder("No data yet", rest, "neutral")
+    return (first, other, other, other, other)
+
+
+def ui_outputs(state: AppState, *, lock_inputs: bool, status: str, step: str = "",
+               cache_info: str = "", show_placeholder: bool, show_view_btn: bool,
+               tabs: Tuple[str, str, str, str, str], cache_json: str = ""):
+    """Urutan harus cocok dengan `outputs` pada weather_json.change."""
+    return (
+        state.to_dict(),
+        gr.update(interactive=not lock_inputs),   # get_loc_btn
+        gr.update(interactive=not lock_inputs),   # analyze_btn
+        status,
+        step,
+        cache_info,
+        gr.update(visible=show_placeholder),      # initial_placeholder
+        gr.update(visible=show_view_btn),         # view_insight_btn
+        gr.update(visible=False),                 # tabs_container (baru tampil setelah View Insight)
+        *tabs,
+        cache_json if cache_json else gr.update(value=""),
+    )
+
+
+def progress_outputs(state: AppState, step_state: str, title: str, message: str):
+    state.state = step_state
+    return ui_outputs(
+        state, lock_inputs=True,
+        status=format_status(step_state), step=format_progress(step_state),
+        show_placeholder=True, show_view_btn=False,
+        tabs=tabs_placeholder(title, message, "active"),
+    )
+
+
+def error_outputs(state: AppState, failed_step: str, message: str):
+    state.is_analyzing = False
+    state.state = STATE_ERROR
+    step = format_progress(failed_step if failed_step in STEP_ORDER else STATE_FETCHING_WEATHER, error=True)
+    return ui_outputs(
+        state, lock_inputs=False,
+        status=format_status(STATE_ERROR, message), step=step,
+        show_placeholder=True, show_view_btn=False,
+        tabs=tabs_placeholder("Analysis failed", message, "error", "Analysis interrupted."),
+    )
+
+
+# ------------------------------------------------------------------
+# WEATHER VALIDATION & FEATURE ENGINEERING
+# ------------------------------------------------------------------
+MAX_DAILY_ROWS = 40
+
+
+def validate_weather_payload(raw: Any) -> str:
+    """Respons cuaca datang dari browser, jadi struktur harus diperiksa di server."""
+    if not isinstance(raw, dict):
+        return "Weather data unavailable. Please try again later. (Invalid JSON)"
+    daily = raw.get("daily")
+    if not isinstance(daily, dict):
+        return "Weather data unavailable. Please try again later. (Missing daily data)"
+    dates = daily.get("time")
+    if not isinstance(dates, list) or len(dates) < 8:
+        return "Weather data unavailable. Please try again later. (Insufficient data)"
+    if len(dates) > MAX_DAILY_ROWS:
+        return "Weather data unavailable. Please try again later. (Too many rows)"
+    for var in WEATHER_VARIABLES:
+        values = daily.get(var)
+        if not isinstance(values, list) or len(values) != len(dates):
+            return f"Weather data unavailable. Please try again later. (Missing variable: {var})"
+    return ""
+
+
+def _weather_num(value):
+    """Convert valid finite numeric values to float; otherwise None."""
+    try:
+        if value is None:
+            return None
+        number = float(value)
+        return number if math.isfinite(number) else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _weather_probability_fraction(value, unit=None):
+    """Normalize a probability to 0-1 (Open-Meteo biasanya dalam persen)."""
+    number = _weather_num(value)
+    if number is None:
+        return None
+    if unit and "%" in str(unit):
+        number /= 100.0
+    elif number > 1.0:
+        number /= 100.0
+    return max(0.0, min(1.0, number))
+
+
+def _get(record: Dict, source: str, key: str):
+    return record["raw"].get(key) if source == "raw" else record["features"].get(key)
+
+
+def engineer_weather_features(normalized):
+    """
+    Build derived agricultural weather features from the daily arrays.
+    Output: feature arrays per periode + ringkasan periode.
+    """
+    units = normalized.get("units", {}) or {}
+    periods = ("historical", "today", "forecast")
+    records = []
+
+    # 1. Gabungkan tiga periode secara kronologis
+    for period in periods:
+        block = normalized.get(period, {}) or {}
+        dates = block.get("time", []) or []
+
+        for i, date in enumerate(dates):
+            raw = {}
+            for variable in WEATHER_VARIABLES:
+                values = block.get(variable, [])
+                value = values[i] if isinstance(values, list) and i < len(values) else None
+                raw[variable] = _weather_num(value)
+
+            rh = raw.get("relative_humidity_2m_mean")
+            leaf_wetness = _weather_probability_fraction(
+                raw.get("leaf_wetness_probability_mean"),
+                units.get("leaf_wetness_probability_mean"),
+            )
+            precip_probability = _weather_probability_fraction(
+                raw.get("precipitation_probability_max"),
+                units.get("precipitation_probability_max"),
+            )
+
+            t_mean = raw.get("temperature_2m_mean")
+            t_min = raw.get("temperature_2m_min")
+            t_max = raw.get("temperature_2m_max")
+            dew = raw.get("dew_point_2m_mean")
+            precip = raw.get("precipitation_sum")
+            precip_hours = raw.get("precipitation_hours")
+            et0 = raw.get("et0_fao_evapotranspiration")
+
+            features = {
+                "temperature_range_c": (
+                    t_max - t_min if t_max is not None and t_min is not None else None
+                ),
+                "dewpoint_depression_proxy_c": (
+                    t_mean - dew if t_mean is not None and dew is not None else None
+                ),
+                "water_balance_proxy_mm": (
+                    precip - et0 if precip is not None and et0 is not None else None
+                ),
+                "precipitation_per_wet_hour_proxy": (
+                    precip / precip_hours
+                    if precip is not None and precip_hours is not None and precip_hours > 0
+                    else None
+                ),
+                "leaf_wetness_fraction": leaf_wetness,
+                "precip_probability_fraction": precip_probability,
+                # Proksi lingkungan, BUKAN probabilitas penyakit.
+                "humidity_wetness_interaction": (
+                    (rh / 100.0) * leaf_wetness
+                    if rh is not None and leaf_wetness is not None
+                    else None
+                ),
+                "wetness_duration_interaction": (
+                    leaf_wetness * max(0.0, min(1.0, precip_hours / 24.0))
+                    if leaf_wetness is not None and precip_hours is not None
+                    else None
+                ),
+            }
+            records.append({"date": date, "period": period, "raw": raw, "features": features})
+
+    # 2. Hari berturut-turut dengan presipitasi <= 0.1 mm
+    dry_streak = 0
+    for record in records:
+        precip = record["raw"].get("precipitation_sum")
+        if precip is None:
+            dry_streak = 0
+            record["features"]["dry_spell_days"] = None
+        elif precip <= 0.1:
+            dry_streak += 1
+            record["features"]["dry_spell_days"] = dry_streak
+        else:
+            dry_streak = 0
+            record["features"]["dry_spell_days"] = 0
+
+    # 3. Rolling 3 dan 7 hari (nilai hilang tidak diganti nol)
+    def rolling_value(index, source, key, window, operation):
+        if index + 1 < window:
+            return None
+        subset = records[index - window + 1:index + 1]
+        values = [_get(r, source, key) for r in subset]
+        if any(v is None for v in values):
+            return None
+        return sum(values) if operation == "sum" else sum(values) / len(values)
+
+    rolling_specs = [
+        # (source, key, operation, prefix)
+        ("raw", "precipitation_sum", "sum", "precipitation"),
+        ("raw", "et0_fao_evapotranspiration", "sum", "et0"),
+        ("feature", "water_balance_proxy_mm", "sum", "water_balance"),
+        ("raw", "growing_degree_days_base_0_limit_50", "sum", "gdd"),
+        ("raw", "temperature_2m_mean", "mean", "temperature_mean"),
+        ("raw", "vapour_pressure_deficit_max", "mean", "vpd"),
+        ("raw", "relative_humidity_2m_mean", "mean", "rh_mean_pct"),
+        ("feature", "leaf_wetness_fraction", "mean", "leaf_wetness"),
+    ]
+    for i, record in enumerate(records):
+        for window in (3, 7):
+            for source, key, operation, prefix in rolling_specs:
+                record["features"][f"{prefix}_{window}d_{operation}"] = rolling_value(
+                    i, source, key, window, operation
+                )
+
+    # 4. Perubahan 1 hari
+    delta_specs = {
+        "temperature_mean_delta_1d": ("raw", "temperature_2m_mean"),
+        "vpd_delta_1d": ("raw", "vapour_pressure_deficit_max"),
+        "rh_mean_delta_1d": ("raw", "relative_humidity_2m_mean"),
+        "precipitation_delta_1d": ("raw", "precipitation_sum"),
+        "leaf_wetness_delta_1d": ("feature", "leaf_wetness_fraction"),
+    }
+    for i, record in enumerate(records):
+        for name, (source, key) in delta_specs.items():
+            value = None
+            if i > 0:
+                cur = _get(record, source, key)
+                prev = _get(records[i - 1], source, key)
+                if cur is not None and prev is not None:
+                    value = cur - prev
+            record["features"][name] = value
+
+    # 5. Prakiraan relatif terhadap rata-rata historis 7 hari
+    anomaly_specs = {
+        "temperature_mean_delta_vs_history7d": ("raw", "temperature_2m_mean"),
+        "vpd_delta_vs_history7d": ("raw", "vapour_pressure_deficit_max"),
+        "rh_mean_delta_vs_history7d": ("raw", "relative_humidity_2m_mean"),
+        "precipitation_delta_vs_history7d": ("raw", "precipitation_sum"),
+        "et0_delta_vs_history7d": ("raw", "et0_fao_evapotranspiration"),
+        "leaf_wetness_delta_vs_history7d": ("feature", "leaf_wetness_fraction"),
+    }
+    historical_records = [r for r in records if r["period"] == "historical"]
+    baselines = {}
+    for name, (source, key) in anomaly_specs.items():
+        values = [v for v in (_get(r, source, key) for r in historical_records) if v is not None]
+        baselines[name] = sum(values) / len(values) if values else None
+
+    for record in records:
+        for name, (source, key) in anomaly_specs.items():
+            value = None
+            if record["period"] == "forecast":
+                cur = _get(record, source, key)
+                base = baselines[name]
+                if cur is not None and base is not None:
+                    value = cur - base
+            record["features"][name] = value
+
+    # 6. Susun array fitur per periode
+    all_feature_names = sorted({k for r in records for k in r["features"]})
+    derived_blocks = {}
+    for period in periods:
+        period_records = [r for r in records if r["period"] == period]
+        derived_blocks[period] = {
+            "time": [r["date"] for r in period_records],
+            "features": {
+                name: [r["features"].get(name) for r in period_records]
+                for name in all_feature_names
+            },
+        }
+
+    # 7. Ringkasan periode
+    def mean_values(values):
+        values = [v for v in values if v is not None]
+        return sum(values) / len(values) if values else None
+
+    def total_values(values):
+        # Jangan tampilkan jumlah parsial sebagai total periode.
+        if not values or any(v is None for v in values):
+            return None
+        return sum(values)
+
+    def max_values(values):
+        return max([v for v in values if v is not None], default=None)
+
+    def min_values(values):
+        return min([v for v in values if v is not None], default=None)
+
+    def summarize_period(period):
+        subset = [r for r in records if r["period"] == period]
+
+        def raw_values(key):
+            return [r["raw"].get(key) for r in subset]
+
+        def feature_values(key):
+            return [r["features"].get(key) for r in subset]
+
+        return {
+            "days": len(subset),
+            "temperature_mean_c": mean_values(raw_values("temperature_2m_mean")),
+            "temperature_max_peak_c": max_values(raw_values("temperature_2m_max")),
+            "temperature_min_low_c": min_values(raw_values("temperature_2m_min")),
+            "temperature_range_mean_c": mean_values(feature_values("temperature_range_c")),
+            "precipitation_total_mm": total_values(raw_values("precipitation_sum")),
+            "precipitation_hours_total": total_values(raw_values("precipitation_hours")),
+            "et0_total_mm": total_values(raw_values("et0_fao_evapotranspiration")),
+            "water_balance_proxy_total_mm": total_values(feature_values("water_balance_proxy_mm")),
+            "gdd_total": total_values(raw_values("growing_degree_days_base_0_limit_50")),
+            "vpd_mean": mean_values(raw_values("vapour_pressure_deficit_max")),
+            "relative_humidity_mean_pct": mean_values(raw_values("relative_humidity_2m_mean")),
+            "leaf_wetness_mean_fraction": mean_values(feature_values("leaf_wetness_fraction")),
+            "humidity_wetness_interaction_mean": mean_values(feature_values("humidity_wetness_interaction")),
+            "longest_dry_spell_days": max_values(feature_values("dry_spell_days")),
+            "max_wind_speed": max_values(raw_values("wind_speed_10m_max")),
+            "max_wind_gust": max_values(raw_values("wind_gusts_10m_max")),
+            "precip_probability_mean_fraction": mean_values(feature_values("precip_probability_fraction")),
+        }
+
+    history_summary = summarize_period("historical")
+    forecast_summary = summarize_period("forecast")
+
+    comparison_keys = [
+        "temperature_mean_c", "precipitation_total_mm", "et0_total_mm",
+        "water_balance_proxy_total_mm", "gdd_total", "vpd_mean",
+        "relative_humidity_mean_pct", "leaf_wetness_mean_fraction",
+    ]
+    comparison = {}
+    for key in comparison_keys:
+        h, f = history_summary.get(key), forecast_summary.get(key)
+        comparison[key + "_forecast_minus_history"] = f - h if h is not None and f is not None else None
+
+    return {
+        "historical": derived_blocks["historical"],
+        "today": derived_blocks["today"],
+        "forecast": derived_blocks["forecast"],
+        "summary": {
+            "history_7d": history_summary,
+            "forecast_7d": forecast_summary,
+            "forecast_minus_history": comparison,
+        },
+    }
+
+
+def normalize_weather_data(raw_data: Dict, lat: float, lon: float, client_date: str) -> Tuple[Optional[Dict], str]:
+    try:
+        timezone_str = raw_data.get("timezone", "UTC")
+        daily = raw_data["daily"]
+        dates = daily["time"]
+        location_date = dates[7] if len(dates) > 7 else client_date
+
+        def extract_block(start: int, end: Optional[int]) -> Dict:
+            time_slice = dates[start:end]
+            if not time_slice:
+                return {}
+            block = {"time": time_slice}
+            for var in WEATHER_VARIABLES:
+                block[var] = daily.get(var, [])[start:end]
+            return block
+
+        historical = extract_block(0, 7)
+        today = extract_block(7, 8)
+        forecast = extract_block(8, None)
+
+        units = raw_data.get("daily_units", {}) or {}
+        units_filtered = {k: v for k, v in units.items() if k != "time"}
+
+        normalized = {
+            "meta": {
+                "location": {
+                    "latitude": raw_data.get("latitude", lat),
+                    "longitude": raw_data.get("longitude", lon),
+                    "timezone": timezone_str,
+                    "elevation_m": raw_data.get("elevation"),
+                },
+                "client_date": client_date,
+                "location_date": location_date,
+                "analysis_period": {
+                    "historical": f"{len(historical.get('time', []))} days",
+                    "forecast": f"{len(forecast.get('time', []))} days",
+                    "anchor_date": client_date,
+                },
+            },
+            "units": units_filtered,
+            "historical": historical,
+            "today": today,
+            "forecast": forecast,
+        }
+        normalized["derived_features"] = engineer_weather_features(normalized)
+        return normalized, ""
+
+    except Exception as e:
+        logger.error(f"Normalization error: {e}")
+        return None, "Failed to process weather data. Please try again later."
+
+
+# ------------------------------------------------------------------
+# LLM ENGINE
+# ------------------------------------------------------------------
+DERIVED_FEATURE_GUIDE = {
+    "temperature_range_c": "Daily maximum temperature minus minimum temperature.",
+    "dewpoint_depression_proxy_c": "Mean air temperature minus mean dewpoint.",
+    "water_balance_proxy_mm": "Precipitation minus reference ET0; not soil water balance.",
+    "precipitation_per_wet_hour_proxy":
+        "Daily precipitation divided by precipitation hours; not peak rainfall intensity.",
+    "humidity_wetness_interaction":
+        "Relative humidity fraction multiplied by leaf-wetness probability fraction; not disease probability.",
+    "wetness_duration_interaction":
+        "Leaf-wetness probability multiplied by precipitation hours divided by 24; "
+        "not measured leaf-wetness duration.",
+    "dry_spell_days":
+        "Consecutive days with precipitation at or below 0.1 mm; not a crop-specific drought threshold.",
+    "rolling_features":
+        "Trailing 3-day and 7-day sums or means. Windows span the continuous history, today, "
+        "and forecast timeline.",
+    "delta_vs_history7d":
+        "Forecast daily value minus the mean of available historical daily values over the previous 7 days.",
+    "forecast_minus_history":
+        "Difference between the 7-day forecast summary and the 7-day historical summary.",
+    "probability_fraction":
+        "Normalized to a 0-1 scale when the source unit is percent. Null means unavailable, not zero.",
+}
+
+
+def build_llm_payload(normalized_data: Dict, lat: float, lon: float, client_date: str,
+                      crop: str = "", phenology: str = "", notes: str = "",
+                      current_concern: str = "", has_image: bool = False) -> Dict:
+    meta = normalized_data.get("meta", {})
+    location = meta.get("location", {})
+    tz = location.get("timezone", "UTC")
+    return {
+        "location": {"latitude": lat, "longitude": lon, "timezone": tz},
+        "field_context": {
+            "crop_type": crop or "Tidak ditentukan",
+            "phenology_phase": phenology or "Tidak ditentukan",
+            "field_notes": notes or "Tidak ada catatan khusus",
+            "current_concern": current_concern or "Tidak ada concern khusus",
+        },
+        "user_image": {
+            "provided": has_image,
+            "note": "Foto lahan/tanaman dari pengguna terlampir (dikompresi, belum diverifikasi)."
+                    if has_image else "Tidak ada foto.",
+        },
+        "analysis_period": {
+            "historical": meta.get("analysis_period", {}).get("historical", "7 days"),
+            "forecast": meta.get("analysis_period", {}).get("forecast", "7 days"),
+            "anchor_date": client_date,
+            "anchor_type": "client_time",
+            "location_date": meta.get("location_date", client_date),
+            "location_timezone": tz,
+        },
+        "units": normalized_data.get("units", {}),
+        "derived_features": normalized_data.get("derived_features", {}),
+        "derived_feature_guide": DERIVED_FEATURE_GUIDE,
+        "historical": {"daily": normalized_data.get("historical", {})},
+        "today": {"daily": normalized_data.get("today", {})},
+        "forecast": {"daily": normalized_data.get("forecast", {})},
+    }
+
+
+def _build_messages(system_prompt: str, payload: Dict, image_data_url: Optional[str]) -> List[Dict]:
+    text = "Weather data for analysis:\n\n" + json.dumps(
+        payload, ensure_ascii=False, separators=(",", ":")
+    )
+    if image_data_url:
+        user_content: Any = [
+            {"type": "text", "text": text},
+            {"type": "image_url", "image_url": {"url": image_data_url}},
+        ]
+    else:
+        user_content = text
+    return [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_content},
+    ]
+
+
+def _extract_json(content: str) -> Dict:
+    m = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", content)
+    if m:
+        content = m.group(1)
+    content = content.strip()
+    start, end = content.find("{"), content.rfind("}")
+    if start != -1 and end != -1:
+        content = content[start:end + 1]
+    return json.loads(content)
+
+
+def call_gemini(payload: Dict, image_data_url: Optional[str] = None) -> Tuple[Optional[Dict], str]:
+    system_prompt = get_system_prompt()
+    if not system_prompt:
+        return None, "System prompt file is missing or empty. Please check prompts/system_prompt.txt"
+
+    use_image = bool(image_data_url)
+    messages = _build_messages(system_prompt, payload, image_data_url)
+    last_error_msg = "Unknown error"
+    deadline = time.monotonic() + GEMINI_TOTAL_BUDGET_S
+
+    for attempt in range(GEMINI_MAX_ROUNDS):
+        saw_rpm = False
+
+        for key in key_manager.get_rotation_order():
+            if time.monotonic() > deadline:
+                last_error_msg = "Batas waktu analisis terlampaui."
+                break
+            if not key_manager._is_available(key):
+                continue
+
+            try:
+                response = completion(
+                    model=GEMINI_MODEL,
+                    messages=messages,
+                    api_key=key,
+                    temperature=1.0,
+                    max_tokens=4000,
+                    timeout=GEMINI_TIMEOUT_IMAGE_S if use_image else GEMINI_TIMEOUT_S,
+                )
+                return _extract_json(response.choices[0].message.content), ""
+
+            except json.JSONDecodeError as e:
+                logger.error(f"JSON decode error: {e}")
+                return None, "Analysis could not be validated. Please try again. (Invalid JSON)"
+
+            except Exception as e:
+                kind = classify_gemini_error(e)
+                logger.warning(f"Key ...{key[-6:]} gagal ({kind}): {e}")
+                if kind == "rpd":
+                    key_manager.mark_rpd_exhausted(key)
+                    last_error_msg = "Satu atau lebih API key mencapai limit harian."
+                elif kind == "rpm":
+                    saw_rpm = True
+                    last_error_msg = "Key sedang sibuk (limit per menit)."
+                else:
+                    last_error_msg = str(e)
+                    if use_image:  # mungkin gambar yang ditolak -> coba tanpa gambar
+                        use_image = False
+                        messages = _build_messages(system_prompt, payload, None)
+
+        if not saw_rpm or time.monotonic() > deadline:
+            break
+        time.sleep(2 * (attempt + 1) + random.random())  # backoff + jitter
+
+    return None, (
+        "Weather data was retrieved, but the analysis could not be generated. "
+        f"Semua API key gagal atau kena limit. ({last_error_msg})"
+    )
+
+
+def validate_llm_output(output: Any) -> Tuple[bool, str]:
+    if not isinstance(output, dict):
+        return False, "Analysis could not be validated. Invalid output format."
+
+    for field in ["summary", "historical", "forecast", "risks", "recommendations", "overall_confidence"]:
+        if field not in output:
+            return False, f"Analysis could not be validated. Missing field: {field}"
+
+    for name in ("historical", "forecast"):
+        block = output.get(name)
+        if not isinstance(block, dict):
+            return False, f"Analysis could not be validated. Invalid {name} format."
+        if "condition" not in block or "impact" not in block:
+            return False, f"Analysis could not be validated. {name.title()} missing condition or impact."
+
+    if not isinstance(output["risks"], list):
+        return False, "Analysis could not be validated. Invalid risks format."
+    for i, risk in enumerate(output["risks"]):
+        if not isinstance(risk, dict):
+            return False, f"Analysis could not be validated. Invalid risk at index {i}."
+        for rf in ["title", "description", "evidence", "period", "severity"]:
+            if rf not in risk:
+                return False, f"Analysis could not be validated. Risk {i} missing field: {rf}"
+        if risk.get("severity") not in VALID_SEVERITY:
+            return False, f"Analysis could not be validated. Invalid severity: {risk.get('severity')}"
+
+    if not isinstance(output["recommendations"], list):
+        return False, "Analysis could not be validated. Invalid recommendations format."
+    for i, rec in enumerate(output["recommendations"]):
+        if not isinstance(rec, dict):
+            return False, f"Analysis could not be validated. Invalid recommendation at index {i}."
+        for rf in ["action", "reason", "priority"]:
+            if rf not in rec:
+                return False, f"Analysis could not be validated. Recommendation {i} missing field: {rf}"
+        if rec.get("priority") not in VALID_PRIORITY:
+            return False, f"Analysis could not be validated. Invalid priority: {rec.get('priority')}"
+
+    if output.get("overall_confidence") not in VALID_CONFIDENCE:
+        return False, "Analysis could not be validated. Invalid overall_confidence."
+
+    return True, ""
+
+
+# ------------------------------------------------------------------
+# EXPORT
+# ------------------------------------------------------------------
+def cleanup_exports(max_age_s: int = EXPORT_MAX_AGE_S) -> None:
+    """Hapus file export lama agar /tmp tidak penuh."""
+    try:
+        now = time.time()
+        for name in os.listdir(EXPORT_DIR):
+            if not name.startswith("weather_analysis_"):
+                continue
+            path = os.path.join(EXPORT_DIR, name)
+            try:
+                if now - os.path.getmtime(path) > max_age_s:
+                    os.remove(path)
+            except OSError:
+                pass
+    except FileNotFoundError:
+        pass
+    except Exception as e:
+        logger.warning(f"Export cleanup failed: {e}")
+
+
+def build_export_file(cache_entry: Optional[Dict]) -> Optional[str]:
+    """
+    Satu file TXT berisi input pengguna, data cuaca mentah, fitur turunan,
+    dan hasil analisis Gemini, untuk dipakai sebagai context di LLM lain.
+    Foto pengguna TIDAK disertakan (memang tidak disimpan).
+    """
+    if not cache_entry:
+        return None
+
+    location = cache_entry.get("location", {}) or {}
+    field_context = cache_entry.get("field_context", {}) or {}
+    analysis = cache_entry.get("analysis", {}) or {}
+
+    lines: List[str] = [
+        "=== EXPORT DATA ANALISIS CUACA ===",
+        f"Dibuat pada : {datetime.now(timezone.utc).isoformat()}",
+        "Tujuan      : Context data untuk analisis lanjutan",
+        "Sumber App  : DigiTanist/tanam",
+        "",
+        "--- INPUT PENGGUNA ---",
+        f"Latitude       : {location.get('latitude')}",
+        f"Longitude      : {location.get('longitude')}",
+        f"Sumber lokasi  : {location.get('source') or '-'}",
+    ]
+    if location.get("accuracy_m"):
+        lines.append(f"Akurasi GPS    : {location.get('accuracy_m')} m")
+    lines += [
+        f"Tanggal analisis    : {cache_entry.get('client_date')}",
+        f"Timezone lokasi     : {cache_entry.get('location_timezone')}",
+        "",
+        "Konteks Lahan:",
+        f"- Jenis Tanaman     : {field_context.get('crop_type') or '-'}",
+        f"- Fase Fenologi     : {field_context.get('phenology_phase') or '-'}",
+        f"- Catatan Lapangan  : {field_context.get('field_notes') or '-'}",
+        f"- Current Concern   : {field_context.get('current_concern') or '-'}",
+        "",
+        "--- DATA CUACA MENTAH (Open-Meteo, historical 7 hari + forecast 7 hari) ---",
+        json.dumps(cache_entry.get("raw_weather", {}), ensure_ascii=False, indent=2),
+        "",
+        "--- FITUR CUACA TURUNAN ---",
+        json.dumps(cache_entry.get("derived_features", {}), ensure_ascii=False, indent=2),
+        "",
+        "--- HASIL ANALISIS GEMINI AI ---",
+        f"Ringkasan: {analysis.get('summary', '-')}",
+        "",
+    ]
+
+    hist = analysis.get("historical", {}) or {}
+    lines += [
+        "Historical (7 hari terakhir):",
+        f"  Kondisi : {hist.get('condition', '-')}",
+        f"  Dampak  : {hist.get('impact', '-')}",
+        "",
+    ]
+
+    fcst = analysis.get("forecast", {}) or {}
+    lines += [
+        "Forecast (7 hari ke depan):",
+        f"  Kondisi : {fcst.get('condition', '-')}",
+        f"  Dampak  : {fcst.get('impact', '-')}",
+        "",
+    ]
+
+    risks = [r for r in (analysis.get("risks") or []) if isinstance(r, dict)]
+    lines.append(f"Risiko ({len(risks)}):")
+    if risks:
+        for i, r in enumerate(risks, 1):
+            lines.append(f"  {i}. {r.get('title', '-')} [severity: {r.get('severity', '-')}]")
+            lines.append(f"     Deskripsi : {r.get('description', '-')}")
+            lines.append(f"     Bukti     : {r.get('evidence', '-')}")
+            lines.append(f"     Periode   : {r.get('period', '-')}")
+    else:
+        lines.append("  Tidak ada risiko signifikan.")
+    lines.append("")
+
+    recs = analysis.get("recommendations") or []
+    lines.append(f"Rekomendasi ({len(recs)}):")
+    if recs:
+        for i, r in enumerate(recs, 1):
+            if isinstance(r, str):
+                lines.append(f"  {i}. {r}")
+                continue
+            lines.append(f"  {i}. {r.get('action', '-')} [priority: {r.get('priority', '-')}]")
+            lines.append(f"     Alasan : {r.get('reason', '-')}")
+    else:
+        lines.append("  Tidak ada tindakan khusus diperlukan.")
+    lines += ["", f"Overall Confidence: {analysis.get('overall_confidence', '-')}"]
+
+    try:
+        os.makedirs(EXPORT_DIR, exist_ok=True)
+        cleanup_exports()
+        date_tag = (cache_entry.get("client_date") or "unknown").replace("-", "")
+        path = os.path.join(EXPORT_DIR, f"weather_analysis_{date_tag}_{uuid.uuid4().hex[:8]}.txt")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines))
+        return path
+    except Exception as e:
+        logger.error(f"Failed to build export file: {e}")
+        return None
+
+
+# ------------------------------------------------------------------
+# MAIN HANDLERS
+# ------------------------------------------------------------------
+def init_app(composite_json: str):
+    cache_entry = None
+    browser_date = None
+    browser_timezone = "UTC"
+
+    if composite_json and composite_json.strip() and composite_json != "{}":
+        try:
+            parsed = json.loads(composite_json)
+            if isinstance(parsed, dict):
+                if "browser_date" in parsed:  # format baru (composite dari JS)
+                    cache_raw = parsed.get("cache", "{}")
+                    browser_date = parsed.get("browser_date")
+                    browser_timezone = parsed.get("browser_timezone", "UTC")
+                    if isinstance(cache_raw, str) and cache_raw.strip() and cache_raw != "{}":
+                        cache_parsed = json.loads(cache_raw)
+                        if isinstance(cache_parsed, dict) and "analysis" in cache_parsed:
+                            cache_entry = cache_parsed
+                elif "analysis" in parsed:  # format lama
+                    cache_entry = parsed
+        except Exception:
+            cache_entry = None
+
+    if not browser_date:
+        browser_date = datetime.now().strftime("%Y-%m-%d")
+        browser_timezone = "UTC"
+
+    # Bandingkan cache dengan TANGGAL BROWSER, bukan tanggal server
+    today_cache = cache_entry if (cache_entry and cache_entry.get("client_date") == browser_date) else None
+
+    state = AppState(
+        state=STATE_READY,
+        client_date=browser_date,
+        client_timezone=browser_timezone,
+        browser_date=browser_date,
+        browser_timezone=browser_timezone,
+        cache=today_cache,
+    )
+
+    if today_cache:
+        state.state = STATE_LOCKED_TODAY
+        location = today_cache.get("location") or {}
+        state.location = location or None
+        analysis = today_cache.get("analysis", {})
+        return (
+            state.to_dict(),
+            location.get("latitude", 0), location.get("longitude", 0),
+            gr.update(interactive=False), gr.update(interactive=False),
+            format_status(STATE_LOCKED_TODAY, "Today's analysis already exists."),
+            "",
+            format_cache_info(today_cache),
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            *render_all_tabs(analysis),
+            gr.update(value=""),
+        )
+
+    return (
+        state.to_dict(), 0, 0,
+        gr.update(interactive=True), gr.update(interactive=False),
+        format_status(STATE_READY),
+        "",
+        "",
+        gr.update(visible=True),
+        gr.update(visible=False),
+        gr.update(visible=False),
+        *render_all_tabs({}),
+        gr.update(value=""),
+    )
+
+
+def handle_gps_result(gps_json: str, state_dict: Dict):
+    state = AppState.from_dict(state_dict)
+
+    if not gps_json:
+        return state.to_dict(), 0, 0, format_status(STATE_ERROR, "No location data received.")
+
+    try:
+        data = json.loads(gps_json)
+    except Exception:
+        return state.to_dict(), 0, 0, format_status(STATE_ERROR, "Invalid location data.")
+
+    if "error" in data:
+        return state.to_dict(), 0, 0, format_status(STATE_ERROR, data["error"])
+
+    lat = data.get("latitude")
+    lon = data.get("longitude")
+    source = data.get("source", "unknown")
+    accuracy = data.get("accuracy_m")
+
+    valid, msg = validate_coordinates(lat, lon)
+    if not valid:
+        return state.to_dict(), 0, 0, format_status(STATE_ERROR, msg)
+
+    state.location = {"latitude": lat, "longitude": lon, "source": source, "accuracy_m": accuracy}
+    state.state = STATE_LOCATION_READY
+    return state.to_dict(), lat, lon, format_location_status(source, accuracy)
+
+
+def _analysis_pipeline(state: AppState, weather_json_str: str, lat, lon, crop, phenology,
+                       notes, current_concern, image_path):
+    """Generator utama. `state` dimutasi di sini dan dikirim balik lewat yield."""
+
+    # --- Input kosong: tidak ada yang diubah ---
+    if not weather_json_str:
+        yield (state.to_dict(),) + tuple(gr.update() for _ in range(14))
+        return
+
+    # --- Sudah ada analisis hari ini: jangan jalankan lagi ---
+    client_date = state.browser_date or datetime.now().strftime("%Y-%m-%d")
+    state.client_date = client_date
+    existing = state.cache
+    if existing and existing.get("client_date") == client_date:
+        state.state = STATE_LOCKED_TODAY
+        yield ui_outputs(
+            state, lock_inputs=True,
+            status=format_status(STATE_LOCKED_TODAY, "Today's analysis already exists."),
+            cache_info=format_cache_info(existing),
+            show_placeholder=False, show_view_btn=True,
+            tabs=render_all_tabs(existing.get("analysis", {})),
+        )
+        return
+
+    if state.is_analyzing:
+        yield (state.to_dict(),) + tuple(gr.update() for _ in range(14))
+        return
+
+    # --- Parse & validasi data cuaca dari browser ---
+    try:
+        raw_weather = json.loads(weather_json_str)
+    except Exception as exc:
+        yield error_outputs(state, STATE_FETCHING_WEATHER, f"Failed to parse weather data: {exc}")
+        return
+
+    if isinstance(raw_weather, dict) and "error" in raw_weather:
+        err = raw_weather.get("reason") or raw_weather["error"]
+        yield error_outputs(state, STATE_FETCHING_WEATHER, str(err))
+        return
+
+    valid_weather = validate_weather_payload(raw_weather)
+    if valid_weather:
+        yield error_outputs(state, STATE_FETCHING_WEATHER, valid_weather)
+        return
+    raw_weather.pop("_client_ts", None)
+
+    valid_coords, coord_msg = validate_coordinates(lat, lon)
+    if not valid_coords:
+        yield error_outputs(state, STATE_FETCHING_WEATHER, coord_msg)
+        return
+
+    prev = state.location or {}
+    state.location = {
+        "latitude": lat,
+        "longitude": lon,
+        "source": prev.get("source", "manual"),
+        "accuracy_m": prev.get("accuracy_m"),
+    }
+    state.is_analyzing = True
+
+    # --- Step 2: proses data + foto ---
+    yield progress_outputs(
+        state, STATE_PROCESSING_DATA, "Processing weather data",
+        "Splitting historical and forecast windows and computing derived indices.",
+    )
+
+    normalized, norm_error = normalize_weather_data(raw_weather, lat, lon, client_date)
+    if norm_error:
+        yield error_outputs(state, STATE_PROCESSING_DATA, norm_error)
+        return
+
+    image_data_url, image_err = compress_image_to_data_url(image_path)
+    if image_err:
+        logger.info(f"Lanjut tanpa foto: {image_err}")
+
+    # --- Step 3: Gemini ---
+    yield progress_outputs(
+        state, STATE_GENERATING_INSIGHT, "Generating weather insight",
+        "Gemini is interpreting the data for risks and recommendations.",
+    )
+
+    payload = build_llm_payload(
+        normalized, lat, lon, client_date, crop, phenology, notes, current_concern,
+        has_image=bool(image_data_url),
+    )
+    llm_output, gemini_error = call_gemini(payload, image_data_url)
+    image_data_url = None  # lepas dari memori
+    payload = None
+
+    if gemini_error:
+        yield error_outputs(state, STATE_GENERATING_INSIGHT, gemini_error)
+        return
+
+    # --- Step 4: validasi ---
+    yield progress_outputs(
+        state, STATE_VALIDATING_OUTPUT, "Validating analysis",
+        "Checking the response against the expected schema.",
+    )
+
+    valid, val_error = validate_llm_output(llm_output)
+    if not valid:
+        yield error_outputs(state, STATE_VALIDATING_OUTPUT, val_error)
+        return
+
+    # --- Selesai: simpan SATU entry cache (tanpa foto) ---
+    cache_entry = {
+        "location": state.location,
+        "client_date": client_date,
+        "location_date": normalized.get("meta", {}).get("location_date", client_date),
+        "location_timezone": raw_weather.get("timezone", "UTC"),
+        "client_timezone": state.client_timezone or "UTC",
+        "field_context": {
+            "crop_type": crop,
+            "phenology_phase": phenology,
+            "field_notes": notes,
+            "current_concern": current_concern,
+        },
+        "raw_weather": raw_weather,
+        "derived_features": normalized.get("derived_features", {}),
+        "analysis": llm_output,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+    }
+    state.cache = cache_entry
+    state.is_analyzing = False
+    cache_json = json.dumps(cache_entry)
+    tabs = render_all_tabs(llm_output)
+
+    state.state = STATE_COMPLETED
+    yield ui_outputs(
+        state, lock_inputs=True,
+        status=format_status(STATE_COMPLETED), step=format_progress(STATE_COMPLETED),
+        cache_info=format_cache_info(cache_entry),
+        show_placeholder=False, show_view_btn=True, tabs=tabs, cache_json=cache_json,
+    )
+
+    state.state = STATE_LOCKED_TODAY
+    yield ui_outputs(
+        state, lock_inputs=True,
+        status=format_status(STATE_LOCKED_TODAY, "Today's analysis complete. Return tomorrow for a new analysis."),
+        cache_info=format_cache_info(cache_entry),
+        show_placeholder=False, show_view_btn=True, tabs=tabs, cache_json=cache_json,
+    )
+
+
+def handle_weather_and_analyze(weather_json_str: str, lat: float, lon: float, crop: str,
+                               phenology: str, notes: str, current_concern: str,
+                               image_path: Optional[str], state_dict: Dict):
+    state = AppState.from_dict(state_dict)
+    try:
+        yield from _analysis_pipeline(
+            state, weather_json_str, lat, lon, crop, phenology, notes, current_concern, image_path
+        )
+    except Exception:
+        logger.exception("Unexpected error in analysis pipeline")
+        yield error_outputs(state, state.state, "Terjadi kesalahan tak terduga. Silakan coba lagi.")
+
+
+# ------------------------------------------------------------------
+# GRADIO UI (Gradio 6.x compatible)
+# ------------------------------------------------------------------
+THEME = gr.themes.Base(
+    font=[gr.themes.GoogleFont("IBM Plex Sans"), "sans-serif"],
+    font_mono=[gr.themes.GoogleFont("IBM Plex Mono"), "monospace"],
+).set(
+    body_background_fill="#0B1B22",
+    body_background_fill_dark="#0B1B22",
+    body_text_color="#E7F1F0",
+    body_text_color_dark="#E7F1F0",
+    body_text_color_subdued="#7E9CA3",
+    body_text_color_subdued_dark="#7E9CA3",
+    background_fill_primary="#122631",
+    background_fill_primary_dark="#122631",
+    background_fill_secondary="#0F2229",
+    background_fill_secondary_dark="#0F2229",
+    border_color_primary="#23414F",
+    border_color_primary_dark="#23414F",
+    block_background_fill="#122631",
+    block_background_fill_dark="#122631",
+    block_border_color="#23414F",
+    block_border_color_dark="#23414F",
+    block_label_text_color="#7E9CA3",
+    block_label_text_color_dark="#7E9CA3",
+    block_label_background_fill="#122631",
+    block_label_background_fill_dark="#122631",
+    block_title_text_color="#E7F1F0",
+    block_title_text_color_dark="#E7F1F0",
+    panel_background_fill="#0F2229",
+    panel_background_fill_dark="#0F2229",
+    panel_border_color="#23414F",
+    panel_border_color_dark="#23414F",
+    input_background_fill="#0F2229",
+    input_background_fill_dark="#0F2229",
+    input_border_color="#23414F",
+    input_border_color_dark="#23414F",
+    input_border_color_focus="#E8A33D",
+    input_border_color_focus_dark="#E8A33D",
+    button_primary_background_fill="#E8A33D",
+    button_primary_background_fill_dark="#E8A33D",
+    button_primary_background_fill_hover="#F2B457",
+    button_primary_background_fill_hover_dark="#F2B457",
+    button_primary_text_color="#0B1B22",
+    button_primary_text_color_dark="#0B1B22",
+    button_primary_border_color="#E8A33D",
+    button_primary_border_color_dark="#E8A33D",
+    button_secondary_background_fill="#16303D",
+    button_secondary_background_fill_dark="#16303D",
+    button_secondary_background_fill_hover="#1B3945",
+    button_secondary_background_fill_hover_dark="#1B3945",
+    button_secondary_text_color="#E7F1F0",
+    button_secondary_text_color_dark="#E7F1F0",
+    button_secondary_border_color="#23414F",
+    button_secondary_border_color_dark="#23414F",
+    error_background_fill="#2A1714",
+    error_background_fill_dark="#2A1714",
+    error_border_color="#E2604F",
+    error_border_color_dark="#E2604F",
+)
+
+# ------------------------------------------------------------------
+# EXTERNAL ASSETS
+# ------------------------------------------------------------------
+CSS = load_text("assets/styles.css")
+SPONSORS_RAW = load_json("assets/sponsors.json")
+SPONSOR_HTML = render_sponsors_html(SPONSORS_RAW.get("sponsors", []))
+
+HEADER_HTML = """
+<div class="hero-banner">
+    <div class="app-header">
+        <div class="eyebrow">Field Telemetry &middot; Weather Intelligence</div>
+        <h1>DigiTanist/tanam</h1>
+        <p class="subtitle">Cegah kerugian akibat cuaca buruk lebih lewat pantauan risiko harian berbasis rekam jejak dan prakiraan cuaca 14 hari. Ditenagai BMKG dan Gemini AI.</p>
+    </div>
+
+    <div class="farmer-counter">
+        <span class="farmer-counter-badge">
+            <span class="farmer-counter-dot"></span>
+            <span><strong id="farmer-count">—</strong> petani sudah menganalisis hari ini</span>
+        </span>
+    </div>
+</div>
+"""
+
+FOOTER_HTML = """
+<div class="app-footer">DATA &middot; OPEN-METEO&nbsp;&nbsp;|&nbsp;&nbsp;ANALYSIS &middot; GEMINI&nbsp;&nbsp;|&nbsp;&nbsp;ONE READ PER DAY</div>
+"""
+
+IMAGE_NOTE_HTML = (
+    '<div style="font-size:12px;color:#7E9CA3;margin:-4px 2px 8px;line-height:1.4;">'
+    'Opsional. Foto dikompres lalu dikirim ke Gemini hanya untuk analisis ini, '
+    'tidak disimpan permanen dan tidak masuk file export.'
+    '</div>'
+)
+
+GA4_HEAD = """
+<!-- Google tag (gtag.js) -->
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-VWC31N398K"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-VWC31N398K');
+</script>
+
+<script>
+function getTodayFarmerCount() {
+  // ====================== PENGATURAN ANGKA ======================
+  const BASE_MIN = 220;
+  const BASE_MAX = 380;
+  const INCREASE_PER_10_MIN = 2; // Jumlah penambahan setiap 10 menit (bisa disesuaikan)
+  // ==============================================================
+
+  const now = new Date();
+
+  const today = now.getFullYear() + '-' +
+                String(now.getMonth() + 1).padStart(2, '0') + '-' +
+                String(now.getDate()).padStart(2, '0');
+
+  let seed = 0;
+  for (let i = 0; i < today.length; i++) {
+    seed = (seed * 31 + today.charCodeAt(i)) & 0xffff;
+  }
+
+  const base = BASE_MIN + (seed % (BASE_MAX - BASE_MIN + 1));
+  const totalMinutes = (now.getHours() * 60) + now.getMinutes();
+  const blocksOf10Min = Math.floor(totalMinutes / 10);
+  const extra = blocksOf10Min * INCREASE_PER_10_MIN;
+
+  return base + extra;
+}
+
+function animateCount(el, target, duration = 3300) {
+  const start = Math.max(0, target - Math.floor(target * 0.15)); // mulai dari ~85%
+  const startTime = performance.now();
+  function tick(now) {
+    const progress = Math.min((now - startTime) / duration, 1);
+    const eased = 1 - Math.pow(1 - progress, 3); // ease-out cubic
+    el.innerText = Math.round(start + (target - start) * eased).toLocaleString("id-ID");
+    if (progress < 1) requestAnimationFrame(tick);
+  }
+  requestAnimationFrame(tick);
+}
+
+function updateFarmerCount() {
+  const el = document.getElementById("farmer-count");
+  if (el) {
+    animateCount(el, getTodayFarmerCount());
+    return true;
+  }
+  return false;
+}
+
+// Coba terus sampai elemen muncul (maksimal 10 detik)
+function tryUpdateCounter(attempts = 0) {
+  if (updateFarmerCount() || attempts > 20) return;
+  setTimeout(() => tryUpdateCounter(attempts + 1), 500);
+}
+
+tryUpdateCounter();
+setInterval(updateFarmerCount, 5 * 60 * 1000);
+</script>
+"""
+
+LOAD_JS = """() => {
+    let cache = '{}';
+    try {
+        cache = localStorage.getItem('space_weather_cache') || '{}';
+    } catch (e) {
+        cache = '{}';
+    }
+    const now = new Date();
+    const browserDate = now.getFullYear() + '-' +
+        String(now.getMonth() + 1).padStart(2, '0') + '-' +
+        String(now.getDate()).padStart(2, '0');
+    const browserTz = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    return JSON.stringify({
+        cache: cache,
+        browser_date: browserDate,
+        browser_timezone: browserTz
+    });
+}"""
+
+GPS_JS = """
+async () => {
+    const fail = () => JSON.stringify({
+        error: "Unable to determine your location. Please enter coordinates manually."
+    });
+    const fromIp = async () => {
+        try {
+            const resp = await fetch('https://ipwho.is/');
+            const data = await resp.json();
+            if (data.success) {
+                return JSON.stringify({
+                    latitude: data.latitude, longitude: data.longitude,
+                    source: "ip", accuracy_m: null
+                });
+            }
+        } catch (e) {}
+        return fail();
+    };
+    return new Promise((resolve) => {
+        if (!navigator.geolocation) {
+            fromIp().then(resolve);
+            return;
+        }
+        navigator.geolocation.getCurrentPosition(
+            (position) => resolve(JSON.stringify({
+                latitude: position.coords.latitude,
+                longitude: position.coords.longitude,
+                source: "gps",
+                accuracy_m: position.coords.accuracy
+            })),
+            () => { fromIp().then(resolve); },
+            {timeout: 10000, maximumAge: 60000}
+        );
+    });
+}
+"""
+
+# Daftar variabel disuntik dari WEATHER_VARIABLES supaya JS dan Python selalu sinkron.
+# `_client_ts` membuat setiap klik Analyze menghasilkan string unik, sehingga event
+# `change` pada textbox tersembunyi selalu terpicu (juga saat mencoba ulang setelah error).
+ANALYZE_JS = """async (lat, lon) => {
+    if (typeof gtag === 'function') {
+        gtag('event', 'analyze_click', {
+            'event_category': 'engagement',
+            'latitude': lat,
+            'longitude': lon
+        });
+    }
+    const stamp = (obj) => JSON.stringify(Object.assign({}, obj, {_client_ts: Date.now()}));
+
+    if (lat === null || lon === null || isNaN(lat) || isNaN(lon)) {
+        return stamp({ error: "Invalid coordinates. Please enter a valid latitude and longitude." });
+    }
+
+    const variables = __VARS__.join(",");
+    const url = `https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&daily=${variables}&timezone=auto&past_days=7&forecast_days=7`;
+    try {
+        const resp = await fetch(url);
+        if (!resp.ok) {
+            return stamp({ error: `Weather data unavailable. Please try again later. (HTTP ${resp.status})` });
+        }
+        const data = await resp.json();
+        return stamp(data);
+    } catch (e) {
+        return stamp({ error: "Weather data unavailable. Network error. Please try again later." });
+    }
+}""".replace("__VARS__", json.dumps(WEATHER_VARIABLES))
+
+VIEW_INSIGHT_JS = """() => {
+    if (typeof gtag === 'function') {
+        gtag('event', 'view_insight_click', {'event_category': 'engagement'});
+    }
+}"""
+
+SAVE_CACHE_JS = """(data) => {
+    if (data && data !== '{}' && data !== '') {
+        try {
+            localStorage.setItem('space_weather_cache', data);  // selalu timpa
+        } catch (e) {
+            console.error('Failed to save cache to localStorage:', e);
+        }
+    }
+    return [];
+}"""
+
+
+def show_insight_view(state_dict):
+    state = AppState.from_dict(state_dict)
+    has_cache = bool(state.cache)
+    modal_html = build_recommendation_modal(state.cache, skip_url=SHOPEE_LINK) if has_cache else ""
+    # Tombol download ditampilkan dulu tanpa file; href diisi di langkah berikutnya (.then)
+    # agar elemen sudah ter-mount dan klik pertama langsung bekerja.
+    return (
+        gr.update(visible=False),
+        gr.update(visible=True),
+        gr.update(visible=has_cache, value=None),
+        modal_html,
+    )
+
+
+def prepare_download_file(state_dict):
+    state = AppState.from_dict(state_dict)
+    export_path = build_export_file(state.cache)
+    return gr.update(value=export_path, visible=bool(export_path))
+
+
+def clear_image_after_success(state_dict):
+    """Lepas referensi foto setelah analisis sukses; biarkan jika gagal agar bisa dicoba lagi."""
+    if AppState.from_dict(state_dict).cache:
+        return gr.update(value=None)
+    return gr.update()
+
+
+with gr.Blocks(title="Space Weather", head=GA4_HEAD, delete_cache=(600, 600)) as demo:
+
+    gr.HTML(HEADER_HTML)
+
+    app_state = gr.State({})
+    gps_data = gr.Textbox(visible=False, elem_id="gps_data_input")
+    cache_in = gr.Textbox(visible=False, elem_id="browser_cache_in")
+    cache_out = gr.Textbox(visible=False, elem_id="browser_cache_out")
+    weather_json = gr.Textbox(visible=False, elem_id="weather_json_input")
+
+    with gr.Row(elem_classes=["main-row"]):
+        with gr.Column(scale=1, min_width=320, elem_classes=["rail-col"]):
+            with gr.Column(elem_classes=["console-panel"]):
+                gr.HTML('<div class="panel-eyebrow">Location</div>')
+
+                lat_input = gr.Number(label="Latitude", precision=6, value=0, info="-90 to 90")
+                lon_input = gr.Number(label="Longitude", precision=6, value=0, info="-180 to 180")
+
+                crop_input = gr.Textbox(
+                    label="Jenis Tanaman",
+                    placeholder="Contoh: Padi, Jagung, Cabai",
+                    lines=1,
+                )
+                phenology_input = gr.Textbox(
+                    label="Fase Fenologi",
+                    placeholder="Contoh: Vegetatif, Pembungaan, Pematangan",
+                    lines=1,
+                )
+                notes_input = gr.Textbox(
+                    label="Catatan Lapangan",
+                    placeholder="Contoh: Ada genangan air, gejala serangan hama ringan",
+                    lines=2,
+                )
+                current_concern_input = gr.Textbox(
+                    label="Current Concern",
+                    placeholder="Contoh: Khawatir kekurangan air atau risiko penyakit jamur",
+                    info="Opsional. Masukkan kondisi atau pertanyaan yang ingin diperiksa berdasarkan cuaca.",
+                    lines=2,
+                )
+
+                # Foto opsional: filepath agar bisa didecode hemat memori (PIL draft)
+                image_input = gr.Image(
+                    label="Foto Lahan/Tanaman (Opsional)",
+                    type="filepath",
+                    sources=["upload"],
+                    height=200,
+                )
+                gr.HTML(IMAGE_NOTE_HTML)
+
+                with gr.Row(elem_classes=["btn-row"]):
+                    get_loc_btn = gr.Button("Ambil lokasi dari GPS perangkat", variant="secondary", size="sm")
+                    analyze_btn = gr.Button("Analyze", variant="primary", size="sm", interactive=False)
+
+                with gr.Column():
+                    status_html = gr.HTML("")
+                    step_html = gr.HTML("")
+                    cache_html = gr.HTML("")
+
+        with gr.Column(scale=2, elem_classes=["content-col"]):
+            initial_placeholder = gr.HTML(render_placeholder("Initializing", "Loading today's status..."))
+            view_insight_btn = gr.Button("View Insight", variant="primary", visible=False, size="lg")
+
+            with gr.Column(visible=False) as tabs_container:
+                with gr.Tabs():
+                    with gr.TabItem("Summary"):
+                        summary_html = gr.HTML()
+                    with gr.TabItem("Historical"):
+                        historical_html = gr.HTML()
+                    with gr.TabItem("Forecast"):
+                        forecast_html = gr.HTML()
+                    with gr.TabItem("Risks"):
+                        risks_html = gr.HTML()
+                    with gr.TabItem("Recommendations"):
+                        recommendations_html = gr.HTML()
+
+            download_data_btn = gr.DownloadButton(
+                "Download Data Analisis (TXT)",
+                visible=False,
+                size="md",
+                variant="secondary",
+                elem_classes=["download-data-btn"],
+            )
+
+            gr.HTML('<div style="height: 16px;"></div>')
+            with gr.Column(elem_classes=["console-panel"]):
+                gr.HTML('<div class="panel-eyebrow" style="padding: 14px 14px 6px;">Supported By</div>')
+                gr.HTML(SPONSOR_HTML)
+
+    modal_output = gr.HTML("", elem_id="modal-output")
+    gr.HTML(FOOTER_HTML)
+
+    # 1. Page load: baca localStorage + waktu browser
+    demo.load(fn=None, js=LOAD_JS, outputs=cache_in)
+
+    # 2. Inisialisasi app dari cache browser
+    cache_in.change(
+        fn=init_app,
+        inputs=[cache_in],
+        outputs=[
+            app_state, lat_input, lon_input, get_loc_btn, analyze_btn,
+            status_html, step_html, cache_html,
+            initial_placeholder, view_insight_btn, tabs_container,
+            summary_html, historical_html, forecast_html, risks_html, recommendations_html,
+            cache_out,
+        ],
+    )
+
+    # 3. Lokasi: GPS -> fallback IP
+    get_loc_btn.click(fn=None, js=GPS_JS, outputs=gps_data)
+    gps_data.change(
+        fn=handle_gps_result,
+        inputs=[gps_data, app_state],
+        outputs=[app_state, lat_input, lon_input, status_html],
+    )
+
+    # 4. Analyze: browser fetch Open-Meteo -> textbox tersembunyi -> server
+    analyze_btn.click(fn=None, js=ANALYZE_JS, inputs=[lat_input, lon_input], outputs=[weather_json])
+
+    analysis_event = weather_json.change(
+        fn=handle_weather_and_analyze,
+        inputs=[
+            weather_json, lat_input, lon_input, crop_input, phenology_input,
+            notes_input, current_concern_input, image_input, app_state,
+        ],
+        outputs=[
+            app_state, get_loc_btn, analyze_btn,
+            status_html, step_html, cache_html,
+            initial_placeholder, view_insight_btn, tabs_container,
+            summary_html, historical_html, forecast_html, risks_html, recommendations_html,
+            cache_out,
+        ],
+        concurrency_limit=CONCURRENCY_LIMIT,
+        concurrency_id="gemini_analysis",
+    )
+    analysis_event.then(
+        fn=clear_image_after_success,
+        inputs=[app_state],
+        outputs=[image_input],
+        show_progress="hidden",
+    )
+
+    lat_input.change(fn=validate_coordinates_ui, inputs=[lat_input, lon_input, app_state], outputs=[analyze_btn])
+    lon_input.change(fn=validate_coordinates_ui, inputs=[lat_input, lon_input, app_state], outputs=[analyze_btn])
+
+    # 5. View Insight (+ modal rekomendasi + file download)
+    view_insight_btn.click(
+        fn=show_insight_view,
+        inputs=[app_state],
+        js=VIEW_INSIGHT_JS,
+        outputs=[view_insight_btn, tabs_container, download_data_btn, modal_output],
+    ).then(
+        fn=prepare_download_file,
+        inputs=[app_state],
+        outputs=[download_data_btn],
+    )
+
+    # 6. Simpan cache ke localStorage (timpa data lama)
+    cache_out.change(fn=None, js=SAVE_CACHE_JS, inputs=[cache_out])
+
+
+demo.queue(default_concurrency_limit=10, max_size=100)
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        theme=THEME,
+        css=CSS,
+        allowed_paths=["assets"],
+        max_threads=60,
+        max_file_size=MAX_UPLOAD_SIZE,
+    )

image_utils.py

@@ -0,0 +1,42 @@
+import base64
+import io
+import logging
+from typing import Optional, Tuple
+
+from PIL import Image, ImageOps
+
+logger = logging.getLogger(__name__)
+
+MAX_SIDE = 768            # sisi terpanjang setelah resize
+JPEG_QUALITIES = (72, 60, 50)
+MAX_OUTPUT_BYTES = 200_000
+MAX_PIXELS = 40_000_000   # tolak gambar raksasa (decompression bomb)
+Image.MAX_IMAGE_PIXELS = MAX_PIXELS
+
+
+def compress_image_to_data_url(path: Optional[str]) -> Tuple[Optional[str], str]:
+    """Return (data_url, error). Semua di memori; tidak ada file baru ditulis."""
+    if not path:
+        return None, ""
+    try:
+        with Image.open(path) as src:
+            if src.width * src.height > MAX_PIXELS:
+                return None, "Resolusi foto terlalu besar."
+            src.draft("RGB", (MAX_SIDE * 2, MAX_SIDE * 2))  # percepat decode JPEG
+            img = ImageOps.exif_transpose(src)               # perbaiki rotasi HP
+            img = img.convert("RGB")
+            img.thumbnail((MAX_SIDE, MAX_SIDE), Image.Resampling.LANCZOS)
+
+            data = b""
+            for q in JPEG_QUALITIES:
+                buf = io.BytesIO()
+                img.save(buf, "JPEG", quality=q, optimize=True)  # EXIF/GPS tidak ikut
+                data = buf.getvalue()
+                if len(data) <= MAX_OUTPUT_BYTES:
+                    break
+
+        b64 = base64.b64encode(data).decode("ascii")
+        return f"data:image/jpeg;base64,{b64}", ""
+    except Exception as e:
+        logger.warning(f"Image compress failed: {e}")
+        return None, "Foto tidak dapat diproses."