dexterm-cli 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,170 @@
+// dexterm — RULES screen (ctrl+r, task-1358 Tier 3). The user's rules (`config.rules`): enabled, name, the
+// condition, the actions, the source (user / pack / jarvis), fires in the last hour, last fired. Below it the
+// PROPOSALS pane (ticket/ask cards a rule produced — inert until the user acts on them, and even then the paper
+// ticket editor / the analyst is where anything happens) or the LOG of recent fires. Typing a rule shows a live
+// dry-run against the rows on screen: "would match N of M rows right now". Nothing on this screen arms or signs.
+import { Canvas, header, footer, breakpoint, fmtAgeSec } from '../../../tui/src/index.js';
+import { describeActions } from '../../../custom/src/index.js';
+import { headerModel } from "../state.js";
+import { describeCard } from "../rules.js";
+function fit(s, w) { return s.length > w ? (w > 1 ? s.slice(0, w - 1) + '…' : s.slice(0, w)) : s; }
+export function renderRules(c, state) {
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    header(c, headerModel(state));
+    const ui = state.rulesUi ?? null;
+    const rules = ui?.engine.rules ?? [];
+    const now = state.now.getTime();
+    const top = 2, bottom = c.h - 1;
+    const typing = ui?.input !== null && ui?.input !== undefined;
+    const enabled = rules.filter((r) => r.enabled).length;
+    const title = `RULES · ${rules.length} (${enabled} on) · ${ui?.fires ?? 0} fires this session · ${ui?.proposals.length ?? 0} proposal${(ui?.proposals.length ?? 0) === 1 ? '' : 's'}`;
+    const caption = bp === 'compact' ? undefined : 'when <cond> [for n ticks] then alert|ticket|ask|popup|tag|sound|watch · parsed, never eval\'d · rules only alert or PROPOSE';
+    const lowerH = Math.max(6, Math.min(14, Math.floor((bottom - top) * 0.4)));
+    const listH = bottom - top - lowerH;
+    const rulesFocus = !typing && (ui?.pane ?? 'rules') === 'rules';
+    const box = c.box(0, top, c.w, listH, { title, caption, focus: rulesFocus });
+    const bg = box.bg;
+    let cy = box.y;
+    if (ui?.errors.length) {
+        for (const e of ui.errors.slice(0, 2)) {
+            c.text(box.x + 1, cy, `⚠ ${e}`, { fg: t.warn, bg }, box.w - 2);
+            cy += 1;
+        }
+    }
+    if (!rules.length) {
+        c.text(box.x + 1, cy + 1, 'no rules yet.', { fg: t.muted, bg });
+        cy += 3;
+        c.text(box.x + 1, cy, 'i                                 type a rule, e.g.  vol5m.velocity > 3 and cluster < 20 and liq > 25K for 2 ticks then alert(up, "surge") popup(chart)', { fg: t.dim, bg }, box.w - 2);
+        cy += 1;
+        c.text(box.x + 1, cy, 'dexterm rules add "<rule>"         the same from a shell · rules list | check | dry-run | remove | enable | disable', { fg: t.dim, bg }, box.w - 2);
+        cy += 1;
+        c.text(box.x + 1, cy, 'fields: price mcap fdv liq vol5m vol1h vol24 holders org top10 dev lplocked bundled snipers cluster age m5 h1 h6 h24 buys sells bonding', { fg: t.dim, bg }, box.w - 2);
+        cy += 1;
+        c.text(box.x + 1, cy, 'signals: <field>.velocity (× its own pace) · <field>.delta (change in the window) · tags: launchpad: flag: verified: sus:', { fg: t.dim, bg }, box.w - 2);
+        cy += 2;
+        c.text(box.x + 1, cy, 'every rule has a cooldown (10m) and a max/h (12, cap 120) · ticket/ask make PROPOSAL cards: you still size + confirm in the paper ticket', { fg: t.dim, bg, i: true }, box.w - 2);
+    }
+    else {
+        const wide = bp !== 'compact';
+        const xs = wide ? [1, 5, 24, 0, 0, 0, 0] : [1, 5, 20, 0, 0, 0, 0];
+        // right-anchored columns: LAST(6) F/H(4) SRC(9) THEN(28 wide / 18)
+        const lastW = 6, fhW = 4, srcW = wide ? 9 : 6, thenW = wide ? 30 : 18;
+        xs[6] = box.w - 1 - lastW;
+        xs[5] = xs[6] - 1 - fhW;
+        xs[4] = xs[5] - 1 - srcW;
+        xs[3] = xs[4] - 1 - thenW;
+        const whenW = Math.max(8, xs[3] - xs[2] - 1);
+        const heads = ['ON', 'RULE', 'WHEN', 'THEN', 'SRC', 'F/H', 'LAST'];
+        heads.forEach((h, i) => c.text(box.x + xs[i], cy, h, { fg: t.dim, bg }));
+        cy += 1;
+        const sel = Math.max(0, Math.min(rules.length - 1, ui?.selected ?? 0));
+        const scroll = Math.max(0, sel - (box.h - 4));
+        for (let i = scroll; i < rules.length; i++) {
+            if (cy >= box.y + box.h - 1)
+                break;
+            const r = rules[i];
+            const selected = i === sel && rulesFocus;
+            const rb = selected ? t.selBg : bg;
+            c.fill(box.x, cy, box.w, 1, ' ', { bg: rb });
+            if (selected)
+                c.put(box.x, cy, '▎', { fg: t.accent, bg: rb, soft: true });
+            c.text(box.x + xs[0], cy, r.enabled ? 'on' : 'off', { fg: r.enabled ? t.up : t.dim, bg: rb, b: r.enabled });
+            c.text(box.x + xs[1], cy, fit(r.name === r.id ? r.id : r.name, xs[2] - xs[1] - 1), { fg: selected ? t.borderFocus : t.text, bg: rb });
+            c.text(box.x + xs[2], cy, fit(`${r.whenText}${r.for ? ` for ${'ticks' in r.for ? r.for.ticks + ' ticks' : Math.round(r.for.ms / 1000) + 's'}` : ''}`, whenW), { fg: r.enabled ? t.text : t.muted, bg: rb });
+            c.text(box.x + xs[3], cy, fit(describeActions(r), thenW), { fg: t.accent, bg: rb });
+            c.text(box.x + xs[4], cy, fit(r.source.replace(/^pack:/, 'pk:'), srcW), { fg: r.source === 'user' ? t.muted : t.warn, bg: rb });
+            const fh = ui.engine.firesLastHour(r.id, now);
+            c.text(box.x + xs[5], cy, String(fh).padStart(3), { fg: fh ? t.text : t.dim, bg: rb });
+            const last = ui.engine.lastFiredAt(r.id);
+            c.text(box.x + xs[6], cy, last ? fmtAgeSec(Math.max(0, Math.round((now - last) / 1000))) : '—', { fg: last ? t.muted : t.dim, bg: rb });
+            cy += 1;
+        }
+    }
+    if (ui?.notice && !typing)
+        c.textR(box.x + 1, box.y + box.h - 1, box.w - 2, ui.notice, { fg: t.warn, bg, i: true });
+    // lower pane: PROPOSALS or LOG
+    const proposalsPane = (ui?.pane ?? 'rules') === 'proposals';
+    const ltitle = proposalsPane
+        ? `PROPOSALS · ${ui?.proposals.length ?? 0} pending · inert until you act`
+        : `LOG · last ${Math.min(ui?.log.length ?? 0, lowerH - 2)} of ${ui?.log.length ?? 0} · tab for proposals`;
+    const lcaption = bp === 'compact' ? undefined : proposalsPane
+        ? '⏎ = open the PAPER ticket editor / ask the analyst (you confirm there) · x = dismiss · nothing here arms or signs'
+        : 'alerts, proposals, watch/tag, popups as they fired · reasons carry each satisfied clause with its value';
+    const lbox = c.box(0, top + listH, c.w, lowerH, { title: ltitle, caption: lcaption, focus: !typing && proposalsPane });
+    const lbg = lbox.bg;
+    let ly = lbox.y;
+    const lrows = lbox.h - (typing ? 2 : 0);
+    if (proposalsPane) {
+        const cards = ui?.proposals ?? [];
+        if (!cards.length)
+            c.text(lbox.x + 1, ly, 'no proposals pending — a rule with ticket(...) or ask(...) puts its card here when it fires', { fg: t.dim, bg: lbg, i: true });
+        const psel = Math.max(0, Math.min(cards.length - 1, ui?.selectedProposal ?? 0));
+        const pscroll = Math.max(0, psel - (lrows - 1));
+        for (let i = pscroll; i < cards.length; i++) {
+            if (ly >= lbox.y + lrows)
+                break;
+            const p = cards[i];
+            const selected = i === psel && !typing;
+            const rb = selected ? t.selBg : lbg;
+            c.fill(lbox.x, ly, lbox.w, 1, ' ', { bg: rb });
+            if (selected)
+                c.put(lbox.x, ly, '▎', { fg: t.accent, bg: rb, soft: true });
+            let cx = c.text(lbox.x + 1, ly, fmtAgeSec(Math.max(0, Math.round((now - p.at) / 1000))).padEnd(5), { fg: t.dim, bg: rb });
+            cx = c.text(cx + 1, ly, 'PROPOSAL', { fg: t.warn, bg: rb, b: true });
+            cx = c.text(cx + 1, ly, fit(describeCard(p), 34).padEnd(34), { fg: p.type === 'ticket' ? (p.side === 'buy' ? t.up : t.down) : t.accent, bg: rb });
+            cx = c.text(cx + 1, ly, fit(p.name, 14).padEnd(14), { fg: t.muted, bg: rb });
+            c.text(cx + 1, ly, fit(p.why, lbox.w - (cx + 1 - lbox.x) - 1), { fg: t.dim, bg: rb });
+            ly += 1;
+        }
+    }
+    else {
+        const log = ui?.log ?? [];
+        if (!log.length)
+            c.text(lbox.x + 1, ly, ui?.engine.rules.some((r) => r.enabled) ? 'nothing fired yet (rules evaluate the screener rows every few seconds)' : 'no enabled rules', { fg: t.dim, bg: lbg, i: true });
+        for (const e of log) {
+            if (ly >= lbox.y + lrows)
+                break;
+            const fg = e.kind === 'alert' ? (e.level === 'up' ? t.up : e.level === 'down' ? t.down : e.level === 'warn' ? t.warn : t.text) : e.kind === 'proposal' ? t.warn : t.muted;
+            let cx = c.text(lbox.x + 1, ly, fmtAgeSec(Math.max(0, Math.round((now - e.at) / 1000))).padEnd(5), { fg: t.dim, bg: lbg });
+            cx = c.text(cx + 1, ly, fit(e.symbol, 8).padEnd(8), { fg: t.accent, bg: lbg });
+            cx = c.text(cx + 1, ly, fit(e.name, 14).padEnd(14), { fg: t.muted, bg: lbg });
+            c.text(cx + 1, ly, fit(e.text, lbox.w - (cx + 1 - lbox.x) - 1), { fg, bg: lbg });
+            ly += 1;
+        }
+    }
+    if (typing && ui) {
+        const iy = lbox.y + lbox.h - 1;
+        c.hline(lbox.x, iy - 1, lbox.w, { fg: t.border, bg: lbg });
+        const label = ui.editingId ? `edit ${ui.editingId}: ` : 'rule: ';
+        c.text(lbox.x + 1, iy, label, { fg: t.accent, bg: lbg, b: true });
+        const avail = lbox.w - label.length - 3;
+        const txt = ui.input;
+        const shown = txt.length > avail ? '…' + txt.slice(txt.length - avail + 1) : txt;
+        c.text(lbox.x + 1 + label.length, iy, `${shown}█`, { fg: t.text, bg: lbg }, avail + 1);
+        // the live dry-run on the line above the input
+        const d = ui.dry;
+        let dryText;
+        let dryFg;
+        if (!txt.trim()) {
+            dryText = 'type a rule · ⏎ save · esc cancel';
+            dryFg = t.dim;
+        }
+        else if (!d) {
+            dryText = 'checking…';
+            dryFg = t.dim;
+        }
+        else if (d.error) {
+            dryText = `✗ ${d.error}`;
+            dryFg = t.down;
+        }
+        else {
+            const names = d.matches.slice(0, 6).map((m) => m.symbol).join(' ');
+            dryText = `✓ would match ${d.matches.length} of ${d.considered} rows right now${names ? ` (${names}${d.matches.length > 6 ? ' …' : ''})` : ''}${d.noHistory ? ` · ${d.noHistory} without history yet (velocity/delta need two earlier samples)` : ''} · ${describeActions(d.rule)} · cooldown ${Math.round(d.rule.cooldownMs / 60000)}m · max ${d.rule.maxPerHour}/h`;
+            dryFg = d.matches.length ? t.up : t.muted;
+        }
+        c.text(lbox.x + 1, iy - 1, ` ${fit(dryText, lbox.w - 4)} `, { fg: dryFg, bg: lbg });
+        c.textR(lbox.x + 1, iy, lbox.w - 2, '⏎ save · esc cancel', { fg: t.dim, bg: lbg });
+    }
+    footer(c, [['↑↓', 'move'], ['i', 'new rule'], ['⏎', proposalsPane ? 'act on proposal' : 'edit rule'], ['space', 'on/off'], ['d', 'delete'], ['tab', proposalsPane ? 'log' : 'proposals'], ['x', 'dismiss'], ['esc', 'back'], ['q', 'quit']], t.name);
+}

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

@@ -0,0 +1,459 @@
+// dexterm — Screener screen: ranked token table + neon sparklines + side spotlight at wide widths.
+// Rows are `ScreenerRow`s (fixtures or the data store); cells the health registry cannot vouch
+// for render as a dim dash with the reason in the panel caption, never as a number.
+// Cyberspace styling (task-1297): rain zones in the filter-bar gap, the table/spotlight gutter and the
+// spotlight's blank middle; the selected ticker in phosphor; ▲/▼ on every direction (VISUAL-V2 §6.5).
+import { Canvas, table, sparkline, sparkArea, heatPct, launchpadBadge, ratioBar, badge, pctStyle, statGrid, fmtUsd, fmtPrice, fmtAge, fmtNum, fmtPct, fmtPctDir, fmtDeltaDir, shortAddr, header, footer, breakpoint, mix, isCalm, onAccent, } from '../../../tui/src/index.js';
+import { layoutFor } from "../custom.js";
+import { headerModel } from "../state.js";
+import { screenerView, gateCaption, feedCondition } from "../screener/view.js";
+import { SORT_KEYS, sortSpec } from "../screener/sort.js";
+import { RUG_FLAG_THRESHOLD, RUG_MODEL_LABEL, fmtRugP, rugDataAge, rugP } from "../screener/rug.js";
+import { drawCoin, imagesOn } from "./coin.js";
+import { COIN_ICON_W } from '../../../tui/src/index.js';
+import { priceCell, priceModeOf, promoteMcap, fallbackCount, fallbackCaption, FALLBACK_MARK, MCAP_FALLBACK_NOTE } from "../display.js";
+/** Table column key → health gate id (COLUMN_SOURCES). Columns without an entry are always shown. */
+export const COLUMN_GATE = {
+    lp: 'launchpad', age: 'age', price: 'price', m5: '5m', h1: '1h', h6: '6h', h24: '24h', vol: 'vol', liq: 'liq', mcap: 'mcap',
+    holders: 'holders', org: 'org', txns: 'bs', spark: 'sparkline', flags: 'flags',
+};
+const DEFAULT_QUERY = 'vol24 > 250K  liq > 50K  age < 30d  chain:solana';
+/**
+ * LARP-detector badge for a verdict (task-1315): a short label + colour, or null for a verdict with
+ * no badge. Only ever called for a mint whose verdict was actually computed (present in larpByMint).
+ */
+export function larpBadge(verdict, t) {
+    switch (verdict) {
+        case 'LARP': return { text: 'LARP', fg: t.down };
+        case 'REAL_PRODUCT': return { text: 'REAL', fg: t.up };
+        case 'EARLY_BUT_REAL': return { text: 'REAL?', fg: mix(t.bg, t.up, 0.8) };
+        case 'UNVERIFIABLE':
+        case 'AMBIGUOUS': return { text: 'UNKNOWN', fg: t.warn };
+        default: return null;
+    }
+}
+export function screenerColumns(c, bp, gates = null, larp = null, icon = null, mode = 'price') {
+    const t = c.theme;
+    const muted = (bg) => ({ fg: t.muted, bg });
+    const dash = (cv, x, y, w, bg, align = 'right') => {
+        if (align === 'right')
+            cv.textR(x, y, w, '—', { fg: t.dim, bg });
+        else
+            cv.text(x, y, '—', { fg: t.dim, bg });
+    };
+    void gates; // the gate drives the panel caption (gateCaption); cells only ever dash a null
+    const cols = [
+        { key: 'rank', label: '#', w: 3, align: 'right', prio: 0, render: (cv, x, y, w, _r, bg, m) => { cv.textR(x, y, w, String(m.index + 1), { fg: t.dim, bg }); } },
+        // task-1326: the coin image (2 cells, quadrant art or real pixels). Drops before the numbers when narrow.
+        ...(icon ? [{ key: 'img', label: '', w: COIN_ICON_W, prio: 2, render: (cv, x, y, w, r, bg) => { if (!r.skeleton)
+                    icon(cv, x, y, w, r, bg); } }] : []),
+        { key: 'token', label: 'TOKEN', w: bp === 'compact' ? 12 : 22, prio: 0, flex: bp !== 'compact', render: (cv, x, y, w, r, bg, m) => {
+                const cx = cv.text(x, y, r.symbol, { fg: m.selected ? t.borderFocus : t.text, bg, b: true }, Math.min(10, w));
+                if (w > 14)
+                    cv.text(cx + 1, y, r.name, muted(bg), w - (cx - x) - 1);
+            } },
+        { key: 'lp', label: 'LP', w: 6, prio: 4, render: (cv, x, y, w, r, bg) => { if (r.launchpad === 'unknown')
+                dash(cv, x, y, w, bg, 'left');
+            else
+                launchpadBadge(cv, x, y, r.launchpad, { on: bg }); } },
+        { key: 'age', label: 'AGE', w: 5, align: 'right', prio: 2, render: (cv, x, y, w, r, bg) => { if (r.ageMin === null)
+                dash(cv, x, y, w, bg);
+            else
+                cv.textR(x, y, w, fmtAge(r.ageMin), muted(bg)); } },
+        { key: 'price', label: 'PRICE', w: 11, align: 'right', prio: 0, render: (cv, x, y, w, r, bg) => { if (r.price === null)
+                dash(cv, x, y, w, bg);
+            else
+                cv.textR(x, y, w, fmtPrice(r.price), { fg: t.text, bg }); } },
+        { key: 'm5', label: '5M', w: 7, align: 'right', prio: 2, render: (cv, x, y, w, r, bg) => heatPct(cv, x, y, w, r.chg.m5, bg) },
+        { key: 'h1', label: '1H', w: 7, align: 'right', prio: 1, render: (cv, x, y, w, r, bg) => heatPct(cv, x, y, w, r.chg.h1, bg) },
+        { key: 'h6', label: '6H', w: 7, align: 'right', prio: 6, render: (cv, x, y, w, r, bg) => heatPct(cv, x, y, w, r.chg.h6, bg) },
+        { key: 'h24', label: '24H', w: 8, align: 'right', prio: 0, render: (cv, x, y, w, r, bg) => heatPct(cv, x, y, w, r.chg.h24, bg) },
+        { key: 'vol', label: 'VOL 24H', w: 9, align: 'right', prio: 0, render: (cv, x, y, w, r, bg) => { if (r.vol24 === null)
+                dash(cv, x, y, w, bg);
+            else
+                cv.textR(x, y, w, fmtUsd(r.vol24, { digits: 1 }), { fg: t.text, bg }); } },
+        { key: 'liq', label: 'LIQ', w: 8, align: 'right', prio: 1, render: (cv, x, y, w, r, bg) => { if (r.liq === null)
+                dash(cv, x, y, w, bg);
+            else
+                cv.textR(x, y, w, fmtUsd(r.liq, { digits: 1 }), { fg: r.liq !== null && r.liq < 50e3 ? t.warn : t.text, bg }); } },
+        { key: 'mcap', label: 'MCAP', w: mode === 'mcap' ? 9 : 8, align: 'right', prio: 0, render: (cv, x, y, w, r, bg) => {
+                // task-1366: in mcap mode a token without a supply shows its PRICE here, marked ᵖ in amber (the caption counts them)
+                if (r.mcap === null && mode === 'mcap' && r.price !== null) {
+                    cv.textR(x, y, w, fmtPrice(r.price) + FALLBACK_MARK, { fg: t.warn, bg });
+                    return;
+                }
+                if (r.mcap === null) {
+                    dash(cv, x, y, w, bg);
+                    return;
+                }
+                // sources disagree (D-06 rule): amber with a trailing ? so the plain render carries the doubt too
+                if (r.mcapFlagged)
+                    cv.textR(x, y, w, fmtUsd(r.mcap, { digits: 1 }) + '?', { fg: t.warn, bg });
+                else
+                    cv.textR(x, y, w, fmtUsd(r.mcap, { digits: 1 }), { fg: t.text, bg });
+            } },
+        { key: 'holders', label: 'HOLDERS', w: 8, align: 'right', prio: 2, render: (cv, x, y, w, r, bg) => { if (r.holders === null)
+                dash(cv, x, y, w, bg);
+            else
+                cv.textR(x, y, w, fmtNum(r.holders), { fg: t.text, bg }); } },
+        { key: 'org', label: 'ORG', w: 4, align: 'right', prio: 2, render: (cv, x, y, w, r, bg) => {
+                if (r.org === null) {
+                    dash(cv, x, y, w, bg);
+                    return;
+                }
+                cv.textR(x, y, w, String(Math.round(r.org)), { fg: r.org >= 70 ? t.up : r.org >= 40 ? t.warn : t.down, bg });
+            } },
+        // task-1361: p(rug) from the H1-v0.1 heuristic (screener/rug.ts). A model output: the panel caption names
+        // the model, the spotlight adds the data age. Dim when the row is stale; dashed when nothing is scoreable.
+        { key: 'rug', label: 'P(RUG)', w: 6, align: 'right', prio: 3, render: (cv, x, y, w, r, bg) => {
+                const p = rugP(r);
+                if (p === null) {
+                    dash(cv, x, y, w, bg);
+                    return;
+                }
+                cv.textR(x, y, w, fmtRugP(p), { fg: r.stale ? t.dim : p >= RUG_FLAG_THRESHOLD ? t.down : p >= 0.35 ? t.warn : t.text, bg });
+            } },
+        { key: 'txns', label: 'B/S 24H', w: 10, prio: 5, render: (cv, x, y, w, r, bg) => { if (r.buys === null || r.sells === null)
+                dash(cv, x, y, w, bg, 'left');
+            else
+                ratioBar(cv, x, y, w, r.buys, r.sells, { bg }); } },
+        { key: 'spark', label: '24H TREND', w: 16, prio: 1, render: (cv, x, y, w, r, bg) => sparkline(cv, x, y, w, r.spark, { bg }) },
+        { key: 'flags', label: 'FLAGS', w: 14, prio: 3, render: (cv, x, y, w, r, bg) => {
+                let cx = x;
+                // task-1315: lead with the LARP-detector verdict, but only for a mint we actually vetted.
+                const lb = larpBadge(larp?.get(r.mint)?.verdict, t);
+                if (lb && cx + lb.text.length + 2 <= x + w)
+                    cx = badge(cv, cx, y, lb.text, lb.fg, { on: bg }) + 1;
+                for (const f of r.flags.slice(0, 2)) {
+                    if (cx + f.length + 2 > x + w)
+                        break;
+                    cx = badge(cv, cx, y, f, f === 'MINT' || f === 'FREEZE' ? t.down : t.warn, { on: bg }) + 1;
+                }
+                if (!r.flags.length && !lb) {
+                    // No flags is only "clean" when the audit actually came back; otherwise say so.
+                    if (r.mintAuth === null && r.freezeAuth === null)
+                        cv.text(x, y, '? unaudited', { fg: t.dim, bg });
+                    else
+                        cv.text(x, y, '✓ clean', { fg: mix(bg, t.up, 0.7), bg });
+                }
+            } },
+    ];
+    return promoteMcap(cols, mode); // task-1366: MCAP takes PRICE's slot in mcap mode
+}
+export function renderScreener(c, state) {
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    const sc = state.screener;
+    header(c, headerModel(state));
+    const top = 2, bottom = c.h - 1;
+    // task-1358: the spotlight width comes from the active workspace's solved layout (44 at ≥ 140 cols by default).
+    const sideW = layoutFor(state.custom, c.w, c.h).spotlightW;
+    const tableW = c.w - sideW - (sideW ? 1 : 0);
+    filterBar(c, sc, top, tableW);
+    const rows = screenerView(sc);
+    const sort = sortSpec(sc.sort.key);
+    const total = sc.rows.length;
+    const gated = gateCaption(sc.gates, Object.values(COLUMN_GATE));
+    const mode = priceModeOf(state);
+    const fallback = mode === 'mcap' ? fallbackCaption(fallbackCount(rows, (r) => r)) : null;
+    const sel0 = Math.min(state.selected || 0, Math.max(0, rows.length - 1));
+    // "N of M tokens" when a filter hides some; "M tokens" otherwise. When the feed scanned a wider
+    // candidate pool than it enriched into rows, trail the real pool size (task-1303). Row position
+    // trails so hundreds read at a glance.
+    const shown = rows.length === total ? `${total} tokens` : `${rows.length} of ${total} tokens`;
+    const count = (sc.pool ?? 0) > total ? `${shown} · pool ${sc.pool}` : shown;
+    const pos = rows.length > 0 ? `row ${sel0 + 1}/${rows.length}` : null;
+    // Ordered by priority: the box drops its caption whole when it overflows (canvas.box), so when the
+    // pool size (task-1303) makes the line too long we shed the low-value tail (position, then refresh
+    // age) rather than losing the pool/sort/gate facts. Budget mirrors box()'s title+caption fit test.
+    const segs = [
+        count,
+        `sorted by ${sort?.label ?? sc.sort.key}${sc.sort.dir === 'asc' ? ' asc' : ''}`,
+        gated || null,
+        fallback, // task-1366: rows whose MCAP cell is a price (supply unknown)
+        // task-1361: the P(RUG) column is a model output, so the panel says which model (sheds before the facts above).
+        sc.sort.key === 'rug' ? null : `p(rug) = ${RUG_MODEL_LABEL}`,
+        // The wide pool is still trickling in under the DexScreener budget (task-1303): tell the user the
+        // tail is slowing, not stalled. Ranks above the refresh age / row position so it survives a trim.
+        sc.slowing ? '◔ rate-limited, slowing down' : null,
+        `refreshed ${state.refreshedAgo || '2s'} ago`,
+        pos,
+    ].filter((s) => !!s);
+    const capBudget = tableW - ' SCREENER '.length - 8;
+    let caption = segs.join(' · ');
+    while (caption.length > capBudget && segs.length > 1) {
+        segs.pop();
+        caption = segs.join(' · ');
+    }
+    const box = c.box(0, top + 1, tableW, bottom - top - 1, { title: 'SCREENER', caption });
+    const sel = Math.min(state.selected || 0, Math.max(0, rows.length - 1));
+    const rowsVisible = box.h - 2;
+    const scroll = Math.max(0, Math.min(sel - rowsVisible + 2, rows.length - rowsVisible));
+    // task-1326: a 2-cell coin icon per row when images are on and the frame is not compact (never on fixtures).
+    const icon = imagesOn(state) && bp !== 'compact'
+        ? (cv, x, y, w, r, bg) => { drawCoin(cv, state, { x, y, w, h: 1, url: r.image, symbol: r.symbol, bg, prio: 1, mode: 'quad' }); }
+        : 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,
+    });
+    if (rows.length === 0)
+        emptyState(c, box, sc);
+    if (sideW) {
+        c.rainZone(tableW, top, 1, bottom - top, 1); // the gutter between table and spotlight
+        const row = rows[sel];
+        if (row)
+            spotlight(c, c.w - sideW, top, sideW, bottom - top, row, sc.gates, imagesOn(state) ? (cv, x, y, w, h) => { drawCoin(cv, state, { x, y, w, h, url: row.image, symbol: row.symbol, bg: c.theme.panel, prio: 2 }); } : null, state.now.getTime(), mode);
+        else
+            c.box(c.w - sideW, top, sideW, bottom - top, { title: 'SPOTLIGHT' });
+    }
+    if (sc.mode === 'sort')
+        sortMenu(c, sc, box);
+    const hints = sc.mode === 'filter'
+        ? [['⏎', 'apply'], ['esc', 'cancel'], ['ctrl+u', 'clear']]
+        : sc.mode === 'sort'
+            ? [['j/k', 'move'], ['⏎', 'pick / flip'], ['esc', 'close']]
+            : sc.query
+                ? [['j/k', 'move'], ['⏎', 'open'], ['g', 'go to'], ['/', 'filter'], ['\\', 'clear filter'], ['s', 'sort'], ['w', 'watch'], ['a', 'ask'], ['q', 'quit']]
+                : [['j/k', 'move'], ['PgUp/Dn·G', 'page'], ['[ ]', 'feed'], ['⏎', 'open'], ['g', 'go to'], ['/', 'filter'], ['s', 'sort'], ['w', 'watch'], ['a', 'ask'], ['q', 'quit']];
+    footer(c, hints, state.theme.name, isCalm(state.vfx));
+}
+/** Row 2: the `⌕` query (or the editor) on the left, presets on the right; the gap between them rains. */
+function filterBar(c, sc, fy, tableW) {
+    const t = c.theme;
+    c.fill(0, fy, tableW, 1, ' ', { bg: t.bg });
+    let x = c.text(1, fy, '⌕ ', { fg: t.accent, bg: t.bg, b: true });
+    if (sc.mode === 'filter') {
+        const text = sc.edit.text;
+        x = c.text(x, fy, text, { fg: t.text, bg: t.bg }, Math.max(0, tableW - x - 2));
+        c.put(x, fy, '▏', { fg: t.accent, bg: t.bg, b: true, soft: true });
+        x += 1;
+        const err = sc.edit.error;
+        const msg = err ? `✗ ${err.error}` : text.trim() ? '✓ ⏎ to apply' : 'type a filter · fields: vol24 liq mcap age holders org … · tags: launchpad: flag: chain:';
+        const mx = x + 2;
+        if (mx < tableW - 8)
+            c.text(mx, fy, msg, { fg: err ? t.down : t.dim, bg: t.bg, i: !err }, tableW - mx - 1);
+        return;
+    }
+    if (sc.notice) {
+        x = c.text(x, fy, sc.notice, { fg: t.warn, bg: t.bg, i: true }, tableW - x - 2);
+    }
+    else {
+        x = c.text(x, fy, sc.query || DEFAULT_QUERY, { fg: sc.query ? t.text : t.muted, bg: t.bg, i: !sc.query }, tableW - x - 2);
+    }
+    // presets, right-aligned; disabled ones dim with their caption ('needs key', 'D-08', …). The
+    // task-1303 feed switcher can outgrow a narrow frame, so when the full set won't fit we window
+    // around the active preset — reading forward from it, counting each disabled preset's caption so
+    // the window never hides why a preset is off — and mark the trimmed sides with ‹ / › instead of
+    // dropping the whole bar.
+    const items = sc.presets.map((p) => ({ p, label: ` ${p.label} `, cap: (!p.available || p.approx) && p.caption ? `${p.caption} ` : '' }));
+    const avail = tableW - 2 - (x + 4);
+    const w = (it) => it.label.length + 1 + it.cap.length;
+    if (avail > 6 && items.length) {
+        let lo = 0, hi = items.length;
+        if (items.reduce((s, it) => s + w(it), 0) > avail) {
+            // Something is always hidden here, so budget for the trailing › (1 col); the leading ‹ (2 cols)
+            // only costs once we have actually trimmed the left (lo > 0), so account for it per step.
+            const budget = avail - 1;
+            const ai = Math.max(0, items.findIndex((it) => it.p.id === sc.preset));
+            lo = ai;
+            hi = ai + 1;
+            let used = w(items[ai]);
+            for (;;) {
+                const canR = hi < items.length && used + w(items[hi]) + (lo > 0 ? 2 : 0) <= budget;
+                const canL = lo > 0 && used + w(items[lo - 1]) + (lo - 1 > 0 ? 2 : 0) <= budget;
+                if (!canR && !canL)
+                    break;
+                if (canR)
+                    used += w(items[hi++]);
+                else
+                    used += w(items[--lo]);
+            }
+        }
+        const win = items.slice(lo, hi);
+        const total = win.reduce((s, it) => s + w(it), 0) + (lo > 0 ? 2 : 0) + (hi < items.length ? 1 : 0);
+        let px = tableW - 2 - total;
+        if (px > x + 2) {
+            c.rainZone(x + 1, fy, px - x - 2, 1, 1);
+            if (lo > 0)
+                px = c.text(px, fy, '‹ ', { fg: t.dim, bg: t.bg });
+            for (const it of win) {
+                const active = it.p.id === sc.preset;
+                if (active)
+                    px = c.text(px, fy, it.label, { fg: onAccent(t.borderFocus), bg: t.borderFocus, b: true }) + 1;
+                else if (it.p.available)
+                    px = c.text(px, fy, it.label, { fg: t.muted, bg: t.bg }) + 1;
+                else
+                    px = c.text(px, fy, it.label, { fg: t.dim, bg: t.bg, d: true }) + 1;
+                // An approximation preset is available but still shows its caption ('approx'), so the UI never
+                // implies the keyed signal; a disabled preset shows its reason ('needs key', 'D-08', …).
+                if (it.cap)
+                    px = c.text(px - 1, fy, it.cap, { fg: t.dim, bg: t.bg, i: true }) + 1;
+            }
+            if (hi < items.length)
+                c.text(px, fy, '›', { fg: t.dim, bg: t.bg });
+        }
+    }
+}
+function emptyState(c, box, sc) {
+    const t = c.theme;
+    const y = box.y + Math.min(4, Math.floor(box.h / 2));
+    // task-1305 (M6): when the live feed has no rows, say *why* — connecting / offline / rate-limited —
+    // instead of an indefinite "waiting for the feed". A degraded color flags the two actionable states.
+    let msg;
+    let fg = t.muted;
+    if (sc.rows.length === 0) {
+        if (sc.source === 'fixtures')
+            msg = 'no rows';
+        else {
+            const cond = feedCondition(sc);
+            msg = cond.message;
+            if (cond.kind === 'offline' || cond.kind === 'ratelimited')
+                fg = t.warn;
+        }
+    }
+    else {
+        msg = `no tokens match "${sc.query}" · / to edit, ctrl+u then ⏎ to clear`;
+    }
+    // Keep the message legible: rain must not write into the spaces inside it (task-1305, QA M7).
+    c.noRain(box.x, y, box.w, 1);
+    c.textC(box.x, y, box.w, msg, { fg, bg: box.bg, i: true });
+}
+/** The `s` sort menu: a small centered list over the table. */
+function sortMenu(c, sc, over) {
+    const t = c.theme;
+    const w = 30, h = SORT_KEYS.length + 2;
+    const x = over.x + Math.max(0, Math.floor((over.w - w) / 2));
+    const y = over.y + Math.max(0, Math.floor((over.h - h) / 2));
+    const box = c.box(x, y, w, h, { title: 'SORT BY', caption: '⏎ pick · again flips', focus: true, bg: t.panelAlt });
+    c.noRain(x, y, w, h);
+    SORT_KEYS.forEach((k, i) => {
+        const cur = k.key === sc.sort.key;
+        const hot = i === sc.sortCursor;
+        const bg = hot ? t.selBg : box.bg;
+        c.fill(box.x, box.y + i, box.w, 1, ' ', { bg });
+        c.text(box.x + 1, box.y + i, hot ? '▸' : ' ', { fg: t.accent, bg });
+        c.text(box.x + 3, box.y + i, k.label, { fg: cur ? t.accent : t.text, bg, b: cur });
+        const dir = cur ? (sc.sort.dir === 'desc' ? '▼' : '▲') : (k.defaultDir === 'desc' ? '▽' : '△');
+        c.textR(box.x + 1, box.y + i, box.w - 2, dir, { fg: cur ? t.accent : t.dim, bg });
+    });
+}
+/** Right-hand spotlight card for the selected row (wide layouts only). */
+export function spotlight(c, x, y, w, h, tk, gates = null, hero = null, now = null, mode = 'price') {
+    const t = c.theme;
+    const off = (id) => !!gates && gates[id]?.available === false;
+    const gateWord = (id) => (gates?.[id]?.state === 'needs-key' ? 'needs key' : gates?.[id]?.state === 'disabled' ? 'off' : 'degraded');
+    const box = c.box(x, y, w, h, { title: `$${tk.symbol}`, caption: shortAddr(tk.mint, 5), focus: true });
+    const bg = box.bg;
+    let cy = box.y;
+    // task-1326: a 6×3 coin image in the card's top-right corner (name / price / gap rows); text keeps clear of it.
+    const heroW = hero ? 6 : 0;
+    c.text(box.x + 1, cy, tk.name, { fg: t.muted, bg }, box.w - 2 - (heroW ? heroW + 1 : 0));
+    cy += 1;
+    // task-1366: the headline number follows the price mode (mcap first, the price beside it; a price + note without a supply)
+    const head = priceCell(mode, tk.price, tk.mcap);
+    let cx = c.text(box.x + 1, cy, head.text, { fg: head.fallback ? t.warn : t.text, bg, b: true });
+    if (head.kind === 'mcap' && tk.price !== null)
+        cx = c.text(cx + 1, cy, `(${fmtPrice(tk.price)})`, { fg: t.dim, bg });
+    cx = c.text(cx + 1, cy, fmtPctDir(tk.chg.h24), pctStyle(c, tk.chg.h24, bg));
+    c.text(cx + 1, cy, '24h', { fg: t.dim, bg });
+    if (head.fallback)
+        c.text(box.x + 1, cy + 1, MCAP_FALLBACK_NOTE, { fg: t.warn, bg, i: true }, box.w - 2 - (heroW ? heroW + 1 : 0));
+    if (tk.launchpad !== 'unknown')
+        launchpadBadge(c, box.x + box.w - 8 - (heroW ? heroW + 1 : 0), cy, tk.launchpad, { on: bg });
+    if (hero)
+        hero(c, box.x + box.w - 1 - heroW, box.y, heroW, 3);
+    cy += 2;
+    sparkArea(c, box.x + 1, cy, box.w - 2, 4, tk.spark, { bg });
+    cy += 5;
+    const holdersOff = off('holders');
+    const orgOff = off('org');
+    const holdersSub = tk.holders24 !== null ? fmtDeltaDir(tk.holders24)
+        : tk.holdersChgPct !== null ? fmtPctDir(tk.holdersChgPct) + ' 24h' : undefined;
+    cy += statGrid(c, box.x + 1, cy, box.w - 2, [
+        tk.mcapFlagged
+            ? { label: 'mcap', value: fmtUsd(tk.mcap, { digits: 1 }) + '?', sub: 'sources differ', style: { fg: t.warn, bg, b: true } }
+            : { label: 'mcap', value: fmtUsd(tk.mcap, { digits: 1 }) },
+        { label: 'liquidity', value: fmtUsd(tk.liq, { digits: 1 }) },
+        { label: 'vol 24h', value: fmtUsd(tk.vol24, { digits: 1 }) },
+        holdersOff
+            ? { label: 'holders', value: '—', sub: gateWord('holders'), style: { fg: t.dim, bg } }
+            : { label: 'holders', value: fmtNum(tk.holders), sub: tk.holders === null ? undefined : holdersSub, style: tk.holders === null ? { fg: t.dim, bg } : undefined },
+        orgOff || tk.org === null
+            ? { label: 'organic', value: '—', sub: orgOff ? gateWord('org') : undefined, style: { fg: t.dim, bg } }
+            : { label: 'organic', value: `${Math.round(tk.org)}/100`, style: { fg: tk.org >= 70 ? t.up : tk.org >= 40 ? t.warn : t.down, b: true } },
+        tk.top10 === null
+            ? { label: 'top 10', value: '—', sub: holdersOff ? gateWord('holders') : 'no audit', style: { fg: t.dim, bg } }
+            : { label: 'top 10', value: `${tk.top10.toFixed(1)}%`, style: { fg: tk.top10 > 30 ? t.warn : t.text, b: true } },
+    ], { bg, cols: 2 });
+    cy += 1;
+    c.text(box.x + 1, cy, 'BUYS / SELLS 24H', { fg: t.dim, bg });
+    cy += 1;
+    if (tk.buys !== null && tk.sells !== null && !off('bs')) {
+        ratioBar(c, box.x + 1, cy, box.w - 2, tk.buys, tk.sells, { bg });
+        cy += 1;
+        c.text(box.x + 1, cy, '▲' + fmtNum(tk.buys), { fg: t.up, bg });
+        c.textR(box.x + 1, cy, box.w - 2, '▼' + fmtNum(tk.sells), { fg: t.down, bg });
+    }
+    else {
+        c.text(box.x + 1, cy, '—', { fg: t.dim, bg });
+        cy += 1;
+        c.text(box.x + 1, cy, off('bs') ? gateWord('bs') : 'no txn counts', { fg: t.dim, bg });
+    }
+    cy += 2;
+    c.text(box.x + 1, cy, 'SAFETY', { fg: t.dim, bg });
+    cy += 1;
+    // null = the keyless sources did not say: shown as an open circle, never as a pass or a fail
+    const checks = [
+        ['mint authority', tk.mintAuth === null ? null : !tk.mintAuth],
+        ['freeze authority', tk.freezeAuth === null ? null : !tk.freezeAuth],
+        [tk.lpLocked === null ? 'LP locked' : `LP locked ${Math.round(tk.lpLocked)}%`, tk.lpLocked === null ? null : tk.lpLocked >= 90],
+        [tk.dev === null ? 'dev holds' : `dev holds ${tk.dev.toFixed(2)}%`, tk.dev === null ? null : tk.dev < 3],
+        [tk.bundled === null ? 'bundled' : `bundled ${tk.bundled.toFixed(0)}%`, tk.bundled === null ? null : tk.bundled < 10],
+        [tk.snipers === null ? 'snipers' : `snipers ${tk.snipers}`, tk.snipers === null ? null : tk.snipers < 5],
+    ];
+    for (const [label, ok] of checks) {
+        if (cy >= box.y + box.h - 5)
+            break;
+        if (ok === null) {
+            c.text(box.x + 1, cy, '○', { fg: t.dim, bg });
+            const lx = c.text(box.x + 3, cy, label, { fg: t.dim, bg }, box.w - 4);
+            c.text(lx + 1, cy, 'needs key', { fg: t.dim, bg, i: true }, Math.max(0, box.x + box.w - 1 - (lx + 1)));
+        }
+        else {
+            c.text(box.x + 1, cy, ok ? '✓' : '✗', { fg: ok ? t.up : t.down, bg, b: true });
+            c.text(box.x + 3, cy, label, { fg: ok ? t.text : t.warn, bg }, box.w - 4);
+        }
+        cy += 1;
+    }
+    // task-1361: p(rug) is a MODEL OUTPUT, so the card says so: value, model id + kind, and how old the scored data is.
+    const ay = box.y + box.h - 3;
+    if (cy < ay - 3) {
+        const p = rugP(tk);
+        const age = now === null ? null : rugDataAge(tk, now);
+        if (p === null) {
+            c.text(box.x + 1, cy, '○', { fg: t.dim, bg });
+            c.text(box.x + 3, cy, `p(rug) — · ${RUG_MODEL_LABEL}`, { fg: t.dim, bg }, box.w - 4);
+            c.text(box.x + 3, cy + 1, 'model output · no data to score', { fg: t.dim, bg, i: true }, box.w - 4);
+        }
+        else {
+            const risky = p >= RUG_FLAG_THRESHOLD;
+            c.text(box.x + 1, cy, risky ? '✗' : p >= 0.35 ? '△' : '✓', { fg: risky ? t.down : p >= 0.35 ? t.warn : t.up, bg, b: true });
+            const vx = c.text(box.x + 3, cy, `p(rug) ${fmtRugP(p)}`, { fg: risky ? t.down : p >= 0.35 ? t.warn : t.text, bg, b: true });
+            c.text(vx + 1, cy, `· ${RUG_MODEL_LABEL}`, { fg: t.dim, bg, i: true }, Math.max(0, box.x + box.w - 1 - (vx + 1)));
+            c.text(box.x + 3, cy + 1, `model output · data ${age ? `${age} old` : 'age unknown'}`, { fg: t.dim, bg, i: true }, box.w - 4);
+        }
+        cy += 2;
+    }
+    // the blank middle of the card is a quiet rain zone
+    if (ay - 2 > cy)
+        c.rainZone(box.x + 1, cy + 1, box.w - 2, ay - 2 - cy, 2);
+    // AI one-liner (coral is the analyst's voice: title and verdict, VISUAL-V2 §2)
+    c.hline(box.x, ay - 1, box.w, { fg: mix(t.border, t.ai, 0.4), bg, soft: true });
+    c.text(box.x + 1, ay, '✦ claude', { fg: t.ai, bg, b: true });
+    c.heading(box.x + 1, ay, 8);
+    if (tk.aiNote)
+        c.text(box.x + 1, ay + 1, tk.aiNote, { fg: t.ai, bg }, box.w - 2);
+    else
+        c.text(box.x + 1, ay + 1, 'press a for a claude analysis', { fg: t.dim, bg, i: true }, box.w - 2);
+    c.textR(box.x + 1, ay, box.w - 2, 'a → full analysis', { fg: t.dim, bg });
+}