@danhachuel/prodmaker 0.1.13 → 0.1.15

package/CHANGELOG.md

@@ -3,6 +3,43 @@
 Todas as versões seguem a etiqueta visual `MAJOR.MINOR.PATCH` com patch de dois dígitos
 (o registry NPM normaliza `0.1.00` → `0.1.0`).
 
+## 0.1.15 — 2026-10-31
+
+- **Fase 11 — TikTok Ads real + Anti-Fraude AdsPixel (Redis).**
+- **TikTok Ads (publicação automática):** `publish_tiktok.py` — troca do auth_code por
+  access_token/refresh_token (`POST /api/tiktok/token`) e criação de campanha + grupo
+  PAUSADOS via Marketing API v1.3 (objective CONVERSIONS, budget diário US$,
+  placement automático); passo final do criativo com instrução honesta quando não há
+  mídia. Erros da API atribuídos. Card TikTok em Chaves de API ganhou auth_code +
+  botão "Trocar auth_code por token". AdsCreator passa a publicar TikTok de verdade.
+- **Anti-Fraude (AdsPixel):** `fraude.py` seguindo o padrão do redis-datasets/fraud-detection —
+  **IP blacklist (Redis Cuckoo Filter)** + **click spamming (Sorted Set com janela de 60s e
+  limite de 10 cliques)**; **fallback SQLite automático sem Redis**; página **Anti-Fraude**
+  (/tracking/fraude) com status do motor, bloqueio/desbloqueio manual, cópia da lista e
+  métricas de spam 24h. O `/track` agora avalia IP bloqueado antes de gravar e o pixel
+  nunca quebra a página do visitante. Card **Redis** em Chaves de API (REDIS_URL).
+- OAuth Google Ads (item 1 da Fase 11) já estava entregue na 0.1.12.
+
+## 0.1.14 — 2026-10-31
+
+- **Fase 10 — REVISÃO (fechamento das lacunas apontadas na criação de produto/PDF).**
+- **`POST /api/builder/generate-product`:** gera o **conteúdo completo** do produto em
+  Markdown conforme o agente low-ticket — 1. Capa (≤6 palavras); 2. Diagnóstico (5 motivos);
+  3. Solução (5–7 passos); 4. Exemplos (3 casos); 5. Checklist; 6. Bônus.
+- **`POST /api/builder/generate-assets`:** 3 Order Bumps (checkout +R$21,90 · upsell +R$197 ·
+  parceiro 50/50) + **Quiz com IA** (5 perguntas) — rota própria conforme imagem 4.
+- **`POST /api/builder/generate-landing`:** landing page de vendas com as **12 seções
+  validadas**, salva em `paginas` com preview em `/pages/{id}`.
+- **Wizard com 4 passos:** (1) mineração + parceiro; (2) **seleção de formato** (E-book/
+  Planilha/Mini-curso/Desafio/Workshop) + estrutura + assets + preço R$27–97; (3) conteúdo
+  completo + **PDF** + landing page; (4) **12 anúncios + 10 pins** + **Publicar no GitHub +
+  Cloudflare** (reaproveita o motor da Fase 4).
+- `generate-ads` agora devolve também os 10 pins; `generate-pdf` usa o conteúdo completo
+  quando disponível (antes renderia só o esqueleto).
+- **Salvamento completo:** `salvar` grava anúncios + pins e **cria o registro em `produtos`**
+  (status aprovado, vinculado via `infoprodutos.produto_id`) — AdsPages e AdsCreator passam
+  a consumir o produto do builder automaticamente.
+
 ## 0.1.13 — 2026-10-31
 
 - **Fase 10 — Product Builder Wizard (motor de criação de ofertas).**

package/app/api/ads.py

@@ -143,11 +143,9 @@ def campanhas_publicar(campanha_id: int):
         elif plataforma == "meta":
             resultado = publish_ads.publicar_meta(campanha)
         else:
-            resultado = {
-                "plataforma": "tiktok",
-                "etapas": [{"etapa": "manual", "observacao": "TikTok: siga o checklist do plano (formato 9:16 UGC) e crie manualmente no TikTok Ads Manager."}],
-                "observacao": "Plano manual — crie manualmente no TikTok Ads Manager.",
-            }
+            from ..services import publish_tiktok
+
+            resultado = publish_tiktok.publicar_campanha(campanha)
     except LLMError as exc:
         campaigns.marcar_publicada(campanha_id, {}, status="erro", erro=str(exc))
         raise HTTPException(status_code=400, detail=str(exc))

package/app/api/builder.py

@@ -17,6 +17,17 @@ class EstruturaBody(BaseModel):
     oferta: dict
 
 
+class ProdutoBody(BaseModel):
+    oferta: dict
+    estrutura: dict = {}
+    formato: str = ""
+
+
+class AssetsBody(BaseModel):
+    oferta: dict
+    preco: float = 47
+
+
 class AnunciosBody(BaseModel):
     produto: str
     promessa: str = ""
@@ -24,17 +35,25 @@ class AnunciosBody(BaseModel):
     link: str = ""
 
 
+class LandingBody(BaseModel):
+    oferta: dict
+    estrutura: dict = {}
+    produto_md: str = ""
+
+
 class PdfBody(BaseModel):
     oferta: dict
-    estrutura: dict
+    estrutura: dict = {}
     preco: float
     parceiro: str = ""
     modo: str = "rapido"
+    produto_md: str = ""
 
 
 class SalvarBody(BaseModel):
     record_id: int
-    anuncios: list
+    anuncios: list = []
+    pins: list = []
 
 
 def _erro(exc: LLMError) -> HTTPException:
@@ -57,6 +76,33 @@ def generate_structure(body: EstruturaBody):
         raise _erro(exc)
 
 
+@router.post("/generate-product")
+def generate_product(body: ProdutoBody):
+    """Conteúdo completo do produto em Markdown (agente low-ticket)."""
+    try:
+        return builder.gerar_produto(body.oferta, body.estrutura, body.formato)
+    except LLMError as exc:
+        raise _erro(exc)
+
+
+@router.post("/generate-assets")
+def generate_assets(body: AssetsBody):
+    """3 Order Bumps (checkout/upsell/parceiro) + Quiz com IA."""
+    try:
+        return builder.gerar_assets(body.oferta, body.preco)
+    except LLMError as exc:
+        raise _erro(exc)
+
+
+@router.post("/generate-landing")
+def generate_landing(body: LandingBody):
+    """Landing page de vendas (12 seções) para o produto do wizard."""
+    try:
+        return builder.gerar_landing(body.oferta, body.estrutura, body.produto_md)
+    except LLMError as exc:
+        raise _erro(exc)
+
+
 @router.post("/generate-ads")
 def generate_ads(body: AnunciosBody):
     try:
@@ -76,6 +122,6 @@ def generate_pdf(body: PdfBody):
 @router.post("/salvar")
 def salvar(body: SalvarBody):
     try:
-        return builder.salvar(body.anuncios, body.record_id)
+        return builder.salvar(body.anuncios, body.record_id, body.pins)
     except (LLMError, ValueError) as exc:
         raise HTTPException(status_code=400, detail=str(exc))

package/app/api/fraude.py

@@ -0,0 +1,35 @@
+"""Anti-Fraude (AdsPixel) — painel de IPs bloqueados, bloqueio/desbloqueio e resumo."""
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import fraude
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/fraude", tags=["anti-fraude"])
+
+
+class BloquearBody(BaseModel):
+    ip: str
+    motivo: str = "manual"
+
+
+@router.get("/resumo")
+def resumo():
+    return fraude.resumo()
+
+
+@router.post("/bloquear")
+def bloquear(body: BloquearBody):
+    try:
+        return fraude.bloquear_ip(body.ip, body.motivo)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.delete("/ips/{ip}")
+def desbloquear(ip: str):
+    try:
+        fraude.desbloquear_ip(ip)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True}

package/app/api/tiktok.py

@@ -0,0 +1,16 @@
+"""TikTok Ads — troca do auth_code por access_token (1 clique)."""
+from fastapi import APIRouter, HTTPException
+
+from ..services.llm import LLMError
+from ..services.publish_tiktok import trocar_auth_code
+
+router = APIRouter(prefix="/api/tiktok", tags=["tiktok"])
+
+
+@router.post("/token")
+def token():
+    """Troca o auth_code salvo em Chaves de API por access_token + refresh_token."""
+    try:
+        return trocar_auth_code()
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))

package/app/main.py

@@ -15,7 +15,7 @@ from .services.database import ensure_db, get_db, now_str, row_to_dict
 from .services.llm import LLMError, analyze_product, list_providers
 from .services.store import PRODMAKER_HOME, STORAGE, STATE, ensure_state_dir, get_master_code, get_settings, save_settings
 
-APP_VERSION = "0.1.13"
+APP_VERSION = "0.1.15"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -41,6 +41,8 @@ from .api import guias as guias_router  # noqa: E402
 from .api import contas as contas_router  # noqa: E402
 from .api import invest as invest_router  # noqa: E402
 from .api import builder as builder_router  # noqa: E402
+from .api import fraude as fraude_router  # noqa: E402
+from .api import tiktok as tiktok_router  # noqa: E402
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
@@ -58,6 +60,8 @@ app.include_router(guias_router.router)
 app.include_router(contas_router.router)
 app.include_router(invest_router.router)
 app.include_router(builder_router.router)
+app.include_router(fraude_router.router)
+app.include_router(tiktok_router.router)
 
 ensure_db()
 
@@ -264,7 +268,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.13"}
+    return {"version": APP_VERSION, "canonical": "0.1.15"}
 
 
 @app.get("/api/settings")
@@ -300,6 +304,20 @@ def track(request: Request):
     forwarded = request.headers.get("x-forwarded-for", "")
     ip = forwarded.split(",")[0].strip() or (request.client.host if request.client else "")
     known = {"event", "page", "gclid", "utm_source", "utm_medium", "utm_campaign", "ref"}
+
+    # Anti-fraude (AdsPixel): IP bloqueado nao entra no tracking; spam e sinalizado
+    from .services import fraude
+
+    try:
+        avaliacao = fraude.avaliar_visita(ip)
+        if avaliacao.get("bloqueado"):
+            # IP na blacklist: nao grava a visita (o pixel segue respondendo 204)
+            return Response(status_code=204, headers={"Access-Control-Allow-Origin": "*"})
+        if params.get("event") == "cta_click":
+            fraude.registrar_clique(ip, params.get("page", ""))
+    except Exception:
+        pass  # anti-fraude nunca quebra o pixel
+    extra_params = json.dumps({k: v for k, v in params.items() if k not in known}, ensure_ascii=False)
     try:
         with get_db() as conn:
             conn.execute(
@@ -314,7 +332,7 @@ def track(request: Request):
                     params.get("ref", ""),
                     ip,
                     request.headers.get("user-agent", ""),
-                    json.dumps({k: v for k, v in params.items() if k not in known}, ensure_ascii=False),
+                    extra_params,
                     now_str(),
                 ),
             )

package/app/services/builder.py

@@ -94,6 +94,56 @@ def gerar_estrutura(oferta: dict) -> dict:
     return {"estrutura": estrutura, "provider": result["provider"]}
 
 
+def gerar_produto(oferta: dict, estrutura: dict, formato: str = "") -> dict:
+    """Gera o CONTEÚDO COMPLETO do produto em Markdown (estrutura obrigatória do agente .md)."""
+    if not oferta or not (oferta.get("promessa") or "").strip():
+        raise LLMError("Selecione uma oferta antes de gerar o conteúdo do produto.")
+    formato = (formato or oferta.get("formato") or "E-book").strip()
+    prompt = _fill(
+        _template("builder-produto.md", "Gere o conteudo completo do produto {OFERTA} em Markdown."),
+        {
+            "OFERTA": oferta.get("nome") or "",
+            "FORMATO": formato,
+            "PROMESSA": oferta.get("promessa") or "",
+            "NICHO": oferta.get("publico") or (oferta.get("dores") or [""])[0],
+            "AVATAR": oferta.get("publico") or "",
+            "PRECO": oferta.get("preco_sugerido") or 47,
+        },
+    )
+    result = generate(
+        prompt,
+        system="Você é um especialista em produtos digitais práticos. Escreva o produto completo em Markdown, sem comentários.",
+        max_tokens=12000,
+    )
+    md_text = (result["text"] or "").strip()
+    if len(md_text) < 400 or "##" not in md_text:
+        raise LLMError("O LLM não retornou o conteúdo completo do produto — tente novamente.")
+    return {"markdown": md_text, "provider": result["provider"]}
+
+
+def gerar_assets(oferta: dict, preco: float = 47) -> dict:
+    """Gera 3 Order Bumps (checkout/upsell/parceiro 50-50) + Quiz com IA."""
+    if not oferta or not (oferta.get("promessa") or "").strip():
+        raise LLMError("Selecione uma oferta antes de gerar os assets.")
+    prompt = _fill(
+        _template("builder-assets.md", "Gere order bumps e quiz para {OFERTA} em JSON."),
+        {
+            "OFERTA": oferta.get("nome") or "",
+            "PROMESSA": oferta.get("promessa") or "",
+            "PRECO": preco or oferta.get("preco_sugerido") or 47,
+        },
+    )
+    result = generate(prompt, system="Você é um estrategista de monetização. Responda SOMENTE JSON válido.", max_tokens=5000)
+    try:
+        parsed = _parse_json(result["text"])
+    except json.JSONDecodeError as exc:
+        raise LLMError(f"JSON do LLM inválido: {exc}") from exc
+    bumps = parsed.get("order_bumps") or []
+    if len(bumps) < 3:
+        raise LLMError(f"O LLM retornou {len(bumps)} order bumps (esperado 3) — tente novamente.")
+    return {"order_bumps": bumps[:3], "quiz": parsed.get("quiz") or {}, "provider": result["provider"]}
+
+
 def gerar_anuncios(produto: str, promessa: str, nicho: str = "", link: str = "") -> dict:
     if not produto.strip():
         raise LLMError("Informe o nome do produto para gerar os anúncios.")
@@ -101,15 +151,16 @@ def gerar_anuncios(produto: str, promessa: str, nicho: str = "", link: str = "")
         _template("builder-anuncios.md", "Gere 12 anuncios para {PRODUTO} em JSON com chave 'anuncios'."),
         {"PRODUTO": produto, "PROMESSA": promessa, "NICHO": nicho, "LINK": link},
     )
-    result = generate(prompt, system="Você é um copywriter de direct response. Responda SOMENTE JSON válido.", max_tokens=5000)
+    result = generate(prompt, system="Você é um copywriter de direct response e especialista em Pinterest. Responda SOMENTE JSON válido.", max_tokens=6000)
     try:
         parsed = _parse_json(result["text"])
     except json.JSONDecodeError as exc:
         raise LLMError(f"JSON do LLM inválido: {exc}") from exc
     anuncios = [item for item in (parsed.get("anuncios") or []) if isinstance(item, dict)]
+    pins = [item for item in (parsed.get("pins") or []) if isinstance(item, dict)]
     if len(anuncios) < 12:
         raise LLMError(f"O LLM retornou {len(anuncios)} anúncios (esperado 12) — tente novamente.")
-    return {"anuncios": anuncios[:12], "provider": result["provider"]}
+    return {"anuncios": anuncios[:12], "pins": pins[:10], "provider": result["provider"]}
 
 
 def _imagem_prompts(oferta: dict, estrutura: dict) -> list[str]:
@@ -154,14 +205,48 @@ def _ensure_columns() -> None:
         add_column_if_missing(conn, "infoprodutos", "oferta_json TEXT NOT NULL DEFAULT ''", "oferta_json")
         add_column_if_missing(conn, "infoprodutos", "estrutura_json TEXT NOT NULL DEFAULT ''", "estrutura_json")
         add_column_if_missing(conn, "infoprodutos", "anuncios_json TEXT NOT NULL DEFAULT ''", "anuncios_json")
+        add_column_if_missing(conn, "infoprodutos", "pins_json TEXT NOT NULL DEFAULT ''", "pins_json")
         add_column_if_missing(conn, "infoprodutos", "preco REAL NOT NULL DEFAULT 0", "preco")
         add_column_if_missing(conn, "infoprodutos", "parceiro TEXT NOT NULL DEFAULT ''", "parceiro")
+        add_column_if_missing(conn, "infoprodutos", "produto_id INTEGER", "produto_id")
+
+
+def gerar_landing(oferta: dict, estrutura: dict, produto_md: str = "") -> dict:
+    """Gera a landing page de vendas (12 seções) via motor de páginas e salva em paginas."""
+    from . import pages
+
+    form = {
+        "titulo": oferta.get("nome") or "Produto",
+        "avatar": oferta.get("publico") or "",
+        "resultado": oferta.get("promessa") or "",
+        "dor": (oferta.get("dores") or [""])[0],
+        "afiliado_link": oferta.get("checkout_link") or "",
+        "checkout_link": oferta.get("checkout_link") or "",
+        "prompt": (produto_md or "")[:3000],
+    }
+    produto_ctx = {"id": None, "nome": oferta.get("nome") or "Produto", "link_afiliado": oferta.get("checkout_link") or ""}
+    resultado = pages.gerar_pagina("vendas", produto_ctx, form)
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO paginas (titulo, tipo, produto_id, idioma, html_path, status, created_at, updated_at) VALUES (?, 'vendas', NULL, ?, '', 'rascunho', ?, ?)",
+            ((oferta.get("nome") or "Produto")[:120], oferta.get("idioma") or "Portugues", timestamp, timestamp),
+        )
+        page_id = cursor.lastrowid
+    pages.salvar_html(page_id, resultado["html"])
+    with get_db() as conn:
+        conn.execute("UPDATE paginas SET html_path = ? WHERE id = ?", (f"pages/{page_id}/index.html", page_id))
+        row = conn.execute("SELECT * FROM paginas WHERE id = ?", (page_id,)).fetchone()
+    record = row_to_dict(row)
+    record["preview_url"] = f"/pages/{page_id}"
+    record["provider"] = resultado["provider"]
+    return record
 
 
-def gerar_pdf(oferta: dict, estrutura: dict, preco: float, parceiro: str = "", modo: str = "rapido") -> dict:
-    """Gera o PDF do produto + prompts de imagem (Gamma/Canva). Salva em infoprodutos."""
+def gerar_pdf(oferta: dict, estrutura: dict, preco: float, parceiro: str = "", modo: str = "rapido", produto_md: str = "") -> dict:
+    """Gera o PDF do produto (conteúdo completo quando disponível) + prompts de imagem."""
     _ensure_columns()
-    md_text = _markdown_produto(oferta, estrutura, preco, parceiro)
+    md_text = (produto_md or "").strip() or _markdown_produto(oferta, estrutura, preco, parceiro)
     prompt_imagens = _imagem_prompts(oferta, estrutura)
     timestamp = now_str()
     with get_db() as conn:
@@ -204,14 +289,45 @@ def gerar_pdf(oferta: dict, estrutura: dict, preco: float, parceiro: str = "", m
     return record
 
 
-def salvar(anuncios: list, record_id: int) -> dict:
+def _criar_produto_para_consumo(record_id: int) -> dict:
+    """Cria (ou reusa) o registro em `produtos` para AdsPages/AdsCreator consumirem."""
+    row = _get_infoproduto(record_id)
+    oferta = json.loads(row.get("oferta_json") or "{}")
+    nome = (oferta.get("nome") or row["titulo"] or "Produto")[:160]
+    with get_db() as conn:
+        existente = None
+        if row.get("produto_id"):
+            existente = conn.execute("SELECT id FROM produtos WHERE id = ?", (row["produto_id"],)).fetchone()
+        if not existente:
+            mesmo_nome = conn.execute("SELECT id FROM produtos WHERE nome = ? ORDER BY id DESC LIMIT 1", (nome,)).fetchone()
+            if mesmo_nome:
+                produto_id = mesmo_nome["id"]
+            else:
+                cursor = conn.execute(
+                    "INSERT INTO produtos (nome, plataforma, link_afiliado, comissao, preco, nicho, status, created_at, updated_at) VALUES (?, 'Outro', '', 0, ?, ?, 'aprovado', ?, ?)",
+                    (nome, float(row.get("preco") or oferta.get("preco_sugerido") or 47), (oferta.get("publico") or "")[:120], now_str(), now_str()),
+                )
+                produto_id = cursor.lastrowid
+        conn.execute("UPDATE infoprodutos SET produto_id = ? WHERE id = ?", (produto_id, record_id))
+    return {"produto_id": produto_id, "nome": nome}
+
+
+def _get_infoproduto(record_id: int) -> dict:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM infoprodutos WHERE id = ?", (record_id,)).fetchone()
+    if not row:
+        raise LLMError("Infoproduto não encontrado.")
+    return row_to_dict(row)
+
+
+def salvar(anuncios: list, record_id: int, pins: list | None = None) -> dict:
     _ensure_columns()
     with get_db() as conn:
         conn.execute(
-            "UPDATE infoprodutos SET anuncios_json = ? WHERE id = ?",
-            (json.dumps(anuncios[:12], ensure_ascii=False), record_id),
+            "UPDATE infoprodutos SET anuncios_json = ?, pins_json = ? WHERE id = ?",
+            (json.dumps((anuncios or [])[:12], ensure_ascii=False), json.dumps((pins or [])[:10], ensure_ascii=False), record_id),
         )
-        row = conn.execute("SELECT * FROM infoprodutos WHERE id = ?", (record_id,)).fetchone()
-    record = row_to_dict(row)
+    produto = _criar_produto_para_consumo(record_id)
+    record = _get_infoproduto(record_id)
     oferta = json.loads(record.get("oferta_json") or "{}")
-    return {**record, "oferta": oferta}
+    return {**record, "oferta": oferta, "produto": produto}

package/app/services/database.py

@@ -1,17 +1,17 @@
-"""Banco de dados — façade sobre dbengine (SQLite padrão, PostgreSQL/Supabase via DATABASE_URL).
+"""Banco de dados — fachada sobre dbengine (SQLite padrao, PostgreSQL/Supabase via DATABASE_URL).
 
-Esquema único para os dois engines. Todas as tabelas carregam `user_id` (preparação
-multi-tenant — hoje vazio). `ensure_db()` cria o que falta e aplica ALTERs de migração.
+Esquema unico para os dois engines. Todas as tabelas carregam `user_id` (preparacao
+multi-tenant — hoje vazio). `ensure_db()` cria o que falta e aplica ALTERs de migracao.
 """
 from .dbengine import (
     add_column_if_missing,
     is_postgres,
-    now_str,  # noqa: F401  (reexportado para os serviços)
-    row_to_dict,  # noqa: F401  (reexportado para os serviços)
+    now_str,  # noqa: F401  (reexportado para os servicos)
+    row_to_dict,  # noqa: F401  (reexportado para os servicos)
 )
 
 # ---------------------------------------------------------------------------
-# Esquema — SQLite DDL; para PostgreSQL as mesmas definições são traduzidas.
+# Esquema — SQLite DDL; para PostgreSQL as mesmas definicoes sao traduzidas.
 # ---------------------------------------------------------------------------
 
 TABLES = {
@@ -201,6 +201,26 @@ TABLES = {
             created_at TEXT NOT NULL
         )
     """,
+    "ips_bloqueados": """
+        CREATE TABLE IF NOT EXISTS ips_bloqueados (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id TEXT NOT NULL DEFAULT '',
+            ip TEXT NOT NULL,
+            motivo TEXT NOT NULL DEFAULT 'manual',
+            origem TEXT NOT NULL DEFAULT 'sqlite',
+            created_at TEXT NOT NULL
+        )
+    """,
+    "fraude_eventos": """
+        CREATE TABLE IF NOT EXISTS fraude_eventos (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id TEXT NOT NULL DEFAULT '',
+            ip TEXT NOT NULL,
+            page TEXT NOT NULL DEFAULT '',
+            created_epoch REAL NOT NULL DEFAULT 0,
+            created_at TEXT NOT NULL
+        )
+    """,
 }
 
 ALL_TABLES = list(TABLES.keys())
@@ -225,11 +245,9 @@ def ensure_db() -> None:
         else:
             for ddl in TABLES.values():
                 conn.execute(ddl)
-            # Migração: bancos criados antes da coluna user_id / da tabela investimentos
+            # Migracao: bancos criados antes da coluna user_id / da tabela investimentos
             for table in ALL_TABLES:
                 add_column_if_missing(conn, table, "user_id TEXT NOT NULL DEFAULT ''", "user_id")
-            if "investimentos" not in [row["name"] for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")]:
-                conn.execute(TABLES["investimentos"])
         conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_gclid ON vendas (gclid)")
         conn.execute("CREATE INDEX IF NOT EXISTS idx_visitas_gclid ON visitas (gclid)")