一夜從零打造 Grok Bot：完整設定指南與可複製貼上的 Rug 過濾腳本

1名稱：RUG DESK
2工作：Solana memecoin 交易台，先跑模擬模式
3描述：根據我貼上的文章，在 /workspace/desk 建立並運行交易台。
4每個代幣都必須經過 check.py，沒有例外，不能走捷徑。
5你絕對不能買進、賣出、簽名或轉移資金。除非我在這個對話中要求，否則你不能編輯 config.py。你絕對不能為了放行某個代幣而調低過濾器的數值。
6回報每一次淘汰時都要附上原因，而不是你對這個代幣的看法。
7當某個資料來源掛掉時，說明是哪一個然後跳過。絕對不要猜測缺少的數值。

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     從任何地方拿到 CA：喊單、貼文、scan.py    -> 一個 mint
21. LIMITS   book.py：每日虧損、未平倉數量、冷卻時間      -> 免費，完全不碰網路
32. FACTS    rugcheck.py：10 項硬性淘汰                     -> 開放 mint、未鎖 LP、前 10 大持倉太集中，都在這裡出局
43. POOL     market.py：深度、年齡、賣壓                   -> 淺池和貔貅盤在這裡被淘汰
54. JUDGE    grok.py + X 搜尋，一次呼叫                   -> BUY 或 SKIP，一個理由，一個風險
65. FILL     模擬：book.py 按即時價格成交               -> 實戰：你自己簽名
76. WATCH    watch.py 每 10 分鐘檢查一次                      -> 停損、分批出場、追蹤停損、時間停損
87. REPORT   report.py 於 21:30 執行                             -> 哪些死了、哪些賺錢了、哪些該質疑

1# config.py
2# 交易台上的每個數值都在這裡。當你要微調時，只改這個檔案，其他的都不用動。
3
4MODEL = "grok-4.7"          # 如果 API 拒絕，請查 console.x.ai -> Models
5PAPER = True                # 第一週：用真實價格做假成交。讀完 log 後再切換
6
7TICKET_USD = 25             # 固定金額。絕對不要因為上次贏了就加大部位
8MAX_OPEN = 4                # 市場上最多 4 x $25 = $100
9MAX_ENTRIES_PER_DAY = 6
10DAILY_LOSS_HALT_USD = 50    # 今日已實現虧損達到此數值 -> 明天之前不再進場
11COOLDOWN_HOURS = 24         # 剛退出的代幣，24 小時內不再進場
12
13FACTS = {                   # rug 過濾器。純程式碼，不用模型
14    "max_risk_score": 40,       # rugcheck score_normalised，0-100，越高越危險
15    "min_lp_locked_pct": 90,    # 最大流動性池：LP 鎖定或銷毀的比例
16    "max_top10_pct": 30,        # 前 10 大持有者佔比，排除池子和鎖倉地址
17    "max_dev_pct": 5,           # 仍在創建者錢包裡的供應量比例
18    "max_insiders": 0,          # 被標記為內部人士的持有者 + 內部關係圖命中數
19    "min_liquidity_usd": 30000,
20    "max_ticket_share": 0.01,   # 你的投入絕對不能超過池子的 1%
21    "min_age_min": 30,          # 低於這個時間，所有報告都還在瞎猜
22    "max_age_hours": 72,
23}
24
25MIN_CONFIDENCE = 0.7        # Grok 在此數值以下說 BUY -> 視為 SKIP
26
27EXIT = {
28    "stop_pct": -35,                        # 從進場點算起的硬停損
29    "ladder": [(100, 0.50), (200, 0.25)],   # +100% 賣一半，+200% 再賣四分之一
30    "trail_pct": 30,                        # 剩下的：當價格從高點回落 30% 時出場
31    "time_stop_hours": 6,                   # 6 小時後還沒漲 20% -> 出場，這是死錢
32    "time_stop_min_pct": 20,
33    "liq_drop_pct": 40,                     # 池子流動性從進場點下降 40% -> 立刻出場
34}
35
36LOG = "checks.csv"
37POSITIONS = "positions.json"
38TRADES = "trades.csv"

1固定投入金額。部位不會因為連贏三次就變大。
2BOT 只讀 config.py，絕對不寫入。數值只有在你手動改的時候才會變。
3放寬過濾器必須留下文字紀錄。你改了數值，當天就要在聊天室裡說明原因。

1# book.py
2# 部位、交易、限制。交易台的記憶存在兩個你可以自己打開的檔案裡。
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    """限制條件在任何網路呼叫之前執行。被擋下的進場不花一毛錢。"""
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    """賣出「原始」部位的一定比例（1.0 = 剩下全部）。回傳已實現損益。"""
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    # 實戰模式：在你自己的錢包買進後 ->  python book.py add <mint> <usd> <price> <liq_usd>
66    # 在你手動賣出後                     ->  python book.py close <mint> <price>
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# 每 10 分鐘檢查所有未平倉部位。沒變化時不輸出任何內容。
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']}: 價格來源掛了 ({e})，繼續持有，稍後重試")
15            continue
16        if not m or m["price"] <= 0:
17            events.append(f"{p['symbol']}: 池子消失了。視為被 rug，能賣多少賣多少")
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 = "sold" if PAPER else "SELL NOW in your wallet"
30            size = "the rest" if frac >= 1 else f"{int(frac * 100)}%"
31            events.append(f"{s['symbol']}: {verb} {size} at {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)

1流動性優先。池子被抽乾的優先級高於所有其他規則，即使部位是綠的也一樣。
2追蹤停損在第一次獲利了結後才啟動。在此之前，-35% 是唯一的底線。
3死錢也是一種虧損。六小時沒動靜，就把部位空出來給下一個代幣。
4沉默也是一種狀態。沒變化時 watch.py 不會輸出任何內容，所以聊天室安靜就代表你不用管它。

1# rugcheck.py
2# 每個代幣一份報告，精簡到交易台會讀的欄位。Grok 永遠不會看到原始報告。
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):  # AMM 金庫和鎖倉地址在前幾大持有者裡，牠們不是巨鯨
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    """單純的比較。第一個失敗的就定生死，原因會被記錄下來。"""
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# 池子本身：深度、年齡、價格，以及是否真的有人能賣出。
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# 唯一存放金鑰的檔案，也是 desk 與 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("環境變數或 .env 中找不到 XAI_API_KEY")
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    """一次呼叫，JSON 進、JSON 出。任何不是 JSON 的東西都會拋出例外，而例外在上游就代表 SKIP（跳過）。"""
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          # 搜尋兩輪，然後它必須給出答案
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"回答中沒有 json：{text[:200]}")
45    return json.loads(text[start:end + 1])

1# prompts.py
2# desk 上唯一的 Grok 提示詞。這才是你真正會反覆閱讀的檔案。
3
4JUDGE_PROMPT = """
5你是 RUG DESK。有一個 Solana memecoin 剛通過了程式碼中的所有硬性檢查：
6權限、LP、持有者、開發者錢包、內線、池子深度、幣齡。
7不要重新檢查那些數字。你要決定的是：是否投入一張固定金額的單。
8你永遠不決定部位大小，也永遠不挑選出場點。
9
10輸入：{"token": {...rugcheck 事實...}, "pool": {...dexscreener 事實...}}
11
12步驟 1. 在 X 上搜尋該代號與合約地址，範圍是過去 72 小時。
13步驟 2. 只判斷程式碼看不到的東西：
14  - warn 等級的風險加在一起會不會變成更糟的狀況
15  - 誰先發文：開發者、有歷史紀錄的真實帳號，還是一大批新帳號
16  - 自然流量還是買來的：相同措辭、同一分鐘、毫無過往紀錄的帳號
17  - 那些貼文中的合約地址是否與輸入中的相同
18  - 這個代號或這個開發者以前是否跟 rug pull 有關
19
20只回傳 JSON：
21{"verdict": "BUY" | "SKIP", "confidence": 0.0-1.0,
22 "why": "最多兩行", "x_read": "一行說明 X 上的狀況",
23 "main_risk": "一行"}
24
25X 上零篇貼文也是一種答案：沒人知道它存在。SKIP。
26X 上同一個代號出現另一個合約地址：仿冒風險。SKIP。
27當你需要欄位是 null 時，絕對不能回答 BUY。
28絕對不要提到目標價。你不知道那些數字。
29"""

1# check.py
2# 輸入一個合約地址，輸出一個判定。每次有代幣送到你的 desk 都會執行。
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)):                                  # 限制檢查，免費
22        return {"stage": "limits", "verdict": "SKIP", "reason": g}
23
24    try:
25        token = report(mint)                                     # rug 篩選，免費
26    except Exception as e:
27        return {"stage": "facts", "verdict": "SKIP", "reason": f"rugcheck 失敗：{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)                                           # 池子檢查，免費
33    except Exception as e:
34        return {"stage": "pool", "verdict": "SKIP", "reason": f"dexscreener 失敗：{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)   # 唯一要付費的步驟
40    except Exception as e:
41        return {"stage": "grok", "verdict": "SKIP", "reason": f"grok 失敗：{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"信心度太低 {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"模擬買入 ${TICKET_USD}，價格 {v['price']}"
58        else:
59            v["action"] = (f"需要核准：請在你自己的錢包買入 ${TICKET_USD} 的 {v['symbol']}，"
60                           f"然後執行：python book.py add {mint} {TICKET_USD} <成交價> {v['liq_usd']}")
61    print(json.dumps(v, indent=2))

1{
2  "verdict": "SKIP",
3  "confidence": 0.78,
4  "why": "通過所有硬性檢查，但前 30 篇貼文都來自本週建立的帳號，而且措辭一模一樣。",
5  "x_read": "一個真實帳號，加上一大批新帳號，合約地址沒有不一致",
6  "main_risk": "買來的熱度，一旦停止發文買家就會跑掉",
7  "stage": "grok",
8  "symbol": "EXAMPLE",
9  "reason": "通過所有硬性檢查，但前 30 篇貼文都來自本週建立的帳號，而且措辭一模一樣。"
10}

1先看事實，再看意見。Grok 永遠不會去判斷某個 mint 是否開放。
2呼叫失敗就是 SKIP。Rugcheck 掛了、DexScreener 掛了、Grok 掛了、JSON 爛掉了：一律 SKIP。
3NULL 不等於乾淨。沒回傳的欄位會直接殺掉這個代幣，絕對不會讓它過關。
4每個代幣只有一個判定。在它說出 BUY 之前，絕對不要重跑。如果你不同意，那你反對的是 config.py。
5看被殺掉的原因，而不是看買入。買入感覺很爽，但淘汰原因才能告訴你篩選器有沒有用。

1每 10 分鐘，在 /workspace/desk 執行 python watch.py。
2如果它沒印出任何東西，你就什麼都別說。如果有印出任何東西，就一字不漏地貼到這裡。

1每 30 分鐘，在 /workspace/desk 執行 python scan.py。
2只貼出 BUY 的判定：代號、信心度、x_read。
3如果 Rugcheck 或 DexScreener 掛了，說一次是哪一個就好，不用每次執行都講。

1每天 21:30，在 /workspace/desk 執行 python report.py，並把輸出貼到這裡。
2加上一件今天有效的事，以及一個你會質疑的 config.py 數字，並附上理由。
3絕對不要自己改那個數字。

1# report.py
2# 晚間報告。裡面所有資料都來自 checks.csv 和 trades.csv，完全不靠記憶。
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"晚間報告 {day} {'(PAPER)' if PAPER else '(LIVE)'}")
19print(f"已檢查：{len(checks)}")
20print(f"被 rug 篩選淘汰：{by_stage['facts']} | 被池子淘汰：{by_stage['pool']} | "
21      f"被 Grok 淘汰：{by_stage['grok']} | 被限制淘汰：{by_stage['limits']}")
22print(f"已買入：{len(buys)} | 目前持倉：{len(book.load())}")
23print(f"今日已實現損益：${book.today_pnl():+.2f}")
24if done:
25    print(f"獲利出場：{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['symbol']} ${float(best['pnl']):+.2f} | 最差：{worst['symbol']} ${float(worst['pnl']):+.2f}")
29if reasons:
30    top, n = reasons.most_common(1)[0]
31    print(f"最常見的淘汰原因：{top} ({n} 次)")

1# scan.py
2# 可選的線索來源：剛付費購買 DexScreener 資料頁的新 Solana 代幣。
3# 付費資料頁不是品質訊號，只代表開發者花了錢。剩下的由篩選器決定。
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]:                   # 每次執行五個，這樣忙碌的一小時才不會把 API 額度吃光
15    subprocess.run([sys.executable, "check.py", mint])

1在任何錢包連線、簽名、交換或轉帳之前，都要先詢問。
2在編輯任何名為 config.py 的檔案之前，都要先詢問。

1xAI 回傳 401              -> 金鑰錯誤。接管控制權，重寫 .env，再跑一次步驟 03 的 curl。
2xAI 回傳 400 / 404        -> 模型名稱改了。修正 config.py 裡的 MODEL，其他都不用動。
3xAI 回傳 429              -> 觸發速率限制。那個代幣就是 SKIP，下次執行會繼續往下走。絕對不要用迴圈重試。
4關於 x_search 的錯誤      -> 你的 MODEL 無法搜尋 X。到 console.x.ai -> Models 挑一個可以搜的。
5Grok 用散文回答           -> ValueError，記錄下來，SKIP。絕對不要把一段文章變成交易。
6rugcheck 404 或空白       -> 太新還沒被索引。SKIP。新不代表乾淨。
7所有東西都顯示 lp_unlocked -> 有些池子類型根本沒有 LP 代幣。在你動那個數字之前，
8                             先自己去 rugcheck 開一個看看，並用文字記錄你的修改。
9no_pool                   -> 還沒在 DEX 上交易，或不是 Solana。SKIP。
10例行任務突然安靜了        -> 你離開太久之後，Grok Bot 會暫停例行任務。
11                             打開 Routines 把它們重新開啟。

1cost_per_token = input_tokens / 1_000_000 * price_per_M_input
2               + output_tokens / 1_000_000 * price_per_M_output
3               + posts_fetched / 1_000 * 5          # X 搜尋：每抓取 1,000 篇貼文 $5
4
5max_turns = 2 會把搜尋限制在兩輪，所以 posts_fetched 會維持在很小的數字。
6每個回應都會回報自己的 x_posts_fetched，所以第一天你就能知道真實數字。
7
8價格：[console.x.ai 上的價格]