dexterm-cli 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,33 @@
+// dexterm — coin images on the screens (task-1326): the thin glue between a screen's cell box and the
+// ImageService + the TUI's coinImage(). Everything here is synchronous: the service answers from memory
+// (and queues what it does not have), the TUI draws pixels-slot / block art / placeholder accordingly.
+import { coinImage } from '../../../tui/src/index.js';
+/**
+ * True when this run shows coin images at all: live/replay with the service on. Never on fixtures — fixture rows
+ * carry no image URL, so the column would only ever paint placeholder initials, and the fixture frames (goldens,
+ * `--fixtures` one-shots) must stay byte for byte what they were before images existed.
+ */
+export function imagesOn(state) { return !!state.images && state.screener.source !== 'fixtures'; }
+/** Draw a coin image box (or its placeholder) if images are on; returns true when something was drawn. */
+export function drawCoin(c, state, b) {
+    const svc = state.images;
+    if (!svc || b.w <= 0 || b.h <= 0)
+        return false;
+    const st = svc.get(b.url ?? null, b.prio ?? 1);
+    const ready = st.state === 'ready';
+    coinImage(c, {
+        x: b.x, y: b.y, w: b.w, h: b.h, symbol: b.symbol,
+        img: ready ? st.img : null, png: ready ? st.png : null, key: ready ? st.key : null,
+        pending: st.state === 'pending',
+        depth: state.colorDepth, bg: b.bg, mode: b.mode ?? state.imageBlocks ?? 'half',
+    });
+    return true;
+}
+/** The popup's same-origin image path for a coin, when the thumbnail is already cached. */
+export function popupImagePath(state, url) {
+    const svc = state.images;
+    if (!svc || !url)
+        return null;
+    const st = svc.get(url, 2);
+    return st.state === 'ready' ? `/img/${st.key}.png` : null;
+}

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

@@ -0,0 +1,201 @@
+// dexterm — FOLLOWED WALLETS screen (key U, task-1360 copy trading Tier 1). The user's own follow list with each
+// wallet's decoded activity (trades, FIFO realised PnL in SOL with a USD view at today's rate, win rate with its n,
+// early-entry score when a launch window was scanned, open positions) and the live ALERTS tape (a followed
+// wallet's buys and sells as the tracker saw them, with the lag). Every figure prints its sample. Labels are the
+// user's own words, never inferred. Nothing on this screen trades, signs or proposes: Tier 2 adds the one-key
+// mirror PROPOSAL and Tier 3 the capped auto-mirror, both behind the plan engine's own keypress gates.
+import { Canvas, header, footer, breakpoint, fmtAgeSec } from '../../../tui/src/index.js';
+import { headerModel } from "../state.js";
+import { shortAddr, autoSizeCap } from '../../../data/src/trade/copy/index.js';
+function fmtSol(n) { const s = n >= 0 ? '+' : '−'; return `${s}${Math.abs(n).toFixed(Math.abs(n) >= 10 ? 1 : 3)} SOL`; }
+function fmtUsdSigned(n) { const s = n >= 0 ? '+' : '−'; const a = Math.abs(n); return `${s}$${a >= 1000 ? (a / 1000).toFixed(1) + 'k' : a.toFixed(a >= 100 ? 0 : 2)}`; }
+function fmtUsdAbs(n) { if (n === null)
+    return '—'; return n >= 1000 ? `$${(n / 1000).toFixed(1)}k` : `$${n.toFixed(n >= 100 ? 0 : 2)}`; }
+export const FOLLOW_INPUT_MAX = 80;
+export function renderFollows(c, state) {
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    header(c, headerModel(state));
+    const ui = state.copyUi ?? null;
+    const svc = state.copy ?? null;
+    const follows = svc ? svc.follows() : [];
+    const status = svc ? svc.status() : null;
+    const now = state.now.getTime();
+    const top = 2, bottom = c.h - 1;
+    const stLabel = !status ? 'no binding' : status.state === 'ok' ? `polling · ${status.polls} polls` : status.state === 'idle' ? 'idle' : status.state.toUpperCase();
+    const title = `FOLLOWED WALLETS · ${follows.length} · ${stLabel} · ${status?.alerts ?? 0} alerts`;
+    const caption = bp === 'compact' ? undefined : 'your own list, your own wallet · labels are yours, never inferred · PnL = FIFO over fetched history · not a recommendation';
+    const alertsH = Math.max(5, Math.min(12, Math.floor((bottom - top) / 3)));
+    const typing = ui?.input !== null && ui?.input !== undefined;
+    const listH = bottom - top - alertsH;
+    const box = c.box(0, top, c.w, listH, { title, caption, focus: !typing });
+    const bg = box.bg;
+    let cy = box.y;
+    if (status && status.state !== 'ok' && status.state !== 'idle' && status.why) {
+        c.text(box.x + 1, cy, `⚠ ${status.why}`, { fg: status.state === 'unavailable' ? t.warn : t.down, bg }, box.w - 2);
+        cy += 1;
+    }
+    if (!follows.length) {
+        c.text(box.x + 1, cy + 1, 'no wallets followed yet.', { fg: t.muted, bg });
+        cy += 3;
+        c.text(box.x + 1, cy, 'i                                     type a wallet address (and an optional label) to follow it', { fg: t.dim, bg });
+        cy += 1;
+        c.text(box.x + 1, cy, 'dexterm follow add <addr> --name x    the same from a shell · follow list | stats <addr> | purge', { fg: t.dim, bg });
+        cy += 1;
+        c.text(box.x + 1, cy, 'alerts on its buys/sells appear as toasts anywhere · the tracker polls Helius history (free key)', { fg: t.dim, bg });
+        cy += 2;
+        c.text(box.x + 1, cy, 'self-directed only: you pick the wallet, your caps, your keys · no pooled copy, no leader lists, no fees', { fg: t.dim, bg, i: true });
+    }
+    else {
+        const wide = bp !== 'compact';
+        const cols = wide ? ['WALLET', 'LABEL', 'AUTO', 'TRADES', 'REALISED', 'WIN RATE', 'EES', 'OPEN', 'LAST', 'SAMPLE'] : ['WALLET', 'LABEL', 'AUTO', 'TRADES', 'REALISED', 'WIN', 'LAST'];
+        const xs = wide ? [1, 13, 26, 34, 43, 62, 76, 83, 89, 97] : [1, 13, 24, 30, 38, 52, 60];
+        const autoOf = (addr) => svc?.auto?.policy(addr) ?? null;
+        cols.forEach((h, i) => c.text(box.x + xs[i], cy, h, { fg: t.dim, bg }));
+        cy += 1;
+        const sel = Math.max(0, Math.min(follows.length - 1, ui?.selected ?? 0));
+        const scroll = Math.max(0, sel - (box.h - 4));
+        for (let i = scroll; i < follows.length; i++) {
+            if (cy >= box.y + box.h - 1)
+                break;
+            const f = follows[i];
+            const s = svc ? svc.stats(f.addr) : null;
+            const selected = i === sel;
+            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, shortAddr(f.addr), { fg: selected ? t.borderFocus : t.text, bg: rb });
+            c.text(box.x + xs[1], cy, f.name ?? '—', { fg: f.name ? t.accent : t.dim, bg: rb }, xs[2] - xs[1] - 1);
+            const ap = autoOf(f.addr);
+            c.text(box.x + xs[2], cy, ap?.enabled ? 'ON' : 'off', { fg: ap?.enabled ? t.warn : t.dim, bg: rb, b: !!ap?.enabled });
+            const err = svc?.tracker.walletError(f.addr) ?? null;
+            if (!s || (s.trades === 0 && !err)) {
+                c.text(box.x + xs[3], cy, status?.state === 'unavailable' ? 'needs a free Helius key' : status?.polls ? 'no swaps in fetched history' : 'loading…', { fg: t.dim, bg: rb, i: true });
+                cy += 1;
+                continue;
+            }
+            if (err) {
+                c.text(box.x + xs[3], cy, `poll failed: ${err}`, { fg: t.down, bg: rb }, box.w - xs[3] - 2);
+                cy += 1;
+                continue;
+            }
+            c.text(box.x + xs[3], cy, `${s.buys}b/${s.sells}s`, { fg: t.text, bg: rb });
+            const pnlFg = s.realisedSol > 0 ? t.up : s.realisedSol < 0 ? t.down : t.muted;
+            c.text(box.x + xs[4], cy, `${fmtSol(s.realisedSol)}${s.realisedUsd !== null ? ` ${fmtUsdSigned(s.realisedUsd)}` : ''}`, { fg: pnlFg, bg: rb }, xs[5] - xs[4] - 1);
+            const wr = s.winRate === null ? `n<10 (${s.wins}/${s.closed})` : `${Math.round(s.winRate * 100)}% (${s.wins}/${s.closed})`;
+            c.text(box.x + xs[5], cy, wr, { fg: s.winRate === null ? t.dim : t.text, bg: rb }, (xs[6] ?? box.w) - xs[5] - 1);
+            if (wide) {
+                c.text(box.x + xs[6], cy, s.earlyEntry.score === null ? '—' : s.earlyEntry.score.toFixed(2), { fg: s.earlyEntry.score === null ? t.dim : t.text, bg: rb });
+                c.text(box.x + xs[7], cy, String(s.open), { fg: t.text, bg: rb });
+                c.text(box.x + xs[8], cy, s.lastT ? fmtAgeSec(Math.max(0, Math.round((now - s.lastT) / 1000))) : '—', { fg: t.muted, bg: rb });
+                c.text(box.x + xs[9], cy, s.sample.note, { fg: t.dim, bg: rb }, box.w - xs[9] - 1);
+            }
+            else {
+                c.text(box.x + xs[6], cy, s.lastT ? fmtAgeSec(Math.max(0, Math.round((now - s.lastT) / 1000))) : '—', { fg: t.muted, 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 });
+    // ALERTS tape
+    const abox = c.box(0, top + listH, c.w, alertsH, { title: `ALERTS · a followed wallet bought or sold · ${status ? `${status.alerts} seen` : ''}`, caption: bp === 'compact' ? undefined : 'information only · lag = seen − block time · USD at the SOL price when seen', focus: false });
+    const abg = abox.bg;
+    const alerts = svc ? svc.alerts(alertsH - 1) : [];
+    if (!alerts.length)
+        c.text(abox.x + 1, abox.y, status?.state === 'ok' ? 'nothing new since the first look (history is not news)' : 'no alerts yet', { fg: t.dim, bg: abg, i: true });
+    let ay = abox.y;
+    for (const a of alerts) {
+        if (ay >= abox.y + abox.h - (typing ? 1 : 0))
+            break;
+        const tr = a.trade;
+        const sideFg = tr.side === 'buy' ? t.up : t.down;
+        let cx = c.text(abox.x + 1, ay, fmtAgeSec(Math.max(0, Math.round((now - a.t) / 1000))).padEnd(5), { fg: t.dim, bg: abg });
+        cx = c.text(cx + 1, ay, (a.name ?? shortAddr(a.wallet)).padEnd(12).slice(0, 12), { fg: t.accent, bg: abg });
+        cx = c.text(cx + 1, ay, tr.side.toUpperCase().padEnd(4), { fg: sideFg, bg: abg, b: true });
+        cx = c.text(cx + 1, ay, shortAddr(tr.mint), { fg: t.text, bg: abg });
+        cx = c.text(cx + 1, ay, fmtUsdAbs(tr.usd).padStart(7), { fg: t.text, bg: abg });
+        cx = c.text(cx + 1, ay, tr.solDelta !== null ? `${Math.abs(tr.solDelta).toFixed(3)} SOL` : 'unpriced', { fg: t.muted, bg: abg });
+        c.text(cx + 1, ay, a.lagMs === null ? 'lag ?' : `lag ${(a.lagMs / 1000).toFixed(0)}s`, { fg: a.lagMs !== null && a.lagMs > 30_000 ? t.warn : t.dim, bg: abg });
+        ay += 1;
+    }
+    if (typing) {
+        const iy = abox.y + abox.h - 1;
+        c.hline(abox.x, iy - 1, abox.w, { fg: t.border, bg: abg });
+        const label = 'follow: ';
+        c.text(abox.x + 1, iy, label, { fg: t.accent, bg: abg, b: true });
+        c.text(abox.x + 1 + label.length, iy, `${ui.input}█`, { fg: t.text, bg: abg }, abox.w - label.length - 3);
+        c.textR(abox.x + 1, iy, abox.w - 2, '<address> [label] ⏎ · esc cancel', { fg: t.dim, bg: abg });
+    }
+    // Tier 2: the MIRROR TICKET preview (proposal only — nothing here arms; the O screen's keypress gate does).
+    if (ui?.mirror) {
+        const mr = ui.mirror;
+        const mw = Math.min(c.w - 4, 96), mh = 15;
+        const mx = Math.floor((c.w - mw) / 2), my = top + Math.max(1, Math.floor((bottom - top - mh) / 2));
+        c.noRain(mx, my, mw, mh);
+        const mbox = c.box(mx, my, mw, mh, { title: 'MIRROR TICKET — proposal only', caption: 'sized by YOUR cap · armed only on the O screen by keypress / Phantom · not a recommendation', focus: true, bg: t.panelAlt });
+        const mbg = mbox.bg;
+        const tr = mr.alert.trade;
+        let y = mbox.y;
+        c.text(mbox.x + 1, y, `${mr.alert.name ?? shortAddr(mr.alert.wallet)} BOUGHT ${mr.market?.symbol ?? shortAddr(tr.mint)} (${shortAddr(tr.mint)}) for ${fmtUsdAbs(tr.usd)}${tr.solDelta !== null ? ` · ${Math.abs(tr.solDelta).toFixed(3)} SOL` : ''}`, { fg: t.text, bg: mbg, b: true }, mbox.w - 2);
+        y += 2;
+        if (mr.pending || !mr.result) {
+            c.text(mbox.x + 1, y, 'resolving price, liquidity, decimals and age…', { fg: t.muted, bg: mbg, i: true });
+        }
+        else {
+            for (const ck of mr.result.checks) {
+                const mark = ck.ok === true ? '✓' : ck.ok === false ? '✗' : '?';
+                const fg = ck.ok === true ? t.up : ck.ok === false ? t.down : t.warn;
+                let cx = c.text(mbox.x + 1, y, mark, { fg, bg: mbg, b: true });
+                cx = c.text(cx + 1, y, ck.name.padEnd(12), { fg: t.text, bg: mbg });
+                c.text(cx + 1, y, ck.detail, { fg: ck.ok === null ? t.warn : t.muted, bg: mbg }, mbox.w - (cx + 1 - mbox.x) - 1);
+                y += 1;
+            }
+            y += 1;
+            if (mr.result.ok) {
+                c.text(mbox.x + 1, y, `size ${fmtUsdAbs(mr.result.sizeUsd)} = ${mr.result.sizeWhy}`, { fg: t.accent, bg: mbg, b: true }, mbox.w - 2);
+                y += 1;
+                c.text(mbox.x + 1, y, 'buy now · no ladder · 3% slippage · expires in 10 min · the mandate\'s per-trade cap applies at arming', { fg: t.muted, bg: mbg }, mbox.w - 2);
+                y += 1;
+                c.text(mbox.x + 1, y, 'm again = PROPOSE (inert order plan on the O screen) · esc = close', { fg: t.accent, bg: mbg }, mbox.w - 2);
+            }
+            else {
+                c.text(mbox.x + 1, y, `REFUSED: ${mr.result.message}`, { fg: t.down, bg: mbg, b: true }, mbox.w - 2);
+                y += 1;
+                c.text(mbox.x + 1, y, 'm or esc = close · nothing was proposed', { fg: t.muted, bg: mbg }, mbox.w - 2);
+            }
+        }
+    }
+    // Tier 3: the AUTO-MIRROR modal (enable = captured physical keypress in the loop; this only paints it).
+    if (ui?.autoModal) {
+        const w = ui.autoModal.wallet;
+        const pol = svc?.auto?.policy(w) ?? null;
+        const st = svc?.auto?.status(w) ?? null;
+        const mw = Math.min(c.w - 4, 92), mh = 14;
+        const mx = Math.floor((c.w - mw) / 2), my = top + Math.max(1, Math.floor((bottom - top - mh) / 2));
+        c.noRain(mx, my, mw, mh);
+        const mbox = c.box(mx, my, mw, mh, { title: '⚠ AUTO-MIRROR — capped, default OFF, less safe', caption: 'your wallet, your caps, your keys · paper/devnet only · not a recommendation', focus: true, bg: t.panelAlt });
+        const mbg = mbox.bg;
+        let y = mbox.y;
+        const name = follows.find((f) => f.addr === w)?.name ?? null;
+        c.text(mbox.x + 1, y, `Mirror every BUY by ${name ?? shortAddr(w)} (${shortAddr(w)}) automatically?`, { fg: t.text, bg: mbg, b: true }, mbox.w - 2);
+        y += 2;
+        if (pol) {
+            c.text(mbox.x + 1, y, `per mirror ≤ $${autoSizeCap(pol).toFixed(2)} (¼ of the $${Math.min(pol.perTradeUsd, pol.dailyUsd)} per-trade cap: auto fires at the hands-free tier) · $${pol.dailyUsd}/day · max ${pol.maxOpen} open · ${Math.round(pol.cooldownMs / 1000)} s cooldown`, { fg: t.muted, bg: mbg }, mbox.w - 2);
+            y += 1;
+            c.text(mbox.x + 1, y, `size factor ${pol.k}× the leader · auto-disarm after ${pol.autoDisarmStreak} refused/failed mirrors · caps expire in ${Math.round(pol.ttlMs / 3600_000)} h · change caps: dexterm follow auto <addr> …`, { fg: t.muted, bg: mbg }, mbox.w - 2);
+            y += 2;
+        }
+        c.text(mbox.x + 1, y, 'every mirror still passes the lag / drift / liquidity / age / leader checks, and the plan engine re-checks every cap signer-side', { fg: t.muted, bg: mbg }, mbox.w - 2);
+        y += 1;
+        c.text(mbox.x + 1, y, 'mirror-SELL is not built: you close every mirror yourself · auto is OFF again after every restart', { fg: t.warn, bg: mbg }, mbox.w - 2);
+        y += 2;
+        const gateOk = st?.gateActive ?? false;
+        c.text(mbox.x + 1, y, gateOk ? '✓ the "less safe" hands-free popup is accepted (O screen, G)' : '✗ needs the "less safe" hands-free popup first: O screen, then G (keypress only, expires in 24 h)', { fg: gateOk ? t.up : t.down, bg: mbg }, mbox.w - 2);
+        y += 2;
+        c.text(mbox.x + 1, y, gateOk ? 'Hold and release [enter] or [y] to turn auto ON (physical keypress) · [esc] leaves it OFF · a pipe/agent cannot' : '[esc] closes · accept the popup, then A again', { fg: t.accent, bg: mbg }, mbox.w - 2);
+    }
+    const autoHint = (() => { const f = follows[Math.max(0, Math.min(follows.length - 1, ui?.selected ?? 0))]; const p = f ? svc?.auto?.policy(f.addr) : null; return p?.enabled ? 'auto OFF' : 'auto-mirror'; })();
+    footer(c, [['↑↓', 'move'], ['i', 'follow a wallet'], ['d', 'unfollow'], ['m', ui?.mirror ? (ui.mirror.result?.ok ? 'PROPOSE mirror' : 'close') : 'mirror ticket'], ['A', autoHint], ['r', 'poll now'], ['esc', 'back'], ['q', 'quit']], t.name);
+}

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

@@ -0,0 +1,90 @@
+// dexterm — KOL LISTS screen (key K, task-1330; INTEGRATIONS-DESIGN §5.4). Own lists, manual handles and
+// signed packs: list, enable/disable per list (space), mute/unmute a handle (m), remove a handle from a manual
+// list (d), add a handle by typing (i … ⏎). Packs are read-only here (`dexterm kol import <dir>`). Credibility
+// is never shown as a property of a list: a pack grants membership, the user's own observations grant trust.
+import { Canvas, header, footer, badge, breakpoint } from '../../../tui/src/index.js';
+import { headerModel } from "../state.js";
+import { kolOf, kolRows } from "../social/view.js";
+export function renderKol(c, state) {
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    header(c, headerModel(state));
+    const kol = kolOf(state);
+    const top = 2, bottom = c.h - 1;
+    const rows = kol ? kolRows(kol) : [];
+    const sel = Math.max(0, Math.min(rows.length - 1, state.kolSelected ?? 0));
+    const title = `KOL LISTS · ${kol ? kol.summary() : 'unavailable'}`;
+    const box = c.box(0, top, c.w, bottom - top, { title, caption: bp === 'compact' ? undefined : 'packs carry handles, never posts · a list grants membership, never credibility', focus: true });
+    const bg = box.bg;
+    let cy = box.y;
+    if (!kol) {
+        c.textC(box.x, cy + 1, box.w, 'KOL lists need live, replay or fixture mode', { fg: t.muted, bg, i: true });
+        footer(c, [['esc', 'back'], ['q', 'quit']], t.name);
+        return;
+    }
+    if (rows.length === 0) {
+        c.text(box.x + 1, cy, 'no KOL lists yet.', { fg: t.muted, bg });
+        cy += 2;
+        c.text(box.x + 1, cy, 'dexterm kol create <name>            make a manual list', { fg: t.dim, bg });
+        cy += 1;
+        c.text(box.x + 1, cy, 'dexterm kol add <list> @handle        add a handle (or press i here once a list exists)', { fg: t.dim, bg });
+        cy += 1;
+        c.text(box.x + 1, cy, 'dexterm kol import <dir>              import a hash-locked pack (pack.json + pack.lock[.sig])', { fg: t.dim, bg });
+        cy += 1;
+        c.text(box.x + 1, cy, 'X (here) or dexterm kol import-x      import your OWN X lists after `dexterm x login` (handles only, never posts)', { fg: t.dim, bg });
+        cy += 1;
+    }
+    const scroll = Math.max(0, sel - (box.h - 3));
+    const typing = state.kolInput !== null && state.kolInput !== undefined;
+    for (let i = scroll; i < rows.length; i++) {
+        if (cy >= box.y + box.h - (typing ? 2 : 0))
+            break;
+        const r = rows[i];
+        const selected = i === sel;
+        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 });
+        if (r.kind === 'list') {
+            const l = r.list;
+            let cx = c.text(box.x + 1, cy, l.enabled ? '◉' : '◌', { fg: l.enabled ? t.up : t.dim, bg: rb, b: true });
+            cx = c.text(cx + 1, cy, l.name, { fg: selected ? t.borderFocus : t.text, bg: rb, b: true }, 32);
+            cx = badge(c, cx + 1, cy, l.source === 'pack' ? 'PACK' : l.source === 'own-x-list' ? 'X LIST' : 'MANUAL', l.source === 'pack' ? t.accent : t.muted, { on: rb }) + 1;
+            cx = badge(c, cx, cy, l.tier === 'kol-a' ? 'KOL·A' : 'KOL·B', t.muted, { on: rb }) + 1;
+            if (l.signed)
+                cx = badge(c, cx, cy, l.signed.verified ? 'SIGNED ✓' : 'UNSIGNED', l.signed.verified ? t.up : t.warn, { on: rb }) + 1;
+            const tail = `${l.handles.length} handle${l.handles.length === 1 ? '' : 's'}${l.wallets.length ? ` · ${l.wallets.length} wallets` : ''}${l.signed ? ` · publisher ${l.signed.publisher} · ${l.signed.hash.slice(0, 8)}` : ''}${l.enabled ? '' : ' · OFF for trending'}`;
+            c.textR(box.x + 1, cy, box.w - 2, tail, { fg: t.dim, bg: rb });
+        }
+        else if (r.kind === 'empty') {
+            c.text(box.x + 4, cy, 'empty · press i to add a handle', { fg: t.dim, bg: rb, i: true });
+        }
+        else {
+            const muted = kol.isMuted(r.handle);
+            let cx = c.text(box.x + 4, cy, `@${r.handle}`, { fg: muted ? t.dim : selected ? t.borderFocus : t.text, bg: rb, d: muted });
+            if (muted)
+                cx = badge(c, cx + 1, cy, 'MUTED', t.warn, { on: rb }) + 1;
+            if (r.list.source === 'pack' && r.list.handles.indexOf(r.handle) === 11 && r.list.handles.length > 12)
+                c.textR(box.x + 1, cy, box.w - 2, `… ${r.list.handles.length - 12} more in the pack`, { fg: t.dim, bg: rb, i: true });
+        }
+        cy += 1;
+    }
+    if (typing) {
+        const iy = box.y + box.h - 1;
+        const list = rows[sel]?.list;
+        c.hline(box.x, iy - 1, box.w, { fg: t.border, bg });
+        c.text(box.x + 1, iy, `add to ${list?.name ?? '?'}: @`, { fg: t.accent, bg, b: true });
+        const px = box.x + 1 + `add to ${list?.name ?? '?'}: @`.length;
+        c.text(px, iy, `${state.kolInput}█`, { fg: t.text, bg }, box.w - (px - box.x) - 2);
+        c.textR(box.x + 1, iy, box.w - 2, '⏎ add · esc cancel', { fg: t.dim, bg });
+    }
+    else if (cy + 1 < box.y + box.h)
+        c.rainZone(box.x + 1, cy + 1, box.w - 2, box.y + box.h - cy - 1, 2);
+    if (state.kolNotice && !typing) {
+        c.textR(box.x + 1, box.y + box.h - 1, box.w - 2, state.kolNotice, { fg: t.warn, bg, i: true });
+    }
+    else if (state.kolImporting && !typing) {
+        c.textR(box.x + 1, box.y + box.h - 1, box.w - 2, 'importing your X lists… (owned_lists + members; handles only)', { fg: t.accent, bg, i: true });
+    }
+    footer(c, [['j/k', 'move'], ['space', 'enable/disable'], ['m', 'mute'], ['d', 'remove'], ['i', 'add handle'], ['o', state.socialAuthor ? `only @${state.socialAuthor} (clear)` : 'only this handle'], ['X', 'import X lists'], ['T', 'trending'], ['esc', 'back'], ['q', 'quit']], t.name);
+}

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

@@ -0,0 +1,90 @@
+// dexterm — NARRATIVE BOARD screen (key N, task-1356; AI-SUITE-DESIGN §7). What is running and what is
+// working across the tokens dexterm has recorded: deterministic lexicon clustering, per-narrative volume /
+// new launches / runners / pace / "what is working" score. No model in the hot path; the board carries
+// its own limits (name-based, X/TG-only narratives missed, honest unclassified share). w flips 1h/24h,
+// M opens the HUD popup. The board is computed in state.ts (computeNarrativeView) on entry and the tick.
+import { Canvas, header, footer, badge, breakpoint } from '../../../tui/src/index.js';
+import { headerModel } from "../state.js";
+const fmtUsd = (v) => { if (v == null)
+    return '—'; const a = Math.abs(v); if (a >= 1e9)
+    return (v / 1e9).toFixed(2) + 'B'; if (a >= 1e6)
+    return (v / 1e6).toFixed(2) + 'M'; if (a >= 1e3)
+    return (v / 1e3).toFixed(1) + 'K'; return v.toFixed(0); };
+const fmtPct = (v) => (v == null ? '—' : (v > 0 ? '+' : '') + v.toFixed(1) + '%');
+export function renderNarrative(c, state) {
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    header(c, headerModel(state));
+    const view = state.narrative ?? null;
+    const board = view?.board ?? null;
+    const top = 2, bottom = c.h - 1;
+    const win = view?.window ?? '1h';
+    const srcLabel = view?.source === 'recorded' ? 'recorded history' : view?.source === 'screen' ? 'visible rows' : 'no data';
+    const title = `NARRATIVE BOARD · ${win} · ${board ? `${board.meta.tokens_total} tokens · ${(100 * board.meta.unclassified_share).toFixed(0)}% unclassified` : srcLabel}`;
+    const caption = bp === 'compact' ? undefined : `model output: none (deterministic lexicon v${board?.meta.lexicon_version ?? '—'}) · name-based · source: ${srcLabel}`;
+    const box = c.box(0, top, c.w, bottom - top, { title, caption, focus: true });
+    const bg = box.bg;
+    if (!board || board.narratives.every((n) => n.tokens === 0)) {
+        c.textC(box.x, box.y + 1, box.w, 'collecting narratives — run the app with the recorder on, or open the screener first', { fg: t.muted, bg, i: true });
+        c.textC(box.x, box.y + 3, box.w, view?.error ? `(${view.error})` : 'clusters come from token names against a lexicon (owner: maintainers); X/Telegram-only narratives are missed', { fg: t.dim, bg });
+        footer(c, [['w', '1h/24h'], ['esc', 'back'], ['q', 'quit']], t.name);
+        return;
+    }
+    const shown = board.narratives.filter((n) => n.tokens > 0);
+    const sel = Math.max(0, Math.min(shown.length - 1, state.selected ?? 0));
+    // column header
+    let cy = box.y;
+    const wide = bp !== 'compact';
+    c.text(box.x + 1, cy, '#', { fg: t.dim, bg });
+    c.text(box.x + 4, cy, 'NARRATIVE', { fg: t.dim, bg });
+    c.text(box.x + 22, cy, 'TOK', { fg: t.dim, bg });
+    c.text(box.x + 28, cy, 'NEW 1h/24h', { fg: t.dim, bg });
+    c.text(box.x + 40, cy, `VOL ${win}`, { fg: t.dim, bg });
+    c.text(box.x + 50, cy, 'PACE', { fg: t.dim, bg });
+    c.text(box.x + 57, cy, 'MED1h', { fg: t.dim, bg });
+    c.text(box.x + 65, cy, 'SCORE', { fg: t.dim, bg });
+    if (wide)
+        c.text(box.x + 72, cy, 'TOP RUNNER (liq≥$10K)', { fg: t.dim, bg });
+    cy += 1;
+    c.hline(box.x, cy, box.w, { fg: t.border, bg });
+    cy += 1;
+    let rank = 0;
+    const scroll = Math.max(0, sel - (box.h - 6));
+    for (let i = scroll; i < shown.length; i++) {
+        if (cy >= box.y + box.h - 2)
+            break;
+        const n = shown[i];
+        if (n.score != null)
+            rank++;
+        const selected = i === sel;
+        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 + 1, cy, n.score == null ? '·' : String(rank), { fg: n.score == null ? t.dim : t.accent, bg: rb, b: true });
+        c.text(box.x + 4, cy, n.narrative, { fg: n.narrative === 'unclassified' ? t.dim : selected ? t.borderFocus : t.text, bg: rb, b: n.score != null }, 17);
+        c.text(box.x + 22, cy, String(n.tokens), { fg: t.text, bg: rb });
+        c.text(box.x + 28, cy, `${n.new_1h}/${n.new_24h}`, { fg: t.muted, bg: rb });
+        c.text(box.x + 40, cy, fmtUsd(win === '24h' ? n.vol_h24 : n.vol_h1), { fg: t.text, bg: rb });
+        c.text(box.x + 50, cy, n.pace_mature != null ? n.pace_mature.toFixed(1) + 'x' : n.pace == null ? '—' : n.pace.toFixed(1) + '*', { fg: t.muted, bg: rb });
+        const med = win === '24h' ? n.med_chg_h24 : n.med_chg_h1;
+        c.text(box.x + 57, cy, fmtPct(med), { fg: med == null ? t.dim : med >= 0 ? t.up : t.down, bg: rb });
+        c.text(box.x + 65, cy, n.score == null ? '—' : n.score.toFixed(0), { fg: n.score == null ? t.dim : t.accent, bg: rb, b: true });
+        if (wide) {
+            const r = n.runners[0];
+            if (r) {
+                let cx = c.text(box.x + 72, cy, r.symbol, { fg: t.text, bg: rb }, 12);
+                cx = c.text(cx + 1, cy, fmtPct(r.chg_h1), { fg: (r.chg_h1 ?? 0) >= 0 ? t.up : t.down, bg: rb });
+                c.text(cx + 1, cy, fmtUsd(r.mcap), { fg: t.muted, bg: rb });
+            }
+            else
+                c.text(box.x + 72, cy, '—', { fg: t.dim, bg: rb });
+        }
+        cy += 1;
+    }
+    // limits line
+    const ly = box.y + box.h - 1;
+    if (wide)
+        c.textC(box.x, ly, box.w, `model output: none (deterministic lexicon v${board.meta.lexicon_version}) · ${board.meta.copycat_tokens} copycat symbols · name-based · pace '*' = all tokens · compute ${board.meta.compute_ms}ms`, { fg: t.dim, bg });
+    footer(c, [['↑↓', 'move'], ['w', win === '1h' ? '→24h' : '→1h'], ['M', 'popup'], ['esc', 'back'], ['q', 'quit']], t.name);
+}

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

@@ -0,0 +1,150 @@
+// dexterm — New pairs feed (pump.fun / DBC / Bonk launches, bonding progress, risk flags) + spotlight.
+// Cyberspace styling (task-1297): a pair younger than a minute gets the magenta NEW treatment (its
+// arrival fires the glitch via pulse in the loop); rain zones in the sub-tab gap, the gutter and the
+// spotlight's blank middle; ▲/▼ on directions; the claude one-liner in coral.
+import { Canvas, table, sparkline, sparkArea, heatPct, launchpadBadge, bar, badge, statGrid, ratioBar, fmtUsd, fmtPrice, fmtAge, fmtNum, fmtPctDir, header, footer, breakpoint, mix, isCalm, } from '../../../tui/src/index.js';
+import { headerModel } from "../state.js";
+import { renderNewPairsLive } from "../live/screens/newpairs-live.js";
+import { layoutFor } from "../custom.js";
+import { priceCell, priceModeOf, MCAP_FALLBACK_NOTE } from "../display.js";
+export function renderNewPairs(c, state) {
+    if (state.live && state.screener.source !== 'fixtures')
+        return renderNewPairsLive(c, state, state.live.newpairs); // task-1298: live data path
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    header(c, headerModel(state));
+    const top = 2, bottom = c.h - 1;
+    const sideW = layoutFor(state.custom, c.w, c.h).pairSpotlightW; // task-1358: from the workspace layout (46 at wide by default)
+    const tableW = c.w - sideW - (sideW ? 1 : 0);
+    const sel = state.selected || 0;
+    const pairs = state.fx.newPairs;
+    // sub-tabs
+    const fy = top;
+    let x = 1;
+    const tabs = [['New', pairs.length], ['Graduating', 4], ['Migrated 1h', 7], ['Trenches', 3]];
+    for (const [lab, n] of tabs) {
+        const active = lab === 'New';
+        x = c.text(x, fy, ` ${lab} `, active ? { fg: t.borderFocus, bg: t.tabActiveBg, b: true } : { fg: t.muted, bg: t.bg });
+        x = c.text(x, fy, `${n} `, { fg: active ? t.accent : t.dim, bg: active ? t.tabActiveBg : t.bg }) + 1;
+    }
+    x = c.text(x + 2, fy, 'min liq 5K · dev < 5% · no mint auth', { fg: t.dim, bg: t.bg, i: true }, tableW - x - 4);
+    c.rainZone(x + 1, fy, Math.max(0, tableW - x - 2), 1, 1);
+    const box = c.box(0, top + 1, tableW, bottom - top - 1, { title: 'NEW PAIRS', caption: 'ws: pumpportal newToken · jup tokens/v2/recent' });
+    const fresh = (r) => r.ageMin < 1;
+    const cols = [
+        { key: 'age', label: 'AGE', w: 5, align: 'right', prio: 0, render: (cv, x, y, w, r, bg) => {
+                if (fresh(r)) {
+                    cv.fill(x, y, w, 1, ' ', { bg: mix(bg, t.pump, 0.35) });
+                    cv.textR(x, y, w, 'NEW', { fg: '#ffffff', bg: mix(bg, t.pump, 0.35), b: true });
+                    return;
+                }
+                cv.textR(x, y, w, fmtAge(r.ageMin), { fg: r.ageMin < 2 ? t.accent : t.muted, bg, b: r.ageMin < 2 });
+            } },
+        { key: 'token', label: 'TOKEN', w: bp === 'compact' ? 12 : 20, prio: 0, flex: bp !== 'compact', render: (cv, x, y, w, r, bg, m) => {
+                const cx = cv.text(x, y, r.symbol, { fg: fresh(r) ? t.pump : m.selected ? t.borderFocus : t.text, bg, b: true }, Math.min(10, w));
+                if (w > 14)
+                    cv.text(cx + 1, y, r.name, { fg: t.muted, bg }, w - (cx - x) - 1);
+            } },
+        { key: 'lp', label: 'LAUNCH', w: 6, prio: 1, render: (cv, x, y, _w, r, bg) => { launchpadBadge(cv, x, y, r.launchpad, { on: bg }); } },
+        { key: 'bond', label: 'BONDING', w: 14, prio: 1, render: (cv, x, y, w, r, bg) => {
+                if (r.bonding == null) {
+                    cv.text(x, y, 'migrated', { fg: t.dim, bg });
+                    return;
+                }
+                bar(cv, x, y, w - 5, r.bonding, { bg, color: r.bonding > 80 ? t.warn : t.pump });
+                cv.textR(x + w - 4, y, 4, `${Math.round(r.bonding)}%`, { fg: r.bonding > 80 ? t.warn : t.muted, bg });
+            } },
+        { key: 'mcap', label: 'MCAP', w: 8, align: 'right', prio: 0, render: (cv, x, y, w, r, bg) => { cv.textR(x, y, w, fmtUsd(r.mcap, { digits: 1 }), { fg: t.text, bg }); } },
+        { key: 'liq', label: 'LIQ', w: 7, align: 'right', prio: 2, render: (cv, x, y, w, r, bg) => { cv.textR(x, y, w, fmtUsd(r.liq, { digits: 1 }), { fg: t.text, bg }); } },
+        { key: 'm5', label: '5M', w: 7, align: 'right', prio: 0, 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: 3, render: (cv, x, y, w, r, bg) => heatPct(cv, x, y, w, r.chg.h1, bg) },
+        { key: 'holders', label: 'HLD', w: 5, align: 'right', prio: 2, render: (cv, x, y, w, r, bg) => { cv.textR(x, y, w, fmtNum(r.holders), { fg: t.text, bg }); } },
+        { key: 'bs', label: 'B/S 5M', w: 8, prio: 4, render: (cv, x, y, w, r, bg) => ratioBar(cv, x, y, w, Math.max(1, r.buys % 37), Math.max(1, r.sells % 29), { bg }) },
+        { key: 'dev', label: 'DEV', w: 5, align: 'right', prio: 3, render: (cv, x, y, w, r, bg) => { cv.textR(x, y, w, `${r.dev.toFixed(1)}%`, { fg: r.dev > 5 ? t.down : t.muted, bg }); } },
+        { key: 'snipe', label: 'SNIPE', w: 5, align: 'right', prio: 4, render: (cv, x, y, w, r, bg) => { cv.textR(x, y, w, String(r.snipers), { fg: r.snipers > 10 ? t.down : r.snipers > 4 ? t.warn : t.muted, bg }); } },
+        { key: 'bund', label: 'BUNDLE', w: 6, align: 'right', prio: 4, render: (cv, x, y, w, r, bg) => { cv.textR(x, y, w, `${r.bundled.toFixed(0)}%`, { fg: r.bundled > 15 ? t.down : t.muted, bg }); } },
+        { key: 'spark', label: 'TREND', w: 12, prio: 2, render: (cv, x, y, w, r, bg) => sparkline(cv, x, y, w, r.spark, { bg }) },
+        { key: 'flags', label: 'RISK', w: 13, prio: 5, render: (cv, x, y, w, r, bg) => {
+                let cx = x;
+                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)
+                    cv.text(x, y, '✓ clean', { fg: mix(bg, t.up, 0.7), bg });
+            } },
+    ];
+    table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows: pairs, selected: sel, scroll: 0, bg: box.bg });
+    if (sideW) {
+        c.rainZone(tableW, top, 1, bottom - top, 1);
+        pairSpotlight(c, c.w - sideW, top, sideW, bottom - top, pairs[sel], priceModeOf(state));
+    }
+    // task-1388: `g` opens the go-to prompt here too (keymap + the ? overlay list it); the footer is kept
+    // byte-identical to prototype-v2 (snapshot parity), so the hint lives in `?` and on the screener footer.
+    footer(c, [['j/k', 'move'], ['⏎', 'open'], ['p', 'pause feed'], ['f', 'filters'], ['w', 'watch'], ['a', 'ask claude'], ['q', 'quit']], state.theme.name, isCalm(state.vfx));
+}
+function pairSpotlight(c, x, y, w, h, tk, mode = 'price') {
+    const t = c.theme;
+    const box = c.box(x, y, w, h, { title: `$${tk.symbol}`, caption: `${fmtAge(tk.ageMin)} old`, focus: true });
+    const bg = box.bg;
+    let cy = box.y;
+    c.text(box.x + 1, cy, tk.name, { fg: t.muted, bg }, box.w - 2);
+    launchpadBadge(c, box.x + box.w - 8, cy, tk.launchpad, { on: bg });
+    cy += 1;
+    // task-1366: the headline follows the price mode (mcap, then the price beside it)
+    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')
+        cx = c.text(cx + 1, cy, `(${fmtPrice(tk.price)})`, { fg: t.dim, bg });
+    c.text(cx + 1, cy, fmtPctDir(tk.chg.h1), { fg: tk.chg.h1 >= 0 ? t.up : t.down, bg });
+    if (head.fallback)
+        c.text(box.x + 1, cy + 1, MCAP_FALLBACK_NOTE, { fg: t.warn, bg, i: true }, box.w - 2);
+    cy += 2;
+    if (tk.bonding != null) {
+        c.text(box.x + 1, cy, 'BONDING CURVE', { fg: t.dim, bg });
+        c.textR(box.x + 1, cy, box.w - 2, `${Math.round(tk.bonding)}% → PumpSwap at $69K`, { fg: t.muted, bg });
+        cy += 1;
+        bar(c, box.x + 1, cy, box.w - 2, tk.bonding, { bg, color: tk.bonding > 80 ? t.warn : t.pump });
+        cy += 2;
+    }
+    sparkArea(c, box.x + 1, cy, box.w - 2, 4, tk.spark, { bg });
+    cy += 5;
+    cy += statGrid(c, box.x + 1, cy, box.w - 2, [
+        { label: 'mcap', value: fmtUsd(tk.mcap, { digits: 1 }) },
+        { label: 'liquidity', value: fmtUsd(tk.liq, { digits: 1 }) },
+        { label: 'holders', value: fmtNum(tk.holders) },
+        { label: 'vol since launch', value: fmtUsd(tk.vol24, { digits: 1 }) },
+    ], { bg, cols: 2 });
+    cy += 1;
+    c.text(box.x + 1, cy, 'LAUNCH FORENSICS', { fg: t.dim, bg });
+    cy += 1;
+    const rows = [
+        ['Dev wallet', `${tk.dev.toFixed(1)}% · ${tk.devHistory.launches} prior · ${tk.devHistory.rugged} rugs`, tk.devHistory.rugged ? 'bad' : tk.dev > 5 ? 'warn' : 'ok'],
+        ['Bundled at launch', `${tk.bundled.toFixed(0)}% across ${Math.max(1, Math.round(tk.bundled / 4))} wallets`, tk.bundled > 15 ? 'bad' : tk.bundled > 8 ? 'warn' : 'ok'],
+        ['Snipers block 0-2', `${tk.snipers} wallets`, tk.snipers > 10 ? 'bad' : tk.snipers > 4 ? 'warn' : 'ok'],
+        ['Top 10 holders', `${tk.top10.toFixed(1)}%`, tk.top10 > 40 ? 'bad' : tk.top10 > 25 ? 'warn' : 'ok'],
+        ['Mint / freeze', tk.mintAuth || tk.freezeAuth ? 'ENABLED' : 'revoked', tk.mintAuth || tk.freezeAuth ? 'bad' : 'ok'],
+        ['Socials', `${[tk.socials.x && 'X', tk.socials.tg && 'TG', tk.socials.web && 'web'].filter(Boolean).join(' ') || 'none'}${tk.socials.x ? ` · ${fmtNum(tk.xFollowers)} followers` : ''}`, tk.socials.x ? 'ok' : 'warn'],
+    ];
+    for (const [label, val, lvl] of rows) {
+        if (cy >= box.y + box.h - 6)
+            break;
+        const color = lvl === 'ok' ? t.up : lvl === 'warn' ? t.warn : t.down;
+        c.text(box.x + 1, cy, lvl === 'ok' ? '●' : lvl === 'warn' ? '◐' : '○', { fg: color, bg });
+        c.text(box.x + 3, cy, label, { fg: t.muted, bg });
+        cy += 1;
+        c.text(box.x + 3, cy, val, { fg: lvl === 'ok' ? t.text : color, bg }, box.w - 4);
+        cy += 1;
+    }
+    const ay = box.y + box.h - 4;
+    if (ay - 2 > cy)
+        c.rainZone(box.x + 1, cy, box.w - 2, ay - 2 - cy, 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);
+    const good = rows.filter((r) => r[2] === 'ok').length;
+    const line = good >= 5 ? 'clean launch, watch holder velocity for 10m' : good >= 3 ? 'mixed: bundled supply is the risk here' : 'skip: dev + bundle pattern matches prior rugs';
+    c.text(box.x + 1, ay + 1, line, { fg: t.ai, bg }, box.w - 2);
+    c.text(box.x + 1, ay + 2, `${good}/${rows.length} checks pass · a → full analysis`, { fg: t.dim, bg }, box.w - 2);
+}