dexterm-cli 0.2.0 → 0.2.2

package/dist/packages/autotrade/src/engine.js

@@ -12,6 +12,7 @@
 // three independent fences, never the only one.
 import { parseFilter } from "../../cli/src/screener/filter.js";
 import { tickRow } from "./replay.js";
+import { TIERS_HARD_CAP_PCT, selectConfidenceTier, tierTable } from "./tiers.js";
 export const DAY_MS = 86_400_000;
 const r2 = (x) => Math.round(x * 100) / 100;
 const r6 = (x) => Number(x.toPrecision(6));
@@ -297,7 +298,7 @@ export const dayOf = (t) => Math.floor(t / DAY_MS);
  * cooldowns, counts), then the size the strategy itself picks, then every ceiling, each reduction recorded.
  * An agent request can only LOWER the size below the strategy's own pick, never raise it above a ceiling.
  */
-export function clampEntry(book, k, req, killSwitch = false) {
+export function clampEntry(book, k, req, killSwitch = false, nowMs = k.t, inFlight) {
     const s = book.strategy;
     const st = book.state;
     const clamps = [];
@@ -306,6 +307,11 @@ export function clampEntry(book, k, req, killSwitch = false) {
     // fills become trade-fire signals for the user's own executor (the runner admits it only through the real-mode hook).
     if (s.mode !== 'paper' && s.mode !== 'real')
         return no('mode-not-paper');
+    // 0.2.2: EXPERIMENTAL confidence tiers are PAPER ONLY. validateStrategy and the runner refuse them too; this is the
+    // engine's own fence for any document that reached it another way.
+    const tiersOn = s.sizing.tiers ?? null;
+    if (tiersOn && s.mode !== 'paper')
+        return no('tiers-paper-only');
     if (killSwitch)
         return no('kill-switch');
     if (st.halted)
@@ -339,34 +345,57 @@ export function clampEntry(book, k, req, killSwitch = false) {
     }
     if ((k.liq ?? 0) < profile.fit.minLiquidityUsd)
         return no('profile-min-liquidity');
+    // 0.2.2 confidence tiers: score the tick (fresh at nowMs), pick the tier; T0 is a skip; one open position unless the
+    // block says not. With tiers, an entry decided but not filled yet (the latency window, an open approval) counts as
+    // open for one-open and maxConcurrent, and its dollars come off the exposure and cash room (task-2156).
+    let tier;
+    const fly = tiersOn ? inFlightOf(inFlight) : { opens: 0, usd: 0 };
+    if (tiersOn) {
+        if (tiersOn.oneOpen !== false && book.open.size + fly.opens >= 1)
+            return no('tier-one-open');
+        if (book.open.size - bags + fly.opens >= s.risk.maxConcurrent)
+            return no('max-concurrent');
+        tier = selectConfidenceTier(k, tierTable(tiersOn.table), nowMs);
+        if (tier.tier === 'T0')
+            return { ok: false, refused: 'tier-T0', clamps, tier };
+    }
     const bank = book.bookEquity();
     const z = s.sizing;
     let usd;
     let basis;
-    switch (z.mode) {
-        case 'fixed':
-            usd = z.fixedUsd ?? 0;
-            basis = `fixed $${z.fixedUsd}`;
-            break;
-        case 'pct':
-            usd = (bank * (z.pct ?? 0)) / 100;
-            basis = `${z.pct}% of $${r2(bank)}`;
-            break;
-        case 'risk': {
-            const stop = profile.hardStop.enabled && profile.hardStop.atPct !== null ? Math.abs(profile.hardStop.atPct) : s.risk.perTrade.assumedLossPctNoStop;
-            usd = (bank * (z.riskPct ?? 0)) / stop;
-            basis = `${z.riskPct}% risk / ${stop}% stop of $${r2(bank)}`;
-            break;
-        }
-        case 'confidence': {
-            const c = z.confidence ?? { minPct: 1, maxPct: 1, default: 0.5 };
-            const conf = clamp01(req.confidence ?? c.default);
-            const pct = c.minPct + (c.maxPct - c.minPct) * conf;
-            usd = (bank * pct) / 100;
-            basis = `confidence ${r2(conf)} → ${r2(pct)}% of $${r2(bank)}`;
-            break;
-        }
+    // With tiers on, the tier's runs-at % is the strategy's pick (an unproven tier above the cap is recorded as clamped
+    // from its configured size); every ceiling below still applies.
+    if (tier) {
+        usd = (bank * tier.effectivePct) / 100;
+        basis = `tier ${tier.tier} (score ${tier.score}/${tier.of}) ${tier.effectivePct}% of $${r2(bank)}`;
+        if (tier.capped)
+            clamps.push({ rule: 'tier-unproven-cap', fromUsd: r2((bank * tier.configuredPct) / 100), toUsd: r2(usd) });
     }
+    else
+        switch (z.mode) {
+            case 'fixed':
+                usd = z.fixedUsd ?? 0;
+                basis = `fixed $${z.fixedUsd}`;
+                break;
+            case 'pct':
+                usd = (bank * (z.pct ?? 0)) / 100;
+                basis = `${z.pct}% of $${r2(bank)}`;
+                break;
+            case 'risk': {
+                const stop = profile.hardStop.enabled && profile.hardStop.atPct !== null ? Math.abs(profile.hardStop.atPct) : s.risk.perTrade.assumedLossPctNoStop;
+                usd = (bank * (z.riskPct ?? 0)) / stop;
+                basis = `${z.riskPct}% risk / ${stop}% stop of $${r2(bank)}`;
+                break;
+            }
+            case 'confidence': {
+                const c = z.confidence ?? { minPct: 1, maxPct: 1, default: 0.5 };
+                const conf = clamp01(req.confidence ?? c.default);
+                const pct = c.minPct + (c.maxPct - c.minPct) * conf;
+                usd = (bank * pct) / 100;
+                basis = `confidence ${r2(conf)} → ${r2(pct)}% of $${r2(bank)}`;
+                break;
+            }
+        }
     // The agent may ask for LESS than the strategy's pick (never more).
     const asked = req.sizeUsd ?? (req.sizePct !== undefined ? (bank * req.sizePct) / 100 : undefined);
     if (asked !== undefined && Number.isFinite(asked)) {
@@ -381,6 +410,12 @@ export function clampEntry(book, k, req, killSwitch = false) {
         clamps.push({ rule, fromUsd: r2(usd), toUsd: r2(Math.max(0, limit)) });
         usd = Math.max(0, limit);
     } };
+    // The engine's own ceiling for a tiered entry, whatever the tier pick said: code, not the table or the strategy file.
+    if (tier) {
+        if (!Number.isFinite(usd))
+            usd = 0;
+        cap('tier-hard-cap', tierHardCapUsd(bank));
+    }
     if (st.sizeDown)
         cap('drawdown-size-down', usd * s.risk.drawdown.sizeDownMult);
     cap('strategy-max-pct', (bank * s.sizing.maxPctOfBankroll) / 100);
@@ -388,14 +423,25 @@ export function clampEntry(book, k, req, killSwitch = false) {
     cap('strategy-max-usd', s.sizing.maxUsd);
     const lossPct = profile.hardStop.enabled && profile.hardStop.atPct !== null ? Math.abs(profile.hardStop.atPct) : s.risk.perTrade.assumedLossPctNoStop;
     cap('per-trade-max-loss', (bank * s.risk.perTrade.maxLossPctOfBankroll) / lossPct);
-    cap('max-exposure', (bank * s.risk.maxExposurePct) / 100 - book.exposureUsd());
-    cap('cash', st.cashUsd);
+    cap('max-exposure', (bank * s.risk.maxExposurePct) / 100 - book.exposureUsd() - fly.usd);
+    cap('cash', st.cashUsd - fly.usd);
     const R = (k.liq ?? 0) / 2;
     const imp = s.execution.maxPriceImpactPct / 100;
     cap('price-impact', (R * imp) / (1 - s.execution.feeBps / 1e4) + s.execution.networkFeeUsd);
-    if (usd < s.sizing.minUsd)
-        return no(clamps.length ? `below-min-after-${clamps[clamps.length - 1].rule}` : 'below-min-size');
+    if (usd < s.sizing.minUsd) {
+        const r = no(clamps.length ? `below-min-after-${clamps[clamps.length - 1].rule}` : 'below-min-size');
+        return tier ? { ...r, tier } : r;
+    }
     const first = z.ladder ? usd * z.ladder[0].frac : usd;
-    return { ok: true, usd: r2(usd), firstTrancheUsd: r2(first), profile, clamps, basis };
+    return { ok: true, usd: r2(usd), firstTrancheUsd: r2(first), profile, clamps, basis, ...(tier ? { tier } : {}) };
+}
+/** In-flight entries, failing closed: a negative or non-finite count is one open entry, such dollars are the whole room. */
+const inFlightOf = (f) => ({
+    opens: f === undefined ? 0 : Number.isFinite(f.opens) && f.opens >= 0 ? f.opens : 1,
+    usd: f === undefined ? 0 : Number.isFinite(f.usd) && f.usd >= 0 ? f.usd : Infinity,
+});
+/** The most a tiered position may cost in total (every tranche and add): TIERS_HARD_CAP_PCT of the book. */
+export function tierHardCapUsd(bookUsd) {
+    return Number.isFinite(bookUsd) && bookUsd > 0 ? (bookUsd * TIERS_HARD_CAP_PCT) / 100 : 0;
 }
 const clamp01 = (x) => (Number.isFinite(x) ? Math.min(1, Math.max(0, x)) : 0.5);

package/dist/packages/autotrade/src/fleet.js

@@ -268,7 +268,7 @@ export class MemberGate extends SessionGate {
     overDay() { const o = super.overDay(); if (o)
         return o; const g = this.fleet.gate.overDay(); return g ? `fleet-${g}` : null; }
     rateLimit(r) { super.rateLimit(r); this.fleet.rateLimit(r, this); }
-    block(reason) { super.block(reason); this.fleet.block(reason, this); }
+    block(reason, sessionId) { super.block(reason, sessionId); this.fleet.block(reason, this); }
     paused() { return super.paused() || this.fleet.paused(); }
     /** A reading another strategy's session made (the same Claude account). */
     shareRateLimit(r) { super.rateLimit(r); }
@@ -543,7 +543,7 @@ export async function runFleet(o) {
         l.done = runAutotrade({
             ...(adopt?.length ? { adopt } : {}),
             strategy: spec.strategy, source: { name: o.tape?.source ?? o.source.name, ticks, startT: now }, sessions, gate, ledger, runId,
-            dossier: o.dossier?.(spec), vet: o.vet?.(spec), executor: execs.executors.get(id), verbose: o.verbose ?? true, onLine: (s) => say(`[${id}] ${s}`),
+            dossier: o.dossier?.(spec), vet: o.vet?.(spec), drain: o.drain?.(spec), executor: execs.executors.get(id), verbose: o.verbose ?? true, onLine: (s) => say(`[${id}] ${s}`),
             pacing, ...(account ? { account, member: id } : {}),
             safety: () => {
                 const g = o.globalSafety();

package/dist/packages/autotrade/src/index.js

@@ -22,6 +22,7 @@
 // execution-port  where an approved entry goes: the paper port (local single-use proofs) and the live stub (task-1527)
 // chat       Telegram notify, control and approve-to-trade through the user's own bot; chat/ (task-1527)
 // yolo       task-1532: the full-port replay (rugs, loss spread, how often it zeroed the wallet); paper only
+// tiers      0.2.2: EXPERIMENTAL, UNPROVEN confidence-tiered sizing (sizing.tiers), PAPER ONLY, default off
 // signal / outbox / signal-channels / receipts / real-mode  task-1645: mode real = the paper engine + a LIVE TRADE FIRE
 //            signal per fill to the user's own executor (webhook, command hook, JSONL, MCP feed, Telegram copy); no key
 // limits / executor-health / report  task-1654: every real-mode limit user-set per scope (stricter wins), executor
@@ -55,6 +56,9 @@ export * from "./trade-ledger.js";
 export * from "./execution-port.js";
 export * from "./chat/index.js";
 export * from "./yolo.js";
+export * from "./rugproof.js";
+export * from "./rugproof-probe.js";
+export * from "./tiers.js";
 export * from "./signal.js";
 export * from "./outbox.js";
 export * from "./signal-channels.js";

package/dist/packages/autotrade/src/rugproof-probe.js

@@ -0,0 +1,415 @@
+// dexterm autotrade — the rug-proof probes (task-1748): the network half of rugproof.ts. READ-ONLY, PAPER ONLY.
+//
+//   DexScreener tokens/v1      the coin's deepest pool: dex, base / quote mint, creation time, liquidity     keyless
+//   Solana RPC                 the PumpSwap pool account (creator, lp mint, vaults), the LP mint's supply and
+//                              largest holders, the pool's newest transactions (Withdraw scan), the SOL vault   public or the user's own key
+//   Jupiter lite quote         token -> SOL for a given raw amount                                          keyless
+//
+// No wallet, no key of any wallet, no signing, no send: only reads. An RPC URL may carry an api key: it is never
+// printed (redactSecrets) and never written to the ledger. Every read has a timeout; a read that fails is `error`
+// and the gate that needed it refuses (fail closed). The vet runs the gates in rugproof.ts order and stops at the first
+// refusal, so a coin refused by a free gate costs no network call.
+import { redactSecrets, base58 } from '../../data/src/index.js';
+import { PUMPSWAP_PROGRAM, WSOL_MINT, drainVerdict, gateHolders, gateLiquidityRecheck, gateLpLocked, gatePoolAge, gatePoolStructure, gateSellRoute, gateWithdrawHistory, verdictOf, } from "./rugproof.js";
+export const defaultFetchJson = (timeoutMs = 12_000) => async (url, init) => {
+    const r = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+    let json = null;
+    try {
+        json = await r.json();
+    }
+    catch {
+        json = null;
+    }
+    return { status: r.status, json };
+};
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const isObj = (x) => !!x && typeof x === 'object' && !Array.isArray(x);
+const str = (x) => (typeof x === 'string' && x ? x : null);
+const fin = (x) => (typeof x === 'number' && Number.isFinite(x) ? x : null);
+export class RugProbe {
+    id = 0;
+    d;
+    /** Per-run cache: a pool's structure does not change, its LP and history are re-read at most every 10 min. */
+    lpCache = new Map();
+    decimals = new Map();
+    rpcCalls = 0;
+    /** Backoff unit after a rate limit (ms); tests set 0. */
+    backoffMs;
+    constructor(d) { this.d = d; this.backoffMs = d.backoffMs ?? 1500; }
+    async rpc(method, params) {
+        if (!this.d.rpcUrl)
+            throw new Error('no RPC endpoint');
+        let r = { status: 0, json: null };
+        // A rate limit (HTTP 429 or JSON-RPC -32429) is retried twice with a backoff before the read counts as failed.
+        for (let attempt = 0; attempt < 3; attempt++) {
+            this.rpcCalls++;
+            try {
+                r = await this.d.fetchJson(this.d.rpcUrl, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: ++this.id, method, params }) });
+            }
+            catch (e) {
+                throw new Error(redactSecrets(`rpc ${method}: ${e.message}`).slice(0, 200));
+            }
+            const limited = r.status === 429 || (isObj(r.json) && isObj(r.json.error) && r.json.error.code === -32429);
+            if (!limited || attempt === 2)
+                break;
+            await sleep(this.backoffMs * (attempt + 1));
+        }
+        if (!isObj(r.json))
+            throw new Error(`rpc ${method}: HTTP ${r.status}`);
+        if (r.json.error)
+            throw new Error(redactSecrets(`rpc ${method}: ${JSON.stringify(r.json.error)}`).slice(0, 200));
+        return r.json.result;
+    }
+    pairCache = new Map();
+    scanCache = new Map();
+    /** The coin's deepest DexScreener pool (shared for 30 s: every fleet member asks about the same coin). */
+    pair(mint, now = Date.now()) {
+        const hit = this.pairCache.get(mint);
+        if (hit && now - hit.t < 30_000)
+            return hit.v;
+        const v = this.readPair(mint);
+        this.pairCache.set(mint, { t: now, v });
+        v.catch(() => this.pairCache.delete(mint));
+        return v;
+    }
+    async readPair(mint) {
+        const r = await this.d.fetchJson(`${this.d.dexscreenerBase ?? 'https://api.dexscreener.com'}/tokens/v1/solana/${mint}`);
+        if (!Array.isArray(r.json))
+            throw new Error(`dexscreener HTTP ${r.status}`);
+        const pairs = r.json.filter((p) => isObj(p) && str(p.pairAddress)).sort((a, b) => (fin(b.liquidity?.usd) ?? 0) - (fin(a.liquidity?.usd) ?? 0));
+        const p = pairs[0];
+        if (!p)
+            return null;
+        return { address: p.pairAddress, dex: str(p.dexId) ?? 'unknown', baseMint: str(p.baseToken?.address) ?? '', quoteMint: str(p.quoteToken?.address) ?? '', createdAt: fin(p.pairCreatedAt), liqUsd: fin(p.liquidity?.usd) };
+    }
+    /** The PumpSwap pool account + its LP mint (supply, largest holders' owners). null = not a PumpSwap account. */
+    async poolLp(pool, now = Date.now()) {
+        const hit = this.lpCache.get(pool);
+        if (hit && now - hit.t < 10 * 60e3 && hit.v !== 'error')
+            return hit.v;
+        let v;
+        try {
+            v = await this.readPoolLp(pool);
+        }
+        catch {
+            v = 'error';
+        }
+        this.lpCache.set(pool, { t: now, v });
+        return v;
+    }
+    async readPoolLp(pool) {
+        const acc = await this.rpc('getAccountInfo', [pool, { encoding: 'base64' }]);
+        const value = isObj(acc) ? acc.value : null;
+        if (!value)
+            return null;
+        if (value.owner !== PUMPSWAP_PROGRAM)
+            return null;
+        const data = Buffer.from(String(value.data[0] ?? ''), 'base64');
+        const lp = decodePumpSwapPool(data);
+        const sup = await this.rpc('getTokenSupply', [lp.lpMint]);
+        const lpSupply = BigInt(String((sup?.value?.amount) ?? '0'));
+        let holders = [];
+        if (lpSupply > 0n) {
+            const big = await this.rpc('getTokenLargestAccounts', [lp.lpMint]);
+            const rows = ((big?.value ?? []).filter(isObj)).slice(0, 5);
+            const accs = rows.length ? await this.rpc('getMultipleAccounts', [rows.map((x) => x.address), { encoding: 'jsonParsed' }]) : null;
+            const vals = accs?.value ?? [];
+            holders = rows.map((x, i) => {
+                const owner = str(vals[i]?.data?.parsed?.info?.owner) ?? 'unknown';
+                return { owner, amount: BigInt(String(x.amount ?? '0')) };
+            }).sort((a, b) => (b.amount > a.amount ? 1 : b.amount < a.amount ? -1 : 0));
+        }
+        return { ...lp, lpSupply, holders };
+    }
+    /**
+     * `Withdraw` instructions among the pool's newest `n` successful transactions (and how many the creator signed).
+     * Fails closed: one transaction that cannot be read (after the rpc's rate-limit retries) could be the creator's
+     * Withdraw, so any unread one makes the whole scan `error` (the gate refuses, the vet looks again in 5 min).
+     */
+    async withdraws(pool, creator, n, now = Date.now()) {
+        const hit = this.scanCache.get(pool);
+        if (hit && now - hit.t < 10 * 60e3)
+            return hit.v;
+        const v = await this.scanWithdraws(pool, creator, n);
+        if (v !== 'error')
+            this.scanCache.set(pool, { t: now, v });
+        return v;
+    }
+    async scanWithdraws(pool, creator, n) {
+        try {
+            const sigs = await this.rpc('getSignaturesForAddress', [pool, { limit: Math.min(100, n * 2) }]);
+            const ok = (Array.isArray(sigs) ? sigs : []).filter((x) => isObj(x) && !x.err).slice(0, n);
+            let withdraws = 0;
+            let byCreator = 0;
+            let scanned = 0;
+            for (const s of ok) {
+                // maxSupportedTransactionVersion 1: Helius answers -32015 for a version-1 transaction under 0 (task-1394).
+                let tx = null;
+                try {
+                    tx = await this.rpc('getTransaction', [s.signature, { encoding: 'jsonParsed', maxSupportedTransactionVersion: 1 }]);
+                }
+                catch {
+                    return 'error';
+                }
+                if (!isObj(tx))
+                    return 'error';
+                scanned++;
+                const logs = tx.meta?.logMessages ?? [];
+                if (!logs.some((l) => l === 'Program log: Instruction: Withdraw'))
+                    continue;
+                withdraws++;
+                const keys = tx.transaction?.message?.accountKeys ?? [];
+                const signer = keys.map((k) => (isObj(k) ? k.pubkey : k))[0];
+                if (signer === creator)
+                    byCreator++;
+            }
+            return { scanned, withdraws, byCreator };
+        }
+        catch {
+            return 'error';
+        }
+    }
+    async tokenDecimals(mint) {
+        const hit = this.decimals.get(mint);
+        if (hit !== undefined)
+            return hit;
+        try {
+            const sup = await this.rpc('getTokenSupply', [mint]);
+            const d = fin(sup?.value?.decimals);
+            if (d !== null) {
+                this.decimals.set(mint, d);
+                return d;
+            }
+        }
+        catch { /* below */ }
+        // pump.fun mints are 6 decimals by construction.
+        return mint.endsWith('pump') ? 6 : null;
+    }
+    /** Jupiter token -> SOL quote for `raw` units. HTTP 429 / a network failure is not a quote error. */
+    async route(mint, raw) {
+        if (raw <= 0n)
+            return { ok: false, kind: 'no-route', error: 'zero amount' };
+        let r = { status: 0, json: null };
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                r = await this.d.fetchJson(`${this.d.jupiterBase ?? 'https://lite-api.jup.ag'}/swap/v1/quote?inputMint=${mint}&outputMint=${WSOL_MINT}&amount=${raw}&slippageBps=1000`);
+            }
+            catch (e) {
+                return { ok: false, kind: 'network', error: e.message.slice(0, 120) };
+            }
+            if (r.status !== 429 || attempt === 2)
+                break;
+            await sleep(this.backoffMs * (attempt + 1));
+        }
+        if (r.status === 429)
+            return { ok: false, kind: 'rate-limited', error: 'HTTP 429' };
+        const j = isObj(r.json) ? r.json : {};
+        if (str(j.outAmount) && !j.errorCode && !j.error)
+            return { ok: true, outLamports: BigInt(j.outAmount), impactPct: fin(Number(j.priceImpactPct)) === null ? null : Math.round(Number(j.priceImpactPct) * 10000) / 100 };
+        if (r.status >= 500 && !j.errorCode)
+            return { ok: false, kind: 'network', error: `HTTP ${r.status}` };
+        return { ok: false, kind: 'no-route', error: String(j.errorCode ?? j.error ?? `HTTP ${r.status}`).slice(0, 120) };
+    }
+    /** The pool's SOL vault balance (SOL). */
+    async vaultSol(vault) {
+        try {
+            const b = await this.rpc('getTokenAccountBalance', [vault]);
+            const v = b?.value ?? {};
+            return fin(v.uiAmount) ?? (str(v.amount) ? Number(v.amount) / 1e9 : null);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/** PumpSwap `Pool`: disc 8, bump u8, index u16, creator, base_mint, quote_mint, lp_mint, base vault, quote vault, lp_supply u64, coin_creator. */
+export function decodePumpSwapPool(d) {
+    if (d.length < 211)
+        throw new Error(`PumpSwap pool account too short (${d.length} bytes)`);
+    const key = (o) => base58(d.subarray(o, o + 32));
+    return { creator: key(11), baseMint: key(43), quoteMint: key(75), lpMint: key(107), baseVault: key(139), quoteVault: key(171) };
+}
+// ───────────────────────────── the vet ─────────────────────────────
+export const UNKNOWN_RETRY_MS = 5 * 60e3;
+/**
+ * The strategy's rug-proof gates as a runner vet: free gates first (tick + history), then the pair, the pool account,
+ * the withdraw scan and the Jupiter route. The first refusal ends it; a time gate asks to be retried.
+ */
+export function rugproofVet(r, o) {
+    return async (k, ctx) => {
+        const results = [];
+        const now = k.t;
+        const done = (x) => {
+            results.push(x);
+            if (x.pass)
+                return null;
+            o.log?.({ mint: k.mint, symbol: k.symbol, gate: x.gate, rule: x.rule, detail: x.detail, results: results.map((y) => `${y.gate}:${y.pass ? 'ok' : 'no'}`) });
+            // A read that failed (`-unknown`: a rate limit, an RPC outage) refuses now (fail closed) and looks again in 5 min,
+            // instead of skipping the coin for the rest of the run; a structural refusal is for good.
+            const retry = x.retryAfterMs ?? (x.rule.endsWith('-unknown') ? UNKNOWN_RETRY_MS : undefined);
+            return { ok: false, rule: x.rule, detail: x.detail, ...(retry !== undefined ? { retryAfterMs: retry } : {}) };
+        };
+        const history = ctx?.history ?? [];
+        const sizeUsd = ctx?.sizeUsd ?? 0;
+        const floor = ctx?.exitFloorUsd ?? 2000;
+        // 1-3: free.
+        let f = done(gatePoolAge(r, k, undefined, now));
+        if (f)
+            return f;
+        f = done(gateHolders(k, ctx?.maxTop10Pct ?? null, ctx?.maxDevPct ?? null, ctx?.unknownHolders));
+        if (f)
+            return f;
+        f = done(gateLiquidityRecheck(r, history, k, floor));
+        if (f)
+            return f;
+        // 4: the pool as listed.
+        let pair = null;
+        let pairErr = null;
+        try {
+            pair = await o.probe.pair(k.mint);
+        }
+        catch (e) {
+            pairErr = e.message.slice(0, 160);
+        }
+        results.shift(); // the token-age pass above is replaced by the pool's own age
+        if (pairErr !== null)
+            return done({ gate: 'pool-structure', pass: false, rule: 'rugproof:pool-structure-unknown', detail: `the pool could not be read: ${pairErr}` });
+        f = done(gatePoolAge(r, k, pair ? pair.createdAt : null, now));
+        if (f)
+            return f;
+        f = done(gatePoolStructure(r, k.mint, k.launchpad, pair));
+        if (f)
+            return f;
+        // 5-6: the chain.
+        let lp = null;
+        if (r.requireSafePool && pair) {
+            lp = o.probe.d.rpcUrl ? await o.probe.poolLp(pair.address, now) : 'error';
+            f = done(gateLpLocked(r, pair, lp, k.mint));
+            if (f)
+                return f;
+            const poolLp = lp;
+            const scan = poolLp.lpSupply === 0n && r.maxWithdraws === 0 ? null : await o.probe.withdraws(pair.address, poolLp.creator, r.withdrawScanTx);
+            f = done(gateWithdrawHistory(r, scan, poolLp));
+            if (f)
+                return f;
+        }
+        // 7: a sell route at routeX x the size.
+        if (r.routeX !== null) {
+            const dec = await o.probe.tokenDecimals(k.mint);
+            let route = null;
+            if (dec !== null && k.price) {
+                const tokens = (sizeUsd * r.routeX) / k.price;
+                route = await o.probe.route(k.mint, BigInt(Math.max(1, Math.round(tokens * 10 ** dec))));
+            }
+            f = done(gateSellRoute(r, route, sizeUsd));
+            if (f)
+                return f;
+        }
+        const v = verdictOf(r, results, pair?.createdAt ? now - pair.createdAt : null);
+        const note = `rugproof ok: ${results.map((x) => `${x.gate}${x.partial ? '~' : ''}`).join(', ')}${v.sizeCapPct !== null ? `; size cap ${v.sizeCapPct}% (young or partly verified pool)` : ''}`;
+        o.log?.({ mint: k.mint, symbol: k.symbol, pass: true, sizeCapPct: v.sizeCapPct, results: results.map((x) => `${x.gate}:${x.partial ? 'partial' : 'ok'}`) });
+        return { ok: true, note, recheck: true, ...(v.sizeCapPct !== null ? { sizeCapPct: v.sizeCapPct } : {}), ...(pair ? { pool: { address: pair.address, quoteVault: lp && lp !== 'error' ? lp.quoteVault : null } } : {}) };
+    };
+}
+/**
+ * Polls every open position's pool (SOL vault when the pool is known, plus a Jupiter quote for the held amount)
+ * every pollSec, outside the candle / tick cadence. The runner reads `verdict()` on every step and sells the whole
+ * position on an exit verdict. Timers are unref'd: they never keep a process alive.
+ */
+export class DrainPoller {
+    w = new Map();
+    g;
+    probe;
+    log;
+    constructor(g, probe, log) { this.g = g; this.probe = probe; this.log = log; }
+    watch(p) {
+        if (this.w.has(p.positionId))
+            return;
+        const x = { pos: p, base: { reserveSol: null, liqUsd: p.entryLiqUsd }, timer: null, verdict: null, reads: 0, quoteErrors: 0, noRoute: 0, busy: false, decimals: null };
+        this.w.set(p.positionId, x);
+        void this.poll(x, true);
+        x.timer = setInterval(() => { void this.poll(x, false); }, Math.max(2, Math.min(10, this.g.pollSec)) * 1000);
+        x.timer.unref?.();
+    }
+    unwatch(positionId) {
+        const x = this.w.get(positionId);
+        if (x?.timer)
+            clearInterval(x.timer);
+        this.w.delete(positionId);
+    }
+    verdict(positionId) {
+        const v = this.w.get(positionId)?.verdict ?? null;
+        return v && v.exit ? v : null;
+    }
+    stop() { for (const id of [...this.w.keys()])
+        this.unwatch(id); }
+    /** One probe of one position (also called by tests). */
+    async poll(x, first) {
+        if (x.busy)
+            return;
+        x.busy = true;
+        try {
+            let vault = x.pos.quoteVault ?? null;
+            if (!vault && x.pos.poolAddress && this.probe.d.rpcUrl) {
+                const lp = await this.probe.poolLp(x.pos.poolAddress);
+                if (lp && lp !== 'error')
+                    vault = x.pos.quoteVault = lp.quoteVault;
+            }
+            const reserveSol = vault && this.probe.d.rpcUrl ? await this.probe.vaultSol(vault) : null;
+            if (first || x.base.reserveSol === null) {
+                if (reserveSol !== null)
+                    x.base.reserveSol = reserveSol;
+            }
+            x.decimals ??= await this.probe.tokenDecimals(x.pos.mint);
+            const tokens = x.pos.tokens();
+            const route = this.g.exitOnNoRoute && x.decimals !== null && tokens > 0 ? await this.probe.route(x.pos.mint, BigInt(Math.max(1, Math.round(tokens * 10 ** x.decimals)))) : null;
+            x.reads++;
+            if (route && !route.ok && route.kind !== 'no-route')
+                x.quoteErrors++;
+            let v = drainVerdict(this.g, x.base, { t: Date.now(), reserveSol, liqUsd: null, route });
+            // A quote error alone needs two reads in a row (one pollSec apart): a single odd answer is not a pull. A reserve
+            // read decides at once. The poller keeps polling after an exit: a route that comes back lifts the verdict.
+            x.noRoute = v.exit && v.reason === 'drain-no-route' ? x.noRoute + 1 : 0;
+            if (v.exit && v.reason === 'drain-no-route' && x.noRoute < 2)
+                v = { exit: false, note: 'no route once: re-checking' };
+            const was = x.verdict?.exit ?? false;
+            x.verdict = v;
+            if (v.exit && !was)
+                this.log?.({ positionId: x.pos.positionId, mint: x.pos.mint, drain: v.reason, detail: v.detail, reads: x.reads });
+        }
+        catch (e) {
+            this.log?.({ positionId: x.pos.positionId, mint: x.pos.mint, probeError: e.message.slice(0, 160) });
+        }
+        finally {
+            x.busy = false;
+        }
+    }
+    stats() {
+        let reads = 0;
+        let quoteErrors = 0;
+        for (const x of this.w.values()) {
+            reads += x.reads;
+            quoteErrors += x.quoteErrors;
+        }
+        return { watched: this.w.size, reads, quoteErrors };
+    }
+}
+/** Run vets in order (the rug-proof gates first: they are the cheapest); the first refusal wins; notes and caps merge. */
+export function chainVets(...vets) {
+    const vs = vets.filter((v) => !!v);
+    if (vs.length <= 1)
+        return vs[0];
+    return async (k, ctx) => {
+        const notes = [];
+        let out = { ok: true };
+        for (const v of vs) {
+            const r = await v(k, ctx);
+            if (!r.ok)
+                return r;
+            if (r.note)
+                notes.push(r.note);
+            out = { ...out, ...r, recheck: !!(out.ok && out.recheck) || !!r.recheck, ...(out.ok && out.sizeCapPct !== undefined && (r.sizeCapPct === undefined || out.sizeCapPct < r.sizeCapPct) ? { sizeCapPct: out.sizeCapPct } : {}) };
+        }
+        return notes.length ? { ...out, note: notes.join('; ') } : out;
+    };
+}