Grok Bot do zero em uma noite: configuração completa + filtro de rug pull pronto para copiar e colar

1Nome: RUG DESK
2Tarefa: Mesa de memecoins Solana, primeiro no modo paper
3Descrição: Monte e rode a mesa em /workspace/desk a partir do artigo que vou colar.
4Todo token passa pelo check.py, sem exceções, sem atalhos.
5Você nunca compra, vende, assina ou move fundos. Você nunca edita o config.py a menos que eu peça
6neste chat. Você nunca abaixa o número de um filtro para deixar um token passar.
7Reporte cada eliminação com o motivo, não com sua opinião sobre o token.
8Quando uma fonte estiver fora do ar, diga qual e pule. Nunca chute um número ausente.

1mkdir -p /workspace/desk && cd /workspace/desk
2read -rs -p "xai key: " K && printf 'XAI_API_KEY=%s\n' "$K" > .env && unset K
3chmod 600 .env
4pip install requests

1curl -s https://api.x.ai/v1/responses \
2  -H "Authorization: Bearer $(cut -d= -f2 .env)" \
3  -H "Content-Type: application/json" \
4  -d '{"model":"grok-4.7","input":"reply with OK"}'
5
6-> ... "type":"output_text","text":"OK" ...

10. LEAD     um CA de qualquer lugar: uma call, um post, scan.py    -> um mint
21. LIMITES   book.py: perda diária, slots abertos, cooldown      -> grátis, sem rede nenhuma
32. FATOS    rugcheck.py: 10 eliminações definitivas                     -> mint aberto, LP destravado, top 10 gordo morrem aqui
43. POOL     market.py: profundidade, idade, vendas                   -> pools finas e honeypots morrem aqui
54. JUIZ    grok.py + busca no X, uma chamada                   -> BUY ou SKIP, um motivo, um risco
65. PREENCHER     paper: book.py no preço real               -> ao vivo: você mesmo assina
76. MONITORAR    watch.py a cada 10 minutos                      -> stop, escadinha, trailing, stop por tempo
87. RELATÓRIO   report.py às 21:30                             -> o que morreu, o que pagou, o que questionar

1# config.py
2# todo número da mesa vive aqui. quando você recalibrar, edite este arquivo e mais nada.
3
4MODEL = "grok-4.7"          # confira em console.x.ai -> Models se a API rejeitar
5PAPER = True                # primeira semana: preenchimentos falsos com preços reais. mude só depois de ler o log
6
7TICKET_USD = 25             # fixo. nunca dimensionado com base na última vitória
8MAX_OPEN = 4                # 4 x US$ 25 = US$ 100 no mercado, no máximo
9MAX_ENTRIES_PER_DAY = 6
10DAILY_LOSS_HALT_USD = 50    # perda realizada hoje bate nisso -> sem novas entradas até amanhã
11COOLDOWN_HOURS = 24         # sem reentrada num token que você acabou de sair
12
13FACTS = {                   # o filtro de rug. só código, sem modelo
14    "max_risk_score": 40,       # score_normalised do rugcheck, 0-100, maior = mais arriscado
15    "min_lp_locked_pct": 90,    # maior pool: LP travado ou queimado
16    "max_top10_pct": 30,        # top 10 holders, excluindo pools e lockers
17    "max_dev_pct": 5,           # supply ainda parado na carteira do criador
18    "max_insiders": 0,          # holders marcados como insider + acertos no gráfico de insiders
19    "min_liquidity_usd": 30000,
20    "max_ticket_share": 0.01,   # seu ticket nunca é mais que 1% da pool
21    "min_age_min": 30,          # mais novo que isso, todo relatório ainda é chute
22    "max_age_hours": 72,
23}
24
25MIN_CONFIDENCE = 0.7        # Grok diz BUY abaixo disso -> tratado como SKIP
26
27EXIT = {
28    "stop_pct": -35,                        # stop definitivo a partir da entrada
29    "ladder": [(100, 0.50), (200, 0.25)],   # +100% vende metade, +200% vende um quarto
30    "trail_pct": 30,                        # o resto: sai quando o preço cai 30% do topo
31    "time_stop_hours": 6,                   # não subiu 20% depois de 6 horas -> sai, dinheiro morto
32    "time_stop_min_pct": 20,
33    "liq_drop_pct": 40,                     # liquidez da pool caiu 40% desde a entrada -> sai agora
34}
35
36LOG = "checks.csv"
37POSITIONS = "positions.json"
38TRADES = "trades.csv"

1TICKET FIXO. o tamanho nunca cresce porque as três últimas ganharam.
2O BOT LÊ config.py, NUNCA ESCREVE NELE. um número só muda quando você muda.
3FILTRO SÓ É AFROUXADO POR ESCRITO. você muda um número, explica o porquê no chat, no mesmo dia.

1# book.py
2# posições, trades, limites. a memória da mesa vive em dois arquivos que você mesmo pode abrir.
3import csv, json, os, sys, time
4from config import (POSITIONS, TRADES, TICKET_USD, MAX_OPEN, MAX_ENTRIES_PER_DAY,
5                    DAILY_LOSS_HALT_USD, COOLDOWN_HOURS)
6
7def load() -> dict:
8    return json.load(open(POSITIONS)) if os.path.exists(POSITIONS) else {}
9
10def save(book: dict):
11    json.dump(book, open(POSITIONS, "w"), indent=2)
12
13def trades() -> list[dict]:
14    return list(csv.DictReader(open(TRADES))) if os.path.exists(TRADES) else []
15
16def record(mint, symbol, action, usd, pnl, reason):
17    new = not os.path.exists(TRADES)
18    with open(TRADES, "a", newline="") as f:
19        w = csv.DictWriter(f, fieldnames=["time", "mint", "symbol", "action", "usd", "pnl", "reason"])
20        if new:
21            w.writeheader()
22        w.writerow({"time": time.strftime("%Y-%m-%d %H:%M"), "mint": mint, "symbol": symbol,
23                    "action": action, "usd": round(usd, 2), "pnl": round(pnl, 2), "reason": reason})
24
25def today_pnl() -> float:
26    day = time.strftime("%Y-%m-%d")
27    return sum(float(t["pnl"]) for t in trades() if t["time"].startswith(day))
28
29def guard(mint: str) -> str | None:
30    """Limites rodam antes de qualquer chamada de rede. Uma entrada bloqueada não custa nada."""
31    day = time.strftime("%Y-%m-%d")
32    book = load()
33    if today_pnl() <= -DAILY_LOSS_HALT_USD:                      return "halted_daily_loss"
34    if mint in book:                                             return "already_open"
35    if len(book) >= MAX_OPEN:                                    return "max_open"
36    opens = [t for t in trades() if t["action"] == "open" and t["time"].startswith(day)]
37    if len(opens) >= MAX_ENTRIES_PER_DAY:                        return "max_entries_today"
38    cutoff = time.strftime("%Y-%m-%d %H:%M", time.localtime(time.time() - COOLDOWN_HOURS * 3600))
39    if any(t["mint"] == mint and t["action"] == "close" and t["time"] >= cutoff for t in trades()):
40        return "cooldown"
41    return None
42
43def open_position(mint, symbol, price, liq_usd, usd=TICKET_USD):
44    book = load()
45    book[mint] = {"symbol": symbol, "entry": price, "qty0": usd / price, "qty": usd / price,
46                  "peak": price, "liq0": liq_usd, "opened": time.time(), "steps": 0}
47    save(book)
48    record(mint, symbol, "open", usd, 0, "entry")
49
50def sell(mint, frac_of_original, price, reason) -> float:
51    """Vende uma fração do tamanho ORIGINAL (1.0 = tudo o que sobrou). Retorna o pnl realizado."""
52    book = load()
53    p = book[mint]
54    q = min(p["qty"], p["qty0"] * frac_of_original)
55    pnl = q * (price - p["entry"])
56    p["qty"] -= q
57    action = "close" if p["qty"] <= p["qty0"] * 1e-6 else "partial"
58    record(mint, p["symbol"], action, q * price, pnl, reason)
59    if action == "close":
60        del book[mint]
61    save(book)
62    return pnl
63
64if __name__ == "__main__":
65    # modo ao vivo: depois de comprar na sua própria carteira ->  python book.py add <mint> <usd> <preço> <liq_usd>
66    # depois de vender manualmente                     ->  python book.py close <mint> <preço>
67    cmd = sys.argv[1]
68    if cmd == "add":
69        mint, usd, price, liq = sys.argv[2], float(sys.argv[3]), float(sys.argv[4]), float(sys.argv[5])
70        open_position(mint, mint[:6], price, liq, usd)
71    elif cmd == "close":
72        print(round(sell(sys.argv[2], 1.0, float(sys.argv[3]), "manual"), 2))

1# watch.py
2# cada posição aberta, a cada 10 minutos. não imprime nada quando nada mudou.
3import time
4from config import EXIT, PAPER
5from market import pool
6import book
7
8def watch() -> list[str]:
9    events = []
10    for mint, p in list(book.load().items()):
11        try:
12            m = pool(mint)
13        except Exception as e:
14            events.append(f"{p['symbol']}: feed de preço fora do ar ({e}), segurando, vou tentar de novo")
15            continue
16        if not m or m["price"] <= 0:
17            events.append(f"{p['symbol']}: pool sumiu. trate como rug, venda o que der")
18            book.sell(mint, 1.0, 0.0, "pool_gone")
19            continue
20
21        price = m["price"]
22        b = book.load(); s = b[mint]
23        s["peak"] = max(s["peak"], price); book.save(b)
24        pct = (price / s["entry"] - 1) * 100
25        hours = (time.time() - s["opened"]) / 3600
26
27        def out(frac, why):
28            pnl = book.sell(mint, frac, price, why)
29            verb = "vendeu" if PAPER else "VENDA AGORA na sua carteira"
30            size = "o resto" if frac >= 1 else f"{int(frac * 100)}%"
31            events.append(f"{s['symbol']}: {verb} {size} a {pct:+.0f}% ({why}), pnl ${pnl:+.2f}")
32
33        if m["liq_usd"] < s["liq0"] * (1 - EXIT["liq_drop_pct"] / 100):
34            out(1.0, "liquidity_pulled"); continue
35        if pct <= EXIT["stop_pct"]:
36            out(1.0, "stop"); continue
37        ladder = EXIT["ladder"]
38        if s["steps"] < len(ladder) and pct >= ladder[s["steps"]][0]:
39            out(ladder[s["steps"]][1], f"take_profit_{ladder[s['steps']][0]}")
40            b = book.load()
41            if mint in b:
42                b[mint]["steps"] += 1; book.save(b)
43            continue
44        if s["steps"] > 0 and price <= s["peak"] * (1 - EXIT["trail_pct"] / 100):
45            out(1.0, "trailing_stop"); continue
46        if hours >= EXIT["time_stop_hours"] and pct < EXIT["time_stop_min_pct"]:
47            out(1.0, "time_stop")
48    return events
49
50if __name__ == "__main__":
51    for e in watch():
52        print(e)

1LIQUIDEZ PRIMEIRO. uma pool puxada vence qualquer outra regra, mesmo numa posição no verde.
2O TRAILING SÓ ARMA DEPOIS DA PRIMEIRA REALIZAÇÃO. antes disso, -35% é o único piso.
3DINHEIRO MORTO TAMBÉM É PREJUÍZO. seis horas paradas liberam o slot para o próximo token.
4SILÊNCIO É UM STATUS. watch.py não imprime nada quando nada mudou, então um chat quieto significa que você não precisa olhar.

1# rugcheck.py
2# um relatório por token, cortado para os campos que a mesa lê. o Grok nunca vê o relatório bruto.
3import requests
4from config import FACTS
5
6RC = "https://api.rugcheck.xyz/v1/tokens"
7
8def report(mint: str) -> dict:
9    r = requests.get(f"{RC}/{mint}/report", timeout=20)
10    r.raise_for_status()
11    d = r.json()
12    token = d.get("token") or {}
13    known = d.get("knownAccounts") or {}
14
15    def is_pool(h):  # vaults AMM e lockers ficam nos top holders, não são baleias
16        tag = known.get(h.get("owner")) or known.get(h.get("address")) or {}
17        return str(tag.get("type", "")).upper() in ("AMM", "LOCKER")
18
19    holders = [h for h in (d.get("topHolders") or []) if not is_pool(h)]
20    markets = sorted(d.get("markets") or [],
21                     key=lambda m: ((m.get("lp") or {}).get("baseUSD") or 0)
22                                 + ((m.get("lp") or {}).get("quoteUSD") or 0),
23                     reverse=True)
24    lp = (markets[0].get("lp") or {}) if markets else {}
25    supply = token.get("supply") or 0
26    risks = d.get("risks") or []
27
28    return {
29        "mint": mint,
30        "symbol": (d.get("tokenMeta") or {}).get("symbol"),
31        "rugged": bool(d.get("rugged")),
32        "risk_score": d.get("score_normalised"),
33        "danger": [x.get("name") for x in risks if x.get("level") == "danger"],
34        "warn": [x.get("name") for x in risks if x.get("level") == "warn"],
35        "mint_authority": token.get("mintAuthority", d.get("mintAuthority")),
36        "freeze_authority": token.get("freezeAuthority", d.get("freezeAuthority")),
37        "lp_locked_pct": lp.get("lpLockedPct", d.get("lpLockedPct")),
38        "top10_pct": round(sum(h.get("pct") or 0 for h in holders[:10]), 2) if holders else None,
39        "dev_pct": round((d.get("creatorBalance") or 0) / supply * 100, 2) if supply else None,
40        "insiders": sum(1 for h in holders if h.get("insider")) + (d.get("graphInsidersDetected") or 0),
41        "holders": d.get("totalHolders"),
42    }
43
44def fact_kill(t: dict) -> str | None:
45    """Comparações simples. A primeira falha vence, o motivo é registrado."""
46    if t["risk_score"] is None:                                  return "no_report"
47    if t["rugged"]:                                              return "already_rugged"
48    if t["mint_authority"]:                                      return "mint_open"
49    if t["freeze_authority"]:                                    return "freeze_open"
50    if t["danger"]:                                              return "danger:" + t["danger"][0]
51    if t["risk_score"] > FACTS["max_risk_score"]:                return "risk_score"
52    if t["lp_locked_pct"] is None or t["lp_locked_pct"] < FACTS["min_lp_locked_pct"]:
53        return "lp_unlocked"
54    if t["top10_pct"] is None or t["top10_pct"] > FACTS["max_top10_pct"]:
55        return "top10_heavy"
56    if t["dev_pct"] is None or t["dev_pct"] > FACTS["max_dev_pct"]:
57        return "dev_holds"
58    if t["insiders"] > FACTS["max_insiders"]:                    return "insiders"
59    return None

1# market.py
2# a pool em si: profundidade, idade, preço e se alguém consegue mesmo vender.
3import time
4import requests
5from config import FACTS, TICKET_USD
6
7DS = "https://api.dexscreener.com/tokens/v1/solana"
8
9def pool(mint: str) -> dict | None:
10    r = requests.get(f"{DS}/{mint}", timeout=15)
11    r.raise_for_status()
12    data = r.json()
13    pairs = data if isinstance(data, list) else (data.get("pairs") or [])
14    pairs = [p for p in pairs if (p.get("baseToken") or {}).get("address") == mint]
15    if not pairs:
16        return None
17    p = max(pairs, key=lambda x: (x.get("liquidity") or {}).get("usd") or 0)
18    h1 = (p.get("txns") or {}).get("h1") or {}
19    born = p.get("pairCreatedAt")
20    return {
21        "symbol": (p.get("baseToken") or {}).get("symbol"),
22        "price": float(p.get("priceUsd") or 0),
23        "liq_usd": (p.get("liquidity") or {}).get("usd") or 0,
24        "age_min": round((time.time() * 1000 - born) / 60000) if born else None,
25        "buys_1h": h1.get("buys", 0),
26        "sells_1h": h1.get("sells", 0),
27        "vol_1h": (p.get("volume") or {}).get("h1"),
28        "url": p.get("url"),
29    }
30
31def market_kill(m: dict | None) -> str | None:
32    if not m:                                                    return "no_pool"
33    if m["price"] <= 0:                                          return "no_price"
34    if m["liq_usd"] < FACTS["min_liquidity_usd"]:                return "thin_pool"
35    if TICKET_USD / m["liq_usd"] > FACTS["max_ticket_share"]:    return "ticket_too_big"
36    if m["age_min"] is None or m["age_min"] < FACTS["min_age_min"]:
37        return "too_fresh"
38    if m["age_min"] > FACTS["max_age_hours"] * 60:               return "too_old"
39    if m["buys_1h"] >= 20 and m["sells_1h"] == 0:                return "nobody_can_sell"
40    return None

1# grok.py
2# o único arquivo que guarda a chave e o único lugar onde a mesa fala com a xAI.
3import os, json, datetime, requests
4from config import MODEL
5
6URL = "https://api.x.ai/v1/responses"
7
8def _key() -> str:
9    k = os.environ.get("XAI_API_KEY")
10    if not k and os.path.exists(".env"):
11        for line in open(".env"):
12            if line.startswith("XAI_API_KEY="):
13                k = line.split("=", 1)[1].strip().strip('"')
14    if not k:
15        raise RuntimeError("no XAI_API_KEY in the environment or in .env")
16    return k
17
18def _text(resp: dict) -> str:
19    if isinstance(resp.get("output_text"), str):
20        return resp["output_text"]
21    parts = []
22    for item in resp.get("output") or []:
23        if item.get("type") == "message":
24            for c in item.get("content") or []:
25                if c.get("type") in ("output_text", "text"):
26                    parts.append(c.get("text") or "")
27    return "\n".join(parts)
28
29def ask(system: str, payload: dict, read_x: bool = False) -> dict:
30    """Uma chamada, JSON entra, JSON sai. Qualquer coisa que não seja JSON gera erro, e um erro é um SKIP lá em cima."""
31    body = {"model": MODEL,
32            "input": [{"role": "system", "content": system},
33                      {"role": "user", "content": json.dumps(payload)}]}
34    if read_x:
35        since = (datetime.date.today() - datetime.timedelta(days=3)).isoformat()
36        body["tools"] = [{"type": "x_search", "from_date": since}]
37        body["max_turns"] = 2          # duas rodadas de busca, depois ele tem que responder
38    r = requests.post(URL, timeout=180, json=body,
39                      headers={"Authorization": f"Bearer {_key()}"})
40    r.raise_for_status()
41    text = _text(r.json())
42    start, end = text.find("{"), text.rfind("}")
43    if start == -1:
44        raise ValueError(f"no json in answer: {text[:200]}")
45    return json.loads(text[start:end + 1])

1# prompts.py
2# o único prompt do Grok na mesa. este é o arquivo que você vai realmente reler.
3
4JUDGE_PROMPT = """
5Você é o RUG DESK. Uma memecoin da Solana acabou de passar por todas as verificações rigorosas no código:
6autoridades, LP, holders, carteira do dev, insiders, profundidade da pool, idade.
7Não verifique esses números de novo. Você decide se um ticket fixo entra.
8Você nunca define tamanho de posição, nunca escolhe saídas.
9
10ENTRADA: {"token": {...fatos do rugcheck...}, "pool": {...fatos do dexscreener...}}
11
12PASSO 1. Pesquise no X pelo ticker e pelo endereço do contrato, nas últimas 72 horas.
13PASSO 2. Julgue apenas o que o código não consegue ver:
14  - os riscos de nível warn se acumulam em algo pior juntos?
15  - quem postou primeiro: o dev, uma conta real com histórico ou uma onda de contas novas?
16  - orgânico ou comprado: mesmo texto, mesmo minuto, contas sem passado
17  - o endereço do contrato nessas postagens é o mesmo da ENTRADA?
18  - esse nome de ticker ou esse dev já esteve ligado a algum rug antes?
19
20RETORNE APENAS JSON:
21{"verdict": "BUY" | "SKIP", "confidence": 0.0-1.0,
22 "why": "máximo duas linhas", "x_read": "uma linha sobre como o X está",
23 "main_risk": "uma linha"}
24
25Zero posts no X é uma resposta: ninguém sabe que existe. SKIP.
26Outro endereço de contrato com o mesmo ticker no X: risco de cópia. SKIP.
27NUNCA responda BUY quando um campo necessário for null.
28NUNCA mencione alvos de preço. Você não os conhece.
29"""

1# check.py
2# um endereço de contrato entra, um veredito sai. roda toda vez que um token passa pela sua mesa.
3import csv, json, os, sys, time
4from config import LOG, MIN_CONFIDENCE, PAPER, TICKET_USD
5from rugcheck import report, fact_kill
6from market import pool, market_kill
7from grok import ask
8from prompts import JUDGE_PROMPT
9import book
10
11def log(row: dict):
12    new = not os.path.exists(LOG)
13    with open(LOG, "a", newline="") as f:
14        w = csv.DictWriter(f, fieldnames=["time", "mint", "symbol", "stage", "verdict",
15                                          "confidence", "reason"])
16        if new:
17            w.writeheader()
18        w.writerow({k: row.get(k) for k in w.fieldnames})
19
20def check(mint: str) -> dict:
21    if (g := book.guard(mint)):                                  # limites, grátis
22        return {"stage": "limits", "verdict": "SKIP", "reason": g}
23
24    try:
25        token = report(mint)                                     # filtro de rug, grátis
26    except Exception as e:
27        return {"stage": "facts", "verdict": "SKIP", "reason": f"rugcheck failed: {e}"}
28    if (k := fact_kill(token)):
29        return {"stage": "facts", "verdict": "SKIP", "reason": k, "symbol": token["symbol"]}
30
31    try:
32        m = pool(mint)                                           # pool, grátis
33    except Exception as e:
34        return {"stage": "pool", "verdict": "SKIP", "reason": f"dexscreener failed: {e}"}
35    if (k := market_kill(m)):
36        return {"stage": "pool", "verdict": "SKIP", "reason": k, "symbol": token["symbol"]}
37
38    try:
39        ans = ask(JUDGE_PROMPT, {"token": token, "pool": m}, read_x=True)   # o único passo pago
40    except Exception as e:
41        return {"stage": "grok", "verdict": "SKIP", "reason": f"grok failed: {e}"}
42
43    verdict, conf = ans.get("verdict"), ans.get("confidence") or 0
44    if verdict == "BUY" and conf < MIN_CONFIDENCE:
45        verdict = "SKIP"
46        ans["why"] = f"low confidence {conf}"
47    return {**ans, "stage": "grok", "verdict": verdict, "symbol": m["symbol"] or token["symbol"],
48            "reason": ans.get("why"), "price": m["price"], "liq_usd": m["liq_usd"], "url": m["url"]}
49
50if __name__ == "__main__":
51    mint = sys.argv[1].strip()
52    v = check(mint)
53    log({"time": time.strftime("%Y-%m-%d %H:%M"), "mint": mint, **v})
54    if v["verdict"] == "BUY":
55        if PAPER:
56            book.open_position(mint, v["symbol"], v["price"], v["liq_usd"])
57            v["action"] = f"PAPER BUY ${TICKET_USD} at {v['price']}"
58        else:
59            v["action"] = (f"APPROVAL NEEDED: buy ${TICKET_USD} of {v['symbol']} in your own wallet, "
60                           f"then run: python book.py add {mint} {TICKET_USD} <fill price> {v['liq_usd']}")
61    print(json.dumps(v, indent=2))

1{
2  "verdict": "SKIP",
3  "confidence": 0.78,
4  "why": "passa em todas as verificações rigorosas, mas os primeiros 30 posts vieram de contas criadas esta semana, com o mesmo texto.",
5  "x_read": "uma conta real, uma onda de contas novas, nenhuma divergência de CA",
6  "main_risk": "hype comprado, os compradores somem quando as postagens param",
7  "stage": "grok",
8  "symbol": "EXAMPLE",
9  "reason": "passa em todas as verificações rigorosas, mas os primeiros 30 posts vieram de contas criadas esta semana, com o mesmo texto."
10}

1FATOS ANTES DE OPINIÕES. O Grok nunca decide se um mint está aberto.
2UMA CHAMADA COM FALHA É UM SKIP. Rugcheck fora do ar, DexScreener fora do ar, Grok fora do ar, JSON ruim: SKIP.
3NULL NÃO É LIMPO. Um campo que não voltou elimina o token, nunca aprova.
4UM VEREDITO POR TOKEN. Nunca rode de novo até que diga BUY. Se você discordar, está discordando do config.py.
5LEIA OS KILLS, NÃO OS BUYS. Os buys dão uma sensação boa. Os motivos dos kills mostram se o filtro funciona.

1A cada 10 minutos, em /workspace/desk rode python watch.py.
2Se não imprimir nada, não diga nada. Se imprimir qualquer coisa, poste aqui palavra por palavra.

1A cada 30 minutos, em /workspace/desk rode python scan.py.
2Poste apenas vereditos BUY: symbol, confidence, x_read.
3Se o Rugcheck ou o DexScreener estiverem fora do ar, diga qual deles uma vez, não em cada execução.

1Todos os dias às 21:30, em /workspace/desk rode python report.py e poste a saída aqui.
2Adicione uma coisa que funcionou hoje e um número no config.py que você questionaria, com o motivo.
3Nunca altere esse número por conta própria.

1# report.py
2# o relatório da noite. tudo nele vem de checks.csv e trades.csv, nada da memória.
3import csv, os, time
4from collections import Counter
5from config import LOG, PAPER
6import book
7
8day = time.strftime("%Y-%m-%d")
9checks = [r for r in csv.DictReader(open(LOG))] if os.path.exists(LOG) else []
10checks = [r for r in checks if r["time"].startswith(day)]
11done = [t for t in book.trades() if t["time"].startswith(day) and t["action"] != "open"]
12
13by_stage = Counter(r["stage"] for r in checks if r["verdict"] == "SKIP")
14buys = [r for r in checks if r["verdict"] == "BUY"]
15wins = [t for t in done if float(t["pnl"]) > 0]
16reasons = Counter(r["reason"] for r in checks if r["stage"] in ("facts", "pool"))
17
18print(f"EVENING REPORT {day} {'(PAPER)' if PAPER else '(LIVE)'}")
19print(f"checked: {len(checks)}")
20print(f"killed by rug filter: {by_stage['facts']} | by pool: {by_stage['pool']} | "
21      f"by Grok: {by_stage['grok']} | by limits: {by_stage['limits']}")
22print(f"bought: {len(buys)} | open now: {len(book.load())}")
23print(f"realized pnl today: ${book.today_pnl():+.2f}")
24if done:
25    print(f"green exits: {len(wins)}/{len(done)}")
26    best = max(done, key=lambda t: float(t["pnl"]))
27    worst = min(done, key=lambda t: float(t["pnl"]))
28    print(f"best: {best['symbol']} ${float(best['pnl']):+.2f} | worst: {worst['symbol']} ${float(worst['pnl']):+.2f}")
29if reasons:
30    top, n = reasons.most_common(1)[0]
31    print(f"most common kill: {top} ({n}x)")

1# scan.py
2# fonte opcional de leads: tokens novos da Solana que acabaram de pagar por um perfil no DexScreener.
3# um perfil pago não é sinal de qualidade, só significa que o dev gastou dinheiro. o filtro decide.
4import csv, os, subprocess, sys
5import requests
6from config import LOG
7
8seen = {r["mint"] for r in csv.DictReader(open(LOG))} if os.path.exists(LOG) else set()
9r = requests.get("https://api.dexscreener.com/token-profiles/latest/v1", timeout=15)
10r.raise_for_status()
11fresh = [t["tokenAddress"] for t in r.json()
12         if t.get("chainId") == "solana" and t.get("tokenAddress") not in seen]
13
14for mint in fresh[:5]:                   # cinco por execução, para que uma hora movimentada não esgote o orçamento da API
15    subprocess.run([sys.executable, "check.py", mint])

1Pergunte antes de qualquer conexão de carteira, assinatura, swap ou transferência.
2Pergunte antes de editar qualquer arquivo chamado config.py.

1401 da xAI              -> chave ruim. Assuma o controle, reescreva o .env, rode o curl do passo 03 de novo.
2400 / 404 da xAI        -> o nome do modelo mudou. corrija o MODEL no config.py, nada mais.
3429 da xAI              -> limite de taxa. esse token é um SKIP, a próxima execução segue em frente. nunca faça loop nisso.
4erro sobre x_search     -> seu MODEL não pode pesquisar no X. escolha um que possa em console.x.ai -> Models.
5Grok responde em prosa  -> ValueError, registrado, SKIP. nunca transforme um parágrafo em uma operação.
6rugcheck 404 ou vazio   -> novo demais para indexar. SKIP. novo não é limpo.
7lp_unlocked em tudo     -> alguns tipos de pool não têm token de LP nenhum. Abra uma no rugcheck você mesmo
8                             antes de mexer nesse número, e altere por escrito.
9no_pool                 -> ainda não negociado em uma DEX, ou não é Solana. SKIP.
10rotinas ficaram quietas -> o Grok Bot pausa as rotinas depois que você fica muito tempo ausente.
11                             abra Routines e ligue-as de novo.

1custo_por_token = tokens_de_entrada / 1_000_000 * preco_por_M_entrada
2               + tokens_de_saida / 1_000_000 * preco_por_M_saida
3               + posts_busca / 1_000 * 5          # Busca no X: $5 por 1.000 posts buscados
4
5max_turns = 2 mantém a pesquisa em duas rodadas, então posts_busca continua pequeno.
6cada resposta informa seu próprio x_posts_fetched, então o dia um já te dá o número real.
7
8preço: [preço de console.x.ai]