dexterm-cli 0.1.5 → 0.1.6

package/dist/packages/cli/src/screens/pnl-chip.js

@@ -0,0 +1,143 @@
+// dexterm — the persistent POSITION PnL chip (task-1473). While an auto mode runs and a position is open, one compact
+// readout is on every terminal screen and on the chart popup: coin, mark PnL % with sign (and $ when the size is
+// known), entry → mark, peak, drawdown from the peak, time held and the take-profit. Sources (state.ts pnlChipFor):
+//   · following an agent (task-1466 HUD) that holds a PAPER ticket — the folded story, TP = what the agent said;
+//   · AI scan mode with the user's OWN paper or live position (OwnPnlTracker; session peak, TP = the ledger target).
+// Where it draws: the HUD dock's signal row when the dock is up (≥ HUD_MIN_H rows while following), else the band
+// under the header (row 1, right-aligned: short terminals, scan mode), and the chart popup's chip strip (ChartVM.chip).
+// It updates on every mark tick, flashes on a new peak (a ★ glyph says the same under calm mode / NO_COLOR) and drops
+// fields from the right as the width shrinks. Display only: it has no input and reads only folded / ledger state.
+import { mix } from '../../../tui/src/index.js';
+import { fmtPx } from '../../../agents/src/index.js';
+import { planFromThoughts, fmtDur } from "./brain.js";
+export const PEAK_FLASH_MS = 1200;
+/** The chip for the followed agent's open PAPER position, or null when nothing is held. */
+export function pnlChipVM(v, now) {
+    const a = v.arc;
+    if (!a || a.stage !== 'open')
+        return null;
+    const dd = a.pnlPct !== null && a.peakPct !== null ? (1 + a.pnlPct) / (1 + a.peakPct) - 1 : null;
+    return {
+        kind: 'PAPER',
+        symbol: a.symbol,
+        pnlPct: a.pnlPct,
+        pnlUsd: a.pnlPct !== null && a.sizeUsd !== null ? a.sizeUsd * a.pnlPct : null,
+        entry: a.entryUsd !== null ? `$${fmtPx(a.entryUsd)}` : '—',
+        mark: a.mark ? `$${fmtPx(a.mark.priceUsd)}` : '—',
+        peakPct: a.peakPct,
+        ddPct: dd,
+        heldMs: a.filledAt !== null ? now - a.filledAt : null,
+        tp: planFromThoughts(v.thoughts, a.openedAt).tp,
+        newPeak: a.peakAt !== null && now - a.peakAt < PEAK_FLASH_MS && a.peakPct !== null && a.peakPct > 0,
+    };
+}
+/**
+ * The user's own position chip in AI scan mode. The ledgers keep no peak, so the peak is this session's highest
+ * mark (reset when the held coin or ledger changes, or the position goes flat). Display only.
+ */
+export class OwnPnlTracker {
+    cur = null;
+    update(s, now) {
+        if (!s) {
+            this.cur = null;
+            return;
+        }
+        const seed = !this.cur || this.cur.s.mint !== s.mint || this.cur.s.kind !== s.kind;
+        if (seed)
+            this.cur = { s, peakPct: s.pnlPct, peakAt: null }; // the first mark is not a "new peak" flash
+        const c = this.cur;
+        c.s = s;
+        if (!seed && s.pnlPct !== null && (c.peakPct === null || s.pnlPct > c.peakPct + 1e-9)) {
+            c.peakPct = s.pnlPct;
+            c.peakAt = now;
+        }
+    }
+    get mint() { return this.cur?.s.mint ?? null; }
+    vm(now) {
+        const c = this.cur;
+        if (!c)
+            return null;
+        const s = c.s;
+        const dd = s.pnlPct !== null && c.peakPct !== null ? (1 + s.pnlPct) / (1 + c.peakPct) - 1 : null;
+        return {
+            kind: s.kind === 'live' ? 'LIVE' : 'PAPER',
+            symbol: s.symbol,
+            pnlPct: s.pnlPct,
+            pnlUsd: s.pnlUsd,
+            entry: s.entryUsd !== null ? `$${fmtPx(s.entryUsd)}` : '—',
+            mark: s.markUsd !== null ? `$${fmtPx(s.markUsd)}` : '—',
+            peakPct: c.peakPct,
+            ddPct: dd,
+            heldMs: s.openedAt !== null ? Math.max(0, now - s.openedAt) : null,
+            tp: s.targetUsd !== null ? `$${fmtPx(s.targetUsd)}` : null,
+            tpNone: 'not set',
+            newPeak: c.peakAt !== null && now - c.peakAt < PEAK_FLASH_MS && c.peakPct !== null && c.peakPct > 0,
+        };
+    }
+}
+const pct = (r) => `${r >= 0 ? '+' : '−'}${Math.abs(r * 100).toFixed(1)}%`;
+const usd = (n) => `${n >= 0 ? '+' : '−'}$${Math.abs(n).toFixed(2)}`;
+/** The chip's segments in priority order (the first ones survive the narrowest widths). */
+export function chipSegments(m) {
+    const segs = [];
+    const dir = m.pnlPct === null ? '·' : m.pnlPct >= 0 ? '▲' : '▼';
+    segs.push({ id: 'head', text: `${m.kind} $${m.symbol}` });
+    segs.push({ id: 'pnl', text: `${dir} ${m.pnlPct === null ? '—' : pct(m.pnlPct)}${m.pnlUsd !== null ? ` ${usd(m.pnlUsd)}` : ''}` });
+    if (m.peakPct !== null)
+        segs.push({ id: 'peak', text: `peak ${pct(m.peakPct)}${m.newPeak ? ' ★' : ''}` });
+    segs.push({ id: 'px', text: `${m.entry} → ${m.mark}` });
+    if (m.heldMs !== null)
+        segs.push({ id: 'held', text: `held ${fmtDur(m.heldMs)}` });
+    if (m.ddPct !== null && m.ddPct < -0.0005)
+        segs.push({ id: 'dd', text: `dd ${pct(m.ddPct)}` });
+    segs.push({ id: 'tp', text: m.tp ? `TP ${m.tp}` : `TP ${m.tpNone ?? 'agent-managed'}` });
+    return segs;
+}
+const SEP = ' │ ';
+/** The chip text that fits in `maxW` (segments drop from the end). Pure, for tests. */
+export function chipText(m, maxW) {
+    const segs = chipSegments(m);
+    let n = segs.length;
+    const join = (k) => ` ${segs.slice(0, k).map((s) => s.text).join(SEP)} `;
+    while (n > 1 && join(n).length > maxW)
+        n--;
+    const s = join(n);
+    return s.length <= maxW ? s : '';
+}
+/**
+ * Draw the chip right-aligned to `right` (exclusive) on row `y`, no wider than `maxW`. Returns the x it starts at
+ * (or `right` when nothing fits).
+ */
+export function renderPnlChip(c, right, y, maxW, m, o) {
+    const t = c.theme;
+    const text = chipText(m, maxW);
+    if (!text)
+        return right;
+    const x0 = right - text.length;
+    const bg = mix(t.bg, t.magenta, 0.22);
+    const col = m.pnlPct === null ? t.muted : m.pnlPct >= 0 ? t.up : t.down;
+    c.text(x0, y, text, { fg: t.text, bg });
+    // re-colour the segments: head magenta, PnL red/green bold (flash on a new peak), peak green, dd warn
+    let x = x0 + 1;
+    for (const s of chipSegments(m)) {
+        if (x + s.text.length > right - 1)
+            break;
+        if (s.id === 'head')
+            c.text(x, y, s.text, { fg: t.magenta, bg, b: true });
+        else if (s.id === 'pnl') {
+            const flash = m.newPeak && !o.reduced;
+            c.text(x, y, s.text, flash ? { fg: t.bg, bg: t.up, b: true } : { fg: col, bg, b: true });
+        }
+        else if (s.id === 'peak')
+            c.text(x, y, s.text, { fg: m.peakPct !== null && m.peakPct >= 0 ? t.up : t.down, bg, b: m.newPeak });
+        else if (s.id === 'dd')
+            c.text(x, y, s.text, { fg: t.warn, bg });
+        else
+            c.text(x, y, s.text, { fg: t.muted, bg });
+        x += s.text.length;
+        if (x + SEP.length < right)
+            c.text(x, y, SEP, { fg: mix(bg, t.border, 0.8), bg });
+        x += SEP.length;
+    }
+    return x0;
+}

package/dist/packages/cli/src/screens/screener.js

@@ -195,6 +195,7 @@ export function renderScreener(c, state) {
         : null;
     table(c, box.x + 1, box.y, box.w - 2, box.h, {
         columns: screenerColumns(c, bp, sc.gates, state.larpByMint ?? null, icon, mode), rows, selected: sel, scroll: Math.max(0, scroll), sortKey: sc.sort.key, sortDir: sc.sort.dir, bg: box.bg,
+        rowKey: (r) => r.mint, // task-1466: the agent HUD finds the rows it scanned
     });
     if (rows.length === 0)
         emptyState(c, box, sc);

package/dist/packages/cli/src/screens/token.js

@@ -8,8 +8,9 @@ import { renderTokenLive } from "../live/screens/token-live.js";
 import { aiTranscript } from "../fixtures.js";
 import { renderAnalystSession } from "./analyst-session.js";
 import { renderSocialPanel } from "./social-panel.js";
+import { brainFor, factsFromFixture, renderBrainPanel } from "./brain.js";
 import { layoutFor } from "../custom.js";
-import { chartMode, priceModeOf } from "../display.js";
+import { chartMode, chartTitle, chartAxisOf, priceModeOf } from "../display.js";
 export function renderToken(c, state) {
     if (state.live?.token && state.screener.source !== 'fixtures')
         return renderTokenLive(c, state, state.live.token.view); // task-1298: live data path
@@ -48,13 +49,13 @@ export function renderToken(c, state) {
     // price line: pump glow = gold bg band, dump = red band (the rain ramp of the moment)
     const priceBg = pumping ? mix(t.bg, t.rainPump[2], 0.3) : dumping ? mix(t.bg, t.rainDump[2], 0.3) : t.bg;
     // task-1366: mcap mode leads with the market cap and keeps the price beside it (fixture tokens always carry a supply)
-    const cm = chartMode(priceModeOf(state), tk.price, tk.mcap);
-    if (cm.kind === 'mcap') {
+    const pm = chartMode(priceModeOf(state), tk.price, tk.mcap);
+    if (pm.kind === 'mcap') {
         x = c.text(1, y, fmtMcap(tk.mcap), { fg: pumping ? t.rainPump[3] : t.text, bg: priceBg, b: true });
         x = c.text(x, y, ` (${fmtPrice(tk.price)})`, { fg: t.dim, bg: priceBg });
     }
     else
-        x = c.text(1, y, fmtPrice(tk.price), { fg: cm.label ? t.warn : pumping ? t.rainPump[3] : t.text, bg: priceBg, b: true });
+        x = c.text(1, y, fmtPrice(tk.price), { fg: pm.label ? t.warn : pumping ? t.rainPump[3] : t.text, bg: priceBg, b: true });
     const deltas = [['5m', tk.chg.m5], ['1h', tk.chg.h1], ['6h', tk.chg.h6], ['24h', tk.chg.h24]];
     x = c.text(x, y, '  ', { bg: t.bg });
     for (const [k, vv] of deltas) {
@@ -70,7 +71,9 @@ export function renderToken(c, state) {
     y += 1;
     // ---- chart
     const chartH = Math.max(10, Math.floor((bottom - y) * lay.chartFrac));
-    const cb = c.box(0, y, mainW, chartH, { title: cm.label ? (cm.kind === 'mcap' ? `${tk.symbol} ${cm.label} · 1h` : `${tk.symbol}/SOL · ${cm.label} · 1h`) : `${tk.symbol}/SOL · 1h`, caption: 'ohlcv: geckoterminal' });
+    // task-1472: the chart Y axis is its own setting (default MARKET CAP, `A` toggles); the header above keeps `$`
+    const cm = chartMode(chartAxisOf(state), tk.price, tk.mcap);
+    const cb = c.box(0, y, mainW, chartH, { title: chartTitle(tk.symbol, '1h', cm, 'SOL'), caption: 'ohlcv: geckoterminal' });
     const tfx = cb.x + cb.w - 2;
     const tfs = ['1m', '5m', '15m', '1h', '4h', '1d'];
     let tx = tfx - tfs.reduce((s, f) => s + f.length + 1, 0) - 24;
@@ -171,8 +174,14 @@ export function renderToken(c, state) {
             }
         }
     }
-    if (showAi)
-        analystPanel(c, mainW, top, aiW, bottom - top, tk, state);
+    if (showAi) {
+        // task-1473: in an auto mode (following an agent / AI scan) the panel is the BRAIN VIEW; otherwise the analyst
+        const brain = brainFor(state, factsFromFixture(tk, state.larpByMint?.get(tk.mint)?.verdict ?? null), isCalm(v), state.live?.scanMeterLabel?.() ?? '');
+        if (brain)
+            renderBrainPanel(c, mainW, top, aiW, bottom - top, brain.model, brain.opts);
+        else
+            analystPanel(c, mainW, top, aiW, bottom - top, tk, state);
+    }
     footer(c, state.tokenSocial
         ? [['esc', 'back'], ['s', 'on-chain'], ['f', 'filter'], ['x', state.socialShowSpam ? 'hide spam' : 'show hidden'], ['K', 'KOL lists'], ['a', showAi ? 'hide analyst' : 'analyst'], ['w', 'watch'], ['q', 'quit']]
         : [['esc', 'back'], ['g', 'go to'], ['a', showAi ? 'hide analyst' : 'analyst'], ['h/t/r', 'holders/trades/traders'], ['w', 'watch'], ['b', 'alert'], ['1-6', 'timeframe'], ['q', 'quit']], state.theme.name, isCalm(v));

package/dist/packages/cli/src/screens/trending.js

@@ -70,7 +70,7 @@ export function renderTrending(c, state) {
     if (rows.length === 0)
         c.textC(box.x, box.y + 2, box.w, all.length ? 'no rows match the filter — f cycles filters, n clears the narrative' : 'nothing trending yet — the keyless venues refresh every 60 s', { fg: t.muted, bg, i: true });
     else
-        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows, selected: sel, scroll, bg });
+        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows, selected: sel, scroll, bg, rowKey: (r) => r.mint });
     // sub-panels
     const sy = top + boardH;
     const news = feed.newsItems(12);

package/dist/packages/cli/src/state.js

@@ -1,11 +1,13 @@
 // dexterm — app state consumed by the screens. Screens are pure render(canvas, state) functions;
 // renderFrame() draws the screen, the toast, then runs the effects post-pass (VISUAL-V2 §3).
-import { Canvas, THEMES, applyFx, toast, makeVfx, setSources, marketActivity, candleActivity, isCalm, } from '../../tui/src/index.js';
+import { Canvas, THEMES, applyFx, toast, makeVfx, setSources, marketActivity, candleActivity, isCalm, breakpoint, } from '../../tui/src/index.js';
 import { makeFixtures } from "./fixtures.js";
 import { fromFixture } from "./screener/rows.js";
 import { makeScreenerState, screenerView } from "./screener/view.js";
 import { renderScreener } from "./screens/screener.js";
 import { renderToken } from "./screens/token.js";
+import { agentBrainActive } from "./screens/brain.js";
+import { pnlChipVM, renderPnlChip } from "./screens/pnl-chip.js";
 import { renderNewPairs } from "./screens/newpairs.js";
 import { renderWatchlist } from "./screens/watchlist.js";
 import { renderAnalyst } from "./screens/analyst.js";
@@ -28,7 +30,9 @@ import { openTicket } from "./trade.js";
 import { computeFill } from '../../data/src/index.js';
 import { renderScanTicker, scanIndicator } from "./scan/ui.js";
 import { renderVoiceHud } from "./voice-hud.js";
+import { composeHud, DOCK_ROWS, HUD_MIN_H } from "./screens/agent-hud.js";
 import { workspaceBadge } from "./custom.js";
+import { chartAxisOf, supplyRatio } from "./display.js";
 /** Map key for the Analyst-tab's own conversation (not tied to a single token). */
 export const ANALYST_TAB_KEY = '__analyst_tab__';
 /**
@@ -426,8 +430,54 @@ export function refreshVfx(state) {
     state.vfx.activity = act.activity;
     state.vfx.mood = act.mood;
 }
-/** Render one frame of the current screen into a fresh canvas: screen → toast → effects. */
+/**
+ * Render one frame of the current screen into a fresh canvas: screen → toast → effects. task-1466: while the
+ * terminal follows an agent, the screen renders DOCK_ROWS shorter and the agent HUD's dock takes the bottom rows
+ * (so no data is hidden), with its overlays (row glow, cursor, cards, flashes, the kill cut) over the screen.
+ */
 export function renderFrame(state, w, h) {
+    const hud = state.agentHud;
+    if (!hud || state.screen === 'boot' || h < HUD_MIN_H)
+        return renderScreenFrame(state, w, h, true);
+    const now = hud.clock();
+    const screen = renderScreenFrame(state, w, h - DOCK_ROWS, false);
+    const view = hud.story.view(now);
+    // task-1473: on the token screen the analyst panel is the agent's brain view (same rule the screen used)
+    const brain = state.screen === 'token' && state.aiOpen !== false && breakpoint(w) !== 'compact' && !state.aiFocused && agentBrainActive(view, now);
+    return composeHud(new Canvas(w, h, state.theme), screen, view, {
+        now, reduced: !!hud.reduced || isCalm(state.vfx), depth: state.colorDepth, dataLabel: hud.dataLabel ?? null, screen: state.screen, brain,
+        chip: pnlChipFor(state, now, view),
+        mcapScale: chartAxisOf(state) === 'mcap' ? (mint) => hudMcapScale(state, mint) : undefined, // task-1472
+    });
+}
+/** task-1472: the supply ratio for the HUD's position card: the open token's (live, else fixture), else its screener row. */
+function hudMcapScale(state, mint) {
+    const v = state.live?.token?.view;
+    if (v && v.mint === mint)
+        return supplyRatio(v.price, v.mcap);
+    const tk = state.token;
+    if (tk && tk.mint === mint)
+        return supplyRatio(tk.price, tk.mcap);
+    const row = state.screener.rows.find((r) => r.mint === mint); // the card also shows over the lists (task-1473)
+    return row ? supplyRatio(row.price, row.mcap) : null;
+}
+/**
+ * task-1473: the POSITION PnL chip for the app's current auto mode, or null. Following an agent: its open PAPER
+ * ticket (the folded story). Else, while AI scan mode runs: the user's own held paper / live position (ownPnl).
+ * The same chip feeds the HUD dock, the band row (no dock) and the chart popup. Display only.
+ */
+export function pnlChipFor(state, now, view) {
+    const hud = state.agentHud;
+    if (hud) {
+        const m = pnlChipVM(view ?? hud.story.view(now), now);
+        if (m)
+            return m;
+    }
+    if (state.scan?.engine.on && state.ownPnl)
+        return state.ownPnl.vm(now);
+    return null;
+}
+function renderScreenFrame(state, w, h, bandChip = false) {
     const c = new Canvas(w, h, state.theme);
     c.fill(0, 0, w, h, ' ', { bg: state.theme.bg });
     c.imageMode = state.images && state.imageProtocol && state.imageProtocol !== 'blocks' ? 'pixels' : 'cells';
@@ -445,11 +495,25 @@ export function renderFrame(state, w, h) {
         renderVoiceHud(c, state.voice, state.theme);
     // task-1358: the workspace badge (non-default name, a pending ctrl+w chord, the save-as input) on the band
     // under the header, right-aligned, drawn after the effects so it is always legible. Nothing on `default`.
+    // task-1473 r2: no HUD dock (short terminal, or AI scan mode): the PnL chip rides the band, right-aligned,
+    // and the workspace badge moves to its left.
+    let bandRight = w - 1;
+    if (bandChip && state.screen !== 'boot') {
+        const now = state.agentHud?.clock() ?? state.now.getTime();
+        const chip = pnlChipFor(state, now);
+        if (chip) {
+            const x0 = renderPnlChip(c, w - 1, 1, Math.max(36, Math.floor(w * 0.7)), chip, { now, reduced: !!state.agentHud?.reduced || isCalm(state.vfx) });
+            if (x0 < w - 1) {
+                c.noRain(x0, 1, w - 1 - x0, 1);
+                bandRight = x0 - 1;
+            }
+        }
+    }
     const badge = state.screen !== 'boot' ? workspaceBadge(state.custom, state.now.getTime()) : null;
-    if (badge) {
+    if (badge && bandRight > 4) {
         const t = state.theme;
-        const text = badge.text.slice(0, Math.max(0, w - 2));
-        const x = Math.max(0, w - text.length - 1);
+        const text = badge.text.slice(0, Math.max(0, bandRight - 1));
+        const x = Math.max(0, bandRight - text.length);
         c.noRain(x, 1, text.length, 1);
         c.text(x, 1, text, badge.kind === 'input' ? { fg: t.text, bg: t.accentSoft, b: true } : badge.kind === 'chord' ? { fg: t.warn, bg: t.warnSoft, b: true } : { fg: t.accent, bg: t.headBg, b: true });
     }

package/dist/packages/cli/src/version.js

@@ -1,3 +1,3 @@
 // The one place the app's version lives (task-1397). --version, the help banner and `dexterm update` read it;
 // cli.test.ts keeps it equal to packages/cli/package.json (release.yml refuses a tag that differs).
-export const VERSION = '0.1.5';
+export const VERSION = '0.1.6';

package/dist/packages/custom/src/schema.js

@@ -140,6 +140,12 @@ export const LAYOUT_SCREENS = ['screener', 'token', 'newpairs', 'watchlist', 'an
  */
 export const PRICE_MODES = ['price', 'mcap'];
 export const DEFAULT_PRICE_MODE = 'price';
+/**
+ * task-1472: what the CHART Y axis shows (the terminal token chart and the chart popup), separate from the table/header
+ * price mode: `mcap` (default; absent = mcap, so existing configs get it too) or `price`. `A` / the popup control toggle it.
+ */
+export const CHART_AXES = ['mcap', 'price'];
+export const DEFAULT_CHART_AXIS = 'mcap';
 const tokenProps = () => Object.fromEntries([...THEME_TOKENS.map((t) => [t, 'hex']), ...THEME_RAMPS.map((t) => [t, 'ramp'])]);
 export const SCHEMAS = {
     hex: { type: 'string', pattern: HEX },
@@ -236,8 +242,8 @@ export const SCHEMAS = {
                     user: { type: 'object', values: 'userTheme' },
                 } },
             fx: { type: 'object', additional: false, props: { intensity: { type: 'string', enum: ['off', 'normal', 'fever'] }, sound: { type: 'boolean' } } },
-            /** task-1366: display options. `priceMode` price | mcap (the `$` key toggles and persists it). */
-            display: { type: 'object', additional: false, props: { priceMode: { type: 'string', enum: PRICE_MODES } } },
+            /** task-1366: display options. `priceMode` price | mcap (the `$` key toggles and persists it). task-1472: `chartAxis` mcap | price (`A`; absent = mcap). */
+            display: { type: 'object', additional: false, props: { priceMode: { type: 'string', enum: PRICE_MODES }, chartAxis: { type: 'string', enum: CHART_AXES } } },
             layout: { type: 'object', additional: false, props: {
                     workspace: { type: 'string', pattern: WS_NAME },
                     workspaces: { type: 'object', values: 'workspace' },

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

@@ -53,6 +53,8 @@ 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',
+    };
+}