Refine elaboracao and trabalhos tecnicos flows

backend/app/api/elaboracao.py

@@ -23,6 +23,14 @@ class ConfirmSheetPayload(SessionPayload):
     sheet_name: str
 
 
+class PastedTablePayload(SessionPayload):
+    pasted_text: str
+
+
+class ApplyImportColumnsPayload(SessionPayload):
+    colunas: list[str] = Field(default_factory=list)
+
+
 class MapCoordsPayload(SessionPayload):
     col_lat: str
     col_lon: str
@@ -213,6 +221,18 @@ def confirm_sheet(payload: ConfirmSheetPayload) -> dict[str, Any]:
     return elaboracao_service.load_uploaded_file(session, selected_sheet=payload.sheet_name)
 
 
+@router.post("/paste-table")
+def paste_table(payload: PastedTablePayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.load_pasted_table(session, payload.pasted_text)
+
+
+@router.post("/apply-import-columns")
+def apply_import_columns(payload: ApplyImportColumnsPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.apply_import_columns(session, payload.colunas)
+
+
 @router.post("/map-coords")
 def map_coords(payload: MapCoordsPayload) -> dict[str, Any]:
     session = session_store.get(payload.session_id)

backend/app/api/trabalhos_tecnicos.py

@@ -25,8 +25,7 @@ class TrabalhoImovelEdicaoPayload(BaseModel):
     modelos: list[str] | None = None
 
 
-class TrabalhoSalvarPayload(BaseModel):
-    trabalho_id: str
+class TrabalhoPayloadBase(BaseModel):
     nome: str | None = None
     tipo_codigo: str | None = None
     ano: int | None = None
@@ -35,6 +34,14 @@ class TrabalhoSalvarPayload(BaseModel):
     imoveis: list[TrabalhoImovelEdicaoPayload] | None = None
 
 
+class TrabalhoCadastrarPayload(TrabalhoPayloadBase):
+    pass
+
+
+class TrabalhoSalvarPayload(TrabalhoPayloadBase):
+    trabalho_id: str
+
+
 class TrabalhosMapaPayload(BaseModel):
     trabalhos_ids: list[str] | None = None
     modo_exibicao: str | None = None
@@ -109,3 +116,19 @@ def salvar_trabalho(payload: TrabalhoSalvarPayload, request: Request) -> dict[st
         details={"trabalho_id": payload.trabalho_id},
     )
     return resposta
+
+
+@router.post("/cadastrar")
+def cadastrar_trabalho(payload: TrabalhoCadastrarPayload, request: Request) -> dict[str, Any]:
+    user = auth_service.require_user(request)
+    resposta = trabalhos_tecnicos_service.cadastrar_trabalho_tecnico(payload.model_dump())
+    trabalho = resposta.get("trabalho") if isinstance(resposta, dict) else {}
+    log_event(
+        "trabalhos_tecnicos",
+        "cadastrar_trabalho",
+        user=user,
+        status="ok",
+        request=request,
+        details={"trabalho_id": trabalho.get("id") if isinstance(trabalho, dict) else None},
+    )
+    return resposta

backend/app/models/session.py

@@ -16,6 +16,7 @@ class SessionState:
     uploaded_filename: str | None = None
     available_sheets: list[str] = field(default_factory=list)
 
+    df_import_original: pd.DataFrame | None = None
     df_original: pd.DataFrame | None = None
     df_filtrado: pd.DataFrame | None = None
     df_geo_origem: pd.DataFrame | None = None

backend/app/services/elaboracao_service.py

@@ -1047,6 +1047,56 @@ def _set_dataframe_base(
     }
 
 
+def _build_import_preview(df: pd.DataFrame, max_rows: int = 15) -> dict[str, Any]:
+    total_rows = len(df.index)
+    total_columns = len(df.columns)
+    sample_size = min(max_rows, total_rows)
+    if sample_size > 0:
+        preview_df = df.sample(n=sample_size)
+    else:
+        preview_df = df.head(0)
+
+    rows: list[dict[str, Any]] = []
+    columns = [str(c) for c in df.columns]
+    for tuple_row in preview_df.itertuples(index=True, name=None):
+        row = {"_index": sanitize_value(tuple_row[0])}
+        for col, value in zip(columns, tuple_row[1:]):
+            row[col] = sanitize_value(value)
+        rows.append(row)
+
+    return {
+        "columns": columns,
+        "rows": rows,
+        "total_rows": total_rows,
+        "total_columns": total_columns,
+        "returned_rows": len(rows),
+    }
+
+
+def _set_import_pending_base(session: SessionState, df: pd.DataFrame) -> None:
+    session.df_import_original = df.copy()
+    session.df_original = None
+    session.df_filtrado = None
+    session.df_geo_origem = df.copy()
+    session.geo_falhas_df = None
+    session.geo_col_cdlog = None
+    session.geo_col_num = None
+    session.mapa_habilitado = False
+    session.reset_modelo()
+    session.coluna_y = None
+    session.tipo_y = None
+    session.coluna_area = None
+    session.colunas_x = []
+    session.dicotomicas = []
+    session.codigo_alocado = []
+    session.percentuais = []
+    session.outliers_anteriores = []
+    session.iteracao = 1
+    session.coluna_data_mercado = None
+    session.periodo_dados_mercado_inicio = None
+    session.periodo_dados_mercado_fim = None
+
+
 def save_uploaded_file(session: SessionState, filename: str, content: bytes) -> str:
     safe_name = os.path.basename(filename)
     destino = session.workdir / safe_name
@@ -1080,7 +1130,7 @@ def load_uploaded_file(session: SessionState, selected_sheet: str | None = None)
     if not sucesso or df is None:
         raise HTTPException(status_code=400, detail=msg)
 
-    base = _set_dataframe_base(session, df, clear_models=True)
+    _set_import_pending_base(session, df)
     sheet_selected_result = ""
     if selected_sheet is not None:
         sheet_selected_result = str(selected_sheet)
@@ -1089,8 +1139,60 @@ def load_uploaded_file(session: SessionState, selected_sheet: str | None = None)
     return {
         "status": msg,
         "requires_sheet": False,
+        "requires_column_selection": True,
         "sheets": [],
         "sheet_selected": sheet_selected_result,
+        "import_preview": _build_import_preview(df),
+        "contexto": _selection_context(session),
+    }
+
+
+def load_pasted_table(session: SessionState, pasted_text: str) -> dict[str, Any]:
+    texto = str(pasted_text or "").replace("\r\n", "\n").replace("\r", "\n").strip("\n")
+    if not texto.strip():
+        raise HTTPException(status_code=400, detail="Cole os dados copiados do Excel antes de carregar.")
+
+    linhas_validas = [linha for linha in texto.split("\n") if linha.strip()]
+    if len(linhas_validas) < 2:
+        raise HTTPException(status_code=400, detail="Cole pelo menos uma linha de cabeçalho e uma linha de dados.")
+
+    nome_arquivo = f"dados_colados_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+    save_uploaded_file(session, nome_arquivo, texto.encode("utf-8-sig"))
+    resposta = load_uploaded_file(session)
+    resposta["status"] = resposta.get("status") or "Dados colados carregados."
+    resposta["pasted_table"] = True
+    resposta["uploaded_filename"] = nome_arquivo
+    return resposta
+
+
+def apply_import_columns(session: SessionState, colunas: list[str]) -> dict[str, Any]:
+    df_origem = session.df_import_original
+    if df_origem is None:
+        df_origem = session.df_original
+    if df_origem is None:
+        raise HTTPException(status_code=400, detail="Carregue um arquivo tabular primeiro.")
+
+    disponiveis = {str(col): col for col in df_origem.columns}
+    selecionadas: list[str] = []
+    vistos: set[str] = set()
+    for item in colunas or []:
+        coluna = str(item or "").strip()
+        if not coluna or coluna in vistos or coluna not in disponiveis:
+            continue
+        selecionadas.append(coluna)
+        vistos.add(coluna)
+
+    if len(selecionadas) < 2:
+        raise HTTPException(status_code=400, detail="Selecione pelo menos 2 colunas para seguir.")
+
+    df_selecionado = df_origem.loc[:, [disponiveis[coluna] for coluna in selecionadas]].copy()
+    base = _set_dataframe_base(session, df_selecionado, clear_models=True)
+    session.df_import_original = df_origem.copy()
+
+    return {
+        "status": f"Seleção aplicada: {len(selecionadas)} colunas farão parte do modelo.",
+        "requires_column_selection": False,
+        "import_columns_selected": selecionadas,
         **base,
         "contexto": _selection_context(session),
     }

backend/app/services/trabalhos_tecnicos_service.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 from datetime import datetime, timezone
 import json
 import math
+import re
 import sqlite3
+import unicodedata
 from pathlib import Path
 from statistics import median
 from threading import Lock
@@ -42,6 +44,14 @@ _MODEL_MATCH_CACHE_CATALOGO: dict[str, dict[str, str]] = {}
 _MODEL_MATCH_CACHE_TRABALHOS: dict[str, set[str]] = {}
 
 
+def _clear_model_match_cache() -> None:
+    global _MODEL_MATCH_CACHE_SIGNATURE, _MODEL_MATCH_CACHE_CATALOGO, _MODEL_MATCH_CACHE_TRABALHOS
+    with _MODEL_MATCH_CACHE_LOCK:
+        _MODEL_MATCH_CACHE_SIGNATURE = None
+        _MODEL_MATCH_CACHE_CATALOGO = {}
+        _MODEL_MATCH_CACHE_TRABALHOS = {}
+
+
 def _connect_database(path: Path) -> sqlite3.Connection:
     conn = sqlite3.connect(str(path))
     conn.row_factory = sqlite3.Row
@@ -745,6 +755,246 @@ def _normalizar_edicao_payload(
     )
 
 
+def _slug_trabalho_fragment(value: Any) -> str:
+    texto = str(value or "").strip()
+    if not texto:
+        return ""
+    sem_acentos = unicodedata.normalize("NFKD", texto).encode("ascii", "ignore").decode("ascii")
+    slug = re.sub(r"[^A-Za-z0-9]+", "_", sem_acentos).strip("_")
+    return slug.upper()
+
+
+def _gerar_trabalho_id_unico(
+    conn: sqlite3.Connection,
+    nome: str,
+    tipo_codigo: str,
+    ano: int | None,
+) -> str:
+    partes = ["MANUAL", tipo_codigo, str(ano or ""), _slug_trabalho_fragment(nome)]
+    base = "_".join([parte for parte in partes if parte]).strip("_")
+    base = (base or "MANUAL_TRABALHO")[:96].rstrip("_") or "MANUAL_TRABALHO"
+
+    def existe(candidate: str) -> bool:
+        row = conn.execute(
+            "SELECT 1 FROM trabalhos WHERE LOWER(trabalho_id) = LOWER(?) LIMIT 1",
+            (candidate,),
+        ).fetchone()
+        if row is not None:
+            return True
+        _ensure_overrides_table(conn)
+        row = conn.execute(
+            "SELECT 1 FROM trabalho_edicoes WHERE LOWER(trabalho_id) = LOWER(?) LIMIT 1",
+            (candidate,),
+        ).fetchone()
+        return row is not None
+
+    candidate = base
+    suffix = 2
+    while existe(candidate):
+        suffix_text = f"_{suffix}"
+        candidate = f"{base[:96 - len(suffix_text)]}{suffix_text}"
+        suffix += 1
+    return candidate
+
+
+def _normalizar_imoveis_cadastro(values: Any, modelos_padrao: list[str]) -> list[dict[str, Any]]:
+    if not isinstance(values, list):
+        return []
+
+    filtrados: list[dict[str, Any]] = []
+    for raw in values:
+        if not isinstance(raw, dict):
+            continue
+        tem_texto = any(
+            str(raw.get(key) or "").strip()
+            for key in ("label", "endereco", "numero")
+        )
+        tem_coord = _to_float_or_none(raw.get("coord_x")) is not None or _to_float_or_none(raw.get("coord_y")) is not None
+        if tem_texto or tem_coord:
+            filtrados.append(raw)
+    return _normalizar_imoveis_edicao(filtrados, modelos_padrao)
+
+
+def _normalizar_cadastro_payload(
+    payload: dict[str, Any],
+    catalogo_modelos: dict[str, dict[str, str]],
+) -> dict[str, Any]:
+    nome = str(payload.get("nome") or "").strip()
+    if not nome:
+        raise HTTPException(status_code=400, detail="Informe o nome do trabalho tecnico.")
+
+    tipo_codigo = str(payload.get("tipo_codigo") or "").strip().upper()
+    if not tipo_codigo:
+        raise HTTPException(status_code=400, detail="Informe o tipo do trabalho tecnico.")
+    if tipo_codigo not in TIPO_LABELS:
+        raise HTTPException(status_code=400, detail="Selecione um tipo valido para o trabalho tecnico.")
+
+    ano = _to_int_or_none(payload.get("ano"))
+    processos_sei = _dedupe_text_list(payload.get("processos_sei"))
+    modelos = _dedupe_text_list(payload.get("modelos"))
+    imoveis = _normalizar_imoveis_cadastro(payload.get("imoveis"), modelos)
+    if not imoveis:
+        raise HTTPException(status_code=400, detail="Informe pelo menos um imovel vinculado ao trabalho tecnico.")
+
+    for imovel in imoveis:
+        modelos_imovel = _dedupe_text_list(imovel.get("modelos"))
+        imovel["modelos"] = modelos_imovel or list(modelos)
+
+    _enriquecer_modelos(modelos, catalogo_modelos)
+
+    return sanitize_value(
+        {
+            "nome": nome,
+            "tipo_codigo": tipo_codigo,
+            "ano": ano,
+            "processos_sei": processos_sei,
+            "modelos": modelos,
+            "imoveis": imoveis,
+        }
+    )
+
+
+def _inserir_trabalho_manual(
+    conn: sqlite3.Connection,
+    trabalho_id: str,
+    normalized: dict[str, Any],
+) -> None:
+    nome = str(normalized.get("nome") or "").strip()
+    tipo_codigo = str(normalized.get("tipo_codigo") or "").strip().upper()
+    ano = _to_int_or_none(normalized.get("ano"))
+    processos_sei = _dedupe_text_list(normalized.get("processos_sei"))
+    modelos = _dedupe_text_list(normalized.get("modelos"))
+    imoveis = list(normalized.get("imoveis") or [])
+    primeiro_imovel = imoveis[0] if imoveis else {}
+    endereco_resumo = _resumo_enderecos(imoveis) or "Endereco nao informado"
+    modelo_resumo = _resumo_modelos(modelos) or "Sem modelo informado"
+    tem_coordenadas = any(
+        _coordenada_valida(item.get("coord_x")) and _coordenada_valida(item.get("coord_y"))
+        for item in imoveis
+    )
+
+    registros: list[tuple[dict[str, Any], str | None, str | None]] = []
+    processos_registro = processos_sei or [None]
+    modelos_registro = modelos or [None]
+    for imovel in imoveis or [{}]:
+        for modelo_nome in modelos_registro:
+            for processo in processos_registro:
+                registros.append((imovel, modelo_nome, processo))
+
+    conn.execute(
+        """
+        INSERT INTO trabalhos (
+          trabalho_id,
+          nome,
+          nome_original,
+          codigo_trabalho,
+          nome_pasta,
+          tipo_codigo,
+          tipo_label,
+          ano,
+          endereco_principal,
+          numero_principal,
+          endereco_resumo,
+          modelo_resumo,
+          tecnico_resumo,
+          processo_resumo,
+          finalidade_processo_resumo,
+          total_registros,
+          total_imoveis,
+          total_modelos,
+          tem_coordenadas
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            trabalho_id,
+            nome,
+            nome,
+            None,
+            None,
+            tipo_codigo,
+            _tipo_label_from_codigo(tipo_codigo),
+            ano,
+            str(primeiro_imovel.get("endereco") or "").strip() or None,
+            str(primeiro_imovel.get("numero") or "").strip() or None,
+            endereco_resumo,
+            modelo_resumo,
+            None,
+            _resumo_textos(processos_sei, limite_inline=2) or None,
+            None,
+            max(1, len(registros)),
+            len(imoveis),
+            len(modelos),
+            1 if tem_coordenadas else 0,
+        ),
+    )
+
+    for ordem, modelo_nome in enumerate(modelos, start=1):
+        conn.execute(
+            "INSERT INTO trabalho_modelos (trabalho_id, modelo_nome, ordem) VALUES (?, ?, ?)",
+            (trabalho_id, modelo_nome, ordem),
+        )
+
+    for imovel in imoveis:
+        cursor = conn.execute(
+            """
+            INSERT INTO trabalho_imoveis (trabalho_id, endereco, numero, label, coord_x, coord_y)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                trabalho_id,
+                str(imovel.get("endereco") or "").strip() or None,
+                str(imovel.get("numero") or "").strip() or None,
+                str(imovel.get("label") or "").strip() or "Imovel",
+                _to_float_or_none(imovel.get("coord_x")),
+                _to_float_or_none(imovel.get("coord_y")),
+            ),
+        )
+        imovel_id = int(cursor.lastrowid)
+        for modelo_nome in _dedupe_text_list(imovel.get("modelos")):
+            conn.execute(
+                "INSERT INTO trabalho_imovel_modelos (imovel_id, modelo_nome) VALUES (?, ?)",
+                (imovel_id, modelo_nome),
+            )
+
+    for source_row, (imovel, modelo_nome, processo) in enumerate(registros, start=1):
+        conn.execute(
+            """
+            INSERT INTO trabalho_registros (
+              trabalho_id,
+              source_row,
+              ano,
+              nome_original,
+              codigo_trabalho,
+              nome_pasta,
+              tecnico,
+              processo,
+              finalidade_processo,
+              modelo_nome,
+              endereco,
+              numero,
+              coord_x,
+              coord_y
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                trabalho_id,
+                source_row,
+                ano,
+                nome,
+                None,
+                None,
+                None,
+                processo,
+                None,
+                modelo_nome,
+                str(imovel.get("endereco") or "").strip() or None,
+                str(imovel.get("numero") or "").strip() or None,
+                _to_float_or_none(imovel.get("coord_x")),
+                _to_float_or_none(imovel.get("coord_y")),
+            ),
+        )
+
+
 def _listar_avaliandos_tecnicos(chaves_modelo: list[str] | None = None) -> list[dict[str, Any]]:
     aliases = [str(item or "").strip() for item in (chaves_modelo or []) if str(item or "").strip()]
     filtrar_por_modelo = chaves_modelo is not None
@@ -779,7 +1029,7 @@ def _listar_avaliandos_tecnicos(chaves_modelo: list[str] | None = None) -> list[
             FROM trabalho_imoveis ti
             JOIN trabalhos t
               ON t.trabalho_id = ti.trabalho_id
-            JOIN trabalho_imovel_modelos tim
+            LEFT JOIN trabalho_imovel_modelos tim
               ON tim.imovel_id = ti.imovel_id
             ORDER BY LOWER(t.nome), ti.imovel_id, LOWER(tim.modelo_nome)
             """
@@ -1393,6 +1643,38 @@ def detalhar_trabalho(trabalho_id: str) -> dict[str, Any]:
     )
 
 
+def cadastrar_trabalho_tecnico(payload: dict[str, Any] | None) -> dict[str, Any]:
+    resolved = trabalhos_tecnicos_repository.resolve_database()
+    if resolved.provider != "local":
+        raise HTTPException(
+            status_code=403,
+            detail="Cadastro de trabalhos tecnicos disponivel apenas na base local neste momento",
+        )
+
+    catalogo_modelos = _catalogo_modelos_mesa()
+    conn = _connect_database(resolved.db_path)
+    trabalho_id = ""
+    try:
+        normalized = _normalizar_cadastro_payload(payload or {}, catalogo_modelos)
+        _ensure_overrides_table(conn)
+        trabalho_id = _gerar_trabalho_id_unico(
+            conn,
+            str(normalized.get("nome") or ""),
+            str(normalized.get("tipo_codigo") or ""),
+            _to_int_or_none(normalized.get("ano")),
+        )
+        _inserir_trabalho_manual(conn, trabalho_id, normalized)
+        conn.commit()
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+    _clear_model_match_cache()
+    return detalhar_trabalho(trabalho_id)
+
+
 def salvar_edicao_trabalho(trabalho_id: str, payload: dict[str, Any] | None) -> dict[str, Any]:
     chave = str(trabalho_id or "").strip()
     if not chave:
@@ -1432,4 +1714,5 @@ def salvar_edicao_trabalho(trabalho_id: str, payload: dict[str, Any] | None) ->
         except Exception:
             pass
 
+    _clear_model_match_cache()
     return detalhar_trabalho(chave)

backend/run_backend.sh

@@ -4,10 +4,53 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 cd "${SCRIPT_DIR}"
 
-# Prefere o ambiente virtual local do backend quando ele existir.
-if [[ -f "${SCRIPT_DIR}/.venv/bin/activate" ]]; then
+VENV_DIR="${SCRIPT_DIR}/.venv"
+VENV_PYTHON="${VENV_DIR}/bin/python"
+VENV_UVICORN="${VENV_DIR}/bin/uvicorn"
+
+find_bootstrap_python() {
+  local candidate
+  for candidate in python3.12 /Library/Frameworks/Python.framework/Versions/3.12/bin/python3.12 python3 python; do
+    if command -v "${candidate}" >/dev/null 2>&1; then
+      command -v "${candidate}"
+      return 0
+    fi
+  done
+
+  return 1
+}
+
+ensure_backend_venv() {
+  local bootstrap_python
+
+  bootstrap_python="$(find_bootstrap_python)" || {
+    cat >&2 <<'EOF'
+[backend] Nenhum interpretador Python compativel foi encontrado.
+[backend] Instale o Python 3.12 e rode ./run_backend.sh novamente.
+EOF
+    return 1
+  }
+
+  if [[ ! -x "${VENV_PYTHON}" ]]; then
+    echo "[backend] Recriando .venv com ${bootstrap_python}..." >&2
+    rm -rf "${VENV_DIR}"
+    "${bootstrap_python}" -m venv "${VENV_DIR}"
+  fi
+
+  # shellcheck disable=SC1091
+  source "${VENV_DIR}/bin/activate"
+
+  if [[ ! -x "${VENV_UVICORN}" ]]; then
+    echo "[backend] Instalando dependencias do backend..." >&2
+    python -m pip install --retries 5 --timeout 60 -r "${SCRIPT_DIR}/requirements.txt" >&2
+  fi
+}
+
+ensure_backend_venv
+
+if [[ -f "${VENV_DIR}/bin/activate" ]]; then
   # shellcheck disable=SC1091
-  source "${SCRIPT_DIR}/.venv/bin/activate"
+  source "${VENV_DIR}/bin/activate"
 fi
 
 uvicorn app.main:app --host 0.0.0.0 --port "${PORT:-8000}" --reload --reload-dir "${SCRIPT_DIR}"

frontend/src/api.js

@@ -235,7 +235,9 @@ export const api = {
   elaboracaoRepositorioModelos: () => getJson('/api/elaboracao/repositorio-modelos'),
   elaboracaoRepositorioCarregar: (sessionId, modeloId) => postJson('/api/elaboracao/repositorio-carregar', { session_id: sessionId, modelo_id: modeloId }),
 
+  pasteElaboracaoTable: (sessionId, pastedText) => postJson('/api/elaboracao/paste-table', { session_id: sessionId, pasted_text: pastedText }),
   confirmSheet: (sessionId, sheetName) => postJson('/api/elaboracao/confirm-sheet', { session_id: sessionId, sheet_name: sheetName }),
+  applyImportColumns: (sessionId, colunas) => postJson('/api/elaboracao/apply-import-columns', { session_id: sessionId, colunas }),
   mapCoords: (sessionId, colLat, colLon) => postJson('/api/elaboracao/map-coords', { session_id: sessionId, col_lat: colLat, col_lon: colLon }),
   geocodificar: (sessionId, colCdlog, colNum, auto200) => postJson('/api/elaboracao/geocodificar', { session_id: sessionId, col_cdlog: colCdlog, col_num: colNum, auto_200: auto200 }),
   geocodificarCorrecoes: (sessionId, correcoes, auto200) => postJson('/api/elaboracao/geocodificar-correcoes', { session_id: sessionId, correcoes, auto_200: auto200 }),
@@ -431,6 +433,7 @@ export const api = {
     avaliando_lon: avaliando?.lon ?? null,
   }),
   trabalhosTecnicosDetalhe: (trabalhoId) => postJson('/api/trabalhos-tecnicos/detalhe', { trabalho_id: trabalhoId }),
+  trabalhosTecnicosCadastrar: (payload = {}) => postJson('/api/trabalhos-tecnicos/cadastrar', payload),
   trabalhosTecnicosSalvar: (payload = {}) => postJson('/api/trabalhos-tecnicos/salvar', payload),
 
   logsStatus: () => getJson('/api/logs/status'),

frontend/src/components/ElaboracaoTab.jsx

@@ -908,6 +908,7 @@ function buildArquivoCarregadoInfo(resp, options = {}) {
   const isDai = tipo === 'dai' || fileNameLower.endsWith('.dai')
   if (isDai) return null
 
+  const importPreview = resp?.import_preview || null
   const extMatch = fileName.match(/\.([^.]+)$/)
   const tipoArquivo = extMatch?.[1] ? String(extMatch[1]).toUpperCase() : '-'
   const sheetName = String(options.sheetName || resp?.sheet_selected || '').trim()
@@ -915,8 +916,16 @@ function buildArquivoCarregadoInfo(resp, options = {}) {
     ? Number(resp.dados.total_rows)
     : Array.isArray(resp?.dados?.rows)
       ? resp.dados.rows.length
-      : null
-  const totalColunas = Array.isArray(resp?.dados?.columns) ? resp.dados.columns.length : null
+      : Number.isFinite(Number(importPreview?.total_rows))
+        ? Number(importPreview.total_rows)
+        : null
+  const totalColunas = Array.isArray(resp?.dados?.columns)
+    ? resp.dados.columns.length
+    : Number.isFinite(Number(importPreview?.total_columns))
+      ? Number(importPreview.total_columns)
+      : Array.isArray(importPreview?.columns)
+        ? importPreview.columns.length
+        : null
   const totalAbas = Array.isArray(resp?.sheets) ? resp.sheets.length : 0
 
   if (!fileName && totalLinhas === null && totalColunas === null && !sheetName) return null
@@ -1026,6 +1035,12 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
   const [requiresSheet, setRequiresSheet] = useState(false)
   const [sheetOptions, setSheetOptions] = useState([])
   const [selectedSheet, setSelectedSheet] = useState('')
+  const [pastedTableText, setPastedTableText] = useState('')
+  const [importPreview, setImportPreview] = useState(null)
+  const [importSelectedColumns, setImportSelectedColumns] = useState([])
+  const [requiresImportColumnSelection, setRequiresImportColumnSelection] = useState(false)
+  const [firstColumnsCount, setFirstColumnsCount] = useState('')
+  const [firstColumnsChecked, setFirstColumnsChecked] = useState(false)
   const [elaborador, setElaborador] = useState(null)
   const [modeloCarregadoInfo, setModeloCarregadoInfo] = useState(null)
   const [repoModelos, setRepoModelos] = useState([])
@@ -1192,6 +1207,22 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
 
   const mapaChoices = useMemo(() => [MAPA_VARIAVEL_PADRAO, ...colunasNumericas], [colunasNumericas])
   const mapaModoDisponivel = mapaVariavel !== MAPA_VARIAVEL_PADRAO
+  const importPreviewColumns = useMemo(
+    () => (Array.isArray(importPreview?.columns) ? importPreview.columns.map((item) => String(item)) : []),
+    [importPreview],
+  )
+  const importPreviewRows = useMemo(
+    () => (Array.isArray(importPreview?.rows) ? importPreview.rows : []),
+    [importPreview],
+  )
+  const importSelectedColumnsSet = useMemo(
+    () => new Set(importSelectedColumns),
+    [importSelectedColumns],
+  )
+  const importSelectionReady = useMemo(
+    () => importSelectedColumns.length >= 2,
+    [importSelectedColumns],
+  )
   const colunasXDisponiveis = useMemo(
     () => (colunaY ? colunasNumericas.filter((coluna) => coluna !== colunaY) : []),
     [colunasNumericas, colunaY],
@@ -1932,7 +1963,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       }
       observer.disconnect()
     }
-  }, [sectionsMountKey, baseCarregada, hasSelection, hasFit])
+  }, [sectionsMountKey, baseCarregada, hasSelection, hasFit, requiresImportColumnSelection])
 
   useEffect(() => {
     if (typeof window === 'undefined') return undefined
@@ -2331,6 +2362,81 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     }
   }
 
+  function limparBaseCarregadaParaSelecaoImportacao() {
+    setDados(null)
+    clearMapaResponse()
+    setMapaGerado(false)
+    setMapaVariavel(MAPA_VARIAVEL_PADRAO)
+    setMapaModo(MAPA_MODO_PONTOS)
+    setMapaResiduosGerado(false)
+    clearMapaResiduosResponse()
+    setMapaResiduosModo(MAPA_MODO_PONTOS)
+    setMapaResiduosExtremoAbs(MAPA_RESIDUOS_EXTREMO_ABS_DEFAULT)
+    setColunasNumericas([])
+    setColunaY('')
+    setColunaYDraft('')
+    setTipoY('')
+    setTipoYDraft('')
+    setColunasAreaCandidatas([])
+    setColunaArea('')
+    setColunasX([])
+    setDicotomicas([])
+    setCodigoAlocado([])
+    setPercentuais([])
+    setColunasDataMercado([])
+    setColunaDataMercadoSugerida('')
+    setColunaDataMercado('')
+    setColunaDataMercadoAplicada('')
+    setPeriodoDadosMercado(null)
+    setPeriodoDadosMercadoPreview(null)
+    setDataMercadoError('')
+    setSelection(null)
+    setGrauCoef(0)
+    setGrauF(0)
+    setFit(null)
+    setSecao10InterativoFigura(null)
+    setSecao10InterativoFiguraComIndices(null)
+    setSecao10InterativoSelecionado('none')
+    setSecao13InterativoFigura(null)
+    setSecao13InterativoFiguraComIndices(null)
+    setSecao13InterativoSelecionado('none')
+    setSelectionAppliedSnapshot(buildSelectionSnapshot())
+    setTransformacaoY('(x)')
+    setTransformacoesX({})
+    setTransformacaoYFixaBusca('Livre')
+    setTransformacoesFixasBusca({})
+    setManualTransformPreview(null)
+    setManualTransformPreviewLoading(false)
+    setTransformacoesAplicadas(null)
+    setOrigemTransformacoes(null)
+    setBuscaTransformAppliedSnapshot(buildGrauSnapshot(0, 0))
+    setManualTransformAppliedSnapshot(buildTransformacoesSnapshot('(x)', {}))
+    setFiltros(defaultFiltros())
+    setOutliersTexto('')
+    setReincluirTexto('')
+    setResumoOutliers('Excluidos: 0 | A excluir: 0 | A reincluir: 0 | Total: 0')
+    setOutliersHtml('')
+    setOutliersAnteriores([])
+    setIteracao(1)
+    setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
+    setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
+    setCoordsInfo(null)
+    setManualLat('')
+    setManualLon('')
+    setGeoCdlog('')
+    setGeoNum('')
+    setCoordsMode('menu')
+    setConfirmarExclusaoCoords(false)
+    setCamposAvaliacao([])
+    valoresAvaliacaoRef.current = {}
+    setAvaliacaoFormVersion((prev) => prev + 1)
+    setAvaliacaoPendente(false)
+    setConfirmarLimpezaAvaliacoes(false)
+    setResultadoAvaliacaoHtml('')
+    setBaseChoices([])
+    setBaseValue('')
+  }
+
   function applyBaseResponse(resp, options = {}) {
     const resetXSelection = Boolean(options.resetXSelection)
     const colunaYPadrao = String(resp.coluna_y_padrao || '')
@@ -2602,6 +2708,19 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     setImportacaoErro('')
     setRequiresSheet(Boolean(resp.requires_sheet))
     setSheetOptions(resp.sheets || [])
+    const proximaImportPreview = resp?.import_preview || null
+    const proximaSelecaoColunasPendente = Boolean(resp?.requires_column_selection)
+    setImportPreview(proximaImportPreview)
+    setRequiresImportColumnSelection(proximaSelecaoColunasPendente)
+    if (proximaImportPreview && proximaSelecaoColunasPendente) {
+      setImportSelectedColumns([])
+      setFirstColumnsCount('')
+      setFirstColumnsChecked(false)
+    } else if (!proximaImportPreview) {
+      setImportSelectedColumns([])
+      setFirstColumnsCount('')
+      setFirstColumnsChecked(false)
+    }
     const nomeModeloCarregado = String(resp?.nome_modelo || '').trim()
     if (Boolean(resp.requires_sheet)) {
       setSelectedSheet('')
@@ -2617,6 +2736,12 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
           ? 'dai'
           : 'tabular'
       setTipoFonteDados(tipoFonte)
+      if (proximaSelecaoColunasPendente) {
+        setNomeArquivoExport('')
+        setModeloLoadSource('')
+        limparBaseCarregadaParaSelecaoImportacao()
+        return
+      }
       if (tipoFonte === 'dai' && nomeModeloCarregado) {
         setNomeArquivoExport(nomeModeloCarregado)
       } else if (tipoFonte !== 'dai') {
@@ -2630,6 +2755,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
 
     setTipoFonteDados('tabular')
     setNomeArquivoExport('')
+    setRequiresImportColumnSelection(false)
     setDados(null)
     setColunasNumericas([])
     setColunaY('')
@@ -2710,6 +2836,11 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setSelectedSheet('')
       setRequiresSheet(false)
       setSheetOptions([])
+      setImportPreview(null)
+      setImportSelectedColumns([])
+      setRequiresImportColumnSelection(false)
+      setFirstColumnsCount('')
+      setFirstColumnsChecked(false)
       const nomeArquivo = String(arquivoUpload?.name || '').toLowerCase()
       const uploadEhDai = nomeArquivo.endsWith('.dai')
       setTipoFonteDados(uploadEhDai ? 'dai' : 'tabular')
@@ -2723,6 +2854,46 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     })
   }
 
+  async function onLoadPastedTable() {
+    const textoColado = String(pastedTableText || '')
+    if (!sessionId) return
+    if (!textoColado.trim()) {
+      setImportacaoErro('Cole os dados copiados do Excel antes de carregar.')
+      return
+    }
+    setModeloLoadSource('paste')
+    setImportacaoErro('')
+    await withBusy(async () => {
+      setMapaGerado(false)
+      clearMapaResponse()
+      setMapaVariavel(MAPA_VARIAVEL_PADRAO)
+      setMapaModo(MAPA_MODO_PONTOS)
+      setMapaResiduosGerado(false)
+      clearMapaResiduosResponse()
+      setMapaResiduosModo(MAPA_MODO_PONTOS)
+      setMapaResiduosExtremoAbs(MAPA_RESIDUOS_EXTREMO_ABS_DEFAULT)
+      setGeoAuto200(true)
+      setSelectedSheet('')
+      setRequiresSheet(false)
+      setSheetOptions([])
+      setImportPreview(null)
+      setImportSelectedColumns([])
+      setRequiresImportColumnSelection(false)
+      setFirstColumnsCount('')
+      setFirstColumnsChecked(false)
+      setUploadedFile(null)
+      setTipoFonteDados('tabular')
+      const resp = await api.pasteElaboracaoTable(sessionId, textoColado)
+      aplicarRespostaCarregamento(resp, 'tabular', {
+        source: 'paste',
+        fileName: String(resp?.uploaded_filename || 'dados_colados.csv'),
+        sheetName: 'Dados colados',
+      })
+    }, {
+      onError: (err) => setImportacaoErro(err?.message || 'Falha ao carregar dados colados.'),
+    })
+  }
+
   async function onCarregarModeloRepositorio(modeloIdOverride = '') {
     const overrideNormalizado = (
       modeloIdOverride
@@ -2749,6 +2920,11 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setSelectedSheet('')
       setRequiresSheet(false)
       setSheetOptions([])
+      setImportPreview(null)
+      setImportSelectedColumns([])
+      setRequiresImportColumnSelection(false)
+      setFirstColumnsCount('')
+      setFirstColumnsChecked(false)
       setTipoFonteDados('dai')
       const resp = await api.elaboracaoRepositorioCarregar(sessionId, modeloId)
       aplicarRespostaCarregamento(resp, 'dai', { source: 'repo' })
@@ -2825,27 +3001,79 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setMapaResiduosExtremoAbs(MAPA_RESIDUOS_EXTREMO_ABS_DEFAULT)
       setGeoAuto200(true)
       const resp = await api.confirmSheet(sessionId, selectedSheet)
-      setTipoFonteDados('tabular')
-      setManualMapError('')
-      setGeoProcessError('')
-      setGeoStatusHtml('')
-      setGeoFalhasHtml('')
-      setGeoCorrecoes([])
-      setElaborador(resp.elaborador || null)
-      setObservacaoModelo(String(resp?.observacao_modelo || '').trim())
-      setModeloCarregadoInfo(null)
-      setAvaliadorSelecionado(resp.elaborador?.nome_completo || '')
-      setNomeArquivoExport('')
-      setRequiresSheet(false)
-      setArquivoCarregadoInfo(buildArquivoCarregadoInfo(resp, {
+      aplicarRespostaCarregamento(resp, 'tabular', {
+        source: 'upload',
         fileName: String(uploadedFile?.name || arquivoCarregadoInfo?.nome_arquivo || ''),
         sheetName: selectedSheet,
-      }))
+      })
+    }, {
+      onError: (err) => setImportacaoErro(err?.message || 'Falha ao confirmar aba do arquivo.'),
+    })
+  }
+
+  function onToggleImportColumn(coluna) {
+    const valor = String(coluna || '').trim()
+    if (!valor) return
+    setFirstColumnsChecked(false)
+    setImportSelectedColumns((prev) => {
+      const next = prev.includes(valor)
+        ? prev.filter((item) => item !== valor)
+        : importPreviewColumns.filter((col) => col === valor || prev.includes(col))
+      return next
+    })
+    setRequiresImportColumnSelection(true)
+  }
+
+  function getFirstImportColumnsQuantity(value = firstColumnsCount) {
+    const limite = importPreviewColumns.length
+    const parsed = Number.parseInt(String(value || '0'), 10)
+    return Number.isFinite(parsed) ? Math.max(0, Math.min(limite, parsed)) : 0
+  }
+
+  function onFirstColumnsCountChange(value) {
+    setFirstColumnsCount(value)
+    if (!firstColumnsChecked) return
+    const quantidade = getFirstImportColumnsQuantity(value)
+    setImportSelectedColumns(importPreviewColumns.slice(0, quantidade))
+    setRequiresImportColumnSelection(true)
+    setImportacaoErro('')
+  }
+
+  function onToggleFirstImportColumns(event) {
+    const checked = event.target.checked
+    setFirstColumnsChecked(checked)
+    const quantidade = getFirstImportColumnsQuantity()
+    const primeiras = importPreviewColumns.slice(0, quantidade)
+    if (checked) {
+      setFirstColumnsCount(String(quantidade))
+      setImportSelectedColumns(primeiras)
+    } else {
+      const primeirasSet = new Set(primeiras)
+      setImportSelectedColumns((prev) => prev.filter((coluna) => !primeirasSet.has(coluna)))
+    }
+    setRequiresImportColumnSelection(true)
+    setImportacaoErro('')
+  }
+
+  function onClearImportColumns() {
+    setImportSelectedColumns([])
+    setFirstColumnsChecked(false)
+    setRequiresImportColumnSelection(true)
+    setImportacaoErro('')
+  }
+
+  async function onApplyImportColumns() {
+    if (!sessionId || importSelectedColumns.length < 2) return
+    setImportacaoErro('')
+    await withBusy(async () => {
+      const resp = await api.applyImportColumns(sessionId, importSelectedColumns)
+      setRequiresImportColumnSelection(false)
+      setImportSelectedColumns(Array.isArray(resp.import_columns_selected) ? resp.import_columns_selected.map((item) => String(item)) : importSelectedColumns)
       applyBaseResponse(resp, { resetXSelection: true })
       setSectionsMountKey((prev) => prev + 1)
       setModeloLoadSource('')
     }, {
-      onError: (err) => setImportacaoErro(err?.message || 'Falha ao confirmar aba do arquivo.'),
+      onError: (err) => setImportacaoErro(err?.message || 'Falha ao aplicar seleção de colunas.'),
     })
   }
 
@@ -4188,7 +4416,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
         </aside>
 
         <div key={`sections-${sectionsMountKey}`} className="workflow-sections-stack elaboracao-sections-stack">
-          <SectionBlock step="1" title="Importar Dados" subtitle="Upload de CSV, Excel ou .dai com recuperação do fluxo.">
+          <SectionBlock step="1" title="Importar Dados" subtitle="Modelo, planilha ou dados colados com recuperação do fluxo.">
             <div className="section1-groups">
               <div className="subpanel section1-group">
                 {!modeloLoadSource ? (
@@ -4217,6 +4445,18 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                     >
                       Fazer upload de Excel ou modelo
                     </button>
+                    <button
+                      type="button"
+                      className="model-source-choice-btn model-source-choice-btn-tertiary"
+                      onClick={() => {
+                        setModeloLoadSource('paste')
+                        setRepoModeloDropdownOpen(false)
+                        setImportacaoErro('')
+                      }}
+                      disabled={loading}
+                    >
+                      Colar dados do Excel
+                    </button>
                   </div>
                 ) : (
 	                  <div className="model-source-flow">
@@ -4307,6 +4547,44 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                 ) : null}
               </>
             ) : null}
+
+            {modeloLoadSource === 'paste' ? (
+              <div className="paste-excel-panel">
+                <label className="paste-excel-field">
+                  Dados do Excel
+                  <textarea
+                    value={pastedTableText}
+                    onChange={(event) => {
+                      setPastedTableText(event.target.value)
+                      setImportacaoErro('')
+                    }}
+                    placeholder="Cole a tabela copiada do Excel"
+                    disabled={loading}
+                    rows={8}
+                  />
+                </label>
+                <div className="row compact paste-excel-actions">
+                  <button
+                    type="button"
+                    onClick={onLoadPastedTable}
+                    disabled={loading || !pastedTableText.trim()}
+                  >
+                    Carregar dados colados
+                  </button>
+                  <button
+                    type="button"
+                    className="paste-excel-clear-btn"
+                    onClick={() => {
+                      setPastedTableText('')
+                      setImportacaoErro('')
+                    }}
+                    disabled={loading || !pastedTableText}
+                  >
+                    Limpar
+                  </button>
+                </div>
+              </div>
+            ) : null}
               </div>
             )}
 
@@ -4353,6 +4631,115 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                 </>
               ) : null}
 
+              {importPreview ? (
+                <div className="import-preview-card">
+                  <div className="import-preview-head">
+                    <div>
+                      <h4>Prévia da planilha</h4>
+                      <div className="section1-empty-hint">
+                        Cabeçalhos e {Number(importPreview?.returned_rows || importPreviewRows.length).toLocaleString('pt-BR')} linhas aleatórias.
+                      </div>
+                    </div>
+                    <div className="import-preview-counter">
+                      {importSelectedColumns.length}/{importPreviewColumns.length} selecionadas
+                    </div>
+                  </div>
+
+                  <div className="import-preview-disclaimer">
+                    Inclua as colunas referentes ao Bairro e à Finalidade Cadastral do imóvel para seguir as diretrizes da DAI.
+                  </div>
+
+                  <div className="import-preview-tools">
+                    <label className="import-preview-first-columns-toggle">
+                      <input
+                        type="checkbox"
+                        checked={firstColumnsChecked}
+                        onChange={onToggleFirstImportColumns}
+                        disabled={loading || importPreviewColumns.length === 0}
+                      />
+                      Selecionar primeiras
+                    </label>
+                    <label className="import-preview-first-columns-field">
+                      <input
+                        type="number"
+                        min="0"
+                        max={importPreviewColumns.length}
+                        value={firstColumnsCount}
+                        onChange={(event) => onFirstColumnsCountChange(event.target.value)}
+                        disabled={loading || importPreviewColumns.length === 0}
+                      />
+                      colunas
+                    </label>
+                    <button
+                      type="button"
+                      className="import-preview-clear-btn"
+                      onClick={onClearImportColumns}
+                      disabled={loading || importSelectedColumns.length === 0}
+                    >
+                      Limpar selecionadas
+                    </button>
+                  </div>
+
+                  {!importSelectionReady ? (
+                    <div className="section1-empty-hint">
+                      Selecione pelo menos 2 colunas para liberar as próximas etapas.
+                    </div>
+                  ) : null}
+
+                  <div className="import-preview-table-wrap">
+                    <table className="import-preview-table">
+                      <thead>
+                        <tr>
+                          <th className="import-preview-index-cell">#</th>
+                          {importPreviewColumns.map((coluna) => {
+                            const selected = importSelectedColumnsSet.has(coluna)
+                            return (
+                              <th key={`import-preview-head-${coluna}`} className={selected ? 'is-selected' : ''}>
+                                <button
+                                  type="button"
+                                  className="import-preview-header-btn"
+                                  onClick={() => onToggleImportColumn(coluna)}
+                                  aria-pressed={selected}
+                                  disabled={loading}
+                                >
+                                  {coluna}
+                                </button>
+                              </th>
+                            )
+                          })}
+                        </tr>
+                      </thead>
+                      <tbody>
+                        {importPreviewRows.map((row, rowIndex) => (
+                          <tr key={`import-preview-row-${row?._index ?? rowIndex}`}>
+                            <td className="import-preview-index-cell">{row?._index ?? rowIndex + 1}</td>
+                            {importPreviewColumns.map((coluna) => {
+                              const selected = importSelectedColumnsSet.has(coluna)
+                              return (
+                                <td key={`import-preview-cell-${rowIndex}-${coluna}`} className={selected ? 'is-selected' : ''}>
+                                  {String(row?.[coluna] ?? '')}
+                                </td>
+                              )
+                            })}
+                          </tr>
+                        ))}
+                      </tbody>
+                    </table>
+                  </div>
+
+                  <div className="import-preview-apply-row">
+                    <button
+                      type="button"
+                      className="import-preview-apply-btn"
+                      onClick={onApplyImportColumns}
+                      disabled={loading || !importSelectionReady || !requiresImportColumnSelection}
+                    >
+                      {requiresImportColumnSelection ? 'Aplicar colunas selecionadas' : 'Seleção aplicada'}
+                    </button>
+                  </div>
+                </div>
+              ) : null}
+
               {modeloCarregadoInfo ? (
                 <>
                   <h4>Informações do modelo</h4>
@@ -4433,7 +4820,7 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
         </div>
       </SectionBlock>
 
-      {baseCarregada ? (
+      {baseCarregada && !requiresImportColumnSelection ? (
         <>
           <SectionBlock step="2" title="Resolver Coordenadas" subtitle="Mapeie lat/lon ou execute geocodificação automática.">
             <div className="coords-section-groups">

frontend/src/components/TrabalhosTecnicosTab.jsx

@@ -92,6 +92,28 @@ function nomeModeloExibicao(modelo) {
   return String(modelo?.mesa_modelo_nome || modelo?.nome || '').trim()
 }
 
+function buildEmptyImovel(idPrefix = 'novo-trabalho', index = 1) {
+  return {
+    id: `${idPrefix}-imovel-${index}`,
+    label: '',
+    endereco: '',
+    numero: '',
+    coord_x: '',
+    coord_y: '',
+  }
+}
+
+function buildCadastroState() {
+  return {
+    nome: '',
+    tipo_codigo: '',
+    ano: '',
+    processos_sei_text: '',
+    modelos: [],
+    imoveis: [buildEmptyImovel('novo-trabalho', 1)],
+  }
+}
+
 function buildEditState(trabalho) {
   const modelos = dedupeTextList(
     (Array.isArray(trabalho?.modelos) ? trabalho.modelos : []).map((item) => nomeModeloExibicao(item))
@@ -106,14 +128,7 @@ function buildEditState(trabalho) {
         coord_y: item?.coord_y ?? '',
       }))
     : [
-        {
-          id: `${trabalho?.id || 'trabalho'}-imovel-1`,
-          label: '',
-          endereco: '',
-          numero: '',
-          coord_x: '',
-          coord_y: '',
-        },
+        buildEmptyImovel(trabalho?.id || 'trabalho', 1),
       ]
 
   return {
@@ -126,6 +141,23 @@ function buildEditState(trabalho) {
   }
 }
 
+function buildTrabalhoPayload(edicao) {
+  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),
+    })),
+  }
+}
+
 function toListItemFromDetail(trabalho) {
   const modelos = Array.isArray(trabalho?.modelos) ? trabalho.modelos : []
   const modelosMesa = modelos.filter((item) => item?.disponivel_mesa)
@@ -182,6 +214,7 @@ export default function TrabalhosTecnicosTab({
   const [trabalhoLoading, setTrabalhoLoading] = useState(false)
   const [trabalhoError, setTrabalhoError] = useState('')
   const [editando, setEditando] = useState(false)
+  const [cadastrando, setCadastrando] = useState(false)
   const [salvando, setSalvando] = useState(false)
   const [edicao, setEdicao] = useState(null)
   const [edicaoErro, setEdicaoErro] = useState('')
@@ -420,6 +453,7 @@ export default function TrabalhosTecnicosTab({
     setTrabalhoError('')
     setEdicaoErro('')
     setEditando(false)
+    setCadastrando(false)
     setEdicao(null)
     setOrigemAbertura(String(options?.origem || 'lista').trim() || 'lista')
     try {
@@ -450,6 +484,7 @@ export default function TrabalhosTecnicosTab({
     setTrabalhoError('')
     setEdicaoErro('')
     setEditando(false)
+    setCadastrando(false)
     setEdicao(null)
     setModeloDraft('')
     if (options.syncRoute !== false && typeof onRouteChange === 'function') {
@@ -461,6 +496,10 @@ export default function TrabalhosTecnicosTab({
   }
 
   function onVoltarDoDetalhe() {
+    if (cadastrando) {
+      onVoltarLista({ subtab: 'repositorio' })
+      return
+    }
     if (origemAbertura === 'pesquisa_mapa' && typeof onVoltarAoMapaPesquisa === 'function') {
       onVoltarLista({ syncRoute: false })
       onVoltarAoMapaPesquisa()
@@ -475,6 +514,41 @@ export default function TrabalhosTecnicosTab({
     onVoltarLista({ subtab: activeInnerTab })
   }
 
+  function onIniciarCadastro() {
+    const draft = buildCadastroState()
+    setActiveInnerTab('repositorio')
+    setTrabalhoAberto({
+      id: '',
+      nome: '',
+      tipo_codigo: '',
+      tipo_label: 'Novo trabalho técnico',
+      ano: '',
+      endereco_resumo: '',
+      modelo_resumo: '',
+      total_registros_planilha: 0,
+      total_imoveis: 0,
+      total_modelos: 0,
+      tem_coordenadas: false,
+      processos_sei: [],
+      modelos: [],
+      imoveis: [],
+    })
+    setEdicao(draft)
+    setModeloDraft('')
+    setEdicaoErro('')
+    setTrabalhoError('')
+    setOrigemAbertura('lista')
+    setCadastrando(true)
+    setEditando(true)
+    void carregarSugestoesModelosMesa()
+    if (typeof onRouteChange === 'function') {
+      onRouteChange({
+        tab: 'trabalhos',
+        subtab: 'repositorio',
+      })
+    }
+  }
+
   function onAbrirModeloAssociado(modelo) {
     if (!modelo?.disponivel_mesa || typeof onAbrirModeloNoRepositorio !== 'function') return
     onAbrirModeloNoRepositorio({
@@ -500,6 +574,10 @@ export default function TrabalhosTecnicosTab({
 
   function onCancelarEdicao() {
     if (salvando) return
+    if (cadastrando) {
+      onVoltarLista({ subtab: 'repositorio' })
+      return
+    }
     setEditando(false)
     setEdicao(null)
     setEdicaoErro('')
@@ -575,40 +653,41 @@ export default function TrabalhosTecnicosTab({
   }
 
   async function onSalvarEdicao() {
-    if (!trabalhoAberto?.id || !edicao) return
+    if (!edicao) return
+    if (!cadastrando && !trabalhoAberto?.id) return
     setSalvando(true)
     setEdicaoErro('')
     try {
-      const payload = {
-        trabalho_id: trabalhoAberto.id,
-        nome: edicao.nome,
-        tipo_codigo: edicao.tipo_codigo,
-        ano: parseNullableInt(edicao.ano),
-        processos_sei: splitTextareaLines(edicao.processos_sei_text),
-        modelos: dedupeTextList(edicao.modelos),
-        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),
-        })),
-      }
-      const resp = await api.trabalhosTecnicosSalvar(payload)
+      const payload = buildTrabalhoPayload(edicao)
+      const resp = cadastrando
+        ? await api.trabalhosTecnicosCadastrar(payload)
+        : await api.trabalhosTecnicosSalvar({ trabalho_id: trabalhoAberto.id, ...payload })
       const trabalhoAtualizado = resp?.trabalho || null
       setTrabalhoAberto(trabalhoAtualizado)
       setEditando(false)
+      setCadastrando(false)
       setEdicao(null)
       setModeloDraft('')
       if (trabalhoAtualizado?.id) {
-        setTrabalhos((prev) => prev.map((item) => (
-          String(item?.id || '') === String(trabalhoAtualizado.id)
-            ? toListItemFromDetail(trabalhoAtualizado)
-            : item
-        )))
+        const itemAtualizado = toListItemFromDetail(trabalhoAtualizado)
+        setTrabalhos((prev) => {
+          const existe = prev.some((item) => String(item?.id || '') === String(trabalhoAtualizado.id))
+          if (!existe) return [itemAtualizado, ...prev]
+          return prev.map((item) => (
+            String(item?.id || '') === String(trabalhoAtualizado.id)
+              ? itemAtualizado
+              : item
+          ))
+        })
+        if (typeof onRouteChange === 'function') {
+          onRouteChange({
+            tab: 'trabalhos',
+            trabalhoId: String(trabalhoAtualizado.id),
+          })
+        }
       }
     } catch (err) {
-      setEdicaoErro(err.message || 'Falha ao salvar alterações do trabalho técnico.')
+      setEdicaoErro(err.message || (cadastrando ? 'Falha ao cadastrar trabalho técnico.' : 'Falha ao salvar alterações do trabalho técnico.'))
     } finally {
       setSalvando(false)
     }
@@ -686,23 +765,24 @@ export default function TrabalhosTecnicosTab({
   }, [activeInnerTab, trabalhoAberto])
 
   if (trabalhoAberto) {
+    const isCadastro = Boolean(cadastrando)
     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 shareHref = buildTrabalhoTecnicoLink(trabalhoAberto?.id || '')
+    const shareHref = !isCadastro && trabalhoAberto?.id ? buildTrabalhoTecnicoLink(trabalhoAberto.id) : ''
 
     return (
       <div className="tab-content">
         <div className="pesquisa-opened-model-view">
           <div className="pesquisa-opened-model-head">
             <div className="pesquisa-opened-model-title-wrap">
-              <h3>{trabalhoAberto?.nome || 'Trabalho técnico'}</h3>
-              <p>{trabalhoAberto?.tipo_label || 'Tipo não identificado'}</p>
+              <h3>{isCadastro ? (edicao?.nome || 'Novo trabalho técnico') : (trabalhoAberto?.nome || 'Trabalho técnico')}</h3>
+              <p>{isCadastro ? 'Cadastro manual' : (trabalhoAberto?.tipo_label || 'Tipo não identificado')}</p>
             </div>
             <div className="trabalho-detail-actions">
-              <ShareLinkButton href={shareHref} />
-              {!editando ? (
+              {shareHref ? <ShareLinkButton href={shareHref} /> : null}
+              {!editando && !isCadastro ? (
                 <button
                   type="button"
                   className="model-source-back-btn"
@@ -719,7 +799,7 @@ export default function TrabalhosTecnicosTab({
                     onClick={() => void onSalvarEdicao()}
                     disabled={salvando}
                   >
-                    {salvando ? 'Salvando...' : 'Salvar alterações'}
+                    {salvando ? 'Salvando...' : (isCadastro ? 'Cadastrar trabalho' : 'Salvar alterações')}
                   </button>
                   <button
                     type="button"
@@ -737,7 +817,9 @@ export default function TrabalhosTecnicosTab({
                 onClick={onVoltarDoDetalhe}
                 disabled={trabalhoLoading || salvando}
               >
-                {origemAbertura === 'pesquisa_mapa' || origemAbertura === 'trabalhos_tecnicos_mapa'
+                {isCadastro
+                  ? 'Voltar à lista'
+                  : origemAbertura === 'pesquisa_mapa' || origemAbertura === 'trabalhos_tecnicos_mapa'
                   ? 'Voltar ao mapa'
                   : 'Voltar à lista'}
               </button>
@@ -1022,7 +1104,9 @@ export default function TrabalhosTecnicosTab({
         </div>
         <LoadingOverlay
           show={trabalhoLoading || salvando}
-          label={salvando ? 'Salvando trabalho técnico...' : 'Abrindo trabalho técnico...'}
+          label={salvando
+            ? (cadastrando ? 'Cadastrando trabalho técnico...' : 'Salvando trabalho técnico...')
+            : 'Abrindo trabalho técnico...'}
         />
       </div>
     )
@@ -1061,6 +1145,9 @@ export default function TrabalhosTecnicosTab({
                 <div><strong>Total:</strong> {trabalhos.length}</div>
               </div>
               <div className="repo-actions">
+                <button type="button" className="repo-refresh-btn trabalhos-create-btn" onClick={onIniciarCadastro} disabled={loading || trabalhoLoading}>
+                  Cadastrar trabalho
+                </button>
                 <button type="button" className="repo-refresh-btn" onClick={() => void carregarTrabalhos()} disabled={loading}>
                   Atualizar lista
                 </button>

frontend/src/styles.css

@@ -460,6 +460,14 @@ textarea {
   color: #ffffff;
 }
 
+.trabalhos-create-btn {
+  --btn-bg-start: #2f8f5b;
+  --btn-bg-end: #247a4b;
+  --btn-border: #1f6b42;
+  --btn-shadow-soft: rgba(47, 143, 91, 0.2);
+  --btn-shadow-strong: rgba(47, 143, 91, 0.28);
+}
+
 .repo-upload-row,
 .repo-delete-row {
   display: flex;
@@ -4641,6 +4649,15 @@ button.model-source-choice-btn-secondary {
   color: #35506a;
 }
 
+button.model-source-choice-btn-tertiary {
+  --btn-bg-start: #fff6e8;
+  --btn-bg-end: #ffe6bf;
+  --btn-border: #e2a94d;
+  --btn-shadow-soft: rgba(226, 169, 77, 0.16);
+  --btn-shadow-strong: rgba(226, 169, 77, 0.24);
+  color: #704b12;
+}
+
 .model-source-flow {
   display: grid;
   gap: 12px;
@@ -4731,6 +4748,46 @@ button.btn-upload-select {
   word-break: break-word;
 }
 
+.paste-excel-panel {
+  display: grid;
+  gap: 10px;
+  border: 1px solid #d1deea;
+  border-radius: 8px;
+  background: #fbfdff;
+  padding: 11px 12px;
+}
+
+.paste-excel-field {
+  display: grid;
+  gap: 7px;
+  color: #33485d;
+  font-size: 0.9rem;
+  font-weight: 800;
+}
+
+.paste-excel-field textarea {
+  min-height: 168px;
+  resize: vertical;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  font-size: 0.84rem;
+  font-weight: 500;
+  line-height: 1.45;
+  white-space: pre;
+}
+
+.paste-excel-actions {
+  justify-content: flex-start;
+}
+
+button.paste-excel-clear-btn {
+  --btn-bg-start: #f5f8fb;
+  --btn-bg-end: #edf2f7;
+  --btn-border: #c9d7e4;
+  --btn-shadow-soft: rgba(53, 74, 95, 0.08);
+  --btn-shadow-strong: rgba(53, 74, 95, 0.12);
+  color: #40576f;
+}
+
 .upload-file-info-card {
   margin-top: 0;
   border: 1px solid #d1deea;
@@ -4770,6 +4827,228 @@ button.btn-upload-select {
   word-break: break-word;
 }
 
+.import-preview-card {
+  display: grid;
+  gap: 12px;
+  border: 1px solid #cbd9e7;
+  border-radius: 8px;
+  background: #fbfdff;
+  padding: 12px;
+}
+
+.import-preview-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 12px;
+}
+
+.import-preview-head h4 {
+  margin: 0 0 4px;
+}
+
+.import-preview-counter {
+  flex: 0 0 auto;
+  border: 1px solid #a9c9e7;
+  border-radius: 999px;
+  background: #eef7ff;
+  color: #245f91;
+  font-size: 0.78rem;
+  font-weight: 800;
+  padding: 5px 9px;
+}
+
+.import-preview-disclaimer {
+  border-left: 3px solid #e28a29;
+  background: #fff8ed;
+  color: #624622;
+  font-size: 0.86rem;
+  font-weight: 700;
+  line-height: 1.4;
+  padding: 8px 10px;
+}
+
+.import-preview-tools {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+}
+
+.import-preview-first-columns-field {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  color: #33485d;
+  font-size: 0.86rem;
+  font-weight: 700;
+}
+
+.import-preview-first-columns-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  min-height: 34px;
+  border: 1px solid #c8d8e8;
+  border-radius: 8px;
+  background: #f6f9fc;
+  color: #33485d;
+  font-size: 0.86rem;
+  font-weight: 800;
+  padding: 6px 9px;
+}
+
+.import-preview-first-columns-toggle input {
+  width: auto;
+  margin: 0;
+}
+
+.import-preview-first-columns-field input {
+  width: 78px;
+}
+
+button.import-preview-apply-btn {
+  --btn-bg-start: #ff8c00;
+  --btn-bg-end: #e67900;
+  --btn-border: #cf6f00;
+  --btn-shadow-soft: rgba(255, 140, 0, 0.2);
+  --btn-shadow-strong: rgba(255, 140, 0, 0.28);
+}
+
+button.import-preview-clear-btn {
+  --btn-bg-start: #f5f8fb;
+  --btn-bg-end: #edf2f7;
+  --btn-border: #c9d7e4;
+  --btn-shadow-soft: rgba(53, 74, 95, 0.08);
+  --btn-shadow-strong: rgba(53, 74, 95, 0.12);
+  color: #40576f;
+}
+
+.import-preview-apply-row {
+  display: flex;
+  justify-content: flex-start;
+  padding-top: 2px;
+}
+
+.import-preview-table-wrap {
+  overflow: auto;
+  max-height: 360px;
+  border: 1px solid #d4e0eb;
+  border-radius: 8px;
+  background: #ffffff;
+}
+
+.import-preview-table {
+  width: max-content;
+  min-width: 100%;
+  border-collapse: separate;
+  border-spacing: 0;
+  font-size: 0.82rem;
+}
+
+.import-preview-table th,
+.import-preview-table td {
+  max-width: 220px;
+  min-width: 120px;
+  border-right: 1px solid #e0e8f0;
+  border-bottom: 1px solid #e8eef4;
+  padding: 0;
+  text-align: left;
+  vertical-align: top;
+}
+
+.import-preview-table td {
+  color: #2f4358;
+  padding: 7px 9px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.import-preview-table th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  background: #eef3f8;
+  padding: 6px;
+}
+
+.import-preview-table th.is-selected {
+  background: #d9edff;
+  box-shadow: inset 0 -3px 0 #2f80cf;
+}
+
+.import-preview-table td.is-selected {
+  background: #f0f8ff;
+}
+
+.import-preview-table tr:hover td {
+  background: #f8fbfe;
+}
+
+.import-preview-table tr:hover td.is-selected {
+  background: #e6f3ff;
+}
+
+.import-preview-header-btn {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  min-height: 42px;
+  border: 1px solid #9fbfdd;
+  border-radius: 7px;
+  background: linear-gradient(180deg, #ffffff 0%, #edf6ff 100%);
+  box-shadow: 0 2px 5px rgba(49, 86, 122, 0.12);
+  color: #24506f;
+  font: inherit;
+  font-weight: 800;
+  line-height: 1.25;
+  text-align: left;
+  white-space: normal;
+  overflow-wrap: anywhere;
+  padding: 8px 10px;
+}
+
+.import-preview-header-btn::before {
+  content: "";
+  flex: 0 0 14px;
+  width: 14px;
+  height: 14px;
+  border: 2px solid #6d9dcc;
+  border-radius: 4px;
+  background: #ffffff;
+  box-shadow: inset 0 0 0 2px #ffffff;
+}
+
+.import-preview-header-btn:hover,
+.import-preview-header-btn:focus-visible {
+  border-color: #2f80cf;
+  background: linear-gradient(180deg, #f7fbff 0%, #dceeff 100%);
+  box-shadow: 0 4px 10px rgba(47, 128, 207, 0.18);
+  transform: none;
+}
+
+.import-preview-table th.is-selected .import-preview-header-btn {
+  border-color: #2f80cf;
+  background: linear-gradient(180deg, #e6f4ff 0%, #cde8ff 100%);
+  color: #155e99;
+}
+
+.import-preview-table th.is-selected .import-preview-header-btn::before {
+  border-color: #2f80cf;
+  background: #2f80cf;
+}
+
+.import-preview-index-cell {
+  min-width: 58px !important;
+  max-width: 72px !important;
+  width: 64px;
+  color: #66788a;
+  font-weight: 800;
+  background: #f7f9fb;
+}
+
 .import-feedback-line {
   margin-top: 10px;
 }