repositorio de trabalhos tecncios e implicacoes

.gitignore

@@ -14,3 +14,8 @@ frontend/dist/
 
 # Runtime logs
 logs/**/*.jsonl
+
+# Local technical-work database
+backend/local_data/*.sqlite3
+backend/local_data/*.sqlite3-shm
+backend/local_data/*.sqlite3-wal

README.md

@@ -71,6 +71,22 @@ Variáveis de ambiente do backend:
 - `MODELOS_REPOSITORIO_HF_SUBDIR` (ex.: `modelos_dai`)
 - `HF_TOKEN` (opcional para dataset privado)
 
+Base de Trabalhos Técnicos:
+
+- Fora do HF Spaces, o app usa por padrão o banco SQLite local.
+- Em runtime HF Spaces, o app usa por padrão o banco SQLite hospedado no dataset.
+- Override opcional: `TRABALHOS_TECNICOS_PROVIDER` (`local` ou `hf_dataset`)
+- Banco local: `TRABALHOS_TECNICOS_DB_LOCAL_PATH`
+- Banco no dataset: `TRABALHOS_TECNICOS_HF_REPO_ID`, `TRABALHOS_TECNICOS_HF_REVISION`, `TRABALHOS_TECNICOS_HF_PATH`
+
+Geração do banco local de Trabalhos Técnicos:
+
+- Script: `backend/scripts/build_trabalhos_tecnicos_db.py`
+- Planilha padrão de origem: `~/Downloads/dados_geocodificados_limpos_v2.xlsx`
+- Exemplo: `backend/.venv/bin/python backend/scripts/build_trabalhos_tecnicos_db.py`
+- Saída padrão: `backend/local_data/trabalhos_tecnicos.sqlite3`
+- O arquivo SQLite local fica ignorado no git e deve ser enviado manualmente ao dataset `gui-sparim/repositorio_mesa` no caminho `trabalhos_tecnicos/trabalhos_tecnicos.sqlite3`.
+
 Regra automática de provider:
 
 - Em runtime HF Spaces (`SPACE_ID`/`SPACE_AUTHOR_NAME`/`HF_SPACE_ID`), o backend força `hf_dataset`.
@@ -98,6 +114,7 @@ Logs são gravados em JSONL por escopo:
 
 - `auth`
 - `repositorio`
+- `trabalhos_tecnicos`
 - `elaboracao`
 - `visualizacao`
 

backend/app/api/trabalhos_tecnicos.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+
+from app.services import auth_service, trabalhos_tecnicos_service
+from app.services.audit_log_service import log_event
+
+
+router = APIRouter(prefix="/api/trabalhos-tecnicos", tags=["trabalhos_tecnicos"])
+
+
+class TrabalhoDetalhePayload(BaseModel):
+    trabalho_id: str
+
+
+@router.get("")
+def listar_trabalhos(request: Request) -> dict[str, Any]:
+    user = auth_service.require_user(request)
+    resposta = trabalhos_tecnicos_service.listar_trabalhos()
+    log_event(
+        "trabalhos_tecnicos",
+        "listar_trabalhos",
+        user=user,
+        status="ok",
+        request=request,
+        details={"total_trabalhos": resposta.get("total_trabalhos")},
+    )
+    return resposta
+
+
+@router.post("/detalhe")
+def detalhar_trabalho(payload: TrabalhoDetalhePayload, request: Request) -> dict[str, Any]:
+    user = auth_service.require_user(request)
+    resposta = trabalhos_tecnicos_service.detalhar_trabalho(payload.trabalho_id)
+    log_event(
+        "trabalhos_tecnicos",
+        "detalhar_trabalho",
+        user=user,
+        status="ok",
+        request=request,
+        details={"trabalho_id": payload.trabalho_id},
+    )
+    return resposta

backend/app/api/visualizacao.py

@@ -23,13 +23,21 @@ class MapaPayload(SessionPayload):
     variavel_mapa: str | None = None
 
 
+class MapaPopupPayload(SessionPayload):
+    row_id: int
+
+
 class AvaliacaoPayload(SessionPayload):
     valores_x: dict[str, Any]
     indice_base: str | None = None
+    avaliando_lat: float | None = None
+    avaliando_lon: float | None = None
 
 
 class AvaliacaoKnnDetalhesPayload(SessionPayload):
     valores_x: dict[str, Any]
+    avaliando_lat: float | None = None
+    avaliando_lon: float | None = None
 
 
 class AvaliacaoDeletePayload(SessionPayload):
@@ -87,9 +95,13 @@ def repositorio_carregar(payload: RepositorioModeloPayload, request: Request) ->
 
 
 @router.post("/exibir")
-def exibir(payload: SessionPayload) -> dict[str, Any]:
+def exibir(payload: SessionPayload, request: Request) -> dict[str, Any]:
     session = session_store.get(payload.session_id)
-    return visualizacao_service.exibir_modelo(session)
+    return visualizacao_service.exibir_modelo(
+        session,
+        api_base_url=str(request.base_url).rstrip("/"),
+        popup_auth_token=getattr(request.state, "auth_token", None),
+    )
 
 
 @router.post("/evaluation/context")
@@ -99,9 +111,20 @@ def evaluation_context(payload: SessionPayload) -> dict[str, Any]:
 
 
 @router.post("/map/update")
-def map_update(payload: MapaPayload) -> dict[str, Any]:
+def map_update(payload: MapaPayload, request: Request) -> dict[str, Any]:
     session = session_store.get(payload.session_id)
-    return visualizacao_service.atualizar_mapa(session, payload.variavel_mapa)
+    return visualizacao_service.atualizar_mapa(
+        session,
+        payload.variavel_mapa,
+        api_base_url=str(request.base_url).rstrip("/"),
+        popup_auth_token=getattr(request.state, "auth_token", None),
+    )
+
+
+@router.post("/map/popup")
+def map_popup(payload: MapaPopupPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return visualizacao_service.carregar_popup_ponto_mapa(session, payload.row_id)
 
 
 @router.post("/evaluation/fields")
@@ -114,7 +137,13 @@ def evaluation_fields(payload: SessionPayload) -> dict[str, Any]:
 def evaluation_calculate(payload: AvaliacaoPayload, request: Request) -> dict[str, Any]:
     session = session_store.get(payload.session_id)
     user = auth_service.require_user(request)
-    resposta = visualizacao_service.calcular_avaliacao(session, payload.valores_x, payload.indice_base)
+    resposta = visualizacao_service.calcular_avaliacao(
+        session,
+        payload.valores_x,
+        payload.indice_base,
+        payload.avaliando_lat,
+        payload.avaliando_lon,
+    )
     log_event(
         "visualizacao",
         "avaliacao_calcular",
@@ -130,7 +159,12 @@ 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 = visualizacao_service.detalhes_knn_avaliacao(session, payload.valores_x)
+    resposta = visualizacao_service.detalhes_knn_avaliacao(
+        session,
+        payload.valores_x,
+        payload.avaliando_lat,
+        payload.avaliando_lon,
+    )
     log_event(
         "visualizacao",
         "avaliacao_knn_detalhes",

backend/app/core/map_layers.py

@@ -143,6 +143,71 @@ def add_indice_marker(
     ).add_to(camada)
 
 
+def add_trabalhos_tecnicos_markers(
+    camada: folium.map.FeatureGroup,
+    trabalhos: list[dict[str, Any]] | None,
+) -> None:
+    for item in trabalhos or []:
+        try:
+            lat = float(item.get("coord_lat"))
+            lon = float(item.get("coord_lon"))
+        except Exception:
+            continue
+
+        trabalho_nome = str(item.get("trabalho_nome") or item.get("trabalho_id") or "Trabalho tecnico").strip()
+        tipo_label = str(item.get("tipo_label") or "").strip()
+        label = str(item.get("label") or "").strip()
+        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()]
+
+        endereco_parts = []
+        if endereco:
+            endereco_parts.append(endereco)
+        if numero:
+            endereco_parts.append(numero)
+        endereco_texto = ", ".join(endereco_parts) or label or "Endereco nao informado"
+        label_texto = label or endereco_texto
+        modelos_texto = ", ".join(modelos) or "Modelo nao informado"
+
+        tooltip_html = (
+            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.5;'>"
+            f"<b>{escape(trabalho_nome)}</b>"
+            f"<br><span style='color:#555;'>Endereco:</span> {escape(endereco_texto)}"
+            "</div>"
+        )
+
+        popup_html = (
+            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.55; min-width:260px;'>"
+            f"<div style='font-weight:700; color:#7d5a00; margin-bottom:6px;'>{escape(trabalho_nome)}</div>"
+            + (f"<div><span style='color:#666;'>Tipo:</span> {escape(tipo_label)}</div>" if tipo_label else "")
+            + f"<div><span style='color:#666;'>Avaliando:</span> {escape(label_texto)}</div>"
+            + f"<div><span style='color:#666;'>Endereco:</span> {escape(endereco_texto)}</div>"
+            + f"<div><span style='color:#666;'>Modelo(s):</span> {escape(modelos_texto)}</div>"
+            + "</div>"
+        )
+
+        folium.Marker(
+            location=[lat, lon],
+            tooltip=folium.Tooltip(tooltip_html, sticky=True),
+            popup=folium.Popup(popup_html, max_width=360),
+            icon=folium.DivIcon(
+                html=(
+                    "<div style='display:flex;align-items:center;justify-content:center;"
+                    "width:14px;height:14px;'>"
+                    "<svg width='14' height='14' viewBox='0 0 24 24' aria-hidden='true'>"
+                    "<polygon points='12,1.8 15.2,8.2 22.2,9.2 17.1,14.1 18.3,21.1 "
+                    "12,17.8 5.7,21.1 6.9,14.1 1.8,9.2 8.8,8.2' "
+                    "fill='#c62828' stroke='#000000' stroke-width='1.4' stroke-linejoin='round'/>"
+                    "</svg></div>"
+                ),
+                icon_size=(14, 14),
+                icon_anchor=(7, 7),
+                class_name="mesa-trabalho-tecnico-marker",
+            ),
+        ).add_to(camada)
+
+
 def add_zoom_responsive_circle_markers(
     mapa: folium.Map,
     *,
@@ -412,6 +477,277 @@ def add_popup_pagination_handlers(mapa: folium.Map) -> None:
           }}
         }}
 
+        function buildLazyPopupError(message) {{
+          const text = String(message || 'Falha ao carregar os dados do registro.')
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+          return (
+            "<div style=\\"font-family:'Segoe UI'; border-radius:8px; overflow:hidden; width:340px; max-width:340px;\\">" +
+              "<div style=\\"background:#6c757d; color:white; padding:10px 15px; font-weight:600;\\">Dados do Registro</div>" +
+              "<div style=\\"padding:12px 15px; background:#f8f9fa; color:#b42318; font-size:12px;\\">" + text + "</div>" +
+            "</div>"
+          );
+        }}
+
+        function isLocalHostname(hostname) {{
+          const name = String(hostname || '').trim().toLowerCase();
+          return name === 'localhost' || name === '127.0.0.1' || name === '0.0.0.0';
+        }}
+
+        function parentOriginOrNull() {{
+          try {{
+            if (window.parent && window.parent.location && window.parent.location.origin) {{
+              return String(window.parent.location.origin);
+            }}
+          }} catch (_error) {{
+            return null;
+          }}
+          return null;
+        }}
+
+        function resolvePopupEndpointCandidates(rawEndpoint) {{
+          const endpoint = String(rawEndpoint || '/api/visualizacao/map/popup').trim();
+          const candidates = [];
+          const seen = new Set();
+
+          function pushCandidate(value) {{
+            const text = String(value || '').trim();
+            if (!text || seen.has(text)) return;
+            seen.add(text);
+            candidates.push(text);
+          }}
+
+          const parentOrigin = parentOriginOrNull();
+          let endpointUrl = null;
+          try {{
+            const base = parentOrigin || window.location.href || undefined;
+            endpointUrl = new URL(endpoint, base);
+          }} catch (_error) {{
+            endpointUrl = null;
+          }}
+
+          if (endpointUrl) {{
+            pushCandidate(endpointUrl.href);
+
+            if (parentOrigin) {{
+              try {{
+                const parentUrl = new URL(parentOrigin);
+                const endpointLooksInternal = isLocalHostname(endpointUrl.hostname) && !isLocalHostname(parentUrl.hostname);
+                const mixedContentRisk = parentUrl.protocol === 'https:' && endpointUrl.protocol === 'http:';
+                if (endpointLooksInternal || mixedContentRisk) {{
+                  pushCandidate(new URL(endpointUrl.pathname + endpointUrl.search, parentOrigin).href);
+                }}
+              }} catch (_error) {{
+                // no-op
+              }}
+            }}
+          }} else if (parentOrigin) {{
+            try {{
+              pushCandidate(new URL(endpoint, parentOrigin).href);
+            }} catch (_error) {{
+              // no-op
+            }}
+          }}
+
+          pushCandidate(endpoint);
+          return candidates;
+        }}
+
+        async function fetchJsonWithTimeout(url, options, timeoutMs) {{
+          const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+          const timeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 8000;
+          let timerId = null;
+
+          if (controller) {{
+            timerId = window.setTimeout(function() {{
+              try {{
+                controller.abort();
+              }} catch (_error) {{
+                // no-op
+              }}
+            }}, timeout);
+          }}
+
+          try {{
+            const response = await fetch(url, {{
+              ...options,
+              signal: controller ? controller.signal : undefined,
+            }});
+            let payload = null;
+            try {{
+              payload = await response.json();
+            }} catch (_error) {{
+              payload = null;
+            }}
+            return {{ response, payload }};
+          }} finally {{
+            if (timerId) {{
+              window.clearTimeout(timerId);
+            }}
+          }}
+        }}
+
+        async function loadLazyPopupContent(popup, contentNode) {{
+          if (!contentNode || !contentNode.querySelector) return;
+          const placeholder = contentNode.querySelector('[data-mesa-lazy-popup]');
+          if (!placeholder) {{
+            const root = contentNode.querySelector('[data-pager]');
+            if (root) {{
+              const initialRaw = parseInt(root.dataset.currentPage || '1', 10);
+              const initialPage = Number.isFinite(initialRaw) && initialRaw > 0 ? initialRaw : 1;
+              updatePager(root, initialPage);
+            }}
+            return;
+          }}
+
+          const currentState = String(placeholder.dataset.lazyState || '').trim();
+          if (currentState === 'loading' || currentState === 'loaded') return;
+          if (popup && popup.__mesaLazyPopupState === 'loaded') {{
+            const root = contentNode.querySelector('[data-pager]');
+            if (root) {{
+              const initialRaw = parseInt(root.dataset.currentPage || '1', 10);
+              const initialPage = Number.isFinite(initialRaw) && initialRaw > 0 ? initialRaw : 1;
+              updatePager(root, initialPage);
+            }}
+            return;
+          }}
+
+          placeholder.dataset.lazyState = 'loading';
+          const endpoint = String(placeholder.dataset.popupEndpoint || '/api/visualizacao/map/popup').trim();
+          const authToken = String(placeholder.dataset.authToken || '').trim();
+          const sessionId = String(placeholder.dataset.sessionId || '').trim();
+          const rowIdRaw = String(placeholder.dataset.rowId || '').trim();
+          const rowId = parseInt(rowIdRaw, 10);
+
+          if (!endpoint || !sessionId || !Number.isFinite(rowId)) {{
+            placeholder.dataset.lazyState = '';
+            const errorHtml = buildLazyPopupError('Identificador do ponto indisponivel.');
+            if (popup && typeof popup.setContent === 'function') {{
+              popup.setContent(errorHtml);
+            }} else {{
+              contentNode.innerHTML = errorHtml;
+            }}
+            if (popup && typeof popup.update === 'function') popup.update();
+            return;
+          }}
+
+          if (popup) {{
+            popup.__mesaLazyPopupState = 'loading';
+          }}
+
+          try {{
+            const headers = {{
+              'Content-Type': 'application/json',
+            }};
+            if (authToken) {{
+              headers['X-Auth-Token'] = authToken;
+            }}
+
+            const endpointCandidates = resolvePopupEndpointCandidates(endpoint);
+            let response = null;
+            let payload = null;
+            let lastError = null;
+
+            for (const candidate of endpointCandidates) {{
+              try {{
+                const result = await fetchJsonWithTimeout(candidate, {{
+                  method: 'POST',
+                  headers,
+                  body: JSON.stringify({{
+                    session_id: sessionId,
+                    row_id: rowId,
+                  }}),
+                }}, 8000);
+                response = result.response;
+                payload = result.payload;
+
+                if (!response.ok) {{
+                  const detail = payload && payload.detail ? String(payload.detail) : 'Falha ao carregar os dados do registro.';
+                  throw new Error(detail);
+                }}
+
+                break;
+              }} catch (error) {{
+                lastError = error;
+                response = null;
+                payload = null;
+              }}
+            }}
+
+            if (!response) {{
+              throw lastError || new Error('Falha ao carregar os dados do registro.');
+            }}
+
+            const popupHtml = payload && typeof payload.popup_html === 'string'
+              ? payload.popup_html
+              : buildLazyPopupError('Nenhum dado disponivel para este ponto.');
+            const popupWidth = Number(payload && payload.popup_width);
+
+            let resolvedContentNode = contentNode;
+            if (popup && typeof popup.setContent === 'function') {{
+              popup.setContent(popupHtml);
+              if (popup && popup._contentNode) {{
+                resolvedContentNode = popup._contentNode;
+              }}
+            }} else {{
+              contentNode.innerHTML = popupHtml;
+            }}
+            if (Number.isFinite(popupWidth) && popupWidth > 0) {{
+              if (popup && popup.options) {{
+                popup.options.maxWidth = popupWidth;
+              }}
+            }}
+            if (popup) {{
+              popup.__mesaLazyPopupState = 'loaded';
+            }}
+
+            if (popup && typeof popup.update === 'function') {{
+              popup.update();
+            }}
+
+            const root = resolvedContentNode && resolvedContentNode.querySelector
+              ? resolvedContentNode.querySelector('[data-pager]')
+              : null;
+            if (root) {{
+              const initialRaw = parseInt(root.dataset.currentPage || '1', 10);
+              const initialPage = Number.isFinite(initialRaw) && initialRaw > 0 ? initialRaw : 1;
+              updatePager(root, initialPage);
+            }}
+          }} catch (error) {{
+            placeholder.dataset.lazyState = '';
+            if (popup) {{
+              popup.__mesaLazyPopupState = '';
+            }}
+            const errorHtml = buildLazyPopupError(error && error.message ? error.message : 'Falha ao carregar os dados do registro.');
+            if (popup && typeof popup.setContent === 'function') {{
+              popup.setContent(errorHtml);
+            }} else {{
+              contentNode.innerHTML = errorHtml;
+            }}
+            if (popup && typeof popup.update === 'function') {{
+              popup.update();
+            }}
+          }}
+        }}
+
+        function scanForLazyPopups(map) {{
+          if (!map || typeof map.getContainer !== 'function') return;
+          const mapContainer = map.getContainer();
+          if (!mapContainer || !mapContainer.ownerDocument) return;
+          const doc = mapContainer.ownerDocument;
+          const contents = doc.querySelectorAll('.leaflet-popup-content');
+          contents.forEach(function(contentNode) {{
+            try {{
+              if (!contentNode || !contentNode.querySelector) return;
+              if (!contentNode.querySelector('[data-mesa-lazy-popup]')) return;
+              loadLazyPopupContent(null, contentNode);
+            }} catch (_error) {{
+              // no-op
+            }}
+          }});
+        }}
+
         function handleClick(event) {{
           const target = event && event.target ? event.target : null;
           if (!target || !target.closest) return;
@@ -461,11 +797,20 @@ def add_popup_pagination_handlers(mapa: folium.Map) -> None:
             const popup = evt && evt.popup ? evt.popup : null;
             const contentNode = popup && popup._contentNode ? popup._contentNode : null;
             if (!contentNode || !contentNode.querySelector) return;
-            const root = contentNode.querySelector('[data-pager]');
-            if (!root) return;
-            const initialRaw = parseInt(root.dataset.currentPage || '1', 10);
-            const initialPage = Number.isFinite(initialRaw) && initialRaw > 0 ? initialRaw : 1;
-            updatePager(root, initialPage);
+            loadLazyPopupContent(popup, contentNode);
+            window.setTimeout(function() {{ scanForLazyPopups(map); }}, 20);
+          }});
+
+          if (typeof MutationObserver !== 'undefined' && mapContainer) {{
+            const observer = new MutationObserver(function() {{
+              scanForLazyPopups(map);
+            }});
+            observer.observe(mapContainer, {{ childList: true, subtree: true }});
+            map.__mesaPopupObserver = observer;
+          }}
+
+          map.whenReady(function() {{
+            window.setTimeout(function() {{ scanForLazyPopups(map); }}, 40);
           }});
 
           let resizeTimer = null;

backend/app/core/visualizacao/app.py

@@ -27,6 +27,7 @@ from app.core.map_layers import (
     add_bairros_layer,
     add_indice_marker,
     add_popup_pagination_handlers,
+    add_trabalhos_tecnicos_markers,
     add_zoom_responsive_circle_markers,
 )
 
@@ -834,10 +835,69 @@ def _montar_popup_registro_paginado(itens, popup_uid, max_itens_pagina=8):
     )
     return html, popup_largura_px
 
+
+def _formatar_valor_popup_registro(coluna, valor):
+    if valor is None:
+        return "—"
+    try:
+        if pd.isna(valor):
+            return "—"
+    except Exception:
+        pass
+
+    col_norm = str(coluna).lower()
+    if isinstance(valor, (int, float, np.integer, np.floating)):
+        numero = float(valor)
+        if not np.isfinite(numero):
+            return "—"
+        if any(k in col_norm for k in ["valor", "preco", "vu", "vunit"]):
+            return formatar_monetario(numero)
+        return f"{numero:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+    return str(valor)
+
+
+def montar_popup_registro_html(row, popup_uid, max_itens_pagina=8):
+    itens = []
+    for col, val in row.items():
+        col_txt = str(col)
+        if col_txt.startswith("__mesa_"):
+            continue
+        if col_txt.lower() not in ["lat", "latitude", "lon", "longitude"]:
+            itens.append((col, _formatar_valor_popup_registro(col, val)))
+    return _montar_popup_registro_paginado(itens, popup_uid, max_itens_pagina=max_itens_pagina)
+
+
+def _montar_popup_registro_placeholder(session_id, row_id, popup_uid, popup_endpoint, auth_token=None):
+    popup_id = escape(str(popup_uid))
+    session_attr = escape(str(session_id))
+    row_attr = escape(str(int(row_id)))
+    endpoint_attr = escape(str(popup_endpoint or "/api/visualizacao/map/popup"))
+    token_attr = escape(str(auth_token or ""))
+    html = (
+        f"<div id='{popup_id}' data-mesa-lazy-popup='1' data-session-id='{session_attr}' "
+        f"data-row-id='{row_attr}' data-popup-endpoint='{endpoint_attr}' data-auth-token='{token_attr}' "
+        "style=\"font-family:'Segoe UI'; border-radius:8px; overflow:hidden; width:340px; max-width:340px;\">"
+        "<div style=\"background:#6c757d; color:white; padding:10px 15px; font-weight:600;\">Dados do Registro</div>"
+        "<div style=\"padding:12px 15px; background:#f8f9fa; color:#6c757d; font-size:12px;\">Carregando detalhes...</div>"
+        "</div>"
+    )
+    return html, 380
+
 # ============================================================
 # FUNÇÃO: GERAR MAPA FOLIUM (com suporte a dimensionamento por variável)
 # ============================================================
-def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, tamanho_col=None, col_y=None):
+def criar_mapa(
+    df,
+    lat_col="lat",
+    lon_col="lon",
+    cor_col=None,
+    tamanho_col=None,
+    col_y=None,
+    session_id=None,
+    popup_endpoint=None,
+    popup_auth_token=None,
+    avaliandos_tecnicos=None,
+):
     """
     Cria mapa Folium com os dados, com suporte a dimensionamento proporcional.
 
@@ -972,6 +1032,11 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, tamanho_col=None,
             tooltip_key = "__mesa_tooltip__"
             df_mapa[tooltip_key] = serie_tooltip
 
+    total_pontos_plot = len(df_plot_pontos)
+    raio_padrao = 4 if total_pontos_plot <= 2500 else 3
+    contorno_padrao = 0.8 if total_pontos_plot <= 2500 else 0.55
+    opacidade_preenchimento = 0.68 if total_pontos_plot <= 2500 else 0.6
+
     # Adiciona pontos
     for marker_ordem, (idx, row) in enumerate(df_plot_pontos.iterrows()):
         # Cor do ponto
@@ -983,31 +1048,32 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, tamanho_col=None,
         # Calcula raio
         if tamanho_func and tamanho_key and pd.notna(row[tamanho_key]):
             raio = tamanho_func(row[tamanho_key])
+            peso_contorno = 1
         else:
-            raio = 8
-
-        # Popup com informações
-        itens = []
-        for col, val in row.items():
-            col_txt = str(col)
-            if col_txt.startswith("__mesa_"):
-                continue
-            if col_txt.lower() not in ['lat', 'latitude', 'lon', 'longitude']:
-                col_norm = str(col).lower()
-                if isinstance(val, (int, float, np.floating)):
-                    if any(k in col_norm for k in ["valor", "preco", "vu", "vunit"]):
-                        val_fmt = formatar_monetario(val)
-                    else:
-                        val_fmt = f"{val:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
-                else:
-                    val_fmt = str(val)
-                itens.append((col, val_fmt))
+            raio = raio_padrao
+            peso_contorno = contorno_padrao
 
         # Tooltip (hover): índice + variável selecionada no dropdown (ou dependente como fallback)
         # Usa coluna "index" (original, gerada pelo reset_index) quando disponível
         idx_display = int(row["index"]) if "index" in row.index else idx
         popup_uid = f"mesa-pop-{marker_ordem}"
-        popup_html, popup_width = _montar_popup_registro_paginado(itens, popup_uid, max_itens_pagina=8)
+        popup_html = None
+        popup_width = None
+        row_id_raw = row["__mesa_row_id__"] if "__mesa_row_id__" in row.index else None
+        if session_id is not None and row_id_raw is not None:
+            try:
+                popup_html, popup_width = _montar_popup_registro_placeholder(
+                    session_id=session_id,
+                    row_id=int(row_id_raw),
+                    popup_uid=popup_uid,
+                    popup_endpoint=popup_endpoint,
+                    auth_token=popup_auth_token,
+                )
+            except Exception:
+                popup_html = None
+                popup_width = None
+        if popup_html is None or popup_width is None:
+            popup_html, popup_width = montar_popup_registro_html(row, popup_uid, max_itens_pagina=8)
         tooltip_html = (
             "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px;"
             " line-height:1.7; padding:2px 4px;'>"
@@ -1035,10 +1101,10 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, tamanho_col=None,
             popup=folium.Popup(popup_html, max_width=popup_width),
             tooltip=folium.Tooltip(tooltip_html, sticky=True),
             color='black',
-            weight=1,
+            weight=peso_contorno,
             fill=True,
             fillColor=cor,
-            fillOpacity=0.7
+            fillOpacity=opacidade_preenchimento
         ).add_to(m)
         marcador.options["mesaBaseRadius"] = float(max(1.0, raio))
 
@@ -1053,6 +1119,11 @@ def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, tamanho_col=None,
     if mostrar_indices and camada_indices is not None:
         camada_indices.add_to(m)
 
+    if avaliandos_tecnicos:
+        camada_trabalhos_tecnicos = folium.FeatureGroup(name="Avaliandos que usaram o modelo", show=True)
+        add_trabalhos_tecnicos_markers(camada_trabalhos_tecnicos, avaliandos_tecnicos)
+        camada_trabalhos_tecnicos.add_to(m)
+
     # Controles
     folium.LayerControl().add_to(m)
     plugins.Fullscreen().add_to(m)

backend/app/main.py

@@ -7,7 +7,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
 
-from app.api import auth, elaboracao, health, logs, pesquisa, repositorio, session, visualizacao
+from app.api import auth, elaboracao, health, logs, pesquisa, repositorio, session, trabalhos_tecnicos, visualizacao
 from app.services import auth_service
 
 
@@ -53,6 +53,7 @@ app.include_router(elaboracao.router)
 app.include_router(visualizacao.router)
 app.include_router(pesquisa.router)
 app.include_router(repositorio.router)
+app.include_router(trabalhos_tecnicos.router)
 app.include_router(logs.router)
 
 

backend/app/services/audit_log_service.py

@@ -23,7 +23,7 @@ except Exception:  # pragma: no cover
 
 LOGS_ROOT = "logs"
 _TZ_GMT_MINUS_3 = timezone(timedelta(hours=-3), name="GMT-3")
-_SCOPE_ALLOWED = {"auth", "repositorio", "elaboracao", "visualizacao", "geral"}
+_SCOPE_ALLOWED = {"auth", "repositorio", "trabalhos_tecnicos", "elaboracao", "visualizacao", "geral"}
 _HF_LOCK = Lock()
 _HF_ROOT_READY: dict[str, bool] = {}
 

backend/app/services/pesquisa_service.py

@@ -18,8 +18,13 @@ from joblib import load
 
 from app.core.elaboracao import geocodificacao
 from app.core.elaboracao.core import _migrar_pacote_v1_para_v2, normalizar_observacao_modelo
-from app.core.map_layers import add_bairros_layer, add_indice_marker, add_zoom_responsive_circle_markers
-from app.services import model_repository
+from app.core.map_layers import (
+    add_bairros_layer,
+    add_indice_marker,
+    add_trabalhos_tecnicos_markers,
+    add_zoom_responsive_circle_markers,
+)
+from app.services import model_repository, trabalhos_tecnicos_service
 from app.services.serializers import sanitize_value
 
 AREA_PRIVATIVA_ALIASES = ["APRIV", "APRIVEQ", "ATPRIV", "ACOPRIV", "AREAPRIV", "AREA_PRIVATIVA", "AREA PRIVATIVA"]
@@ -587,6 +592,9 @@ def gerar_mapa_modelos(
         cor = MAP_COLORS[idx % len(MAP_COLORS)]
         nome = str(resumo.get("nome_modelo") or modelo_id)
         distancia_info = _calcular_distancia_geometria_cache(geometria, aval_lat, aval_lon)
+        avaliandos_tecnicos = trabalhos_tecnicos_service.listar_avaliandos_por_modelo(
+            [modelo_id, caminho.name, nome]
+        )
 
         modelos_plotados.append(
             {
@@ -598,6 +606,7 @@ def gerar_mapa_modelos(
                 "geometria": geometria,
                 "distancia_km": distancia_info.get("distancia_km"),
                 "distancia_label": distancia_info.get("distancia_label"),
+                "avaliandos_tecnicos": avaliandos_tecnicos,
             }
         )
         bounds.extend([[ponto["lat"], ponto["lon"]] for ponto in pontos])
@@ -679,18 +688,16 @@ def _renderizar_mapa_modelos(
     add_bairros_layer(mapa, show=True)
 
     mostrar_indices = renderizar_pontos and sum(int(modelo["total_pontos"]) for modelo in modelos_plotados) <= 800
-    camada_indices = folium.FeatureGroup(name="Índices", show=False) if mostrar_indices else None
-    camada_pontos = folium.FeatureGroup(name="Dados de mercado", show=True) if renderizar_pontos else None
-    camada_poligonos = folium.FeatureGroup(name="Cobertura dos modelos", show=True) if renderizar_cobertura else None
     camada_avaliando = folium.FeatureGroup(name="Avaliando", show=True)
-    camada_distancias = folium.FeatureGroup(name="Distancias", show=False) if renderizar_cobertura else None
 
     for modelo in modelos_plotados:
-        tooltip_modelo = modelo["nome"]
-        if modelo.get("distancia_label"):
-            tooltip_modelo = f'{tooltip_modelo} • Distancia: {modelo["distancia_label"]}'
+        nome_layer = str(modelo.get("nome") or modelo.get("id") or "Modelo").strip() or "Modelo"
+        camada_modelo = folium.FeatureGroup(name=nome_layer, show=True)
 
-        if renderizar_pontos and camada_pontos is not None:
+        if renderizar_pontos:
+            tooltip_modelo = nome_layer
+            if modelo.get("distancia_label"):
+                tooltip_modelo = f'{tooltip_modelo} • Distancia: {modelo["distancia_label"]}'
             for ponto in modelo["pontos"]:
                 marcador = folium.CircleMarker(
                     location=[ponto["lat"], ponto["lon"]],
@@ -702,25 +709,22 @@ def _renderizar_mapa_modelos(
                     opacity=0.9,
                     weight=1,
                     tooltip=tooltip_modelo,
-                ).add_to(camada_pontos)
+                ).add_to(camada_modelo)
                 marcador.options["mesaBaseRadius"] = 3.0
-                if mostrar_indices and camada_indices is not None and ponto.get("indice") is not None:
+                if mostrar_indices and ponto.get("indice") is not None:
                     add_indice_marker(
-                        camada_indices,
+                        camada_modelo,
                         lat=float(ponto["lat"]),
                         lon=float(ponto["lon"]),
                         indice=ponto["indice"],
                     )
 
-        if renderizar_cobertura and camada_poligonos is not None:
-            _adicionar_geometria_modelo_no_mapa(camada_poligonos, camada_distancias, modelo, aval_lat, aval_lon)
+        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_pontos is not None:
-        camada_pontos.add_to(mapa)
-    if mostrar_indices and camada_indices is not None:
-        camada_indices.add_to(mapa)
-    if camada_poligonos is not None:
-        camada_poligonos.add_to(mapa)
     if aval_lat is not None and aval_lon is not None:
         folium.Marker(
             location=[aval_lat, aval_lon],
@@ -728,11 +732,10 @@ def _renderizar_mapa_modelos(
             icon=folium.Icon(color="red", icon="home", prefix="glyphicon"),
         ).add_to(camada_avaliando)
         camada_avaliando.add_to(mapa)
-    if camada_distancias is not None and any(modelo.get("distancia_km") not in (None, "") for modelo in modelos_plotados):
-        camada_distancias.add_to(mapa)
 
     plugins.Fullscreen().add_to(mapa)
     add_zoom_responsive_circle_markers(mapa)
+    folium.LayerControl(collapsed=False).add_to(mapa)
     if bounds:
         lat_values = [float(coord[0]) for coord in bounds]
         lon_values = [float(coord[1]) for coord in bounds]

backend/app/services/trabalhos_tecnicos_importer.py

@@ -0,0 +1,527 @@
+from __future__ import annotations
+
+import re
+import sqlite3
+import unicodedata
+import zipfile
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+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"]
+TIPO_LABELS = {
+    "LA": "Laudo de Avaliacao",
+    "PT": "Parecer Tecnico",
+    "IT": "Informacao Tecnica",
+    "PTF": "Parecer Tecnico Fundamentado",
+    "PIV": "Parecer Indicativo de Valor",
+}
+LOGRADOURO_ABREV = {
+    "RUA": "R",
+    "R": "R",
+    "AVENIDA": "AV",
+    "AV": "AV",
+    "ESTRADA": "ESTR",
+    "ESTR": "ESTR",
+    "RODOVIA": "ROD",
+    "ROD": "ROD",
+    "ALAMEDA": "AL",
+    "AL": "AL",
+    "TRAVESSA": "TV",
+    "TV": "TV",
+    "LARGO": "LGO",
+    "PRACA": "PRACA",
+    "PRAÇA": "PRACA",
+}
+XLSX_NS = {
+    "a": "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+    "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+}
+
+
+@dataclass
+class TrabalhoRawGroup:
+    raw_name: str
+    ano: int | None = None
+    endereco_base: str = ""
+    numero_base: str = ""
+    first_row_number: int = 0
+    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)
+    clean_name: str = ""
+
+
+def _clean_text(value: Any) -> str:
+    if value is None:
+        return ""
+    text = str(value).strip()
+    if text.endswith(".0"):
+        try:
+            return str(int(float(text)))
+        except Exception:
+            return text
+    return text
+
+
+def _to_int(value: Any) -> int | None:
+    text = _clean_text(value)
+    if not text:
+        return None
+    try:
+        return int(float(text))
+    except Exception:
+        return None
+
+
+def _to_float(value: Any) -> float | None:
+    text = _clean_text(value)
+    if not text:
+        return None
+    try:
+        return float(text)
+    except Exception:
+        return None
+
+
+def _strip_accents(value: str) -> str:
+    normalized = unicodedata.normalize("NFKD", value)
+    return "".join(ch for ch in normalized if not unicodedata.combining(ch))
+
+
+def _slugify(value: Any) -> str:
+    text = _clean_text(value)
+    if not text:
+        return ""
+    text = _strip_accents(text.upper()).replace("�", "")
+    text = re.sub(r"[^A-Z0-9]+", "_", text)
+    text = re.sub(r"_+", "_", text)
+    return text.strip("_")
+
+
+def _address_slug(endereco: str) -> str:
+    slug = _slugify(endereco)
+    if not slug:
+        return ""
+    tokens = [token for token in slug.split("_") if token]
+    if not tokens:
+        return ""
+    tokens[0] = LOGRADOURO_ABREV.get(tokens[0], tokens[0])
+    return "_".join(tokens)
+
+
+def _extract_prefix_tokens(raw_name: str) -> list[str]:
+    tokens = [token for token in _clean_text(raw_name).split("_") if token]
+    if not tokens:
+        return []
+    prefix: list[str] = [_slugify(tokens[0])]
+    if len(tokens) >= 2 and tokens[1].isdigit():
+        prefix.append(tokens[1])
+    if len(tokens) >= 3 and re.fullmatch(r"\d{4}", tokens[2] or ""):
+        prefix.append(tokens[2])
+    return [token for token in prefix if token]
+
+
+def build_clean_trabalho_name(raw_name: str, endereco: str, numero: str) -> str:
+    prefix_tokens = _extract_prefix_tokens(raw_name)
+    address_slug = _address_slug(endereco)
+    number_slug = _slugify(numero)
+
+    parts = prefix_tokens[:]
+    if address_slug:
+        parts.append(address_slug)
+    if number_slug:
+        parts.append(number_slug)
+
+    if parts:
+        return "_".join(parts)
+    return _slugify(raw_name)
+
+
+def _tipo_codigo_from_name(nome: str) -> str:
+    tokens = [token for token in _clean_text(nome).split("_") if token]
+    if not tokens:
+        return ""
+    return _slugify(tokens[0])
+
+
+def _tipo_label(codigo: str) -> str:
+    return TIPO_LABELS.get(_clean_text(codigo).upper(), _clean_text(codigo).upper() or "Nao identificado")
+
+
+def _col_ref_to_index(ref: str) -> int:
+    letters = "".join(ch for ch in str(ref or "") if ch.isalpha())
+    index = 0
+    for char in letters:
+        index = (index * 26) + (ord(char.upper()) - 64)
+    return max(0, index - 1)
+
+
+def _shared_strings(zf: zipfile.ZipFile) -> list[str]:
+    if "xl/sharedStrings.xml" not in zf.namelist():
+        return []
+    root = ET.fromstring(zf.read("xl/sharedStrings.xml"))
+    values: list[str] = []
+    for si in root.findall("a:si", XLSX_NS):
+        values.append("".join((node.text or "") for node in si.findall(".//a:t", XLSX_NS)))
+    return values
+
+
+def read_xlsx_rows(path: str | Path) -> tuple[str, list[dict[str, Any]]]:
+    workbook_path = Path(path).expanduser().resolve()
+    with zipfile.ZipFile(workbook_path) as zf:
+        shared = _shared_strings(zf)
+        workbook = ET.fromstring(zf.read("xl/workbook.xml"))
+        rels = ET.fromstring(zf.read("xl/_rels/workbook.xml.rels"))
+        rel_map = {rel.attrib["Id"]: rel.attrib["Target"] for rel in rels}
+        sheet = workbook.find("a:sheets", XLSX_NS)[0]
+        sheet_name = str(sheet.attrib.get("name") or "Sheet1")
+        rid = sheet.attrib.get("{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id")
+        worksheet = ET.fromstring(zf.read(f"xl/{rel_map[rid]}"))
+        rows = worksheet.findall(".//a:sheetData/a:row", XLSX_NS)
+
+        headers: list[str] = []
+        records: list[dict[str, Any]] = []
+        for row in rows:
+            values_by_index: dict[int, str] = {}
+            for cell in row.findall("a:c", XLSX_NS):
+                idx = _col_ref_to_index(cell.attrib.get("r", ""))
+                kind = cell.attrib.get("t")
+                raw_value = ""
+                value_node = cell.find("a:v", XLSX_NS)
+                if value_node is not None:
+                    raw_value = value_node.text or ""
+                if kind == "s":
+                    raw_value = shared[int(raw_value)] if raw_value.isdigit() and int(raw_value) < len(shared) else raw_value
+                elif kind == "inlineStr":
+                    inline_node = cell.find("a:is", XLSX_NS)
+                    if inline_node is not None:
+                        raw_value = "".join((node.text or "") for node in inline_node.findall(".//a:t", XLSX_NS))
+                values_by_index[idx] = raw_value
+
+            if not headers:
+                headers = [values_by_index.get(idx, "") for idx in range(max(values_by_index.keys()) + 1)]
+                continue
+
+            record = {headers[idx]: values_by_index.get(idx, "") for idx in range(len(headers))}
+            records.append(record)
+
+    return sheet_name, records
+
+
+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 missing_columns:
+        raise ValueError(f"Planilha sem colunas obrigatorias: {', '.join(missing_columns)}")
+
+    groups: dict[str, TrabalhoRawGroup] = {}
+    invalid_rows = 0
+
+    for offset, record in enumerate(records, start=2):
+        raw_name = _clean_text(record.get("AVALIANDO"))
+        if not raw_name:
+            invalid_rows += 1
+            continue
+
+        group = groups.get(raw_name)
+        if group is None:
+            group = TrabalhoRawGroup(
+                raw_name=raw_name,
+                ano=_to_int(record.get("ANO")),
+                endereco_base=_clean_text(record.get("ENDERECO")),
+                numero_base=_clean_text(record.get("NUM")),
+                first_row_number=offset,
+            )
+            groups[raw_name] = group
+        else:
+            if group.ano is None:
+                group.ano = _to_int(record.get("ANO"))
+            if not group.endereco_base:
+                group.endereco_base = _clean_text(record.get("ENDERECO"))
+            if not group.numero_base:
+                group.numero_base = _clean_text(record.get("NUM"))
+
+        modelo_nome = _clean_text(record.get("MODELO"))
+        endereco = _clean_text(record.get("ENDERECO"))
+        numero = _clean_text(record.get("NUM"))
+        coord_x = _to_float(record.get("x"))
+        coord_y = _to_float(record.get("y"))
+
+        if modelo_nome:
+            group.modelos.setdefault(modelo_nome, len(group.modelos) + 1)
+
+        imovel_key = (
+            _slugify(endereco),
+            _slugify(numero),
+            "" if coord_x is None else f"{coord_x:.8f}",
+            "" if coord_y is None else f"{coord_y:.8f}",
+        )
+        imovel = group.imoveis.get(imovel_key)
+        if imovel is None:
+            imovel = {
+                "endereco": endereco,
+                "numero": numero or "S/N",
+                "label": f"{endereco}, {numero or 'S/N'}" if endereco else (numero or "S/N"),
+                "coord_x": coord_x,
+                "coord_y": coord_y,
+                "modelos": [],
+            }
+            group.imoveis[imovel_key] = imovel
+        if modelo_nome and modelo_nome not in imovel["modelos"]:
+            imovel["modelos"].append(modelo_nome)
+
+        group.registros.append(
+            {
+                "source_row": offset,
+                "ano": _to_int(record.get("ANO")),
+                "nome_original": raw_name,
+                "modelo_nome": modelo_nome,
+                "endereco": endereco,
+                "numero": numero or "S/N",
+                "coord_x": coord_x,
+                "coord_y": coord_y,
+            }
+        )
+
+    ordered_groups = sorted(groups.values(), key=lambda item: item.first_row_number)
+
+    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)
+        if not base_name:
+            base_name = _slugify(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:
+            candidate = f"{base_name}__{suffix}"
+            suffix += 1
+        used_names[candidate] = group.raw_name
+        group.clean_name = candidate
+
+    return ordered_groups, invalid_rows
+
+
+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()
+
+    sheet_name, records = read_xlsx_rows(source_path)
+    groups, invalid_rows = _build_groups(records)
+
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    if target_path.exists():
+        target_path.unlink()
+
+    conn = sqlite3.connect(str(target_path))
+    try:
+        conn.executescript(
+            """
+            PRAGMA journal_mode = DELETE;
+            PRAGMA foreign_keys = ON;
+
+            CREATE TABLE meta (
+              key TEXT PRIMARY KEY,
+              value TEXT NOT NULL
+            );
+
+            CREATE TABLE trabalhos (
+              trabalho_id TEXT PRIMARY KEY,
+              nome TEXT NOT NULL,
+              nome_original TEXT NOT NULL,
+              tipo_codigo TEXT NOT NULL,
+              tipo_label TEXT NOT NULL,
+              ano INTEGER,
+              endereco_principal TEXT,
+              numero_principal TEXT,
+              endereco_resumo TEXT,
+              modelo_resumo TEXT,
+              total_registros INTEGER NOT NULL,
+              total_imoveis INTEGER NOT NULL,
+              total_modelos INTEGER NOT NULL,
+              tem_coordenadas INTEGER NOT NULL DEFAULT 0
+            );
+
+            CREATE TABLE trabalho_modelos (
+              trabalho_id TEXT NOT NULL,
+              modelo_nome TEXT NOT NULL,
+              ordem INTEGER NOT NULL,
+              PRIMARY KEY (trabalho_id, modelo_nome)
+            );
+
+            CREATE TABLE trabalho_imoveis (
+              imovel_id INTEGER PRIMARY KEY AUTOINCREMENT,
+              trabalho_id TEXT NOT NULL,
+              endereco TEXT,
+              numero TEXT,
+              label TEXT NOT NULL,
+              coord_x REAL,
+              coord_y REAL
+            );
+
+            CREATE TABLE trabalho_imovel_modelos (
+              imovel_id INTEGER NOT NULL,
+              modelo_nome TEXT NOT NULL,
+              PRIMARY KEY (imovel_id, modelo_nome)
+            );
+
+            CREATE TABLE trabalho_registros (
+              registro_id INTEGER PRIMARY KEY AUTOINCREMENT,
+              trabalho_id TEXT NOT NULL,
+              source_row INTEGER NOT NULL,
+              ano INTEGER,
+              nome_original TEXT NOT NULL,
+              modelo_nome TEXT,
+              endereco TEXT,
+              numero TEXT,
+              coord_x REAL,
+              coord_y REAL
+            );
+
+            CREATE INDEX idx_trabalhos_ano ON trabalhos (ano);
+            CREATE INDEX idx_trabalho_modelos_trabalho ON trabalho_modelos (trabalho_id);
+            CREATE INDEX idx_trabalho_imoveis_trabalho ON trabalho_imoveis (trabalho_id);
+            CREATE INDEX idx_trabalho_registros_trabalho ON trabalho_registros (trabalho_id);
+            """
+        )
+
+        imported_at = datetime.now(timezone.utc).isoformat()
+        meta_entries = {
+            "source_xlsx_path": str(source_path),
+            "source_xlsx_name": source_path.name,
+            "source_sheet_name": sheet_name,
+            "source_row_count": str(len(records)),
+            "invalid_row_count": str(invalid_rows),
+            "total_trabalhos": str(len(groups)),
+            "generated_at_utc": imported_at,
+            "generator_version": "sqlite-v1",
+        }
+        conn.executemany(
+            "INSERT INTO meta (key, value) VALUES (?, ?)",
+            list(meta_entries.items()),
+        )
+
+        for group in groups:
+            tipo_codigo = _tipo_codigo_from_name(group.clean_name)
+            modelos_ordenados = sorted(group.modelos.items(), key=lambda item: (item[1], item[0].lower()))
+            imoveis_ordenados = list(group.imoveis.values())
+            endereco_resumo = imoveis_ordenados[0]["label"] if imoveis_ordenados else "Endereco nao informado"
+            if len(imoveis_ordenados) > 1:
+                endereco_resumo = f"{endereco_resumo} (+{len(imoveis_ordenados) - 1})"
+            modelo_resumo = "Sem modelo informado"
+            if len(modelos_ordenados) == 1:
+                modelo_resumo = modelos_ordenados[0][0]
+            elif len(modelos_ordenados) > 1:
+                modelo_resumo = f"{len(modelos_ordenados)} modelos vinculados"
+
+            conn.execute(
+                """
+                INSERT INTO trabalhos (
+                  trabalho_id,
+                  nome,
+                  nome_original,
+                  tipo_codigo,
+                  tipo_label,
+                  ano,
+                  endereco_principal,
+                  numero_principal,
+                  endereco_resumo,
+                  modelo_resumo,
+                  total_registros,
+                  total_imoveis,
+                  total_modelos,
+                  tem_coordenadas
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    group.clean_name,
+                    group.clean_name,
+                    group.raw_name,
+                    tipo_codigo,
+                    _tipo_label(tipo_codigo),
+                    group.ano,
+                    group.endereco_base,
+                    group.numero_base or "S/N",
+                    endereco_resumo,
+                    modelo_resumo,
+                    len(group.registros),
+                    len(imoveis_ordenados),
+                    len(modelos_ordenados),
+                    1 if any(item.get("coord_x") is not None and item.get("coord_y") is not None for item in imoveis_ordenados) else 0,
+                ),
+            )
+
+            for modelo_nome, ordem in modelos_ordenados:
+                conn.execute(
+                    "INSERT INTO trabalho_modelos (trabalho_id, modelo_nome, ordem) VALUES (?, ?, ?)",
+                    (group.clean_name, modelo_nome, ordem),
+                )
+
+            for imovel in imoveis_ordenados:
+                cursor = conn.execute(
+                    """
+                    INSERT INTO trabalho_imoveis (trabalho_id, endereco, numero, label, coord_x, coord_y)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        group.clean_name,
+                        imovel.get("endereco"),
+                        imovel.get("numero"),
+                        imovel.get("label"),
+                        imovel.get("coord_x"),
+                        imovel.get("coord_y"),
+                    ),
+                )
+                imovel_id = int(cursor.lastrowid)
+                for modelo_nome in imovel.get("modelos") or []:
+                    conn.execute(
+                        "INSERT INTO trabalho_imovel_modelos (imovel_id, modelo_nome) VALUES (?, ?)",
+                        (imovel_id, modelo_nome),
+                    )
+
+            for registro in group.registros:
+                conn.execute(
+                    """
+                    INSERT INTO trabalho_registros (
+                      trabalho_id,
+                      source_row,
+                      ano,
+                      nome_original,
+                      modelo_nome,
+                      endereco,
+                      numero,
+                      coord_x,
+                      coord_y
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        group.clean_name,
+                        registro["source_row"],
+                        registro["ano"],
+                        registro["nome_original"],
+                        registro["modelo_nome"],
+                        registro["endereco"],
+                        registro["numero"],
+                        registro["coord_x"],
+                        registro["coord_y"],
+                    ),
+                )
+
+        conn.commit()
+    finally:
+        conn.close()
+
+    corrected_names = sum(1 for group in groups if group.clean_name != group.raw_name)
+    return {
+        "db_path": str(target_path),
+        "source_xlsx_path": str(source_path),
+        "source_sheet_name": sheet_name,
+        "source_row_count": len(records),
+        "invalid_row_count": invalid_rows,
+        "total_trabalhos": len(groups),
+        "corrected_names": corrected_names,
+    }

backend/app/services/trabalhos_tecnicos_repository.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from fastapi import HTTPException
+
+try:
+    from huggingface_hub import HfApi, hf_hub_download
+except Exception:  # pragma: no cover
+    HfApi = None  # type: ignore[assignment]
+    hf_hub_download = None  # type: ignore[assignment]
+
+from app.services.trabalhos_tecnicos_importer import DEFAULT_LOCAL_DB_FILE
+
+
+DEFAULT_HF_REPO_ID = "gui-sparim/repositorio_mesa"
+DEFAULT_HF_REVISION = "main"
+DEFAULT_HF_DB_PATH = f"trabalhos_tecnicos/{DEFAULT_LOCAL_DB_FILE}"
+
+
+@dataclass(frozen=True)
+class TrabalhosTecnicosDbResolution:
+    provider: str
+    db_path: Path
+    revision: str | None = None
+    repo_id: str | None = None
+    path_in_repo: str | None = None
+
+    def as_payload(self) -> dict[str, str | None]:
+        return {
+            "provider": self.provider,
+            "db_path": str(self.db_path),
+            "revision": self.revision,
+            "repo_id": self.repo_id,
+            "path_in_repo": self.path_in_repo,
+        }
+
+
+def _is_hf_runtime() -> bool:
+    for key in ("SPACE_ID", "SPACE_AUTHOR_NAME", "HF_SPACE_ID"):
+        if str(os.getenv(key) or "").strip():
+            return True
+    return False
+
+
+def _provider() -> str:
+    raw = str(os.getenv("TRABALHOS_TECNICOS_PROVIDER") or "auto").strip().lower()
+    if raw in {"local", "file"}:
+        return "local"
+    if raw in {"hf", "hf_dataset", "dataset", "huggingface"}:
+        return "hf_dataset"
+    return "hf_dataset" if _is_hf_runtime() else "local"
+
+
+def _local_db_path() -> Path:
+    raw = str(os.getenv("TRABALHOS_TECNICOS_DB_LOCAL_PATH") or "").strip()
+    if raw:
+        return Path(raw).expanduser().resolve()
+    return (Path(__file__).resolve().parents[2] / "local_data" / DEFAULT_LOCAL_DB_FILE).resolve()
+
+
+def _hf_repo_id() -> str:
+    return str(
+        os.getenv("TRABALHOS_TECNICOS_HF_REPO_ID")
+        or os.getenv("MODELOS_REPOSITORIO_HF_REPO_ID")
+        or DEFAULT_HF_REPO_ID
+    ).strip()
+
+
+def _hf_revision() -> str:
+    return str(
+        os.getenv("TRABALHOS_TECNICOS_HF_REVISION")
+        or os.getenv("MODELOS_REPOSITORIO_HF_REVISION")
+        or DEFAULT_HF_REVISION
+    ).strip()
+
+
+def _hf_path_in_repo() -> str:
+    return str(os.getenv("TRABALHOS_TECNICOS_HF_PATH") or DEFAULT_HF_DB_PATH).strip().strip("/")
+
+
+def _hf_token() -> str | None:
+    for key in ("HF_TOKEN", "HUGGINGFACE_HUB_TOKEN", "HUGGINGFACE_TOKEN"):
+        value = os.getenv(key)
+        if value:
+            return value
+    return None
+
+
+def resolve_database() -> TrabalhosTecnicosDbResolution:
+    provider = _provider()
+    if provider == "local":
+        path = _local_db_path()
+        if not path.exists():
+            raise HTTPException(
+                status_code=404,
+                detail=(
+                    "Banco local de trabalhos tecnicos nao encontrado. "
+                    "Gere-o com o script de importacao antes de abrir a aba."
+                ),
+            )
+        return TrabalhosTecnicosDbResolution(provider="local", db_path=path)
+
+    if HfApi is None or hf_hub_download is None:
+        raise HTTPException(status_code=500, detail="huggingface_hub nao disponivel no backend")
+
+    repo_id = _hf_repo_id()
+    revision_ref = _hf_revision()
+    path_in_repo = _hf_path_in_repo()
+    token = _hf_token()
+    api = HfApi(token=token)
+    try:
+        info = api.dataset_info(repo_id=repo_id, revision=revision_ref, token=token)
+        revision = str(getattr(info, "sha", "") or "").strip() or revision_ref
+        local_path = Path(
+            hf_hub_download(
+                repo_id=repo_id,
+                repo_type="dataset",
+                revision=revision,
+                filename=path_in_repo,
+                token=token,
+            )
+        )
+    except Exception as exc:
+        raise HTTPException(
+            status_code=503,
+            detail=f"Nao foi possivel carregar o banco de trabalhos tecnicos do dataset HF: {exc}",
+        ) from exc
+
+    return TrabalhosTecnicosDbResolution(
+        provider="hf_dataset",
+        db_path=local_path,
+        revision=revision,
+        repo_id=repo_id,
+        path_in_repo=path_in_repo,
+    )

backend/app/services/trabalhos_tecnicos_service.py

@@ -0,0 +1,557 @@
+from __future__ import annotations
+
+import math
+import sqlite3
+from pathlib import Path
+from statistics import median
+from typing import Any
+
+import folium
+from fastapi import HTTPException
+from folium import plugins
+
+from app.core.map_layers import add_bairros_layer, add_popup_pagination_handlers, add_zoom_responsive_circle_markers
+from app.services import model_repository, trabalhos_tecnicos_repository
+from app.services.serializers import sanitize_value
+
+
+def _connect_database(path: Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(path))
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def _fetch_meta(conn: sqlite3.Connection) -> dict[str, str]:
+    rows = conn.execute("SELECT key, value FROM meta").fetchall()
+    return {str(row["key"]): str(row["value"]) for row in rows}
+
+
+def _table_payload(records: list[dict[str, Any]], columns: list[str]) -> dict[str, Any]:
+    rows: list[dict[str, Any]] = []
+    for index, record in enumerate(records, start=1):
+        payload_row = {"_index": index}
+        for column in columns:
+            payload_row[column] = sanitize_value(record.get(column))
+        rows.append(payload_row)
+    return {
+        "columns": ["_index"] + columns,
+        "rows": rows,
+        "total_rows": len(records),
+        "returned_rows": len(records),
+        "truncated": False,
+    }
+
+
+def _source_payload(
+    resolved: trabalhos_tecnicos_repository.TrabalhosTecnicosDbResolution,
+    meta: dict[str, str],
+) -> dict[str, Any]:
+    return sanitize_value(
+        {
+            "provider": resolved.provider,
+            "arquivo": str(resolved.db_path),
+            "arquivo_nome": Path(resolved.path_in_repo or resolved.db_path.name).name,
+            "repo_id": resolved.repo_id,
+            "revision": resolved.revision,
+            "path_in_repo": resolved.path_in_repo,
+            "source_xlsx_name": meta.get("source_xlsx_name"),
+            "source_sheet_name": meta.get("source_sheet_name"),
+            "source_row_count": int(meta.get("source_row_count") or 0),
+            "generated_at_utc": meta.get("generated_at_utc"),
+        }
+    )
+
+
+def _catalogo_modelos_mesa() -> dict[str, dict[str, str]]:
+    try:
+        payload = model_repository.list_repository_models()
+    except Exception:
+        return {}
+
+    itens = payload.get("modelos") if isinstance(payload, dict) else []
+    if not isinstance(itens, list):
+        return {}
+
+    catalogo: dict[str, dict[str, str]] = {}
+    for item in itens:
+        if not isinstance(item, dict):
+            continue
+        modelo_id = str(item.get("id") or "").strip()
+        arquivo = str(item.get("arquivo") or "").strip()
+        nome_modelo = str(item.get("nome_modelo") or modelo_id or arquivo).strip()
+        if not modelo_id and not arquivo:
+            continue
+        registro = {
+            "id": modelo_id or Path(arquivo).stem,
+            "arquivo": arquivo or f"{modelo_id}.dai",
+            "nome_modelo": nome_modelo,
+        }
+        for key in {modelo_id, arquivo, Path(arquivo).stem if arquivo else "", nome_modelo}:
+            key_norm = str(key or "").strip().casefold()
+            if key_norm:
+                catalogo[key_norm] = registro
+    return catalogo
+
+
+def _registrar_chaves_modelo(destino: set[str], *values: Any) -> None:
+    for value in values:
+        texto = str(value or "").strip()
+        if not texto:
+            continue
+        destino.add(texto.casefold())
+        if texto.lower().endswith(".dai"):
+            stem = Path(texto).stem.strip()
+            if stem:
+                destino.add(stem.casefold())
+
+
+def _expandir_chaves_modelo(values: list[str], catalogo: dict[str, dict[str, str]]) -> set[str]:
+    chaves: set[str] = set()
+    for value in values:
+        _registrar_chaves_modelo(chaves, value)
+
+    registros = [catalogo.get(chave) for chave in list(chaves)]
+    for registro in registros:
+        if not registro:
+            continue
+        _registrar_chaves_modelo(
+            chaves,
+            registro.get("id"),
+            registro.get("arquivo"),
+            registro.get("nome_modelo"),
+        )
+    return chaves
+
+
+def _enriquecer_modelos(modelo_nomes: list[str], catalogo: dict[str, dict[str, str]]) -> list[dict[str, Any]]:
+    enriched: list[dict[str, Any]] = []
+    for nome in modelo_nomes:
+        key = str(nome or "").strip().casefold()
+        mesa = catalogo.get(key)
+        enriched.append(
+            {
+                "nome": nome,
+                "disponivel_mesa": bool(mesa),
+                "mesa_modelo_id": mesa.get("id") if mesa else None,
+                "mesa_modelo_arquivo": mesa.get("arquivo") if mesa else None,
+                "mesa_modelo_nome": mesa.get("nome_modelo") if mesa else None,
+            }
+        )
+    return enriched
+
+
+def _coordenada_valida(value: Any) -> bool:
+    if value is None:
+        return False
+    try:
+        number = float(value)
+    except Exception:
+        return False
+    return math.isfinite(number)
+
+
+def listar_avaliandos_por_modelo(chaves_modelo: list[str]) -> list[dict[str, Any]]:
+    aliases = [str(item or "").strip() for item in (chaves_modelo or []) if str(item or "").strip()]
+    if not aliases:
+        return []
+
+    try:
+        resolved = trabalhos_tecnicos_repository.resolve_database()
+        catalogo_modelos = _catalogo_modelos_mesa()
+    except Exception:
+        return []
+
+    chaves_selecionadas = _expandir_chaves_modelo(aliases, catalogo_modelos)
+    if not chaves_selecionadas:
+        return []
+
+    conn = _connect_database(resolved.db_path)
+    try:
+        rows = conn.execute(
+            """
+            SELECT
+              t.trabalho_id,
+              t.nome AS trabalho_nome,
+              t.tipo_label,
+              ti.imovel_id,
+              ti.label,
+              ti.endereco,
+              ti.numero,
+              ti.coord_x,
+              ti.coord_y,
+              tim.modelo_nome
+            FROM trabalho_imoveis ti
+            JOIN trabalhos t
+              ON t.trabalho_id = ti.trabalho_id
+            JOIN trabalho_imovel_modelos tim
+              ON tim.imovel_id = ti.imovel_id
+            ORDER BY LOWER(t.nome), ti.imovel_id, LOWER(tim.modelo_nome)
+            """
+        ).fetchall()
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+    if not rows:
+        return []
+
+    agregados: dict[tuple[str, int], dict[str, Any]] = {}
+    for row in rows:
+        coord_x = row["coord_x"]
+        coord_y = row["coord_y"]
+        if not _coordenada_valida(coord_x) or not _coordenada_valida(coord_y):
+            continue
+
+        chaves_linha = _expandir_chaves_modelo([str(row["modelo_nome"] or "")], catalogo_modelos)
+        if not chaves_linha or chaves_linha.isdisjoint(chaves_selecionadas):
+            continue
+
+        trabalho_id = str(row["trabalho_id"])
+        imovel_id = int(row["imovel_id"])
+        chave = (trabalho_id, imovel_id)
+        item = agregados.setdefault(
+            chave,
+            {
+                "trabalho_id": trabalho_id,
+                "trabalho_nome": str(row["trabalho_nome"] or trabalho_id),
+                "tipo_label": str(row["tipo_label"] or ""),
+                "label": str(row["label"] or ""),
+                "endereco": str(row["endereco"] or ""),
+                "numero": str(row["numero"] or ""),
+                "coord_x": float(coord_x),
+                "coord_y": float(coord_y),
+                "coord_lon": float(coord_x),
+                "coord_lat": float(coord_y),
+                "modelos_relacionados": set(),
+            },
+        )
+        modelo_nome = str(row["modelo_nome"] or "").strip()
+        if modelo_nome:
+            item["modelos_relacionados"].add(modelo_nome)
+
+    resultado: list[dict[str, Any]] = []
+    for item in agregados.values():
+        modelos_relacionados = sorted(item["modelos_relacionados"], key=lambda value: str(value).casefold())
+        resultado.append(
+            {
+                **item,
+                "modelos_relacionados": modelos_relacionados,
+            }
+        )
+
+    resultado.sort(
+        key=lambda item: (
+            str(item.get("trabalho_nome") or "").casefold(),
+            str(item.get("label") or item.get("endereco") or "").casefold(),
+        )
+    )
+    return sanitize_value(resultado)
+
+
+def _criar_mapa_trabalho(nome_trabalho: str, imoveis: list[dict[str, Any]]) -> str:
+    pontos = [
+        item for item in imoveis
+        if _coordenada_valida(item.get("coord_x")) and _coordenada_valida(item.get("coord_y"))
+    ]
+    if not pontos:
+        return "<p>Coordenadas indisponiveis para este trabalho tecnico.</p>"
+
+    latitudes = [float(item["coord_y"]) for item in pontos]
+    longitudes = [float(item["coord_x"]) for item in pontos]
+    centro_lat = float(median(latitudes))
+    centro_lon = float(median(longitudes))
+
+    mapa = folium.Map(
+        location=[centro_lat, centro_lon],
+        zoom_start=14,
+        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)
+
+    camada = folium.FeatureGroup(name="Imoveis do trabalho", show=True)
+    for index, item in enumerate(pontos, start=1):
+        modelos_texto = ", ".join(item.get("modelos") or []) or "Sem modelo informado"
+        tooltip_html = (
+            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:13px; line-height:1.5;'>"
+            f"<b>{nome_trabalho}</b>"
+            f"<br><span style='color:#555;'>Imovel:</span> <b>{item.get('label') or 'Nao informado'}</b>"
+            f"<br><span style='color:#555;'>Modelos:</span> {modelos_texto}"
+            "</div>"
+        )
+        marcador = folium.CircleMarker(
+            location=[float(item["coord_y"]), float(item["coord_x"])],
+            radius=8,
+            tooltip=folium.Tooltip(tooltip_html, sticky=True),
+            color="#ffffff",
+            weight=1.0,
+            fill=True,
+            fillColor="#1f6fb2",
+            fillOpacity=0.9,
+        )
+        marcador.options["mesaBaseRadius"] = 8.0
+        camada.add_child(marcador)
+        if len(pontos) > 1:
+            folium.Marker(
+                location=[float(item["coord_y"]), float(item["coord_x"])],
+                icon=folium.DivIcon(
+                    html=(
+                        "<div style='display:flex;align-items:center;justify-content:center;"
+                        "width:20px;height:20px;border-radius:999px;background:#ffffff;"
+                        "border:1px solid #1f6fb2;color:#1f4b75;font:700 11px Arial,sans-serif;'>"
+                        f"{index}</div>"
+                    )
+                ),
+            ).add_to(camada)
+    camada.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 = min(latitudes)
+    lat_max = max(latitudes)
+    lon_min = min(longitudes)
+    lon_max = max(longitudes)
+    if math.isclose(lat_min, lat_max):
+        lat_min -= 0.0008
+        lat_max += 0.0008
+    if math.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=(42, 42), max_zoom=18)
+    return mapa.get_root().render()
+
+
+def listar_trabalhos() -> dict[str, Any]:
+    resolved = trabalhos_tecnicos_repository.resolve_database()
+    catalogo_modelos = _catalogo_modelos_mesa()
+
+    conn = _connect_database(resolved.db_path)
+    try:
+        meta = _fetch_meta(conn)
+        trabalhos_rows = conn.execute(
+            """
+            SELECT
+              trabalho_id,
+              nome,
+              nome_original,
+              tipo_codigo,
+              tipo_label,
+              ano,
+              endereco_resumo,
+              modelo_resumo,
+              total_registros,
+              total_imoveis,
+              total_modelos,
+              tem_coordenadas
+            FROM trabalhos
+            ORDER BY COALESCE(ano, 0) DESC, LOWER(tipo_codigo), LOWER(nome)
+            """
+        ).fetchall()
+        modelos_rows = conn.execute(
+            "SELECT trabalho_id, modelo_nome FROM trabalho_modelos ORDER BY trabalho_id, ordem, LOWER(modelo_nome)"
+        ).fetchall()
+    finally:
+        conn.close()
+
+    modelos_por_trabalho: dict[str, list[str]] = {}
+    for row in modelos_rows:
+        modelos_por_trabalho.setdefault(str(row["trabalho_id"]), []).append(str(row["modelo_nome"]))
+
+    trabalhos: list[dict[str, Any]] = []
+    total_com_modelo_mesa = 0
+    for row in trabalhos_rows:
+        trabalho_id = str(row["trabalho_id"])
+        modelos = _enriquecer_modelos(modelos_por_trabalho.get(trabalho_id, []), catalogo_modelos)
+        modelos_mesa = [item for item in modelos if item.get("disponivel_mesa")]
+        if modelos_mesa:
+            total_com_modelo_mesa += 1
+        trabalhos.append(
+            {
+                "id": trabalho_id,
+                "nome": str(row["nome"]),
+                "nome_original": str(row["nome_original"]),
+                "tipo_codigo": str(row["tipo_codigo"]),
+                "tipo_label": str(row["tipo_label"]),
+                "ano": row["ano"],
+                "endereco_resumo": str(row["endereco_resumo"] or ""),
+                "modelo_resumo": str(row["modelo_resumo"] or ""),
+                "total_registros_planilha": int(row["total_registros"] or 0),
+                "total_imoveis": int(row["total_imoveis"] or 0),
+                "total_modelos": int(row["total_modelos"] or 0),
+                "possui_modelo_mesa": bool(modelos_mesa),
+                "modelo_mesa_principal": modelos_mesa[0]["mesa_modelo_nome"] if modelos_mesa else None,
+                "tem_coordenadas": bool(row["tem_coordenadas"]),
+                "modelos": modelos,
+            }
+        )
+
+    return sanitize_value(
+        {
+            "trabalhos": trabalhos,
+            "total_trabalhos": len(trabalhos),
+            "total_com_modelo_mesa": total_com_modelo_mesa,
+            "fonte": _source_payload(resolved, meta),
+        }
+    )
+
+
+def detalhar_trabalho(trabalho_id: str) -> dict[str, Any]:
+    chave = str(trabalho_id or "").strip()
+    if not chave:
+        raise HTTPException(status_code=400, detail="Informe o identificador do trabalho tecnico")
+
+    resolved = trabalhos_tecnicos_repository.resolve_database()
+    catalogo_modelos = _catalogo_modelos_mesa()
+
+    conn = _connect_database(resolved.db_path)
+    try:
+        meta = _fetch_meta(conn)
+        trabalho_row = conn.execute(
+            """
+            SELECT
+              trabalho_id,
+              nome,
+              nome_original,
+              tipo_codigo,
+              tipo_label,
+              ano,
+              endereco_resumo,
+              modelo_resumo,
+              total_registros,
+              total_imoveis,
+              total_modelos,
+              tem_coordenadas
+            FROM trabalhos
+            WHERE trabalho_id = ?
+            """,
+            (chave,),
+        ).fetchone()
+        if trabalho_row is None:
+            raise HTTPException(status_code=404, detail="Trabalho tecnico nao encontrado")
+
+        modelo_rows = conn.execute(
+            "SELECT modelo_nome FROM trabalho_modelos WHERE trabalho_id = ? ORDER BY ordem, LOWER(modelo_nome)",
+            (chave,),
+        ).fetchall()
+        imovel_rows = conn.execute(
+            """
+            SELECT imovel_id, endereco, numero, label, coord_x, coord_y
+            FROM trabalho_imoveis
+            WHERE trabalho_id = ?
+            ORDER BY imovel_id
+            """,
+            (chave,),
+        ).fetchall()
+        imovel_model_rows = conn.execute(
+            """
+            SELECT imovel_id, modelo_nome
+            FROM trabalho_imovel_modelos
+            WHERE imovel_id IN (SELECT imovel_id FROM trabalho_imoveis WHERE trabalho_id = ?)
+            ORDER BY imovel_id, LOWER(modelo_nome)
+            """,
+            (chave,),
+        ).fetchall()
+        registro_rows = conn.execute(
+            """
+            SELECT source_row, ano, nome_original, modelo_nome, endereco, numero, coord_x, coord_y
+            FROM trabalho_registros
+            WHERE trabalho_id = ?
+            ORDER BY source_row
+            """,
+            (chave,),
+        ).fetchall()
+    finally:
+        conn.close()
+
+    modelos = _enriquecer_modelos([str(row["modelo_nome"]) for row in modelo_rows], catalogo_modelos)
+    modelos_por_imovel: dict[int, list[str]] = {}
+    for row in imovel_model_rows:
+        modelos_por_imovel.setdefault(int(row["imovel_id"]), []).append(str(row["modelo_nome"]))
+
+    imoveis: list[dict[str, Any]] = []
+    for row in imovel_rows:
+        imoveis.append(
+            {
+                "endereco": str(row["endereco"] or ""),
+                "numero": str(row["numero"] or ""),
+                "label": str(row["label"] or ""),
+                "coord_x": row["coord_x"],
+                "coord_y": row["coord_y"],
+                "coord_lon": row["coord_x"],
+                "coord_lat": row["coord_y"],
+                "modelos": modelos_por_imovel.get(int(row["imovel_id"]), []),
+            }
+        )
+
+    imoveis_tabela = _table_payload(
+        [
+            {
+                "Endereco": item.get("endereco"),
+                "Numero": item.get("numero"),
+                "Coordenada X": item.get("coord_x"),
+                "Coordenada Y": item.get("coord_y"),
+                "Modelos associados": ", ".join(item.get("modelos") or []),
+            }
+            for item in imoveis
+        ],
+        ["Endereco", "Numero", "Coordenada X", "Coordenada Y", "Modelos associados"],
+    )
+    modelos_tabela = _table_payload(
+        [
+            {
+                "Modelo importado": item.get("nome"),
+                "Disponivel na MESA": "Sim" if item.get("disponivel_mesa") else "Nao",
+                "Modelo no repositorio": item.get("mesa_modelo_nome") or "",
+            }
+            for item in modelos
+        ],
+        ["Modelo importado", "Disponivel na MESA", "Modelo no repositorio"],
+    )
+    registros_tabela = _table_payload(
+        [
+            {
+                "Linha origem": int(row["source_row"]),
+                "Ano": row["ano"],
+                "Nome original": str(row["nome_original"]),
+                "Modelo": str(row["modelo_nome"] or ""),
+                "Endereco": str(row["endereco"] or ""),
+                "Numero": str(row["numero"] or ""),
+                "Coordenada X": row["coord_x"],
+                "Coordenada Y": row["coord_y"],
+            }
+            for row in registro_rows
+        ],
+        ["Linha origem", "Ano", "Nome original", "Modelo", "Endereco", "Numero", "Coordenada X", "Coordenada Y"],
+    )
+
+    return sanitize_value(
+        {
+            "trabalho": {
+                "id": str(trabalho_row["trabalho_id"]),
+                "nome": str(trabalho_row["nome"]),
+                "nome_original": str(trabalho_row["nome_original"]),
+                "tipo_codigo": str(trabalho_row["tipo_codigo"]),
+                "tipo_label": str(trabalho_row["tipo_label"]),
+                "ano": trabalho_row["ano"],
+                "endereco_resumo": str(trabalho_row["endereco_resumo"] or ""),
+                "modelo_resumo": str(trabalho_row["modelo_resumo"] or ""),
+                "total_registros_planilha": int(trabalho_row["total_registros"] or 0),
+                "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"]),
+                "modelos": modelos,
+                "imoveis": imoveis,
+                "mapa_html": _criar_mapa_trabalho(str(trabalho_row["nome"]), imoveis),
+                "imoveis_tabela": imoveis_tabela,
+                "modelos_tabela": modelos_tabela,
+                "registros_tabela": registros_tabela,
+                "fonte": _source_payload(resolved, meta),
+            }
+        }
+    )

backend/app/services/visualizacao_service.py

@@ -24,7 +24,7 @@ from app.core.elaboracao.core import (
 )
 from app.core.elaboracao.formatadores import formatar_avaliacao_html
 from app.models.session import SessionState
-from app.services import model_repository
+from app.services import model_repository, trabalhos_tecnicos_service
 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
@@ -96,6 +96,76 @@ def _formatar_tooltip_valor(coluna: str, valor: Any) -> str:
     return str(valor)
 
 
+def _resumir_trabalhos_tecnicos(avaliandos_tecnicos: list[dict[str, Any]] | None) -> list[dict[str, Any]]:
+    agrupados: dict[str, dict[str, Any]] = {}
+    for item in avaliandos_tecnicos or []:
+        trabalho_id = str(item.get("trabalho_id") or "").strip()
+        if not trabalho_id:
+            continue
+
+        trabalho = agrupados.setdefault(
+            trabalho_id,
+            {
+                "trabalho_id": trabalho_id,
+                "trabalho_nome": str(item.get("trabalho_nome") or trabalho_id).strip(),
+                "tipo_label": str(item.get("tipo_label") or "").strip(),
+                "_imoveis_indexados": set(),
+                "_modelos_relacionados": set(),
+                "imoveis": [],
+            },
+        )
+
+        endereco = str(item.get("endereco") or "").strip()
+        numero = str(item.get("numero") or "").strip()
+        endereco_texto = ", ".join([valor for valor in [endereco, numero] if valor]) or "Endereco nao informado"
+        label = str(item.get("label") or "").strip() or endereco_texto
+        imovel_key = f"{label}::{endereco_texto}"
+        if imovel_key not in trabalho["_imoveis_indexados"]:
+            trabalho["_imoveis_indexados"].add(imovel_key)
+            trabalho["imoveis"].append(
+                {
+                    "label": label,
+                    "endereco": endereco_texto,
+                }
+            )
+
+        for modelo_nome in item.get("modelos_relacionados") or []:
+            modelo_texto = str(modelo_nome or "").strip()
+            if modelo_texto:
+                trabalho["_modelos_relacionados"].add(modelo_texto)
+
+    resultado: list[dict[str, Any]] = []
+    for trabalho in agrupados.values():
+        imoveis = sorted(
+            trabalho["imoveis"],
+            key=lambda imovel: (
+                str(imovel.get("label") or "").casefold(),
+                str(imovel.get("endereco") or "").casefold(),
+            ),
+        )
+        resultado.append(
+            {
+                "trabalho_id": trabalho["trabalho_id"],
+                "trabalho_nome": trabalho["trabalho_nome"],
+                "tipo_label": trabalho["tipo_label"],
+                "total_imoveis": len(imoveis),
+                "imoveis": imoveis,
+                "modelos_relacionados": sorted(
+                    trabalho["_modelos_relacionados"],
+                    key=lambda valor: str(valor).casefold(),
+                ),
+            }
+        )
+
+    resultado.sort(
+        key=lambda item: (
+            str(item.get("trabalho_nome") or "").casefold(),
+            str(item.get("tipo_label") or "").casefold(),
+        )
+    )
+    return sanitize_value(resultado)
+
+
 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>"
@@ -342,6 +412,54 @@ def _resolver_valor_area_avaliacao(valores: dict[str, Any], coluna_area: str | N
     return float(valor)
 
 
+def _normalizar_coordenadas_avaliando(lat_raw: Any, lon_raw: Any) -> tuple[float | None, float | None]:
+    try:
+        lat = float(lat_raw)
+        lon = float(lon_raw)
+    except Exception:
+        return None, None
+    if not np.isfinite(lat) or not np.isfinite(lon):
+        return None, None
+    if not (-90.0 <= lat <= 90.0) or not (-180.0 <= lon <= 180.0):
+        return None, None
+    return float(lat), float(lon)
+
+
+def _montar_valores_knn(
+    valores_x: dict[str, float],
+    avaliando_lat: Any = None,
+    avaliando_lon: Any = None,
+) -> tuple[dict[str, float], float | None, float | None]:
+    valores_knn = dict(valores_x or {})
+    lat, lon = _normalizar_coordenadas_avaliando(avaliando_lat, avaliando_lon)
+    if lat is not None and lon is not None:
+        valores_knn["latitude"] = lat
+        valores_knn["longitude"] = lon
+    return valores_knn, lat, lon
+
+
+def _aliases_modelo_visualizacao(session: SessionState) -> list[str]:
+    aliases: list[str] = []
+    for value in (session.uploaded_filename, session.uploaded_file_path):
+        texto = str(value or "").strip()
+        if not texto:
+            continue
+        aliases.append(texto)
+        try:
+            aliases.append(Path(texto).stem)
+        except Exception:
+            continue
+    vistos = set()
+    unicos: list[str] = []
+    for item in aliases:
+        chave = str(item or "").strip().casefold()
+        if not chave or chave in vistos:
+            continue
+        vistos.add(chave)
+        unicos.append(str(item).strip())
+    return unicos
+
+
 def _equacoes_do_modelo(pacote: dict[str, Any], info: dict[str, Any]) -> dict[str, Any]:
     diagnosticos = pacote.get("modelo", {}).get("diagnosticos", {}) if isinstance(pacote.get("modelo"), dict) else {}
     return build_equacoes_payload(
@@ -354,6 +472,15 @@ def _equacoes_do_modelo(pacote: dict[str, Any], info: dict[str, Any]) -> dict[st
     )
 
 
+def _preparar_dados_visualizacao(pacote: dict[str, Any]) -> pd.DataFrame:
+    dados = pacote["dados"]["df"].reset_index()
+    for col in dados.columns:
+        if pd.api.types.is_numeric_dtype(dados[col]) and str(col).lower() not in ["lat", "latitude", "lon", "longitude", "long", "siat_latitude", "siat_longitude"]:
+            dados[col] = dados[col].round(2)
+    dados["__mesa_row_id__"] = np.arange(len(dados), dtype=int)
+    return dados
+
+
 def exibir_contexto_avaliacao(session: SessionState) -> dict[str, Any]:
     pacote = session.pacote_visualizacao
     if pacote is None:
@@ -368,15 +495,13 @@ def exibir_contexto_avaliacao(session: SessionState) -> dict[str, Any]:
     }
 
 
-def exibir_modelo(session: SessionState) -> dict[str, Any]:
+def exibir_modelo(session: SessionState, api_base_url: str | None = None, popup_auth_token: str | None = None) -> dict[str, Any]:
     pacote = session.pacote_visualizacao
     if pacote is None:
         raise HTTPException(status_code=400, detail="Carregue um modelo primeiro")
 
-    dados = pacote["dados"]["df"].reset_index()
-    for col in dados.columns:
-        if pd.api.types.is_numeric_dtype(dados[col]) and str(col).lower() not in ["lat", "latitude", "lon", "longitude", "long", "siat_latitude", "siat_longitude"]:
-            dados[col] = dados[col].round(2)
+    dados = _preparar_dados_visualizacao(pacote)
+    dados_publicos = dados.drop(columns=["__mesa_row_id__"])
 
     estat = _tabela_estatisticas(pacote).round(2)
 
@@ -406,11 +531,22 @@ def exibir_modelo(session: SessionState) -> dict[str, Any]:
 
     info = _extrair_modelo_info(pacote)
     equacoes = _equacoes_do_modelo(pacote, info)
-    mapa_html = viz_app.criar_mapa(dados, col_y=info["nome_y"])
+    aliases_modelo = _aliases_modelo_visualizacao(session)
+    avaliandos_tecnicos = trabalhos_tecnicos_service.listar_avaliandos_por_modelo(aliases_modelo)
+    trabalhos_tecnicos = _resumir_trabalhos_tecnicos(avaliandos_tecnicos)
+    popup_endpoint = f"{api_base_url.rstrip('/')}/api/visualizacao/map/popup" if api_base_url else "/api/visualizacao/map/popup"
+    mapa_html = viz_app.criar_mapa(
+        dados,
+        col_y=info["nome_y"],
+        session_id=session.session_id,
+        popup_endpoint=popup_endpoint,
+        popup_auth_token=popup_auth_token,
+        avaliandos_tecnicos=avaliandos_tecnicos,
+    )
 
     colunas_numericas = [
         str(col)
-        for col in dados.select_dtypes(include=[np.number]).columns
+        for col in dados_publicos.select_dtypes(include=[np.number]).columns
         if str(col).lower() not in ["lat", "lon", "latitude", "longitude", "index"]
     ]
     choices_mapa = ["Visualização Padrão"] + colunas_numericas
@@ -418,7 +554,7 @@ def exibir_modelo(session: SessionState) -> dict[str, Any]:
     session.dados_visualizacao = dados
 
     return {
-        "dados": dataframe_to_payload(dados, decimals=2, max_rows=None),
+        "dados": dataframe_to_payload(dados_publicos, decimals=2, max_rows=None),
         "estatisticas": dataframe_to_payload(estat, decimals=2),
         "escalas_html": escalas_html,
         "dados_transformados": dataframe_to_payload(df_xy, decimals=2, max_rows=None),
@@ -435,10 +571,11 @@ def exibir_modelo(session: SessionState) -> dict[str, Any]:
         "campos_avaliacao": campos_avaliacao(session),
         "meta_modelo": sanitize_value(info),
         "equacoes": sanitize_value(equacoes),
+        "trabalhos_tecnicos": trabalhos_tecnicos,
     }
 
 
-def atualizar_mapa(session: SessionState, variavel_mapa: str | None) -> dict[str, Any]:
+def atualizar_mapa(session: SessionState, variavel_mapa: str | None, api_base_url: str | None = None, popup_auth_token: str | None = None) -> dict[str, Any]:
     pacote = session.pacote_visualizacao
     dados = session.dados_visualizacao
     if pacote is None or dados is None or dados.empty:
@@ -449,10 +586,50 @@ def atualizar_mapa(session: SessionState, variavel_mapa: str | None) -> dict[str
     if variavel_mapa and variavel_mapa != "Visualização Padrão":
         tamanho_col = variavel_mapa
 
-    mapa_html = viz_app.criar_mapa(dados, tamanho_col=tamanho_col, col_y=info["nome_y"])
+    avaliandos_tecnicos = trabalhos_tecnicos_service.listar_avaliandos_por_modelo(
+        _aliases_modelo_visualizacao(session)
+    )
+    popup_endpoint = f"{api_base_url.rstrip('/')}/api/visualizacao/map/popup" if api_base_url else "/api/visualizacao/map/popup"
+    mapa_html = viz_app.criar_mapa(
+        dados,
+        tamanho_col=tamanho_col,
+        col_y=info["nome_y"],
+        session_id=session.session_id,
+        popup_endpoint=popup_endpoint,
+        popup_auth_token=popup_auth_token,
+        avaliandos_tecnicos=avaliandos_tecnicos,
+    )
     return {"mapa_html": mapa_html}
 
 
+def carregar_popup_ponto_mapa(session: SessionState, row_id: int) -> dict[str, Any]:
+    dados = session.dados_visualizacao
+    if dados is None or dados.empty:
+        raise HTTPException(status_code=400, detail="Exiba o modelo antes de abrir os detalhes do ponto")
+    if "__mesa_row_id__" not in dados.columns:
+        raise HTTPException(status_code=400, detail="Sessao sem identificadores de pontos carregados")
+
+    try:
+        row_id_int = int(row_id)
+    except (TypeError, ValueError) as exc:
+        raise HTTPException(status_code=400, detail="Identificador de ponto invalido") from exc
+
+    registros = dados.loc[dados["__mesa_row_id__"] == row_id_int]
+    if registros.empty:
+        raise HTTPException(status_code=404, detail="Ponto nao encontrado para esta sessao")
+
+    row = registros.iloc[0]
+    popup_html, popup_width = viz_app.montar_popup_registro_html(
+        row,
+        popup_uid=f"mesa-popup-row-{row_id_int}",
+        max_itens_pagina=8,
+    )
+    return {
+        "popup_html": popup_html,
+        "popup_width": int(popup_width),
+    }
+
+
 def campos_avaliacao(session: SessionState) -> list[dict[str, Any]]:
     pacote = session.pacote_visualizacao
     if pacote is None:
@@ -532,7 +709,13 @@ def campos_avaliacao(session: SessionState) -> list[dict[str, Any]]:
     return sanitize_value(campos)
 
 
-def calcular_avaliacao(session: SessionState, valores_x: dict[str, Any], indice_base: str | None) -> dict[str, Any]:
+def calcular_avaliacao(
+    session: SessionState,
+    valores_x: dict[str, Any],
+    indice_base: str | None,
+    avaliando_lat: float | None = None,
+    avaliando_lon: float | None = None,
+) -> dict[str, Any]:
     pacote = session.pacote_visualizacao
     if pacote is None:
         raise HTTPException(status_code=400, detail="Carregue um modelo primeiro")
@@ -578,6 +761,7 @@ def calcular_avaliacao(session: SessionState, valores_x: dict[str, Any], indice_
     valor_area = _resolver_valor_area_avaliacao(valores_x, info.get("coluna_area"))
     if info.get("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.")
+    valores_knn, aval_lat, aval_lon = _montar_valores_knn(entradas, avaliando_lat, avaliando_lon)
 
     resultado = avaliar_imovel(
         modelo_sm=pacote["modelo"]["sm"],
@@ -605,7 +789,7 @@ def calcular_avaliacao(session: SessionState, valores_x: dict[str, Any], indice_
             df_base=df_knn,
             coluna_y=info["nome_y"],
             colunas_x=colunas_x,
-            valores_x=entradas,
+            valores_x=valores_knn,
             alpha_geo=0.35,
         ),
         tipo_y=info.get("tipo_y"),
@@ -613,6 +797,8 @@ def calcular_avaliacao(session: SessionState, valores_x: dict[str, Any], indice_
         valor_area=valor_area,
     )
     resultado.update(resultado_knn)
+    resultado["avaliando_lat"] = aval_lat
+    resultado["avaliando_lon"] = aval_lon
 
     session.avaliacoes_visualizacao.append(resultado)
 
@@ -629,7 +815,12 @@ 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]:
+def detalhes_knn_avaliacao(
+    session: SessionState,
+    valores_x: dict[str, Any],
+    avaliando_lat: float | None = None,
+    avaliando_lon: float | None = None,
+) -> dict[str, Any]:
     pacote = session.pacote_visualizacao
     if pacote is None:
         raise HTTPException(status_code=400, detail="Carregue um modelo primeiro")
@@ -674,6 +865,7 @@ def detalhes_knn_avaliacao(session: SessionState, valores_x: dict[str, Any]) ->
     valor_area = _resolver_valor_area_avaliacao(valores_x, info.get("coluna_area"))
     if info.get("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.")
+    valores_knn, aval_lat, aval_lon = _montar_valores_knn(entradas, avaliando_lat, avaliando_lon)
 
     df_knn = pacote.get("dados", {}).get("df")
     if not isinstance(df_knn, pd.DataFrame):
@@ -684,7 +876,7 @@ def detalhes_knn_avaliacao(session: SessionState, valores_x: dict[str, Any]) ->
             df_base=df_knn,
             coluna_y=info["nome_y"],
             colunas_x=colunas_x,
-            valores_x=entradas,
+            valores_x=valores_knn,
             alpha_geo=0.35,
             retornar_detalhes=True,
         ),
@@ -727,6 +919,9 @@ def detalhes_knn_avaliacao(session: SessionState, valores_x: dict[str, Any]) ->
     avaliando = [{"variavel": str(col), "valor": entradas.get(col)} for col in colunas_x]
     if info.get("coluna_area") and info.get("coluna_area") not in colunas_x:
         avaliando.append({"variavel": f"{info['coluna_area']} (area)", "valor": valor_area})
+    if aval_lat is not None and aval_lon is not None:
+        avaliando.append({"variavel": "Latitude", "valor": aval_lat})
+        avaliando.append({"variavel": "Longitude", "valor": aval_lon})
 
     return sanitize_value(
         {

backend/scripts/build_trabalhos_tecnicos_db.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[2]
+
+
+def main() -> int:
+    repo_root = _repo_root()
+    if str(repo_root / "backend") not in sys.path:
+        sys.path.insert(0, str(repo_root / "backend"))
+
+    from app.services.trabalhos_tecnicos_importer import DEFAULT_LOCAL_DB_FILE, DEFAULT_SOURCE_XLSX_FILE, build_database_from_xlsx
+
+    parser = argparse.ArgumentParser(description="Importa o Excel de trabalhos tecnicos para um banco SQLite.")
+    parser.add_argument(
+        "--xlsx",
+        default=str(Path.home() / "Downloads" / DEFAULT_SOURCE_XLSX_FILE),
+        help="Caminho da planilha xlsx de origem.",
+    )
+    parser.add_argument(
+        "--db",
+        default=str(repo_root / "backend" / "local_data" / DEFAULT_LOCAL_DB_FILE),
+        help="Caminho do banco SQLite de destino.",
+    )
+    args = parser.parse_args()
+
+    resultado = build_database_from_xlsx(args.xlsx, args.db)
+    print(json.dumps(resultado, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

frontend/src/App.jsx

@@ -3,16 +3,16 @@ import { api, getAuthToken, setAuthToken } from './api'
 import AvaliacaoTab from './components/AvaliacaoTab'
 import ElaboracaoTab from './components/ElaboracaoTab'
 import InicioTab from './components/InicioTab'
-import PesquisaTab from './components/PesquisaTab'
-import RepositorioTab from './components/RepositorioTab'
+import ModelosEstatisticosTab from './components/ModelosEstatisticosTab'
+import TrabalhosTecnicosTab from './components/TrabalhosTecnicosTab'
 
 const LOGS_PAGE_SIZE = 30
 
 const TABS = [
-  { key: 'Pesquisa/Visualização', label: 'Pesquisa/Visualização' },
+  { key: 'Modelos Estatísticos', label: 'Modelos Estatísticos' },
   { key: 'Elaboração/Edição', label: 'Elaboração/Edição' },
   { key: 'Avaliação', label: 'Avaliação de Imóveis' },
-  { key: 'Repositório de Modelos', label: 'Repositório de Modelos' },
+  { key: 'Trabalhos Técnicos', label: 'Trabalhos Técnicos' },
 ]
 
 export default function App() {
@@ -21,6 +21,7 @@ export default function App() {
   const [sessionId, setSessionId] = useState('')
   const [bootError, setBootError] = useState('')
   const [avaliacaoQuickLoad, setAvaliacaoQuickLoad] = useState(null)
+  const [modeloRepositorioQuickOpen, setModeloRepositorioQuickOpen] = useState(null)
 
   const [authLoading, setAuthLoading] = useState(true)
   const [authUser, setAuthUser] = useState(null)
@@ -60,6 +61,7 @@ export default function App() {
     setLoginLoading(false)
     setSessionId('')
     setBootError('')
+    setModeloRepositorioQuickOpen(null)
     setLogsStatus(null)
     setLogsOpen(false)
     setLogsEvents([])
@@ -323,6 +325,20 @@ export default function App() {
     setShowStartupIntro(false)
   }
 
+  function onAbrirModeloNoRepositorio(modelo) {
+    const modeloId = String(modelo?.modeloId || modelo?.id || '').trim()
+    if (!modeloId) return
+    setModeloRepositorioQuickOpen({
+      requestKey: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      modeloId,
+      modeloArquivo: String(modelo?.modeloArquivo || modelo?.arquivo || '').trim(),
+      nomeModelo: String(modelo?.nomeModelo || modelo?.nome_modelo || modeloId).trim(),
+    })
+    setActiveTab('Modelos Estatísticos')
+    setLogsOpen(false)
+    setShowStartupIntro(false)
+  }
+
   function onScrollToHeader() {
     if (typeof window === 'undefined') return
     const headerEl = headerRef.current
@@ -493,6 +509,7 @@ export default function App() {
                       <option value="">Todos</option>
                       <option value="auth">Auth</option>
                       <option value="repositorio">Repositório</option>
+                      <option value="trabalhos_tecnicos">Trabalhos Técnicos</option>
                       <option value="elaboracao">Elaboração</option>
                       <option value="visualizacao">Visualização</option>
                     </select>
@@ -582,16 +599,24 @@ export default function App() {
             </div>
           ) : null}
 
-          <div className="tab-pane" hidden={activeTab !== 'Pesquisa/Visualização'}>
-            <PesquisaTab sessionId={sessionId} onUsarModeloEmAvaliacao={onUsarModeloEmAvaliacao} />
+          <div className="tab-pane" hidden={activeTab !== 'Modelos Estatísticos'}>
+            <ModelosEstatisticosTab
+              sessionId={sessionId}
+              authUser={authUser}
+              onUsarModeloEmAvaliacao={onUsarModeloEmAvaliacao}
+              openRepositorioModeloRequest={modeloRepositorioQuickOpen}
+            />
           </div>
 
           <div className="tab-pane" hidden={activeTab !== 'Elaboração/Edição'}>
             <ElaboracaoTab sessionId={sessionId} authUser={authUser} />
           </div>
 
-          <div className="tab-pane" hidden={activeTab !== 'Repositório de Modelos'}>
-            <RepositorioTab authUser={authUser} sessionId={sessionId} />
+          <div className="tab-pane" hidden={activeTab !== 'Trabalhos Técnicos'}>
+            <TrabalhosTecnicosTab
+              sessionId={sessionId}
+              onAbrirModeloNoRepositorio={onAbrirModeloNoRepositorio}
+            />
           </div>
 
           <div className="tab-pane" hidden={activeTab !== 'Avaliação'}>

frontend/src/api.js

@@ -328,14 +328,18 @@ export const api = {
   evaluationContextViz: (sessionId) => postJson('/api/visualizacao/evaluation/context', { session_id: sessionId }),
   updateVisualizacaoMap: (sessionId, variavelMapa) => postJson('/api/visualizacao/map/update', { session_id: sessionId, variavel_mapa: variavelMapa }),
   evaluationFieldsViz: (sessionId) => postJson('/api/visualizacao/evaluation/fields', { session_id: sessionId }),
-  evaluationCalculateViz: (sessionId, valoresX, indiceBase) => postJson('/api/visualizacao/evaluation/calculate', {
+  evaluationCalculateViz: (sessionId, valoresX, indiceBase, avaliando = null) => postJson('/api/visualizacao/evaluation/calculate', {
     session_id: sessionId,
     valores_x: valoresX,
     indice_base: indiceBase,
+    avaliando_lat: avaliando?.lat ?? null,
+    avaliando_lon: avaliando?.lon ?? null,
   }),
-  evaluationKnnDetailsViz: (sessionId, valoresX) => postJson('/api/visualizacao/evaluation/knn-details', {
+  evaluationKnnDetailsViz: (sessionId, valoresX, avaliando = null) => postJson('/api/visualizacao/evaluation/knn-details', {
     session_id: sessionId,
     valores_x: valoresX,
+    avaliando_lat: avaliando?.lat ?? null,
+    avaliando_lon: avaliando?.lon ?? null,
   }),
   evaluationClearViz: (sessionId) => postJson('/api/visualizacao/evaluation/clear', { session_id: sessionId }),
   evaluationDeleteViz: (sessionId, indice, indiceBase) => postJson('/api/visualizacao/evaluation/delete', {
@@ -361,6 +365,8 @@ export const api = {
     return postForm('/api/repositorio/upload', form)
   },
   repositorioDelete: (modelosIds = []) => postJson('/api/repositorio/delete', { modelos_ids: modelosIds }),
+  trabalhosTecnicosListar: () => getJson('/api/trabalhos-tecnicos'),
+  trabalhosTecnicosDetalhe: (trabalhoId) => postJson('/api/trabalhos-tecnicos/detalhe', { trabalho_id: trabalhoId }),
 
   logsStatus: () => getJson('/api/logs/status'),
   logsEvents({ scope = '', usuario = '', limit = 200 } = {}) {

frontend/src/components/AvaliacaoTab.jsx

@@ -459,6 +459,21 @@ function removerObservacaoDoBadgeHtml(html) {
 }
 
 const BASE_COMPARACAO_SEM_BASE = '__none__'
+const EMPTY_LOCATION_INPUTS = {
+  latitude: '',
+  longitude: '',
+  logradouro: '',
+  numero: '',
+  cdlog: '',
+}
+
+function obterCoordenadasResolvidas(localizacao) {
+  const lat = Number(localizacao?.lat)
+  const lon = Number(localizacao?.lon)
+  if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null
+  if (lat < -90 || lat > 90 || lon < -180 || lon > 180) return null
+  return { lat, lon }
+}
 
 export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
   const [loading, setLoading] = useState(false)
@@ -480,6 +495,14 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
   const [equacaoSab, setEquacaoSab] = useState('')
   const valoresAvaliacaoRef = useRef({})
   const [avaliacaoFormVersion, setAvaliacaoFormVersion] = useState(0)
+  const [avaliandoLocalizacaoModo, setAvaliandoLocalizacaoModo] = useState('endereco')
+  const [avaliandoLocalizacaoInputs, setAvaliandoLocalizacaoInputs] = useState(EMPTY_LOCATION_INPUTS)
+  const [avaliandoLocalizacaoResolvida, setAvaliandoLocalizacaoResolvida] = useState(null)
+  const [avaliandoLocalizacaoLoading, setAvaliandoLocalizacaoLoading] = useState(false)
+  const [avaliandoLocalizacaoError, setAvaliandoLocalizacaoError] = useState('')
+  const [avaliandoLocalizacaoStatus, setAvaliandoLocalizacaoStatus] = useState('')
+  const [avaliandoLogradouroOptions, setAvaliandoLogradouroOptions] = useState([])
+  const [avaliandoLogradouroLoading, setAvaliandoLogradouroLoading] = useState(false)
 
   const [avaliacoesCards, setAvaliacoesCards] = useState([])
   const [baseCardId, setBaseCardId] = useState(BASE_COMPARACAO_SEM_BASE)
@@ -672,6 +695,35 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
     }
   }, [sessionId])
 
+  useEffect(() => {
+    let ativo = true
+    if (!sessionId) return () => {
+      ativo = false
+    }
+
+    setAvaliandoLogradouroLoading(true)
+    api.pesquisarModelos({ somente_contexto: true })
+      .then((resp) => {
+        if (!ativo) return
+        const logradouros = Array.isArray(resp?.sugestoes?.logradouros_eixos)
+          ? resp.sugestoes.logradouros_eixos
+          : []
+        setAvaliandoLogradouroOptions(logradouros)
+      })
+      .catch(() => {
+        if (!ativo) return
+        setAvaliandoLogradouroOptions([])
+      })
+      .finally(() => {
+        if (!ativo) return
+        setAvaliandoLogradouroLoading(false)
+      })
+
+    return () => {
+      ativo = false
+    }
+  }, [sessionId])
+
   useEffect(() => {
     if (!avaliacoesCards.length) {
       if (baseCardId !== BASE_COMPARACAO_SEM_BASE) {
@@ -825,10 +877,78 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
     void onUploadModel(file)
   }
 
+  function atualizarCampoAvaliandoLocalizacao(campo, valor) {
+    setAvaliandoLocalizacaoInputs((prev) => ({
+      ...prev,
+      [campo]: String(valor ?? ''),
+    }))
+  }
+
+  async function onResolverAvaliandoLocalizacao() {
+    setAvaliandoLocalizacaoError('')
+    setAvaliandoLocalizacaoStatus('')
+
+    if (avaliandoLocalizacaoModo === 'coords') {
+      const lat = Number(avaliandoLocalizacaoInputs.latitude)
+      const lon = Number(avaliandoLocalizacaoInputs.longitude)
+      if (!Number.isFinite(lat) || !Number.isFinite(lon)) {
+        setAvaliandoLocalizacaoError('Informe latitude e longitude válidas para localizar o avaliando.')
+        return
+      }
+    } else {
+      if (!String(avaliandoLocalizacaoInputs.logradouro || '').trim()) {
+        setAvaliandoLocalizacaoError('Informe o logradouro para localizar o avaliando.')
+        return
+      }
+      const numero = Number(avaliandoLocalizacaoInputs.numero)
+      if (!Number.isFinite(numero) || numero <= 0) {
+        setAvaliandoLocalizacaoError('Informe um número válido para localizar o avaliando.')
+        return
+      }
+    }
+
+    setAvaliandoLocalizacaoLoading(true)
+    try {
+      const response = await api.pesquisarLocalizacaoAvaliando({
+        latitude: avaliandoLocalizacaoModo === 'coords' ? Number(avaliandoLocalizacaoInputs.latitude) : null,
+        longitude: avaliandoLocalizacaoModo === 'coords' ? Number(avaliandoLocalizacaoInputs.longitude) : null,
+        logradouro: avaliandoLocalizacaoModo === 'endereco' ? String(avaliandoLocalizacaoInputs.logradouro || '').trim() : null,
+        numero: avaliandoLocalizacaoModo === 'endereco' ? Number(avaliandoLocalizacaoInputs.numero) : null,
+        cdlog: avaliandoLocalizacaoModo === 'endereco' && String(avaliandoLocalizacaoInputs.cdlog || '').trim()
+          ? Number(avaliandoLocalizacaoInputs.cdlog)
+          : null,
+      })
+      const resolvida = {
+        ...response,
+        lat: Number(response?.lat),
+        lon: Number(response?.lon),
+      }
+      setAvaliandoLocalizacaoResolvida(resolvida)
+      setAvaliandoLocalizacaoStatus(response?.status || 'Localização do avaliando definida.')
+    } catch (err) {
+      setAvaliandoLocalizacaoError(err?.message || 'Falha ao localizar o avaliando.')
+      setAvaliandoLocalizacaoResolvida(null)
+    } finally {
+      setAvaliandoLocalizacaoLoading(false)
+    }
+  }
+
+  function onLimparAvaliandoLocalizacao() {
+    setAvaliandoLocalizacaoInputs(EMPTY_LOCATION_INPUTS)
+    setAvaliandoLocalizacaoResolvida(null)
+    setAvaliandoLocalizacaoError('')
+    setAvaliandoLocalizacaoStatus('')
+  }
+
   async function onIncluirAvaliacao() {
     if (!sessionId || !camposAvaliacao.length) return
     await withBusy(async () => {
-      const resp = await api.evaluationCalculateViz(sessionId, valoresAvaliacaoRef.current, null)
+      const resp = await api.evaluationCalculateViz(
+        sessionId,
+        valoresAvaliacaoRef.current,
+        null,
+        obterCoordenadasResolvidas(avaliandoLocalizacaoResolvida),
+      )
       const lista = Array.isArray(resp?.avaliacoes) ? resp.avaliacoes : []
       const ultima = lista.length ? lista[lista.length - 1] : null
       if (!ultima || typeof ultima !== 'object') {
@@ -925,7 +1045,14 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
     setKnnDetalheTabela(null)
     setKnnDetalheInfo(null)
     try {
-      const resp = await api.evaluationKnnDetailsViz(sessionId, construirPayloadKnnAvaliacao(card.avaliacao))
+      const resp = await api.evaluationKnnDetailsViz(
+        sessionId,
+        construirPayloadKnnAvaliacao(card.avaliacao),
+        obterCoordenadasResolvidas({
+          lat: card?.avaliacao?.avaliando_lat,
+          lon: card?.avaliacao?.avaliando_lon,
+        }),
+      )
       setKnnDetalheMapaHtml(String(resp?.mapa_html || ''))
       setKnnDetalheAvaliando(Array.isArray(resp?.avaliando) ? resp.avaliando : [])
       setKnnDetalheTabela(resp?.vizinhos_tabela || null)
@@ -1031,6 +1158,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
   const indiceBaseSelecionada = mostrarComparacaoBase
     ? (avaliacoesCards.findIndex((item) => item.id === baseCard?.id) + 1)
     : 0
+  const avaliandoLocalizacaoAtiva = Boolean(obterCoordenadasResolvidas(avaliandoLocalizacaoResolvida))
 
   return (
     <div className="tab-content">
@@ -1147,6 +1275,171 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null }) {
             </div>
 
             <div className="avaliacao-groups avaliacao-modelos-groups">
+              <div className="subpanel avaliacao-group">
+                <h4>Geolocalização do avaliando</h4>
+                <div className="pesquisa-field-pair pesquisa-localizacao-group">
+                  <span className="pesquisa-field-pair-title">Localização para estimativa KNN (opcional)</span>
+                  <div className="pesquisa-localizacao-optional-hint">
+                    Esta localização é usada apenas para a componente geográfica da estimativa KNN. Se nada for informado, a avaliação continua normal e o KNN usa somente as características do imóvel.
+                  </div>
+
+                  {avaliandoLocalizacaoModo === 'coords' ? (
+                    <div className="pesquisa-localizacao-grid pesquisa-localizacao-grid-coords">
+                      <label className="pesquisa-field">
+                        Forma de localização
+                        <select
+                          value={avaliandoLocalizacaoModo}
+                          onChange={(event) => setAvaliandoLocalizacaoModo(event.target.value)}
+                          autoComplete="off"
+                        >
+                          <option value="endereco">Endereço</option>
+                          <option value="coords">Coordenadas</option>
+                        </select>
+                      </label>
+                      <label className="pesquisa-field">
+                        Latitude
+                        <input
+                          type="number"
+                          step="any"
+                          value={avaliandoLocalizacaoInputs.latitude}
+                          onChange={(event) => atualizarCampoAvaliandoLocalizacao('latitude', event.target.value)}
+                          placeholder="-30.000000"
+                        />
+                      </label>
+                      <label className="pesquisa-field">
+                        Longitude
+                        <input
+                          type="number"
+                          step="any"
+                          value={avaliandoLocalizacaoInputs.longitude}
+                          onChange={(event) => atualizarCampoAvaliandoLocalizacao('longitude', event.target.value)}
+                          placeholder="-51.000000"
+                        />
+                      </label>
+                      <div className="pesquisa-localizacao-actions-inline">
+                        <button
+                          type="button"
+                          className="pesquisa-localizacao-action pesquisa-localizacao-action-ok"
+                          onClick={() => void onResolverAvaliandoLocalizacao()}
+                          disabled={avaliandoLocalizacaoLoading}
+                        >
+                          {avaliandoLocalizacaoLoading ? 'Buscando...' : 'Buscar'}
+                        </button>
+                        <button
+                          type="button"
+                          className="pesquisa-localizacao-action pesquisa-localizacao-action-reset"
+                          onClick={onLimparAvaliandoLocalizacao}
+                          disabled={avaliandoLocalizacaoLoading}
+                        >
+                          Limpar
+                        </button>
+                      </div>
+                    </div>
+                  ) : (
+                    <div className="pesquisa-localizacao-grid pesquisa-localizacao-grid-endereco">
+                      <label className="pesquisa-field">
+                        Forma de localização
+                        <select
+                          value={avaliandoLocalizacaoModo}
+                          onChange={(event) => setAvaliandoLocalizacaoModo(event.target.value)}
+                          autoComplete="off"
+                        >
+                          <option value="endereco">Endereço</option>
+                          <option value="coords">Coordenadas</option>
+                        </select>
+                      </label>
+                      <label className="pesquisa-field">
+                        CDLOG
+                        <input
+                          type="number"
+                          value={avaliandoLocalizacaoInputs.cdlog}
+                          onChange={(event) => atualizarCampoAvaliandoLocalizacao('cdlog', event.target.value)}
+                          placeholder="Opcional"
+                        />
+                      </label>
+                      <label className="pesquisa-field pesquisa-localizacao-logradouro-field">
+                        Logradouro
+                        <SinglePillAutocomplete
+                          value={avaliandoLocalizacaoInputs.logradouro}
+                          onChange={(nextValue) => atualizarCampoAvaliandoLocalizacao('logradouro', nextValue)}
+                          options={avaliandoLogradouroOptions}
+                          placeholder={avaliandoLogradouroLoading ? 'Carregando logradouros...' : 'Digite ou selecione um logradouro dos eixos'}
+                          panelTitle="Logradouros dos eixos"
+                          emptyMessage="Nenhum logradouro encontrado nos eixos."
+                          loading={avaliandoLogradouroLoading}
+                          inputName="logradouroEixosAvaliacao"
+                          inputAutoComplete="new-password"
+                        />
+                      </label>
+                      <label className="pesquisa-field">
+                        Número
+                        <input
+                          type="number"
+                          value={avaliandoLocalizacaoInputs.numero}
+                          onChange={(event) => atualizarCampoAvaliandoLocalizacao('numero', event.target.value)}
+                          placeholder="0"
+                        />
+                      </label>
+                      <div className="pesquisa-localizacao-actions-inline">
+                        <button
+                          type="button"
+                          className="pesquisa-localizacao-action pesquisa-localizacao-action-ok"
+                          onClick={() => void onResolverAvaliandoLocalizacao()}
+                          disabled={avaliandoLocalizacaoLoading}
+                        >
+                          {avaliandoLocalizacaoLoading ? 'Buscando...' : 'Buscar'}
+                        </button>
+                        <button
+                          type="button"
+                          className="pesquisa-localizacao-action pesquisa-localizacao-action-reset"
+                          onClick={onLimparAvaliandoLocalizacao}
+                          disabled={avaliandoLocalizacaoLoading}
+                        >
+                          Limpar
+                        </button>
+                      </div>
+                    </div>
+                  )}
+
+                  {avaliandoLocalizacaoStatus && !avaliandoLocalizacaoAtiva ? <div className="status-line">{avaliandoLocalizacaoStatus}</div> : null}
+                  {avaliandoLocalizacaoError ? <div className="error-line inline-error">{avaliandoLocalizacaoError}</div> : null}
+
+                  {avaliandoLocalizacaoAtiva ? (
+                    <div className="pesquisa-localizacao-summary">
+                      {avaliandoLocalizacaoResolvida?.logradouro ? (
+                        <div className="pesquisa-localizacao-summary-row">
+                          <span className="pesquisa-localizacao-summary-label">Endereço</span>
+                          <span className="pesquisa-localizacao-summary-value">
+                            {avaliandoLocalizacaoResolvida.logradouro}
+                            {avaliandoLocalizacaoResolvida?.numero_usado ? `, ${avaliandoLocalizacaoResolvida.numero_usado}` : ''}
+                          </span>
+                        </div>
+                      ) : null}
+                      {avaliandoLocalizacaoResolvida?.cdlog ? (
+                        <div className="pesquisa-localizacao-summary-row">
+                          <span className="pesquisa-localizacao-summary-label">CDLOG</span>
+                          <span className="pesquisa-localizacao-summary-value">{avaliandoLocalizacaoResolvida.cdlog}</span>
+                        </div>
+                      ) : null}
+                      <div className="pesquisa-localizacao-summary-row">
+                        <span className="pesquisa-localizacao-summary-label">Latitude</span>
+                        <span className="pesquisa-localizacao-summary-value">{Number(avaliandoLocalizacaoResolvida.lat).toFixed(6)}</span>
+                      </div>
+                      <div className="pesquisa-localizacao-summary-row">
+                        <span className="pesquisa-localizacao-summary-label">Longitude</span>
+                        <span className="pesquisa-localizacao-summary-value">{Number(avaliandoLocalizacaoResolvida.lon).toFixed(6)}</span>
+                      </div>
+                      <div className="pesquisa-localizacao-summary-row">
+                        <span className="pesquisa-localizacao-summary-label">Origem</span>
+                        <span className="pesquisa-localizacao-summary-value">
+                          {avaliandoLocalizacaoResolvida?.origem === 'eixos' ? 'Eixos de logradouro' : 'Coordenadas informadas'}
+                        </span>
+                      </div>
+                    </div>
+                  ) : null}
+                </div>
+              </div>
+
               <div className="subpanel avaliacao-group">
                 <h4>Parâmetros</h4>
                 <div className="avaliacao-grid" key={`avaliacao-grid-avaliacao-${avaliacaoFormVersion}`}>

frontend/src/components/InicioTab.jsx

@@ -6,10 +6,10 @@ export default function InicioTab() {
       <section className="inicio-card">
         <h3>Resumo rápido</h3>
         <ul className="inicio-lista">
-          <li><strong>Pesquisa/Visualização:</strong> encontra modelos e abre visualização completa a partir da pesquisa.</li>
+          <li><strong>Modelos Estatísticos:</strong> reúne as subabas de pesquisa e de repositório de modelos.</li>
           <li><strong>Elaboração/Edição:</strong> cria, ajusta e exporta modelos estatísticos.</li>
           <li><strong>Avaliação:</strong> compara avaliações de modelos diferentes em cards no mesmo painel.</li>
-          <li><strong>Repositório de Modelos:</strong> lista, adiciona e remove modelos do acervo central.</li>
+          <li><strong>Trabalhos Técnicos:</strong> lista trabalhos técnicos georreferenciados, seus imóveis e os modelos associados.</li>
         </ul>
         <p className="inicio-creditos">
           Aplicativo criado por Guilherme Silberfarb Costa e David Schuch Bertoglio.

frontend/src/components/ListPagination.jsx

@@ -0,0 +1,39 @@
+import React from 'react'
+
+export default function ListPagination({
+  totalItems = 0,
+  currentPage = 1,
+  pageSize = 50,
+  onPageChange,
+  loading = false,
+}) {
+  const total = Math.max(0, Number(totalItems) || 0)
+  const tamanhoPagina = Math.max(1, Number(pageSize) || 50)
+  const totalPages = Math.max(1, Math.ceil(total / tamanhoPagina))
+  const paginaAtual = Math.min(Math.max(1, Number(currentPage) || 1), totalPages)
+  const startIndex = total ? ((paginaAtual - 1) * tamanhoPagina) + 1 : 0
+  const endIndex = total ? Math.min(total, paginaAtual * tamanhoPagina) : 0
+
+  return (
+    <div className="logs-pagination">
+      <span>{total ? `Exibindo ${startIndex}-${endIndex} de ${total}` : 'Exibindo 0 de 0'}</span>
+      <div className="logs-pagination-actions">
+        <button
+          type="button"
+          onClick={() => onPageChange?.(Math.max(1, paginaAtual - 1))}
+          disabled={loading || paginaAtual <= 1}
+        >
+          Anterior
+        </button>
+        <span>Página {paginaAtual} de {totalPages}</span>
+        <button
+          type="button"
+          onClick={() => onPageChange?.(Math.min(totalPages, paginaAtual + 1))}
+          disabled={loading || paginaAtual >= totalPages}
+        >
+          Próxima
+        </button>
+      </div>
+    </div>
+  )
+}

frontend/src/components/ModeloTrabalhosTecnicosPanel.jsx

@@ -0,0 +1,59 @@
+import React from 'react'
+import DataTable from './DataTable'
+
+function formatarProcessosAdministrativos(item) {
+  const processosArray = Array.isArray(item?.processos_administrativos)
+    ? item.processos_administrativos.map((valor) => String(valor || '').trim()).filter(Boolean)
+    : []
+  if (processosArray.length) {
+    return processosArray.join(' | ')
+  }
+
+  const processoResumo = String(
+    item?.processos_administrativos_resumo || item?.processo_administrativo || ''
+  ).trim()
+  if (processoResumo) {
+    return processoResumo
+  }
+
+  return 'Nenhum registrado'
+}
+
+function montarTabelaTrabalhos(trabalhos) {
+  const lista = Array.isArray(trabalhos) ? trabalhos : []
+  const rows = lista.map((item) => {
+    const imoveis = Array.isArray(item?.imoveis) ? item.imoveis : []
+    const enderecosTexto = imoveis
+      .map((imovel) => String(imovel?.endereco || '').trim())
+      .filter(Boolean)
+      .join(' | ') || '-'
+    return {
+      'Trabalho Técnico': String(item?.trabalho_nome || item?.trabalho_id || '-').trim() || '-',
+      Tipo: String(item?.tipo_label || '-').trim() || '-',
+      'Total de Imóveis': item?.total_imoveis ?? 0,
+      Endereços: enderecosTexto,
+      'Processos SEI': formatarProcessosAdministrativos(item),
+    }
+  })
+
+  return {
+    columns: ['Trabalho Técnico', 'Tipo', 'Total de Imóveis', 'Endereços', 'Processos SEI'],
+    rows,
+  }
+}
+
+export default function ModeloTrabalhosTecnicosPanel({ trabalhos }) {
+  const lista = Array.isArray(trabalhos) ? trabalhos : []
+  if (!lista.length) {
+    return <div className="empty-box">Nenhum trabalho técnico vinculado foi encontrado na base atual. Essa base ainda pode não estar completa.</div>
+  }
+
+  return (
+    <>
+      <div className="section1-empty-hint modelo-trabalhos-tecnicos-disclaimer">
+        {lista.length} trabalho(s) técnico(s) utilizando este modelo foram encontrados na base atual. Essa base ainda pode não estar completa.
+      </div>
+      <DataTable table={montarTabelaTrabalhos(lista)} maxHeight={620} />
+    </>
+  )
+}

frontend/src/components/ModelosEstatisticosTab.jsx

@@ -0,0 +1,52 @@
+import React, { useEffect, useState } from 'react'
+import PesquisaTab from './PesquisaTab'
+import RepositorioTab from './RepositorioTab'
+
+const SUBTABS = [
+  { key: 'Pesquisar Modelos', label: 'Pesquisar Modelos' },
+  { key: 'Repositório de Modelos', label: 'Repositório de Modelos' },
+]
+
+export default function ModelosEstatisticosTab({
+  sessionId,
+  authUser,
+  onUsarModeloEmAvaliacao,
+  openRepositorioModeloRequest = null,
+}) {
+  const [activeSubtab, setActiveSubtab] = useState('Pesquisar Modelos')
+
+  useEffect(() => {
+    const modeloId = String(openRepositorioModeloRequest?.modeloId || '').trim()
+    if (!modeloId) return
+    setActiveSubtab('Repositório de Modelos')
+  }, [openRepositorioModeloRequest])
+
+  return (
+    <div className="tab-content">
+      <div className="inner-tabs" role="tablist" aria-label="Abas de modelos estatísticos">
+        {SUBTABS.map((tab) => (
+          <button
+            key={tab.key}
+            type="button"
+            className={activeSubtab === tab.key ? 'inner-tab-pill active' : 'inner-tab-pill'}
+            onClick={() => setActiveSubtab(tab.key)}
+          >
+            {tab.label}
+          </button>
+        ))}
+      </div>
+
+      <div className="tab-pane" hidden={activeSubtab !== 'Pesquisar Modelos'}>
+        <PesquisaTab sessionId={sessionId} onUsarModeloEmAvaliacao={onUsarModeloEmAvaliacao} />
+      </div>
+
+      <div className="tab-pane" hidden={activeSubtab !== 'Repositório de Modelos'}>
+        <RepositorioTab
+          authUser={authUser}
+          sessionId={sessionId}
+          openModeloRequest={openRepositorioModeloRequest}
+        />
+      </div>
+    </div>
+  )
+}

frontend/src/components/PesquisaTab.jsx

@@ -5,6 +5,7 @@ import DataTable from './DataTable'
 import EquationFormatsPanel from './EquationFormatsPanel'
 import LoadingOverlay from './LoadingOverlay'
 import MapFrame from './MapFrame'
+import ModeloTrabalhosTecnicosPanel from './ModeloTrabalhosTecnicosPanel'
 import PlotFigure from './PlotFigure'
 import PesquisaAdminConfigPanel from './PesquisaAdminConfigPanel'
 import SectionBlock from './SectionBlock'
@@ -42,6 +43,7 @@ const RESULT_INITIAL = {
 
 const PESQUISA_INNER_TABS = [
   { key: 'mapa', label: 'Mapa' },
+  { key: 'trabalhos_tecnicos', label: 'Trabalhos Técnicos' },
   { key: 'dados_mercado', label: 'Dados de Mercado' },
   { key: 'metricas', label: 'Métricas' },
   { key: 'transformacoes', label: 'Transformações' },
@@ -826,9 +828,7 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
   const [mapaError, setMapaError] = useState('')
   const [mapaStatus, setMapaStatus] = useState('')
   const [mapaHtmls, setMapaHtmls] = useState({ pontos: '', cobertura: '' })
-  const [mapaLegendas, setMapaLegendas] = useState([])
   const [mapaModoExibicao, setMapaModoExibicao] = useState('pontos')
-  const [mapaIdsVisiveis, setMapaIdsVisiveis] = useState([])
 
   const [modeloAbertoMeta, setModeloAbertoMeta] = useState(null)
   const [modeloAbertoLoading, setModeloAbertoLoading] = useState(false)
@@ -845,6 +845,7 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
   const [modeloAbertoMapaHtml, setModeloAbertoMapaHtml] = useState('')
   const [modeloAbertoMapaChoices, setModeloAbertoMapaChoices] = useState(['Visualização Padrão'])
   const [modeloAbertoMapaVar, setModeloAbertoMapaVar] = useState('Visualização Padrão')
+  const [modeloAbertoTrabalhosTecnicos, setModeloAbertoTrabalhosTecnicos] = useState([])
   const [modeloAbertoPlotObsCalc, setModeloAbertoPlotObsCalc] = useState(null)
   const [modeloAbertoPlotResiduos, setModeloAbertoPlotResiduos] = useState(null)
   const [modeloAbertoPlotHistograma, setModeloAbertoPlotHistograma] = useState(null)
@@ -893,20 +894,17 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
   function resetMapaPesquisa() {
     setMapaHtmls({ pontos: '', cobertura: '' })
     setMapaStatus('')
-    setMapaLegendas([])
     setMapaError('')
     setMapaModoExibicao('pontos')
-    setMapaIdsVisiveis([])
   }
 
-  async function carregarMapaPesquisa(ids, { atualizarLegendas = false } = {}) {
+  async function carregarMapaPesquisa(ids) {
     const idsValidos = (ids || []).map((item) => String(item || '').trim()).filter(Boolean)
 
     if (!idsValidos.length) {
       setMapaHtmls({ pontos: '', cobertura: '' })
       setMapaStatus('Nenhum modelo marcado para exibição no mapa.')
       setMapaError('')
-      setMapaIdsVisiveis([])
       return
     }
 
@@ -919,10 +917,6 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
         cobertura: response.mapa_html_cobertura || '',
       })
       setMapaStatus(response.status || '')
-      setMapaIdsVisiveis(idsValidos)
-      if (atualizarLegendas) {
-        setMapaLegendas(response.modelos_plotados || [])
-      }
     } catch (err) {
       setMapaError(err.message)
     } finally {
@@ -1067,6 +1061,7 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
     setModeloAbertoMapaHtml(resp?.mapa_html || '')
     setModeloAbertoMapaChoices(resp?.mapa_choices || ['Visualização Padrão'])
     setModeloAbertoMapaVar('Visualização Padrão')
+    setModeloAbertoTrabalhosTecnicos(Array.isArray(resp?.trabalhos_tecnicos) ? resp.trabalhos_tecnicos : [])
     setModeloAbertoPlotObsCalc(resp?.grafico_obs_calc || null)
     setModeloAbertoPlotResiduos(resp?.grafico_residuos || null)
     setModeloAbertoPlotHistograma(resp?.grafico_histograma || null)
@@ -1140,21 +1135,7 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
     }
 
     setMapaModoExibicao('pontos')
-    await carregarMapaPesquisa(selectedIds, { atualizarLegendas: true })
-  }
-
-  async function onToggleLegendaMapa(modeloId) {
-    const modeloIdNorm = String(modeloId || '').trim()
-    if (!modeloIdNorm || mapaLoading) return
-
-    const ativosAtuais = mapaIdsVisiveis.length
-      ? mapaIdsVisiveis
-      : mapaLegendas.map((item) => item.id)
-    const nextIds = ativosAtuais.includes(modeloIdNorm)
-      ? ativosAtuais.filter((id) => id !== modeloIdNorm)
-      : [...ativosAtuais, modeloIdNorm]
-
-    await carregarMapaPesquisa(nextIds, { atualizarLegendas: false })
+    await carregarMapaPesquisa(selectedIds)
   }
 
   async function onAdminConfigSalva() {
@@ -1275,6 +1256,10 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
               </>
             ) : null}
 
+            {modeloAbertoActiveTab === 'trabalhos_tecnicos' ? (
+              <ModeloTrabalhosTecnicosPanel trabalhos={modeloAbertoTrabalhosTecnicos} />
+            ) : null}
+
             {modeloAbertoActiveTab === 'dados_mercado' ? <DataTable table={modeloAbertoDados} maxHeight={620} /> : null}
             {modeloAbertoActiveTab === 'metricas' ? <DataTable table={modeloAbertoEstatisticas} maxHeight={620} /> : null}
 
@@ -1780,29 +1765,6 @@ export default function PesquisaTab({ sessionId, onUsarModeloEmAvaliacao = null
           </div>
         ) : null}
 
-        {mapaLegendas.length ? (
-          <div className="pesquisa-legenda-grid">
-            {mapaLegendas.map((item) => (
-              <label
-                key={item.id}
-                className={`pesquisa-legenda-item${mapaIdsVisiveis.includes(item.id) ? '' : ' is-disabled'}`}
-              >
-                <input
-                  type="checkbox"
-                  checked={mapaIdsVisiveis.includes(item.id)}
-                  onChange={() => void onToggleLegendaMapa(item.id)}
-                  disabled={mapaLoading}
-                />
-                <span className="pesquisa-legenda-color" style={{ backgroundColor: item.cor }} />
-                <span>
-                  {item.nome} ({item.total_pontos})
-                  {String(item?.distancia_label || '').trim() ? ` • ${item.distancia_label}` : ''}
-                </span>
-              </label>
-            ))}
-          </div>
-        ) : null}
-
         {mapaHtmlAtual ? <MapFrame html={mapaHtmlAtual} /> : <div className="empty-box">Nenhum mapa gerado ainda.</div>}
       </SectionBlock>
 

frontend/src/components/RepositorioTab.jsx

@@ -1,14 +1,19 @@
-import React, { useEffect, useState } from 'react'
+import React, { useEffect, useRef, useState } from 'react'
 import { api, downloadBlob } from '../api'
 import DataTable from './DataTable'
 import EquationFormatsPanel from './EquationFormatsPanel'
+import ListPagination from './ListPagination'
 import LoadingOverlay from './LoadingOverlay'
 import MapFrame from './MapFrame'
+import ModeloTrabalhosTecnicosPanel from './ModeloTrabalhosTecnicosPanel'
 import PlotFigure from './PlotFigure'
 import { getFaixaDataRecencyInfo } from '../modelRecency'
 
+const PAGE_SIZE = 50
+
 const REPO_INNER_TABS = [
   { key: 'mapa', label: 'Mapa' },
+  { key: 'trabalhos_tecnicos', label: 'Trabalhos Técnicos' },
   { key: 'dados_mercado', label: 'Dados de Mercado' },
   { key: 'metricas', label: 'Métricas' },
   { key: 'transformacoes', label: 'Transformações' },
@@ -30,12 +35,13 @@ function formatarFonte(fonte) {
   return 'Pasta local'
 }
 
-export default function RepositorioTab({ authUser, sessionId }) {
+export default function RepositorioTab({ authUser, sessionId, openModeloRequest = null }) {
   const [modelos, setModelos] = useState([])
   const [fonte, setFonte] = useState(null)
   const [loading, setLoading] = useState(false)
   const [uploading, setUploading] = useState(false)
   const [deleting, setDeleting] = useState(false)
+  const [listaPage, setListaPage] = useState(1)
   const [error, setError] = useState('')
   const [status, setStatus] = useState('')
   const [arquivoUpload, setArquivoUpload] = useState(null)
@@ -63,11 +69,13 @@ export default function RepositorioTab({ authUser, sessionId }) {
   const [modeloAbertoMapaHtml, setModeloAbertoMapaHtml] = useState('')
   const [modeloAbertoMapaChoices, setModeloAbertoMapaChoices] = useState(['Visualização Padrão'])
   const [modeloAbertoMapaVar, setModeloAbertoMapaVar] = useState('Visualização Padrão')
+  const [modeloAbertoTrabalhosTecnicos, setModeloAbertoTrabalhosTecnicos] = useState([])
   const [modeloAbertoPlotObsCalc, setModeloAbertoPlotObsCalc] = useState(null)
   const [modeloAbertoPlotResiduos, setModeloAbertoPlotResiduos] = useState(null)
   const [modeloAbertoPlotHistograma, setModeloAbertoPlotHistograma] = useState(null)
   const [modeloAbertoPlotCook, setModeloAbertoPlotCook] = useState(null)
   const [modeloAbertoPlotCorr, setModeloAbertoPlotCorr] = useState(null)
+  const lastOpenRequestKeyRef = useRef('')
 
   const isAdmin = String(authUser?.perfil || '').toLowerCase() === 'admin'
   const totalModelos = modelos.length
@@ -81,6 +89,31 @@ export default function RepositorioTab({ authUser, sessionId }) {
     void carregarModelos()
   }, [])
 
+  useEffect(() => {
+    const totalPages = Math.max(1, Math.ceil(totalModelos / PAGE_SIZE))
+    setListaPage((prev) => Math.min(Math.max(1, prev), totalPages))
+  }, [totalModelos])
+
+  useEffect(() => {
+    const requestKey = String(openModeloRequest?.requestKey || '').trim()
+    const modeloId = String(openModeloRequest?.modeloId || '').trim()
+    if (!sessionId || !requestKey || !modeloId) return
+    if (lastOpenRequestKeyRef.current === requestKey) return
+    lastOpenRequestKeyRef.current = requestKey
+    setModeloAbertoMeta({
+      id: modeloId,
+      nome: openModeloRequest?.nomeModelo || modeloId,
+      observacao: '',
+    })
+    setModeloAbertoError('')
+    setModeloAbertoActiveTab('mapa')
+    void onAbrirModelo({
+      id: modeloId,
+      nome_modelo: openModeloRequest?.nomeModelo || modeloId,
+      arquivo: openModeloRequest?.modeloArquivo || '',
+    })
+  }, [openModeloRequest, sessionId])
+
   async function carregarModelos() {
     setLoading(true)
     setError('')
@@ -189,6 +222,7 @@ export default function RepositorioTab({ authUser, sessionId }) {
     setModeloAbertoMapaHtml(resp?.mapa_html || '')
     setModeloAbertoMapaChoices(resp?.mapa_choices || ['Visualização Padrão'])
     setModeloAbertoMapaVar('Visualização Padrão')
+    setModeloAbertoTrabalhosTecnicos(Array.isArray(resp?.trabalhos_tecnicos) ? resp.trabalhos_tecnicos : [])
     setModeloAbertoPlotObsCalc(resp?.grafico_obs_calc || null)
     setModeloAbertoPlotResiduos(resp?.grafico_residuos || null)
     setModeloAbertoPlotHistograma(resp?.grafico_histograma || null)
@@ -293,6 +327,10 @@ export default function RepositorioTab({ authUser, sessionId }) {
               </>
             ) : null}
 
+            {modeloAbertoActiveTab === 'trabalhos_tecnicos' ? (
+              <ModeloTrabalhosTecnicosPanel trabalhos={modeloAbertoTrabalhosTecnicos} />
+            ) : null}
+
             {modeloAbertoActiveTab === 'dados_mercado' ? <DataTable table={modeloAbertoDados} maxHeight={620} /> : null}
             {modeloAbertoActiveTab === 'metricas' ? <DataTable table={modeloAbertoEstatisticas} maxHeight={620} /> : null}
 
@@ -343,6 +381,11 @@ export default function RepositorioTab({ authUser, sessionId }) {
     )
   }
 
+  const modelosTotalPages = Math.max(1, Math.ceil(totalModelos / PAGE_SIZE))
+  const modelosCurrentPage = Math.min(Math.max(1, listaPage), modelosTotalPages)
+  const modelosStart = (modelosCurrentPage - 1) * PAGE_SIZE
+  const modelosPagina = modelos.slice(modelosStart, modelosStart + PAGE_SIZE)
+
   return (
     <div className="tab-content">
       <div className="repositorio-standalone-panel">
@@ -401,7 +444,7 @@ export default function RepositorioTab({ authUser, sessionId }) {
               </tr>
             </thead>
             <tbody>
-              {modelos.map((item) => {
+              {modelosPagina.map((item) => {
                 const key = String(item.id)
                 const emConfirmacao = confirmDeleteId === key
                 const periodoRecency = getFaixaDataRecencyInfo(item.periodo_dados)
@@ -481,6 +524,13 @@ export default function RepositorioTab({ authUser, sessionId }) {
             </tbody>
           </table>
         </div>
+        <ListPagination
+          totalItems={totalModelos}
+          currentPage={modelosCurrentPage}
+          pageSize={PAGE_SIZE}
+          onPageChange={setListaPage}
+          loading={loading || uploading || deleting}
+        />
       </div>
 
       {confirmarSubstituicao.open ? (

frontend/src/components/TrabalhosTecnicosTab.jsx

@@ -0,0 +1,402 @@
+import React, { useEffect, useState } from 'react'
+import { api } from '../api'
+import ListPagination from './ListPagination'
+import LoadingOverlay from './LoadingOverlay'
+
+const PAGE_SIZE = 50
+
+function normalizeSearchText(value) {
+  return String(value || '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .trim()
+}
+
+function normalizeDigitsOnly(value) {
+  return String(value || '').replace(/\D+/g, '')
+}
+
+function listarProcessosAdministrativos(item) {
+  const processosArray = Array.isArray(item?.processos_administrativos)
+    ? item.processos_administrativos.map((valor) => String(valor || '').trim()).filter(Boolean)
+    : []
+  if (processosArray.length) return processosArray
+
+  const processoResumo = String(
+    item?.processos_administrativos_resumo || item?.processo_administrativo || ''
+  ).trim()
+  if (processoResumo) return [processoResumo]
+
+  return ['Nenhum registrado']
+}
+
+export default function TrabalhosTecnicosTab({ sessionId, onAbrirModeloNoRepositorio = null }) {
+  const [trabalhos, setTrabalhos] = useState([])
+  const [loading, setLoading] = useState(false)
+  const [listaPage, setListaPage] = useState(1)
+  const [error, setError] = useState('')
+  const [filtroTexto, setFiltroTexto] = useState('')
+  const [filtroTipo, setFiltroTipo] = useState('')
+  const [filtroAno, setFiltroAno] = useState('')
+  const [trabalhoAberto, setTrabalhoAberto] = useState(null)
+  const [trabalhoLoading, setTrabalhoLoading] = useState(false)
+  const [trabalhoError, setTrabalhoError] = useState('')
+
+  useEffect(() => {
+    void carregarTrabalhos()
+  }, [])
+
+  useEffect(() => {
+    setListaPage(1)
+  }, [filtroTexto, filtroTipo, filtroAno])
+
+  async function carregarTrabalhos() {
+    setLoading(true)
+    setError('')
+    try {
+      const resp = await api.trabalhosTecnicosListar()
+      setTrabalhos(Array.isArray(resp?.trabalhos) ? resp.trabalhos : [])
+    } catch (err) {
+      setError(err.message || 'Falha ao carregar trabalhos técnicos.')
+      setTrabalhos([])
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function onAbrirTrabalho(item) {
+    const trabalhoId = String(item?.id || '').trim()
+    if (!trabalhoId) return
+    setTrabalhoLoading(true)
+    setTrabalhoError('')
+    try {
+      const resp = await api.trabalhosTecnicosDetalhe(trabalhoId)
+      setTrabalhoAberto(resp?.trabalho || null)
+    } catch (err) {
+      setTrabalhoError(err.message || 'Falha ao abrir trabalho técnico.')
+    } finally {
+      setTrabalhoLoading(false)
+    }
+  }
+
+  function onVoltarLista() {
+    setTrabalhoAberto(null)
+    setTrabalhoError('')
+  }
+
+  function onAbrirModeloAssociado(modelo) {
+    if (!modelo?.disponivel_mesa || typeof onAbrirModeloNoRepositorio !== 'function') return
+    onAbrirModeloNoRepositorio({
+      modeloId: modelo?.mesa_modelo_id,
+      nomeModelo: modelo?.mesa_modelo_nome || modelo?.nome,
+      modeloArquivo: modelo?.mesa_modelo_arquivo || '',
+    })
+  }
+
+  const tiposDisponiveis = Array.from(
+    new Set(trabalhos.map((item) => String(item?.tipo_codigo || '').trim()).filter(Boolean))
+  ).sort((a, b) => a.localeCompare(b, 'pt-BR'))
+
+  const anosDisponiveis = Array.from(
+    new Set(trabalhos.map((item) => String(item?.ano || '').trim()).filter(Boolean))
+  ).sort((a, b) => Number(b) - Number(a))
+
+  const textoFiltro = normalizeSearchText(filtroTexto)
+  const digitosFiltro = normalizeDigitsOnly(filtroTexto)
+  const trabalhosFiltrados = trabalhos.filter((item) => {
+    if (filtroTipo && String(item?.tipo_codigo || '') !== filtroTipo) return false
+    if (filtroAno && String(item?.ano || '') !== filtroAno) return false
+    if (!textoFiltro) return true
+    const processosAdministrativos = listarProcessosAdministrativos(item)
+    const alvoTexto = [
+      item?.nome,
+      item?.nome_original,
+      item?.tipo_label,
+      item?.endereco_resumo,
+      item?.modelo_resumo,
+      item?.modelo_mesa_principal,
+      ...processosAdministrativos,
+      ...(Array.isArray(item?.modelos) ? item.modelos.map((modelo) => modelo?.nome) : []),
+    ]
+      .map((value) => normalizeSearchText(value))
+      .join(' ')
+    if (alvoTexto.includes(textoFiltro)) return true
+
+    if (!digitosFiltro) return false
+    const processosDigitos = processosAdministrativos
+      .map((value) => normalizeDigitsOnly(value))
+      .filter(Boolean)
+      .join(' ')
+    return processosDigitos.includes(digitosFiltro)
+  })
+  const trabalhosTotalPages = Math.max(1, Math.ceil(trabalhosFiltrados.length / PAGE_SIZE))
+  const trabalhosCurrentPage = Math.min(Math.max(1, listaPage), trabalhosTotalPages)
+  const trabalhosStart = (trabalhosCurrentPage - 1) * PAGE_SIZE
+  const trabalhosPagina = trabalhosFiltrados.slice(trabalhosStart, trabalhosStart + PAGE_SIZE)
+
+  if (trabalhoAberto) {
+    const modelos = Array.isArray(trabalhoAberto?.modelos) ? trabalhoAberto.modelos : []
+    const modelosMesa = modelos.filter((item) => item?.disponivel_mesa)
+    const imoveis = Array.isArray(trabalhoAberto?.imoveis) ? trabalhoAberto.imoveis : []
+    return (
+      <div className="tab-content">
+        <div className="pesquisa-opened-model-view">
+          <div className="pesquisa-opened-model-head">
+            <div className="pesquisa-opened-model-title-wrap">
+              <h3>{trabalhoAberto?.nome || 'Trabalho técnico'}</h3>
+              <p>{trabalhoAberto?.tipo_label || 'Tipo não identificado'}</p>
+            </div>
+            <button
+              type="button"
+              className="model-source-back-btn model-source-back-btn-danger"
+              onClick={onVoltarLista}
+              disabled={trabalhoLoading}
+            >
+              Voltar à lista
+            </button>
+          </div>
+
+          <div className="trabalho-tecnico-summary-grid">
+            <section className="trabalho-tecnico-card trabalho-tecnico-card-primary">
+              <h4>Dados Gerais</h4>
+              <div className="trabalho-tecnico-kpis">
+                <div className="trabalho-tecnico-kpi">
+                  <span className="trabalho-tecnico-kpi-label">Tipo</span>
+                  <strong>{trabalhoAberto?.tipo_label || '-'}</strong>
+                </div>
+                <div className="trabalho-tecnico-kpi">
+                  <span className="trabalho-tecnico-kpi-label">Ano</span>
+                  <strong>{trabalhoAberto?.ano || '-'}</strong>
+                </div>
+                <div className="trabalho-tecnico-kpi">
+                  <span className="trabalho-tecnico-kpi-label">Imóveis</span>
+                  <strong>{trabalhoAberto?.total_imoveis ?? 0}</strong>
+                </div>
+                <div className="trabalho-tecnico-kpi">
+                  <span className="trabalho-tecnico-kpi-label">Modelos</span>
+                  <strong>{trabalhoAberto?.total_modelos ?? 0}</strong>
+                </div>
+                <div className="trabalho-tecnico-kpi">
+                  <span className="trabalho-tecnico-kpi-label">Registros</span>
+                  <strong>{trabalhoAberto?.total_registros_planilha ?? 0}</strong>
+                </div>
+              </div>
+              <div className="trabalho-tecnico-note">
+                {trabalhoAberto?.endereco_resumo || 'Endereço não informado'}
+              </div>
+            </section>
+
+            <section className="trabalho-tecnico-card">
+              <h4>Imóveis Vinculados</h4>
+              {imoveis.length ? (
+                <div className="trabalho-imoveis-stack">
+                  {imoveis.map((item, index) => (
+                    <div key={`${trabalhoAberto?.id || 'trabalho'}-imovel-${index + 1}`} className="trabalho-imovel-card">
+                      <strong>{item?.label || 'Imóvel sem identificação'}</strong>
+                      {Array.isArray(item?.modelos) && item.modelos.length ? (
+                        <span>{item.modelos.join(', ')}</span>
+                      ) : (
+                        <span>Sem modelo informado</span>
+                      )}
+                    </div>
+                  ))}
+                </div>
+              ) : (
+                <div className="section1-empty-hint">Nenhum imóvel vinculado.</div>
+              )}
+            </section>
+          </div>
+
+          <section className="trabalho-tecnico-card">
+            <h4>Modelos associados</h4>
+            {modelos.length ? (
+              <div className="trabalho-model-links">
+                {modelos.map((item) => (
+                  <button
+                    key={`${trabalhoAberto?.id || 'trabalho'}-modelo-${item?.nome || ''}`}
+                    type="button"
+                    className={item?.disponivel_mesa ? 'trabalho-model-link-btn' : 'trabalho-model-link-btn is-disabled'}
+                    onClick={() => onAbrirModeloAssociado(item)}
+                    disabled={!item?.disponivel_mesa}
+                    title={item?.disponivel_mesa ? 'Abrir modelo na MESA' : 'Modelo ainda não disponível na MESA'}
+                  >
+                    <span>{item?.mesa_modelo_nome || item?.nome || 'Modelo sem nome'}</span>
+                    <strong>{item?.disponivel_mesa ? 'Abrir na MESA' : 'Não disponível'}</strong>
+                  </button>
+                ))}
+              </div>
+            ) : (
+              <div className="section1-empty-hint">Nenhum modelo informado para este trabalho.</div>
+            )}
+            {modelosMesa.length ? (
+              <div className="section1-empty-hint">
+                Clique em um modelo disponível para abri-lo em Modelos Estatísticos &gt; Repositório de Modelos.
+              </div>
+            ) : null}
+          </section>
+
+          {trabalhoError ? <div className="error-line inline-error">{trabalhoError}</div> : null}
+        </div>
+        <LoadingOverlay show={trabalhoLoading} label="Carregando trabalho técnico..." />
+      </div>
+    )
+  }
+
+  return (
+    <div className="tab-content">
+      <div className="repositorio-standalone-panel">
+        <div className="repo-toolbar">
+          <div className="repo-summary">
+            <div><strong>Total:</strong> {trabalhos.length}</div>
+          </div>
+          <div className="repo-actions">
+            <button type="button" className="repo-refresh-btn" onClick={() => void carregarTrabalhos()} disabled={loading}>
+              Atualizar lista
+            </button>
+          </div>
+        </div>
+
+        <div className="trabalhos-filters">
+          <label className="trabalhos-filter-field">
+            Buscar
+            <input
+              type="text"
+              value={filtroTexto}
+              onChange={(event) => setFiltroTexto(event.target.value)}
+              placeholder="nome, endereço, modelo ou processo"
+              autoComplete="off"
+            />
+          </label>
+
+          <label className="trabalhos-filter-field">
+            Tipo
+            <select value={filtroTipo} onChange={(event) => setFiltroTipo(event.target.value)}>
+              <option value="">Todos</option>
+              {tiposDisponiveis.map((tipo) => (
+                <option key={`tipo-${tipo}`} value={tipo}>{tipo}</option>
+              ))}
+            </select>
+          </label>
+
+          <label className="trabalhos-filter-field">
+            Ano
+            <select value={filtroAno} onChange={(event) => setFiltroAno(event.target.value)}>
+              <option value="">Todos</option>
+              {anosDisponiveis.map((ano) => (
+                <option key={`ano-${ano}`} value={ano}>{ano}</option>
+              ))}
+            </select>
+          </label>
+
+          <div className="trabalhos-filter-result">
+            {trabalhosFiltrados.length} trabalho(s)
+          </div>
+        </div>
+
+        {error ? <div className="error-line">{error}</div> : null}
+        {trabalhoError ? <div className="error-line">{trabalhoError}</div> : null}
+
+        <div className="table-container repo-table-block">
+          <table className="repo-table trabalhos-repo-table">
+            <colgroup>
+              <col className="trabalhos-col-nome" />
+              <col className="trabalhos-col-tipo" />
+              <col className="trabalhos-col-ano" />
+              <col className="trabalhos-col-endereco" />
+              <col className="trabalhos-col-modelos" />
+              <col className="trabalhos-col-processos" />
+              <col className="trabalhos-col-abrir" />
+            </colgroup>
+            <thead>
+              <tr>
+                <th className="trabalhos-col-nome">Trabalho</th>
+                <th className="trabalhos-col-tipo">Tipo</th>
+                <th className="trabalhos-col-ano">Ano</th>
+                <th className="trabalhos-col-endereco">Endereço</th>
+                <th className="trabalhos-col-modelos">Modelos</th>
+                <th className="trabalhos-col-processos">Processos SEI</th>
+                <th className="repo-col-open">Abrir</th>
+              </tr>
+            </thead>
+            <tbody>
+              {trabalhosPagina.map((item) => (
+                <tr key={String(item?.id || '')}>
+                  <td className="trabalhos-col-nome">{item?.nome || '-'}</td>
+                  <td className="trabalhos-col-tipo">{item?.tipo_label || item?.tipo_codigo || '-'}</td>
+                  <td className="trabalhos-col-ano">{item?.ano || '-'}</td>
+                  <td className="trabalhos-col-endereco">{item?.endereco_resumo || '-'}</td>
+                  <td className="trabalhos-col-modelos">
+                    {Array.isArray(item?.modelos) && item.modelos.length ? (
+                      <div className="trabalho-model-stack">
+                        {item.modelos.map((modelo) => (
+                          <div
+                            key={`${item?.id || 'trabalho'}-lista-modelo-${modelo?.nome || ''}`}
+                            className="trabalho-model-list-item"
+                          >
+                            {modelo?.disponivel_mesa ? (
+                              <button
+                                type="button"
+                                className="trabalho-model-inline-link"
+                                onClick={() => onAbrirModeloAssociado(modelo)}
+                                title="Abrir modelo na MESA"
+                              >
+                                {modelo?.mesa_modelo_nome || modelo?.nome || '-'}
+                              </button>
+                            ) : (
+                              <span>{modelo?.nome || '-'}</span>
+                            )}
+                          </div>
+                        ))}
+                      </div>
+                    ) : (
+                      item?.modelo_resumo || '-'
+                    )}
+                  </td>
+                  <td className="trabalhos-col-processos">
+                    <div className="trabalho-model-stack">
+                      {listarProcessosAdministrativos(item).map((processo, index) => (
+                        <div
+                          key={`${item?.id || 'trabalho'}-processo-${index + 1}`}
+                          className="trabalho-model-list-item"
+                        >
+                          {processo}
+                        </div>
+                      ))}
+                    </div>
+                  </td>
+                  <td className="repo-col-open">
+                    <button
+                      type="button"
+                      className="repo-open-btn"
+                      onClick={() => void onAbrirTrabalho(item)}
+                      title="Abrir trabalho técnico"
+                      aria-label={`Abrir ${item?.nome || 'trabalho técnico'}`}
+                    >
+                      ↗
+                    </button>
+                  </td>
+                </tr>
+              ))}
+              {!trabalhosFiltrados.length ? (
+                <tr>
+                  <td colSpan={7}>
+                    {loading ? 'Carregando trabalhos técnicos...' : 'Nenhum trabalho encontrado para os filtros informados.'}
+                  </td>
+                </tr>
+              ) : null}
+            </tbody>
+          </table>
+        </div>
+        <ListPagination
+          totalItems={trabalhosFiltrados.length}
+          currentPage={trabalhosCurrentPage}
+          pageSize={PAGE_SIZE}
+          onPageChange={setListaPage}
+          loading={loading}
+        />
+      </div>
+      <LoadingOverlay show={loading} label="Carregando trabalhos técnicos..." />
+    </div>
+  )
+}

frontend/src/styles.css

@@ -400,6 +400,16 @@ textarea {
   .logs-filters {
     grid-template-columns: 1fr;
   }
+
+  .trabalhos-filters {
+    grid-template-columns: 1fr;
+  }
+
+  .trabalho-tecnico-meta-row {
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 4px;
+  }
 }
 
 .repositorio-standalone-panel {
@@ -418,6 +428,12 @@ textarea {
   flex-wrap: wrap;
 }
 
+.repo-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
 .repo-summary {
   display: grid;
   gap: 4px;
@@ -478,6 +494,30 @@ textarea {
   min-width: 880px;
 }
 
+.trabalhos-repo-table {
+  table-layout: fixed;
+}
+
+.trabalhos-repo-table col.trabalhos-col-nome {
+  width: 220px;
+}
+
+.trabalhos-repo-table col.trabalhos-col-tipo {
+  width: 120px;
+}
+
+.trabalhos-repo-table col.trabalhos-col-ano {
+  width: 82px;
+}
+
+.trabalhos-repo-table col.trabalhos-col-processos {
+  width: 190px;
+}
+
+.trabalhos-repo-table col.trabalhos-col-abrir {
+  width: 68px;
+}
+
 .repo-table th,
 .repo-table td {
   border-bottom: 1px solid #e1e9f1;
@@ -494,6 +534,25 @@ textarea {
   color: #48627a;
 }
 
+.trabalhos-repo-table th,
+.trabalhos-repo-table td {
+  vertical-align: top;
+}
+
+.trabalhos-repo-table .trabalhos-col-nome {
+  white-space: normal;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+  line-height: 1.4;
+}
+
+.trabalhos-repo-table .trabalhos-col-endereco,
+.trabalhos-repo-table .trabalhos-col-modelos {
+  white-space: normal;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+}
+
 .repo-periodo-wrap {
   display: inline-flex;
   align-items: center;
@@ -595,6 +654,231 @@ textarea {
   flex-wrap: wrap;
 }
 
+.trabalhos-filters {
+  margin-top: 14px;
+  display: grid;
+  grid-template-columns: minmax(240px, 1.6fr) minmax(140px, 0.7fr) minmax(120px, 0.5fr) auto;
+  gap: 10px 12px;
+  align-items: end;
+}
+
+.trabalhos-filter-field {
+  display: grid;
+  gap: 6px;
+  color: #334c64;
+  font-size: 0.86rem;
+}
+
+.trabalhos-filter-field input,
+.trabalhos-filter-field select {
+  min-height: 38px;
+}
+
+.trabalhos-filter-result {
+  align-self: end;
+  color: #47627b;
+  font-size: 0.84rem;
+  font-weight: 700;
+  padding-bottom: 8px;
+  white-space: nowrap;
+}
+
+.trabalho-tecnico-summary-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+  margin-bottom: 12px;
+}
+
+.trabalho-tecnico-card {
+  border: 1px solid #dbe5ef;
+  border-radius: 12px;
+  background: #ffffff;
+  padding: 14px;
+  display: grid;
+  gap: 10px;
+}
+
+.trabalho-tecnico-card-primary {
+  background: linear-gradient(180deg, #ffffff 0%, #f8fbff 100%);
+}
+
+.trabalho-tecnico-card h4 {
+  margin: 0;
+  color: #2f4760;
+  font-family: 'Sora', sans-serif;
+  font-size: 0.92rem;
+}
+
+.trabalho-tecnico-meta-list {
+  display: grid;
+  gap: 8px;
+}
+
+.trabalho-tecnico-meta-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  gap: 12px;
+  color: #344e65;
+}
+
+.trabalho-tecnico-meta-label {
+  color: #65809a;
+  font-size: 0.74rem;
+  font-weight: 800;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.trabalho-tecnico-note {
+  color: #31485f;
+  font-size: 0.9rem;
+  line-height: 1.5;
+}
+
+.trabalho-tecnico-kpis {
+  display: grid;
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.trabalho-tecnico-kpi {
+  border: 1px solid #dbe6f0;
+  border-radius: 10px;
+  background: #ffffff;
+  padding: 10px 11px;
+  display: grid;
+  gap: 4px;
+}
+
+.trabalho-tecnico-kpi-label {
+  color: #6b849a;
+  font-size: 0.72rem;
+  font-weight: 800;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.trabalho-imoveis-stack {
+  display: grid;
+  gap: 8px;
+}
+
+.trabalho-imovel-card {
+  border: 1px solid #dbe6f0;
+  border-radius: 10px;
+  background: #fbfdff;
+  padding: 10px 11px;
+  display: grid;
+  gap: 4px;
+  color: #324c64;
+}
+
+.trabalho-imovel-card span {
+  color: #5a7288;
+  font-size: 0.85rem;
+  line-height: 1.4;
+}
+
+.trabalho-model-links {
+  display: grid;
+  gap: 8px;
+}
+
+.trabalho-model-stack {
+  display: grid;
+  gap: 6px;
+}
+
+.trabalho-model-list-item {
+  color: #28465f;
+  line-height: 1.35;
+  word-break: break-word;
+}
+
+.trabalho-model-inline-link {
+  appearance: none;
+  border: none;
+  background: transparent;
+  padding: 0;
+  margin: 0;
+  color: #1f5d8d;
+  font: inherit;
+  line-height: 1.35;
+  text-align: left;
+  text-decoration: underline;
+  text-decoration-color: rgba(31, 93, 141, 0.28);
+  text-underline-offset: 2px;
+  cursor: pointer;
+}
+
+.trabalho-model-inline-link:hover {
+  color: #15486e;
+  text-decoration-color: currentColor;
+}
+
+.trabalho-model-inline-link:focus-visible {
+  outline: 2px solid rgba(31, 93, 141, 0.25);
+  outline-offset: 2px;
+  border-radius: 4px;
+}
+
+.trabalho-model-link-btn {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  width: 100%;
+  text-align: left;
+  border-radius: 10px;
+  padding: 10px 12px;
+  --btn-bg-start: #eef7ff;
+  --btn-bg-end: #e2f0ff;
+  --btn-border: #99bddf;
+  --btn-shadow-soft: rgba(73, 122, 169, 0.12);
+  --btn-shadow-strong: rgba(73, 122, 169, 0.18);
+  color: #1f4f79;
+}
+
+.trabalho-model-link-btn strong {
+  white-space: nowrap;
+}
+
+.trabalho-model-link-btn.is-disabled {
+  --btn-bg-start: #f7f9fb;
+  --btn-bg-end: #eef3f7;
+  --btn-border: #d4dee8;
+  --btn-shadow-soft: rgba(84, 104, 123, 0.08);
+  --btn-shadow-strong: rgba(84, 104, 123, 0.12);
+  color: #6f8598;
+  cursor: not-allowed;
+}
+
+@media (max-width: 980px) {
+  .trabalhos-filters {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .trabalhos-filter-result {
+    grid-column: 1 / -1;
+    padding-bottom: 0;
+  }
+
+  .trabalho-tecnico-summary-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .trabalho-tecnico-kpis {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .trabalho-model-link-btn {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+}
+
 .repo-delete-typing-field {
   display: grid;
   gap: 6px;
@@ -3584,6 +3868,10 @@ button.btn-upload-select {
   font-size: 0.86rem;
 }
 
+.modelo-trabalhos-tecnicos-disclaimer {
+  margin-bottom: 12px;
+}
+
 .coords-ready-hint {
   color: #1f5e3a;
   font-size: 0.88rem;

test-results/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "failed",
+  "failedTests": []
+}