Improve elaboracao interactions and pesquisa map behavior

backend/app/api/elaboracao.py

@@ -129,7 +129,8 @@ class AvaliacaoPayload(SessionPayload):
 
 
 class AvaliacaoKnnDetalhesPayload(SessionPayload):
-    valores_x: dict[str, Any]
+    valores_x: dict[str, Any] | None = None
+    indice_avaliacao: int | None = None
 
 
 class AvaliacaoDeletePayload(SessionPayload):
@@ -401,7 +402,11 @@ def evaluation_calculate(payload: AvaliacaoPayload, request: Request) -> dict[st
 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)
+    resposta = elaboracao_service.detalhes_knn_avaliacao_elaboracao(
+        session,
+        payload.valores_x,
+        payload.indice_avaliacao,
+    )
     log_event(
         "elaboracao",
         "avaliacao_knn_detalhes",

backend/app/core/map_layers.py

@@ -231,6 +231,7 @@ def build_trabalhos_tecnicos_marker_payloads(
         endereco = str(item.get("endereco") or "").strip()
         numero = str(item.get("numero") or "").strip()
         modelos = [str(valor).strip() for valor in (item.get("modelos_relacionados") or []) if str(valor).strip()]
+        modelos_origem_ids = [str(valor).strip() for valor in (item.get("modelos_origem_ids") or []) if str(valor).strip()]
 
         endereco_parts = []
         if endereco:
@@ -306,6 +307,7 @@ def build_trabalhos_tecnicos_marker_payloads(
                     "lon": lon,
                     "tooltip_html": detalhes_html,
                     "popup_html": detalhes_html,
+                    "source_overlay_ids": modelos_origem_ids,
                     "marker_html": marker_html,
                     "marker_style": "estrela",
                     "ignore_bounds": bool(ignore_bounds),
@@ -327,6 +329,7 @@ def build_trabalhos_tecnicos_marker_payloads(
                 "lon": lon,
                 "tooltip_html": detalhes_html,
                 "popup_html": detalhes_html,
+                "source_overlay_ids": modelos_origem_ids,
                 "marker_html": marker_html,
                 "marker_style": "ponto",
                 "ignore_bounds": bool(ignore_bounds),

backend/app/core/visualizacao/app.py

@@ -929,7 +929,7 @@ def criar_mapa(
         camada_indices.add_to(mapa)
 
     if avaliandos_tecnicos:
-        camada_trabalhos_tecnicos = folium.FeatureGroup(name="Avaliandos", show=True)
+        camada_trabalhos_tecnicos = folium.FeatureGroup(name="Trabalhos tecnicos", show=True)
         add_trabalhos_tecnicos_markers(camada_trabalhos_tecnicos, avaliandos_tecnicos)
         camada_trabalhos_tecnicos.add_to(mapa)
 

backend/app/services/elaboracao_service.py

@@ -2248,7 +2248,11 @@ def calcular_avaliacao_elaboracao(
     }
 
 
-def detalhes_knn_avaliacao_elaboracao(session: SessionState, valores_x: dict[str, Any]) -> dict[str, Any]:
+def detalhes_knn_avaliacao_elaboracao(
+    session: SessionState,
+    valores_x: dict[str, Any] | None = None,
+    indice_avaliacao: int | None = None,
+) -> 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:
@@ -2258,12 +2262,31 @@ def detalhes_knn_avaliacao_elaboracao(session: SessionState, valores_x: dict[str
     if not colunas_x:
         raise HTTPException(status_code=400, detail="Modelo sem variaveis")
 
+    valores_resolvidos: dict[str, Any] = {}
+    idx_avaliacao = (int(indice_avaliacao) - 1) if indice_avaliacao is not None else None
+    if idx_avaliacao is not None and 0 <= idx_avaliacao < len(session.avaliacoes_elaboracao):
+        avaliacao_sessao = session.avaliacoes_elaboracao[idx_avaliacao]
+        if isinstance(avaliacao_sessao, dict):
+            valores_resolvidos.update(avaliacao_sessao.get("valores_x") or {})
+            coluna_area_sessao = str(avaliacao_sessao.get("coluna_area") or "").strip()
+            valor_area_sessao = avaliacao_sessao.get("valor_area")
+            if (
+                coluna_area_sessao
+                and coluna_area_sessao not in valores_resolvidos
+                and valor_area_sessao is not None
+            ):
+                valores_resolvidos[coluna_area_sessao] = valor_area_sessao
+    if isinstance(valores_x, dict):
+        valores_resolvidos.update(valores_x)
+    if not valores_resolvidos:
+        raise HTTPException(status_code=400, detail="Avaliacao selecionada indisponivel para detalhamento do KNN.")
+
     entradas: dict[str, float] = {}
     for col in colunas_x:
-        if col not in valores_x:
+        if col not in valores_resolvidos:
             raise HTTPException(status_code=400, detail=f"Valor ausente para {col}")
         try:
-            entradas[col] = float(valores_x[col])
+            entradas[col] = float(valores_resolvidos[col])
         except Exception as exc:
             raise HTTPException(status_code=400, detail=f"Valor invalido para {col}") from exc
 
@@ -2288,7 +2311,7 @@ def detalhes_knn_avaliacao_elaboracao(session: SessionState, valores_x: dict[str
         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")
 
-    valor_area = _resolver_valor_area_avaliacao(valores_x, session.coluna_area)
+    valor_area = _resolver_valor_area_avaliacao(valores_resolvidos, session.coluna_area)
     if session.tipo_y and valor_area is None:
         raise HTTPException(status_code=400, detail="Informe um valor de area maior que 1 para a coluna configurada.")
 
@@ -2299,12 +2322,12 @@ def detalhes_knn_avaliacao_elaboracao(session: SessionState, valores_x: dict[str
     coluna_y_knn = str(session.coluna_y or session.resultado_modelo.get("coluna_y") or "").strip()
     resultado_knn = enriquecer_resultado_knn_com_area(
         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,
+            df_base=df_knn,
+            coluna_y=coluna_y_knn,
+            colunas_x=colunas_x,
+            valores_x=entradas,
+            alpha_geo=0.35,
+            retornar_detalhes=True,
         ),
         tipo_y=session.tipo_y,
         coluna_area=session.coluna_area,

backend/app/services/pesquisa_service.py

@@ -876,6 +876,44 @@ def _listar_avaliandos_tecnicos_proximos_por_avaliandos(
     return sanitize_value(consolidado)
 
 
+def _consolidar_trabalhos_tecnicos_modelos(modelos_plotados: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    agregados: dict[tuple[str, str, str, str, str, str], dict[str, Any]] = {}
+
+    for modelo in modelos_plotados or []:
+        modelo_id = str(modelo.get("id") or "").strip()
+        for item in (modelo.get("avaliandos_tecnicos") or []):
+            if not isinstance(item, dict):
+                continue
+            chave = _chave_unica_trabalho_tecnico(item)
+            atual = agregados.get(chave)
+            if atual is None:
+                novo_item = dict(item)
+                novo_item["modelos_relacionados"] = [str(valor).strip() for valor in (item.get("modelos_relacionados") or []) if str(valor).strip()]
+                novo_item["modelos_origem_ids"] = [modelo_id] if modelo_id else []
+                agregados[chave] = novo_item
+                continue
+
+            _append_aliases_unicos(
+                atual.setdefault("modelos_relacionados", []),
+                *[str(valor).strip() for valor in (item.get("modelos_relacionados") or []) if str(valor).strip()],
+            )
+            if modelo_id:
+                _append_aliases_unicos(atual.setdefault("modelos_origem_ids", []), modelo_id)
+            for campo in ("trabalho_nome", "tipo_label", "label", "endereco", "numero"):
+                if not str(atual.get(campo) or "").strip() and str(item.get(campo) or "").strip():
+                    atual[campo] = item.get(campo)
+
+    consolidado = list(agregados.values())
+    consolidado.sort(
+        key=lambda item: (
+            str(item.get("trabalho_nome") or "").casefold(),
+            str(item.get("label") or item.get("endereco") or "").casefold(),
+            str(item.get("numero") or "").casefold(),
+        )
+    )
+    return sanitize_value(consolidado)
+
+
 def gerar_mapa_modelos(
     modelos_ids: list[str],
     limite_pontos_por_modelo: int = 0,
@@ -1193,12 +1231,16 @@ def _marker_payloads_avaliandos(avaliandos_geo: list[dict[str, Any]]) -> list[di
         marker_html = (
             "<div style='display:flex;align-items:center;justify-content:center;"
             "width:30px;height:30px;filter:drop-shadow(0 2px 6px rgba(0,0,0,0.22));'>"
-            "<svg viewBox='0 0 24 24' width='28' height='28' aria-hidden='true'>"
+            "<div style='display:flex;align-items:center;justify-content:center;"
+            "width:24px;height:24px;border-radius:999px;background:rgba(255,255,255,0.97);"
+            "box-shadow:0 0 0 1.4px rgba(255,255,255,0.98),0 0 0 2.5px rgba(0,0,0,0.74);'>"
+            "<svg viewBox='0 0 24 24' width='20' height='20' aria-hidden='true'>"
             "<path d='M12 3.2L3.9 10v10.1h5.4v-5.3h5.4v5.3h5.4V10L12 3.2Z' "
-            "fill='#c62828' stroke='rgba(255,255,255,0.96)' stroke-width='1.5' stroke-linejoin='round'/>"
+            "fill='#c62828' stroke='rgba(255,255,255,0.96)' stroke-width='1.2' stroke-linejoin='round'/>"
             "<rect x='10.1' y='15.2' width='3.8' height='4.9' rx='0.5' fill='rgba(255,255,255,0.96)'/>"
             "</svg>"
             "</div>"
+            "</div>"
         )
         payloads.append(
             {
@@ -1299,13 +1341,13 @@ def _build_mapa_modelos_payload(
     avaliando_unico = avaliandos_geo[0] if len(avaliandos_geo) == 1 else None
     aval_lat = avaliando_unico.get("lat") if avaliando_unico is not None else None
     aval_lon = avaliando_unico.get("lon") if avaliando_unico is not None else None
+    trabalhos_tecnicos_modelos = _consolidar_trabalhos_tecnicos_modelos(modelos_plotados)
 
     for modelo in modelos_plotados:
         layer: dict[str, Any] = {
             "id": str(modelo.get("id") or ""),
             "label": str(modelo.get("nome") or "Modelo"),
             "show": True,
-            "markers": build_trabalhos_tecnicos_marker_payloads(modelo.get("avaliandos_tecnicos") or []),
         }
         if modo_exibicao == "pontos":
             tooltip_html = _tooltip_mapa_modelo_html(modelo)
@@ -1326,12 +1368,23 @@ def _build_mapa_modelos_payload(
             layer["shapes"] = _shapes_modelo_payload(modelo, aval_lat, aval_lon)
         overlay_layers.append(layer)
 
+    if trabalhos_tecnicos_modelos:
+        overlay_layers.append(
+            {
+                "id": "trabalhos-tecnicos-modelos",
+                "label": "Trabalhos tecnicos dos modelos",
+                "show": True,
+                "markers": build_trabalhos_tecnicos_marker_payloads(trabalhos_tecnicos_modelos),
+            }
+        )
+
     if avaliandos_tecnicos_proximos is not None:
         label_raio = f" (até {int(trabalhos_tecnicos_raio_m or 0)} m)" if trabalhos_tecnicos_raio_m is not None else ""
         proximos_layer: dict[str, Any] = {
             "id": "trabalhos-tecnicos-proximos",
             "label": f"Trabalhos técnicos próximos{label_raio}",
             "show": True,
+            "required_overlay_ids": ["trabalhos-tecnicos-modelos"],
             "markers": build_trabalhos_tecnicos_marker_payloads(
                 avaliandos_tecnicos_proximos or [],
                 origem="pesquisa_mapa",
@@ -1409,6 +1462,12 @@ def _renderizar_mapa_modelos(
     add_bairros_layer(mapa, show=True)
     nome_camada_avaliando = "Avaliando" if len(avaliandos_geo) == 1 else "Avaliandos"
     camada_avaliando = folium.FeatureGroup(name=nome_camada_avaliando, show=True)
+    trabalhos_tecnicos_modelos = _consolidar_trabalhos_tecnicos_modelos(modelos_plotados)
+    camada_trabalhos_modelos = (
+        folium.FeatureGroup(name="Trabalhos tecnicos dos modelos", show=True)
+        if trabalhos_tecnicos_modelos
+        else None
+    )
     camada_trabalhos_proximos = None
     if avaliandos_tecnicos_proximos is not None:
         label_raio = f" (ate {int(trabalhos_tecnicos_raio_m or 0)} m)" if trabalhos_tecnicos_raio_m is not None else ""
@@ -1451,10 +1510,12 @@ def _renderizar_mapa_modelos(
 
         if renderizar_cobertura:
             _adicionar_geometria_modelo_no_mapa(camada_modelo, camada_modelo, modelo, aval_lat, aval_lon)
-
-        add_trabalhos_tecnicos_markers(camada_modelo, modelo.get("avaliandos_tecnicos") or [])
         camada_modelo.add_to(mapa)
 
+    if camada_trabalhos_modelos is not None:
+        add_trabalhos_tecnicos_markers(camada_trabalhos_modelos, trabalhos_tecnicos_modelos)
+        camada_trabalhos_modelos.add_to(mapa)
+
     if camada_trabalhos_proximos is not None:
         if int(trabalhos_tecnicos_raio_m or 0) > 0:
             for idx, avaliando in enumerate(avaliandos_geo):
@@ -1495,14 +1556,20 @@ def _renderizar_mapa_modelos(
         marker_icon = folium.DivIcon(
             html=(
                 "<div style='display:flex;align-items:center;justify-content:center;"
-                "width:28px;height:28px;border-radius:999px;background:#c62828;color:#fff;"
-                "font-weight:800;font-size:12px;border:2px solid rgba(255,255,255,0.95);"
-                "box-shadow:0 2px 6px rgba(0,0,0,0.18);'>"
-                f"{escape(label)}"
+                "width:30px;height:30px;filter:drop-shadow(0 2px 6px rgba(0,0,0,0.22));'>"
+                "<div style='display:flex;align-items:center;justify-content:center;"
+                "width:24px;height:24px;border-radius:999px;background:rgba(255,255,255,0.97);"
+                "box-shadow:0 0 0 1.4px rgba(255,255,255,0.98),0 0 0 2.5px rgba(0,0,0,0.74);'>"
+                "<svg viewBox='0 0 24 24' width='20' height='20' aria-hidden='true'>"
+                "<path d='M12 3.2L3.9 10v10.1h5.4v-5.3h5.4v5.3h5.4V10L12 3.2Z' "
+                "fill='#c62828' stroke='rgba(255,255,255,0.96)' stroke-width='1.2' stroke-linejoin='round'/>"
+                "<rect x='10.1' y='15.2' width='3.8' height='4.9' rx='0.5' fill='rgba(255,255,255,0.96)'/>"
+                "</svg>"
+                "</div>"
                 "</div>"
             ),
-            icon_size=(28, 28),
-            icon_anchor=(14, 14),
+            icon_size=(30, 30),
+            icon_anchor=(15, 15),
             class_name="mesa-avaliando-marker",
         )
         folium.Marker(

backend/app/services/trabalhos_tecnicos_importer.py

@@ -13,7 +13,11 @@ from typing import Any
 
 DEFAULT_SOURCE_XLSX_FILE = "dados_geocodificados_limpos_v2.xlsx"
 DEFAULT_LOCAL_DB_FILE = "trabalhos_tecnicos.sqlite3"
-COLUNAS_ESPERADAS = ["ANO", "AVALIANDO", "MODELO", "ENDERECO", "NUM", "x", "y"]
+COLUNAS_BASE_OBRIGATORIAS = ["ANO", "MODELO", "ENDERECO", "NUM", "x", "y"]
+COLUNAS_IDENTIFICADORAS = ["NOME_PASTA", "AVALIANDO", "TRABALHO"]
+COLUNAS_TECNICO = ["TÉCNICO", "TECNICO"]
+COLUNA_PROCESSO = "PROCESSO"
+COLUNA_FINALIDADE_PROCESSO = "FINALIDADE PROCESSO"
 TIPO_LABELS = {
     "LA": "Laudo de Avaliacao",
     "PT": "Parecer Tecnico",
@@ -48,9 +52,14 @@ XLSX_NS = {
 class TrabalhoRawGroup:
     raw_name: str
     ano: int | None = None
+    codigo_trabalho: str = ""
+    nome_pasta: str = ""
     endereco_base: str = ""
     numero_base: str = ""
     first_row_number: int = 0
+    tecnicos: dict[str, int] = field(default_factory=dict)
+    processos: dict[str, int] = field(default_factory=dict)
+    finalidades_processo: dict[str, int] = field(default_factory=dict)
     modelos: dict[str, int] = field(default_factory=dict)
     imoveis: dict[tuple[str, str, str, str], dict[str, Any]] = field(default_factory=dict)
     registros: list[dict[str, Any]] = field(default_factory=list)
@@ -69,6 +78,14 @@ def _clean_text(value: Any) -> str:
     return text
 
 
+def _first_non_empty(record: dict[str, Any], *keys: str) -> str:
+    for key in keys:
+        text = _clean_text(record.get(key))
+        if text:
+            return text
+    return ""
+
+
 def _to_int(value: Any) -> int | None:
     text = _clean_text(value)
     if not text:
@@ -215,24 +232,41 @@ def read_xlsx_rows(path: str | Path) -> tuple[str, list[dict[str, Any]]]:
 
 
 def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup], int]:
-    missing_columns = [column for column in COLUNAS_ESPERADAS if not records or column not in records[0]]
+    if not records:
+        raise ValueError("Planilha sem linhas de dados")
+
+    available_columns = set(records[0].keys())
+    missing_columns = [column for column in COLUNAS_BASE_OBRIGATORIAS if column not in available_columns]
     if missing_columns:
         raise ValueError(f"Planilha sem colunas obrigatorias: {', '.join(missing_columns)}")
+    if not any(column in available_columns for column in COLUNAS_IDENTIFICADORAS):
+        raise ValueError(
+            "Planilha sem coluna identificadora obrigatoria: informe ao menos uma entre "
+            + ", ".join(COLUNAS_IDENTIFICADORAS)
+        )
 
     groups: dict[str, TrabalhoRawGroup] = {}
     invalid_rows = 0
 
     for offset, record in enumerate(records, start=2):
-        raw_name = _clean_text(record.get("AVALIANDO"))
+        nome_pasta = _clean_text(record.get("NOME_PASTA"))
+        codigo_trabalho = _clean_text(record.get("TRABALHO"))
+        raw_name = _first_non_empty(record, "NOME_PASTA", "AVALIANDO", "TRABALHO")
         if not raw_name:
             invalid_rows += 1
             continue
 
+        tecnico = _first_non_empty(record, *COLUNAS_TECNICO)
+        processo = _clean_text(record.get(COLUNA_PROCESSO))
+        finalidade_processo = _clean_text(record.get(COLUNA_FINALIDADE_PROCESSO))
+
         group = groups.get(raw_name)
         if group is None:
             group = TrabalhoRawGroup(
                 raw_name=raw_name,
                 ano=_to_int(record.get("ANO")),
+                codigo_trabalho=codigo_trabalho,
+                nome_pasta=nome_pasta,
                 endereco_base=_clean_text(record.get("ENDERECO")),
                 numero_base=_clean_text(record.get("NUM")),
                 first_row_number=offset,
@@ -241,6 +275,10 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
         else:
             if group.ano is None:
                 group.ano = _to_int(record.get("ANO"))
+            if not group.codigo_trabalho:
+                group.codigo_trabalho = codigo_trabalho
+            if not group.nome_pasta:
+                group.nome_pasta = nome_pasta
             if not group.endereco_base:
                 group.endereco_base = _clean_text(record.get("ENDERECO"))
             if not group.numero_base:
@@ -252,6 +290,12 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
         coord_x = _to_float(record.get("x"))
         coord_y = _to_float(record.get("y"))
 
+        if tecnico:
+            group.tecnicos.setdefault(tecnico, len(group.tecnicos) + 1)
+        if processo:
+            group.processos.setdefault(processo, len(group.processos) + 1)
+        if finalidade_processo:
+            group.finalidades_processo.setdefault(finalidade_processo, len(group.finalidades_processo) + 1)
         if modelo_nome:
             group.modelos.setdefault(modelo_nome, len(group.modelos) + 1)
 
@@ -280,6 +324,11 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
                 "source_row": offset,
                 "ano": _to_int(record.get("ANO")),
                 "nome_original": raw_name,
+                "codigo_trabalho": codigo_trabalho,
+                "nome_pasta": nome_pasta,
+                "tecnico": tecnico,
+                "processo": processo,
+                "finalidade_processo": finalidade_processo,
                 "modelo_nome": modelo_nome,
                 "endereco": endereco,
                 "numero": numero or "S/N",
@@ -292,9 +341,9 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
 
     used_names: dict[str, str] = {}
     for group in ordered_groups:
-        base_name = build_clean_trabalho_name(group.raw_name, group.endereco_base, group.numero_base)
+        base_name = build_clean_trabalho_name(group.nome_pasta or group.raw_name, group.endereco_base, group.numero_base)
         if not base_name:
-            base_name = _slugify(group.raw_name) or f"TRABALHO_{group.first_row_number}"
+            base_name = _slugify(group.nome_pasta or group.raw_name) or f"TRABALHO_{group.first_row_number}"
         candidate = base_name
         suffix = 2
         while candidate in used_names and used_names[candidate] != group.raw_name:
@@ -306,6 +355,15 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
     return ordered_groups, invalid_rows
 
 
+def _summarize_ordered_values(values: dict[str, int]) -> str:
+    ordered = [value for value, _ in sorted(values.items(), key=lambda item: (item[1], item[0].lower()))]
+    if not ordered:
+        return ""
+    if len(ordered) == 1:
+        return ordered[0]
+    return f"{ordered[0]} (+{len(ordered) - 1})"
+
+
 def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict[str, Any]:
     source_path = Path(xlsx_path).expanduser().resolve()
     target_path = Path(db_path).expanduser().resolve()
@@ -333,6 +391,8 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
               trabalho_id TEXT PRIMARY KEY,
               nome TEXT NOT NULL,
               nome_original TEXT NOT NULL,
+              codigo_trabalho TEXT,
+              nome_pasta TEXT,
               tipo_codigo TEXT NOT NULL,
               tipo_label TEXT NOT NULL,
               ano INTEGER,
@@ -340,6 +400,9 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
               numero_principal TEXT,
               endereco_resumo TEXT,
               modelo_resumo TEXT,
+              tecnico_resumo TEXT,
+              processo_resumo TEXT,
+              finalidade_processo_resumo TEXT,
               total_registros INTEGER NOT NULL,
               total_imoveis INTEGER NOT NULL,
               total_modelos INTEGER NOT NULL,
@@ -375,6 +438,11 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
               source_row INTEGER NOT NULL,
               ano INTEGER,
               nome_original TEXT NOT NULL,
+              codigo_trabalho TEXT,
+              nome_pasta TEXT,
+              tecnico TEXT,
+              processo TEXT,
+              finalidade_processo TEXT,
               modelo_nome TEXT,
               endereco TEXT,
               numero TEXT,
@@ -398,7 +466,7 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
             "invalid_row_count": str(invalid_rows),
             "total_trabalhos": str(len(groups)),
             "generated_at_utc": imported_at,
-            "generator_version": "sqlite-v1",
+            "generator_version": "sqlite-v2",
         }
         conn.executemany(
             "INSERT INTO meta (key, value) VALUES (?, ?)",
@@ -417,6 +485,9 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                 modelo_resumo = modelos_ordenados[0][0]
             elif len(modelos_ordenados) > 1:
                 modelo_resumo = f"{len(modelos_ordenados)} modelos vinculados"
+            tecnico_resumo = _summarize_ordered_values(group.tecnicos)
+            processo_resumo = _summarize_ordered_values(group.processos)
+            finalidade_processo_resumo = _summarize_ordered_values(group.finalidades_processo)
 
             conn.execute(
                 """
@@ -424,6 +495,8 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                   trabalho_id,
                   nome,
                   nome_original,
+                  codigo_trabalho,
+                  nome_pasta,
                   tipo_codigo,
                   tipo_label,
                   ano,
@@ -431,16 +504,21 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                   numero_principal,
                   endereco_resumo,
                   modelo_resumo,
+                  tecnico_resumo,
+                  processo_resumo,
+                  finalidade_processo_resumo,
                   total_registros,
                   total_imoveis,
                   total_modelos,
                   tem_coordenadas
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     group.clean_name,
                     group.clean_name,
                     group.raw_name,
+                    group.codigo_trabalho or None,
+                    group.nome_pasta or None,
                     tipo_codigo,
                     _tipo_label(tipo_codigo),
                     group.ano,
@@ -448,6 +526,9 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                     group.numero_base or "S/N",
                     endereco_resumo,
                     modelo_resumo,
+                    tecnico_resumo or None,
+                    processo_resumo or None,
+                    finalidade_processo_resumo or None,
                     len(group.registros),
                     len(imoveis_ordenados),
                     len(modelos_ordenados),
@@ -491,18 +572,28 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                       source_row,
                       ano,
                       nome_original,
+                      codigo_trabalho,
+                      nome_pasta,
+                      tecnico,
+                      processo,
+                      finalidade_processo,
                       modelo_nome,
                       endereco,
                       numero,
                       coord_x,
                       coord_y
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                     """,
                     (
                         group.clean_name,
                         registro["source_row"],
                         registro["ano"],
                         registro["nome_original"],
+                        registro["codigo_trabalho"] or None,
+                        registro["nome_pasta"] or None,
+                        registro["tecnico"] or None,
+                        registro["processo"] or None,
+                        registro["finalidade_processo"] or None,
                         registro["modelo_nome"],
                         registro["endereco"],
                         registro["numero"],

backend/app/services/trabalhos_tecnicos_service.py

@@ -349,6 +349,80 @@ def _dedupe_text_list(values: Any) -> list[str]:
     return resultado
 
 
+def _table_has_column(conn: sqlite3.Connection, table_name: str, column_name: str) -> bool:
+    try:
+        rows = conn.execute(f"PRAGMA table_info({table_name})").fetchall()
+    except Exception:
+        return False
+    column_name_norm = str(column_name or "").strip().casefold()
+    return any(str(row["name"] or "").strip().casefold() == column_name_norm for row in rows)
+
+
+def _resumo_textos(valores: list[str], limite_inline: int = 2) -> str:
+    unicos = _dedupe_text_list(valores)
+    if not unicos:
+        return ""
+    if len(unicos) <= limite_inline:
+        return " | ".join(unicos)
+    return " | ".join(unicos[:limite_inline]) + f" | +{len(unicos) - limite_inline}"
+
+
+def _carregar_processos_importados_por_trabalho(
+    conn: sqlite3.Connection,
+    trabalho_id: str | None = None,
+) -> dict[str, list[str]]:
+    processos_por_trabalho: dict[str, list[str]] = {}
+
+    if _table_has_column(conn, "trabalho_registros", "processo"):
+        params: list[Any] = []
+        where_clause = "WHERE TRIM(COALESCE(processo, '')) <> ''"
+        if trabalho_id:
+            where_clause += " AND trabalho_id = ?"
+            params.append(trabalho_id)
+        rows = conn.execute(
+            f"""
+            SELECT trabalho_id, processo
+            FROM trabalho_registros
+            {where_clause}
+            ORDER BY trabalho_id, source_row, LOWER(TRIM(processo))
+            """,
+            params,
+        ).fetchall()
+        for row in rows:
+            chave = str(row["trabalho_id"] or "").strip()
+            processo = str(row["processo"] or "").strip()
+            if not chave or not processo:
+                continue
+            processos_por_trabalho.setdefault(chave, []).append(processo)
+
+    if processos_por_trabalho:
+        return {chave: _dedupe_text_list(valores) for chave, valores in processos_por_trabalho.items()}
+
+    if _table_has_column(conn, "trabalhos", "processo_resumo"):
+        params = []
+        where_clause = "WHERE TRIM(COALESCE(processo_resumo, '')) <> ''"
+        if trabalho_id:
+            where_clause += " AND trabalho_id = ?"
+            params.append(trabalho_id)
+        rows = conn.execute(
+            f"""
+            SELECT trabalho_id, processo_resumo
+            FROM trabalhos
+            {where_clause}
+            ORDER BY LOWER(trabalho_id)
+            """,
+            params,
+        ).fetchall()
+        for row in rows:
+            chave = str(row["trabalho_id"] or "").strip()
+            processo = str(row["processo_resumo"] or "").strip()
+            if not chave or not processo:
+                continue
+            processos_por_trabalho[chave] = [processo]
+
+    return {chave: _dedupe_text_list(valores) for chave, valores in processos_por_trabalho.items()}
+
+
 def _tipo_label_from_codigo(codigo: Any, fallback: Any = None) -> str:
     codigo_texto = str(codigo or "").strip().upper()
     if codigo_texto in TIPO_LABELS:
@@ -432,6 +506,7 @@ def _parse_override_payload(payload_json: str | None) -> dict[str, Any]:
         "nome": str(raw.get("nome") or "").strip(),
         "tipo_codigo": str(raw.get("tipo_codigo") or "").strip().upper(),
         "ano": _to_int_or_none(raw.get("ano")),
+        "processos_sei_informados": "processos_sei" in raw,
         "processos_sei": _dedupe_text_list(raw.get("processos_sei")),
         "modelos": modelos,
         "imoveis": imoveis,
@@ -456,7 +531,9 @@ def _apply_override_trabalho(
 ) -> dict[str, Any]:
     if not override:
         trabalho = dict(base)
-        trabalho.setdefault("processos_sei", [])
+        processos_base = _dedupe_text_list(base.get("processos_sei"))
+        trabalho["processos_sei"] = processos_base
+        trabalho["processos_sei_resumo"] = _resumo_textos(processos_base, limite_inline=1)
         return trabalho
 
     trabalho = dict(base)
@@ -479,7 +556,12 @@ def _apply_override_trabalho(
     trabalho["tipo_codigo"] = override.get("tipo_codigo") or trabalho.get("tipo_codigo") or ""
     trabalho["tipo_label"] = _tipo_label_from_codigo(trabalho.get("tipo_codigo"), trabalho.get("tipo_label"))
     trabalho["ano"] = override.get("ano")
-    trabalho["processos_sei"] = _dedupe_text_list(override.get("processos_sei"))
+    processos_base = _dedupe_text_list(base.get("processos_sei"))
+    if override.get("processos_sei_informados"):
+        trabalho["processos_sei"] = _dedupe_text_list(override.get("processos_sei"))
+    else:
+        trabalho["processos_sei"] = processos_base
+    trabalho["processos_sei_resumo"] = _resumo_textos(_dedupe_text_list(trabalho.get("processos_sei")), limite_inline=1)
     trabalho["imoveis"] = imoveis
     trabalho["modelos"] = _enriquecer_modelos(modelos_raw, catalogo_modelos)
     trabalho["total_imoveis"] = len(imoveis)
@@ -563,6 +645,7 @@ def _carregar_trabalho_base(
         """,
         (trabalho_id,),
     ).fetchall()
+    processos_sei = _carregar_processos_importados_por_trabalho(conn, trabalho_id).get(trabalho_id, [])
 
     modelos = _enriquecer_modelos([str(row["modelo_nome"]) for row in modelo_rows], catalogo_modelos)
     modelos_por_imovel: dict[int, list[str]] = {}
@@ -597,7 +680,8 @@ def _carregar_trabalho_base(
         "total_imoveis": int(trabalho_row["total_imoveis"] or 0),
         "total_modelos": int(trabalho_row["total_modelos"] or 0),
         "tem_coordenadas": bool(trabalho_row["tem_coordenadas"]),
-        "processos_sei": [],
+        "processos_sei": processos_sei,
+        "processos_sei_resumo": _resumo_textos(processos_sei, limite_inline=1),
         "modelos": modelos,
         "imoveis": imoveis,
     }
@@ -626,7 +710,10 @@ def _normalizar_edicao_payload(
     nome = str(payload.get("nome") or base.get("nome") or "").strip()
     tipo_codigo = str(payload.get("tipo_codigo") or base.get("tipo_codigo") or "").strip().upper()
     ano = _to_int_or_none(payload.get("ano"))
-    processos_sei = _dedupe_text_list(payload.get("processos_sei"))
+    if "processos_sei" in payload:
+        processos_sei = _dedupe_text_list(payload.get("processos_sei"))
+    else:
+        processos_sei = _dedupe_text_list(base.get("processos_sei"))
 
     modelos_informados = _dedupe_text_list(payload.get("modelos"))
     if not modelos_informados:
@@ -675,6 +762,7 @@ def _listar_avaliandos_tecnicos(chaves_modelo: list[str] | None = None) -> list[
     conn = _connect_database(resolved.db_path)
     try:
         overrides = _fetch_overrides(conn)
+        processos_por_trabalho = _carregar_processos_importados_por_trabalho(conn)
         rows = conn.execute(
             """
             SELECT
@@ -737,6 +825,7 @@ def _listar_avaliandos_tecnicos(chaves_modelo: list[str] | None = None) -> list[
                 "coord_lon": float(coord_x),
                 "coord_lat": float(coord_y),
                 "modelos_relacionados": set(),
+                "processos_sei": list(processos_por_trabalho.get(trabalho_id, [])),
             },
         )
         if modelo_nome:
@@ -1205,6 +1294,7 @@ def listar_trabalhos() -> dict[str, Any]:
     try:
         meta = _fetch_meta(conn)
         overrides = _fetch_overrides(conn)
+        processos_por_trabalho = _carregar_processos_importados_por_trabalho(conn)
         trabalhos_rows = conn.execute(
             """
             SELECT
@@ -1238,6 +1328,7 @@ def listar_trabalhos() -> dict[str, Any]:
     total_com_modelo_mesa = 0
     for row in trabalhos_rows:
         trabalho_id = str(row["trabalho_id"])
+        processos_sei = list(processos_por_trabalho.get(trabalho_id, []))
         base = {
             "id": trabalho_id,
             "nome": str(row["nome"]),
@@ -1251,7 +1342,8 @@ def listar_trabalhos() -> dict[str, Any]:
             "total_imoveis": int(row["total_imoveis"] or 0),
             "total_modelos": int(row["total_modelos"] or 0),
             "tem_coordenadas": bool(row["tem_coordenadas"]),
-            "processos_sei": [],
+            "processos_sei": processos_sei,
+            "processos_sei_resumo": _resumo_textos(processos_sei, limite_inline=1),
             "modelos": _enriquecer_modelos(modelos_por_trabalho.get(trabalho_id, []), catalogo_modelos),
             "imoveis": [],
         }

frontend/src/api.js

@@ -301,9 +301,10 @@ export const api = {
     valores_x: valoresX,
     indice_base: indiceBase,
   }),
-  evaluationKnnDetailsElab: (sessionId, valoresX) => postJson('/api/elaboracao/evaluation/knn-details', {
+  evaluationKnnDetailsElab: (sessionId, valoresX = null, indiceAvaliacao = null) => postJson('/api/elaboracao/evaluation/knn-details', {
     session_id: sessionId,
     valores_x: valoresX,
+    indice_avaliacao: indiceAvaliacao,
   }),
   evaluationClearElab: (sessionId) => postJson('/api/elaboracao/evaluation/clear', { session_id: sessionId }),
   evaluationDeleteElab: (sessionId, indice, indiceBase) => postJson('/api/elaboracao/evaluation/delete', {

frontend/src/components/ElaboracaoTab.jsx

@@ -3299,7 +3299,9 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     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
+    const valoresKnn = avaliacao && typeof avaliacao === 'object'
+      ? construirPayloadKnnAvaliacao(avaliacao)
+      : null
 
     setKnnDetalheAberto(true)
     setKnnDetalheLoading(true)
@@ -3312,7 +3314,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     setKnnDetalheInfo(null)
 
     try {
-      const resp = await api.evaluationKnnDetailsElab(sessionId, construirPayloadKnnAvaliacao(avaliacao))
+      const resp = await api.evaluationKnnDetailsElab(sessionId, valoresKnn, idx + 1)
       setKnnDetalheMapaHtml(String(resp?.mapa_html || ''))
       setKnnDetalheMapaPayload(resp?.mapa_payload || null)
       setKnnDetalheAvaliando(Array.isArray(resp?.avaliando) ? resp.avaliando : [])

frontend/src/components/LeafletMapFrame.jsx

@@ -343,8 +343,8 @@ function buildLegacyOverlayLayers(payload) {
 
   if (Array.isArray(payload?.trabalhos_tecnicos_points) && payload.trabalhos_tecnicos_points.length) {
     overlays.push({
-      id: 'avaliandos',
-      label: 'Avaliandos',
+      id: 'trabalhos-tecnicos',
+      label: 'Trabalhos técnicos',
       show: true,
       markers: payload.trabalhos_tecnicos_points,
     })
@@ -391,6 +391,8 @@ export default function LeafletMapFrame({ payload, sessionId }) {
     const canvasRenderer = L.canvas({ padding: 0.5, pane: 'mesa-market-pane' })
     const baseLayers = {}
     const overlayLayers = {}
+    const overlayGroupsById = new Map()
+    const dependencyAwareOverlays = []
 
     ;(payload.tile_layers || []).forEach((layerDef, index) => {
       const tileLayer = L.tileLayer(String(layerDef?.url || ''), {
@@ -576,6 +578,46 @@ export default function LeafletMapFrame({ payload, sessionId }) {
       })
     }
 
+    function filterDependencyAwareMarkers(items) {
+      if (!Array.isArray(items) || !items.length) return []
+      return items.filter((item) => {
+        const sourceIds = Array.isArray(item?.source_overlay_ids)
+          ? item.source_overlay_ids.map((entry) => String(entry || '').trim()).filter(Boolean)
+          : []
+        if (!sourceIds.length) return true
+        return sourceIds.some((sourceId) => {
+          const sourceLayer = overlayGroupsById.get(sourceId)
+          return Boolean(sourceLayer && map.hasLayer(sourceLayer))
+        })
+      })
+    }
+
+    function areRequiredOverlaysVisible(spec) {
+      const requiredIds = Array.isArray(spec?.required_overlay_ids)
+        ? spec.required_overlay_ids.map((entry) => String(entry || '').trim()).filter(Boolean)
+        : []
+      if (!requiredIds.length) return true
+      return requiredIds.every((requiredId) => {
+        const requiredLayer = overlayGroupsById.get(requiredId)
+        return Boolean(requiredLayer && map.hasLayer(requiredLayer))
+      })
+    }
+
+    function renderDependencyAwareOverlay(spec, layerGroup) {
+      if (!layerGroup) return
+      layerGroup.clearLayers()
+      if (!map.hasLayer(layerGroup)) return
+      if (!areRequiredOverlaysVisible(spec)) return
+      addShapeOverlays(layerGroup, spec?.shapes)
+      addMarkerOverlays(layerGroup, filterDependencyAwareMarkers(spec?.markers))
+    }
+
+    function refreshDependencyAwareOverlays() {
+      dependencyAwareOverlays.forEach(({ spec, layerGroup }) => {
+        renderDependencyAwareOverlay(spec, layerGroup)
+      })
+    }
+
     function addShapeOverlays(layerGroup, shapes) {
       if (!Array.isArray(shapes) || !shapes.length) return
       shapes.forEach((shape) => {
@@ -680,9 +722,13 @@ export default function LeafletMapFrame({ payload, sessionId }) {
     }
 
     overlaySpecs.forEach((spec, index) => {
+      const specId = String(spec?.id || '').trim()
       const label = String(spec?.label || spec?.id || `Camada ${index + 1}`)
       const layerGroup = L.layerGroup()
       overlayLayers[label] = layerGroup
+      if (specId) {
+        overlayGroupsById.set(specId, layerGroup)
+      }
       if (spec?.show !== false) {
         layerGroup.addTo(map)
       }
@@ -690,11 +736,24 @@ export default function LeafletMapFrame({ payload, sessionId }) {
         addGeoJsonOverlay(layerGroup, spec)
       }
       addHeatmapOverlay(layerGroup, spec?.heatmap)
-      addShapeOverlays(layerGroup, spec?.shapes)
       addPointMarkers(layerGroup, spec?.points)
-      addMarkerOverlays(layerGroup, spec?.markers)
+      const hasMarkerDependencies = Array.isArray(spec?.markers)
+        && spec.markers.some((item) => Array.isArray(item?.source_overlay_ids) && item.source_overlay_ids.length)
+      const hasOverlayDependencies = Array.isArray(spec?.required_overlay_ids) && spec.required_overlay_ids.length > 0
+      if (hasMarkerDependencies || hasOverlayDependencies) {
+        dependencyAwareOverlays.push({ spec, layerGroup })
+        renderDependencyAwareOverlay(spec, layerGroup)
+      } else {
+        addShapeOverlays(layerGroup, spec?.shapes)
+        addMarkerOverlays(layerGroup, spec?.markers)
+      }
     })
 
+    if (dependencyAwareOverlays.length) {
+      map.on('overlayadd', refreshDependencyAwareOverlays)
+      map.on('overlayremove', refreshDependencyAwareOverlays)
+    }
+
     if (payload.controls?.layer_control) {
       L.control.layers(baseLayers, overlayLayers, { collapsed: true }).addTo(map)
     }
@@ -989,6 +1048,10 @@ export default function LeafletMapFrame({ payload, sessionId }) {
     }
 
     return () => {
+      if (dependencyAwareOverlays.length) {
+        map.off('overlayadd', refreshDependencyAwareOverlays)
+        map.off('overlayremove', refreshDependencyAwareOverlays)
+      }
       disposed = true
       restoreMapInteractions?.()
       map.remove()

frontend/src/components/PesquisaTab.jsx

@@ -82,6 +82,15 @@ const TIPO_SIGLAS = {
   DEPOS: 'Deposito',
   CCOM: 'Casa comercial',
 }
+const TIPOS_MODELO_GENERICOS = [
+  'Apartamentos',
+  'Casa comercial',
+  'Deposito',
+  'Edificio',
+  'Loja',
+  'Salas comerciais',
+  'Terrenos',
+]
 
 function formatRange(range) {
   if (!range) return '-'
@@ -1024,9 +1033,12 @@ export default function PesquisaTab({
 
   const sugestoes = result.sugestoes || {}
   const opcoesTipoModelo = useMemo(
-    () => [...new Set((sugestoes.tipos_modelo || []).map((item) => String(item || '').trim()).filter(Boolean))]
-      .sort((a, b) => a.localeCompare(b, 'pt-BR', { sensitivity: 'base' })),
-    [sugestoes.tipos_modelo],
+    () => {
+      const atual = String(filters.tipoModelo || '').trim()
+      if (!atual || TIPOS_MODELO_GENERICOS.includes(atual)) return TIPOS_MODELO_GENERICOS
+      return [...TIPOS_MODELO_GENERICOS, atual]
+    },
+    [filters.tipoModelo],
   )
   const modoModeloAberto = Boolean(modeloAbertoMeta)
   const avaliandosGeoPayload = useMemo(