knn e melhorias esteticas

backend/app/api/elaboracao.py

@@ -126,6 +126,10 @@ class AvaliacaoPayload(SessionPayload):
     indice_base: str | None = None
 
 
+class AvaliacaoKnnDetalhesPayload(SessionPayload):
+    valores_x: dict[str, Any]
+
+
 class AvaliacaoDeletePayload(SessionPayload):
     indice: str | None = None
     indice_base: str | None = None
@@ -384,6 +388,21 @@ def evaluation_calculate(payload: AvaliacaoPayload, request: Request) -> dict[st
     return resposta
 
 
+@router.post("/evaluation/knn-details")
+def evaluation_knn_details(payload: AvaliacaoKnnDetalhesPayload, request: Request) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    user = auth_service.require_user(request)
+    resposta = elaboracao_service.detalhes_knn_avaliacao_elaboracao(session, payload.valores_x)
+    log_event(
+        "elaboracao",
+        "avaliacao_knn_detalhes",
+        user=user,
+        session_id=payload.session_id,
+        request=request,
+    )
+    return resposta
+
+
 @router.post("/evaluation/clear")
 def evaluation_clear(payload: SessionPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)

backend/app/api/visualizacao.py

@@ -28,6 +28,10 @@ class AvaliacaoPayload(SessionPayload):
     indice_base: str | None = None
 
 
+class AvaliacaoKnnDetalhesPayload(SessionPayload):
+    valores_x: dict[str, Any]
+
+
 class AvaliacaoDeletePayload(SessionPayload):
     indice: str | None = None
     indice_base: str | None = None
@@ -122,6 +126,21 @@ def evaluation_calculate(payload: AvaliacaoPayload, request: Request) -> dict[st
     return resposta
 
 
+@router.post("/evaluation/knn-details")
+def evaluation_knn_details(payload: AvaliacaoKnnDetalhesPayload, request: Request) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    user = auth_service.require_user(request)
+    resposta = visualizacao_service.detalhes_knn_avaliacao(session, payload.valores_x)
+    log_event(
+        "visualizacao",
+        "avaliacao_knn_detalhes",
+        user=user,
+        session_id=payload.session_id,
+        request=request,
+    )
+    return resposta
+
+
 @router.post("/evaluation/clear")
 def evaluation_clear(payload: SessionPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)

backend/app/core/elaboracao/core.py

@@ -2209,6 +2209,7 @@ def exportar_avaliacoes_excel(avaliacoes_lista):
             valores.append(aval["valores_x"].get(var, ""))
         # Métricas
         valores.append(aval["estimado"])
+        valores.append(aval.get("knn_estimado"))
         valores.append(aval["ca_inf"])
         valores.append(aval["ca_sup"])
         valores.append(aval["ic_inf"])
@@ -2221,7 +2222,7 @@ def exportar_avaliacoes_excel(avaliacoes_lista):
         dados[col_name] = valores
 
     indice = colunas_x + [
-        "Estimado", "CA −15%", "CA +15%",
+        "Estimado", "Estimativa KNN", "CA −15%", "CA +15%",
         "IC 80% Inf.", "IC 80% Sup.",
         "% Inf.", "% Sup.", "Amplitude",
         "Precisão", "Fundamentação",

backend/app/core/elaboracao/formatadores.py

@@ -584,6 +584,65 @@ def _popup_fronteira_html(aval):
     )
 
 
+def _popup_knn_html(aval):
+    """Gera conteúdo HTML do popup para a linha 'Estimativa KNN'."""
+
+    disponivel = bool(aval.get("knn_disponivel"))
+    estimado = _formatar_brl(aval.get("knn_estimado"))
+    motivo = str(aval.get("knn_motivo") or "").strip()
+    colunas = ", ".join(str(c) for c in (aval.get("knn_colunas") or [])) or "—"
+    k = aval.get("knn_k")
+    n_validos = aval.get("knn_n_validos")
+    usa_geo = bool(aval.get("knn_geo_aplicado"))
+    alpha_geo = aval.get("knn_alpha_geo")
+
+    if not disponivel or estimado == "—":
+        motivo_txt = motivo or "Nao foi possivel calcular a estimativa KNN para esta avaliacao."
+        return (
+            '<div style="font-weight: 600; margin-bottom: 4px; color: #495057;">'
+            'Estimativa KNN</div>'
+            f'<div style="font-size: 11px; color: #6c757d; line-height: 1.45;">{motivo_txt}</div>'
+        )
+
+    metodo = "Caracteristicas + localizacao" if usa_geo else "Somente caracteristicas"
+    alpha_txt = f"{float(alpha_geo):.2f}".replace(".", ",") if alpha_geo is not None else "—"
+    motivo_extra = (
+        f'<div style="margin-top: 4px; font-size: 11px; color: #6c757d;">{motivo}</div>'
+        if (motivo and not usa_geo)
+        else ""
+    )
+
+    return (
+        '<div style="font-weight: 600; margin-bottom: 4px; color: #495057;">'
+        'Estimativa KNN</div>'
+        f'<div style="font-size: 11px; color: #6c757d; margin-bottom: 6px; line-height: 1.45;">'
+        f'Valor estimado por KNN: <b>{estimado}</b></div>'
+        '<table style="width: 100%; border-collapse: collapse; font-size: 11px;">'
+        '<tr style="border-bottom: 1px solid #f0f0f0;">'
+        '<td style="padding: 2px 6px; color: #6c757d;">Metodo</td>'
+        f'<td style="padding: 2px 6px; text-align: right;"><b>{metodo}</b></td>'
+        '</tr>'
+        '<tr style="border-bottom: 1px solid #f0f0f0;">'
+        '<td style="padding: 2px 6px; color: #6c757d;">k dinamico</td>'
+        f'<td style="padding: 2px 6px; text-align: right;"><b>{k if k is not None else "—"}</b></td>'
+        '</tr>'
+        '<tr style="border-bottom: 1px solid #f0f0f0;">'
+        '<td style="padding: 2px 6px; color: #6c757d;">Base valida</td>'
+        f'<td style="padding: 2px 6px; text-align: right;"><b>{n_validos if n_validos is not None else "—"}</b></td>'
+        '</tr>'
+        '<tr style="border-bottom: 1px solid #f0f0f0;">'
+        '<td style="padding: 2px 6px; color: #6c757d;">Peso geo (a)</td>'
+        f'<td style="padding: 2px 6px; text-align: right;"><b>{alpha_txt}</b></td>'
+        '</tr>'
+        '<tr>'
+        '<td style="padding: 2px 6px; color: #6c757d;">Caracteristicas</td>'
+        f'<td style="padding: 2px 6px; text-align: right;">{colunas}</td>'
+        '</tr>'
+        '</table>'
+        f'{motivo_extra}'
+    )
+
+
 def formatar_avaliacao_html(avaliacoes_lista, indice_base=0, elem_id_excluir="excluir-aval-elab"):
     """Formata resultados de avaliação como tabela HTML acumulada.
 
@@ -682,6 +741,20 @@ def formatar_avaliacao_html(avaliacoes_lista, indice_base=0, elem_id_excluir="ex
         html += f'<td {_td_r}>{celula} {popup}</td>'
     html += '</tr>'
 
+    # Estimativa KNN
+    html += f'<tr><td {_td}>Estimativa KNN</td>'
+    for i, aval in enumerate(avaliacoes_lista):
+        knn_disponivel = bool(aval.get("knn_disponivel"))
+        valor_knn = _formatar_brl(aval.get("knn_estimado")) if knn_disponivel else '\u2014'
+        idx_1 = i + 1
+        botao_knn = (
+            f'<button type="button" data-avaliacao-knn-open="1" data-avaliacao-knn-index="{idx_1}" '
+            f'class="avaliacao-knn-open-icon" title="Abrir detalhamento KNN" '
+            f'aria-label="Abrir detalhamento KNN">ⓘ</button>'
+        )
+        html += f'<td {_td_r}>{valor_knn} {botao_knn}</td>'
+    html += '</tr>'
+
     # Estimado / Base (só se houver mais de 1 avaliação e base selecionada)
     if n > 1 and indice_base_normalizado is not None:
         estimado_base = avaliacoes_lista[indice_base_normalizado]["estimado"]

backend/app/services/elaboracao_service.py

@@ -50,6 +50,7 @@ from app.core.elaboracao.formatadores import (
 from app.models.session import SessionState
 from app.services import model_repository
 from app.services.equacao_service import build_equacoes_payload, exportar_planilha_equacao
+from app.services.knn_avaliacao_service import estimar_valor_knn_avaliacao
 from app.services.serializers import dataframe_to_payload, figure_to_payload, sanitize_value
 
 _AVALIADORES_PATH = Path(__file__).resolve().parent.parent / "core" / "elaboracao" / "avaliadores.json"
@@ -2020,6 +2021,16 @@ def calcular_avaliacao_elaboracao(
     if resultado is None:
         raise HTTPException(status_code=400, detail="Erro ao calcular avaliacao")
 
+    coluna_y_knn = str(session.coluna_y or session.resultado_modelo.get("coluna_y") or "").strip()
+    resultado_knn = estimar_valor_knn_avaliacao(
+        df_base=session.df_filtrado if session.df_filtrado is not None else session.df_original,
+        coluna_y=coluna_y_knn,
+        colunas_x=colunas_x,
+        valores_x=entradas,
+        alpha_geo=0.35,
+    )
+    resultado.update(resultado_knn)
+
     session.avaliacoes_elaboracao.append(resultado)
     total_avaliacoes = len(session.avaliacoes_elaboracao)
     idx_base, base = _resolver_indice_base(indice_base, total_avaliacoes, default_para_primeira=True)
@@ -2035,6 +2046,110 @@ def calcular_avaliacao_elaboracao(
     }
 
 
+def detalhes_knn_avaliacao_elaboracao(session: SessionState, valores_x: dict[str, Any]) -> dict[str, Any]:
+    if session.resultado_modelo is None:
+        raise HTTPException(status_code=400, detail="Ajuste um modelo primeiro")
+    if session.tabela_estatisticas is None:
+        raise HTTPException(status_code=400, detail="Estatisticas indisponiveis")
+
+    colunas_x = list(session.resultado_modelo.get("colunas_x", []))
+    if not colunas_x:
+        raise HTTPException(status_code=400, detail="Modelo sem variaveis")
+
+    entradas: dict[str, float] = {}
+    for col in colunas_x:
+        if col not in valores_x:
+            raise HTTPException(status_code=400, detail=f"Valor ausente para {col}")
+        try:
+            entradas[col] = float(valores_x[col])
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Valor invalido para {col}") from exc
+
+    est = session.tabela_estatisticas
+    if "Variável" in est.columns:
+        est_idx = est.set_index("Variável")
+    else:
+        est_idx = est
+
+    for col in colunas_x:
+        valor = entradas[col]
+        if col in session.dicotomicas and valor not in (0, 0.0, 1, 1.0):
+            raise HTTPException(status_code=400, detail=f"{col} aceita apenas 0 ou 1")
+        if col in session.codigo_alocado and col in est_idx.index:
+            min_v = float(est_idx.loc[col, "Mínimo"])
+            max_v = float(est_idx.loc[col, "Máximo"])
+            if _is_rh_col(col):
+                if float(valor) != int(float(valor)):
+                    raise HTTPException(status_code=400, detail=f"{col} aceita apenas valores inteiros")
+            elif float(valor) != int(float(valor)) or valor < min_v or valor > max_v:
+                raise HTTPException(status_code=400, detail=f"{col} aceita inteiros de {int(min_v)} a {int(max_v)}")
+        if col in session.percentuais and (valor < -PERCENTUAL_RUIDO_TOL or valor > 1 + PERCENTUAL_RUIDO_TOL):
+            raise HTTPException(status_code=400, detail=f"{col} aceita valores entre 0 e 1")
+
+    df_knn = session.df_filtrado if session.df_filtrado is not None else session.df_original
+    if not isinstance(df_knn, pd.DataFrame) or df_knn.empty:
+        raise HTTPException(status_code=400, detail="Base de dados indisponivel para KNN.")
+
+    coluna_y_knn = str(session.coluna_y or session.resultado_modelo.get("coluna_y") or "").strip()
+    resultado_knn = estimar_valor_knn_avaliacao(
+        df_base=df_knn,
+        coluna_y=coluna_y_knn,
+        colunas_x=colunas_x,
+        valores_x=entradas,
+        alpha_geo=0.35,
+        retornar_detalhes=True,
+    )
+
+    vizinhos = resultado_knn.get("knn_vizinhos") or []
+    posicoes_vizinhos = [
+        int(item.get("posicao_base"))
+        for item in vizinhos
+        if item is not None and item.get("posicao_base") is not None
+    ]
+
+    tabela_payload = None
+    if posicoes_vizinhos:
+        pares_validos: list[tuple[int, float | None]] = []
+        for item in vizinhos:
+            if not item:
+                continue
+            pos_raw = item.get("posicao_base")
+            if pos_raw is None:
+                continue
+            pos = int(pos_raw)
+            if pos < 0 or pos >= len(df_knn):
+                continue
+            distancia = item.get("distancia")
+            pares_validos.append((pos, float(distancia) if distancia is not None else None))
+
+        if pares_validos:
+            posicoes_validas = [pos for pos, _ in pares_validos]
+            distancias_validas = [dist for _, dist in pares_validos]
+            df_vizinhos = df_knn.iloc[posicoes_validas].copy()
+            df_vizinhos.insert(0, "__ordem_knn__", list(range(1, len(df_vizinhos) + 1)))
+            df_vizinhos.insert(1, "__distancia_knn__", distancias_validas)
+            tabela_payload = dataframe_to_payload(df_vizinhos, decimals=4, max_rows=None)
+
+    # Import local evita acoplamento no carregamento inicial do módulo.
+    from app.services.visualizacao_service import _criar_mapa_knn_destaque
+
+    mapa_html = _criar_mapa_knn_destaque(df_knn, posicoes_vizinhos, coluna_y_knn)
+    avaliando = [{"variavel": str(col), "valor": entradas.get(col)} for col in colunas_x]
+
+    return sanitize_value(
+        {
+            "mapa_html": mapa_html,
+            "avaliando": avaliando,
+            "vizinhos_tabela": tabela_payload,
+            "knn": resultado_knn,
+            "legenda_mapa": {
+                "mercado": "#4f6d8a",
+                "selecionados_knn": "#d7263d",
+            },
+        }
+    )
+
+
 def limpar_avaliacoes_elaboracao(session: SessionState) -> dict[str, Any]:
     session.avaliacoes_elaboracao = []
     return {

backend/app/services/knn_avaliacao_service.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+
+COORD_LAT_NAMES = {
+    "lat",
+    "latitude",
+    "siat_latitude",
+}
+COORD_LON_NAMES = {
+    "lon",
+    "long",
+    "longitude",
+    "siat_longitude",
+}
+
+
+def _normalizar_nome_coluna(value: Any) -> str:
+    return str(value or "").strip().lower()
+
+
+def _primeira_serie_por_nome(df: pd.DataFrame, coluna: str) -> pd.Series | None:
+    if coluna not in df.columns:
+        return None
+    serie = df.loc[:, coluna]
+    if isinstance(serie, pd.DataFrame):
+        if serie.shape[1] == 0:
+            return None
+        return serie.iloc[:, 0]
+    return serie
+
+
+def _detectar_coluna_coord(df: pd.DataFrame, candidatos: set[str]) -> str | None:
+    for coluna in df.columns:
+        if _normalizar_nome_coluna(coluna) in candidatos:
+            return str(coluna)
+    return None
+
+
+def _coercer_float(value: Any) -> float | None:
+    try:
+        numero = float(value)
+    except Exception:
+        return None
+    if not np.isfinite(numero):
+        return None
+    return float(numero)
+
+
+def _escala_robusta(valores: np.ndarray) -> float:
+    arr = np.asarray(valores, dtype=float)
+    arr = arr[np.isfinite(arr)]
+    if arr.size == 0:
+        return 1.0
+
+    med = float(np.median(arr))
+    mad = float(np.median(np.abs(arr - med)))
+    if np.isfinite(mad) and mad > 1e-9:
+        return float(mad * 1.4826)
+
+    std = float(np.std(arr))
+    if np.isfinite(std) and std > 1e-9:
+        return std
+
+    span = float(np.max(arr) - np.min(arr))
+    if np.isfinite(span) and span > 1e-9:
+        return span
+
+    return 1.0
+
+
+def _normalizar_distancias(distancias: np.ndarray) -> np.ndarray:
+    arr = np.asarray(distancias, dtype=float)
+    positivos = arr[np.isfinite(arr) & (arr > 0)]
+    if positivos.size == 0:
+        escala = 1.0
+    else:
+        escala = float(np.median(positivos))
+        if not np.isfinite(escala) or escala <= 0:
+            escala = float(np.mean(positivos))
+        if not np.isfinite(escala) or escala <= 0:
+            escala = 1.0
+    return arr / escala
+
+
+def _escala_iqr_robusta(valores: np.ndarray) -> float:
+    arr = np.asarray(valores, dtype=float)
+    arr = arr[np.isfinite(arr)]
+    if arr.size == 0:
+        return 1.0
+
+    q1, q3 = np.quantile(arr, [0.25, 0.75])
+    iqr = float(q3 - q1)
+    if np.isfinite(iqr) and iqr > 1e-9:
+        return iqr
+
+    return _escala_robusta(arr)
+
+
+def _eh_coluna_binaria(valores: np.ndarray) -> bool:
+    arr = np.asarray(valores, dtype=float)
+    arr = arr[np.isfinite(arr)]
+    if arr.size == 0:
+        return False
+
+    unicos = np.unique(arr)
+    if unicos.size > 2:
+        return False
+
+    arredondados = np.round(unicos)
+    if np.max(np.abs(unicos - arredondados)) > 1e-9:
+        return False
+
+    return bool(np.all(np.isin(arredondados, np.asarray([0.0, 1.0]))))
+
+
+def _haversine_km(lat: np.ndarray, lon: np.ndarray, lat_ref: float, lon_ref: float) -> np.ndarray:
+    raio_terra_km = 6371.0088
+
+    lat1 = np.radians(np.asarray(lat, dtype=float))
+    lon1 = np.radians(np.asarray(lon, dtype=float))
+    lat2 = math.radians(float(lat_ref))
+    lon2 = math.radians(float(lon_ref))
+
+    dlat = lat1 - lat2
+    dlon = lon1 - lon2
+    termo = np.sin(dlat / 2.0) ** 2 + np.cos(lat1) * math.cos(lat2) * (np.sin(dlon / 2.0) ** 2)
+    termo = np.clip(termo, 0.0, 1.0)
+    return 2.0 * raio_terra_km * np.arcsin(np.sqrt(termo))
+
+
+def _resultado_indisponivel(motivo: str, alpha_geo: float) -> dict[str, Any]:
+    return {
+        "knn_estimado": None,
+        "knn_disponivel": False,
+        "knn_metodo": "indisponivel",
+        "knn_geo_aplicado": False,
+        "knn_k": None,
+        "knn_n_validos": 0,
+        "knn_alpha_geo": float(alpha_geo),
+        "knn_motivo": str(motivo or "").strip(),
+        "knn_colunas": [],
+    }
+
+
+def estimar_valor_knn_avaliacao(
+    df_base: pd.DataFrame | None,
+    coluna_y: str,
+    colunas_x: list[str],
+    valores_x: dict[str, Any],
+    alpha_geo: float = 0.35,
+    min_k: int = 3,
+    max_k: int = 12,
+    retornar_detalhes: bool = False,
+) -> dict[str, Any]:
+    if df_base is None or not isinstance(df_base, pd.DataFrame) or df_base.empty:
+        return _resultado_indisponivel("Base de dados indisponivel para KNN.", alpha_geo)
+
+    if not coluna_y or coluna_y not in df_base.columns:
+        return _resultado_indisponivel("Variavel dependente indisponivel na base.", alpha_geo)
+
+    y_serie = _primeira_serie_por_nome(df_base, coluna_y)
+    if y_serie is None:
+        return _resultado_indisponivel("Variavel dependente indisponivel na base.", alpha_geo)
+
+    y_arr = pd.to_numeric(y_serie, errors="coerce").to_numpy(dtype=float)
+
+    colunas_validas: list[str] = []
+    matriz_colunas: list[np.ndarray] = []
+    query_vals: list[float] = []
+
+    for coluna in colunas_x:
+        if coluna not in df_base.columns:
+            continue
+        query_val = _coercer_float(valores_x.get(coluna))
+        if query_val is None:
+            continue
+
+        serie = _primeira_serie_por_nome(df_base, coluna)
+        if serie is None:
+            continue
+
+        valores_col = pd.to_numeric(serie, errors="coerce").to_numpy(dtype=float)
+        if not np.isfinite(valores_col).any():
+            continue
+
+        colunas_validas.append(str(coluna))
+        matriz_colunas.append(valores_col)
+        query_vals.append(float(query_val))
+
+    if not colunas_validas:
+        return _resultado_indisponivel(
+            "Nao foi possivel montar caracteristicas numericas validas para o KNN.",
+            alpha_geo,
+        )
+
+    mask_valid = np.isfinite(y_arr)
+    for valores_col in matriz_colunas:
+        mask_valid &= np.isfinite(valores_col)
+
+    if int(mask_valid.sum()) < 2:
+        return _resultado_indisponivel("Base com poucos registros validos para KNN.", alpha_geo)
+
+    feat_matrix = np.column_stack([valores_col[mask_valid] for valores_col in matriz_colunas]).astype(float)
+    y_valid = y_arr[mask_valid].astype(float)
+    query_vector = np.asarray(query_vals, dtype=float)
+    base_index = np.asarray(df_base.index, dtype=object)
+    pos_valid = np.flatnonzero(mask_valid)
+    idx_valid = base_index[pos_valid]
+
+    dist_partes: list[np.ndarray] = []
+    for idx_col in range(feat_matrix.shape[1]):
+        col = feat_matrix[:, idx_col]
+        query_val = float(query_vector[idx_col])
+
+        if _eh_coluna_binaria(col):
+            distancia_col = (np.round(col) != round(query_val)).astype(float)
+        else:
+            escala = _escala_iqr_robusta(col)
+            distancia_col = np.abs(col - query_val) / escala
+            distancia_col = np.clip(distancia_col, 0.0, 4.0)
+
+        dist_partes.append(distancia_col)
+
+    d_feat = np.mean(np.column_stack(dist_partes), axis=1)
+    d_feat_norm = _normalizar_distancias(d_feat)
+
+    lat_col = _detectar_coluna_coord(df_base, COORD_LAT_NAMES)
+    lon_col = _detectar_coluna_coord(df_base, COORD_LON_NAMES)
+
+    valores_x_norm = {_normalizar_nome_coluna(k): v for k, v in (valores_x or {}).items()}
+    lat_query = None
+    lon_query = None
+    for nome in COORD_LAT_NAMES:
+        if nome in valores_x_norm:
+            lat_query = _coercer_float(valores_x_norm.get(nome))
+            if lat_query is not None:
+                break
+    for nome in COORD_LON_NAMES:
+        if nome in valores_x_norm:
+            lon_query = _coercer_float(valores_x_norm.get(nome))
+            if lon_query is not None:
+                break
+
+    usa_geo = False
+    motivo_geo = ""
+    d_total = d_feat_norm
+    y_final = y_valid
+    pos_final = pos_valid
+    idx_final = idx_valid
+
+    if lat_col and lon_col and lat_query is not None and lon_query is not None:
+        lat_serie = _primeira_serie_por_nome(df_base, lat_col)
+        lon_serie = _primeira_serie_por_nome(df_base, lon_col)
+        if lat_serie is not None and lon_serie is not None:
+            lat_vals = pd.to_numeric(lat_serie, errors="coerce").to_numpy(dtype=float)[mask_valid]
+            lon_vals = pd.to_numeric(lon_serie, errors="coerce").to_numpy(dtype=float)[mask_valid]
+            mask_geo = (
+                np.isfinite(lat_vals)
+                & np.isfinite(lon_vals)
+                & (np.abs(lat_vals) <= 90.0)
+                & (np.abs(lon_vals) <= 180.0)
+            )
+
+            if int(mask_geo.sum()) >= 3:
+                d_geo = _haversine_km(lat_vals[mask_geo], lon_vals[mask_geo], lat_query, lon_query)
+                d_geo_norm = _normalizar_distancias(d_geo)
+                d_feat_geo = d_feat_norm[mask_geo]
+                d_total = np.sqrt((1.0 - alpha_geo) * (d_feat_geo ** 2) + alpha_geo * (d_geo_norm ** 2))
+                y_final = y_valid[mask_geo]
+                pos_final = pos_valid[mask_geo]
+                idx_final = idx_valid[mask_geo]
+                usa_geo = True
+            else:
+                motivo_geo = "Base com poucas coordenadas validas para aplicar componente geografica."
+        else:
+            motivo_geo = "Base sem coordenadas validas para aplicar componente geografica."
+    elif not (lat_col and lon_col):
+        motivo_geo = "Base sem colunas de coordenadas para componente geografica."
+    else:
+        motivo_geo = "Avaliando sem coordenadas informadas; KNN aplicado apenas por caracteristicas."
+
+    n_validos = int(len(y_final))
+    if n_validos <= 0:
+        return _resultado_indisponivel("Base sem registros validos para KNN.", alpha_geo)
+
+    k_dinamico = int(round(math.sqrt(n_validos)))
+    k = max(int(min_k), k_dinamico)
+    k = min(int(max_k), k, n_validos)
+    if k <= 0:
+        return _resultado_indisponivel("Nao foi possivel definir K valido para KNN.", alpha_geo)
+
+    ordem = np.argsort(d_total)
+    idx_vizinhos = ordem[:k]
+    y_vizinhos = y_final[idx_vizinhos]
+    d_vizinhos = d_total[idx_vizinhos]
+
+    mask_zero = d_vizinhos <= 1e-12
+    if np.any(mask_zero):
+        estimado = float(np.mean(y_vizinhos[mask_zero]))
+    else:
+        pesos = 1.0 / ((d_vizinhos + 1e-9) ** 2)
+        estimado = float(np.sum(pesos * y_vizinhos) / np.sum(pesos))
+
+    if not np.isfinite(estimado):
+        return _resultado_indisponivel("Estimativa KNN invalida apos calculo.", alpha_geo)
+
+    if usa_geo:
+        metodo = "caracteristicas_localizacao"
+        motivo = ""
+    else:
+        metodo = "caracteristicas"
+        motivo = motivo_geo or "Componente geografica nao aplicada."
+
+    resultado = {
+        "knn_estimado": estimado,
+        "knn_disponivel": True,
+        "knn_metodo": metodo,
+        "knn_geo_aplicado": bool(usa_geo),
+        "knn_k": int(k),
+        "knn_n_validos": int(n_validos),
+        "knn_alpha_geo": float(alpha_geo),
+        "knn_motivo": str(motivo or "").strip(),
+        "knn_colunas": colunas_validas,
+    }
+
+    if retornar_detalhes:
+        pos_vizinhos = pos_final[idx_vizinhos]
+        idx_base_vizinhos = idx_final[idx_vizinhos]
+        detalhes_vizinhos: list[dict[str, Any]] = []
+        for ordem_vizinho, (pos, idx_base, dist, y_viz) in enumerate(
+            zip(pos_vizinhos, idx_base_vizinhos, d_vizinhos, y_vizinhos, strict=False),
+            start=1,
+        ):
+            detalhes_vizinhos.append(
+                {
+                    "ordem": int(ordem_vizinho),
+                    "posicao_base": int(pos),
+                    "indice_base": idx_base.item() if isinstance(idx_base, np.generic) else idx_base,
+                    "distancia": float(dist),
+                    "valor_y": float(y_viz),
+                }
+            )
+        resultado["knn_vizinhos"] = detalhes_vizinhos
+
+    return resultado

backend/app/services/visualizacao_service.py

@@ -3,28 +3,166 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
+import folium
 import numpy as np
 import pandas as pd
 from fastapi import HTTPException
+from folium import plugins
 from joblib import load
 
 from app.core.visualizacao import app as viz_app
+from app.core.map_layers import add_bairros_layer, add_popup_pagination_handlers, add_zoom_responsive_circle_markers
 from app.core.elaboracao.core import PERCENTUAL_RUIDO_TOL, _migrar_pacote_v1_para_v2, avaliar_imovel, exportar_avaliacoes_excel
 from app.core.elaboracao.formatadores import formatar_avaliacao_html
 from app.models.session import SessionState
 from app.services import model_repository
 from app.services.equacao_service import build_equacoes_payload, exportar_planilha_equacao
+from app.services.knn_avaliacao_service import estimar_valor_knn_avaliacao
 from app.services.serializers import dataframe_to_payload, figure_to_payload, sanitize_value
 
 
 CHAVES_ESPERADAS = ["versao", "dados", "transformacoes", "modelo"]
 BASE_COMPARACAO_SEM_BASE = "__none__"
+COORD_LAT_NAMES = {"lat", "latitude", "siat_latitude"}
+COORD_LON_NAMES = {"lon", "long", "longitude", "siat_longitude"}
 
 
 def _is_rh_col(coluna: str) -> bool:
     return str(coluna or "").strip().upper() == "RH"
 
 
+def _normalizar_nome_coluna(value: Any) -> str:
+    return str(value or "").strip().lower()
+
+
+def _detectar_coluna_coord(df: pd.DataFrame, candidatos: set[str]) -> str | None:
+    for coluna in df.columns:
+        if _normalizar_nome_coluna(coluna) in candidatos:
+            return str(coluna)
+    return None
+
+
+def _primeira_serie_por_nome(df: pd.DataFrame, coluna: str) -> pd.Series | None:
+    if coluna not in df.columns:
+        return None
+    serie = df.loc[:, coluna]
+    if isinstance(serie, pd.DataFrame):
+        if serie.shape[1] == 0:
+            return None
+        return serie.iloc[:, 0]
+    return serie
+
+
+def _formatar_tooltip_valor(coluna: str, valor: Any) -> str:
+    if valor is None or (isinstance(valor, float) and not np.isfinite(valor)):
+        return "—"
+    nome = str(coluna or "").strip().lower()
+    if isinstance(valor, (int, float, np.integer, np.floating)):
+        numero = float(valor)
+        if not np.isfinite(numero):
+            return "—"
+        if any(chave in nome for chave in ["valor", "preco", "vu", "vunit"]):
+            return f"R$ {numero:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+        if "lat" in nome or "lon" in nome:
+            return f"{numero:.6f}"
+        return f"{numero:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+    return str(valor)
+
+
+def _criar_mapa_knn_destaque(df_base: pd.DataFrame, posicoes_knn: list[int], coluna_y: str) -> str:
+    if df_base is None or df_base.empty:
+        return "<p>Base de dados indisponivel para mapa KNN.</p>"
+
+    lat_col = _detectar_coluna_coord(df_base, COORD_LAT_NAMES)
+    lon_col = _detectar_coluna_coord(df_base, COORD_LON_NAMES)
+    if not lat_col or not lon_col:
+        return "<p>Modelo sem colunas de coordenadas para exibir o mapa KNN.</p>"
+
+    lat_serie = _primeira_serie_por_nome(df_base, lat_col)
+    lon_serie = _primeira_serie_por_nome(df_base, lon_col)
+    if lat_serie is None or lon_serie is None:
+        return "<p>Coordenadas indisponiveis para o mapa KNN.</p>"
+
+    dados = df_base.copy()
+    dados["__pos_base__"] = np.arange(len(dados), dtype=int)
+    dados["__indice_base__"] = [str(v) for v in dados.index]
+    dados["__lat__"] = pd.to_numeric(lat_serie, errors="coerce")
+    dados["__lon__"] = pd.to_numeric(lon_serie, errors="coerce")
+    dados = dados[
+        np.isfinite(dados["__lat__"])
+        & np.isfinite(dados["__lon__"])
+        & (np.abs(dados["__lat__"]) <= 90.0)
+        & (np.abs(dados["__lon__"]) <= 180.0)
+    ].copy()
+
+    if dados.empty:
+        return "<p>Sem coordenadas validas para exibir o mapa KNN.</p>"
+
+    centro_lat = float(dados["__lat__"].median())
+    centro_lon = float(dados["__lon__"].median())
+
+    mapa = folium.Map(
+        location=[centro_lat, centro_lon],
+        zoom_start=12,
+        tiles=None,
+        prefer_canvas=True,
+        control_scale=True,
+    )
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True, show=True).add_to(mapa)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True, show=False).add_to(mapa)
+    add_bairros_layer(mapa, show=True)
+
+    posicoes_set = {int(v) for v in (posicoes_knn or [])}
+    camada_mercado = folium.FeatureGroup(name="Mercado (base completa)", show=True)
+    camada_knn = folium.FeatureGroup(name="Selecionados KNN", show=True)
+
+    for _, row in dados.iterrows():
+        pos = int(row["__pos_base__"])
+        selecionado = pos in posicoes_set
+        col_y_val = row.get(coluna_y)
+        valor_tooltip = _formatar_tooltip_valor(coluna_y, col_y_val)
+        tooltip_html = (
+            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.5;'>"
+            f"<b>Indice {row['__indice_base__']}</b>"
+            f"<br><span style='color:#555;'>{coluna_y}:</span> <b>{valor_tooltip}</b>"
+            "</div>"
+        )
+
+        marcador = folium.CircleMarker(
+            location=[float(row["__lat__"]), float(row["__lon__"])],
+            radius=8 if selecionado else 5,
+            tooltip=folium.Tooltip(tooltip_html, sticky=True),
+            color="#ffffff",
+            weight=0.9,
+            fill=True,
+            fillColor="#d7263d" if selecionado else "#4f6d8a",
+            fillOpacity=0.92 if selecionado else 0.52,
+        )
+        marcador.options["mesaBaseRadius"] = 8.0 if selecionado else 5.0
+        (camada_knn if selecionado else camada_mercado).add_child(marcador)
+
+    camada_mercado.add_to(mapa)
+    camada_knn.add_to(mapa)
+    folium.LayerControl().add_to(mapa)
+    plugins.Fullscreen().add_to(mapa)
+    add_zoom_responsive_circle_markers(mapa)
+    add_popup_pagination_handlers(mapa)
+
+    lat_min = float(dados["__lat__"].quantile(0.01))
+    lat_max = float(dados["__lat__"].quantile(0.99))
+    lon_min = float(dados["__lon__"].quantile(0.01))
+    lon_max = float(dados["__lon__"].quantile(0.99))
+    if np.isclose(lat_min, lat_max):
+        lat_min -= 0.0008
+        lat_max += 0.0008
+    if np.isclose(lon_min, lon_max):
+        lon_min -= 0.0008
+        lon_max += 0.0008
+    mapa.fit_bounds([[lat_min, lon_min], [lat_max, lon_max]], padding=(46, 46), max_zoom=18)
+
+    return mapa.get_root().render()
+
+
 def _resolver_indice_base(
     indice_base_raw: str | None,
     total_avaliacoes: int,
@@ -366,6 +504,18 @@ def calcular_avaliacao(session: SessionState, valores_x: dict[str, Any], indice_
     if resultado is None:
         raise HTTPException(status_code=400, detail="Erro ao calcular avaliacao")
 
+    df_knn = pacote.get("dados", {}).get("df")
+    if not isinstance(df_knn, pd.DataFrame):
+        df_knn = pd.DataFrame(df_knn)
+    resultado_knn = estimar_valor_knn_avaliacao(
+        df_base=df_knn,
+        coluna_y=info["nome_y"],
+        colunas_x=colunas_x,
+        valores_x=entradas,
+        alpha_geo=0.35,
+    )
+    resultado.update(resultado_knn)
+
     session.avaliacoes_visualizacao.append(resultado)
 
     total_avaliacoes = len(session.avaliacoes_visualizacao)
@@ -381,6 +531,108 @@ def calcular_avaliacao(session: SessionState, valores_x: dict[str, Any], indice_
     }
 
 
+def detalhes_knn_avaliacao(session: SessionState, valores_x: dict[str, Any]) -> dict[str, Any]:
+    pacote = session.pacote_visualizacao
+    if pacote is None:
+        raise HTTPException(status_code=400, detail="Carregue um modelo primeiro")
+
+    info = _extrair_modelo_info(pacote)
+    colunas_x = info["colunas_x"]
+    entradas: dict[str, float] = {}
+    for col in colunas_x:
+        if col not in valores_x:
+            raise HTTPException(status_code=400, detail=f"Valor ausente para {col}")
+        try:
+            entradas[col] = float(valores_x[col])
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Valor invalido para {col}") from exc
+
+    estatisticas_df = pacote["dados"]["estatisticas"]
+    if isinstance(estatisticas_df, pd.DataFrame):
+        est_df = estatisticas_df
+    else:
+        est_df = pd.DataFrame(estatisticas_df)
+
+    if "Variável" in est_df.columns:
+        est_idx = est_df.set_index("Variável")
+    else:
+        est_idx = est_df
+
+    for col in colunas_x:
+        valor = entradas[col]
+        if col in info["dicotomicas"] and valor not in (0, 0.0, 1, 1.0):
+            raise HTTPException(status_code=400, detail=f"{col} aceita apenas 0 ou 1")
+        if col in info["codigo_alocado"] and col in est_idx.index:
+            min_v = float(est_idx.loc[col, "Mínimo"])
+            max_v = float(est_idx.loc[col, "Máximo"])
+            if _is_rh_col(col):
+                if float(valor) != int(float(valor)):
+                    raise HTTPException(status_code=400, detail=f"{col} aceita apenas valores inteiros")
+            elif float(valor) != int(float(valor)) or valor < min_v or valor > max_v:
+                raise HTTPException(status_code=400, detail=f"{col} aceita inteiros de {int(min_v)} a {int(max_v)}")
+        if col in info["percentuais"] and (valor < -PERCENTUAL_RUIDO_TOL or valor > 1 + PERCENTUAL_RUIDO_TOL):
+            raise HTTPException(status_code=400, detail=f"{col} aceita valores entre 0 e 1")
+
+    df_knn = pacote.get("dados", {}).get("df")
+    if not isinstance(df_knn, pd.DataFrame):
+        df_knn = pd.DataFrame(df_knn)
+
+    resultado_knn = estimar_valor_knn_avaliacao(
+        df_base=df_knn,
+        coluna_y=info["nome_y"],
+        colunas_x=colunas_x,
+        valores_x=entradas,
+        alpha_geo=0.35,
+        retornar_detalhes=True,
+    )
+
+    vizinhos = resultado_knn.get("knn_vizinhos") or []
+    posicoes_vizinhos = [
+        int(item.get("posicao_base"))
+        for item in vizinhos
+        if item is not None and item.get("posicao_base") is not None
+    ]
+
+    tabela_payload = None
+    if posicoes_vizinhos:
+        pares_validos: list[tuple[int, float | None]] = []
+        for item in vizinhos:
+            if not item:
+                continue
+            pos_raw = item.get("posicao_base")
+            if pos_raw is None:
+                continue
+            pos = int(pos_raw)
+            if pos < 0 or pos >= len(df_knn):
+                continue
+            distancia = item.get("distancia")
+            pares_validos.append((pos, float(distancia) if distancia is not None else None))
+
+        if pares_validos:
+            posicoes_validas = [pos for pos, _ in pares_validos]
+            distancias_validas = [dist for _, dist in pares_validos]
+            df_vizinhos = df_knn.iloc[posicoes_validas].copy()
+            df_vizinhos.insert(0, "__ordem_knn__", list(range(1, len(df_vizinhos) + 1)))
+            df_vizinhos.insert(1, "__distancia_knn__", distancias_validas)
+            tabela_payload = dataframe_to_payload(df_vizinhos, decimals=4, max_rows=None)
+
+    mapa_html = _criar_mapa_knn_destaque(df_knn, posicoes_vizinhos, info["nome_y"])
+    avaliando = [{"variavel": str(col), "valor": entradas.get(col)} for col in colunas_x]
+
+    return sanitize_value(
+        {
+            "mapa_html": mapa_html,
+            "avaliando": avaliando,
+            "vizinhos_tabela": tabela_payload,
+            "knn": resultado_knn,
+            "legenda_mapa": {
+                "mercado": "#4f6d8a",
+                "selecionados_knn": "#d7263d",
+            },
+        }
+    )
+
+
 def limpar_avaliacoes(session: SessionState) -> dict[str, Any]:
     session.avaliacoes_visualizacao = []
     return {

frontend/src/api.js

@@ -253,6 +253,10 @@ export const api = {
     valores_x: valoresX,
     indice_base: indiceBase,
   }),
+  evaluationKnnDetailsElab: (sessionId, valoresX) => postJson('/api/elaboracao/evaluation/knn-details', {
+    session_id: sessionId,
+    valores_x: valoresX,
+  }),
   evaluationClearElab: (sessionId) => postJson('/api/elaboracao/evaluation/clear', { session_id: sessionId }),
   evaluationDeleteElab: (sessionId, indice, indiceBase) => postJson('/api/elaboracao/evaluation/delete', {
     session_id: sessionId,
@@ -309,6 +313,10 @@ export const api = {
     valores_x: valoresX,
     indice_base: indiceBase,
   }),
+  evaluationKnnDetailsViz: (sessionId, valoresX) => postJson('/api/visualizacao/evaluation/knn-details', {
+    session_id: sessionId,
+    valores_x: valoresX,
+  }),
   evaluationClearViz: (sessionId) => postJson('/api/visualizacao/evaluation/clear', { session_id: sessionId }),
   evaluationDeleteViz: (sessionId, indice, indiceBase) => postJson('/api/visualizacao/evaluation/delete', {
     session_id: sessionId,

frontend/src/components/AvaliacaoTab.jsx

@@ -1,6 +1,7 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react'
 import { api, downloadBlob } from '../api'
 import LoadingOverlay from './LoadingOverlay'
+import MapFrame from './MapFrame'
 import SinglePillAutocomplete from './SinglePillAutocomplete'
 
 function normalizarChaveModelo(value) {
@@ -33,6 +34,46 @@ function formatarDataHoraIso(iso) {
   return data.toLocaleString('pt-BR')
 }
 
+function formatarValorTabelaKnn(coluna, valor) {
+  if (valor === null || valor === undefined || valor === '') return '-'
+  const nome = String(coluna || '').toLowerCase()
+  if (typeof valor === 'number' && Number.isFinite(valor)) {
+    if (nome.includes('lat') || nome.includes('lon')) {
+      return valor.toLocaleString('pt-BR', {
+        minimumFractionDigits: 6,
+        maximumFractionDigits: 6,
+      })
+    }
+    if (nome.includes('distancia')) {
+      return valor.toLocaleString('pt-BR', {
+        minimumFractionDigits: 4,
+        maximumFractionDigits: 4,
+      })
+    }
+    return valor.toLocaleString('pt-BR', {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2,
+    })
+  }
+  return String(valor)
+}
+
+function valorPadraoCampoAvaliacao(campo) {
+  if (String(campo?.tipo || '') !== 'dicotomica') return ''
+  const opcoes = Array.isArray(campo?.opcoes) && campo.opcoes.length ? campo.opcoes : [0, 1]
+  const zero = opcoes.find((item) => Number(item) === 0)
+  if (zero !== undefined) return String(zero)
+  return String(opcoes[0] ?? 0)
+}
+
+function construirValoresIniciaisAvaliacao(campos = []) {
+  const init = {}
+  ;(campos || []).forEach((campo) => {
+    init[campo.coluna] = valorPadraoCampoAvaliacao(campo)
+  })
+  return init
+}
+
 function formatarExtrapoladasNaFronteira(aval) {
   const qtdExtrapolacoes = Number(aval?.qtd_extrapolacoes ?? 0)
   const houveExtrapolacao = Boolean(aval?.houve_extrapolacao) || qtdExtrapolacoes > 0
@@ -53,15 +94,33 @@ function formatarExtrapoladasNaFronteiraCsv(aval) {
   return formatarNumero(fronteira, 2)
 }
 
+function formatarEstimativaKnn(aval) {
+  const disponivel = Boolean(aval?.knn_disponivel)
+  const estimado = Number(aval?.knn_estimado)
+  if (!disponivel || !Number.isFinite(estimado)) return '-'
+  return formatarMoeda(estimado)
+}
+
+function formatarEstimativaKnnCsv(aval) {
+  const disponivel = Boolean(aval?.knn_disponivel)
+  const estimado = Number(aval?.knn_estimado)
+  if (!disponivel || !Number.isFinite(estimado)) return '-'
+  return formatarNumero(estimado, 2)
+}
+
 function classificarExtrapolacao(info) {
   const status = String(info?.status || 'ok')
   const percentual = Number(info?.percentual || 0)
   const direcao = String(info?.direcao || '')
   const seta = direcao === 'acima' ? '↑' : (direcao === 'abaixo' ? '↓' : '')
-  if (status === 'ok') return 'ok'
-  if (status === 'warning') return `⚠️${seta} ${formatarNumero(percentual, 1)}%`
-  if (status === 'grave') return `❌${seta} ${formatarNumero(percentual, 1)}%`
+  if (status === 'ok') return '✅'
   if (status === 'dicotomica' || status === 'codigo_alocado' || status === 'percentual') return '—'
+  if (status === 'warning') return `⚠️${seta} ${formatarNumero(percentual, 1)}%`
+  if (status === 'grave') {
+    if (info?.valor_invalido) return '❌'
+    return `❌${seta} ${formatarNumero(percentual, 1)}%`
+  }
+  if (info?.valor_invalido) return '❌'
   return status
 }
 
@@ -74,13 +133,6 @@ function escaparHtml(value) {
     .replaceAll("'", ''')
 }
 
-const CORES_GRAU = {
-  'Grau III': '#28a745',
-  'Grau II': '#17a2b8',
-  'Grau I': '#e67e00',
-  'Sem enquadramento': '#dc3545',
-}
-
 function normalizarGrau(value) {
   const texto = String(value || '').toLowerCase()
   if (texto.includes('grau iii')) return 'Grau III'
@@ -90,31 +142,26 @@ function normalizarGrau(value) {
   return String(value || '-')
 }
 
-function corGrau(valor) {
-  const grau = normalizarGrau(valor)
-  return CORES_GRAU[grau] || '#495057'
-}
-
 function popupPrecisaoHtml(aval) {
   const amplitude = Number(aval?.amplitude)
   const amplitudeTexto = Number.isFinite(amplitude) ? `${formatarNumero(amplitude, 1)}%` : '—'
   const grau = normalizarGrau(aval?.precisao)
   const regras = [
-    ['≤30%', 'Grau III', '#28a745'],
-    ['≤40%', 'Grau II', '#17a2b8'],
-    ['≤50%', 'Grau I', '#e67e00'],
-    ['>50%', 'Sem enquadramento', '#dc3545'],
+    ['≤30%', 'Grau III'],
+    ['≤40%', 'Grau II'],
+    ['≤50%', 'Grau I'],
+    ['>50%', 'Sem enquadramento'],
   ]
 
-  const linhas = regras.map(([faixa, nome, cor]) => {
+  const linhas = regras.map(([faixa, nome]) => {
     const ativo = nome === grau
-    const bg = ativo ? `background: ${cor}11;` : ''
+    const bg = ativo ? 'background: #f1f3f5;' : ''
     const fw = ativo ? 'font-weight: 600;' : ''
     const marca = ativo ? ' ◀' : ''
     return (
       `<tr style="border-bottom: 1px solid #f0f0f0; ${bg}">`
       + `<td style="padding: 2px 6px; ${fw}">${faixa}</td>`
-      + `<td style="padding: 2px 6px; color: ${cor}; ${fw}">${nome}${marca}</td>`
+      + `<td style="padding: 2px 6px; ${fw}">${nome}${marca}</td>`
       + '</tr>'
     )
   }).join('')
@@ -139,7 +186,6 @@ function popupPrecisaoHtml(aval) {
 
 function popupFundamentacaoHtml(aval) {
   const grau = normalizarGrau(aval?.fundamentacao)
-  const corGrauAtual = CORES_GRAU[grau] || '#495057'
   const qtdExtrapolacoes = Number(aval?.qtd_extrapolacoes ?? 0)
   const houveExtrapolacao = Boolean(aval?.houve_extrapolacao) || qtdExtrapolacoes > 0
   const percExt = Number(aval?.perc_ext)
@@ -164,7 +210,7 @@ function popupFundamentacaoHtml(aval) {
   if (!houveExtrapolacao) {
     return (
       header
-      + `<div>Nenhuma variável extrapolou os limites amostrais. <span style="color: #28a745; font-weight: 600;">→ ${grau}</span></div>`
+      + `<div>Nenhuma variável extrapolou os limites amostrais. <span style="font-weight: 600;">→ ${grau}</span></div>`
     )
   }
 
@@ -208,7 +254,7 @@ function popupFundamentacaoHtml(aval) {
   ]
   const tabelaRegras = regras.map(([condicao, nome]) => {
     const ativo = nome === grau || (nome === 'Sem enq.' && grau === 'Sem enquadramento')
-    const bg = ativo ? `background: ${corGrauAtual}11;` : ''
+    const bg = ativo ? 'background: #f1f3f5;' : ''
     const fw = ativo ? 'font-weight: 600;' : ''
     const marca = ativo ? ' ◀' : ''
     return (
@@ -226,7 +272,7 @@ function popupFundamentacaoHtml(aval) {
     header
     + `<div style="margin-bottom: 3px;">${resumo}</div>`
     + `<div style="background: #f8f9fa; border-radius: 4px; padding: 4px 8px; margin-bottom: 4px; font-size: 11px;">${varsStr}</div>`
-    + `<div style="margin-bottom: 4px; font-size: 11px; color: #495057;">${motivo} <span style="color: ${corGrauAtual}; font-weight: 600;">→ ${grau}</span></div>`
+    + `<div style="margin-bottom: 4px; font-size: 11px; color: #495057;">${motivo} <span style="font-weight: 600;">→ ${grau}</span></div>`
     + '<table style="width: 100%; border-collapse: collapse; font-size: 11px;">'
     + '<tr style="border-bottom: 1px solid #e9ecef;">'
     + '<th style="text-align: left; padding: 2px 6px; color: #6c757d;">Condição</th>'
@@ -329,7 +375,16 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
   const [avaliacoesCards, setAvaliacoesCards] = useState([])
   const [baseCardId, setBaseCardId] = useState(BASE_COMPARACAO_SEM_BASE)
   const [confirmarLimpezaAvaliacoes, setConfirmarLimpezaAvaliacoes] = useState(false)
-  const [avaliacaoPopupHtml, setAvaliacaoPopupHtml] = useState('')
+  const [confirmarExclusaoCardId, setConfirmarExclusaoCardId] = useState('')
+  const [avaliacaoPopup, setAvaliacaoPopup] = useState(null)
+  const [knnDetalheAberto, setKnnDetalheAberto] = useState(false)
+  const [knnDetalheLoading, setKnnDetalheLoading] = useState(false)
+  const [knnDetalheErro, setKnnDetalheErro] = useState('')
+  const [knnDetalheCardTitulo, setKnnDetalheCardTitulo] = useState('')
+  const [knnDetalheMapaHtml, setKnnDetalheMapaHtml] = useState('')
+  const [knnDetalheAvaliando, setKnnDetalheAvaliando] = useState([])
+  const [knnDetalheTabela, setKnnDetalheTabela] = useState(null)
+  const [knnDetalheInfo, setKnnDetalheInfo] = useState(null)
 
   const uploadInputRef = useRef(null)
   const quickLoadHandledRef = useRef('')
@@ -521,12 +576,15 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
     }
   }, [avaliacoesCards, baseCardId])
 
+  useEffect(() => {
+    if (!confirmarExclusaoCardId) return
+    if (!avaliacoesCards.some((item) => item.id === confirmarExclusaoCardId)) {
+      setConfirmarExclusaoCardId('')
+    }
+  }, [avaliacoesCards, confirmarExclusaoCardId])
+
   function resetCamposAvaliacao(campos = camposAvaliacao) {
-    const limpo = {}
-    ;(campos || []).forEach((campo) => {
-      limpo[campo.coluna] = ''
-    })
-    valoresAvaliacaoRef.current = limpo
+    valoresAvaliacaoRef.current = construirValoresIniciaisAvaliacao(campos)
     setAvaliacaoFormVersion((prev) => prev + 1)
   }
 
@@ -674,6 +732,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
       }
       setAvaliacoesCards((prev) => [...prev, card])
       setBaseCardId((prev) => prev || card.id)
+      setConfirmarExclusaoCardId('')
       setConfirmarLimpezaAvaliacoes(false)
     })
   }
@@ -682,22 +741,96 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
     resetCamposAvaliacao()
   }
 
-  function onExcluirCard(cardId) {
+  function onSolicitarExclusaoCard(cardId) {
+    setConfirmarExclusaoCardId(String(cardId || ''))
+  }
+
+  function onConfirmarExclusaoCard(cardId) {
     setAvaliacoesCards((prev) => prev.filter((item) => item.id !== cardId))
+    setConfirmarExclusaoCardId('')
+  }
+
+  function onCancelarExclusaoCard() {
+    setConfirmarExclusaoCardId('')
   }
 
   function onLimparAvaliacoes() {
     setAvaliacoesCards([])
     setBaseCardId(BASE_COMPARACAO_SEM_BASE)
+    setConfirmarExclusaoCardId('')
     setConfirmarLimpezaAvaliacoes(false)
   }
 
-  function onPopupEnter(html) {
-    setAvaliacaoPopupHtml(String(html || ''))
+  function onPopupEnter(event, html) {
+    const conteudo = String(html || '').trim()
+    if (!conteudo) {
+      setAvaliacaoPopup(null)
+      return
+    }
+
+    const alvo = event?.currentTarget
+    if (!alvo || typeof alvo.getBoundingClientRect !== 'function') {
+      setAvaliacaoPopup({
+        html: conteudo,
+        left: 12,
+        top: 12,
+        width: 320,
+      })
+      return
+    }
+
+    const rect = alvo.getBoundingClientRect()
+    const vw = Math.max(window.innerWidth || 0, 320)
+    const vh = Math.max(window.innerHeight || 0, 320)
+    const largura = Math.min(520, Math.max(280, vw - 24))
+
+    const abreParaDireita = rect.left < (vw / 2)
+    let left = abreParaDireita ? (rect.right + 10) : (rect.left - largura - 10)
+    left = Math.max(12, Math.min(left, vw - largura - 12))
+
+    const topoMax = Math.max(12, vh - 220)
+    let top = rect.bottom + 8
+    top = Math.max(12, Math.min(top, topoMax))
+
+    setAvaliacaoPopup({
+      html: conteudo,
+      left,
+      top,
+      width: largura,
+    })
   }
 
   function onPopupLeave() {
-    setAvaliacaoPopupHtml('')
+    setAvaliacaoPopup(null)
+  }
+
+  async function onAbrirDetalheKnn(card, indice) {
+    if (!sessionId || !card?.avaliacao?.valores_x) return
+    setKnnDetalheAberto(true)
+    setKnnDetalheLoading(true)
+    setKnnDetalheErro('')
+    setKnnDetalheCardTitulo(`Aval. ${Number(indice) + 1} — ${String(card?.modelo || 'Modelo')}`)
+    setKnnDetalheMapaHtml('')
+    setKnnDetalheAvaliando([])
+    setKnnDetalheTabela(null)
+    setKnnDetalheInfo(null)
+    try {
+      const resp = await api.evaluationKnnDetailsViz(sessionId, card.avaliacao.valores_x)
+      setKnnDetalheMapaHtml(String(resp?.mapa_html || ''))
+      setKnnDetalheAvaliando(Array.isArray(resp?.avaliando) ? resp.avaliando : [])
+      setKnnDetalheTabela(resp?.vizinhos_tabela || null)
+      setKnnDetalheInfo(resp?.knn || null)
+    } catch (err) {
+      setKnnDetalheErro(err?.message || 'Falha ao carregar detalhes do KNN.')
+    } finally {
+      setKnnDetalheLoading(false)
+    }
+  }
+
+  function onFecharDetalheKnn() {
+    setKnnDetalheAberto(false)
+    setKnnDetalheLoading(false)
+    setKnnDetalheErro('')
   }
 
   function calcularComparacaoBase(avaliacao) {
@@ -735,6 +868,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
       'Fundamentacao',
       'QtdExtrapolacoes',
       'ExtrapoladasNaFronteira',
+      'EstimativaKNN',
       ...variaveis.map((item) => `X_${item}`),
     ]
     const linhas = [cabecalho.join(';')]
@@ -758,6 +892,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
         String(aval.fundamentacao || ''),
         String(aval.qtd_extrapolacoes ?? ''),
         formatarExtrapoladasNaFronteiraCsv(aval),
+        formatarEstimativaKnnCsv(aval),
       ]
       const camposVars = variaveis.map((variavel) => {
         const valor = aval?.valores_x?.[variavel]
@@ -771,6 +906,10 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
   }
 
   const modeloPronto = Boolean(camposAvaliacao.length)
+  const mostrarComparacaoBase = Boolean(baseCard && avaliacoesCards.length > 1)
+  const indiceBaseSelecionada = mostrarComparacaoBase
+    ? (avaliacoesCards.findIndex((item) => item.id === baseCard?.id) + 1)
+    : 0
 
   return (
     <div className="tab-content">
@@ -889,12 +1028,11 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
                       <label>{campo.coluna}</label>
                       {campo.tipo === 'dicotomica' ? (
                         <select
-                          defaultValue={String(valoresAvaliacaoRef.current[campo.coluna] ?? '')}
+                          defaultValue={String(valoresAvaliacaoRef.current[campo.coluna] ?? valorPadraoCampoAvaliacao(campo))}
                           onChange={(event) => {
                             valoresAvaliacaoRef.current[campo.coluna] = event.target.value
                           }}
                         >
-                          <option value="">Selecione</option>
                           {(campo.opcoes || [0, 1]).map((opcao) => (
                             <option key={`op-avaliacao-${campo.coluna}-${opcao}`} value={String(opcao)}>
                               {opcao}
@@ -966,6 +1104,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
                     {avaliacoesCards.map((item, idx) => {
                       const aval = item.avaliacao || {}
                       const ehBase = item.id === baseCardId
+                      const exclusaoPendente = confirmarExclusaoCardId === item.id
                       const variaveis = Object.keys(aval.valores_x || {})
                       return (
                         <article key={item.id} className="avaliacao-modelos-card">
@@ -975,9 +1114,35 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
                               <span>{item.modelo}</span>
                             </div>
                             <div className="avaliacao-modelos-card-actions">
-                              <button type="button" className="avaliacao-modelos-delete-btn" onClick={() => onExcluirCard(item.id)} disabled={loading}>
-                                Excluir
-                              </button>
+                              {!exclusaoPendente ? (
+                                <button
+                                  type="button"
+                                  className="avaliacao-modelos-delete-btn"
+                                  onClick={() => onSolicitarExclusaoCard(item.id)}
+                                  disabled={loading}
+                                >
+                                  Excluir
+                                </button>
+                              ) : (
+                                <div className="avaliacao-card-delete-confirm">
+                                  <button
+                                    type="button"
+                                    className="avaliacao-modelos-delete-btn"
+                                    onClick={() => onConfirmarExclusaoCard(item.id)}
+                                    disabled={loading}
+                                  >
+                                    Confirmar
+                                  </button>
+                                  <button
+                                    type="button"
+                                    className="avaliacao-modelos-delete-cancel-btn"
+                                    onClick={onCancelarExclusaoCard}
+                                    disabled={loading}
+                                  >
+                                    Cancelar
+                                  </button>
+                                </div>
+                              )}
                             </div>
                           </div>
 
@@ -985,79 +1150,116 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
                             {formatarDataHoraIso(item.createdAt)}
                           </div>
 
-                          <div className="avaliacao-modelos-card-base">
-                            <strong>Estimado / Base:</strong>{' '}
-                            {ehBase ? (
-                              <span className="avaliacao-modelos-base-pill">Base</span>
-                            ) : (
-                              <span>{calcularComparacaoBase(aval)}</span>
-                            )}
-                          </div>
-
-                          <div className="avaliacao-modelos-vars-list">
+                          <div className="avaliacao-modelos-linhas">
                             {variaveis.map((variavel) => (
-                              <div key={`${item.id}-var-${variavel}`} className="avaliacao-modelos-vars-item">
+                              <div key={`${item.id}-var-${variavel}`} className="avaliacao-modelos-linha">
                                 <span>{variavel}</span>
                                 <span>
                                   {formatarNumero(aval?.valores_x?.[variavel], 2)} {classificarExtrapolacao(aval?.extrapolacoes?.[variavel])}
                                 </span>
                               </div>
                             ))}
-                          </div>
 
-                          <div className="avaliacao-modelos-metrics">
-                            <div><strong>Estimado:</strong> {formatarMoeda(aval.estimado)}</div>
-                            <div>
-                              <strong>Extrapoladas na fronteira:</strong> {formatarExtrapoladasNaFronteira(aval)}{' '}
-                              <button
-                                type="button"
-                                className="avaliacao-popup-trigger"
-                                aria-label="Detalhes de extrapoladas na fronteira"
-                                onMouseEnter={() => onPopupEnter(popupFronteiraHtml(aval))}
-                                onMouseLeave={onPopupLeave}
-                                onFocus={() => onPopupEnter(popupFronteiraHtml(aval))}
-                                onBlur={onPopupLeave}
-                              >
-                                ⓘ
-                              </button>
+                            <div className="avaliacao-modelos-linha avaliacao-modelos-linha-destaque">
+                              <span>Estimado</span>
+                              <strong>{formatarMoeda(aval.estimado)}</strong>
+                            </div>
+
+                            <div className="avaliacao-modelos-linha">
+                              <span>Extrapoladas na fronteira</span>
+                              <span>
+                                {formatarExtrapoladasNaFronteira(aval)}{' '}
+                                <button
+                                  type="button"
+                                  className="avaliacao-popup-trigger"
+                                  aria-label="Detalhes de extrapoladas na fronteira"
+                                  onMouseEnter={(event) => onPopupEnter(event, popupFronteiraHtml(aval))}
+                                  onMouseLeave={onPopupLeave}
+                                  onFocus={(event) => onPopupEnter(event, popupFronteiraHtml(aval))}
+                                  onBlur={onPopupLeave}
+                                >
+                                  ⓘ
+                                </button>
+                              </span>
                             </div>
-                            <div><strong>CA -15%:</strong> {formatarMoeda(aval.ca_inf)}</div>
-                            <div><strong>CA +15%:</strong> {formatarMoeda(aval.ca_sup)}</div>
-                            <div><strong>IC 80% Inf.:</strong> {formatarMoeda(aval.ic_inf)} ({`-${formatarNumero(aval.perc_inf, 1)}%`})</div>
-                            <div><strong>IC 80% Sup.:</strong> {formatarMoeda(aval.ic_sup)} ({`+${formatarNumero(aval.perc_sup, 1)}%`})</div>
-                            <div><strong>Amplitude:</strong> {formatarNumero(aval.amplitude, 1)}%</div>
-                            <div><strong>Qtd. extrapolações:</strong> {String(aval.qtd_extrapolacoes ?? 0)}</div>
-                          </div>
 
-                          <div className="avaliacao-modelos-graus">
-                            <span className="avaliacao-grau-item" style={{ color: corGrau(aval.precisao) }}>
-                              <strong>Precisão:</strong> {String(aval.precisao || '-')}
-                              <button
-                                type="button"
-                                className="avaliacao-popup-trigger"
-                                aria-label="Detalhes do enquadramento de precisão"
-                                onMouseEnter={() => onPopupEnter(popupPrecisaoHtml(aval))}
-                                onMouseLeave={onPopupLeave}
-                                onFocus={() => onPopupEnter(popupPrecisaoHtml(aval))}
-                                onBlur={onPopupLeave}
-                              >
-                                ⓘ
-                              </button>
-                            </span>
-                            <span className="avaliacao-grau-item" style={{ color: corGrau(aval.fundamentacao) }}>
-                              <strong>Fundamentação:</strong> {String(aval.fundamentacao || '-')}
-                              <button
-                                type="button"
-                                className="avaliacao-popup-trigger"
-                                aria-label="Detalhes do enquadramento de fundamentação"
-                                onMouseEnter={() => onPopupEnter(popupFundamentacaoHtml(aval))}
-                                onMouseLeave={onPopupLeave}
-                                onFocus={() => onPopupEnter(popupFundamentacaoHtml(aval))}
-                                onBlur={onPopupLeave}
-                              >
-                                ⓘ
-                              </button>
-                            </span>
+                            <div className="avaliacao-modelos-linha">
+                              <span>Estimativa KNN</span>
+                              <span>
+                                {formatarEstimativaKnn(aval)}{' '}
+                                <button
+                                  type="button"
+                                  className="avaliacao-knn-open-icon"
+                                  title="Abrir detalhamento KNN"
+                                  aria-label="Abrir detalhamento KNN"
+                                  onClick={() => void onAbrirDetalheKnn(item, idx)}
+                                  disabled={loading}
+                                >
+                                  ⓘ
+                                </button>
+                              </span>
+                            </div>
+
+                            {mostrarComparacaoBase ? (
+                              <div className="avaliacao-modelos-linha">
+                                <span>{`Estimado / Base (Aval. ${indiceBaseSelecionada})`}</span>
+                                <span>{ehBase ? 'Base' : calcularComparacaoBase(aval)}</span>
+                              </div>
+                            ) : null}
+                            <div className="avaliacao-modelos-linha">
+                              <span>CA −15%</span>
+                              <span>{formatarMoeda(aval.ca_inf)}</span>
+                            </div>
+                            <div className="avaliacao-modelos-linha">
+                              <span>CA +15%</span>
+                              <span>{formatarMoeda(aval.ca_sup)}</span>
+                            </div>
+                            <div className="avaliacao-modelos-linha">
+                              <span>IC 80% Inf.</span>
+                              <span>{formatarMoeda(aval.ic_inf)} ({`-${formatarNumero(aval.perc_inf, 1)}%`})</span>
+                            </div>
+                            <div className="avaliacao-modelos-linha">
+                              <span>IC 80% Sup.</span>
+                              <span>{formatarMoeda(aval.ic_sup)} ({`+${formatarNumero(aval.perc_sup, 1)}%`})</span>
+                            </div>
+                            <div className="avaliacao-modelos-linha">
+                              <span>Amplitude</span>
+                              <span>{formatarNumero(aval.amplitude, 1)}%</span>
+                            </div>
+                            <div className="avaliacao-modelos-linha">
+                              <span>Precisão</span>
+                              <span>
+                                {String(aval.precisao || '-')} {' '}
+                                <button
+                                  type="button"
+                                  className="avaliacao-popup-trigger"
+                                  aria-label="Detalhes do enquadramento de precisão"
+                                  onMouseEnter={(event) => onPopupEnter(event, popupPrecisaoHtml(aval))}
+                                  onMouseLeave={onPopupLeave}
+                                  onFocus={(event) => onPopupEnter(event, popupPrecisaoHtml(aval))}
+                                  onBlur={onPopupLeave}
+                                >
+                                  ⓘ
+                                </button>
+                              </span>
+                            </div>
+                            <div className="avaliacao-modelos-linha">
+                              <span>Fundamentação</span>
+                              <span>
+                                {String(aval.fundamentacao || '-')} {' '}
+                                <button
+                                  type="button"
+                                  className="avaliacao-popup-trigger"
+                                  aria-label="Detalhes do enquadramento de fundamentação"
+                                  onMouseEnter={(event) => onPopupEnter(event, popupFundamentacaoHtml(aval))}
+                                  onMouseLeave={onPopupLeave}
+                                  onFocus={(event) => onPopupEnter(event, popupFundamentacaoHtml(aval))}
+                                  onBlur={onPopupLeave}
+                                >
+                                  ⓘ
+                                </button>
+                              </span>
+                            </div>
                           </div>
                         </article>
                       )
@@ -1071,8 +1273,134 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
       </div>
 
       <LoadingOverlay show={loading} label="Processando dados..." />
-      {avaliacaoPopupHtml ? (
-        <div className="avaliacao-popup-overlay" dangerouslySetInnerHTML={{ __html: avaliacaoPopupHtml }} />
+      {avaliacaoPopup?.html ? (
+        <div
+          className="avaliacao-popup-overlay"
+          style={{
+            left: `${avaliacaoPopup.left}px`,
+            top: `${avaliacaoPopup.top}px`,
+            width: `${avaliacaoPopup.width}px`,
+          }}
+          dangerouslySetInnerHTML={{ __html: avaliacaoPopup.html }}
+        />
+      ) : null}
+      {knnDetalheAberto ? (
+        <div className="pesquisa-modal-backdrop" onClick={(event) => {
+          if (event.target === event.currentTarget) onFecharDetalheKnn()
+        }}
+        >
+          <div className="pesquisa-modal avaliacao-knn-modal">
+            <div className="pesquisa-modal-head">
+              <div>
+                <h4>Detalhamento KNN</h4>
+                <p>{knnDetalheCardTitulo || 'Avaliação selecionada'}</p>
+              </div>
+              <button type="button" className="pesquisa-modal-close" onClick={onFecharDetalheKnn}>
+                Fechar
+              </button>
+            </div>
+            <div className="pesquisa-modal-body">
+              {knnDetalheLoading ? (
+                <div className="empty-box">Carregando detalhes do KNN...</div>
+              ) : null}
+              {knnDetalheErro ? (
+                <div className="error-line">{knnDetalheErro}</div>
+              ) : null}
+              {!knnDetalheLoading && !knnDetalheErro ? (
+                <>
+                  <div className="subpanel avaliacao-knn-detalhes-box">
+                    <h4>Dados do KNN</h4>
+                    <div className="avaliacao-knn-resumo-grid">
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Estimativa KNN</span>
+                        <strong>{formatarEstimativaKnn(knnDetalheInfo || {})}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Método</span>
+                        <strong>{Boolean(knnDetalheInfo?.knn_geo_aplicado) ? 'Características + localização' : 'Somente características'}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>k dinâmico</span>
+                        <strong>{Number.isFinite(Number(knnDetalheInfo?.knn_k)) ? String(knnDetalheInfo.knn_k) : '—'}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Base válida</span>
+                        <strong>{Number.isFinite(Number(knnDetalheInfo?.knn_n_validos)) ? String(knnDetalheInfo.knn_n_validos) : '—'}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Peso geo (a)</span>
+                        <strong>{Number.isFinite(Number(knnDetalheInfo?.knn_alpha_geo)) ? formatarNumero(knnDetalheInfo.knn_alpha_geo, 2) : '—'}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Status</span>
+                        <strong>{Boolean(knnDetalheInfo?.knn_disponivel) ? 'Disponível' : 'Indisponível'}</strong>
+                      </div>
+                    </div>
+                    {Array.isArray(knnDetalheInfo?.knn_colunas) && knnDetalheInfo.knn_colunas.length ? (
+                      <div className="avaliacao-knn-resumo-colunas">
+                        <b>Características usadas:</b> {knnDetalheInfo.knn_colunas.join(', ')}
+                      </div>
+                    ) : null}
+                    {String(knnDetalheInfo?.knn_motivo || '').trim() ? (
+                      <div className="section1-empty-hint">{String(knnDetalheInfo.knn_motivo || '').trim()}</div>
+                    ) : null}
+                  </div>
+
+                  <div className="avaliacao-knn-legenda">
+                    <span><b>Mercado (base completa):</b> azul</span>
+                    <span><b>Selecionados KNN:</b> vermelho</span>
+                  </div>
+
+                  <div className="avaliacao-knn-map-wrap">
+                    <MapFrame html={knnDetalheMapaHtml} />
+                  </div>
+
+                  <div className="subpanel avaliacao-knn-detalhes-box">
+                    <h4>Valores do avaliando</h4>
+                    <div className="avaliacao-knn-avaliando-grid">
+                      {(knnDetalheAvaliando || []).map((item) => (
+                        <div key={`knn-aval-${String(item?.variavel || '')}`} className="avaliacao-knn-avaliando-item">
+                          <span>{String(item?.variavel || '-')}</span>
+                          <strong>{formatarValorTabelaKnn(item?.variavel, item?.valor)}</strong>
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+
+                  <div className="subpanel avaliacao-knn-detalhes-box">
+                    <h4>Linhas da base de mercado selecionadas no KNN</h4>
+                    {knnDetalheTabela?.columns?.length ? (
+                      <div className="table-wrapper avaliacao-knn-table-wrapper">
+                        <table>
+                          <thead>
+                            <tr>
+                              {knnDetalheTabela.columns.map((coluna) => (
+                                <th key={`th-knn-${coluna}`}>{String(coluna)}</th>
+                              ))}
+                            </tr>
+                          </thead>
+                          <tbody>
+                            {(knnDetalheTabela.rows || []).map((linha, idxLinha) => (
+                              <tr key={`tr-knn-${idxLinha}`}>
+                                {knnDetalheTabela.columns.map((coluna) => (
+                                  <td key={`td-knn-${idxLinha}-${coluna}`}>
+                                    {formatarValorTabelaKnn(coluna, linha?.[coluna])}
+                                  </td>
+                                ))}
+                              </tr>
+                            ))}
+                          </tbody>
+                        </table>
+                      </div>
+                    ) : (
+                      <div className="empty-box">Sem vizinhos disponíveis para esta avaliação.</div>
+                    )}
+                  </div>
+                </>
+              ) : null}
+            </div>
+          </div>
+        </div>
       ) : null}
       {error ? <div className="error-line">{error}</div> : null}
     </div>

frontend/src/components/ElaboracaoTab.jsx

@@ -216,6 +216,52 @@ function formatNumberBr(value, maximumFractionDigits = 4) {
   })
 }
 
+function formatCurrencyBr(value) {
+  const num = Number(value)
+  if (!Number.isFinite(num)) return '-'
+  return num.toLocaleString('pt-BR', { style: 'currency', currency: 'BRL' })
+}
+
+function formatarValorTabelaKnn(coluna, valor) {
+  if (valor === null || valor === undefined || valor === '') return '-'
+  const nome = String(coluna || '').toLowerCase()
+  if (typeof valor === 'number' && Number.isFinite(valor)) {
+    if (nome.includes('lat') || nome.includes('lon')) {
+      return valor.toLocaleString('pt-BR', {
+        minimumFractionDigits: 6,
+        maximumFractionDigits: 6,
+      })
+    }
+    if (nome.includes('distancia')) {
+      return valor.toLocaleString('pt-BR', {
+        minimumFractionDigits: 4,
+        maximumFractionDigits: 4,
+      })
+    }
+    return valor.toLocaleString('pt-BR', {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2,
+    })
+  }
+  return String(valor)
+}
+
+function valorPadraoCampoAvaliacao(campo) {
+  if (String(campo?.tipo || '') !== 'dicotomica') return ''
+  const opcoes = Array.isArray(campo?.opcoes) && campo.opcoes.length ? campo.opcoes : [0, 1]
+  const zero = opcoes.find((item) => Number(item) === 0)
+  if (zero !== undefined) return String(zero)
+  return String(opcoes[0] ?? 0)
+}
+
+function construirValoresIniciaisAvaliacao(campos = []) {
+  const init = {}
+  ;(campos || []).forEach((campo) => {
+    init[campo.coluna] = valorPadraoCampoAvaliacao(campo)
+  })
+  return init
+}
+
 function quantileLinear(sortedValues, q) {
   if (!Array.isArray(sortedValues) || sortedValues.length === 0) return null
   const clampedQ = Math.min(1, Math.max(0, Number(q)))
@@ -856,8 +902,17 @@ export default function ElaboracaoTab({ sessionId }) {
   const [avaliacaoPendente, setAvaliacaoPendente] = useState(false)
   const [confirmarLimpezaAvaliacoes, setConfirmarLimpezaAvaliacoes] = useState(false)
   const [resultadoAvaliacaoHtml, setResultadoAvaliacaoHtml] = useState('')
+  const [avaliacoesResultado, setAvaliacoesResultado] = useState([])
   const [baseChoices, setBaseChoices] = useState([])
   const [baseValue, setBaseValue] = useState('')
+  const [knnDetalheAberto, setKnnDetalheAberto] = useState(false)
+  const [knnDetalheLoading, setKnnDetalheLoading] = useState(false)
+  const [knnDetalheErro, setKnnDetalheErro] = useState('')
+  const [knnDetalheCardTitulo, setKnnDetalheCardTitulo] = useState('')
+  const [knnDetalheMapaHtml, setKnnDetalheMapaHtml] = useState('')
+  const [knnDetalheAvaliando, setKnnDetalheAvaliando] = useState([])
+  const [knnDetalheTabela, setKnnDetalheTabela] = useState(null)
+  const [knnDetalheInfo, setKnnDetalheInfo] = useState(null)
 
   const [nomeArquivoExport, setNomeArquivoExport] = useState('')
   const [avaliadores, setAvaliadores] = useState([])
@@ -2081,11 +2136,7 @@ export default function ElaboracaoTab({ sessionId }) {
     setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(filtros))
     setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot(outliersTexto, reincluirTexto))
     setCamposAvaliacao(resp.avaliacao_campos || [])
-    const init = {}
-    ;(resp.avaliacao_campos || []).forEach((campo) => {
-      init[campo.coluna] = ''
-    })
-    valoresAvaliacaoRef.current = init
+    valoresAvaliacaoRef.current = construirValoresIniciaisAvaliacao(resp.avaliacao_campos || [])
     setAvaliacaoFormVersion((prev) => prev + 1)
     setAvaliacaoPendente(false)
     setConfirmarLimpezaAvaliacoes(false)
@@ -2863,6 +2914,16 @@ export default function ElaboracaoTab({ sessionId }) {
     await onRestartIterationWithTexts('', joinSelection(outliersAnteriores))
   }
 
+  useEffect(() => {
+    if (resultadoAvaliacaoHtml) return
+    setAvaliacoesResultado([])
+    if (knnDetalheAberto) {
+      setKnnDetalheAberto(false)
+      setKnnDetalheLoading(false)
+      setKnnDetalheErro('')
+    }
+  }, [resultadoAvaliacaoHtml, knnDetalheAberto])
+
   async function onClearHistory() {
     if (!sessionId) return
     await withBusy(async () => {
@@ -2902,6 +2963,7 @@ export default function ElaboracaoTab({ sessionId }) {
     await withBusy(async () => {
       const resp = await api.evaluationCalculateElab(sessionId, valoresAvaliacaoRef.current, baseValue || null)
       setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setAvaliacoesResultado(Array.isArray(resp?.avaliacoes) ? resp.avaliacoes : [])
       setBaseChoices(resp.base_choices || [])
       setBaseValue(resp.base_value || '')
       setConfirmarLimpezaAvaliacoes(false)
@@ -2910,11 +2972,7 @@ export default function ElaboracaoTab({ sessionId }) {
   }
 
   function onResetCamposAvaliacao() {
-    const limpo = {}
-    camposAvaliacao.forEach((campo) => {
-      limpo[campo.coluna] = ''
-    })
-    valoresAvaliacaoRef.current = limpo
+    valoresAvaliacaoRef.current = construirValoresIniciaisAvaliacao(camposAvaliacao)
     setAvaliacaoFormVersion((prev) => prev + 1)
     setAvaliacaoPendente(false)
   }
@@ -2924,6 +2982,7 @@ export default function ElaboracaoTab({ sessionId }) {
     await withBusy(async () => {
       const resp = await api.evaluationClearElab(sessionId)
       setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setAvaliacoesResultado(Array.isArray(resp?.avaliacoes) ? resp.avaliacoes : [])
       setBaseChoices(resp.base_choices || [])
       setBaseValue(resp.base_value || '')
       setConfirmarLimpezaAvaliacoes(false)
@@ -2935,13 +2994,57 @@ export default function ElaboracaoTab({ sessionId }) {
     await withBusy(async () => {
       const resp = await api.evaluationDeleteElab(sessionId, indice ? String(indice) : null, baseValue || null)
       setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setAvaliacoesResultado(Array.isArray(resp?.avaliacoes) ? resp.avaliacoes : [])
       setBaseChoices(resp.base_choices || [])
       setBaseValue(resp.base_value || '')
       setConfirmarLimpezaAvaliacoes(false)
     })
   }
 
+  async function onAbrirDetalheKnnElab(indiceRaw) {
+    if (!sessionId) return
+    const idx = Number(indiceRaw) - 1
+    if (!Number.isInteger(idx) || idx < 0) return
+    const avaliacao = Array.isArray(avaliacoesResultado) ? avaliacoesResultado[idx] : null
+    if (!avaliacao || typeof avaliacao !== 'object' || !avaliacao.valores_x) return
+
+    setKnnDetalheAberto(true)
+    setKnnDetalheLoading(true)
+    setKnnDetalheErro('')
+    setKnnDetalheCardTitulo(`Aval. ${idx + 1}`)
+    setKnnDetalheMapaHtml('')
+    setKnnDetalheAvaliando([])
+    setKnnDetalheTabela(null)
+    setKnnDetalheInfo(null)
+
+    try {
+      const resp = await api.evaluationKnnDetailsElab(sessionId, avaliacao.valores_x)
+      setKnnDetalheMapaHtml(String(resp?.mapa_html || ''))
+      setKnnDetalheAvaliando(Array.isArray(resp?.avaliando) ? resp.avaliando : [])
+      setKnnDetalheTabela(resp?.vizinhos_tabela || null)
+      setKnnDetalheInfo(resp?.knn || null)
+    } catch (err) {
+      setKnnDetalheErro(err?.message || 'Falha ao carregar detalhes do KNN.')
+    } finally {
+      setKnnDetalheLoading(false)
+    }
+  }
+
+  function onFecharDetalheKnnElab() {
+    setKnnDetalheAberto(false)
+    setKnnDetalheLoading(false)
+    setKnnDetalheErro('')
+  }
+
   function onAvaliacaoResultadoClick(event) {
+    const ativarDetalheKnn = event.target.closest('[data-avaliacao-knn-open]')
+    if (ativarDetalheKnn) {
+      const indice = ativarDetalheKnn.getAttribute('data-avaliacao-knn-index')
+      if (!indice) return
+      void onAbrirDetalheKnnElab(indice)
+      return
+    }
+
     const ativarExclusao = event.target.closest('[data-avaliacao-delete-arm]')
     if (ativarExclusao) {
       const indice = ativarExclusao.getAttribute('data-avaliacao-delete-index')
@@ -5445,13 +5548,12 @@ export default function ElaboracaoTab({ sessionId }) {
                       <label>{campo.coluna}</label>
                       {campo.tipo === 'dicotomica' ? (
                         <select
-                          defaultValue={String(valoresAvaliacaoRef.current[campo.coluna] ?? '')}
+                          defaultValue={String(valoresAvaliacaoRef.current[campo.coluna] ?? valorPadraoCampoAvaliacao(campo))}
                           onChange={(e) => {
                             valoresAvaliacaoRef.current[campo.coluna] = e.target.value
                             setAvaliacaoPendente(true)
                           }}
                         >
-                          <option value="">Selecione</option>
                           {(campo.opcoes || [0, 1]).map((opcao) => (
                             <option key={`op-${campo.coluna}-${opcao}`} value={String(opcao)}>
                               {opcao}
@@ -5558,6 +5660,124 @@ export default function ElaboracaoTab({ sessionId }) {
           {disabledHint.text}
         </div>
       ) : null}
+      {knnDetalheAberto ? (
+        <div className="pesquisa-modal-backdrop" onClick={(event) => {
+          if (event.target === event.currentTarget) onFecharDetalheKnnElab()
+        }}
+        >
+          <div className="pesquisa-modal avaliacao-knn-modal">
+            <div className="pesquisa-modal-head">
+              <div>
+                <h4>Detalhamento KNN</h4>
+                <p>{knnDetalheCardTitulo || 'Avaliação selecionada'}</p>
+              </div>
+              <button type="button" className="pesquisa-modal-close" onClick={onFecharDetalheKnnElab}>
+                Fechar
+              </button>
+            </div>
+            <div className="pesquisa-modal-body">
+              {knnDetalheLoading ? (
+                <div className="empty-box">Carregando detalhes do KNN...</div>
+              ) : null}
+              {knnDetalheErro ? (
+                <div className="error-line">{knnDetalheErro}</div>
+              ) : null}
+              {!knnDetalheLoading && !knnDetalheErro ? (
+                <>
+                  <div className="subpanel avaliacao-knn-detalhes-box">
+                    <h4>Dados do KNN</h4>
+                    <div className="avaliacao-knn-resumo-grid">
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Estimativa KNN</span>
+                        <strong>{formatCurrencyBr(knnDetalheInfo?.knn_estimado)}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Método</span>
+                        <strong>{Boolean(knnDetalheInfo?.knn_geo_aplicado) ? 'Características + localização' : 'Somente características'}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>k dinâmico</span>
+                        <strong>{Number.isFinite(Number(knnDetalheInfo?.knn_k)) ? String(knnDetalheInfo.knn_k) : '—'}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Base válida</span>
+                        <strong>{Number.isFinite(Number(knnDetalheInfo?.knn_n_validos)) ? String(knnDetalheInfo.knn_n_validos) : '—'}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Peso geo (a)</span>
+                        <strong>{Number.isFinite(Number(knnDetalheInfo?.knn_alpha_geo)) ? formatNumberBr(knnDetalheInfo.knn_alpha_geo, 2) : '—'}</strong>
+                      </div>
+                      <div className="avaliacao-knn-resumo-item">
+                        <span>Status</span>
+                        <strong>{Boolean(knnDetalheInfo?.knn_disponivel) ? 'Disponível' : 'Indisponível'}</strong>
+                      </div>
+                    </div>
+                    {Array.isArray(knnDetalheInfo?.knn_colunas) && knnDetalheInfo.knn_colunas.length ? (
+                      <div className="avaliacao-knn-resumo-colunas">
+                        <b>Características usadas:</b> {knnDetalheInfo.knn_colunas.join(', ')}
+                      </div>
+                    ) : null}
+                    {String(knnDetalheInfo?.knn_motivo || '').trim() ? (
+                      <div className="section1-empty-hint">{String(knnDetalheInfo.knn_motivo || '').trim()}</div>
+                    ) : null}
+                  </div>
+
+                  <div className="avaliacao-knn-legenda">
+                    <span><b>Mercado (base completa):</b> azul</span>
+                    <span><b>Selecionados KNN:</b> vermelho</span>
+                  </div>
+
+                  <div className="avaliacao-knn-map-wrap">
+                    <MapFrame html={knnDetalheMapaHtml} />
+                  </div>
+
+                  <div className="subpanel avaliacao-knn-detalhes-box">
+                    <h4>Valores do avaliando</h4>
+                    <div className="avaliacao-knn-avaliando-grid">
+                      {(knnDetalheAvaliando || []).map((item) => (
+                        <div key={`knn-elab-aval-${String(item?.variavel || '')}`} className="avaliacao-knn-avaliando-item">
+                          <span>{String(item?.variavel || '-')}</span>
+                          <strong>{formatarValorTabelaKnn(item?.variavel, item?.valor)}</strong>
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+
+                  <div className="subpanel avaliacao-knn-detalhes-box">
+                    <h4>Linhas da base de mercado selecionadas no KNN</h4>
+                    {knnDetalheTabela?.columns?.length ? (
+                      <div className="table-wrapper avaliacao-knn-table-wrapper">
+                        <table>
+                          <thead>
+                            <tr>
+                              {knnDetalheTabela.columns.map((coluna) => (
+                                <th key={`th-knn-elab-${coluna}`}>{String(coluna)}</th>
+                              ))}
+                            </tr>
+                          </thead>
+                          <tbody>
+                            {(knnDetalheTabela.rows || []).map((linha, idxLinha) => (
+                              <tr key={`tr-knn-elab-${idxLinha}`}>
+                                {knnDetalheTabela.columns.map((coluna) => (
+                                  <td key={`td-knn-elab-${idxLinha}-${coluna}`}>
+                                    {formatarValorTabelaKnn(coluna, linha?.[coluna])}
+                                  </td>
+                                ))}
+                              </tr>
+                            ))}
+                          </tbody>
+                        </table>
+                      </div>
+                    ) : (
+                      <div className="empty-box">Sem vizinhos disponíveis para esta avaliação.</div>
+                    )}
+                  </div>
+                </>
+              ) : null}
+            </div>
+          </div>
+        </div>
+      ) : null}
       <LoadingOverlay show={loading} label="Processando dados..." />
       {error ? <div className="error-line">{error}</div> : null}
     </div>

frontend/src/styles.css

@@ -2392,17 +2392,20 @@ button.pesquisa-coluna-remove:hover {
   display: grid;
   grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
   gap: 12px;
+  align-items: stretch;
 }
 
 .avaliacao-modelos-card {
-  border: 1px solid #d7e3ef;
+  border: 1px solid #d5d9de;
   border-radius: 12px;
   background: #fff;
-  box-shadow: 0 2px 6px rgba(34, 52, 70, 0.08);
+  box-shadow: 0 2px 6px rgba(20, 20, 20, 0.05);
   padding: 10px 11px;
-  display: grid;
+  display: flex;
+  flex-direction: column;
   gap: 8px;
   min-width: 0;
+  height: 100%;
 }
 
 .avaliacao-modelos-card-head {
@@ -2421,13 +2424,13 @@ button.pesquisa-coluna-remove:hover {
 }
 
 .avaliacao-modelos-card-title strong {
-  color: #2f465c;
+  color: #232629;
   font-family: 'Sora', sans-serif;
   font-size: 0.87rem;
 }
 
 .avaliacao-modelos-card-title span {
-  color: #4f667d;
+  color: #454b51;
   font-size: 0.79rem;
   font-weight: 600;
   line-height: 1.2;
@@ -2437,7 +2440,7 @@ button.pesquisa-coluna-remove:hover {
 }
 
 .avaliacao-modelos-card-subtitle {
-  color: #70869b;
+  color: #5a6066;
   font-size: 0.75rem;
 }
 
@@ -2447,24 +2450,43 @@ button.pesquisa-coluna-remove:hover {
   flex: 0 0 auto;
 }
 
+.avaliacao-card-delete-confirm {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+
 .avaliacao-modelos-delete-btn {
   min-height: 28px;
   padding: 3px 8px;
   font-size: 0.74rem;
-  --btn-bg-start: #fff4f6;
-  --btn-bg-end: #fee9ed;
-  --btn-border: #e3adb8;
-  --btn-shadow-soft: rgba(178, 47, 64, 0.1);
-  --btn-shadow-strong: rgba(178, 47, 64, 0.16);
-  color: #a63446;
+  --btn-bg-start: #f6f7f8;
+  --btn-bg-end: #eceff2;
+  --btn-border: #c9d0d7;
+  --btn-shadow-soft: rgba(36, 41, 46, 0.08);
+  --btn-shadow-strong: rgba(36, 41, 46, 0.14);
+  color: #1f252b;
+}
+
+.avaliacao-modelos-delete-cancel-btn {
+  min-height: 28px;
+  padding: 3px 8px;
+  font-size: 0.74rem;
+  --btn-bg-start: #ffffff;
+  --btn-bg-end: #f5f7f9;
+  --btn-border: #c9d0d7;
+  --btn-shadow-soft: rgba(36, 41, 46, 0.06);
+  --btn-shadow-strong: rgba(36, 41, 46, 0.1);
+  color: #1f252b;
 }
 
 .avaliacao-modelos-card-base {
-  color: #3c546a;
+  color: #2f3438;
   font-size: 0.8rem;
-  border: 1px solid #e3ebf3;
+  border: 1px solid #e0e4e8;
   border-radius: 8px;
-  background: #fbfdff;
+  background: #fafbfc;
   padding: 6px 8px;
 }
 
@@ -2489,15 +2511,15 @@ button.pesquisa-coluna-remove:hover {
   grid-template-columns: minmax(88px, auto) minmax(0, 1fr);
   gap: 6px;
   align-items: center;
-  border: 1px solid #edf2f7;
+  border: 1px solid #e8ebef;
   border-radius: 7px;
-  background: #fcfdff;
+  background: #fcfcfd;
   padding: 5px 7px;
   font-size: 0.78rem;
 }
 
 .avaliacao-modelos-vars-item span:first-child {
-  color: #526a80;
+  color: #32373c;
   font-weight: 700;
   min-width: 0;
   overflow-wrap: anywhere;
@@ -2505,7 +2527,7 @@ button.pesquisa-coluna-remove:hover {
 }
 
 .avaliacao-modelos-vars-item span:last-child {
-  color: #2e475d;
+  color: #2b3034;
   text-align: right;
   min-width: 0;
   overflow-wrap: anywhere;
@@ -2515,16 +2537,95 @@ button.pesquisa-coluna-remove:hover {
 .avaliacao-modelos-metrics {
   display: grid;
   gap: 3px;
-  color: #40596f;
+  color: #2e3338;
   font-size: 0.78rem;
 }
 
+.avaliacao-knn-open-icon {
+  all: unset;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  height: 18px;
+  border-radius: 999px;
+  border: 1px solid #9fd3ac;
+  background: #eefaf1;
+  color: #2a7f43;
+  font-size: 0.85em;
+  line-height: 1;
+  cursor: pointer;
+  transition: background 0.15s ease, border-color 0.15s ease;
+}
+
+.avaliacao-knn-open-icon:hover {
+  background: #e2f6e7;
+  border-color: #73bb87;
+}
+
+.avaliacao-modelos-card .avaliacao-knn-open-icon {
+  border-color: #c8cfd7;
+  background: #f6f7f9;
+  color: #1f252b;
+}
+
+.avaliacao-modelos-card .avaliacao-knn-open-icon:hover {
+  background: #eceff3;
+  border-color: #aeb7c2;
+}
+
+.avaliacao-knn-open-icon:disabled {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
 .avaliacao-modelos-graus {
   display: grid;
   gap: 3px;
   padding-top: 2px;
-  border-top: 1px solid #ecf2f8;
+  border-top: 1px solid #e6e9ed;
   font-size: 0.79rem;
+  margin-top: auto;
+}
+
+.avaliacao-modelos-linhas {
+  display: grid;
+  gap: 4px;
+}
+
+.avaliacao-modelos-linha {
+  display: grid;
+  grid-template-columns: minmax(118px, auto) minmax(0, 1fr);
+  gap: 7px;
+  align-items: center;
+  border: 1px solid #e8ebef;
+  border-radius: 7px;
+  background: #fcfcfd;
+  padding: 5px 7px;
+  font-size: 0.78rem;
+  color: #22272c;
+}
+
+.avaliacao-modelos-linha span:first-child {
+  font-weight: 700;
+  color: #30353a;
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.avaliacao-modelos-linha span:last-child {
+  text-align: right;
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.avaliacao-modelos-linha-destaque {
+  background: #f3f4f6;
+  border-color: #d8dce1;
+}
+
+.avaliacao-modelos-linha-destaque strong {
+  color: #111315;
 }
 
 .avaliacao-grau-item {
@@ -2548,11 +2649,8 @@ button.pesquisa-coluna-remove:hover {
 
 .avaliacao-popup-overlay {
   position: fixed;
-  left: 50%;
-  top: 50%;
-  transform: translate(-50%, -50%);
   z-index: 3600;
-  width: min(520px, calc(100vw - 24px));
+  max-width: calc(100vw - 24px);
   background: #fff;
   border: 1px solid #dee2e6;
   border-radius: 8px;
@@ -2569,6 +2667,97 @@ button.pesquisa-coluna-remove:hover {
   pointer-events: none;
 }
 
+.avaliacao-knn-modal {
+  width: min(1180px, 100%);
+}
+
+.avaliacao-knn-legenda {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 12px;
+  font-size: 0.83rem;
+  color: #445d74;
+  margin-bottom: 2px;
+}
+
+.avaliacao-knn-map-wrap .map-frame {
+  min-height: 420px;
+  height: 420px;
+}
+
+.avaliacao-knn-detalhes-box {
+  margin-bottom: 0;
+}
+
+.avaliacao-knn-resumo-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(165px, 1fr));
+  gap: 6px;
+}
+
+.avaliacao-knn-resumo-item {
+  border: 1px solid #e2ebf3;
+  border-radius: 8px;
+  background: #fafdff;
+  padding: 6px 8px;
+  display: grid;
+  gap: 2px;
+}
+
+.avaliacao-knn-resumo-item span {
+  color: #4b647a;
+  font-size: 0.76rem;
+  font-weight: 700;
+}
+
+.avaliacao-knn-resumo-item strong {
+  color: #2f4a60;
+  font-size: 0.84rem;
+}
+
+.avaliacao-knn-resumo-colunas {
+  margin-top: 7px;
+  color: #4a6379;
+  font-size: 0.82rem;
+}
+
+.avaliacao-knn-avaliando-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(170px, 1fr));
+  gap: 6px;
+}
+
+.avaliacao-knn-avaliando-item {
+  border: 1px solid #e2ebf3;
+  border-radius: 8px;
+  background: #fafdff;
+  padding: 6px 8px;
+  display: grid;
+  gap: 2px;
+}
+
+.avaliacao-knn-avaliando-item span {
+  color: #4b647a;
+  font-size: 0.76rem;
+  font-weight: 700;
+}
+
+.avaliacao-knn-avaliando-item strong {
+  color: #2f4a60;
+  font-size: 0.84rem;
+}
+
+.avaliacao-knn-table-wrapper {
+  max-height: min(44vh, 420px);
+}
+
+@media (max-width: 900px) {
+  .avaliacao-knn-map-wrap .map-frame {
+    min-height: 340px;
+    height: 340px;
+  }
+}
+
 label {
   font-weight: 700;
   color: #394a5e;