Jev picks the coin, the Grok Bots trade it

import os
from fastapi import FastAPI, Header, HTTPException
from pydantic import BaseModel, ValidationError
from typesafe_sdk import AsyncTypeSafeClient, TypeSafeAPIError, TypeSafeError
from questions import SETS
import book

DESK_SECRET = os.environ["DESK_SECRET"]     # for the bots. NOT the TypeSafe key.
client = AsyncTypeSafeClient()              # reads TYPESAFE_API_KEY itself
app = FastAPI()


class Ask(BaseModel):
    question_set: str
    state: dict


@app.post("/")                  # fixed: the bare tunnel URL works too, so JUDGE_URL needs no path
@app.post("/judge")
async def judge(ask: Ask, authorization: str = Header("")):
    if authorization != f"Bearer {DESK_SECRET}":
        raise HTTPException(401, "bad desk secret")
    if ask.question_set not in SETS:
        raise HTTPException(422, f"unknown question set {ask.question_set}")

    qs = SETS[ask.question_set]
    # fixed: Jev's errors reached the bots as a bare 500. Pass a real status on instead.
    try:
        qs = qs(ask.state) if callable(qs) else qs    # pick builds options at call time
        r = await client.system_one(state=ask.state, questions=qs)
    except (ValidationError, KeyError) as e:          # a question that could not be built
        raise HTTPException(422, f"bad question set {ask.question_set}: {e}")
    except TypeSafeAPIError as e:                     # Jev answered with an error, after retries
        raise HTTPException(422 if e.status == 422 else 502, f"jev {e.status}: {e}")
    except TypeSafeError as e:                        # Jev unreachable or timed out, after retries
        raise HTTPException(504, f"jev unreachable: {e}")

    # raw answers out. never flattened, never thresholded here.
    return {"model": r.model,
            "answers": {k: v.model_dump() for k, v in r.answers.items()},
            "usage": r.usage.model_dump()}


@app.post("/release")           # fixed: RISK runs in the cloud and can't reach book.py on
async def release(authorization: str = Header("")):  # this machine, so it frees the book here
    if authorization != f"Bearer {DESK_SECRET}":
        raise HTTPException(401, "bad desk secret")
    book.release()
    return {"released": True}

import os, re, time, requests
from fomo_api import Fomo                      # Privy bearer out of Chrome over CDP

GT  = "https://api.geckoterminal.com/api/v2"
DEX = "https://api.dexscreener.com/latest/dex/tokens"

# the three chains the desk trades, plus Base which shares the BSC question set
GT_NET   = {1399811149: "solana", 4663: "robinhood", 56: "bsc", 8453: "base"}
FOMO_NET = {v: k for k, v in GT_NET.items()}


def age_minutes(created) -> float:
    """createdAt comes back as epoch seconds or milliseconds depending on the row."""
    if not created:
        return 0.0
    c = float(created)
    if c > 1e11:                                # milliseconds
        c /= 1000
    return max(0.0, (time.time() - c) / 60)


def universe(nets=("solana", "bsc", "robinhood"), pages=2) -> list[str]:
    """Where the whole thing starts. Fresh pools per chain -> ['<addr>:<netId>', ...].
       Costs one GeckoTerminal slot per chain per page, so keep pages small."""
    ids, seen = [], set()
    for net in nets:
        for page in range(1, pages + 1):
            try:
                r = requests.get(f"{GT}/networks/{net}/new_pools",
                                 params={"page": page}, timeout=20).json()
            except Exception:
                break
            if "data" not in r:                  # fixed: a 429 body has no "data" and
                break                            # used to read as a page with no pools
            for pool in r["data"]:
                base = ((pool.get("relationships") or {}).get("base_token") or {})
                gid  = (base.get("data") or {}).get("id")      # 'solana_<addr>'
                if not gid:
                    continue
                addr = gid.split("_", 1)[1]
                tid  = f"{addr}:{FOMO_NET[net]}"
                if tid not in seen:
                    seen.add(tid)
                    ids.append(tid)
    return ids


def normalise(tid: str, m: dict) -> dict:
    """FOMO's field names become the desk's field names, once, here.
       Every file downstream reads these names and only these."""
    addr, net = tid.split(":")
    # fixed: read the names filterTokens returns (section 4), not ones it doesn't
    return {"addr": addr, "net": int(net), "tid": tid, "ticker": m["symbol"],
            "mcap_usd": m["marketCap"], "liquidity_usd": m["liquidity"],
            "volume_h24": m["volume24"], "price_usd": m["priceUSD"],
            "holder_count": m["holders"] or None,
            "change": {"5m": m.get("change5m"), "1h": m.get("change1"),
                       "4h": m.get("change4"), "24h": m.get("change24")},
            "age_minutes": age_minutes(m["createdAt"])}


def shortlist(fomo: Fomo, ids: list[str]) -> list[dict]:
    """Pass one over everything FOMO knows. No network beyond FOMO itself:
       one call per twenty tokens, and not a single request per token."""
    out = []
    for tid, m in fomo.tokens(ids).items():             # 20 per call
        t = normalise(tid, m)
        if t["net"] in GT_NET:
            out.append(t)
    # turnover ranks the queue. It orders work, it does not decide anything
    # fixed: a null volume or market cap used to crash the whole cycle here
    out.sort(key=lambda t: (t["volume_h24"] or 0) / max(t["mcap_usd"] or 0, 1), reverse=True)
    return out


def trade_counts(t: dict) -> dict:
    """buys and sells per window. FOMO does not return them, DexScreener does.
       Called ONLY for tokens that already cleared the free checks. One per token,
       so this runs on tens, never on the whole universe."""
    try:
        pairs = requests.get(f"{DEX}/{t['addr']}", timeout=20).json().get("pairs") or []
    except Exception:
        return {"buys_h1": None, "sells_h1": None, "trades_h24": None}
    if not pairs:
        return {"buys_h1": None, "sells_h1": None, "trades_h24": None}
    # fixed: take the busiest pair. Bonding-curve pairs carry no liquidity figure, so
    # ranking by liquidity picked a dust pool and its handful of trades instead
    x = max(pairs, key=lambda p: sum(((p.get("txns") or {}).get("h24") or {}).values()))["txns"]
    return {"buys_h1": x["h1"]["buys"], "sells_h1": x["h1"]["sells"],
            "buys_h6": x["h6"]["buys"], "sells_h6": x["h6"]["sells"],
            "trades_h24": x["h24"]["buys"] + x["h24"]["sells"],
            "pair_addresses": [p.get("pairAddress") for p in pairs]}   # fixed: for the top wallet


def dossier(t: dict) -> dict:
    """One GT call per token. Fills what the chain actually has, null where it does not."""
    net = GT_NET[t["net"]]
    r = requests.get(f"{GT}/networks/{net}/tokens/{t['addr']}/info", timeout=20)
    r.raise_for_status()                         # fixed: main tells our 429 from a bad token
    a = r.json()["data"]["attributes"]
    pools = set(t.get("pair_addresses") or ())

    d = {**{k: v for k, v in t.items() if k != "pair_addresses"}, "chain": net,
         # GT first, FOMO as the fallback. On Robinhood GT is null and FOMO is all you get.
         "holder_count": (a.get("holders") or {}).get("count") or t["holder_count"],
         "top_10_percent": ((a.get("holders") or {}).get("distribution_percentage")
                            or {}).get("top_10"),
         "developer_holding_percentage": a.get("developer_holding_percentage"),
         "gt_score_details": a.get("gt_score_details"),
         "is_honeypot": a.get("is_honeypot"),
         "mint_authority": a.get("mint_authority"),       # "yes" / "no", null if not indexed
         "freeze_authority": a.get("freeze_authority"),
         "description": a.get("description"),
         "x_handle": clean_handle(a.get("twitter_handle")),
         "top_wallet_percent": None}           # fixed: null off Solana, not missing

    # Solana only: exact top wallet share, off a Solana RPC
    if t["net"] == 1399811149:
        d["top_wallet_percent"] = sol_top_wallet(t["addr"], pools)

    return d


def clean_handle(h):
    """GT returned 'LuffyX100X/status/2102659581109272876' on a Robinhood token.
       Take the first path segment, or treat the account as missing."""
    if not h:
        return None
    # fixed: strip a full x.com URL, refuse X's own paths ('i/status/...' came back as
    # the handle "i"), and accept only the characters an X handle can contain
    h = re.sub(r"^(https?://)?(www\.)?(x|twitter)\.com/", "", h.strip())
    h = h.lstrip("@").split("?")[0].split("/")[0]
    if h.lower() in {"i", "intent", "home", "search", "share", "hashtag", "explore"}:
        return None
    return h if re.fullmatch(r"[A-Za-z0-9_]{1,15}", h) else None


def sol_top_wallet(mint: str, pools=()):
    # fixed: the largest token account is normally the pool's vault or the bonding curve,
    # so skip accounts the token's pools own. The public RPC refuses getTokenLargestAccounts,
    # so point SOLANA_RPC_URL at a keyed one. A failed lookup is null, not a dead dossier.
    rpc = os.environ.get("SOLANA_RPC_URL", "https://api.mainnet-beta.solana.com")
    q = lambda m, p: requests.post(rpc, json={"jsonrpc": "2.0", "id": 1,
                                              "method": m, "params": p},
                                   timeout=20).json()["result"]
    try:
        supply = float(q("getTokenSupply", [mint])["value"]["amount"])
        top = q("getTokenLargestAccounts", [mint])["value"]
        owners = q("getMultipleAccounts", [[a["address"] for a in top],
                                           {"encoding": "jsonParsed"}])["value"]
        held = [float(a["amount"]) for a, o in zip(top, owners)
                if o and o["data"]["parsed"]["info"]["owner"] not in pools]
    except (KeyError, TypeError, ValueError, requests.RequestException):
        return None
    return held[0] / supply if supply and held else None


def social_state(d: dict) -> dict:
    """What SOCIAL hands the judge. The X block is filled by the bot's X plugin."""
    return {"x_account": d["x_account"],                 # collected by SOCIAL, not here
            "token": {"ticker": d["ticker"], "narrative": d.get("description")}}

from typesafe_sdk import Choice, Noul, Score

MARKET = {
    "shape": Choice(
        instructions="Classify the shape of this launch from the fields in `state`.",
        criteria={
            "crowd": "Holders growing faster than price. Buys outnumber sells across both "
                     "recent windows. Volume spread rather than spiking once.",
            "one_buyer": "Price climbing faster than holders. Holder growth flat while "
                         "price rises. One wallet walking the price up.",
            "fading": "Recent volume is a small fraction of the daily average, or sells "
                      "outnumber buys in both recent windows.",
            "too_early": "Too few data points to tell any of the above apart yet.",
        }),
    "liquidity_fits_ticket": Noul(
        instructions="A position of `intended_ticket_usd` could be exited into "
                     "`liquidity_usd` without moving the price more than a few percent."),
    "momentum_already_spent": Noul(
        instructions="The move in `change` has already happened, so entering now means "
                     "buying after the information is public.",
        criteria={"true": "The largest change sits in the older windows.",
                  "false": "The recent windows carry the move."}),
}

CONCENTRATION = Noul(
    instructions="Holding this token means being exit liquidity, based on "
                 "`top_10_percent`, `top_wallet_percent` and `holder_count`.",
    criteria={"true": "A few wallets can end the market by selling.",
              "false": "The float is spread widely enough to absorb a large holder."})

DEV_LOADED = Noul(
    instructions="`developer_holding_percentage` is large enough that the creator "
                 "selling would meaningfully move the price.")

CHAIN_SOLANA = {                      # 1399811149
    "authority_risk": Choice(
        instructions="Judge contract control risk from `mint_authority` and "
                     "`freeze_authority`.",
        # fixed: GeckoTerminal reports "yes" / "no", not null / set, and null means
        # not indexed yet, which is not the same as renounced
        criteria={
            "renounced": "Both are \"no\". Supply cannot be inflated, balances cannot "
                         "be frozen.",
            "mint_open": "mint_authority is \"yes\". Supply can be inflated at will.",
            "freeze_open": "freeze_authority is \"yes\". Balances can be frozen at will.",
            "both_open": "Both are \"yes\".",
            "unknown": "Either one is null: the authorities have not been indexed yet.",
        }),
    "concentration_is_exit_risk": CONCENTRATION,
    "dev_still_loaded": DEV_LOADED,
}

CHAIN_BSC = {                         # 56, same set works for Base
    "sell_side_risk": Choice(
        instructions="Judge whether a position here can be sold, from `is_honeypot`, "
                     "`gt_score_details` and the buy and sell counts.",
        criteria={
            "clean": "Not flagged, and sells are going through in the data.",
            "flagged": "Explicitly flagged as a honeypot.",
            "suspicious": "Not flagged, but sells are absent or vanishingly rare while "
                          "buys are plentiful.",
            "unknown": "The honeypot field is missing or unknown and trade counts are "
                       "too thin to stand in for it.",
        }),
    "concentration_is_exit_risk": CONCENTRATION,
    "pool_quality": Score(
        instructions="Rate the pool from `gt_score_details` and `liquidity_usd`.",
        criteria=["Thin and new. One withdrawal ends the market.",
                  "Usable, but a large ticket would move it.",
                  "Deep enough that normal desk size is invisible."]),
}

CHAIN_ROBINHOOD = {                   # 4663, the one with holes in the data
    "data_coverage": Choice(
        instructions="Judge how much of this token is visible, from which fields in "
                     "`state` carry values and which are null or unknown.",
        criteria={
            "indexed": "Holder count and distribution present, honeypot field is a real "
                       "answer.",
            "partial": "Holder count present from the venue, but distribution or the "
                       "honeypot field is missing.",
            "dark": "Neither distribution nor honeypot available. Only price, volume and "
                    "pool age are known.",
        }),
    "sellable_by_evidence": Noul(
        instructions="Sells are going through on this token, judged from the buy and sell "
                     "counts rather than from any honeypot flag.",
        criteria={"true": "Sells appear across recent windows in a normal ratio.",
                  "false": "Buys with almost no sells, or no trades at all."}),
    "concentration_is_exit_risk": CONCENTRATION,
    "dev_still_loaded": DEV_LOADED,
}

SOCIAL = {
    "account_is_the_project": Noul(
        instructions="The account in `x_account` is the token's official account, not a "
                     "fan account, an impersonator, or an unrelated similar name.",
        criteria={"true": "Handle matches the one published on chain and the content is "
                          "about this token.",
                  "false": "Similar name, different subject, or no link back."}),
    "audience_is_real": Noul(
        instructions="Engagement in `x_account` is consistent with its follower count, "
                     "rather than a large follower number with almost no replies or "
                     "reposts on recent posts."),
    "recycled_account": Noul(
        instructions="`x_account` shows signs of being repurposed: far older than the "
                     "token, with a handle or content history belonging to a different "
                     "project."),
    "effort": Score(
        instructions="Rate how much work is visibly behind this project from `x_account`.",
        criteria=["One post, one image, nothing else.",
                  "A handful of posts, all promotional.",
                  "Regular posting with substance beyond price.",
                  "A visible team shipping visible things."]),
}


def PICK(state):
    """Options built from the shortlist at call time. Choice takes up to 255."""
    return {
        "best": Choice(
            instructions="Choose the single token in `candidates` that is the best entry "
                         "right now. Weigh crowd shape, contract risk, concentration and "
                         "the project account together. Prefer a clean unspent setup over "
                         "a larger move that already happened.",
            criteria={c["ticker"]: c["summary"] for c in state["candidates"]}),
        "worth_trading_at_all": Noul(
            instructions="At least one token in `candidates` is worth a position today, "
                         "rather than all of them being mediocre.",
            criteria={"true": "At least one is a clean setup.",
                      "false": "Every candidate has a disqualifying weakness."}),
    }


SETS = {"market": MARKET, "social": SOCIAL, "pick": PICK,
        "solana": CHAIN_SOLANA, "bsc": CHAIN_BSC, "robinhood": CHAIN_ROBINHOOD}

# thresholds.py
HARD = {                        # stage 2, arithmetic, runs before anything costs money
    "min_age_minutes":   15,    # younger than this and the data is noise
    "max_age_hours":     72,    # older than this and it is not a launch any more
    "min_liquidity_usd": 12_000,
    "min_volume_h24":    40_000,
    "min_mcap_usd":      60_000,
    "max_mcap_usd":      8_000_000,
    "min_trades_h24":    150,
    "max_top_wallet":    0.05,  # solana only, exact, from RPC
    "max_top_10":        0.60,  # where distribution exists
    "min_holders":       80,
}

SOFT = {                        # applied to Jev's answers, per token
    "concentration_is_exit_risk": ("max", 0.55),
    "momentum_already_spent":     ("max", 0.60),
    "liquidity_fits_ticket":      ("min", 0.60),
    "account_is_the_project":     ("min", 0.70),
    "recycled_account":           ("max", 0.50),
    "audience_is_real":           ("min", 0.45),
    "effort":                     ("min", 1.0),
    "dev_still_loaded":           ("max", 0.55),
    "sellable_by_evidence":       ("min", 0.60),   # robinhood
}

SHAPE_MIN_CROWD = 0.55          # probabilities["crowd"], not the winning label
PICK_MIN_WORTH  = 0.60
PICK_MIN_CONF   = 0.55
DARK_TICKET_CUT = 0.40          # robinhood, data_coverage == dark
NO_SOCIAL_CUT   = 0.60          # no usable X handle: trade smaller, do not skip

from thresholds import HARD, SOFT, SHAPE_MIN_CROWD


def free_kill(t) -> str | None:
    """Pass one. Runs on the whole universe, costs nothing, touches no network.
       Everything it reads came back with the FOMO batch."""
    if not HARD["min_age_minutes"] <= t["age_minutes"] <= HARD["max_age_hours"] * 60:
        # fixed: too young can come back later (main re-feeds it), too old never does
        return "age" if t["age_minutes"] < HARD["min_age_minutes"] else "too_old"
    # fixed: a null used to crash the cycle; now it fails the check
    if (t["liquidity_usd"] or 0) < HARD["min_liquidity_usd"]:   return "liquidity"
    if (t["volume_h24"] or 0)    < HARD["min_volume_h24"]:      return "volume"
    if not HARD["min_mcap_usd"] <= (t["mcap_usd"] or 0) <= HARD["max_mcap_usd"]:
        return "mcap"
    return None


def trade_kill(t) -> str | None:
    """Pass two. One DexScreener call already spent on this token. Tens, not hundreds."""
    if t["trades_h24"] is None:                             return "no_pair"
    if t["trades_h24"] < HARD["min_trades_h24"]:            return "trades"
    if t["sells_h1"] == 0 and (t["buys_h1"] or 0) > 20:     return "no_sells"
    return None


def chain_kill(d) -> str | None:
    """After the dossier, still free. Facts, not judgements."""
    if d.get("top_wallet_percent") is not None and \
       d["top_wallet_percent"] > HARD["max_top_wallet"]:
        return "top_wallet"
    if d.get("top_10_percent") is not None and \
       float(d["top_10_percent"]) / 100 > HARD["max_top_10"]:
        return "top_10"
    if d.get("holder_count") is not None and d["holder_count"] < HARD["min_holders"]:
        return "holders"
    # fixed: GeckoTerminal answers "yes" / "no" (null if not indexed), and "no" used to
    # count as open, which killed every renounced Solana token
    if d["chain"] == "solana" and {d["mint_authority"], d["freeze_authority"]} - {None, "no"}:
        return "authority_open"          # a fact, no model needed
    if d.get("is_honeypot") is True:     # fixed: was bsc only, so base honeypots got through
        return "honeypot"                # also a fact
    return None


def soft_kill(ans) -> str | None:
    """Jev's answers against SOFT. First failure wins."""
    for name, (direction, limit) in SOFT.items():
        a = ans.get(name)
        if a is None:
            continue                     # question not asked for this chain
        v = a.get("noul", a.get("score"))
        if v is None:
            continue
        if direction == "max" and v > limit: return name
        if direction == "min" and v < limit: return name

    shape = ans.get("shape")
    if shape:
        if shape["choice"] in ("fading", "one_buyer"):        return "shape"
        if shape["probabilities"]["crowd"] < SHAPE_MIN_CROWD: return "shape_weak"

    chain = ans.get("sell_side_risk")
    if chain and chain["choice"] in ("flagged", "suspicious"): return "sell_side"
    return None

# pick.py
from thresholds import PICK_MIN_WORTH, PICK_MIN_CONF, DARK_TICKET_CUT, NO_SOCIAL_CUT


def summary(d, ans) -> str:
    """Two lines per candidate, built from answers Jev already gave.
       Never the raw dossier. A fat state costs accuracy."""
    # fixed: age rounded, and momentum added, since the pick prefers unspent setups
    bits = [f"{d['chain']}, {d['age_minutes']:.0f}m old, ${d['mcap_usd']:,.0f} mcap, "
            f"${d['liquidity_usd']:,.0f} liq, {d['holder_count'] or '?'} holders",
            f"crowd {ans['shape']['probabilities']['crowd']:.2f}, "
            f"momentum spent {ans['momentum_already_spent']['noul']:.2f}, "
            f"concentration risk {ans['concentration_is_exit_risk']['noul']:.2f}"]

    if "authority_risk" in ans:
        bits.append(f"authority {ans['authority_risk']['choice']}")
    if "sell_side_risk" in ans:
        bits.append(f"sell side {ans['sell_side_risk']['choice']}")
    if "data_coverage" in ans:
        bits.append(f"data {ans['data_coverage']['choice']}")
    if "account_is_the_project" in ans:
        bits.append(f"official account {ans['account_is_the_project']['noul']:.2f}, "
                    f"effort {ans['effort']['score']:.1f}")
    else:
        bits.append("no usable X account")
    return "; ".join(bits)


def pick(judge, survivors) -> dict | None:
    """survivors: [(dossier, answers), ...]. Returns the order, or None."""
    if not survivors:
        return None

    # fixed: options are keyed by label, so two coins sharing a ticker collapsed into one
    # and the desk could buy a token Jev never saw. Labels are now unique strings.
    tickers = [d["ticker"] or "?" for d, _ in survivors]
    labels = [t if tickers.count(t) == 1 else f"{t} {d['tid']}"
              for t, (d, _) in zip(tickers, survivors)]
    state = {"candidates": [{"ticker": l, "summary": summary(d, a)}
                            for l, (d, a) in zip(labels, survivors)]}
    r = judge("pick", state)
    best, worth = r["answers"]["best"], r["answers"]["worth_trading_at_all"]

    if worth["noul"] < PICK_MIN_WORTH:
        return None                      # every candidate is mediocre. Normal outcome.
    # fixed: a lone survivor now comes through here too. Its confidence proves nothing,
    # so only the worth gate and the size cuts apply to it.
    if len(survivors) > 1 and best["confidence"] < PICK_MIN_CONF:
        return None                      # flat over ten options means no favourite.

    d, ans = next((x for l, x in zip(labels, survivors) if l == best["choice"]), (None, None))
    if d is None:
        return None                      # the schema guarantees the option is in the
                                         # list, so log this one and stand down.

    size_factor = 1.0
    if ans.get("data_coverage", {}).get("choice") == "dark":
        size_factor *= DARK_TICKET_CUT   # less visibility, smaller ticket
    if "account_is_the_project" not in ans:
        size_factor *= NO_SOCIAL_CUT

    return {"model": r["model"],
            "token": {"ticker": d["ticker"], "address": d["addr"],
                      "network_id": d["net"], "chain": d["chain"]},
            "size_factor": round(size_factor, 2),
            "confidence": best["confidence"],
            "runner_up": sorted(best["probabilities"].items(),
                                key=lambda kv: -kv[1])[1:2],
            "why": {k: v for k, v in ans.items()}}

YOU DO NOT FORM OPINIONS ABOUT TOKENS. YOU CALL THE JUDGE.

You do not reason about a candidate, you do not weigh it, you do not write a paragraph
about it. You build a state, you call the judge once, you act on the numbers.

THE CALL
  POST $JUDGE_URL
  Authorization: Bearer $DESK_SECRET
  {"question_set": "<market|solana|bsc|robinhood|social|pick>", "state": {...}}

WHAT COMES BACK
  {"model":"jev-1.13.0",
   "answers":{"<name>":{"type":"noul","noul":0.72}, ...},
   "usage":{"input_tokens":1387,"output_tokens":54}}

HOW YOU USE IT
- Compare the numbers against the thresholds in your prompt. That comparison is the
  decision. You do not have a second opinion about it.
- A noul is a probability, not a yes. 0.49 and 0.51 are nearly the same reading and the
  threshold is what makes them different. Never narrate around a number near your line.
- confidence is a separate axis. Low confidence is not a no, it is a do not act alone.
- Log every answer with the model id, exactly as returned.

WHAT YOU NEVER DO
- Never call api.typesafe.ai directly. You do not have that key and will not be given it.
- Never ask for a question set that is not yours. Unknown sets return 422, that is the
  system working.
- Never retry a 422.
- Never substitute your own judgement when the judge is unreachable. A missing answer is
  missing, not neutral, and no token passes on your say so.
- Never put a number in a report that did not come from the judge or from your own
  arithmetic on desk data.

# book.py
import os, sqlite3, time

# fixed: one file for every process that imports this, wherever it starts (main.py,
# and judge.py, which frees the book for RISK)
DB = sqlite3.connect(os.environ.get("DESK_DB", os.path.join(os.path.dirname(
                     os.path.abspath(__file__)), "desk.db")), check_same_thread=False)
DB.executescript("""
CREATE TABLE IF NOT EXISTS position(
  id INTEGER PRIMARY KEY CHECK (id = 1),
  ticker TEXT, addr TEXT, net INT, opened_at REAL);
CREATE TABLE IF NOT EXISTS bench(
  tid TEXT PRIMARY KEY, reason TEXT, until REAL);
""")

# how long a rejection stands, by what fired it
BENCH_MINUTES = {
    # facts that will not change while this token exists
    "honeypot": 100_000, "authority_open": 100_000,
    "top_wallet": 100_000, "sell_side": 100_000,
    "too_old": 100_000,                  # fixed: past max_age_hours, so never coming back
    # slow to change
    "recycled_account": 360, "account_is_the_project": 360,
    # can change as the float moves
    "top_10": 90, "holders": 90, "dev_still_loaded": 90,
    "concentration_is_exit_risk": 90,
    # can change inside the hour, keep it short or you miss the token maturing
    "shape": 25, "shape_weak": 25, "momentum_already_spent": 25,
    "liquidity_fits_ticket": 25, "liquidity": 25, "volume": 25,
    "trades": 25, "mcap": 25, "age": 20,
}
DEFAULT_BENCH = 45


def held():
    r = DB.execute("SELECT ticker, opened_at FROM position WHERE id=1").fetchone()
    return {"ticker": r[0], "minutes": (time.time() - r[1]) / 60} if r else None


def take(order):
    t = order["token"]
    # fixed: INSERT, not INSERT OR REPLACE, which let a second shift overwrite a held position
    DB.execute("INSERT INTO position VALUES (1,?,?,?,?)",
               (t["ticker"], t["address"], t["network_id"], time.time()))
    DB.commit()


def release():
    """RISK calls this the moment a close is filled. Nothing else calls it."""
    DB.execute("DELETE FROM position")
    DB.commit()


def benched(tid: str) -> bool:
    r = DB.execute("SELECT until FROM bench WHERE tid=?", (tid,)).fetchone()
    return bool(r and r[0] > time.time())


def sit(tid: str, reason: str):
    mins = BENCH_MINUTES.get(reason, DEFAULT_BENCH)
    DB.execute("INSERT OR REPLACE INTO bench VALUES (?,?,?)",
               (tid, reason, time.time() + mins * 60))
    DB.commit()


def due(reason: str) -> list[str]:
    """fixed: tokens whose bench for `reason` ran out in the last hour. new_pools has moved
       on by then, so without this a token that was five minutes too young never comes back."""
    now = time.time()
    return [r[0] for r in DB.execute("SELECT tid FROM bench WHERE reason=? AND until<=? "
                                     "AND until>?", (reason, now, now - 3600))]

# main.py
import time, logging, sqlite3
from fomo_api import Fomo
from collect import universe, shortlist, trade_counts, dossier, social_state
from filter import free_kill, trade_kill, chain_kill, soft_kill
from pick import pick
import book

CHAIN_SET     = {1399811149: "solana", 56: "bsc", 8453: "bsc", 4663: "robinhood"}
CYCLE_SECONDS = 900
GT_PER_MINUTE = 10          # free tier
GT_PAGES      = 2           # fixed: the budget now follows from these, instead of
GT_UNIVERSE   = 3 * GT_PAGES                       # numbers that were never read
GT_DOSSIER    = GT_PER_MINUTE - GT_UNIVERSE - 1    # 3, one spare. 6 at GT_PAGES = 1
DEX_BUDGET    = 25          # DexScreener calls per cycle, pass two only
log = logging.getLogger("desk")


def run_once(fomo, judge, desk, bank, shadow=True):
    if (h := book.held()):                       # RISK owns the desk right now
        log.info("holding %s for %.0f min, no scan this cycle",
                 h["ticker"], h["minutes"])
        return None, {"held": h["ticker"], "minutes": round(h["minutes"])}

    stats = {"seen": 0, "benched": 0, "free": {}, "trade": {},
             "chain": {}, "soft": {}}
    survivors = []
    gt_slots, dex_slots = GT_DOSSIER, DEX_BUDGET

    def ask(question_set, state):                # fixed: log the model id of every call
        r = judge(question_set, state)
        log.info("judge %s %s model=%s", question_set, state.get("tid", ""), r["model"])
        return r["answers"]

    ids = universe(pages=GT_PAGES)               # fresh pools, 3 chains, GT_UNIVERSE slots
    # fixed: new_pools covers only the last few minutes, so nearly every token is too young
    # on first sight and gone from the list by the time it qualifies. Look at those again.
    ids += [i for i in book.due("age") if i not in ids]
    for t in shortlist(fomo, ids):               # pass one: free, no per-token requests
        stats["seen"] += 1
        if book.benched(t["tid"]):               # already judged, still serving its time
            stats["benched"] += 1
            continue
        if (k := free_kill(t)):
            book.sit(t["tid"], k)
            stats["free"][k] = stats["free"].get(k, 0) + 1
            continue

        if dex_slots <= 0 or gt_slots <= 0:
            break                                # out of budget, not out of ideas

        t |= trade_counts(t)                     # pass two: one DexScreener call
        dex_slots -= 1
        if (k := trade_kill(t)):
            book.sit(t["tid"], k)
            stats["trade"][k] = stats["trade"].get(k, 0) + 1
            continue

        try:
            d = dossier(t)                       # pass three: one GeckoTerminal slot
            gt_slots -= 1
        except Exception as e:
            log.warning("dossier failed %s: %s", t["ticker"], e)
            gt_slots -= 1                        # a failed call still cost you the slot
            if getattr(getattr(e, "response", None), "status_code", None) == 429:
                break                            # fixed: our rate limit, not the token's fault
            book.sit(t["tid"], "dossier_failed")
            continue                             # missing is missing, not a pass

        if (k := chain_kill(d)):
            book.sit(t["tid"], k)                # facts bench longest
            stats["chain"][k] = stats["chain"].get(k, 0) + 1
            continue

        # fixed: the most SIZE could ever allow is also capped at 2% of liquidity
        d["intended_ticket_usd"] = min(bank * 0.06, (d["liquidity_usd"] or 0) * 0.02)

        ans = {}
        try:
            ans |= ask("market", d)                                 # pass four
            ans |= ask(CHAIN_SET[d["net"]], d)
            # fixed: read X after those two, so its posts aren't sent (and billed) as their state
            d["x_account"] = desk.read_x(d["x_handle"]) if d["x_handle"] else None
            if d["x_account"]:
                ans |= ask("social", social_state(d))
        except Exception as e:
            log.warning("judge failed %s: %s", d["ticker"], e)
            stats["judge"] = repr(e)             # fixed: stand down, as the failure table says,
            return None, stats                   # instead of spending the cycle on the next token

        if (k := soft_kill(ans)):
            book.sit(t["tid"], k)
            stats["soft"][k] = stats["soft"].get(k, 0) + 1
            continue

        survivors.append((d, ans))

    log.info("cycle: %(seen)s seen, %(benched)s benched, free %(free)s, "
             "trade %(trade)s, chain %(chain)s, soft %(soft)s", stats)

    if not survivors:
        return None, stats
    # fixed: a lone survivor skipped pick, so it was never asked worth_trading_at_all and
    # went out at full size whatever its data or X account looked like
    order = pick(judge, survivors)               # pass five

    if order is None:
        return None, stats
    order["order_id"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())   # fixed: CHIEF logs it
    if shadow:
        desk.log_shadow(order, stats)            # written, never sent
        return None, stats

    try:
        book.take(order)      # the desk is now held. No scan until RISK calls release().
    except sqlite3.IntegrityError:        # fixed: a second shift can't overwrite a held position
        log.warning("desk already held, %s not sent", order["token"]["ticker"])
        return None, stats
    return order, stats


def main(fomo, judge, desk, shadow=True):
    """desk is your Grok Bot side. It has to provide five things:
         bank()                 -> float, free cash right now
         read_x(handle)         -> the X block SOCIAL collects with its plugin, or None
         log_shadow(order, st)  -> append a row for the shadow week
         report(order, stats)   -> one line to Telegram, trade or no trade
         send_to_seats(order)   -> hand it to SIZE, then FILLS, then RISK, in that order
    """
    while True:
        try:
            fomo.token()                         # Privy bearer lives ~60 min, refresh it
            order, stats = run_once(fomo, judge, desk, desk.bank(), shadow)
            desk.report(order, stats)            # every cycle, trade or not
            if order:
                desk.send_to_seats(order)
        except Exception as e:
            log.exception("cycle blew up: %s", e)
        time.sleep(CYCLE_SECONDS)