Update technical work views and scatter transforms

README.md

@@ -87,7 +87,7 @@ Base de Trabalhos Técnicos:
 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`
+- Planilha padrão de origem: `~/Downloads/AVALIANDOS_20260515_corrigido_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`.

backend/app/api/elaboracao.py

@@ -98,6 +98,9 @@ class DispersaoPayload(SessionPayload):
 
 class DispersaoInterativoPayload(SessionPayload):
     alvo: str = "secao10"
+    coluna_x: str | None = None
+    transformacao_x: str = "(x)"
+    transformacao_y: str = "(x)"
 
 
 class DiagnosticoInterativoPayload(SessionPayload):
@@ -334,7 +337,13 @@ def model_dispersao(payload: DispersaoPayload) -> dict[str, Any]:
 @router.post("/dispersao-interativo")
 def dispersao_interativo(payload: DispersaoInterativoPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)
-    return elaboracao_service.obter_grafico_dispersao_interativo(session, payload.alvo)
+    return elaboracao_service.obter_grafico_dispersao_interativo(
+        session,
+        payload.alvo,
+        coluna_x=payload.coluna_x,
+        transformacao_x=payload.transformacao_x,
+        transformacao_y=payload.transformacao_y,
+    )
 
 
 @router.post("/diagnostico-interativo")

backend/app/services/elaboracao_service.py

@@ -22,6 +22,7 @@ from app.core.elaboracao.core import (
     PERCENTUAL_RUIDO_TOL,
     TRANSFORMACOES,
     ajustar_modelo,
+    aplicar_transformacao,
     normalizar_coluna_area,
     normalizar_tipo_y,
     normalizar_config_avaliacao_modelo,
@@ -1863,11 +1864,77 @@ def gerar_grafico_dispersao_modelo(
     }
 
 
-def obter_grafico_dispersao_interativo(session: SessionState, alvo: str) -> dict[str, Any]:
+def _normalizar_transformacao_dispersao(value: str | None) -> str:
+    text = str(value or "").strip()
+    return text if text in TRANSFORMACOES else "(x)"
+
+
+def _gerar_grafico_secao10_variavel(
+    session: SessionState,
+    coluna_x: str,
+    transformacao_x: str = "(x)",
+    transformacao_y: str = "(x)",
+) -> dict[str, Any]:
+    df_base = session.df_filtrado if session.df_filtrado is not None else session.df_original
+    if df_base is None or getattr(df_base, "empty", True):
+        raise HTTPException(status_code=400, detail="Base filtrada indisponivel")
+
+    coluna_x_norm = str(coluna_x or "").strip()
+    if not coluna_x_norm:
+        raise HTTPException(status_code=400, detail="Informe a variavel X")
+    if coluna_x_norm not in (session.colunas_x or []):
+        raise HTTPException(status_code=400, detail="Variavel X fora da selecao atual")
+    if coluna_x_norm not in df_base.columns:
+        raise HTTPException(status_code=404, detail="Variavel X indisponivel na base")
+    if not session.coluna_y or session.coluna_y not in df_base.columns:
+        raise HTTPException(status_code=404, detail="Variavel Y indisponivel na base")
+
+    transf_x = _normalizar_transformacao_dispersao(transformacao_x)
+    transf_y = _normalizar_transformacao_dispersao(transformacao_y)
+
+    x_vals = pd.to_numeric(df_base[coluna_x_norm], errors="coerce").to_numpy(dtype=float)
+    y_vals = pd.to_numeric(df_base[session.coluna_y], errors="coerce").to_numpy(dtype=float)
+    x_transf = aplicar_transformacao(x_vals, transf_x)
+    y_transf = aplicar_transformacao(y_vals, transf_y)
+
+    x_df = pd.DataFrame({coluna_x_norm: x_transf}, index=df_base.index)
+    y_series = pd.Series(y_transf, index=df_base.index, name=session.coluna_y)
+
+    try:
+        fig = charts.criar_graficos_dispersao(x_df, y_series)
+    except Exception:
+        fig = None
+
+    grafico = figure_to_payload(fig)
+    return {
+        "alvo": "secao10",
+        "coluna_x": coluna_x_norm,
+        "transformacao_x": transf_x,
+        "transformacao_y": transf_y,
+        "grafico": sanitize_value(grafico),
+        "grafico_com_indices": _payload_grafico_com_indices(grafico),
+    }
+
+
+def obter_grafico_dispersao_interativo(
+    session: SessionState,
+    alvo: str,
+    coluna_x: str | None = None,
+    transformacao_x: str = "(x)",
+    transformacao_y: str = "(x)",
+) -> dict[str, Any]:
     key = str(alvo or "").strip().lower()
     if key not in {"secao10", "secao13"}:
         raise HTTPException(status_code=400, detail="Alvo de grafico invalido")
 
+    if key == "secao10" and str(coluna_x or "").strip():
+        return _gerar_grafico_secao10_variavel(
+            session,
+            coluna_x=str(coluna_x or "").strip(),
+            transformacao_x=transformacao_x,
+            transformacao_y=transformacao_y,
+        )
+
     grafico = session.graficos_dispersao_cache.get(key)
     if not grafico:
         raise HTTPException(status_code=404, detail="Grafico interativo indisponivel para este alvo")

backend/app/services/trabalhos_tecnicos_importer.py

@@ -11,13 +11,18 @@ from pathlib import Path
 from typing import Any
 
 
-DEFAULT_SOURCE_XLSX_FILE = "dados_geocodificados_limpos_v2.xlsx"
+DEFAULT_SOURCE_XLSX_FILE = "AVALIANDOS_20260515_corrigido_v2.xlsx"
 DEFAULT_LOCAL_DB_FILE = "trabalhos_tecnicos.sqlite3"
-COLUNAS_BASE_OBRIGATORIAS = ["ANO", "MODELO", "ENDERECO", "NUM", "x", "y"]
-COLUNAS_IDENTIFICADORAS = ["NOME_PASTA", "AVALIANDO", "TRABALHO"]
+COLUNAS_BASE_OBRIGATORIAS = ["ANO", "MODELO", "x", "y"]
+COLUNAS_IDENTIFICADORAS = ["TRABALHO", "NOME_PASTA", "PASTA", "AVALIANDO"]
 COLUNAS_TECNICO = ["TÉCNICO", "TECNICO"]
-COLUNA_PROCESSO = "PROCESSO"
-COLUNA_FINALIDADE_PROCESSO = "FINALIDADE PROCESSO"
+COLUNAS_PROCESSO = ["PROCESSO", "PROCESO"]
+COLUNAS_LINK_PROCESSO = ["LINK_PROCESSO", "LINK PROCESSO"]
+COLUNAS_FINALIDADE_PROCESSO = ["FINALIDADE PROCESSO", "FINALIDADE_PROCESSO"]
+COLUNAS_PASTA = ["PASTA", "NOME_PASTA"]
+COLUNAS_LINK_PASTA = ["LINK_PASTA", "LINK PASTA", "LINK"]
+COLUNAS_ENDERECO = ["ENDERECO", "ENDEREÇO"]
+COLUNAS_NUMERO = ["NUM", "NUMERO", "NÚMERO", "NUMERO_IMOVEL"]
 TIPO_LABELS = {
     "LA": "Laudo de Avaliacao",
     "PT": "Parecer Tecnico",
@@ -54,6 +59,7 @@ class TrabalhoRawGroup:
     ano: int | None = None
     codigo_trabalho: str = ""
     nome_pasta: str = ""
+    link_pasta: str = ""
     endereco_base: str = ""
     numero_base: str = ""
     first_row_number: int = 0
@@ -86,6 +92,35 @@ def _first_non_empty(record: dict[str, Any], *keys: str) -> str:
     return ""
 
 
+def _split_pasta_tokens(value: str) -> list[str]:
+    return [token for token in _clean_text(value).split("_") if token]
+
+
+def _tokens_equal(left: list[str], right: list[str]) -> bool:
+    return _slugify("_".join(left)) == _slugify("_".join(right))
+
+
+def _infer_endereco_numero_from_pasta(nome_pasta: str, codigo_trabalho: str) -> tuple[str, str]:
+    tokens = _split_pasta_tokens(nome_pasta)
+    if not tokens:
+        return "", ""
+
+    trabalho_tokens = _split_pasta_tokens(codigo_trabalho)
+    if trabalho_tokens and len(tokens) > len(trabalho_tokens) and _tokens_equal(tokens[: len(trabalho_tokens)], trabalho_tokens):
+        tokens = tokens[len(trabalho_tokens) :]
+    elif len(tokens) > 3 and _slugify(tokens[0]) in TIPO_LABELS and tokens[1].isdigit() and re.fullmatch(r"\d{4}", tokens[2] or ""):
+        tokens = tokens[3:]
+
+    if not tokens:
+        return "", ""
+
+    ultimo = _strip_accents(tokens[-1]).upper()
+    numero = tokens[-1] if re.fullmatch(r"\d+[A-Z]?", ultimo) else ""
+    endereco_tokens = tokens[:-1] if numero else tokens
+    endereco = " ".join(token.strip() for token in endereco_tokens if str(token or "").strip()).strip()
+    return endereco, numero
+
+
 def _to_int(value: Any) -> int | None:
     text = _clean_text(value)
     if not text:
@@ -249,16 +284,24 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
     invalid_rows = 0
 
     for offset, record in enumerate(records, start=2):
-        nome_pasta = _clean_text(record.get("NOME_PASTA"))
+        nome_pasta = _first_non_empty(record, *COLUNAS_PASTA)
+        link_pasta = _first_non_empty(record, *COLUNAS_LINK_PASTA)
         codigo_trabalho = _clean_text(record.get("TRABALHO"))
-        raw_name = _first_non_empty(record, "NOME_PASTA", "AVALIANDO", "TRABALHO")
+        raw_name = _first_non_empty(record, *COLUNAS_IDENTIFICADORAS)
         if not raw_name:
             invalid_rows += 1
             continue
 
         tecnico = _first_non_empty(record, *COLUNAS_TECNICO)
-        processo = _clean_text(record.get(COLUNA_PROCESSO))
-        finalidade_processo = _clean_text(record.get(COLUNA_FINALIDADE_PROCESSO))
+        processo = _first_non_empty(record, *COLUNAS_PROCESSO)
+        link_processo = _first_non_empty(record, *COLUNAS_LINK_PROCESSO)
+        finalidade_processo = _first_non_empty(record, *COLUNAS_FINALIDADE_PROCESSO)
+        endereco_planilha = _first_non_empty(record, *COLUNAS_ENDERECO)
+        numero_planilha = _first_non_empty(record, *COLUNAS_NUMERO)
+        endereco_inferido, numero_inferido = _infer_endereco_numero_from_pasta(
+            nome_pasta,
+            codigo_trabalho or raw_name,
+        )
 
         group = groups.get(raw_name)
         if group is None:
@@ -267,8 +310,9 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
                 ano=_to_int(record.get("ANO")),
                 codigo_trabalho=codigo_trabalho,
                 nome_pasta=nome_pasta,
-                endereco_base=_clean_text(record.get("ENDERECO")),
-                numero_base=_clean_text(record.get("NUM")),
+                link_pasta=link_pasta,
+                endereco_base=endereco_planilha or endereco_inferido,
+                numero_base=numero_planilha or numero_inferido,
                 first_row_number=offset,
             )
             groups[raw_name] = group
@@ -279,14 +323,16 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
                 group.codigo_trabalho = codigo_trabalho
             if not group.nome_pasta:
                 group.nome_pasta = nome_pasta
+            if not group.link_pasta:
+                group.link_pasta = link_pasta
             if not group.endereco_base:
-                group.endereco_base = _clean_text(record.get("ENDERECO"))
+                group.endereco_base = endereco_planilha or endereco_inferido
             if not group.numero_base:
-                group.numero_base = _clean_text(record.get("NUM"))
+                group.numero_base = numero_planilha or numero_inferido
 
         modelo_nome = _clean_text(record.get("MODELO"))
-        endereco = _clean_text(record.get("ENDERECO"))
-        numero = _clean_text(record.get("NUM"))
+        endereco = endereco_planilha or endereco_inferido
+        numero = numero_planilha or numero_inferido
         coord_x = _to_float(record.get("x"))
         coord_y = _to_float(record.get("y"))
 
@@ -326,8 +372,10 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
                 "nome_original": raw_name,
                 "codigo_trabalho": codigo_trabalho,
                 "nome_pasta": nome_pasta,
+                "link_pasta": link_pasta,
                 "tecnico": tecnico,
                 "processo": processo,
+                "link_processo": link_processo,
                 "finalidade_processo": finalidade_processo,
                 "modelo_nome": modelo_nome,
                 "endereco": endereco,
@@ -341,7 +389,7 @@ def _build_groups(records: list[dict[str, Any]]) -> tuple[list[TrabalhoRawGroup]
 
     used_names: dict[str, str] = {}
     for group in ordered_groups:
-        base_name = build_clean_trabalho_name(group.nome_pasta or group.raw_name, group.endereco_base, group.numero_base)
+        base_name = _slugify(group.codigo_trabalho or group.raw_name)
         if not base_name:
             base_name = _slugify(group.nome_pasta or group.raw_name) or f"TRABALHO_{group.first_row_number}"
         candidate = base_name
@@ -393,6 +441,7 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
               nome_original TEXT NOT NULL,
               codigo_trabalho TEXT,
               nome_pasta TEXT,
+              link_pasta TEXT,
               tipo_codigo TEXT NOT NULL,
               tipo_label TEXT NOT NULL,
               ano INTEGER,
@@ -440,8 +489,10 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
               nome_original TEXT NOT NULL,
               codigo_trabalho TEXT,
               nome_pasta TEXT,
+              link_pasta TEXT,
               tecnico TEXT,
               processo TEXT,
+              link_processo TEXT,
               finalidade_processo TEXT,
               modelo_nome TEXT,
               endereco TEXT,
@@ -454,6 +505,7 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
             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);
+            CREATE INDEX idx_trabalho_registros_processo ON trabalho_registros (trabalho_id, processo);
             """
         )
 
@@ -466,7 +518,7 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
             "invalid_row_count": str(invalid_rows),
             "total_trabalhos": str(len(groups)),
             "generated_at_utc": imported_at,
-            "generator_version": "sqlite-v2",
+            "generator_version": "sqlite-v3",
         }
         conn.executemany(
             "INSERT INTO meta (key, value) VALUES (?, ?)",
@@ -474,7 +526,8 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
         )
 
         for group in groups:
-            tipo_codigo = _tipo_codigo_from_name(group.clean_name)
+            nome_exibicao = group.codigo_trabalho or group.raw_name or group.clean_name
+            tipo_codigo = _tipo_codigo_from_name(nome_exibicao)
             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"
@@ -497,6 +550,7 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                   nome_original,
                   codigo_trabalho,
                   nome_pasta,
+                  link_pasta,
                   tipo_codigo,
                   tipo_label,
                   ano,
@@ -511,14 +565,15 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                   total_imoveis,
                   total_modelos,
                   tem_coordenadas
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     group.clean_name,
-                    group.clean_name,
+                    nome_exibicao,
                     group.raw_name,
                     group.codigo_trabalho or None,
                     group.nome_pasta or None,
+                    group.link_pasta or None,
                     tipo_codigo,
                     _tipo_label(tipo_codigo),
                     group.ano,
@@ -574,15 +629,17 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                       nome_original,
                       codigo_trabalho,
                       nome_pasta,
+                      link_pasta,
                       tecnico,
                       processo,
+                      link_processo,
                       finalidade_processo,
                       modelo_nome,
                       endereco,
                       numero,
                       coord_x,
                       coord_y
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                     """,
                     (
                         group.clean_name,
@@ -591,8 +648,10 @@ def build_database_from_xlsx(xlsx_path: str | Path, db_path: str | Path) -> dict
                         registro["nome_original"],
                         registro["codigo_trabalho"] or None,
                         registro["nome_pasta"] or None,
+                        registro["link_pasta"] or None,
                         registro["tecnico"] or None,
                         registro["processo"] or None,
+                        registro["link_processo"] or None,
                         registro["finalidade_processo"] or None,
                         registro["modelo_nome"],
                         registro["endereco"],

backend/app/services/trabalhos_tecnicos_service.py

@@ -368,6 +368,21 @@ def _table_has_column(conn: sqlite3.Connection, table_name: str, column_name: st
     return any(str(row["name"] or "").strip().casefold() == column_name_norm for row in rows)
 
 
+def _select_optional_column(
+    conn: sqlite3.Connection,
+    table_name: str,
+    column_name: str,
+    *,
+    alias: str | None = None,
+    table_alias: str | None = None,
+) -> str:
+    alias_name = alias or column_name
+    if _table_has_column(conn, table_name, column_name):
+        prefix = f"{table_alias}." if table_alias else ""
+        return f"{prefix}{column_name} AS {alias_name}"
+    return f"NULL AS {alias_name}"
+
+
 def _resumo_textos(valores: list[str], limite_inline: int = 2) -> str:
     unicos = _dedupe_text_list(valores)
     if not unicos:
@@ -433,6 +448,87 @@ def _carregar_processos_importados_por_trabalho(
     return {chave: _dedupe_text_list(valores) for chave, valores in processos_por_trabalho.items()}
 
 
+def _normalizar_processos_detalhados(
+    values: Any,
+    fallback_processos: list[str] | None = None,
+) -> list[dict[str, str]]:
+    detalhados: list[dict[str, str]] = []
+    vistos: set[str] = set()
+    for item in values or []:
+        if isinstance(item, dict):
+            numero = str(item.get("numero") or item.get("processo") or "").strip()
+            link = str(item.get("link") or item.get("href") or "").strip()
+        else:
+            numero = str(item or "").strip()
+            link = ""
+        chave = numero.casefold()
+        if not numero or chave in vistos:
+            continue
+        vistos.add(chave)
+        detalhados.append({"numero": numero, "link": link})
+
+    for processo in fallback_processos or []:
+        numero = str(processo or "").strip()
+        chave = numero.casefold()
+        if not numero or chave in vistos:
+            continue
+        vistos.add(chave)
+        detalhados.append({"numero": numero, "link": ""})
+
+    return detalhados
+
+
+def _carregar_processos_detalhados_por_trabalho(
+    conn: sqlite3.Connection,
+    trabalho_id: str | None = None,
+) -> dict[str, list[dict[str, str]]]:
+    processos_por_trabalho: dict[str, list[dict[str, str]]] = {}
+
+    if _table_has_column(conn, "trabalho_registros", "processo"):
+        params: list[Any] = []
+        where_clause = "WHERE TRIM(COALESCE(processo, '')) <> ''"
+        if trabalho_id:
+            where_clause += " AND trabalho_id = ?"
+            params.append(trabalho_id)
+        link_select = _select_optional_column(
+            conn,
+            "trabalho_registros",
+            "link_processo",
+            alias="link_processo",
+        )
+        rows = conn.execute(
+            f"""
+            SELECT trabalho_id, processo, {link_select}
+            FROM trabalho_registros
+            {where_clause}
+            ORDER BY trabalho_id, source_row, LOWER(TRIM(processo))
+            """,
+            params,
+        ).fetchall()
+        for row in rows:
+            chave = str(row["trabalho_id"] or "").strip()
+            processo = str(row["processo"] or "").strip()
+            if not chave or not processo:
+                continue
+            processos_por_trabalho.setdefault(chave, []).append(
+                {
+                    "numero": processo,
+                    "link": str(row["link_processo"] or "").strip(),
+                }
+            )
+
+    if processos_por_trabalho:
+        return {
+            chave: _normalizar_processos_detalhados(valores)
+            for chave, valores in processos_por_trabalho.items()
+        }
+
+    return {
+        chave: _normalizar_processos_detalhados([], valores)
+        for chave, valores in _carregar_processos_importados_por_trabalho(conn, trabalho_id).items()
+    }
+
+
 def _tipo_label_from_codigo(codigo: Any, fallback: Any = None) -> str:
     codigo_texto = str(codigo or "").strip().upper()
     if codigo_texto in TIPO_LABELS:
@@ -543,6 +639,10 @@ def _apply_override_trabalho(
         trabalho = dict(base)
         processos_base = _dedupe_text_list(base.get("processos_sei"))
         trabalho["processos_sei"] = processos_base
+        trabalho["processos_detalhados"] = _normalizar_processos_detalhados(
+            base.get("processos_detalhados"),
+            processos_base,
+        )
         trabalho["processos_sei_resumo"] = _resumo_textos(processos_base, limite_inline=1)
         return trabalho
 
@@ -569,8 +669,13 @@ def _apply_override_trabalho(
     processos_base = _dedupe_text_list(base.get("processos_sei"))
     if override.get("processos_sei_informados"):
         trabalho["processos_sei"] = _dedupe_text_list(override.get("processos_sei"))
+        trabalho["processos_detalhados"] = _normalizar_processos_detalhados([], trabalho["processos_sei"])
     else:
         trabalho["processos_sei"] = processos_base
+        trabalho["processos_detalhados"] = _normalizar_processos_detalhados(
+            base.get("processos_detalhados"),
+            processos_base,
+        )
     trabalho["processos_sei_resumo"] = _resumo_textos(_dedupe_text_list(trabalho.get("processos_sei")), limite_inline=1)
     trabalho["imoveis"] = imoveis
     trabalho["modelos"] = _enriquecer_modelos(modelos_raw, catalogo_modelos)
@@ -610,23 +715,39 @@ def _carregar_trabalho_base(
     trabalho_id: str,
     catalogo_modelos: dict[str, dict[str, str]],
 ) -> dict[str, Any]:
+    nome_pasta_select = _select_optional_column(conn, "trabalhos", "nome_pasta", alias="nome_pasta", table_alias="t")
+    link_pasta_select = _select_optional_column(conn, "trabalhos", "link_pasta", alias="link_pasta", table_alias="t")
+    tecnico_select = _select_optional_column(conn, "trabalhos", "tecnico_resumo", alias="tecnico_resumo", table_alias="t")
+    processo_select = _select_optional_column(conn, "trabalhos", "processo_resumo", alias="processo_resumo", table_alias="t")
+    finalidade_select = _select_optional_column(
+        conn,
+        "trabalhos",
+        "finalidade_processo_resumo",
+        alias="finalidade_processo_resumo",
+        table_alias="t",
+    )
     trabalho_row = conn.execute(
-        """
+        f"""
         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 = ?
+          t.trabalho_id,
+          t.nome,
+          t.nome_original,
+          {nome_pasta_select},
+          {link_pasta_select},
+          t.tipo_codigo,
+          t.tipo_label,
+          t.ano,
+          t.endereco_resumo,
+          t.modelo_resumo,
+          {tecnico_select},
+          {processo_select},
+          {finalidade_select},
+          t.total_registros,
+          t.total_imoveis,
+          t.total_modelos,
+          t.tem_coordenadas
+        FROM trabalhos t
+        WHERE t.trabalho_id = ?
         """,
         (trabalho_id,),
     ).fetchone()
@@ -655,7 +776,8 @@ def _carregar_trabalho_base(
         """,
         (trabalho_id,),
     ).fetchall()
-    processos_sei = _carregar_processos_importados_por_trabalho(conn, trabalho_id).get(trabalho_id, [])
+    processos_detalhados = _carregar_processos_detalhados_por_trabalho(conn, trabalho_id).get(trabalho_id, [])
+    processos_sei = [item["numero"] for item in processos_detalhados]
 
     modelos = _enriquecer_modelos([str(row["modelo_nome"]) for row in modelo_rows], catalogo_modelos)
     modelos_por_imovel: dict[int, list[str]] = {}
@@ -681,16 +803,22 @@ def _carregar_trabalho_base(
         "id": str(trabalho_row["trabalho_id"]),
         "nome": str(trabalho_row["nome"]),
         "nome_original": str(trabalho_row["nome_original"]),
+        "pasta_nome": str(trabalho_row["nome_pasta"] or ""),
+        "pasta_link": str(trabalho_row["link_pasta"] or ""),
         "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 ""),
+        "tecnico_resumo": str(trabalho_row["tecnico_resumo"] or ""),
+        "processo_resumo": str(trabalho_row["processo_resumo"] or ""),
+        "finalidade_processo_resumo": str(trabalho_row["finalidade_processo_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"]),
         "processos_sei": processos_sei,
+        "processos_detalhados": processos_detalhados,
         "processos_sei_resumo": _resumo_textos(processos_sei, limite_inline=1),
         "modelos": modelos,
         "imoveis": imoveis,
@@ -889,6 +1017,7 @@ def _inserir_trabalho_manual(
           nome_original,
           codigo_trabalho,
           nome_pasta,
+          link_pasta,
           tipo_codigo,
           tipo_label,
           ano,
@@ -903,7 +1032,7 @@ def _inserir_trabalho_manual(
           total_imoveis,
           total_modelos,
           tem_coordenadas
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """,
         (
             trabalho_id,
@@ -911,6 +1040,7 @@ def _inserir_trabalho_manual(
             nome,
             None,
             None,
+            None,
             tipo_codigo,
             _tipo_label_from_codigo(tipo_codigo),
             ano,
@@ -966,15 +1096,17 @@ def _inserir_trabalho_manual(
               nome_original,
               codigo_trabalho,
               nome_pasta,
+              link_pasta,
               tecnico,
               processo,
+              link_processo,
               finalidade_processo,
               modelo_nome,
               endereco,
               numero,
               coord_x,
               coord_y
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
             (
                 trabalho_id,
@@ -984,8 +1116,10 @@ def _inserir_trabalho_manual(
                 None,
                 None,
                 None,
+                None,
                 processo,
                 None,
+                None,
                 modelo_nome,
                 str(imovel.get("endereco") or "").strip() or None,
                 str(imovel.get("numero") or "").strip() or None,
@@ -1544,24 +1678,40 @@ def listar_trabalhos() -> dict[str, Any]:
     try:
         meta = _fetch_meta(conn)
         overrides = _fetch_overrides(conn)
-        processos_por_trabalho = _carregar_processos_importados_por_trabalho(conn)
+        processos_detalhados_por_trabalho = _carregar_processos_detalhados_por_trabalho(conn)
+        nome_pasta_select = _select_optional_column(conn, "trabalhos", "nome_pasta", alias="nome_pasta", table_alias="t")
+        link_pasta_select = _select_optional_column(conn, "trabalhos", "link_pasta", alias="link_pasta", table_alias="t")
+        tecnico_select = _select_optional_column(conn, "trabalhos", "tecnico_resumo", alias="tecnico_resumo", table_alias="t")
+        processo_select = _select_optional_column(conn, "trabalhos", "processo_resumo", alias="processo_resumo", table_alias="t")
+        finalidade_select = _select_optional_column(
+            conn,
+            "trabalhos",
+            "finalidade_processo_resumo",
+            alias="finalidade_processo_resumo",
+            table_alias="t",
+        )
         trabalhos_rows = conn.execute(
-            """
+            f"""
             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)
+              t.trabalho_id,
+              t.nome,
+              t.nome_original,
+              {nome_pasta_select},
+              {link_pasta_select},
+              t.tipo_codigo,
+              t.tipo_label,
+              t.ano,
+              t.endereco_resumo,
+              t.modelo_resumo,
+              {tecnico_select},
+              {processo_select},
+              {finalidade_select},
+              t.total_registros,
+              t.total_imoveis,
+              t.total_modelos,
+              t.tem_coordenadas
+            FROM trabalhos t
+            ORDER BY COALESCE(t.ano, 0) DESC, LOWER(t.tipo_codigo), LOWER(t.nome)
             """
         ).fetchall()
         modelos_rows = conn.execute(
@@ -1578,21 +1728,28 @@ def listar_trabalhos() -> dict[str, Any]:
     total_com_modelo_mesa = 0
     for row in trabalhos_rows:
         trabalho_id = str(row["trabalho_id"])
-        processos_sei = list(processos_por_trabalho.get(trabalho_id, []))
+        processos_detalhados = list(processos_detalhados_por_trabalho.get(trabalho_id, []))
+        processos_sei = [item["numero"] for item in processos_detalhados]
         base = {
             "id": trabalho_id,
             "nome": str(row["nome"]),
             "nome_original": str(row["nome_original"]),
+            "pasta_nome": str(row["nome_pasta"] or ""),
+            "pasta_link": str(row["link_pasta"] or ""),
             "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 ""),
+            "tecnico_resumo": str(row["tecnico_resumo"] or ""),
+            "processo_resumo": str(row["processo_resumo"] or ""),
+            "finalidade_processo_resumo": str(row["finalidade_processo_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),
             "tem_coordenadas": bool(row["tem_coordenadas"]),
             "processos_sei": processos_sei,
+            "processos_detalhados": processos_detalhados,
             "processos_sei_resumo": _resumo_textos(processos_sei, limite_inline=1),
             "modelos": _enriquecer_modelos(modelos_por_trabalho.get(trabalho_id, []), catalogo_modelos),
             "imoveis": [],

frontend/public/logo_sigedai.svg.qlpreview/Preview.url

@@ -0,0 +1 @@
+file:///Users/guilhermesilberfarbcosta/Downloads/mesa-frame/frontend/public/logo_sigedai.svg

frontend/public/logo_sigedai.svg.qlpreview/PreviewProperties.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>MimeType</key>
+	<string>image/svg+xml</string>
+</dict>
+</plist>

frontend/src/api.js

@@ -267,9 +267,10 @@ export const api = {
     session_id: sessionId,
     ...(payload || {}),
   }),
-  getDispersaoInterativo: (sessionId, alvo) => postJson('/api/elaboracao/dispersao-interativo', {
+  getDispersaoInterativo: (sessionId, alvo, options = {}) => postJson('/api/elaboracao/dispersao-interativo', {
     session_id: sessionId,
     alvo,
+    ...(options || {}),
   }),
   getDiagnosticoInterativo: (sessionId, grafico) => postJson('/api/elaboracao/diagnostico-interativo', {
     session_id: sessionId,
@@ -367,10 +368,6 @@ export const api = {
   },
   visualizacaoRepositorioModelos: () => getJson('/api/visualizacao/repositorio-modelos'),
   visualizacaoRepositorioCarregar: (sessionId, modeloId) => postJson('/api/visualizacao/repositorio-carregar', { session_id: sessionId, modelo_id: modeloId }),
-  exibirVisualizacao: (sessionId, trabalhosTecnicosModelosModo = 'selecionados_e_outras_versoes') => postJson('/api/visualizacao/exibir', {
-    session_id: sessionId,
-    trabalhos_tecnicos_modelos_modo: trabalhosTecnicosModelosModo,
-  }),
   visualizacaoSection: (sessionId, secao, trabalhosTecnicosModelosModo = 'selecionados_e_outras_versoes') => postJson('/api/visualizacao/section', {
     session_id: sessionId,
     secao,
@@ -382,7 +379,6 @@ export const api = {
     variavel_mapa: variavelMapa,
     trabalhos_tecnicos_modelos_modo: trabalhosTecnicosModelosModo,
   }),
-  evaluationFieldsViz: (sessionId) => postJson('/api/visualizacao/evaluation/fields', { session_id: sessionId }),
   evaluationCalculateViz: (sessionId, valoresX, indiceBase, avaliando = null) => postJson('/api/visualizacao/evaluation/calculate', {
     session_id: sessionId,
     valores_x: valoresX,
@@ -401,19 +397,7 @@ export const api = {
     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', {
-    session_id: sessionId,
-    indice,
-    indice_base: indiceBase,
-  }),
-  evaluationBaseViz: (sessionId, indiceBase) => postJson('/api/visualizacao/evaluation/base', {
-    session_id: sessionId,
-    indice_base: indiceBase,
-  }),
-  exportEvaluationViz: (sessionId) => getBlob(`/api/visualizacao/evaluation/export?session_id=${encodeURIComponent(sessionId)}`),
   exportEquationViz: (sessionId, mode = 'excel') => getBlob(`/api/visualizacao/equation/export?session_id=${encodeURIComponent(sessionId)}&mode=${encodeURIComponent(String(mode || 'excel'))}`),
-  clearVisualizacao: (sessionId) => postJson('/api/visualizacao/clear', { session_id: sessionId }),
 
   repositorioListar: () => getJson('/api/repositorio/modelos'),
   repositorioUpload(files = [], { confirmarSubstituicao = false } = {}) {

frontend/src/components/ElaboracaoTab.jsx

@@ -32,6 +32,8 @@ const GRAU_LABEL_CURTO = {
   2: 'Grau II',
   3: 'Grau III',
 }
+const TRANSFORMACOES_GRAFICO_DISPERSAO = ['(x)', '1/(x)', 'ln(x)', 'exp(x)', '(x)^2', 'raiz(x)', '1/raiz(x)']
+const TRANSFORMACAO_GRAFICO_PADRAO = '(x)'
 const MAPA_VARIAVEL_PADRAO = 'Visualização Padrão'
 const MAPA_MODO_PONTOS = 'pontos'
 const MAPA_MODO_CALOR = 'calor'
@@ -493,6 +495,291 @@ function parsePanelHeading(tituloHtml, fallbackTitle) {
   }
 }
 
+function normalizarTransformacaoGrafico(value) {
+  const text = String(value || '').trim()
+  return TRANSFORMACOES_GRAFICO_DISPERSAO.includes(text) ? text : TRANSFORMACAO_GRAFICO_PADRAO
+}
+
+function formatTransformacaoEixo(transformacao, eixo = 'x') {
+  const text = normalizarTransformacaoGrafico(transformacao)
+  if (String(eixo || '').toLowerCase() !== 'y') return text
+  return text.replace(/\bx\b/g, 'y')
+}
+
+function getScatterTransformKey(label) {
+  return String(label || '').trim()
+}
+
+function getScatterTransformConfig(map, label) {
+  const key = getScatterTransformKey(label)
+  const raw = key && map && typeof map === 'object' ? map[key] : null
+  return {
+    x: normalizarTransformacaoGrafico(raw?.x),
+    y: normalizarTransformacaoGrafico(raw?.y),
+  }
+}
+
+function buildScatterLazyCacheKey(label, config) {
+  const safeConfig = {
+    x: normalizarTransformacaoGrafico(config?.x),
+    y: normalizarTransformacaoGrafico(config?.y),
+  }
+  return `${getScatterTransformKey(label)}::${safeConfig.x}::${safeConfig.y}`
+}
+
+function aplicarTransformacaoNumerica(value, transformacao) {
+  const num = Number(value)
+  if (!Number.isFinite(num)) return null
+  const tipo = normalizarTransformacaoGrafico(transformacao)
+  let next = num
+  if (tipo === '1/(x)') {
+    if (num === 0) return null
+    next = 1 / num
+  } else if (tipo === 'ln(x)') {
+    if (num <= 0) return null
+    next = Math.log(num)
+  } else if (tipo === 'exp(x)') {
+    next = Math.exp(num)
+  } else if (tipo === '(x)^2') {
+    next = num ** 2
+  } else if (tipo === 'raiz(x)') {
+    if (num < 0) return null
+    next = Math.sqrt(num)
+  } else if (tipo === '1/raiz(x)') {
+    if (num <= 0) return null
+    next = 1 / Math.sqrt(num)
+  }
+  return Number.isFinite(next) ? next : null
+}
+
+function normalizarSequenciaNumerica(values) {
+  if (Array.isArray(values)) return values
+  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(values)) {
+    return Array.from(values)
+  }
+  if (values && typeof values === 'object' && Array.isArray(values.values)) {
+    return values.values
+  }
+  if (
+    values &&
+    typeof values !== 'string' &&
+    typeof values.length === 'number' &&
+    Number.isFinite(Number(values.length))
+  ) {
+    try {
+      return Array.from(values)
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+function transformarArrayNumerico(values, transformacao) {
+  const numericValues = normalizarSequenciaNumerica(values)
+  if (!numericValues) return values
+  const tipo = normalizarTransformacaoGrafico(transformacao)
+  if (tipo === TRANSFORMACAO_GRAFICO_PADRAO) {
+    return numericValues.map((value) => {
+      const num = Number(value)
+      return Number.isFinite(num) ? num : null
+    })
+  }
+  return numericValues.map((value) => aplicarTransformacaoNumerica(value, tipo))
+}
+
+function coletarParesFinitos(xValues, yValues) {
+  const xArray = normalizarSequenciaNumerica(xValues)
+  const yArray = normalizarSequenciaNumerica(yValues)
+  if (!xArray || !yArray) return []
+  const len = Math.min(xArray.length, yArray.length)
+  const pairs = []
+  for (let index = 0; index < len; index += 1) {
+    const x = Number(xArray[index])
+    const y = Number(yArray[index])
+    if (Number.isFinite(x) && Number.isFinite(y)) pairs.push([x, y])
+  }
+  return pairs
+}
+
+function calcularCorrelacaoPares(pairs) {
+  if (!Array.isArray(pairs) || pairs.length < 2) return null
+  const n = pairs.length
+  const meanX = pairs.reduce((sum, pair) => sum + pair[0], 0) / n
+  const meanY = pairs.reduce((sum, pair) => sum + pair[1], 0) / n
+  let cov = 0
+  let varX = 0
+  let varY = 0
+  pairs.forEach(([x, y]) => {
+    const dx = x - meanX
+    const dy = y - meanY
+    cov += dx * dy
+    varX += dx * dx
+    varY += dy * dy
+  })
+  const denom = Math.sqrt(varX * varY)
+  if (!Number.isFinite(denom) || denom <= 0) return null
+  const corr = cov / denom
+  return Number.isFinite(corr) ? corr : null
+}
+
+function formatarCorrelacao(value) {
+  if (!Number.isFinite(value)) return ''
+  const normalized = Math.abs(value) < 0.0005 ? 0 : value
+  return normalized.toFixed(3)
+}
+
+function calcularLinhaRegressao(pairs) {
+  if (!Array.isArray(pairs) || pairs.length < 3) return null
+  const n = pairs.length
+  const meanX = pairs.reduce((sum, pair) => sum + pair[0], 0) / n
+  const meanY = pairs.reduce((sum, pair) => sum + pair[1], 0) / n
+  let varX = 0
+  let cov = 0
+  pairs.forEach(([x, y]) => {
+    const dx = x - meanX
+    varX += dx * dx
+    cov += dx * (y - meanY)
+  })
+  if (!Number.isFinite(varX) || varX <= 0) return null
+  const a = cov / varX
+  const b = meanY - (a * meanX)
+  const sortedX = pairs.map((pair) => pair[0]).sort((aValue, bValue) => aValue - bValue)
+  return {
+    x: sortedX,
+    y: sortedX.map((xValue) => (a * xValue) + b),
+  }
+}
+
+function tituloEixoTransformado(axis, fallback, transformacao, eixo) {
+  const baseTitle = getAxisTitleText(axis) || String(fallback || '').trim() || String(eixo || '').toUpperCase()
+  const tipo = normalizarTransformacaoGrafico(transformacao)
+  return `${baseTitle} (${formatTransformacaoEixo(tipo, eixo)})`
+}
+
+function aplicarTransformacoesFiguraDispersao(figure, config, label, yFallback = 'Y') {
+  if (!figure || typeof figure !== 'object') return figure
+  const transformacaoX = normalizarTransformacaoGrafico(config?.x)
+  const transformacaoY = normalizarTransformacaoGrafico(config?.y)
+  const data = Array.isArray(figure.data) ? figure.data : []
+  const transformedData = data.map((trace) => ({
+    ...trace,
+    x: transformarArrayNumerico(trace?.x, transformacaoX),
+    y: transformarArrayNumerico(trace?.y, transformacaoY),
+  }))
+
+  const markerTrace = transformedData.find((trace) => String(trace?.mode || '').includes('markers'))
+  const pairs = markerTrace ? coletarParesFinitos(markerTrace.x, markerTrace.y) : []
+  const regression = calcularLinhaRegressao(pairs)
+  const dataComRegressao = transformedData.map((trace) => {
+    const mode = String(trace?.mode || '')
+    if (!mode.includes('lines') || mode.includes('markers')) return trace
+    return {
+      ...trace,
+      x: regression?.x || [],
+      y: regression?.y || [],
+    }
+  })
+
+  const baseLayout = figure.layout || {}
+  const {
+    range: _ignoreXRange,
+    autorange: _ignoreXAutorange,
+    ...xaxisRest
+  } = baseLayout.xaxis || {}
+  const {
+    range: _ignoreYRange,
+    autorange: _ignoreYAutorange,
+    ...yaxisRest
+  } = baseLayout.yaxis || {}
+  const xTitle = tituloEixoTransformado(baseLayout.xaxis, label, transformacaoX, 'x')
+  const yTitle = tituloEixoTransformado(baseLayout.yaxis, yFallback, transformacaoY, 'y')
+
+  return {
+    ...figure,
+    data: dataComRegressao,
+    layout: {
+      ...baseLayout,
+      xaxis: {
+        ...xaxisRest,
+        autorange: true,
+        title: {
+          ...(typeof baseLayout.xaxis?.title === 'object' ? baseLayout.xaxis.title : {}),
+          text: xTitle,
+        },
+      },
+      yaxis: {
+        ...yaxisRest,
+        autorange: true,
+        title: {
+          ...(typeof baseLayout.yaxis?.title === 'object' ? baseLayout.yaxis.title : {}),
+          text: yTitle,
+        },
+      },
+    },
+  }
+}
+
+function rotularFiguraDispersao(figure, config, label, yFallback = 'Y') {
+  if (!figure || typeof figure !== 'object') return figure
+  const transformacaoX = normalizarTransformacaoGrafico(config?.x)
+  const transformacaoY = normalizarTransformacaoGrafico(config?.y)
+  const baseLayout = figure.layout || {}
+  const xTitle = tituloEixoTransformado(baseLayout.xaxis, label, transformacaoX, 'x')
+  const yTitle = tituloEixoTransformado(baseLayout.yaxis, yFallback, transformacaoY, 'y')
+  return {
+    ...figure,
+    layout: {
+      ...baseLayout,
+      xaxis: {
+        ...(baseLayout.xaxis || {}),
+        title: {
+          ...(typeof baseLayout.xaxis?.title === 'object' ? baseLayout.xaxis.title : {}),
+          text: xTitle,
+        },
+      },
+      yaxis: {
+        ...(baseLayout.yaxis || {}),
+        title: {
+          ...(typeof baseLayout.yaxis?.title === 'object' ? baseLayout.yaxis.title : {}),
+          text: yTitle,
+        },
+      },
+    },
+  }
+}
+
+function rotularPainelDispersao(item, config, yFallback = 'Y') {
+  if (!item?.figure) return item
+  const transformacaoX = normalizarTransformacaoGrafico(config?.x)
+  const transformacaoY = normalizarTransformacaoGrafico(config?.y)
+  return {
+    ...item,
+    figure: rotularFiguraDispersao(item.figure, { x: transformacaoX, y: transformacaoY }, item.label, yFallback),
+    revisionKey: `${transformacaoX}|${transformacaoY}`,
+  }
+}
+
+function aplicarTransformacoesPainelDispersao(item, config, yFallback = 'Y') {
+  if (!item?.figure) return item
+  const transformacaoX = normalizarTransformacaoGrafico(config?.x)
+  const transformacaoY = normalizarTransformacaoGrafico(config?.y)
+  const figure = aplicarTransformacoesFiguraDispersao(item.figure, { x: transformacaoX, y: transformacaoY }, item.label, yFallback)
+  const markerTrace = Array.isArray(figure?.data)
+    ? figure.data.find((trace) => String(trace?.mode || '').includes('markers'))
+    : null
+  const corr = markerTrace ? calcularCorrelacaoPares(coletarParesFinitos(markerTrace.x, markerTrace.y)) : null
+  const subtitle = corr === null ? item.subtitle : `Correlação (r = ${formatarCorrelacao(corr)})`
+  const revisionKey = `${transformacaoX}|${transformacaoY}`
+  return {
+    ...item,
+    figure,
+    subtitle,
+    legenda: [item.title, subtitle].filter(Boolean).join(' - '),
+    revisionKey,
+  }
+}
+
 function matchesShapeAxisRef(ref, token) {
   const text = String(ref || '').trim().toLowerCase()
   if (!text) return false
@@ -703,6 +990,70 @@ function buildScatterPanelFigureMap(panels) {
   return mapa
 }
 
+function DownloadIcon() {
+  return (
+    <svg className="plot-card-download-icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false">
+      <path d="M12 3v11" />
+      <path d="M7.5 9.5 12 14l4.5-4.5" />
+      <path d="M5 18.5h14" />
+    </svg>
+  )
+}
+
+function DownloadIconButton({ onClick, disabled = false, title = 'Fazer download', ariaLabel = 'Fazer download', className = '' }) {
+  return (
+    <button
+      type="button"
+      className={`btn-download-subtle plot-card-download-btn plot-card-download-icon-btn ${className}`.trim()}
+      title={title}
+      aria-label={ariaLabel}
+      onClick={onClick}
+      disabled={disabled}
+    >
+      <DownloadIcon />
+    </button>
+  )
+}
+
+function ScatterTransformControls({ label, config, onChange, disabled = false }) {
+  const safeConfig = {
+    x: normalizarTransformacaoGrafico(config?.x),
+    y: normalizarTransformacaoGrafico(config?.y),
+  }
+  return (
+    <div className="scatter-transform-controls" aria-label="Transformações do gráfico">
+      <label className="scatter-transform-field">
+        <span>X</span>
+        <select
+          value={safeConfig.x}
+          onChange={(event) => onChange?.(label, 'x', event.target.value)}
+          disabled={disabled}
+        >
+          {TRANSFORMACOES_GRAFICO_DISPERSAO.map((item) => (
+            <option key={`scatter-transform-x-${item}`} value={item}>
+              {formatTransformacaoEixo(item, 'x')}
+            </option>
+          ))}
+        </select>
+      </label>
+      <label className="scatter-transform-field">
+        <span>Y</span>
+        <select
+          value={safeConfig.y}
+          onChange={(event) => onChange?.(label, 'y', event.target.value)}
+          disabled={disabled}
+        >
+          {TRANSFORMACOES_GRAFICO_DISPERSAO.map((item) => (
+            <option key={`scatter-transform-y-${item}`} value={item}>
+              {formatTransformacaoEixo(item, 'y')}
+            </option>
+          ))}
+        </select>
+      </label>
+    </div>
+  )
+}
+
 function ScatterPlotCarousel({
   items,
   indexedFigureMap,
@@ -711,6 +1062,8 @@ function ScatterPlotCarousel({
   sectionFilePrefix,
   onDownloadFigure,
   onDownloadAll,
+  renderHeaderActions = null,
+  renderTrailingHeaderActions = null,
   renderItem = null,
   downloadAllLabel = 'Baixar todos os gráficos',
   pillsAriaLabel = 'Escolher dupla de gráficos',
@@ -805,6 +1158,20 @@ function ScatterPlotCarousel({
           const forceHideLegend = item.forceHideLegend ?? true
           const showPointIndexToggle = item.showPointIndexToggle ?? true
           const downloadOptions = item.downloadOptions || { forceHideLegend }
+          const defaultDownloadAction = typeof onDownloadFigure === 'function' ? (
+            <DownloadIconButton
+              title={item.legenda || item.label || 'Fazer download'}
+              ariaLabel={`Fazer download de ${item.legenda || item.label || 'gráfico'}`}
+              onClick={() => onDownloadFigure(item.figure, fileNameBase, downloadOptions)}
+              disabled={loading || downloadingAssets || !item.figure}
+            />
+          ) : null
+          const headerActions = typeof renderHeaderActions === 'function'
+            ? renderHeaderActions({ item, itemIndex, fileNameBase, downloadOptions })
+            : null
+          const trailingHeaderActions = typeof renderTrailingHeaderActions === 'function'
+            ? renderTrailingHeaderActions({ item, itemIndex, fileNameBase, downloadOptions })
+            : defaultDownloadAction
           return (
           <PlotFigure
             key={`${itemKeyPrefix}-${item.id || itemIndex}`}
@@ -817,17 +1184,9 @@ function ScatterPlotCarousel({
             forceHideLegend={forceHideLegend}
             className={item.className || 'plot-stretch'}
             lazy
-            headerActions={typeof onDownloadFigure === 'function' ? (
-              <button
-                type="button"
-                className="btn-download-subtle plot-card-download-btn"
-                title={item.legenda || item.label || 'Fazer download'}
-                onClick={() => onDownloadFigure(item.figure, fileNameBase, downloadOptions)}
-                disabled={loading || downloadingAssets || !item.figure}
-              >
-                Fazer download
-              </button>
-            ) : null}
+            headerActions={headerActions}
+            trailingHeaderActions={trailingHeaderActions}
+            revisionKey={item.revisionKey}
           />
           )
         })}
@@ -1128,6 +1487,9 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
   const [secao10InterativoFigura, setSecao10InterativoFigura] = useState(null)
   const [secao10InterativoFiguraComIndices, setSecao10InterativoFiguraComIndices] = useState(null)
   const [secao10InterativoSelecionado, setSecao10InterativoSelecionado] = useState('none')
+  const [secao10GraficoTransformacoes, setSecao10GraficoTransformacoes] = useState({})
+  const [secao10GraficosLazyCache, setSecao10GraficosLazyCache] = useState({})
+  const [secao10GraficosLazyLoading, setSecao10GraficosLazyLoading] = useState({})
   const [secao13InterativoFigura, setSecao13InterativoFigura] = useState(null)
   const [secao13InterativoFiguraComIndices, setSecao13InterativoFiguraComIndices] = useState(null)
   const [secao13InterativoSelecionado, setSecao13InterativoSelecionado] = useState('none')
@@ -1596,6 +1958,34 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     }
     return ''
   }, [origemTransformacoes])
+  function getSecao10PainelComCache(item, useIndices = false, options = {}) {
+    const config = getScatterTransformConfig(secao10GraficoTransformacoes, item?.label)
+    const cacheKey = buildScatterLazyCacheKey(item?.label, config)
+    const cached = secao10GraficosLazyCache[cacheKey]
+    const cachedFigure = useIndices ? cached?.grafico_com_indices : cached?.grafico
+    if (cachedFigure) {
+      const panels = buildScatterPanels(cachedFigure, {
+        singleLabel: 'Dispersão',
+        height: 360,
+        yLabel: colunaY || 'Y',
+        useScatterGlMarkers: Boolean(options.useScatterGlMarkers),
+      })
+      if (panels.length > 0) {
+        return {
+          ...rotularPainelDispersao(panels[0], config, colunaY || 'Y'),
+          id: item?.id || panels[0].id,
+          label: item?.label || panels[0].label,
+          title: item?.title || panels[0].title,
+          onRequestIndexedFigure: () => carregarSecao10GraficoLazy(item?.label || panels[0].label, config, true),
+        }
+      }
+    }
+    return {
+      ...aplicarTransformacoesPainelDispersao(item, config, colunaY || 'Y'),
+      onRequestIndexedFigure: () => carregarSecao10GraficoLazy(item?.label, config, true),
+    }
+  }
+
   const secao10ModoPng = useMemo(
     () => String(selection?.grafico_dispersao_modo || '') === 'png',
     [selection?.grafico_dispersao_modo],
@@ -1629,9 +2019,18 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     }),
     [selection?.grafico_dispersao_com_indices, colunaY],
   )
-  const graficosSecao9ComIndicesMap = useMemo(
-    () => buildScatterPanelFigureMap(graficosSecao9ComIndices),
-    [graficosSecao9ComIndices],
+  const graficosSecao9Transformados = useMemo(
+    () => graficosSecao9.map((item) => getSecao10PainelComCache(item)),
+    [graficosSecao9, secao10GraficoTransformacoes, secao10GraficosLazyCache, colunaY],
+  )
+  const graficosSecao9ComIndicesTransformados = useMemo(
+    () => (graficosSecao9ComIndices.length > 0 ? graficosSecao9ComIndices : graficosSecao9)
+      .map((item) => getSecao10PainelComCache(item, true)),
+    [graficosSecao9ComIndices, graficosSecao9, secao10GraficoTransformacoes, secao10GraficosLazyCache, colunaY],
+  )
+  const graficosSecao9ComIndicesTransformadosMap = useMemo(
+    () => buildScatterPanelFigureMap(graficosSecao9ComIndicesTransformados),
+    [graficosSecao9ComIndicesTransformados],
   )
   const graficosSecao9Interativo = useMemo(
     () => buildScatterPanels(secao10InterativoFigura, {
@@ -1651,9 +2050,18 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     }),
     [secao10InterativoFiguraComIndices, colunaY],
   )
-  const graficosSecao9InterativoComIndicesMap = useMemo(
-    () => buildScatterPanelFigureMap(graficosSecao9InterativoComIndices),
-    [graficosSecao9InterativoComIndices],
+  const graficosSecao9InterativoTransformados = useMemo(
+    () => graficosSecao9Interativo.map((item) => getSecao10PainelComCache(item, false, { useScatterGlMarkers: true })),
+    [graficosSecao9Interativo, secao10GraficoTransformacoes, secao10GraficosLazyCache, colunaY],
+  )
+  const graficosSecao9InterativoComIndicesTransformados = useMemo(
+    () => (graficosSecao9InterativoComIndices.length > 0 ? graficosSecao9InterativoComIndices : graficosSecao9Interativo)
+      .map((item) => getSecao10PainelComCache(item, true, { useScatterGlMarkers: true })),
+    [graficosSecao9InterativoComIndices, graficosSecao9Interativo, secao10GraficoTransformacoes, secao10GraficosLazyCache, colunaY],
+  )
+  const graficosSecao9InterativoComIndicesTransformadosMap = useMemo(
+    () => buildScatterPanelFigureMap(graficosSecao9InterativoComIndicesTransformados),
+    [graficosSecao9InterativoComIndicesTransformados],
   )
   const secao10InterativoOpcoes = useMemo(() => {
     const labels = graficosSecao9Interativo.length > 0
@@ -1662,9 +2070,9 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     return Array.from(new Set(labels))
   }, [graficosSecao9Interativo, selection?.contexto?.colunas_x, colunasX])
   const secao10InterativoAtual = useMemo(() => {
-    if (secao10InterativoSelecionado === 'none' || graficosSecao9Interativo.length === 0) return null
-    return graficosSecao9Interativo.find((item) => String(item.label || '') === secao10InterativoSelecionado) || graficosSecao9Interativo[0]
-  }, [graficosSecao9Interativo, secao10InterativoSelecionado])
+    if (secao10InterativoSelecionado === 'none' || graficosSecao9InterativoTransformados.length === 0) return null
+    return graficosSecao9InterativoTransformados.find((item) => String(item.label || '') === secao10InterativoSelecionado) || graficosSecao9InterativoTransformados[0]
+  }, [graficosSecao9InterativoTransformados, secao10InterativoSelecionado])
   const colunasOriginaisDispersao = useMemo(() => {
     const cols = Array.isArray(dados?.columns) ? dados.columns : []
     return cols
@@ -1807,6 +2215,12 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     }
   }, [modeloLoadSource])
 
+  useEffect(() => {
+    setSecao10GraficoTransformacoes({})
+    setSecao10GraficosLazyCache({})
+    setSecao10GraficosLazyLoading({})
+  }, [selection?.grafico_dispersao, selection?.grafico_dispersao_png])
+
   const onDisabledHintEnter = useCallback((event, showHint, hintText) => {
     if (!showHint || !hintText || typeof window === 'undefined') {
       setDisabledHint(null)
@@ -4215,6 +4629,71 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     }
   }
 
+  async function carregarSecao10GraficoLazy(label, config, includeIndices = true) {
+    const safeLabel = getScatterTransformKey(label)
+    if (!safeLabel || !sessionId) return null
+    const safeConfig = {
+      x: normalizarTransformacaoGrafico(config?.x),
+      y: normalizarTransformacaoGrafico(config?.y),
+    }
+    const cacheKey = buildScatterLazyCacheKey(safeLabel, safeConfig)
+    const cached = secao10GraficosLazyCache[cacheKey]
+    if (cached?.grafico && (!includeIndices || cached?.grafico_com_indices)) {
+      return includeIndices ? cached.grafico_com_indices : cached.grafico
+    }
+
+    setSecao10GraficosLazyLoading((prev) => ({ ...(prev || {}), [cacheKey]: true }))
+    try {
+      const resp = await api.getDispersaoInterativo(sessionId, 'secao10', {
+        coluna_x: safeLabel,
+        transformacao_x: safeConfig.x,
+        transformacao_y: safeConfig.y,
+      })
+      const nextEntry = {
+        grafico: resp?.grafico || null,
+        grafico_com_indices: resp?.grafico_com_indices || null,
+      }
+      setSecao10GraficosLazyCache((prev) => ({
+        ...(prev || {}),
+        [cacheKey]: nextEntry,
+      }))
+      return includeIndices ? nextEntry.grafico_com_indices : nextEntry.grafico
+    } catch (err) {
+      setError(err?.message || 'Falha ao carregar gráfico transformado.')
+      return null
+    } finally {
+      setSecao10GraficosLazyLoading((prev) => {
+        const next = { ...(prev || {}) }
+        delete next[cacheKey]
+        return next
+      })
+    }
+  }
+
+  const onChangeSecao10TransformacaoGrafico = useCallback((label, eixo, value) => {
+    const key = getScatterTransformKey(label)
+    if (!key) return
+    const axis = String(eixo || '').toLowerCase() === 'y' ? 'y' : 'x'
+    const nextValue = normalizarTransformacaoGrafico(value)
+    const current = getScatterTransformConfig(secao10GraficoTransformacoes, key)
+    const nextConfigToLoad = { ...current, [axis]: nextValue }
+    setSecao10GraficoTransformacoes((prev) => {
+      const current = getScatterTransformConfig(prev, key)
+      const nextConfig = { ...current, [axis]: nextValue }
+      const next = { ...(prev || {}) }
+      if (
+        nextConfig.x === TRANSFORMACAO_GRAFICO_PADRAO &&
+        nextConfig.y === TRANSFORMACAO_GRAFICO_PADRAO
+      ) {
+        delete next[key]
+      } else {
+        next[key] = nextConfig
+      }
+      return next
+    })
+    void carregarSecao10GraficoLazy(key, nextConfigToLoad, true)
+  }, [secao10GraficoTransformacoes, sessionId, secao10GraficosLazyCache])
+
   async function ensureSecao10GraficoComIndices() {
     const figuraAtual = selection?.grafico_dispersao_com_indices || null
     if (figuraAtual) {
@@ -5563,19 +6042,27 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                       <PlotFigure
                         key={`s9-interativo-plot-${secao10InterativoAtual.id}`}
                         figure={secao10InterativoAtual.figure}
-                        indexedFigure={graficosSecao9InterativoComIndicesMap.get(String(secao10InterativoAtual.label || '').trim()) || null}
-                        onRequestIndexedFigure={ensureSecao10GraficoComIndices}
+                        indexedFigure={graficosSecao9InterativoComIndicesTransformadosMap.get(String(secao10InterativoAtual.label || '').trim()) || null}
+                        onRequestIndexedFigure={secao10InterativoAtual.onRequestIndexedFigure || ensureSecao10GraficoComIndices}
                         title={secao10InterativoAtual.title}
                         subtitle={secao10InterativoAtual.subtitle}
                         showPointIndexToggle
                         forceHideLegend
                         className="plot-stretch"
                         lazy
+                        revisionKey={secao10InterativoAtual.revisionKey}
                         headerActions={(
-                          <button
-                            type="button"
-                            className="btn-download-subtle plot-card-download-btn"
-                            title={secao10InterativoAtual?.legenda || ''}
+                          <ScatterTransformControls
+                            label={secao10InterativoAtual.label}
+                            config={getScatterTransformConfig(secao10GraficoTransformacoes, secao10InterativoAtual.label)}
+                            onChange={onChangeSecao10TransformacaoGrafico}
+                            disabled={loading}
+                          />
+                        )}
+                        trailingHeaderActions={(
+                          <DownloadIconButton
+                            title={secao10InterativoAtual?.legenda || 'Fazer download'}
+                            ariaLabel={`Fazer download de ${secao10InterativoAtual?.legenda || secao10InterativoAtual?.label || 'gráfico'}`}
                             onClick={() => {
                               void onDownloadFigurePng(
                                 secao10InterativoAtual.figure,
@@ -5584,9 +6071,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                               )
                             }}
                             disabled={loading || downloadingAssets || !secao10InterativoAtual?.figure}
-                          >
-                            Fazer download
-                          </button>
+                          />
                         )}
                       />
                     ) : (
@@ -5597,16 +6082,32 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
               </>
             ) : (
               <>
-                {graficosSecao9.length > 0 ? (
+                {graficosSecao9Transformados.length > 0 ? (
                   <ScatterPlotCarousel
-                    items={graficosSecao9}
-                    indexedFigureMap={graficosSecao9ComIndicesMap}
+                    items={graficosSecao9Transformados}
+                    indexedFigureMap={graficosSecao9ComIndicesTransformadosMap}
                     onRequestIndexedFigure={ensureSecao10GraficoComIndices}
                     itemKeyPrefix="s9-plot"
                     sectionFilePrefix="secao10"
                     onDownloadFigure={onDownloadFigurePng}
+                    renderHeaderActions={({ item }) => (
+                      <ScatterTransformControls
+                        label={item.label}
+                        config={getScatterTransformConfig(secao10GraficoTransformacoes, item.label)}
+                        onChange={onChangeSecao10TransformacaoGrafico}
+                        disabled={loading}
+                      />
+                    )}
+                    renderTrailingHeaderActions={({ item, fileNameBase, downloadOptions }) => (
+                      <DownloadIconButton
+                        title={item.legenda || item.label || 'Fazer download'}
+                        ariaLabel={`Fazer download de ${item.legenda || item.label || 'gráfico'}`}
+                        onClick={() => onDownloadFigurePng(item.figure, fileNameBase, downloadOptions)}
+                        disabled={loading || downloadingAssets || !item.figure}
+                      />
+                    )}
                     onDownloadAll={() => onDownloadFiguresPngBatch(
-                      graficosSecao9.map((item, idx) => ({
+                      graficosSecao9Transformados.map((item, idx) => ({
                         figure: item.figure,
                         fileNameBase: `secao10_${sanitizeFileName(item.label, `dispersao_${idx + 1}`)}`,
                         forceHideLegend: true,
@@ -6077,11 +6578,10 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                         forceHideLegend
                         className="plot-stretch"
                         lazy
-                        headerActions={(
-                          <button
-                            type="button"
-                            className="btn-download-subtle plot-card-download-btn"
-                            title={secao13InterativoAtual?.legenda || ''}
+                        trailingHeaderActions={(
+                          <DownloadIconButton
+                            title={secao13InterativoAtual?.legenda || 'Fazer download'}
+                            ariaLabel={`Fazer download de ${secao13InterativoAtual?.legenda || secao13InterativoAtual?.label || 'gráfico'}`}
                             onClick={() => {
                               void onDownloadFigurePng(
                                 secao13InterativoAtual.figure,
@@ -6090,9 +6590,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                               )
                             }}
                             disabled={loading || downloadingAssets || !secao13InterativoAtual?.figure}
-                          >
-                            Fazer download
-                          </button>
+                          />
                         )}
                       />
                     ) : (
@@ -6132,8 +6630,8 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
             <div className="section14-tabs" role="tablist" aria-label="Conteúdos do diagnóstico do modelo">
               {[
                 { id: 'diagnosticos', label: 'Diagnósticos' },
-                { id: 'testes', label: 'Testes' },
-                { id: 'coeficientes', label: 'Coeficientes' },
+                { id: 'testes', label: 'Resultados Gerais' },
+                { id: 'coeficientes', label: 'Resultados por Variável' },
                 { id: 'equacoes', label: 'Equações' },
               ].map((tab) => (
                 <button
@@ -6181,7 +6679,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
               {section14Tab === 'coeficientes' ? (
                 <div className="section14-table-panel">
                   <div className="section14-table-head">
-                    <h4>Tabela de Coeficientes</h4>
+                    <h4>Resultados por Variável</h4>
                     <button
                       type="button"
                       className="btn-download-subtle"
@@ -6248,14 +6746,12 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                       alt={`${item.title} em PNG`}
                       className="plot-stretch"
                       headerActions={(
-                        <button
-                          type="button"
-                          className="btn-download-subtle plot-card-download-btn"
+                        <DownloadIconButton
+                          title={`Fazer download de ${item.title}`}
+                          ariaLabel={`Fazer download de ${item.title}`}
                           onClick={() => onDownloadPngBase64(item.pngPayload?.image_base64, item.pngPayload?.mime_type, fileNameBase)}
                           disabled={loading || downloadingAssets || !item.pngPayload?.image_base64}
-                        >
-                          Fazer download
-                        </button>
+                        />
                       )}
                     />
                   ) : (
@@ -6265,14 +6761,12 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                       className={item.className}
                       lazy
                       headerActions={(
-                        <button
-                          type="button"
-                          className="btn-download-subtle plot-card-download-btn"
+                        <DownloadIconButton
+                          title={`Fazer download de ${item.title}`}
+                          ariaLabel={`Fazer download de ${item.title}`}
                           onClick={() => onDownloadFigurePng(item.figure, fileNameBase)}
                           disabled={loading || downloadingAssets || !item.figure}
-                        >
-                          Fazer download
-                        </button>
+                        />
                       )}
                     />
                   )
@@ -6331,10 +6825,10 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                         forceHideLegend={secao15InterativoSelecionado === 'cook'}
                         className="plot-stretch"
                         lazy
-                        headerActions={(
-                          <button
-                            type="button"
-                            className="btn-download-subtle plot-card-download-btn"
+                        trailingHeaderActions={(
+                          <DownloadIconButton
+                            title={`Fazer download de ${secao15InterativoLabel}`}
+                            ariaLabel={`Fazer download de ${secao15InterativoLabel}`}
                             onClick={() => {
                               if (!secao15InterativoFigura) return
                               void onDownloadFigurePng(
@@ -6344,9 +6838,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                               )
                             }}
                             disabled={loading || downloadingAssets || !secao15InterativoFigura}
-                          >
-                            Fazer download
-                          </button>
+                          />
                         )}
                       />
                     ) : (

frontend/src/components/PesquisaTab.jsx

@@ -54,10 +54,10 @@ 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: 'metricas', label: 'Estatísticas' },
   { key: 'transformacoes', label: 'Transformações' },
-  { key: 'resumo', label: 'Resumo' },
-  { key: 'coeficientes', label: 'Coeficientes' },
+  { key: 'resumo', label: 'Resultados Gerais' },
+  { key: 'coeficientes', label: 'Resultados por variável' },
   { key: 'obs_calc', label: 'Obs x Calc' },
   { key: 'graficos', label: 'Gráficos' },
 ]
@@ -1898,7 +1898,7 @@ export default function PesquisaTab({
               ? (modeloAbertoLoadedTabs.dados_mercado ? <DataTable table={modeloAbertoDados} maxHeight={620} /> : <div className="empty-box">Carregando dados de mercado...</div>)
               : null}
             {modeloAbertoActiveTab === 'metricas'
-              ? (modeloAbertoLoadedTabs.metricas ? <DataTable table={modeloAbertoEstatisticas} maxHeight={620} /> : <div className="empty-box">Carregando métricas do modelo...</div>)
+              ? (modeloAbertoLoadedTabs.metricas ? <DataTable table={modeloAbertoEstatisticas} maxHeight={620} /> : <div className="empty-box">Carregando estatísticas do modelo...</div>)
               : null}
 
             {modeloAbertoActiveTab === 'transformacoes' ? (
@@ -1927,12 +1927,12 @@ export default function PesquisaTab({
                 <div dangerouslySetInnerHTML={{ __html: modeloAbertoResumoHtml }} />
               </>
               ) : (
-                <div className="empty-box">Carregando resumo do modelo...</div>
+                <div className="empty-box">Carregando resultados gerais do modelo...</div>
               )
             ) : null}
 
             {modeloAbertoActiveTab === 'coeficientes'
-              ? (modeloAbertoLoadedTabs.coeficientes ? <DataTable table={modeloAbertoCoeficientes} maxHeight={620} /> : <div className="empty-box">Carregando coeficientes do modelo...</div>)
+              ? (modeloAbertoLoadedTabs.coeficientes ? <DataTable table={modeloAbertoCoeficientes} maxHeight={620} /> : <div className="empty-box">Carregando resultados por variável do modelo...</div>)
               : null}
             {modeloAbertoActiveTab === 'obs_calc'
               ? (modeloAbertoLoadedTabs.obs_calc ? <DataTable table={modeloAbertoObsCalc} maxHeight={620} /> : <div className="empty-box">Carregando observados x calculados...</div>)

frontend/src/components/PlotFigure.jsx

@@ -13,6 +13,8 @@ function PlotFigure({
   lazy = false,
   showPointIndexToggle = false,
   headerActions = null,
+  trailingHeaderActions = null,
+  revisionKey = '',
 }) {
   const containerRef = useRef(null)
   const [shouldRenderPlot, setShouldRenderPlot] = useState(() => !lazy)
@@ -82,6 +84,7 @@ function PlotFigure({
   }
 
   const plotHeight = layout.height ? `${layout.height}px` : '100%'
+  const plotRevision = `${showPointIndices && hasIndexedFigure ? 'indices' : 'base'}:${String(revisionKey || '')}`
   const cardClassName = `plot-card ${className}`.trim()
 
   async function handleToggleChange(event) {
@@ -116,13 +119,14 @@ function PlotFigure({
 
   return (
     <div ref={containerRef} className={cardClassName}>
-      {title || subtitle || showPointIndexToggle || headerActions ? (
+      {title || subtitle || showPointIndexToggle || headerActions || trailingHeaderActions ? (
         <div className="plot-card-head">
           <div className="plot-card-head-main">
             {title ? <h4 className="plot-card-title">{title}</h4> : null}
             {subtitle ? <div className="plot-card-subtitle">{subtitle}</div> : null}
           </div>
           <div className="plot-card-head-actions">
+            {headerActions}
             {showPointIndexToggle ? (
               <label className={`plot-card-toggle${canToggleIndices ? '' : ' is-disabled'}`}>
                 <input
@@ -132,10 +136,10 @@ function PlotFigure({
                   onChange={handleToggleChange}
                   title={toggleTitle}
                 />
-                {loadingIndexedFigure ? 'Carregando índices...' : 'Exibir índices dos pontos'}
+                {loadingIndexedFigure ? 'Carregando...' : 'Índices'}
               </label>
             ) : null}
-            {headerActions}
+            {trailingHeaderActions}
           </div>
         </div>
       ) : null}
@@ -144,7 +148,7 @@ function PlotFigure({
           <Plot
             data={data}
             layout={layout}
-            revision={showPointIndices && hasIndexedFigure ? 1 : 0}
+            revision={plotRevision}
             config={{ responsive: true, displaylogo: false }}
             style={{ width: '100%', height: plotHeight, minHeight: '320px' }}
             useResizeHandler

frontend/src/components/RepositorioTab.jsx

@@ -19,10 +19,10 @@ 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: 'metricas', label: 'Estatísticas' },
   { key: 'transformacoes', label: 'Transformações' },
-  { key: 'resumo', label: 'Resumo' },
-  { key: 'coeficientes', label: 'Coeficientes' },
+  { key: 'resumo', label: 'Resultados Gerais' },
+  { key: 'coeficientes', label: 'Resultados por variável' },
   { key: 'obs_calc', label: 'Obs x Calc' },
   { key: 'graficos', label: 'Gráficos' },
 ]
@@ -117,13 +117,13 @@ function getModeloAbertoLoadingLabel(tabKey) {
     case 'dados_mercado':
       return 'Carregando dados de mercado...'
     case 'metricas':
-      return 'Carregando métricas do modelo...'
+      return 'Carregando estatísticas do modelo...'
     case 'transformacoes':
       return 'Carregando transformações do modelo...'
     case 'resumo':
-      return 'Carregando resumo do modelo...'
+      return 'Carregando resultados gerais do modelo...'
     case 'coeficientes':
-      return 'Carregando coeficientes do modelo...'
+      return 'Carregando resultados por variável do modelo...'
     case 'obs_calc':
       return 'Carregando observados x calculados...'
     case 'graficos':
@@ -711,7 +711,7 @@ export default function RepositorioTab({
               ? (activeTabLoaded ? <DataTable table={modeloAbertoDados} maxHeight={620} /> : <div className="empty-box">Carregando dados de mercado...</div>)
               : null}
             {modeloAbertoActiveTab === 'metricas'
-              ? (activeTabLoaded ? <DataTable table={modeloAbertoEstatisticas} maxHeight={620} /> : <div className="empty-box">Carregando métricas do modelo...</div>)
+              ? (activeTabLoaded ? <DataTable table={modeloAbertoEstatisticas} maxHeight={620} /> : <div className="empty-box">Carregando estatísticas do modelo...</div>)
               : null}
 
             {modeloAbertoActiveTab === 'transformacoes' ? (
@@ -740,12 +740,12 @@ export default function RepositorioTab({
                   <div dangerouslySetInnerHTML={{ __html: modeloAbertoResumoHtml }} />
                 </>
               ) : (
-                <div className="empty-box">Carregando resumo do modelo...</div>
+                <div className="empty-box">Carregando resultados gerais do modelo...</div>
               )
             ) : null}
 
             {modeloAbertoActiveTab === 'coeficientes'
-              ? (activeTabLoaded ? <DataTable table={modeloAbertoCoeficientes} maxHeight={620} /> : <div className="empty-box">Carregando coeficientes do modelo...</div>)
+              ? (activeTabLoaded ? <DataTable table={modeloAbertoCoeficientes} maxHeight={620} /> : <div className="empty-box">Carregando resultados por variável do modelo...</div>)
               : null}
             {modeloAbertoActiveTab === 'obs_calc'
               ? (activeTabLoaded ? <DataTable table={modeloAbertoObsCalc} maxHeight={620} /> : <div className="empty-box">Carregando observados x calculados...</div>)

frontend/src/components/TrabalhosTecnicosTab.jsx

@@ -5,6 +5,7 @@ import ListPagination from './ListPagination'
 import LoadingOverlay from './LoadingOverlay'
 import MapFrame from './MapFrame'
 import ShareLinkButton from './ShareLinkButton'
+import SinglePillAutocomplete from './SinglePillAutocomplete'
 import TruncatedCellContent from './TruncatedCellContent'
 
 const PAGE_SIZE = 50
@@ -46,8 +47,25 @@ function dedupeTextList(values) {
   return output
 }
 
+function normalizeLogradouroOption(item) {
+  if (typeof item === 'string') {
+    const text = String(item || '').trim()
+    return text ? { value: text, label: text } : null
+  }
+  if (!item || typeof item !== 'object') return null
+  const value = String(item.value ?? item.logradouro ?? '').trim()
+  if (!value) return null
+  const label = String(item.label ?? item.display_label ?? value).trim() || value
+  return {
+    value,
+    label,
+    secondary: String(item.secondary ?? '').trim(),
+  }
+}
+
 function listarProcessosSei(item) {
   const processosArray = dedupeTextList([
+    ...(Array.isArray(item?.processos_detalhados) ? item.processos_detalhados.map((processo) => processo?.numero) : []),
     ...(Array.isArray(item?.processos_sei) ? item.processos_sei : []),
     ...(Array.isArray(item?.processos_administrativos) ? item.processos_administrativos : []),
   ])
@@ -64,12 +82,88 @@ function listarProcessosSei(item) {
   return ['Nenhum registrado']
 }
 
+function listarProcessosDetalhados(item) {
+  const detalhes = []
+  const vistos = new Set()
+  ;(Array.isArray(item?.processos_detalhados) ? item.processos_detalhados : []).forEach((processo) => {
+    const numero = String(processo?.numero || processo?.processo || '').trim()
+    const key = numero.toLowerCase()
+    if (!numero || vistos.has(key)) return
+    vistos.add(key)
+    detalhes.push({
+      numero,
+      link: String(processo?.link || processo?.href || '').trim(),
+    })
+  })
+  listarProcessosSei(item).forEach((processo) => {
+    const numero = String(processo || '').trim()
+    const key = numero.toLowerCase()
+    if (!numero || numero === 'Nenhum registrado' || vistos.has(key)) return
+    vistos.add(key)
+    detalhes.push({ numero, link: '' })
+  })
+  return detalhes.length ? detalhes : [{ numero: 'Nenhum registrado', link: '' }]
+}
+
+function normalizarHrefExterno(value) {
+  const text = String(value || '').trim()
+  if (!text) return ''
+  if (/^(https?:|mailto:|file:)/i.test(text)) return text
+  if (/^\\\\/.test(text)) {
+    return `file://${text.replace(/^\\\\+/, '').replace(/\\/g, '/')}`
+  }
+  if (/^[A-Za-z]:\\/.test(text)) {
+    return `file:///${text.replace(/\\/g, '/')}`
+  }
+  return text
+}
+
 function formatarCoordenada(value) {
   const number = Number(value)
   if (!Number.isFinite(number)) return 'Nao informada'
   return number.toLocaleString('pt-BR', { maximumFractionDigits: 6 })
 }
 
+function listarCoordenadasImoveis(imoveis) {
+  const seen = new Set()
+  const coordenadas = []
+  ;(Array.isArray(imoveis) ? imoveis : []).forEach((item) => {
+    const x = Number(item?.coord_x)
+    const y = Number(item?.coord_y)
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return
+    const key = `${x.toFixed(8)}|${y.toFixed(8)}`
+    if (seen.has(key)) return
+    seen.add(key)
+    coordenadas.push(`X ${formatarCoordenada(x)} | Y ${formatarCoordenada(y)}`)
+  })
+  return coordenadas
+}
+
+function formatarEnderecoImovel(item) {
+  const endereco = String(item?.endereco || '').trim()
+  const numero = String(item?.numero || '').trim()
+  const texto = [endereco, numero].filter(Boolean).join(', ').trim()
+  return texto || String(item?.label || '').trim() || 'Endereço não informado'
+}
+
+function formatarEnderecoImovelEditavel(item) {
+  const endereco = String(item?.endereco || '').trim()
+  const numero = String(item?.numero || '').trim()
+  const texto = [endereco, numero].filter(Boolean).join(', ').trim()
+  return texto || String(item?.label || '').trim()
+}
+
+function primeiraCoordenadaValida(imoveis) {
+  const item = (Array.isArray(imoveis) ? imoveis : []).find((imovel) => (
+    Number.isFinite(Number(imovel?.coord_x)) && Number.isFinite(Number(imovel?.coord_y))
+  ))
+  if (!item) return { coord_x: '', coord_y: '' }
+  return {
+    coord_x: item.coord_x ?? '',
+    coord_y: item.coord_y ?? '',
+  }
+}
+
 function parseNullableNumber(value) {
   const text = String(value ?? '').replace(',', '.').trim()
   if (!text) return null
@@ -109,6 +203,8 @@ function buildCadastroState() {
     tipo_codigo: '',
     ano: '',
     processos_sei_text: '',
+    coord_x: '',
+    coord_y: '',
     modelos: [],
     imoveis: [buildEmptyImovel('novo-trabalho', 1)],
   }
@@ -130,31 +226,36 @@ function buildEditState(trabalho) {
     : [
         buildEmptyImovel(trabalho?.id || 'trabalho', 1),
       ]
+  const coordenadas = primeiraCoordenadaValida(imoveis)
 
   return {
     nome: String(trabalho?.nome || '').trim(),
     tipo_codigo: String(trabalho?.tipo_codigo || '').trim().toUpperCase(),
     ano: trabalho?.ano ?? '',
     processos_sei_text: listarProcessosSei(trabalho).filter((value) => value !== 'Nenhum registrado').join('\n'),
+    coord_x: coordenadas.coord_x,
+    coord_y: coordenadas.coord_y,
     modelos,
     imoveis,
   }
 }
 
 function buildTrabalhoPayload(edicao) {
+  const imoveisBase = Array.isArray(edicao.imoveis) ? edicao.imoveis : []
+  const imoveisPayload = (imoveisBase.length ? imoveisBase : [buildEmptyImovel('trabalho', 1)]).map((item, index) => ({
+    label: item.label,
+    endereco: item.endereco,
+    numero: item.numero,
+    coord_x: index === 0 ? parseNullableNumber(edicao.coord_x) : parseNullableNumber(item.coord_x),
+    coord_y: index === 0 ? parseNullableNumber(edicao.coord_y) : parseNullableNumber(item.coord_y),
+  }))
   return {
     nome: edicao.nome,
     tipo_codigo: edicao.tipo_codigo,
     ano: parseNullableInt(edicao.ano),
     processos_sei: splitTextareaLines(edicao.processos_sei_text),
     modelos: dedupeTextList(edicao.modelos),
-    imoveis: (Array.isArray(edicao.imoveis) ? edicao.imoveis : []).map((item) => ({
-      label: item.label,
-      endereco: item.endereco,
-      numero: item.numero,
-      coord_x: parseNullableNumber(item.coord_x),
-      coord_y: parseNullableNumber(item.coord_y),
-    })),
+    imoveis: imoveisPayload,
   }
 }
 
@@ -164,11 +265,16 @@ function toListItemFromDetail(trabalho) {
   return {
     id: String(trabalho?.id || ''),
     nome: String(trabalho?.nome || '').trim(),
+    pasta_nome: String(trabalho?.pasta_nome || '').trim(),
+    pasta_link: String(trabalho?.pasta_link || '').trim(),
     tipo_codigo: String(trabalho?.tipo_codigo || '').trim(),
     tipo_label: String(trabalho?.tipo_label || '').trim(),
     ano: trabalho?.ano ?? '',
     endereco_resumo: String(trabalho?.endereco_resumo || '').trim(),
     modelo_resumo: String(trabalho?.modelo_resumo || '').trim(),
+    tecnico_resumo: String(trabalho?.tecnico_resumo || '').trim(),
+    processo_resumo: String(trabalho?.processo_resumo || '').trim(),
+    finalidade_processo_resumo: String(trabalho?.finalidade_processo_resumo || '').trim(),
     total_registros_planilha: Number(trabalho?.total_registros_planilha || 0),
     total_imoveis: Number(trabalho?.total_imoveis || 0),
     total_modelos: Number(trabalho?.total_modelos || 0),
@@ -176,6 +282,7 @@ function toListItemFromDetail(trabalho) {
     modelo_mesa_principal: modelosMesa[0]?.mesa_modelo_nome || null,
     tem_coordenadas: Boolean(trabalho?.tem_coordenadas),
     modelos,
+    processos_detalhados: Array.isArray(trabalho?.processos_detalhados) ? trabalho.processos_detalhados : [],
     processos_sei: listarProcessosSei(trabalho).filter((value) => value !== 'Nenhum registrado'),
   }
 }
@@ -221,6 +328,14 @@ export default function TrabalhosTecnicosTab({
   const [modeloDraft, setModeloDraft] = useState('')
   const [modeloSugestoesMesa, setModeloSugestoesMesa] = useState([])
   const [modeloSugestoesLoading, setModeloSugestoesLoading] = useState(false)
+  const [trabalhoGeoModo, setTrabalhoGeoModo] = useState('endereco')
+  const [trabalhoGeoInputs, setTrabalhoGeoInputs] = useState(EMPTY_LOCATION_INPUTS)
+  const [trabalhoGeoLoading, setTrabalhoGeoLoading] = useState(false)
+  const [trabalhoGeoError, setTrabalhoGeoError] = useState('')
+  const [trabalhoGeoStatus, setTrabalhoGeoStatus] = useState('')
+  const [trabalhoLogradouroOptions, setTrabalhoLogradouroOptions] = useState([])
+  const [trabalhoLogradouroOptionsLoading, setTrabalhoLogradouroOptionsLoading] = useState(false)
+  const [trabalhoLogradouroOptionsLoaded, setTrabalhoLogradouroOptionsLoaded] = useState(false)
   const [origemAbertura, setOrigemAbertura] = useState('lista')
   const [abrindoTrabalhoId, setAbrindoTrabalhoId] = useState('')
   const quickOpenHandledRef = useRef('')
@@ -487,6 +602,7 @@ export default function TrabalhosTecnicosTab({
     setCadastrando(false)
     setEdicao(null)
     setModeloDraft('')
+    limparFormularioTrabalhoGeo()
     if (options.syncRoute !== false && typeof onRouteChange === 'function') {
       onRouteChange({
         tab: 'trabalhos',
@@ -535,6 +651,7 @@ export default function TrabalhosTecnicosTab({
     })
     setEdicao(draft)
     setModeloDraft('')
+    limparFormularioTrabalhoGeo()
     setEdicaoErro('')
     setTrabalhoError('')
     setOrigemAbertura('lista')
@@ -568,6 +685,7 @@ export default function TrabalhosTecnicosTab({
     setEdicao(buildEditState(trabalhoAberto))
     setEdicaoErro('')
     setModeloDraft('')
+    limparFormularioTrabalhoGeo()
     setEditando(true)
     void carregarSugestoesModelosMesa()
   }
@@ -582,17 +700,117 @@ export default function TrabalhosTecnicosTab({
     setEdicao(null)
     setEdicaoErro('')
     setModeloDraft('')
+    limparFormularioTrabalhoGeo()
   }
 
   function atualizarCampoEdicao(chave, valor) {
     setEdicao((prev) => (prev ? { ...prev, [chave]: valor } : prev))
   }
 
-  function atualizarImovel(index, chave, valor) {
+  function limparFormularioTrabalhoGeo() {
+    setTrabalhoGeoModo('endereco')
+    setTrabalhoGeoInputs(EMPTY_LOCATION_INPUTS)
+    setTrabalhoGeoError('')
+    setTrabalhoGeoStatus('')
+  }
+
+  function atualizarCampoTrabalhoGeo(field, value) {
+    if (!field) return
+    setTrabalhoGeoInputs((prev) => ({ ...prev, [field]: value }))
+    setTrabalhoGeoError('')
+    setTrabalhoGeoStatus('')
+  }
+
+  async function carregarSugestoesLogradouroTrabalho() {
+    if (trabalhoLogradouroOptionsLoading || trabalhoLogradouroOptionsLoaded) return
+    setTrabalhoLogradouroOptionsLoading(true)
+    try {
+      const response = await api.pesquisarLogradourosEixos()
+      const opcoes = Array.isArray(response?.logradouros_eixos)
+        ? response.logradouros_eixos.map(normalizeLogradouroOption).filter(Boolean)
+        : []
+      setTrabalhoLogradouroOptions(opcoes)
+      setTrabalhoLogradouroOptionsLoaded(true)
+    } catch {
+      setTrabalhoLogradouroOptions([])
+    } finally {
+      setTrabalhoLogradouroOptionsLoading(false)
+    }
+  }
+
+  function aplicarCoordenadasTrabalho(lat, lon) {
     setEdicao((prev) => {
       if (!prev) return prev
+      return {
+        ...prev,
+        coord_x: Number.isFinite(Number(lon)) ? String(lon) : '',
+        coord_y: Number.isFinite(Number(lat)) ? String(lat) : '',
+      }
+    })
+  }
+
+  async function onResolverCoordenadasTrabalho() {
+    setTrabalhoGeoError('')
+    setTrabalhoGeoStatus('')
+    if (trabalhoGeoModo === 'coords') {
+      const lat = Number(trabalhoGeoInputs.latitude)
+      const lon = Number(trabalhoGeoInputs.longitude)
+      if (!Number.isFinite(lat) || !Number.isFinite(lon)) {
+        setTrabalhoGeoError('Informe latitude e longitude válidas.')
+        return
+      }
+    } else {
+      const logradouro = String(trabalhoGeoInputs.logradouro || '').trim()
+      const cdlogTexto = String(trabalhoGeoInputs.cdlog || '').trim()
+      const cdlog = cdlogTexto ? Number(cdlogTexto) : null
+      if (!logradouro && !(Number.isFinite(cdlog) && cdlog > 0)) {
+        setTrabalhoGeoError('Informe o logradouro ou um CDLOG válido.')
+        return
+      }
+      if (cdlogTexto && !(Number.isFinite(cdlog) && cdlog > 0)) {
+        setTrabalhoGeoError('Informe um CDLOG válido.')
+        return
+      }
+      const numero = Number(trabalhoGeoInputs.numero)
+      if (!Number.isFinite(numero) || numero <= 0) {
+        setTrabalhoGeoError('Informe um número válido.')
+        return
+      }
+    }
+
+    setTrabalhoGeoLoading(true)
+    try {
+      const response = await api.pesquisarLocalizacaoAvaliando({
+        latitude: trabalhoGeoModo === 'coords' ? Number(trabalhoGeoInputs.latitude) : null,
+        longitude: trabalhoGeoModo === 'coords' ? Number(trabalhoGeoInputs.longitude) : null,
+        logradouro: trabalhoGeoModo === 'endereco' ? String(trabalhoGeoInputs.logradouro || '').trim() : null,
+        numero: trabalhoGeoModo === 'endereco' ? Number(trabalhoGeoInputs.numero) : null,
+        cdlog: trabalhoGeoModo === 'endereco' && String(trabalhoGeoInputs.cdlog || '').trim()
+          ? Number(trabalhoGeoInputs.cdlog)
+          : null,
+      })
+      const lat = Number(response?.lat)
+      const lon = Number(response?.lon)
+      if (!Number.isFinite(lat) || !Number.isFinite(lon)) {
+        throw new Error('A localização retornada não possui coordenadas válidas.')
+      }
+      aplicarCoordenadasTrabalho(lat, lon)
+      setTrabalhoGeoStatus(response?.status || 'Coordenadas do trabalho técnico definidas.')
+    } catch (err) {
+      setTrabalhoGeoError(err.message || 'Falha ao localizar as coordenadas do trabalho técnico.')
+    } finally {
+      setTrabalhoGeoLoading(false)
+    }
+  }
+
+  function atualizarEnderecoImovel(index, valor) {
+    setEdicao((prev) => {
+      if (!prev) return prev
+      const endereco = String(valor || '')
       const proximosImoveis = prev.imoveis.map((item, itemIndex) => (
-        itemIndex === index ? { ...item, [chave]: valor } : item
+        itemIndex === index
+          ? { ...item, label: endereco, endereco, numero: '' }
+          : item
       ))
       return { ...prev, imoveis: proximosImoveis }
     })
@@ -714,6 +932,9 @@ export default function TrabalhosTecnicosTab({
       item?.endereco_resumo,
       item?.modelo_resumo,
       item?.modelo_mesa_principal,
+      item?.pasta_nome,
+      item?.tecnico_resumo,
+      item?.finalidade_processo_resumo,
       ...processosSei,
       ...(Array.isArray(item?.modelos) ? item.modelos.map((modelo) => modelo?.nome) : []),
     ]
@@ -769,7 +990,10 @@ export default function TrabalhosTecnicosTab({
     const modelos = Array.isArray(trabalhoAberto?.modelos) ? trabalhoAberto.modelos : []
     const modelosMesa = modelos.filter((item) => item?.disponivel_mesa)
     const imoveis = Array.isArray(trabalhoAberto?.imoveis) ? trabalhoAberto.imoveis : []
-    const processosSei = listarProcessosSei(trabalhoAberto)
+    const processosDetalhados = listarProcessosDetalhados(trabalhoAberto)
+    const coordenadasImoveis = listarCoordenadasImoveis(imoveis)
+    const pastaNome = String(trabalhoAberto?.pasta_nome || '').trim()
+    const pastaHref = normalizarHrefExterno(trabalhoAberto?.pasta_link)
     const shareHref = !isCadastro && trabalhoAberto?.id ? buildTrabalhoTecnicoLink(trabalhoAberto.id) : ''
 
     return (
@@ -828,48 +1052,64 @@ export default function TrabalhosTecnicosTab({
 
           <div className="trabalho-tecnico-summary-grid">
             <section className="trabalho-tecnico-card trabalho-tecnico-card-primary">
-              <h4>Dados Gerais</h4>
+              <h4>Resumo</h4>
               {!editando ? (
-                <>
-                  <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 className="trabalho-tecnico-meta-list trabalho-tecnico-meta-list-two-cols">
+                  <div className="trabalho-tecnico-meta-row">
+                    <span className="trabalho-tecnico-meta-label">Finalidade</span>
+                    <strong>{trabalhoAberto?.finalidade_processo_resumo || 'Não informada'}</strong>
+                  </div>
+                  <div className="trabalho-tecnico-meta-row">
+                    <span className="trabalho-tecnico-meta-label">Avaliador</span>
+                    <strong>{trabalhoAberto?.tecnico_resumo || 'Não informado'}</strong>
                   </div>
-                  <div className="trabalho-tecnico-meta-list">
-                    <div className="trabalho-tecnico-meta-row">
-                      <span className="trabalho-tecnico-meta-label">Endereços</span>
-                      <strong>{trabalhoAberto?.endereco_resumo || 'Não informado'}</strong>
+                  <div className="trabalho-tecnico-meta-row">
+                    <span className="trabalho-tecnico-meta-label">Ano</span>
+                    <strong>{trabalhoAberto?.ano || '-'}</strong>
+                  </div>
+                  <div className="trabalho-tecnico-meta-row trabalho-tecnico-meta-row-block">
+                    <span className="trabalho-tecnico-meta-label">Pasta</span>
+                    {pastaHref && pastaNome ? (
+                      <a className="trabalho-meta-link" href={pastaHref} target="_blank" rel="noreferrer">
+                        {pastaNome}
+                      </a>
+                    ) : (
+                      <strong>{pastaNome || 'Não informada'}</strong>
+                    )}
+                  </div>
+                  <div className="trabalho-tecnico-meta-row trabalho-tecnico-meta-row-block">
+                    <span className="trabalho-tecnico-meta-label">Processo</span>
+                    <div className="trabalho-link-list">
+                      {processosDetalhados.map((processo, index) => {
+                        const processoHref = normalizarHrefExterno(processo?.link)
+                        const processoNumero = String(processo?.numero || '').trim() || 'Nenhum registrado'
+                        return processoHref && processoNumero !== 'Nenhum registrado' ? (
+                          <a
+                            key={`${trabalhoAberto?.id || 'trabalho'}-processo-detalhe-${index + 1}`}
+                            className="trabalho-meta-link"
+                            href={processoHref}
+                            target="_blank"
+                            rel="noreferrer"
+                          >
+                            {processoNumero}
+                          </a>
+                        ) : (
+                          <strong key={`${trabalhoAberto?.id || 'trabalho'}-processo-detalhe-${index + 1}`}>
+                            {processoNumero}
+                          </strong>
+                        )
+                      })}
                     </div>
-                    <div className="trabalho-tecnico-meta-row trabalho-tecnico-meta-row-block">
-                      <span className="trabalho-tecnico-meta-label">Processos SEI</span>
-                      <div className="trabalho-processos-stack">
-                        {processosSei.map((processo, index) => (
-                          <span key={`${trabalhoAberto?.id || 'trabalho'}-processo-detalhe-${index + 1}`}>
-                            {processo}
-                          </span>
-                        ))}
-                      </div>
+                  </div>
+                  <div className="trabalho-tecnico-meta-row trabalho-tecnico-meta-row-block">
+                    <span className="trabalho-tecnico-meta-label">Coordenadas</span>
+                    <div className="trabalho-link-list trabalho-coordinates-list">
+                      {coordenadasImoveis.length ? coordenadasImoveis.map((coordenada, index) => (
+                        <strong key={`${trabalhoAberto?.id || 'trabalho'}-coord-${index + 1}`}>{coordenada}</strong>
+                      )) : <strong>Não informadas</strong>}
                     </div>
                   </div>
-                </>
+                </div>
               ) : (
                 <div className="trabalho-edit-grid">
                   <label className="trabalho-edit-field">
@@ -911,110 +1151,190 @@ export default function TrabalhosTecnicosTab({
                       rows={4}
                     />
                   </label>
-                </div>
-              )}
-            </section>
-
-            <section className="trabalho-tecnico-card">
-              <h4>Imóveis Vinculados</h4>
-              {!editando ? (
-                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>
-                        <span>{[item?.endereco, item?.numero].filter(Boolean).join(', ') || 'Endereço não informado'}</span>
-                        <span className="trabalho-imovel-coords">
-                          Coordenadas: X {formatarCoordenada(item?.coord_x)} | Y {formatarCoordenada(item?.coord_y)}
-                        </span>
-                        {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>
-                )
-              ) : (
-                <div className="trabalho-edit-imoveis-stack">
-                  {Array.isArray(edicao?.imoveis) ? edicao.imoveis.map((item, index) => (
-                    <div key={item.id || `${trabalhoAberto?.id || 'trabalho'}-imovel-edit-${index + 1}`} className="trabalho-edit-imovel-card">
-                      <div className="trabalho-edit-imovel-head">
-                        <strong>Imóvel {index + 1}</strong>
-                        <button
-                          type="button"
-                          className="trabalho-mini-action"
-                          onClick={() => removerImovel(index)}
-                          disabled={(edicao?.imoveis || []).length <= 1 || salvando}
-                        >
-                          Remover
-                        </button>
-                      </div>
-                      <div className="trabalho-edit-imovel-grid">
-                        <label className="trabalho-edit-field">
-                          Identificação
+                  <div className="trabalho-edit-field trabalho-edit-field-full trabalho-coordenadas-editor">
+                    <span>Coordenadas do trabalho</span>
+                    <div className="trabalho-coordenadas-current">
+                      <span>
+                        <strong>Longitude/X</strong>
+                        {formatarCoordenada(edicao?.coord_x)}
+                      </span>
+                      <span>
+                        <strong>Latitude/Y</strong>
+                        {formatarCoordenada(edicao?.coord_y)}
+                      </span>
+                    </div>
+                    {trabalhoGeoModo === 'coords' ? (
+                      <div className="pesquisa-localizacao-grid pesquisa-localizacao-grid-coords trabalho-coordenadas-grid">
+                        <label className="pesquisa-field">
+                          Forma de localização
+                          <select value={trabalhoGeoModo} onChange={(event) => setTrabalhoGeoModo(event.target.value)}>
+                            <option value="endereco">Endereço</option>
+                            <option value="coords">Coordenadas</option>
+                          </select>
+                        </label>
+                        <label className="pesquisa-field">
+                          Latitude
                           <input
-                            type="text"
-                            value={item.label}
-                            onChange={(event) => atualizarImovel(index, 'label', event.target.value)}
-                            autoComplete="off"
+                            type="number"
+                            step="any"
+                            value={trabalhoGeoInputs.latitude}
+                            onChange={(event) => atualizarCampoTrabalhoGeo('latitude', event.target.value)}
+                            placeholder="-30.000000"
                           />
                         </label>
-                        <label className="trabalho-edit-field">
-                          Número
+                        <label className="pesquisa-field">
+                          Longitude
                           <input
-                            type="text"
-                            value={item.numero}
-                            onChange={(event) => atualizarImovel(index, 'numero', event.target.value)}
-                            autoComplete="off"
+                            type="number"
+                            step="any"
+                            value={trabalhoGeoInputs.longitude}
+                            onChange={(event) => atualizarCampoTrabalhoGeo('longitude', event.target.value)}
+                            placeholder="-51.000000"
                           />
                         </label>
-                        <label className="trabalho-edit-field trabalho-edit-field-full">
-                          Endereço
+                        <div className="pesquisa-localizacao-actions-inline">
+                          <button
+                            type="button"
+                            className="pesquisa-localizacao-action pesquisa-localizacao-action-ok"
+                            onClick={() => void onResolverCoordenadasTrabalho()}
+                            disabled={trabalhoGeoLoading}
+                          >
+                            {trabalhoGeoLoading ? 'Definindo...' : 'Definir'}
+                          </button>
+                          <button
+                            type="button"
+                            className="pesquisa-localizacao-action pesquisa-localizacao-action-reset"
+                            onClick={limparFormularioTrabalhoGeo}
+                            disabled={trabalhoGeoLoading}
+                          >
+                            Limpar
+                          </button>
+                        </div>
+                      </div>
+                    ) : (
+                      <div className="pesquisa-localizacao-grid pesquisa-localizacao-grid-endereco trabalho-coordenadas-grid">
+                        <label className="pesquisa-field">
+                          Forma de localização
+                          <select value={trabalhoGeoModo} onChange={(event) => setTrabalhoGeoModo(event.target.value)}>
+                            <option value="endereco">Endereço</option>
+                            <option value="coords">Coordenadas</option>
+                          </select>
+                        </label>
+                        <label className="pesquisa-field">
+                          CDLOG
                           <input
-                            type="text"
-                            value={item.endereco}
-                            onChange={(event) => atualizarImovel(index, 'endereco', event.target.value)}
-                            autoComplete="off"
+                            type="number"
+                            value={trabalhoGeoInputs.cdlog}
+                            onChange={(event) => atualizarCampoTrabalhoGeo('cdlog', event.target.value)}
+                            placeholder="Opcional"
                           />
                         </label>
-                        <label className="trabalho-edit-field">
-                          Coordenada X
-                          <input
-                            type="text"
-                            value={item.coord_x}
-                            onChange={(event) => atualizarImovel(index, 'coord_x', event.target.value)}
-                            autoComplete="off"
+                        <label className="pesquisa-field pesquisa-localizacao-logradouro-field">
+                          Logradouro
+                          <SinglePillAutocomplete
+                            value={trabalhoGeoInputs.logradouro}
+                            onChange={(nextValue) => atualizarCampoTrabalhoGeo('logradouro', nextValue)}
+                            options={trabalhoLogradouroOptions}
+                            placeholder={trabalhoLogradouroOptionsLoading ? 'Carregando logradouros...' : 'Digite ou selecione um logradouro dos eixos'}
+                            panelTitle="Logradouros dos eixos"
+                            emptyMessage="Nenhum logradouro encontrado nos eixos."
+                            loading={trabalhoLogradouroOptionsLoading}
+                            onOpenChange={(open) => {
+                              if (open) void carregarSugestoesLogradouroTrabalho()
+                            }}
+                            inputName="logradouroEixosTrabalhoTecnico"
+                            inputAutoComplete="new-password"
                           />
                         </label>
-                        <label className="trabalho-edit-field">
-                          Coordenada Y
+                        <label className="pesquisa-field">
+                          Número
                           <input
-                            type="text"
-                            value={item.coord_y}
-                            onChange={(event) => atualizarImovel(index, 'coord_y', event.target.value)}
-                            autoComplete="off"
+                            type="number"
+                            value={trabalhoGeoInputs.numero}
+                            onChange={(event) => atualizarCampoTrabalhoGeo('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 onResolverCoordenadasTrabalho()}
+                            disabled={trabalhoGeoLoading}
+                          >
+                            {trabalhoGeoLoading ? 'Buscando...' : 'Buscar'}
+                          </button>
+                          <button
+                            type="button"
+                            className="pesquisa-localizacao-action pesquisa-localizacao-action-reset"
+                            onClick={limparFormularioTrabalhoGeo}
+                            disabled={trabalhoGeoLoading}
+                          >
+                            Limpar
+                          </button>
+                        </div>
                       </div>
-                    </div>
-                  )) : null}
-                  <button
-                    type="button"
-                    className="trabalho-mini-action trabalho-mini-action-add"
-                    onClick={adicionarImovel}
-                    disabled={salvando}
-                  >
-                    Adicionar imóvel
-                  </button>
+                    )}
+                    {trabalhoGeoStatus ? <div className="status-line">{trabalhoGeoStatus}</div> : null}
+                    {trabalhoGeoError ? <div className="error-line inline-error">{trabalhoGeoError}</div> : null}
+                  </div>
                 </div>
               )}
             </section>
           </div>
 
+          <section className="trabalho-tecnico-card">
+            <h4>Imóveis</h4>
+            {!editando ? (
+              imoveis.length ? (
+                <div className="trabalho-imoveis-stack">
+                  {imoveis.map((item, index) => (
+                    <div key={`${trabalhoAberto?.id || 'trabalho'}-imovel-${index + 1}`} className="trabalho-imovel-card">
+                      <strong className="trabalho-imovel-address">{formatarEnderecoImovel(item)}</strong>
+                    </div>
+                  ))}
+                </div>
+              ) : (
+                <div className="section1-empty-hint">Nenhum imóvel vinculado.</div>
+              )
+            ) : (
+              <div className="trabalho-edit-imoveis-stack">
+                {Array.isArray(edicao?.imoveis) ? edicao.imoveis.map((item, index) => (
+                  <div key={item.id || `${trabalhoAberto?.id || 'trabalho'}-imovel-edit-${index + 1}`} className="trabalho-edit-imovel-card">
+                    <div className="trabalho-edit-imovel-head">
+                      <strong>Imóvel {index + 1}</strong>
+                      <button
+                        type="button"
+                        className="trabalho-mini-action"
+                        onClick={() => removerImovel(index)}
+                        disabled={(edicao?.imoveis || []).length <= 1 || salvando}
+                      >
+                        Remover
+                      </button>
+                    </div>
+                    <label className="trabalho-edit-field">
+                      Endereço
+                      <input
+                        type="text"
+                        value={formatarEnderecoImovelEditavel(item)}
+                        onChange={(event) => atualizarEnderecoImovel(index, event.target.value)}
+                        autoComplete="off"
+                      />
+                    </label>
+                  </div>
+                )) : null}
+                <button
+                  type="button"
+                  className="trabalho-mini-action trabalho-mini-action-add"
+                  onClick={adicionarImovel}
+                  disabled={salvando}
+                >
+                  Adicionar imóvel
+                </button>
+              </div>
+            )}
+          </section>
+
           <section className="trabalho-tecnico-card">
             <h4>Modelos associados</h4>
             {!editando ? (
@@ -1161,7 +1481,7 @@ export default function TrabalhosTecnicosTab({
                   type="text"
                   value={filtroTexto}
                   onChange={(event) => setFiltroTexto(event.target.value)}
-                  placeholder="nome, endereço, modelo ou processo"
+                  placeholder="nome, imóvel, modelo ou processo"
                   autoComplete="off"
                 />
               </label>
@@ -1207,7 +1527,7 @@ export default function TrabalhosTecnicosTab({
                     <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-endereco">Imóveis</th>
                     <th className="trabalhos-col-modelos">Modelos</th>
                     <th className="trabalhos-col-processos">Processos SEI</th>
                     <th className="repo-col-open">Abrir</th>
@@ -1252,14 +1572,24 @@ export default function TrabalhosTecnicosTab({
                       </td>
                       <td className="trabalhos-col-processos">
                         <div className="trabalho-model-stack">
-                          {listarProcessosSei(item).map((processo, index) => (
-                            <div
-                              key={`${item?.id || 'trabalho'}-processo-${index + 1}`}
-                              className="trabalho-model-list-item"
-                            >
-                              {processo}
-                            </div>
-                          ))}
+                          {listarProcessosDetalhados(item).map((processo, index) => {
+                            const processoHref = normalizarHrefExterno(processo?.link)
+                            const processoNumero = String(processo?.numero || '').trim() || 'Nenhum registrado'
+                            return (
+                              <div
+                                key={`${item?.id || 'trabalho'}-processo-${index + 1}`}
+                                className="trabalho-model-list-item"
+                              >
+                                {processoHref && processoNumero !== 'Nenhum registrado' ? (
+                                  <a className="trabalho-model-inline-link" href={processoHref} target="_blank" rel="noreferrer">
+                                    {processoNumero}
+                                  </a>
+                                ) : (
+                                  processoNumero
+                                )}
+                              </div>
+                            )
+                          })}
                         </div>
                       </td>
                       <td className="repo-col-open">
@@ -1306,7 +1636,7 @@ export default function TrabalhosTecnicosTab({
                     type="text"
                     value={filtroTexto}
                     onChange={(event) => setFiltroTexto(event.target.value)}
-                    placeholder="nome, endereço, modelo ou processo"
+                        placeholder="nome, imóvel, modelo ou processo"
                     autoComplete="off"
                   />
                 </label>

frontend/src/components/VisualizacaoTab.jsx

@@ -1,877 +0,0 @@
-import React, { useEffect, useMemo, useRef, useState } from 'react'
-import { api, downloadBlob } from '../api'
-import DataTable from './DataTable'
-import EquationFormatsPanel from './EquationFormatsPanel'
-import LoadingOverlay from './LoadingOverlay'
-import MapFrame from './MapFrame'
-import PlotFigure from './PlotFigure'
-import SectionBlock from './SectionBlock'
-import SinglePillAutocomplete from './SinglePillAutocomplete'
-
-const INNER_TABS = [
-  { key: 'mapa', label: 'Mapa' },
-  { key: 'dados_mercado', label: 'Dados de Mercado' },
-  { key: 'metricas', label: 'Métricas' },
-  { key: 'transformacoes', label: 'Transformações' },
-  { key: 'resumo', label: 'Resumo' },
-  { key: 'coeficientes', label: 'Coeficientes' },
-  { key: 'obs_calc', label: 'Obs x Calc' },
-  { key: 'graficos', label: 'Gráficos' },
-  { key: 'avaliacao', label: 'Avaliação' },
-  { key: 'avaliacao_massa', label: 'Avaliação em Massa' },
-]
-const BASE_COMPARACAO_SEM_BASE = '__none__'
-const TRABALHOS_TECNICOS_MODELOS_PADRAO = 'selecionados_e_outras_versoes'
-const SECTION_TABS = new Set([
-  'mapa',
-  'dados_mercado',
-  'metricas',
-  'transformacoes',
-  'resumo',
-  'coeficientes',
-  'obs_calc',
-  'graficos',
-])
-
-function getVisualizacaoLoadingLabel(tabKey) {
-  switch (String(tabKey || '').trim()) {
-    case 'mapa':
-      return 'Carregando mapa do modelo...'
-    case 'dados_mercado':
-      return 'Carregando dados de mercado...'
-    case 'metricas':
-      return 'Carregando métricas do modelo...'
-    case 'transformacoes':
-      return 'Carregando transformações do modelo...'
-    case 'resumo':
-      return 'Carregando resumo do modelo...'
-    case 'coeficientes':
-      return 'Carregando coeficientes do modelo...'
-    case 'obs_calc':
-      return 'Carregando observados x calculados...'
-    case 'graficos':
-      return 'Carregando gráficos do modelo...'
-    default:
-      return 'Processando dados...'
-  }
-}
-
-export default function VisualizacaoTab({ sessionId }) {
-  const [loading, setLoading] = useState(false)
-  const [error, setError] = useState('')
-  const [status, setStatus] = useState('')
-  const [badgeHtml, setBadgeHtml] = useState('')
-  const [modeloCarregado, setModeloCarregado] = useState(false)
-
-  const [uploadedFile, setUploadedFile] = useState(null)
-  const [uploadDragOver, setUploadDragOver] = useState(false)
-  const [modeloLoadSource, setModeloLoadSource] = useState('')
-  const [repoModelos, setRepoModelos] = useState([])
-  const [repoModeloSelecionado, setRepoModeloSelecionado] = useState('')
-  const [repoModelosLoading, setRepoModelosLoading] = useState(false)
-  const [repoFonteModelos, setRepoFonteModelos] = useState('')
-
-  const [dados, setDados] = useState(null)
-  const [estatisticas, setEstatisticas] = useState(null)
-  const [escalasHtml, setEscalasHtml] = useState('')
-  const [dadosTransformados, setDadosTransformados] = useState(null)
-  const [resumoHtml, setResumoHtml] = useState('')
-  const [equacoes, setEquacoes] = useState(null)
-  const [coeficientes, setCoeficientes] = useState(null)
-  const [obsCalc, setObsCalc] = useState(null)
-
-  const [plotObsCalc, setPlotObsCalc] = useState(null)
-  const [plotResiduos, setPlotResiduos] = useState(null)
-  const [plotHistograma, setPlotHistograma] = useState(null)
-  const [plotCook, setPlotCook] = useState(null)
-  const [plotCorr, setPlotCorr] = useState(null)
-
-  const [mapaHtml, setMapaHtml] = useState('')
-  const [mapaPayload, setMapaPayload] = useState(null)
-  const [mapaChoices, setMapaChoices] = useState(['Visualização Padrão'])
-  const [mapaVar, setMapaVar] = useState('Visualização Padrão')
-  const [mapaTrabalhosTecnicosModelosModo, setMapaTrabalhosTecnicosModelosModo] = useState(TRABALHOS_TECNICOS_MODELOS_PADRAO)
-
-  const [camposAvaliacao, setCamposAvaliacao] = useState([])
-  const valoresAvaliacaoRef = useRef({})
-  const [avaliacaoFormVersion, setAvaliacaoFormVersion] = useState(0)
-  const [confirmarLimpezaAvaliacoes, setConfirmarLimpezaAvaliacoes] = useState(false)
-  const [resultadoAvaliacaoHtml, setResultadoAvaliacaoHtml] = useState('')
-  const [baseChoices, setBaseChoices] = useState([])
-  const [baseValue, setBaseValue] = useState('')
-
-  const [activeInnerTab, setActiveInnerTab] = useState('mapa')
-  const [loadedTabs, setLoadedTabs] = useState({})
-  const [loadingTabs, setLoadingTabs] = useState({})
-  const deleteConfirmTimersRef = useRef({})
-  const uploadInputRef = useRef(null)
-  const pendingTabRequestsRef = useRef({})
-  const modeloLoadVersionRef = useRef(0)
-  const temAvaliacoes = Array.isArray(baseChoices) && baseChoices.length > 0
-  const repoModeloOptions = useMemo(
-    () => (repoModelos || []).map((item) => ({
-      value: String(item?.id || ''),
-      label: String(item?.nome_modelo || item?.arquivo || item?.id || ''),
-      secondary: String(item?.arquivo || ''),
-    })).filter((item) => item.value && item.label),
-    [repoModelos],
-  )
-
-  function resetConteudoVisualizacao() {
-    pendingTabRequestsRef.current = {}
-    setModeloCarregado(false)
-    setDados(null)
-    setEstatisticas(null)
-    setEscalasHtml('')
-    setDadosTransformados(null)
-    setResumoHtml('')
-    setEquacoes(null)
-    setCoeficientes(null)
-    setObsCalc(null)
-
-    setPlotObsCalc(null)
-    setPlotResiduos(null)
-    setPlotHistograma(null)
-    setPlotCook(null)
-    setPlotCorr(null)
-
-    setMapaHtml('')
-    setMapaPayload(null)
-    setMapaChoices(['Visualização Padrão'])
-    setMapaVar('Visualização Padrão')
-    setMapaTrabalhosTecnicosModelosModo(TRABALHOS_TECNICOS_MODELOS_PADRAO)
-
-    setCamposAvaliacao([])
-    valoresAvaliacaoRef.current = {}
-    setAvaliacaoFormVersion((prev) => prev + 1)
-    setConfirmarLimpezaAvaliacoes(false)
-    setResultadoAvaliacaoHtml('')
-    setBaseChoices([])
-    setBaseValue('')
-
-    setActiveInnerTab('mapa')
-    setLoadedTabs({})
-    setLoadingTabs({})
-  }
-
-  function applyEvaluationContext(resp) {
-    setCamposAvaliacao(resp?.campos_avaliacao || [])
-    setEquacoes(resp?.equacoes || null)
-    const values = {}
-    ;(resp?.campos_avaliacao || []).forEach((campo) => {
-      values[campo.coluna] = ''
-    })
-    valoresAvaliacaoRef.current = values
-    setAvaliacaoFormVersion((prev) => prev + 1)
-    setConfirmarLimpezaAvaliacoes(false)
-    setResultadoAvaliacaoHtml('')
-    setBaseChoices([])
-    setBaseValue('')
-    setModeloCarregado(true)
-  }
-
-  function applyVisualizacaoSection(secao, resp) {
-    const key = String(secao || '').trim()
-    if (key === 'dados_mercado') {
-      setDados(resp?.dados || null)
-      return
-    }
-    if (key === 'metricas') {
-      setEstatisticas(resp?.estatisticas || null)
-      return
-    }
-    if (key === 'transformacoes') {
-      setEscalasHtml(resp?.escalas_html || '')
-      setDadosTransformados(resp?.dados_transformados || null)
-      return
-    }
-    if (key === 'resumo') {
-      setResumoHtml(resp?.resumo_html || '')
-      setEquacoes(resp?.equacoes || null)
-      return
-    }
-    if (key === 'coeficientes') {
-      setCoeficientes(resp?.coeficientes || null)
-      return
-    }
-    if (key === 'obs_calc') {
-      setObsCalc(resp?.obs_calc || null)
-      return
-    }
-    if (key === 'graficos') {
-      setPlotObsCalc(resp?.grafico_obs_calc || null)
-      setPlotResiduos(resp?.grafico_residuos || null)
-      setPlotHistograma(resp?.grafico_histograma || null)
-      setPlotCook(resp?.grafico_cook || null)
-      setPlotCorr(resp?.grafico_correlacao || null)
-      return
-    }
-    if (key === 'mapa') {
-      const nextChoices = Array.isArray(resp?.mapa_choices) && resp.mapa_choices.length
-        ? resp.mapa_choices
-        : ['Visualização Padrão']
-      setMapaHtml(resp?.mapa_html || '')
-      setMapaPayload(resp?.mapa_payload || null)
-      setMapaChoices(nextChoices)
-      setMapaVar((current) => (nextChoices.includes(current) ? current : 'Visualização Padrão'))
-      setMapaTrabalhosTecnicosModelosModo(resp?.trabalhos_tecnicos_modelos_modo || TRABALHOS_TECNICOS_MODELOS_PADRAO)
-    }
-  }
-
-  async function ensureVisualizacaoSection(secao, options = {}) {
-    const secaoNormalizada = String(secao || '').trim()
-    if (!sessionId || !SECTION_TABS.has(secaoNormalizada)) return
-    if (!options.force && loadedTabs[secaoNormalizada]) return
-    if (pendingTabRequestsRef.current[secaoNormalizada]) {
-      await pendingTabRequestsRef.current[secaoNormalizada]
-      return
-    }
-
-    const expectedVersion = options.expectedVersion ?? modeloLoadVersionRef.current
-    const trabalhosTecnicosModo = options.trabalhosTecnicosModelosModo || mapaTrabalhosTecnicosModelosModo
-    setLoadingTabs((prev) => ({ ...prev, [secaoNormalizada]: true }))
-
-    const request = (async () => {
-      try {
-        const resp = await api.visualizacaoSection(sessionId, secaoNormalizada, trabalhosTecnicosModo)
-        if (modeloLoadVersionRef.current !== expectedVersion) return
-        applyVisualizacaoSection(secaoNormalizada, resp)
-        setLoadedTabs((prev) => ({ ...prev, [secaoNormalizada]: true }))
-      } catch (err) {
-        if (modeloLoadVersionRef.current !== expectedVersion) return
-        setError(err.message || 'Falha ao carregar dados do modelo.')
-      } finally {
-        if (modeloLoadVersionRef.current !== expectedVersion) return
-        setLoadingTabs((prev) => ({ ...prev, [secaoNormalizada]: false }))
-      }
-    })()
-
-    pendingTabRequestsRef.current[secaoNormalizada] = request
-    try {
-      await request
-    } finally {
-      if (pendingTabRequestsRef.current[secaoNormalizada] === request) {
-        delete pendingTabRequestsRef.current[secaoNormalizada]
-      }
-    }
-  }
-
-  async function withBusy(fn) {
-    setLoading(true)
-    setError('')
-    try {
-      await fn()
-    } catch (err) {
-      setError(err.message)
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  function formatarFonteRepositorio(fonte) {
-    if (!fonte || typeof fonte !== 'object') return ''
-    const provider = String(fonte.provider || '').toLowerCase()
-    if (provider === 'hf_dataset') {
-      const repo = String(fonte.repo_id || '').trim()
-      const revision = String(fonte.revision || '').trim()
-      const degradado = Boolean(fonte.degraded)
-      const sufixo = degradado ? ' (modo contingência)' : ''
-      return `Fonte: HF Dataset${repo ? ` (${repo})` : ''}${revision ? ` | revisão ${revision.slice(0, 8)}` : ''}${sufixo}`
-    }
-    return 'Fonte: pasta local'
-  }
-
-  function aplicarRespostaModelosRepositorio(resp) {
-    const modelos = Array.isArray(resp?.modelos) ? resp.modelos : []
-    setRepoModelos(modelos)
-    setRepoFonteModelos(formatarFonteRepositorio(resp?.fonte || null))
-    setRepoModeloSelecionado((prev) => {
-      const atual = String(prev || '')
-      if (atual && modelos.some((item) => String(item.id) === atual)) return atual
-      return ''
-    })
-  }
-
-  async function carregarModelosRepositorio() {
-    setRepoModelosLoading(true)
-    try {
-      const resp = await api.visualizacaoRepositorioModelos()
-      aplicarRespostaModelosRepositorio(resp)
-    } catch (err) {
-      setError(err.message || 'Falha ao carregar modelos do repositório.')
-      setRepoModelos([])
-      setRepoModeloSelecionado('')
-      setRepoFonteModelos('')
-    } finally {
-      setRepoModelosLoading(false)
-    }
-  }
-
-  useEffect(() => {
-    let ativo = true
-    if (!sessionId) return () => {
-      ativo = false
-    }
-
-    setRepoModelosLoading(true)
-    api.visualizacaoRepositorioModelos()
-      .then((resp) => {
-        if (!ativo) return
-        aplicarRespostaModelosRepositorio(resp)
-      })
-      .catch(() => {
-        if (!ativo) return
-        setRepoModelos([])
-        setRepoModeloSelecionado('')
-        setRepoFonteModelos('')
-      })
-      .finally(() => {
-        if (!ativo) return
-        setRepoModelosLoading(false)
-      })
-
-    return () => {
-      ativo = false
-    }
-  }, [sessionId])
-
-  async function onUploadModel(arquivo = null) {
-    const arquivoUpload = arquivo || uploadedFile
-    if (!sessionId || !arquivoUpload) return
-    setModeloLoadSource('upload')
-    await withBusy(async () => {
-      resetConteudoVisualizacao()
-      modeloLoadVersionRef.current += 1
-      const openVersion = modeloLoadVersionRef.current
-      const uploadResp = await api.uploadVisualizacaoFile(sessionId, arquivoUpload)
-      if (modeloLoadVersionRef.current !== openVersion) return
-      setStatus(uploadResp.status || '')
-      setBadgeHtml(uploadResp.badge_html || '')
-      const contextoResp = await api.evaluationContextViz(sessionId)
-      if (modeloLoadVersionRef.current !== openVersion) return
-      applyEvaluationContext(contextoResp)
-      await ensureVisualizacaoSection('mapa', {
-        force: true,
-        expectedVersion: openVersion,
-        trabalhosTecnicosModelosModo: TRABALHOS_TECNICOS_MODELOS_PADRAO,
-      })
-    })
-  }
-
-  async function onCarregarModeloRepositorio() {
-    if (!sessionId || !repoModeloSelecionado) return
-    setModeloLoadSource('repo')
-    await withBusy(async () => {
-      resetConteudoVisualizacao()
-      modeloLoadVersionRef.current += 1
-      const openVersion = modeloLoadVersionRef.current
-      const uploadResp = await api.visualizacaoRepositorioCarregar(sessionId, repoModeloSelecionado)
-      if (modeloLoadVersionRef.current !== openVersion) return
-      setStatus(uploadResp.status || '')
-      setBadgeHtml(uploadResp.badge_html || '')
-      const contextoResp = await api.evaluationContextViz(sessionId)
-      if (modeloLoadVersionRef.current !== openVersion) return
-      applyEvaluationContext(contextoResp)
-      await ensureVisualizacaoSection('mapa', {
-        force: true,
-        expectedVersion: openVersion,
-        trabalhosTecnicosModelosModo: TRABALHOS_TECNICOS_MODELOS_PADRAO,
-      })
-      setUploadedFile(null)
-    })
-  }
-
-  function onUploadInputChange(event) {
-    const input = event.target
-    const file = input.files?.[0] ?? null
-    setModeloLoadSource('upload')
-    setUploadedFile(file)
-    input.value = ''
-    if (!file || loading) return
-    void onUploadModel(file)
-  }
-
-  function onUploadDropZoneDragOver(event) {
-    event.preventDefault()
-    event.dataTransfer.dropEffect = 'copy'
-    setUploadDragOver(true)
-  }
-
-  function onUploadDropZoneDragLeave(event) {
-    event.preventDefault()
-    if (!event.currentTarget.contains(event.relatedTarget)) {
-      setUploadDragOver(false)
-    }
-  }
-
-  function onUploadDropZoneDrop(event) {
-    event.preventDefault()
-    setUploadDragOver(false)
-    const file = event.dataTransfer?.files?.[0]
-    if (!file || loading) return
-    setModeloLoadSource('upload')
-    setUploadedFile(file)
-    void onUploadModel(file)
-  }
-
-  async function atualizarMapa(
-    variavelMapa = mapaVar,
-    trabalhosTecnicosModelosModo = mapaTrabalhosTecnicosModelosModo,
-  ) {
-    if (!sessionId) return
-    setLoadingTabs((prev) => ({ ...prev, mapa: true }))
-    try {
-      const resp = await api.updateVisualizacaoMap(sessionId, variavelMapa, trabalhosTecnicosModelosModo)
-      setMapaHtml(resp?.mapa_html || '')
-      setMapaPayload(resp?.mapa_payload || null)
-      setMapaTrabalhosTecnicosModelosModo(resp?.trabalhos_tecnicos_modelos_modo || trabalhosTecnicosModelosModo)
-      setLoadedTabs((prev) => ({ ...prev, mapa: true }))
-    } finally {
-      setLoadingTabs((prev) => ({ ...prev, mapa: false }))
-    }
-  }
-
-  async function onMapChange(value) {
-    setMapaVar(value)
-    await withBusy(async () => {
-      await atualizarMapa(value, mapaTrabalhosTecnicosModelosModo)
-    })
-  }
-
-  async function onMapTrabalhosTecnicosModeChange(value) {
-    setMapaTrabalhosTecnicosModelosModo(value)
-    await withBusy(async () => {
-      await atualizarMapa(mapaVar, value)
-    })
-  }
-
-  async function onCalcularAvaliacao() {
-    if (!sessionId) return
-    await withBusy(async () => {
-      const resp = await api.evaluationCalculateViz(sessionId, valoresAvaliacaoRef.current, baseValue || null)
-      setResultadoAvaliacaoHtml(resp.resultado_html || '')
-      setBaseChoices(resp.base_choices || [])
-      setBaseValue(resp.base_value || '')
-      setConfirmarLimpezaAvaliacoes(false)
-    })
-  }
-
-  function onResetCamposAvaliacao() {
-    const limpo = {}
-    camposAvaliacao.forEach((campo) => {
-      limpo[campo.coluna] = ''
-    })
-    valoresAvaliacaoRef.current = limpo
-    setAvaliacaoFormVersion((prev) => prev + 1)
-  }
-
-  async function onClearAvaliacao() {
-    if (!sessionId) return
-    await withBusy(async () => {
-      const resp = await api.evaluationClearViz(sessionId)
-      setResultadoAvaliacaoHtml(resp.resultado_html || '')
-      setBaseChoices(resp.base_choices || [])
-      setBaseValue(resp.base_value || '')
-      setConfirmarLimpezaAvaliacoes(false)
-    })
-  }
-
-  async function onDeleteAvaliacao(indice) {
-    if (!sessionId) return
-    await withBusy(async () => {
-      const resp = await api.evaluationDeleteViz(sessionId, indice ? String(indice) : null, baseValue || null)
-      setResultadoAvaliacaoHtml(resp.resultado_html || '')
-      setBaseChoices(resp.base_choices || [])
-      setBaseValue(resp.base_value || '')
-      setConfirmarLimpezaAvaliacoes(false)
-    })
-  }
-
-  function onAvaliacaoResultadoClick(event) {
-    const ativarExclusao = event.target.closest('[data-avaliacao-delete-arm]')
-    if (ativarExclusao) {
-      const indice = ativarExclusao.getAttribute('data-avaliacao-delete-index')
-      if (!indice) return
-
-      const cell = ativarExclusao.closest('td')
-      const botaoConfirmar = cell?.querySelector(`[data-avaliacao-delete-confirm="${indice}"]`)
-      if (!botaoConfirmar) return
-
-      ativarExclusao.style.display = 'none'
-      botaoConfirmar.style.display = 'inline-block'
-
-      const timerKey = String(indice)
-      if (deleteConfirmTimersRef.current[timerKey]) {
-        clearTimeout(deleteConfirmTimersRef.current[timerKey])
-      }
-      deleteConfirmTimersRef.current[timerKey] = window.setTimeout(() => {
-        botaoConfirmar.style.display = 'none'
-        ativarExclusao.style.display = 'inline'
-        delete deleteConfirmTimersRef.current[timerKey]
-      }, 10000)
-      return
-    }
-
-    const confirmarExclusao = event.target.closest('[data-avaliacao-delete-confirm]')
-    if (!confirmarExclusao) return
-    const indice = confirmarExclusao.getAttribute('data-avaliacao-delete-confirm')
-    if (!indice) return
-
-    const timerKey = String(indice)
-    if (deleteConfirmTimersRef.current[timerKey]) {
-      clearTimeout(deleteConfirmTimersRef.current[timerKey])
-      delete deleteConfirmTimersRef.current[timerKey]
-    }
-    onDeleteAvaliacao(indice)
-  }
-
-  async function onBaseChange(value) {
-    setBaseValue(value)
-    if (!sessionId) return
-    await withBusy(async () => {
-      const resp = await api.evaluationBaseViz(sessionId, value)
-      setResultadoAvaliacaoHtml(resp.resultado_html || '')
-    })
-  }
-
-  async function onExportAvaliacoes() {
-    if (!sessionId) return
-    await withBusy(async () => {
-      const blob = await api.exportEvaluationViz(sessionId)
-      downloadBlob(blob, 'avaliacoes_visualizacao.xlsx')
-    })
-  }
-
-  async function onDownloadEquacao(mode) {
-    if (!sessionId || !mode) return
-    await withBusy(async () => {
-      const blob = await api.exportEquationViz(sessionId, mode)
-      const sufixo = String(mode) === 'excel_sab' ? 'estilo_sab' : 'excel'
-      downloadBlob(blob, `equacao_modelo_${sufixo}.xlsx`)
-    })
-  }
-
-  function onInnerTabSelect(nextTab) {
-    setActiveInnerTab(nextTab)
-    if (SECTION_TABS.has(nextTab)) {
-      void ensureVisualizacaoSection(nextTab)
-    }
-  }
-
-  return (
-    <div className="tab-content">
-      <SectionBlock step="1" title="Carregar Modelo .dai" subtitle="Carregue o arquivo e o conteúdo será exibido automaticamente.">
-        {!modeloLoadSource ? (
-          <div className="model-source-choice-grid">
-            <button
-              type="button"
-              className="model-source-choice-btn model-source-choice-btn-primary"
-              onClick={() => setModeloLoadSource('repo')}
-              disabled={loading}
-            >
-              Carregar modelo do repositório
-            </button>
-            <button
-              type="button"
-              className="model-source-choice-btn model-source-choice-btn-secondary"
-              onClick={() => setModeloLoadSource('upload')}
-              disabled={loading}
-            >
-              Fazer upload de modelo
-            </button>
-          </div>
-        ) : (
-          <div className="model-source-flow">
-            <div className="model-source-flow-head">
-              <button
-                type="button"
-                className="model-source-back-btn"
-                onClick={() => setModeloLoadSource('')}
-                disabled={loading}
-              >
-                Voltar
-              </button>
-            </div>
-
-            {modeloLoadSource === 'repo' ? (
-              <div className="row upload-repo-row">
-                <label className="upload-repo-field">
-                  Modelo do repositório
-                  <SinglePillAutocomplete
-                    value={repoModeloSelecionado}
-                    onChange={setRepoModeloSelecionado}
-                    options={repoModeloOptions}
-                    placeholder={repoModelosLoading ? 'Carregando lista...' : repoModeloOptions.length > 0 ? 'Digite para buscar modelo' : 'Nenhum modelo disponível'}
-                    emptyMessage={repoModeloOptions.length > 0 ? 'Nenhum modelo encontrado.' : 'Nenhum modelo disponível.'}
-                    loading={repoModelosLoading}
-                    disabled={loading || repoModelosLoading || repoModeloOptions.length === 0}
-                  />
-                </label>
-                <div className="row compact upload-repo-actions">
-                  <button type="button" onClick={onCarregarModeloRepositorio} disabled={loading || repoModelosLoading || !repoModeloSelecionado}>
-                    Carregar do repositório
-                  </button>
-                  <button type="button" onClick={() => void carregarModelosRepositorio()} disabled={loading || repoModelosLoading}>
-                    Atualizar lista
-                  </button>
-                </div>
-                {repoFonteModelos ? <div className="section1-empty-hint">{repoFonteModelos}</div> : null}
-              </div>
-            ) : null}
-
-            {modeloLoadSource === 'upload' ? (
-              <div
-                className={`upload-dropzone${uploadDragOver ? ' is-dragover' : ''}`}
-                onDragOver={onUploadDropZoneDragOver}
-                onDragEnter={onUploadDropZoneDragOver}
-                onDragLeave={onUploadDropZoneDragLeave}
-                onDrop={onUploadDropZoneDrop}
-              >
-                <input
-                  ref={uploadInputRef}
-                  type="file"
-                  className="upload-hidden-input"
-                  accept=".dai"
-                  onChange={onUploadInputChange}
-                />
-                <div className="row upload-dropzone-main">
-                  <button
-                    type="button"
-                    className="btn-upload-select"
-                    onClick={() => uploadInputRef.current?.click()}
-                    disabled={loading}
-                  >
-                    Selecionar arquivo
-                  </button>
-                </div>
-                <div className="upload-dropzone-hint">Ou arraste e solte aqui para carregar automaticamente.</div>
-              </div>
-            ) : null}
-          </div>
-        )}
-        {status ? <div className="status-line">{status}</div> : null}
-        {badgeHtml ? <div className="upload-badge-block" dangerouslySetInnerHTML={{ __html: badgeHtml }} /> : null}
-      </SectionBlock>
-
-      {modeloCarregado ? (
-        <SectionBlock step="2" title="Conteúdo do Modelo" subtitle="Carregue o modelo no topo e navegue pelas abas internas abaixo.">
-          <div className="inner-tabs" role="tablist" aria-label="Abas internas de visualização">
-            {INNER_TABS.map((tab) => (
-              <button
-                key={tab.key}
-                type="button"
-                className={activeInnerTab === tab.key ? 'inner-tab-pill active' : 'inner-tab-pill'}
-                onClick={() => onInnerTabSelect(tab.key)}
-              >
-                {tab.label}
-              </button>
-            ))}
-          </div>
-
-          <div className="inner-tab-panel">
-            {activeInnerTab === 'mapa' ? (
-              !loadedTabs.mapa ? (
-                <div className="empty-box">Carregando mapa do modelo...</div>
-              ) : (
-                <>
-                <div className="row compact visualizacao-mapa-controls pesquisa-mapa-controls-row">
-                  <label className="pesquisa-field pesquisa-mapa-modo-field">
-                    Variável no mapa
-                    <select value={mapaVar} onChange={(e) => onMapChange(e.target.value)}>
-                      {mapaChoices.map((choice) => (
-                        <option key={choice} value={choice}>{choice}</option>
-                      ))}
-                    </select>
-                  </label>
-                  <label className="pesquisa-field pesquisa-mapa-trabalhos-field">
-                    Exibição dos trabalhos técnicos
-                    <select
-                      value={mapaTrabalhosTecnicosModelosModo === 'selecionados_e_anteriores'
-                        ? TRABALHOS_TECNICOS_MODELOS_PADRAO
-                        : mapaTrabalhosTecnicosModelosModo}
-                      onChange={(event) => void onMapTrabalhosTecnicosModeChange(event.target.value)}
-                      autoComplete="off"
-                    >
-                      <option value="selecionados">Somente deste modelo</option>
-                      <option value="selecionados_e_outras_versoes">Incluir demais versões do modelo</option>
-                    </select>
-                  </label>
-                </div>
-                <MapFrame html={mapaHtml} payload={mapaPayload} sessionId={sessionId} />
-              </>
-              )
-            ) : null}
-
-            {activeInnerTab === 'dados_mercado' ? (
-              loadedTabs.dados_mercado ? <DataTable table={dados} maxHeight={620} /> : <div className="empty-box">Carregando dados de mercado...</div>
-            ) : null}
-
-            {activeInnerTab === 'metricas' ? (
-              loadedTabs.metricas ? <DataTable table={estatisticas} maxHeight={620} /> : <div className="empty-box">Carregando métricas do modelo...</div>
-            ) : null}
-
-            {activeInnerTab === 'transformacoes' ? (
-              loadedTabs.transformacoes ? (
-                <>
-                <div dangerouslySetInnerHTML={{ __html: escalasHtml }} />
-                <h4 className="visualizacao-table-title">Dados com variáveis transformadas</h4>
-                <DataTable table={dadosTransformados} />
-              </>
-              ) : (
-                <div className="empty-box">Carregando transformações do modelo...</div>
-              )
-            ) : null}
-
-            {activeInnerTab === 'resumo' ? (
-              loadedTabs.resumo ? (
-                <>
-                <div className="equation-formats-section">
-                  <h4>Equações do Modelo</h4>
-                  <EquationFormatsPanel
-                    equacoes={equacoes}
-                    onDownload={(mode) => void onDownloadEquacao(mode)}
-                    disabled={loading}
-                  />
-                </div>
-                <div dangerouslySetInnerHTML={{ __html: resumoHtml }} />
-              </>
-              ) : (
-                <div className="empty-box">Carregando resumo do modelo...</div>
-              )
-            ) : null}
-
-            {activeInnerTab === 'coeficientes' ? (
-              loadedTabs.coeficientes ? <DataTable table={coeficientes} maxHeight={620} /> : <div className="empty-box">Carregando coeficientes do modelo...</div>
-            ) : null}
-
-            {activeInnerTab === 'obs_calc' ? (
-              loadedTabs.obs_calc ? <DataTable table={obsCalc} maxHeight={620} /> : <div className="empty-box">Carregando observados x calculados...</div>
-            ) : null}
-
-            {activeInnerTab === 'graficos' ? (
-              loadedTabs.graficos ? (
-                <>
-                <div className="plot-grid-2-fixed">
-                  <PlotFigure figure={plotObsCalc} title="Obs x Calc" />
-                  <PlotFigure figure={plotResiduos} title="Resíduos" />
-                  <PlotFigure figure={plotHistograma} title="Histograma" />
-                  <PlotFigure figure={plotCook} title="Cook" forceHideLegend />
-                </div>
-                <div className="plot-full-width">
-                  <PlotFigure figure={plotCorr} title="Correlação" className="plot-correlation-card" />
-                </div>
-              </>
-              ) : (
-                <div className="empty-box">Carregando gráficos do modelo...</div>
-              )
-            ) : null}
-
-            {activeInnerTab === 'avaliacao' ? (
-              <>
-                <div className="equation-formats-section avaliacao-equacao-section">
-                  <h5>Equação (estilo SAB)</h5>
-                  <div className="equation-box equation-box-plain">
-                    {equacoes?.excel_sab || 'Equação indisponível.'}
-                  </div>
-                </div>
-                <div className="avaliacao-groups">
-                  <div className="subpanel avaliacao-group">
-                    <h4>Parâmetros</h4>
-                    <div className="avaliacao-grid" key={`avaliacao-grid-viz-${avaliacaoFormVersion}`}>
-                      {camposAvaliacao.map((campo) => (
-                        <div key={`campo-${campo.coluna}`} className="avaliacao-card">
-                          <label>{String(campo?.rotulo || campo?.coluna || '')}</label>
-                          {campo.tipo === 'dicotomica' ? (
-                            <select
-                              defaultValue={String(valoresAvaliacaoRef.current[campo.coluna] ?? '')}
-                              onChange={(e) => {
-                                valoresAvaliacaoRef.current[campo.coluna] = e.target.value
-                              }}
-                            >
-                              <option value="">Selecione</option>
-                              {(campo.opcoes || [0, 1]).map((opcao) => (
-                                <option key={`op-viz-${campo.coluna}-${opcao}`} value={String(opcao)}>
-                                  {opcao}
-                                </option>
-                              ))}
-                            </select>
-                          ) : (
-                            <input
-                              type="number"
-                              defaultValue={valoresAvaliacaoRef.current[campo.coluna] ?? ''}
-                              placeholder={campo.placeholder || ''}
-                              onChange={(e) => {
-                                valoresAvaliacaoRef.current[campo.coluna] = e.target.value
-                              }}
-                            />
-                          )}
-                        </div>
-                      ))}
-                    </div>
-                    <div className="row-wrap avaliacao-actions-row">
-                      <button onClick={onCalcularAvaliacao} disabled={loading}>Calcular</button>
-                      <button onClick={onResetCamposAvaliacao} disabled={loading}>Resetar campos</button>
-                    </div>
-                  </div>
-
-                  {temAvaliacoes ? (
-                    <div className="subpanel avaliacao-group">
-                      <h4>Avaliações</h4>
-                      <div className="row avaliacao-base-row">
-                        <label>Base comparação</label>
-                        <select value={baseValue || ''} onChange={(e) => onBaseChange(e.target.value)}>
-                          <option value={BASE_COMPARACAO_SEM_BASE}>Sem base</option>
-                          {baseChoices.map((choice) => (
-                            <option key={`base-${choice}`} value={choice}>{choice}</option>
-                          ))}
-                        </select>
-                        <button type="button" className="btn-avaliacao-export" onClick={onExportAvaliacoes} disabled={loading}>
-                          Exportar avaliações
-                        </button>
-                        {!confirmarLimpezaAvaliacoes ? (
-                          <button
-                            type="button"
-                            className="btn-avaliacao-clear"
-                            onClick={() => setConfirmarLimpezaAvaliacoes(true)}
-                            disabled={loading}
-                          >
-                            Limpar avaliações
-                          </button>
-                        ) : (
-                          <div className="avaliacao-clear-confirm avaliacao-clear-confirm-inline">
-                            <span>Confirmar limpeza?</span>
-                            <button type="button" className="btn-avaliacao-clear" onClick={onClearAvaliacao} disabled={loading}>
-                              Confirmar
-                            </button>
-                            <button type="button" onClick={() => setConfirmarLimpezaAvaliacoes(false)} disabled={loading}>
-                              Cancelar
-                            </button>
-                          </div>
-                        )}
-                      </div>
-                      <div
-                        className="avaliacao-resultado-box"
-                        onClick={onAvaliacaoResultadoClick}
-                        dangerouslySetInnerHTML={{ __html: resultadoAvaliacaoHtml }}
-                      />
-                    </div>
-                  ) : null}
-                </div>
-              </>
-            ) : null}
-
-            {activeInnerTab === 'avaliacao_massa' ? (
-              <div className="empty-box">Módulo em desenvolvimento.</div>
-            ) : null}
-          </div>
-        </SectionBlock>
-      ) : null}
-
-      <LoadingOverlay
-        show={loading || Boolean(loadingTabs[activeInnerTab])}
-        label={loading ? 'Processando dados...' : getVisualizacaoLoadingLabel(activeInnerTab)}
-      />
-      {error ? <div className="error-line">{error}</div> : null}
-    </div>
-  )
-}

frontend/src/styles.css

@@ -410,6 +410,13 @@ textarea {
     align-items: flex-start;
     gap: 4px;
   }
+
+  .trabalho-tecnico-meta-row strong,
+  .trabalho-link-list,
+  .trabalho-meta-link {
+    justify-items: start;
+    text-align: left;
+  }
 }
 
 .repositorio-standalone-panel {
@@ -907,9 +914,8 @@ textarea {
 
 .trabalho-tecnico-summary-grid {
   display: grid;
-  grid-template-columns: repeat(2, minmax(0, 1fr));
+  grid-template-columns: minmax(0, 1fr);
   gap: 12px;
-  margin-bottom: 12px;
 }
 
 .trabalho-tecnico-card {
@@ -937,6 +943,25 @@ textarea {
   gap: 8px;
 }
 
+.trabalho-tecnico-meta-list-two-cols {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 14px 28px;
+}
+
+.trabalho-tecnico-meta-list-two-cols .trabalho-tecnico-meta-row {
+  display: grid;
+  justify-content: stretch;
+  align-items: start;
+  gap: 4px;
+}
+
+.trabalho-tecnico-meta-list-two-cols .trabalho-tecnico-meta-row strong,
+.trabalho-tecnico-meta-list-two-cols .trabalho-link-list,
+.trabalho-tecnico-meta-list-two-cols .trabalho-meta-link {
+  justify-items: start;
+  text-align: left;
+}
+
 .trabalho-tecnico-meta-row {
   display: flex;
   justify-content: space-between;
@@ -945,6 +970,10 @@ textarea {
   color: #344e65;
 }
 
+.trabalho-tecnico-meta-row strong {
+  text-align: right;
+}
+
 .trabalho-tecnico-meta-row-block {
   align-items: flex-start;
 }
@@ -963,6 +992,35 @@ textarea {
   line-height: 1.5;
 }
 
+.trabalho-link-list {
+  display: grid;
+  justify-items: end;
+  gap: 4px;
+  min-width: 0;
+  text-align: right;
+}
+
+.trabalho-meta-link {
+  color: #1f5d8d;
+  font-weight: 800;
+  line-height: 1.35;
+  text-align: right;
+  overflow-wrap: anywhere;
+  text-decoration: underline;
+  text-decoration-color: rgba(31, 93, 141, 0.28);
+  text-underline-offset: 2px;
+}
+
+.trabalho-meta-link:hover {
+  color: #164a72;
+  text-decoration-color: rgba(31, 93, 141, 0.58);
+}
+
+.trabalho-coordinates-list {
+  font-family: 'IBM Plex Mono', monospace;
+  font-size: 0.86rem;
+}
+
 .trabalho-tecnico-kpis {
   display: grid;
   grid-template-columns: repeat(5, minmax(0, 1fr));
@@ -1007,6 +1065,10 @@ textarea {
   line-height: 1.4;
 }
 
+.trabalho-imovel-address {
+  overflow-wrap: anywhere;
+}
+
 .trabalho-imovel-coords {
   font-family: 'IBM Plex Mono', monospace;
 }
@@ -1134,6 +1196,41 @@ textarea {
   resize: vertical;
 }
 
+.trabalho-coordenadas-editor {
+  border: 1px solid #dbe6f0;
+  border-radius: 10px;
+  background: #fbfdff;
+  padding: 12px;
+}
+
+.trabalho-coordenadas-current {
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+  color: #405a73;
+  font-size: 0.84rem;
+  font-weight: 600;
+}
+
+.trabalho-coordenadas-current span {
+  border: 1px solid #dce7f1;
+  border-radius: 8px;
+  background: #ffffff;
+  padding: 7px 9px;
+}
+
+.trabalho-coordenadas-current strong {
+  margin-right: 6px;
+  color: #6b849a;
+  font-size: 0.72rem;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.trabalho-coordenadas-grid {
+  margin: 2px 0 0;
+}
+
 .trabalho-edit-imoveis-stack {
   display: grid;
   gap: 10px;
@@ -1259,7 +1356,8 @@ textarea {
     padding-bottom: 0;
   }
 
-  .trabalho-tecnico-summary-grid {
+  .trabalho-tecnico-summary-grid,
+  .trabalho-tecnico-meta-list-two-cols {
     grid-template-columns: 1fr;
   }
 
@@ -6708,6 +6806,7 @@ button.import-preview-clear-btn {
   align-items: flex-start;
   justify-content: space-between;
   gap: 10px;
+  flex-wrap: wrap;
   position: relative;
   z-index: 2;
 }
@@ -6722,9 +6821,10 @@ button.import-preview-clear-btn {
   display: inline-flex;
   align-items: center;
   justify-content: flex-end;
-  gap: 8px;
+  gap: 12px;
   flex-wrap: wrap;
   flex-shrink: 0;
+  max-width: 100%;
 }
 
 .plot-card-download-btn {
@@ -6732,6 +6832,54 @@ button.import-preview-clear-btn {
   padding: 6px 9px;
 }
 
+.plot-card-download-icon-btn {
+  width: 32px;
+  height: 32px;
+  min-width: 32px;
+  padding: 0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.plot-card-download-icon {
+  width: 16px;
+  height: 16px;
+  display: block;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 2;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+.scatter-transform-controls {
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+.scatter-transform-field {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  color: #42586e;
+  font-size: 0.76rem;
+  font-weight: 800;
+  line-height: 1;
+}
+
+.scatter-transform-field select {
+  width: 92px;
+  min-width: 0;
+  height: 30px;
+  padding: 4px 22px 4px 7px;
+  border-radius: 8px;
+  font-size: 0.73rem;
+  font-weight: 700;
+}
+
 .plot-card-title {
   margin: 0;
   color: #2f465c;

release/hf-modelos-dai/modelos_dai_hf.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bcaa29d2cbb87cc57cce70efd5226eada2dc640b3c8f2896456d5a6dc370d52
+size 18436140

release/windows-gh/MesaFrame-portable-run-25354206310.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5de46c0ae3fcc170298bb556025686a1d491234f457abebf28dae4a56794c4f8
+size 158996901

repositorio_mesa_colunas_summary.json

@@ -0,0 +1,85 @@
+{
+  "repo_id": "gui-sparim/repositorio_mesa",
+  "output_xlsx": "/Users/guilhermesilberfarbcosta/Downloads/mesa-frame/repositorio_mesa_colunas.xlsx",
+  "summary_json": "/Users/guilhermesilberfarbcosta/Downloads/mesa-frame/repositorio_mesa_colunas_summary.json",
+  "tabular_files_found": 106,
+  "tabular_files_scanned": 106,
+  "tabular_files_skipped": 0,
+  "unique_columns": 14,
+  "models_found": 5,
+  "columns": [
+    "ts",
+    "event_id",
+    "scope",
+    "action",
+    "status",
+    "session_id",
+    "usuario",
+    "nome",
+    "perfil",
+    "details",
+    "path",
+    "method",
+    "ip",
+    "user_agent"
+  ],
+  "column_sources": {
+    "ts": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "event_id": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "scope": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "action": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "status": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "session_id": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "usuario": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "nome": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "perfil": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "details": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "path": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "method": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "ip": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    },
+    "user_agent": {
+      "model": "logs/auth",
+      "file": "logs/auth/2026/03/auth-2026-03-02.jsonl"
+    }
+  },
+  "skipped_files": []
+}

scan_hf_dai_columns.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import math
+import os
+import sys
+from collections import OrderedDict
+from pathlib import Path
+from typing import Any
+
+import joblib
+import pandas as pd
+from huggingface_hub import HfApi, hf_hub_download
+
+
+REPO_ID = "gui-sparim/repositorio_mesa"
+OUTPUT_XLSX = "repositorio_mesa_colunas_dai.xlsx"
+SUMMARY_JSON = "repositorio_mesa_colunas_dai_summary.json"
+
+
+def normalize_value(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, float) and math.isnan(value):
+        return None
+    try:
+        if pd.isna(value):
+            return None
+    except Exception:  # noqa: BLE001
+        pass
+    if isinstance(value, bytes):
+        value = value.decode("utf-8", errors="replace")
+    if isinstance(value, (dict, list, tuple, set)):
+        value = json.dumps(value, ensure_ascii=False)
+    text = str(value).strip()
+    return text or None
+
+
+def first_nonblank_samples(frame: pd.DataFrame, column: str, limit: int = 5) -> list[str]:
+    samples: list[str] = []
+    for value in frame[column].tolist():
+        normalized = normalize_value(value)
+        if normalized is not None:
+            samples.append(normalized)
+            if len(samples) >= limit:
+                break
+    return samples
+
+
+def walk_dataframes(node: Any, path: str = "root", seen: set[int] | None = None) -> list[tuple[str, pd.DataFrame]]:
+    if seen is None:
+        seen = set()
+
+    node_id = id(node)
+    if node_id in seen:
+        return []
+    seen.add(node_id)
+
+    results: list[tuple[str, pd.DataFrame]] = []
+    if isinstance(node, pd.DataFrame):
+        return [(path, node)]
+
+    if isinstance(node, dict):
+        for key, value in node.items():
+            results.extend(walk_dataframes(value, f"{path}.{key}", seen))
+        return results
+
+    if isinstance(node, (list, tuple)):
+        for index, value in enumerate(node):
+            results.extend(walk_dataframes(value, f"{path}[{index}]", seen))
+        return results
+
+    attrs = getattr(node, "__dict__", None)
+    if isinstance(attrs, dict):
+        for key, value in attrs.items():
+            results.extend(walk_dataframes(value, f"{path}.{key}", seen))
+
+    return results
+
+
+def main() -> None:
+    token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+    if not token:
+        raise SystemExit("HF_TOKEN or HUGGINGFACE_HUB_TOKEN is required.")
+
+    os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
+
+    api = HfApi(token=token)
+    tree = list(api.list_repo_tree(REPO_ID, repo_type="dataset", recursive=True, expand=False))
+    dai_files = sorted(
+        item.path
+        for item in tree
+        if getattr(item, "type", "file") == "file" and item.path.lower().endswith(".dai")
+    )
+
+    ordered_columns: OrderedDict[str, list[str]] = OrderedDict()
+    sources: OrderedDict[str, dict[str, str]] = OrderedDict()
+    dataframe_rows: list[dict[str, Any]] = []
+    scanned_files: list[str] = []
+    skipped_files: list[dict[str, str]] = []
+
+    for dai_path in dai_files:
+        print(f"Scanning {dai_path}...", file=sys.stderr)
+        try:
+            local_path = hf_hub_download(
+                repo_id=REPO_ID,
+                repo_type="dataset",
+                filename=dai_path,
+                token=token,
+            )
+            obj = joblib.load(local_path)
+            dataframes = walk_dataframes(obj)
+            scanned_files.append(dai_path)
+
+            for dataframe_path, frame in dataframes:
+                dataframe_rows.append(
+                    {
+                        "dai_file": dai_path,
+                        "dataframe_path": dataframe_path,
+                        "row_count": int(frame.shape[0]),
+                        "column_count": int(frame.shape[1]),
+                    }
+                )
+                for column in frame.columns:
+                    if column in ordered_columns:
+                        continue
+                    samples = first_nonblank_samples(frame, column)
+                    ordered_columns[column] = samples
+                    sources[column] = {
+                        "dai_file": dai_path,
+                        "dataframe_path": dataframe_path,
+                    }
+        except Exception as exc:  # noqa: BLE001
+            skipped_files.append({"dai_file": dai_path, "error": str(exc)})
+            print(f"Skipped {dai_path}: {exc}", file=sys.stderr)
+
+    if not ordered_columns:
+        raise SystemExit("No dataframe columns were extracted from the .dai files.")
+
+    workbook_data = {
+        column: ordered_columns[column] + [""] * (5 - len(ordered_columns[column]))
+        for column in ordered_columns
+    }
+    columns_df = pd.DataFrame(workbook_data)
+    origins_df = pd.DataFrame(
+        [
+            {
+                "column_name": column,
+                "first_seen_dai_file": source["dai_file"],
+                "first_seen_dataframe_path": source["dataframe_path"],
+                "sample_count": len(ordered_columns[column]),
+            }
+            for column, source in sources.items()
+        ]
+    )
+    dataframes_df = pd.DataFrame(dataframe_rows)
+    skipped_df = pd.DataFrame(skipped_files or [{"dai_file": "", "error": ""}])
+
+    output_path = Path(OUTPUT_XLSX).resolve()
+    summary_path = Path(SUMMARY_JSON).resolve()
+
+    with pd.ExcelWriter(output_path, engine="openpyxl") as writer:
+        columns_df.to_excel(writer, sheet_name="colunas", index=False)
+        origins_df.to_excel(writer, sheet_name="origem_colunas", index=False)
+        dataframes_df.to_excel(writer, sheet_name="dataframes_lidos", index=False)
+        skipped_df.to_excel(writer, sheet_name="arquivos_pulados", index=False)
+
+    summary = {
+        "repo_id": REPO_ID,
+        "output_xlsx": str(output_path),
+        "summary_json": str(summary_path),
+        "dai_files_found": len(dai_files),
+        "dai_files_scanned": len(scanned_files),
+        "dai_files_skipped": len(skipped_files),
+        "dataframes_found": len(dataframe_rows),
+        "unique_columns": len(ordered_columns),
+        "columns": list(ordered_columns.keys()),
+        "sources": sources,
+        "skipped_files": skipped_files,
+    }
+    summary_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()