dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/data/src/basis.js

@@ -0,0 +1,191 @@
+// @dexterm/data/basis (task-1537): THE price-basis module. Market cap is the default way dexterm shows and talks
+// about a coin ("entered at $69.7K, exited at $264.9K, 3.8x"); USD price per token is the alternative when the user
+// sets `display.priceMode: "price"` in ~/.dexterm/config.json (or for one run: `--price` / DEXTERM_PRICE_BASIS=price).
+//
+// One resolver (`resolveBasis`) decides what a price slot shows, one formatter pair (`fmtCap` / `fmtUsdPrice`) draws it,
+// and `basisLanguage` is the paragraph every model-facing prompt carries so the agents speak the same basis as the UI.
+//
+// Supply rule (shared with the PnL card, task-1518): a market cap the data source reports, else price × a supply that
+// is KNOWN: the source's own mcap ÷ price, the recorded FDV ÷ price, or pump.fun's fixed 1B for a pump.fun coin. A
+// supply is never guessed: with none, the slot shows the price and says why (`fallback`).
+//
+// Pure: no I/O, no imports. Display and wording only; nothing here is read by the signer, caps, plans or tickets.
+// JSON outputs keep BOTH `price` and `mcap` fields always (`withMcap`); only the human-facing text switches.
+export const PRICE_BASES = ['mcap', 'price'];
+/** The default basis everywhere (UI, CLI text, agent language) when config, flag and env say nothing. */
+export const DEFAULT_PRICE_BASIS = 'mcap';
+/** One-run override: `DEXTERM_PRICE_BASIS=price dexterm …` (the CLI flags `--price` / `--mcap` set it too). */
+export const PRICE_BASIS_ENV = 'DEXTERM_PRICE_BASIS';
+export function isPriceBasis(v) { return v === 'mcap' || v === 'price'; }
+/** The one-run override from the environment, or null when unset / not a basis. */
+export function envPriceBasis(env) {
+    const v = env?.[PRICE_BASIS_ENV]?.trim().toLowerCase();
+    return isPriceBasis(v) ? v : null;
+}
+/**
+ * The basis in effect: the one-run override (flag/env) wins, then the config value (`display.priceMode`), then mcap.
+ * A config written before task-1537 is migrated (custom v4 → v5), so `configured` is the user's saved choice.
+ */
+export function pickBasis(configured, env) {
+    return envPriceBasis(env) ?? (isPriceBasis(configured) ? configured : DEFAULT_PRICE_BASIS);
+}
+// ------------------------------------------------------------------------------------------------ formatters
+const SUB = '₀₁₂₃₄₅₆₇₈₉';
+const trim = (s) => (s.includes('.') ? s.replace(/0+$/, '').replace(/\.$/, '') : s);
+/**
+ * A market cap (or any large USD amount) in sentences, rows and lines: `$950`, `$69.7K`, `$264.9K`, `$1.2M`, `$1.23M`,
+ * `$4.5B`. K keeps one decimal, M / B / T two, trailing zeros dropped; the unit is promoted AFTER rounding so 999 960
+ * reads `$1M`, never `$1000K`. Null / non-finite → '—'. (Narrow table cells use the 3-significant-digit tui form.)
+ */
+export function fmtCap(n) {
+    if (n === null || n === undefined || !Number.isFinite(n))
+        return '—';
+    const sign = n < 0 ? '-' : '';
+    const a = Math.abs(n);
+    if (a < 999.5)
+        return `${sign}$${a < 1 ? trim(a.toFixed(2)) : String(Math.round(a))}`;
+    const units = ['K', 'M', 'B', 'T'];
+    let u = 0, v = a / 1000;
+    while (u < units.length - 1 && v >= 1000) {
+        v /= 1000;
+        u++;
+    }
+    const dp = (i) => (i === 0 ? 1 : 2);
+    let r = Number(v.toFixed(dp(u)));
+    if (r >= 1000 && u < units.length - 1) {
+        u++;
+        r = Number((r / 1000).toFixed(dp(u)));
+    }
+    return `${sign}$${trim(r.toFixed(dp(u)))}${units[u]}`;
+}
+/**
+ * A USD price per token, the usual small-number form with subscript zeros: `$0.0₄123`, `$0.0123`, `$1.234`, `$142.50`.
+ * Matches `fmtPrice` in @dexterm/tui (tested), so a price reads the same on every surface.
+ */
+export function fmtUsdPrice(p) {
+    if (p === null || p === undefined || !Number.isFinite(p))
+        return '—';
+    if (p < 0)
+        return `-${fmtUsdPrice(-p)}`;
+    if (p >= 1000)
+        return `$${p.toLocaleString('en-US', { maximumFractionDigits: 0 })}`;
+    if (p >= 1)
+        return `$${p.toFixed(p >= 100 ? 2 : 3)}`;
+    if (p >= 0.01)
+        return `$${p.toFixed(4)}`;
+    const m = p.toFixed(12).match(/^0\.(0*)(\d+)/);
+    if (!m)
+        return `$${p}`;
+    const zeros = m[1].length;
+    const digits = m[2].replace(/0+$/, '').slice(0, 4) || '0';
+    if (zeros < 3)
+        return `$0.${m[1]}${digits}`;
+    return `$0.0${String(zeros).split('').map((c) => SUB[Number(c)]).join('')}${digits}`;
+}
+/** An x-multiple between two levels of the same basis: `3.8x`, `0.42x`, `12x`. Null when either side is unusable. */
+export function fmtX(from, to) {
+    if (from === null || from === undefined || to === null || to === undefined || !Number.isFinite(from) || !Number.isFinite(to) || from <= 0 || to < 0)
+        return null;
+    const x = to / from;
+    return `${x >= 10 ? x.toFixed(0) : x >= 1 ? x.toFixed(1) : x.toFixed(2)}x`;
+}
+// ------------------------------------------------------------------------------------------------ supply + resolver
+/** pump.fun mints a fixed 1,000,000,000 supply per coin (none is minted later), so its market cap is price × 1B. */
+export const PUMP_FUN_SUPPLY = 1_000_000_000;
+const pos = (n) => n !== null && n !== undefined && Number.isFinite(n) && n > 0;
+/**
+ * The KNOWN supply for a coin, or null. Order: an explicit supply; the source's mcap ÷ price; recorded FDV ÷ price
+ * (a fully diluted cap on a non-pump coin, and the source says so); pump.fun's fixed 1B for a pump.fun coin (by
+ * launchpad, or a `…pump` mint with no launchpad). Never guessed.
+ */
+export function knownSupply(h) {
+    const via = h.via ? ` (${h.via})` : '';
+    if (pos(h.supply))
+        return { tokens: h.supply, source: `recorded supply${via}` };
+    if (pos(h.mcap) && pos(h.price) && Number.isFinite(h.mcap / h.price))
+        return { tokens: h.mcap / h.price, source: `market cap ÷ price${via}` };
+    if (pos(h.fdv) && pos(h.price) && Number.isFinite(h.fdv / h.price))
+        return { tokens: h.fdv / h.price, source: `recorded FDV ÷ price${via}` };
+    const mint = h.mint ?? '';
+    if (h.launchpad === 'pump.fun' || ((!h.launchpad || h.launchpad === 'unknown') && mint.endsWith('pump')))
+        return { tokens: PUMP_FUN_SUPPLY, source: 'pump.fun fixed supply' };
+    return null;
+}
+/** Why a slot that wanted market cap shows a price instead (said next to the number, never hidden). */
+export const NO_SUPPLY_REASON = 'market cap unknown: no supply recorded, showing price';
+/**
+ * THE resolver every screen, line, table and prompt calls: the headline figure for one price slot.
+ * `price` is the USD (or the caller's unit) price at that moment; `mcap` a cap the source reports for the SAME moment.
+ * A historical price (an entry fill) is turned into a cap with a known supply (`supply` / FDV / pump.fun 1B).
+ */
+export function resolveBasis(want, o) {
+    const price = Number.isFinite(o.price) ? o.price : null;
+    const sup = knownSupply(o);
+    const mcap = pos(o.mcap) && !pos(o.supply) ? o.mcap : price !== null && sup ? price * sup.tokens : null;
+    const pText = fmtUsdPrice(price);
+    if (want === 'mcap' && mcap !== null) {
+        return { want, basis: 'mcap', price, mcap, text: fmtCap(mcap), both: price !== null ? `${fmtCap(mcap)} mcap (${pText})` : `${fmtCap(mcap)} mcap`, fallback: null, supply: sup };
+    }
+    const fallback = want === 'mcap' && price !== null ? NO_SUPPLY_REASON : null;
+    const both = mcap !== null ? `${pText} (mcap ${fmtCap(mcap)})` : fallback ? `${pText} (${fallback})` : pText;
+    return { want, basis: 'price', price, mcap, text: pText, both, fallback, supply: sup };
+}
+/** A level in a sentence: `$69.7K` (mcap) or `$0.0₄697` (price, or the mcap fallback with `· supply unknown`). */
+export function fmtLevel(want, o) {
+    const v = resolveBasis(want, o);
+    return v.fallback ? `${v.text} (price; supply unknown)` : v.text;
+}
+/**
+ * An entry → exit (or → now) sentence in the basis: mcap `entered at $69.7K, exited at $264.9K (3.8x)`, price
+ * `entered at $0.0₄697, exited at $0.0₃265 (3.8x)`. Both levels use the same supply, so the multiple is the same in
+ * either basis. `exit` null with `now` → `…, now $120K (1.7x)`.
+ */
+export function entryExitLine(want, o) {
+    const sup = knownSupply({ ...o, mcap: o.mcap, price: o.price });
+    const asCap = want === 'mcap' && sup !== null;
+    const f = (p) => (p === null || p === undefined || !Number.isFinite(p) ? '—' : asCap ? fmtCap(p * sup.tokens) : fmtUsdPrice(p));
+    const end = o.exit !== null && o.exit !== undefined ? o.exit : o.now ?? null;
+    const verb = o.exit !== null && o.exit !== undefined ? 'exited at' : 'now';
+    const x = fmtX(o.entry, end);
+    const tail = want === 'mcap' && !asCap ? ' (prices: supply unknown)' : '';
+    return `entered at ${f(o.entry)}${end !== null ? `, ${verb} ${f(end)}` : ''}${x ? ` (${x})` : ''}${tail}`;
+}
+/**
+ * JSON keeps BOTH numbers: return `obj` with a market-cap twin for each price key (`pairs` maps price key → cap key,
+ * e.g. `{ price: 'mcap', entryPrice: 'entryMcap' }`), from a known supply, else null. A cap already on the object (a
+ * source-reported one) is kept. Never removes or changes a price field.
+ */
+export function withMcap(obj, pairs, h) {
+    const sup = knownSupply(h);
+    const out = { ...obj };
+    for (const [k, name] of Object.entries(pairs)) {
+        if (typeof out[name] === 'number' && Number.isFinite(out[name]))
+            continue;
+        const p = obj[k];
+        out[name] = typeof p === 'number' && Number.isFinite(p) && sup ? p * sup.tokens : null;
+    }
+    return out;
+}
+// ------------------------------------------------------------------------------------------------ agent language
+/** A short hint for tool descriptions (MCP, agent tool table) so external agents also speak the basis. */
+export const MCAP_FIELD_HINT = 'Every price field has a market-cap twin (`mcap`, `entryMcap`, …; null when the supply is unknown). basis: talk in market cap by default (cap at entry, cap now, targets/stops as cap levels, x-multiples); use the price fields only when the user\'s display.priceMode is "price" or the cap is null.';
+/**
+ * The paragraph every model-facing prompt carries (the chat assistant, the autotrade candidate agent, help answers).
+ * Follows the basis AT RUN TIME: tests assert both texts.
+ */
+export function basisLanguage(basis) {
+    if (basis === 'price') {
+        return [
+            'PRICE BASIS: USD PRICE (the user set display.priceMode = "price").',
+            'Talk in USD price per token: the price at entry, the price now, targets and stops as price levels (with x-multiples).',
+            'Quote market cap only as a secondary number in brackets ("$0.0₄697 (mcap $69.7K)"). Tools return both `price` and `mcap` fields.',
+        ].join(' ');
+    }
+    return [
+        'PRICE BASIS: MARKET CAP (the default; display.priceMode = "mcap").',
+        'Talk about a coin the way traders do, in market cap: the cap at entry and the cap now ("in at $69.7K, now $264.9K, 3.8x"),',
+        'targets and stops as market-cap levels ("take profit at $500K, stop at $40K"), and moves as x-multiples.',
+        'Use the `mcap` / `*Mcap` fields tools return; write caps as $69.7K / $1.2M. A per-token price only in brackets when it helps,',
+        'or alone when the cap is null (the supply is unknown): then say "price only, supply unknown". Never invent a supply.',
+    ].join(' ');
+}

package/dist/packages/data/src/detail.js

@@ -3,7 +3,10 @@
 // stale-while-revalidate, so the detail screen and the MCP tools share one
 // set of requests.
 import { TTL } from "./cache.js";
-const NS = { mint: 'rpc:mint', holders: 'rpc:holders', rug: 'rugcheck', pools: 'gt:pools', goplus: 'goplus', trades: 'gt:trades' };
+import { classifyHolder, EX_POOL_TAGS } from "./intel/holder-class.js";
+const NS = { mint: 'rpc:mint', holders: 'rpc:holders', ownerMeta: 'rpc:owner-meta', rug: 'rugcheck', pools: 'gt:pools', goplus: 'goplus', trades: 'gt:trades' };
+/** The program that owns an account (a pool, a curve PDA, a wallet) does not change: a week per owner. */
+const OWNER_META_TTL = 7 * 86_400_000;
 /** Pools for a mint change rarely; one lookup per hour per mint. */
 const POOLS_TTL = 3_600_000;
 /** The trades tape shares GeckoTerminal's 10/min bucket with the candles: refresh at most every 20 s per pool. */
@@ -51,7 +54,7 @@ export class TokenDetail {
         return this.cache.fetch(NS.holders, mint, async () => {
             const info = (await this.mintInfo(mint)).value;
             try {
-                return await this.pool.topHolders(mint, { info });
+                return await this.exPool(await this.pool.topHolders(mint, { info }));
             }
             catch (rpcErr) {
                 const agg = await this.aggregateHolders(mint, info).catch(() => null);
@@ -61,6 +64,54 @@ export class TokenDetail {
             }
         }, { ttlMs: TTL.holders, source: this.pool.primary.source });
     }
+    /**
+     * The HOLDERS panel's ex-pool rule (task-1367 `classifyHolder`) for every caller of `holders()` (the MCP
+     * `get_holders` / `get_dossier` concentration, the autotrade dossier, rug-check), task-1518. A top account whose
+     * owner is a pool, a bonding curve, a launch vault, a lock or the burn address is not a person's position: it gets
+     * `poolSide` (and `label: 'LP'` for a pool, curve or vault) and is left out of `top10Pct`. Without this, every young
+     * PumpSwap pool (the vault owner is the pool account) and every Meteora DAMM v2 pool (the global pool authority)
+     * read as one 80-95 % "holder". One extra getMultipleAccounts over the owners not yet known (no data, <= 20
+     * addresses, cached a week per owner: an account's program does not change), the same lookup the wallet-intel scan
+     * makes; when it fails, only the derived authorities and the pump.fun curve are recognised and every other owner
+     * stays counted (never hidden).
+     */
+    async exPool(h) {
+        if (h.aggregateOnly || !h.holders.length)
+            return h;
+        const owners = [...new Set(h.holders.map((x) => x.owner).filter((o) => !!o))];
+        const meta = new Map();
+        const misses = [];
+        for (const o of owners) {
+            const hit = this.cache.get(NS.ownerMeta, o);
+            if (hit)
+                meta.set(o, hit.value);
+            else
+                misses.push(o);
+        }
+        if (misses.length) {
+            try {
+                const got = await this.pool.accountMeta(misses);
+                // an address with no account yet can be created later: an hour for those, a week for accounts that exist
+                for (const [o, m] of got) {
+                    meta.set(o, m);
+                    this.cache.set(NS.ownerMeta, o, m, { ttlMs: m.exists ? OWNER_META_TTL : 3_600_000, source: this.pool.primary.source });
+                }
+            }
+            catch { /* counted, never hidden */ }
+        }
+        const holders = h.holders.map((x) => {
+            if (!x.owner || x.label)
+                return x;
+            const c = classifyHolder({ mint: h.mint, owner: x.owner, tokenAccounts: [x.tokenAccount], meta: meta.get(x.owner), cex: null, dev: null, poolRule: null, linked: null });
+            if (!EX_POOL_TAGS.has(c.tag))
+                return x;
+            return { ...x, ...(c.tag === 'POOL' || c.tag === 'CURVE' || c.tag === 'VAULT' ? { label: 'LP' } : {}), poolSide: { tag: c.tag, program: c.program, reason: c.reason } };
+        });
+        const sum = (xs) => Math.round(xs.reduce((s, x) => s + x.pct, 0) * 1000) / 1000;
+        const notCounted = new Set(['LP', 'cex', 'bridge']);
+        const counted = holders.filter((x) => !x.poolSide && !(x.label && notCounted.has(x.label))).slice(0, 10);
+        return { ...h, holders, top10Pct: h.top10Pct === null ? null : sum(counted), top10PctRaw: h.top10Pct === null ? null : sum(holders.slice(0, 10)) };
+    }
     /** Build an aggregate-only TopHolders from the keyless Jupiter holder data; null when unavailable. */
     async aggregateHolders(mint, info) {
         if (!this.holdersAggregate)

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

@@ -28,31 +28,19 @@ export * from "./credits.js";
 export * from "./budget.js";
 export * from "./watchlist.js";
 export * from "./paper.js";
-export * from "./trade/caps.js";
 export * from "./trade/bridge.js";
-export * from "./trade/swap-build.js";
-export * from "./trade/rpc-exec.js";
-export * from "./trade/executor.js";
 export * from "./trade/link-store.js";
 export * from "./trade/tx-decode.js";
-export * from "./trade/sol-usd.js";
 export * from "./trade/kill-switch.js";
-export * from "./trade/token-delta.js";
 // task-1443: the paper agent desk + its rendezvous (agents paper-trade inside an armed mandate; never sign/send).
 export * from "./trade/agent/paper-desk.js";
 export * from "./trade/agent/rendezvous.js";
-export * from "./trade/signer/protocol.js";
-export * from "./trade/signer/service.js";
-export * from "./trade/signer/host.js";
-export * from "./trade/signer/client.js";
-export * from "./trade/signer/probe-builder.js";
-export * from "./trade/signer/fast-wallet.js";
-export * from "./trade/signer/sol-usd-feed.js";
-export { parseSignerArgs, buildSignerService } from "./trade/signer/main.js";
 export * from "./larp/links.js";
 export * from "./larp/safe-fetch.js";
 export * from "./larp/evidence.js";
 export * from "./larp/link-baseline.js";
+export * from "./larp/x-account.js";
+export * from "./larp/score.js";
 // task-1401: parse a CA / coin link from any input (go-to, analyst chat, filter line, --mint, MCP refs).
 export * from "./coin-target.js";
 export * from "./analyst-actions.js";

package/dist/packages/data/src/larp/score.js

@@ -0,0 +1,220 @@
+// LARP score (task-1471): a 0-100 summary of the LARP check's flags. Pure, offline, deterministic.
+//
+// What it is: the transparent SUM of named flags, each with its points and the evidence that raised it. Higher
+// means more of the things that go with LARP coins showed up. It is evidence, not a verdict: every flag can be
+// innocent on its own, and the score never says a coin is fake, safe or worth anything.
+//
+// Missing data never lowers the score and is never scored as clean. A flag whose evidence could not be read (page
+// blocked, RDAP down, the X sources unavailable) goes to `missing` with the points it COULD have added, and the
+// range `[score, score + those points]` (and its band range) widens instead.
+//
+// Where the points come from (LARP_SCORE_WEIGHTS[*].source):
+//  - `calibrated`: the link-shape flags, fitted on the TRAIN split of the task-1401 eval set (1054 coins, 72 h
+//    outcome labels; packages/packs/src/larp-score-backtest.ts). points = clamp(round(8 × ln odds ratio of a bad
+//    outcome), 0, 12), using the flag only when ≥ 20 train coins carry it. The cap keeps link shape alone in the
+//    `medium` band at most: the larp-check skill never calls a coin LARP from links alone.
+//  - `prior`: page, domain, GitHub and X-account flags. The eval set does not hold that evidence point-in-time (the
+//    pages are gone or changed, and a deleted X account after a coin dies would leak the outcome), so these are
+//    pre-registered weights written from the skill text before any data, and are labelled as such everywhere.
+import { linkSignals } from "./link-baseline.js";
+export const LARP_SCORE_MODEL = 'larp-score-v1';
+/**
+ * The shipped weights. The `calibrated` rows are asserted equal to a fresh fit on the committed eval set
+ * (packages/packs/test/larp-score-1471.test.ts), so a re-tune cannot ship stale points.
+ */
+export const LARP_SCORE_WEIGHTS = {
+    // links (DexScreener / Jupiter advertised links): calibrated where the eval set had ≥ 20 train coins.
+    no_website: { group: 'links', label: 'no website advertised', points: 9, source: 'calibrated' },
+    no_x: { group: 'links', label: 'no X account advertised', points: 10, source: 'calibrated' },
+    x_not_account: { group: 'links', label: 'X link is a single post or a community, not an account', points: 5, source: 'calibrated' },
+    no_telegram: { group: 'links', label: 'no Telegram advertised', points: 12, source: 'calibrated' },
+    site_is_social: { group: 'links', label: 'the "website" is a social page', points: 1, source: 'calibrated' },
+    domain_no_name_match: { group: 'links', label: "the website's domain does not name the token", points: 0, source: 'calibrated' },
+    cheap_tld: { group: 'links', label: 'website on a throwaway-priced TLD', points: 0, source: 'calibrated' },
+    site_is_launchpad: { group: 'links', label: 'the "website" is a launchpad/explorer page', points: 4, source: 'prior' },
+    site_linktree: { group: 'links', label: 'the "website" is a link hub', points: 2, source: 'prior' },
+    site_free_host: { group: 'links', label: 'website on a free/site-builder host', points: 2, source: 'prior' },
+    links_mismatch: { group: 'links', label: 'sources advertise different sites or X accounts', points: 8, source: 'prior' },
+    // website (one SSRF-safe fetch, no JavaScript)
+    drainer_markers: { group: 'website', label: 'wallet-drainer markers on the page', points: 30, source: 'prior' },
+    default_page: { group: 'website', label: 'website is a default/placeholder page', points: 15, source: 'prior' },
+    wallet_connect: { group: 'website', label: 'website asks to connect a wallet', points: 8, source: 'prior' },
+    never_names_token: { group: 'website', label: 'website never names the token', points: 8, source: 'prior' },
+    // domain (RDAP)
+    domain_new: { group: 'domain', label: 'domain registered under 30 days ago', points: 8, source: 'prior' },
+    domain_privacy: { group: 'domain', label: 'domain behind registrant privacy', points: 2, source: 'prior' },
+    // GitHub (keyless API)
+    no_github: { group: 'github', label: 'no GitHub repo advertised', points: 2, source: 'prior' },
+    github_archived: { group: 'github', label: 'GitHub repo is archived', points: 4, source: 'prior' },
+    github_fork: { group: 'github', label: 'GitHub repo is a fork', points: 4, source: 'prior' },
+    github_stale: { group: 'github', label: 'GitHub repo not pushed in 180+ days', points: 4, source: 'prior' },
+    // X account (keyless lookup chain)
+    x_suspended: { group: 'x', label: 'X account is suspended', points: 20, source: 'prior' },
+    x_not_found: { group: 'x', label: 'X account does not exist', points: 15, source: 'prior' },
+    x_account_days_old: { group: 'x', label: 'X account under 7 days old', points: 12, source: 'prior' },
+    x_account_new: { group: 'x', label: 'X account under 30 days old', points: 6, source: 'prior' },
+    x_tiny_following: { group: 'x', label: 'X account has under 50 followers', points: 5, source: 'prior' },
+    x_no_posts: { group: 'x', label: 'X account has no posts in 30 days', points: 6, source: 'prior' },
+    x_handle_mismatch: { group: 'x', label: "the website's X link and the advertised X account differ", points: 10, source: 'prior' },
+    x_renamed: { group: 'x', label: 'the linked X post is now under another handle', points: 5, source: 'prior' },
+    x_no_site_link: { group: 'x', label: "the X account's bio/website does not link the coin's site", points: 3, source: 'prior' },
+};
+/** Band thresholds (pre-registered round numbers; their measured precision is in LARP_SCORE_MEASURED). */
+export const LARP_SCORE_BANDS = { medium: 25, high: 50 };
+export const bandOf = (score) => (score >= LARP_SCORE_BANDS.high ? 'high' : score >= LARP_SCORE_BANDS.medium ? 'medium' : 'low');
+/**
+ * Held-out TEST-split numbers for the link-shape part of the score (the only part the eval set can replay),
+ * from packages/packs/eval/larp-score-backtest.json (`dexterm backtest --subject larp-score`). A test asserts these match the committed report.
+ */
+export const LARP_SCORE_MEASURED = {
+    model: LARP_SCORE_MODEL,
+    eval: 'task-1401 eval set (built 2026-10-16), 72h outcome labels, bad = rug or dead',
+    part: 'link-shape flags only (page, domain, GitHub and X-account flags cannot be replayed on history)',
+    test: { n: 328, bad: 61, auroc: 0.691, by_band: { low: { n: 218, bad: 27 }, medium: { n: 110, bad: 34 }, high: { n: 0, bad: 0 } } },
+    train: { n: 726, bad: 294, auroc: 0.727 },
+};
+const W = LARP_SCORE_WEIGHTS;
+const LINK_FLAG = {
+    site_is_social: 'site_is_social', site_is_launchpad: 'site_is_launchpad', site_linktree: 'site_linktree', site_free_host: 'site_free_host',
+    site_no_name_match: 'domain_no_name_match', cheap_tld: 'cheap_tld', x_not_profile: 'x_not_account', no_x: 'no_x', no_tg: 'no_telegram',
+};
+/** The link-shape flags of a feature set (shared by the live score and the backtest, so both score the same thing). */
+export function linkFlagIds(f) {
+    const ids = linkSignals(f).map((s) => LINK_FLAG[s]);
+    if (f.web === 'none')
+        ids.unshift('no_website');
+    return ids;
+}
+/** Sum the link-shape points only (what the backtest scores). */
+export function linkScore(f, weights = {}) {
+    return Math.min(100, linkFlagIds(f).reduce((a, id) => a + (weights[id] ?? W[id].points), 0));
+}
+/** Compute the LARP score from the gathered evidence. Pure. */
+export function larpScore(ev) {
+    const flags = [];
+    const missing = [];
+    // A flag fitted to 0 points (it did not go with bad outcomes) is not listed: it would add nothing but noise.
+    const add = (id, evidence) => { const w = W[id]; if (w.points > 0)
+        flags.push({ id, group: w.group, label: w.label, points: w.points, weight: w.source, evidence }); };
+    const miss = (id, group, what, maxPoints) => { if (maxPoints > 0)
+        missing.push({ id, group, what, maxPoints }); };
+    const pts = (...ids) => ids.reduce((a, id) => a + W[id].points, 0);
+    if (ev.mode === 'token' && ev.link) {
+        const why = {
+            no_website: 'DexScreener/Jupiter list no website', no_x: 'DexScreener/Jupiter list no X link', no_telegram: 'DexScreener/Jupiter list no Telegram link',
+            x_not_account: `the advertised X link is a ${ev.link.x === 'status' ? 'single post' : ev.link.x === 'community' ? 'community' : 'non-account page'}`,
+            site_is_social: 'the advertised website is a social-network page', site_is_launchpad: 'the advertised website is a launchpad/explorer page',
+            site_linktree: 'the advertised website is a link hub', site_free_host: 'the advertised website is on a free/site-builder host',
+            domain_no_name_match: 'neither the symbol nor the name appears in the domain', cheap_tld: 'the domain is on a throwaway-priced TLD',
+        };
+        for (const id of linkFlagIds(ev.link))
+            add(id, why[id] ?? W[id].label);
+    }
+    if (ev.mismatch.length)
+        add('links_mismatch', ev.mismatch.join('; '));
+    // website page
+    if (ev.website) {
+        const p = ev.page;
+        if (!p || !p.ok)
+            miss('website:*', 'website', `website page not read${p && !p.ok ? ` (${p.reason})` : ''}`, pts('drainer_markers', 'default_page', 'wallet_connect', 'never_names_token'));
+        else {
+            if (p.drainerFlags.length)
+                add('drainer_markers', `markers: ${p.drainerFlags.slice(0, 3).join(', ')}`);
+            if (p.defaultPage)
+                add('default_page', 'the page matches a default/placeholder template');
+            if (p.walletConnect)
+                add('wallet_connect', 'the page carries a wallet-connect prompt');
+            if (p.mentionsSymbol === false && p.mentionsName === false)
+                add('never_names_token', 'neither the symbol nor the name appears in the page text');
+            else if (p.mentionsSymbol === null && p.mentionsName === null)
+                miss('never_names_token', 'website', 'whether the page names the token (no symbol/name to look for)', W.never_names_token.points);
+        }
+        const d = ev.domain;
+        if (!d || !d.ok)
+            miss('domain:*', 'domain', `domain registration not read${d && !d.ok ? ` (${d.reason})` : ''}`, pts('domain_new', 'domain_privacy'));
+        else {
+            if (typeof d.ageDays === 'number' && d.ageDays < 30)
+                add('domain_new', `registered ${d.ageDays} days ago (RDAP)`);
+            else if (d.ageDays === null)
+                miss('domain_new', 'domain', 'domain registration date', W.domain_new.points);
+            if (d.privacy === true)
+                add('domain_privacy', 'the RDAP registrant contact is redacted');
+            else if (d.privacy === null)
+                miss('domain_privacy', 'domain', 'registrant privacy', W.domain_privacy.points);
+        }
+    }
+    // GitHub
+    const g = ev.github;
+    if (g === 'none') {
+        if (ev.mode === 'token')
+            add('no_github', 'no github.com repo link among the advertised links or on the fetched page');
+    }
+    else if (g && !g.ok)
+        miss('github:*', 'github', `GitHub repo not read (${g.reason})`, pts('github_archived', 'github_fork', 'github_stale'));
+    else if (g) {
+        if (g.archived)
+            add('github_archived', 'the GitHub API marks the repo archived');
+        if (g.fork)
+            add('github_fork', 'the GitHub API marks the repo a fork');
+        if (typeof g.daysSincePush === 'number' && g.daysSincePush > 180)
+            add('github_stale', `last push ${g.daysSincePush} days ago`);
+    }
+    // X account
+    const x = ev.x;
+    if (x && x.handle) {
+        const at = `@${x.screenName ?? x.handle}`;
+        if (x.status === 'suspended')
+            add('x_suspended', `${at}: an X lookup source reports the account suspended`);
+        else if (x.status === 'not_found')
+            add('x_not_found', `@${x.handle}: two independent sources (vxtwitter, X oEmbed) found no such account`);
+        else if (x.status === 'unavailable')
+            miss('x:*', 'x', `X account not read (${x.unavailable[0] ?? 'every source failed'})`, Math.max(pts('x_suspended'), pts('x_account_days_old', 'x_tiny_following', 'x_no_posts', 'x_no_site_link')));
+        else {
+            if (typeof x.ageDays === 'number' && x.ageDays < 7)
+                add('x_account_days_old', `${at} created ${x.createdAt?.slice(0, 10)} (${x.ageDays} days ago)`);
+            else if (typeof x.ageDays === 'number' && x.ageDays < 30)
+                add('x_account_new', `${at} created ${x.createdAt?.slice(0, 10)} (${x.ageDays} days ago)`);
+            else if (x.ageDays === null)
+                miss('x_account_days_old', 'x', 'X account created date', W.x_account_days_old.points);
+            if (typeof x.followers === 'number' && x.followers < 50)
+                add('x_tiny_following', `${at} has ${x.followers} followers${x.countsSource === 'vxtwitter' && x.countsAsOf ? ` (cached copy from ${x.countsAsOf.slice(0, 16).replace('T', ' ')} UTC)` : ''}`);
+            else if (x.followers === null)
+                miss('x_tiny_following', 'x', 'X follower count', W.x_tiny_following.points);
+            if (x.tweets === 0)
+                add('x_no_posts', `${at} has never posted`);
+            else if (typeof x.daysSinceLastPost === 'number' && x.daysSinceLastPost > 30)
+                add('x_no_posts', `${at} last posted ${x.lastPostAt?.slice(0, 10)} (${x.daysSinceLastPost} days ago)`);
+            else if (x.lastPostAt === null && x.tweets !== 0)
+                miss('x_no_posts', 'x', 'X last post date', W.x_no_posts.points);
+            if (x.linksSite === false)
+                add('x_no_site_link', `${at}'s bio and website field do not mention ${ev.website ? new URL(ev.website).hostname.replace(/^www\./, '') : 'the site'}`);
+            else if (x.linksSite === null && ev.website)
+                miss('x_no_site_link', 'x', "whether the X account links the coin's site", W.x_no_site_link.points);
+        }
+        if (x.renamed)
+            add('x_renamed', x.renamed.evidence);
+    }
+    if (ev.xAgreement?.siteAgrees === false)
+        add('x_handle_mismatch', ev.xAgreement.note ?? "the website's X link and the advertised account differ");
+    const GROUP_MAX = {
+        website: pts('drainer_markers', 'default_page', 'wallet_connect', 'never_names_token'),
+        domain: pts('domain_new', 'domain_privacy'),
+        github: pts('github_archived', 'github_fork', 'github_stale'),
+        x: Math.max(pts('x_suspended'), pts('x_account_days_old', 'x_tiny_following', 'x_no_posts', 'x_no_site_link')),
+    };
+    for (const n of ev.notChecked ?? [])
+        if (!missing.some((m) => m.group === n.group))
+            miss(`${n.group}:*`, n.group, n.why, GROUP_MAX[n.group]);
+    flags.sort((a, b) => b.points - a.points);
+    const score = Math.min(100, flags.reduce((a, f) => a + f.points, 0));
+    const hi = Math.min(100, score + missing.reduce((a, m) => a + m.maxPoints, 0));
+    const m = LARP_SCORE_MEASURED.test;
+    return {
+        model: LARP_SCORE_MODEL, score, band: bandOf(score),
+        range: { lo: score, hi, bandLo: bandOf(score), bandHi: bandOf(hi) },
+        thresholds: { ...LARP_SCORE_BANDS },
+        flags, top: flags.filter((f) => f.points > 0).slice(0, 3), missing,
+        measured: `link-shape part only, held-out test split (${m.n} coins, ${m.bad} went bad within 72 h): AUROC ${m.auroc.toFixed(2)}; ${m.by_band.low.bad}/${m.by_band.low.n} low-band and ${m.by_band.medium.bad}/${m.by_band.medium.n} medium-band coins went bad. Page, domain, GitHub and X points are pre-registered priors, not fitted.`,
+        caveat: 'a sum of named flags, evidence not a verdict: any flag can be innocent, a low score is not a safety check, and missing data widens the range instead of lowering the score',
+    };
+}