dexterm-cli 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,326 @@
+// dexterm — full-screen Analyst (chat with screener-aware Claude) + live context rail.
+// Cyberspace styling (task-1297): Claude's verdict/answer lines and tool-call lines in coral, the
+// streaming answer decrypts through code glyphs behind the Claude-Code spinner, rain zones under the
+// transcript and the market pulse, ▲/▼ on every direction.
+import { Canvas, sparkline, heatPct, decryptText, spinnerGlyph, fmtUsd, fmtPrice, fmtPctDir, fmtDeltaDir, wrap, header, footer, breakpoint, mix, isCalm, } from '../../../tui/src/index.js';
+import { headerModel } from "../state.js";
+import { screenerView } from "../screener/view.js";
+import { renderAnalystSession } from "./analyst-session.js";
+import { resolveAnalystResults } from "../analyst/results.js";
+export function renderAnalyst(c, state) {
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    header(c, headerModel(state));
+    const top = 2, bottom = c.h - 1;
+    const railW = bp === 'compact' ? 0 : Math.min(48, Math.floor(c.w * 0.32));
+    const chatW = c.w - railW;
+    const bc = mix(t.border, t.ai, 0.55);
+    // Live Claude session (task-1302): render it in the chat area, with the navigable coin list beside
+    // it (task-1313) so the user can see and change the hovered coin while chatting.
+    if (state.analyst) {
+        const focused = state.aiFocused === true;
+        // task-1313 part F: when the finished turn is a list-of-coins answer, resolve each mint against the
+        // app's LIVE data layer (never the model's text) and render it as a real table inside the chat. The
+        // table is "active" (↑↓ moves its cursor, ⏎ jumps, o opens a PAPER ticket) when the input is blurred.
+        const results = state.analyst.hasResults ? resolveAnalystResults(state, state.analyst.results) : [];
+        const resultsActive = results.length > 0 && !focused && state.aiResultsActive === true;
+        renderAnalystSession(c, 0, top, chatW, bottom - top, state.analyst, {
+            frame: state.vfx.frame, code: state.vfx.code, calm: isCalm(state.vfx),
+            input: state.aiInput ?? '', inputFocused: focused,
+            scroll: state.aiScroll, revealAll: state.aiRevealAll,
+            results, resultsCursor: state.analyst.resultsCursor, resultsActive,
+            inputHint: focused ? 'type your question…  ⏎ send · esc blur · analysis not advice'
+                : results.length ? 'i ask · ↑↓ pick coin · ⏎ open · o ticket · esc back'
+                    : 'i ask · ⏎ focus · ↑↓ pick coin · PgUp/Dn scroll',
+        });
+        if (railW)
+            renderCoinList(c, chatW, top, railW, bottom - top, state);
+        footer(c, analystFooter(state, focused), state.theme.name, isCalm(state.vfx));
+        return;
+    }
+    // task-1311 (QA M13): the canned SIGMA/GOAT/BOME conversation is seeded demo data. Never show it
+    // next to live data — in live mode the empty tab says how to start a real conversation instead.
+    if (state.screener.source !== 'fixtures') {
+        const live = state.aiFocused === true;
+        const b = c.box(0, top, chatW, bottom - top, { title: '✦ ANALYST · claude', titleFg: t.ai, caption: 'read-only · local claude CLI · on demand', captionFg: t.dim, border: bc });
+        const bbg = b.bg;
+        const bin = b.w - 2;
+        let by = b.y + 1;
+        const say2 = (s) => { for (const w2 of wrap(s, bin - 2)) {
+            if (by >= b.y + b.h - 3)
+                break;
+            c.text(b.x + 2, by, w2, { fg: t.muted, bg: bbg }, bin - 2);
+            by += 1;
+        } };
+        say2('No conversation yet.');
+        by += 1;
+        say2("Press  i  to ask claude about the market, a token, or your watchlist. It can read the live screener, a token's holders / tape / RugCheck, and your watchlist — read-only, never trades.");
+        const iy = b.y + b.h - 2;
+        c.hline(b.x, iy - 1, b.w, { fg: bc, bg: bbg, soft: true });
+        c.put(b.x, iy - 1, '├', { fg: bc, bg: bbg, soft: true });
+        c.put(b.x + b.w - 1, iy - 1, '┤', { fg: bc, bg: bbg, soft: true });
+        const typed = state.aiInput ?? '';
+        c.text(b.x + 1, iy, '▌', { fg: t.ai, bg: bbg, b: true, soft: true });
+        if (typed)
+            c.text(b.x + 2, iy, typed + (live ? '█' : ''), { fg: t.text, bg: bbg }, bin - 2);
+        else
+            c.text(b.x + 2, iy, live ? '█ type your question…  ⏎ send · esc blur' : 'press i to ask claude · ⏎ to focus', { fg: t.dim, bg: bbg, i: true }, bin - 2);
+        if (railW)
+            renderCoinList(c, chatW, top, railW, bottom - top, state);
+        footer(c, analystFooter(state, live), state.theme.name, isCalm(state.vfx));
+        return;
+    }
+    const cb = c.box(0, top, chatW, bottom - top, { title: '✦ ANALYST · claude', titleFg: t.ai, caption: 'session 14m · 11 tool calls · $0.00 (your CLI)', border: bc });
+    const bg = cb.bg;
+    const inner = cb.w - 2;
+    const fx = state.fx;
+    const picks = fx.tokens.filter((k) => k.org >= 55 && k.top10 < 30 && !k.mintAuth).slice(0, 5);
+    const convo = [
+        { role: 'user', text: 'screen for tokens under $5M mcap with rising holders, organic score over 60, and no bundler footprint. rank them.' },
+        { role: 'tool', text: 'screener_query(mcap<5M, org>60, bundled<10) 38ms · get_holders_delta(5 tokens, 6h) 212ms · get_dev_history(5) 540ms' },
+        { role: 'table', rows: picks },
+        { role: 'ai', text: `Ranked by holder velocity × organic volume. ${picks[0]?.symbol} leads because new wallets outpace sells 3:1 and the dev has no prior rugs; ${picks[1]?.symbol} has the better chart but 2 wallets took 11% in block 1, which I weight down. None are "safe", all are sub-$5M memes.` },
+        { role: 'user', text: `what would make you flip bullish on ${picks[2]?.symbol}?` },
+        { role: 'ai', text: `Three things, in order: liquidity above $150K (currently ${fmtUsd(picks[2]?.liq || 0, { digits: 0 })}), top-10 below 25%, and a 6h candle closing above ${fmtPrice((picks[2]?.price || 0) * 1.18)} on organic volume. I added those as a watch rule; you'll get an alert, not a trade.` },
+        { role: 'user', text: 'draft the thesis as a note for my watchlist' },
+        { role: 'ai', text: `Saved to watchlist note for ${picks[2]?.symbol}: "Range-bound memecoin with improving holder spread; entry only on liq > 150K + top10 < 25%; invalidate on dev sell or liq < 60K." Edit with n.` },
+    ];
+    const ai = state.ai ?? { phase: 'done', cut: convo.length, revealed: 0 };
+    const frame = state.vfx.frame;
+    const code = state.vfx.code;
+    const cut = ai.phase === 'done' ? convo.length : ai.cut;
+    let revealedLeft = ai.revealed;
+    let cy = cb.y;
+    const inputY = cb.y + cb.h - 2;
+    for (let li = 0; li < convo.length; li++) {
+        const ln = convo[li];
+        if (cy >= inputY - 1)
+            break;
+        if (li > cut && revealedLeft <= 0)
+            break;
+        const streaming = li >= cut;
+        if (streaming && ai.phase === 'thinking') {
+            c.text(cb.x + 2, cy, spinnerGlyph(frame), { fg: t.ai, bg, b: true });
+            const status = ['Thinking', 'Querying screener', 'Reading dev history', 'Decrypting'][Math.floor(frame / 24) % 4];
+            c.text(cb.x + 4, cy, `${status}…`, { fg: t.ai, bg, b: true });
+            c.text(cb.x + 5 + status.length, cy, `(esc to interrupt · ${(frame / 30).toFixed(1)}s · ↓ ${Math.floor(frame * 11)} tokens)`, { fg: t.dim, bg }, inner - status.length - 6);
+            cy += 1;
+            break;
+        }
+        if (ln.role === 'user') {
+            c.text(cb.x + 1, cy, '›', { fg: t.accent, bg, b: true });
+            for (const w2 of wrap(ln.text, inner - 3)) {
+                if (cy >= inputY - 1)
+                    break;
+                c.text(cb.x + 3, cy, w2, { fg: t.text, bg, b: true });
+                cy += 1;
+            }
+            cy += 1;
+        }
+        else if (ln.role === 'tool') {
+            for (const w2 of wrap('↳ ' + ln.text, inner - 3)) {
+                if (cy >= inputY - 1)
+                    break;
+                c.text(cb.x + 3, cy, w2, { fg: t.ai, bg, i: true });
+                cy += 1;
+            }
+        }
+        else if (ln.role === 'table') {
+            cy += 1;
+            const cols = [['#', 3, 'r'], ['TOKEN', 11, 'l'], ['MCAP', 8, 'r'], ['HLD 6H', 8, 'r'], ['ORG', 4, 'r'], ['1H', 7, 'r'], ['24H', 8, 'r'], ['LIQ', 8, 'r'], ['TREND', 14, 'l']];
+            let hx = cb.x + 3;
+            for (const [lab, w, al] of cols) {
+                if (al === 'r')
+                    c.textR(hx, cy, w, lab, { fg: t.dim, bg });
+                else
+                    c.text(hx, cy, lab, { fg: t.dim, bg });
+                hx += w + 1;
+            }
+            cy += 1;
+            ln.rows.forEach((k, i) => {
+                if (cy >= inputY - 1)
+                    return;
+                let rx = cb.x + 3;
+                const rowBg = i % 2 ? mix(bg, t.panelAlt, 1) : bg;
+                c.fill(cb.x + 2, cy, inner - 2, 1, ' ', { bg: rowBg });
+                c.textR(rx, cy, 3, String(i + 1), { fg: t.dim, bg: rowBg });
+                rx += 4;
+                c.text(rx, cy, k.symbol, { fg: t.text, bg: rowBg, b: true }, 11);
+                rx += 12;
+                c.textR(rx, cy, 8, fmtUsd(k.mcap, { digits: 1 }), { fg: t.text, bg: rowBg });
+                rx += 9;
+                c.textR(rx, cy, 8, fmtDeltaDir(k.holders24), { fg: k.holders24 >= 0 ? t.up : t.down, bg: rowBg });
+                rx += 9;
+                c.textR(rx, cy, 4, String(k.org), { fg: k.org >= 70 ? t.up : t.warn, bg: rowBg });
+                rx += 5;
+                heatPct(c, rx, cy, 7, k.chg.h1, rowBg);
+                rx += 8;
+                heatPct(c, rx, cy, 8, k.chg.h24, rowBg);
+                rx += 9;
+                c.textR(rx, cy, 8, fmtUsd(k.liq, { digits: 1 }), { fg: t.text, bg: rowBg });
+                rx += 9;
+                const sw = Math.min(14, cb.x + cb.w - 2 - rx);
+                if (sw >= 4)
+                    sparkline(c, rx, cy, sw, k.spark, { bg: rowBg });
+                cy += 1;
+            });
+            cy += 1;
+        }
+        else {
+            // Claude speaks in coral; the streaming answer decrypts through code glyphs
+            c.text(cb.x + 1, cy, '✦', { fg: t.ai, bg, b: true });
+            for (const w2 of wrap(ln.text, inner - 3)) {
+                if (cy >= inputY - 1)
+                    break;
+                if (streaming) {
+                    const n = Math.min(revealedLeft, w2.length);
+                    decryptText(c, cb.x + 3, cy, w2, n, frame, { fg: t.ai, bg }, inner - 3, code);
+                    revealedLeft -= w2.length + 1;
+                    cy += 1;
+                    if (revealedLeft <= -6)
+                        break;
+                }
+                else {
+                    c.text(cb.x + 3, cy, w2, { fg: t.ai, bg });
+                    cy += 1;
+                }
+            }
+            cy += 1;
+        }
+    }
+    if (inputY - 2 > cy)
+        c.rainZone(cb.x + 1, cy, inner, inputY - 2 - cy, 2);
+    c.hline(cb.x, inputY - 1, cb.w, { fg: bc, bg, soft: true });
+    c.put(cb.x, inputY - 1, '├', { fg: bc, bg, soft: true });
+    c.put(cb.x + cb.w - 1, inputY - 1, '┤', { fg: bc, bg, soft: true });
+    // task-1311 (QA B3): the input line captures typed text even before a session exists, with a cursor
+    // when focused. Keystrokes reach here only while the box is focused, so nothing types by accident.
+    // When idle (not focused, nothing typed) the line keeps its original placeholder so the demo render
+    // is unchanged — the focus affordances only appear once the user engages.
+    const focused = state.aiFocused === true;
+    const typed = state.aiInput ?? '';
+    c.text(cb.x + 1, inputY, '▌', { fg: t.ai, bg, b: true, soft: true });
+    if (typed)
+        c.text(cb.x + 2, inputY, typed + (focused ? '█' : ''), { fg: t.text, bg }, inner - 2);
+    else if (focused)
+        c.text(cb.x + 2, inputY, '█ type your question…  ⏎ send · esc blur', { fg: t.dim, bg, i: true }, inner - 2);
+    else
+        c.text(cb.x + 2, inputY, 'ask anything about the market, a token, or your watchlist… (/screen /explain /rank /thesis /backtest)', { fg: t.dim, bg, i: true }, inner - 2);
+    if (railW)
+        renderContextRail(c, chatW, top, railW, bottom - top, state);
+    footer(c, analystFooter(state, focused), state.theme.name, isCalm(state.vfx));
+}
+/** Footer keys for the analyst screen — focus state decides whether `q`/screens show or `esc blur`. */
+function analystFooter(state, focused) {
+    if (state.analyst?.busy)
+        return [['⏎', 'queue'], ['esc', 'interrupt'], ['ctrl+c', 'quit']];
+    if (focused)
+        return [['⏎', 'send'], ['esc', state.aiInput ? 'clear' : 'blur'], ['ctrl+c', 'quit']];
+    if (state.analyst)
+        return [['i', 'ask'], ['esc', 'back'], ['tab', 'screens'], ['q', 'quit']];
+    // Idle demo tab (no session, not focused): the original footer, kept for prototype-v2 parity.
+    return [['⏎', 'send'], ['↑↓', 'history'], ['ctrl+l', 'clear'], ['esc', 'back'], ['tab', 'screens'], ['q', 'quit']];
+}
+/**
+ * The right-hand navigable COIN LIST beside the chat (task-1313): the live screener rows with the
+ * hovered coin highlighted (↑↓ changes it, which updates the analyst's context), plus a short
+ * "analyst did X" log of applied UI actions. Degrades to nothing when the panel is too narrow (the
+ * caller passes w=0 in compact mode and the chat takes the full width).
+ */
+export function renderCoinList(c, x, y, w, h, state) {
+    const t = c.theme;
+    const live = state.screener.source !== 'fixtures';
+    const rows = live ? screenerView(state.screener) : [];
+    const sel = Math.max(0, Math.min(Math.max(0, rows.length - 1), state.selected || 0));
+    const box = c.box(x, y, w, h, { title: 'COINS', titleFg: t.text, caption: live ? '↑↓ pick · ⏎ open' : 'live only', captionFg: t.dim });
+    const bg = box.bg;
+    const inner = box.w - 2;
+    const log = state.analystActions ?? [];
+    // Reserve a short footer for the "analyst did X" log: a divider, a label, up to two entries.
+    const logRows = log.length ? 2 + Math.min(2, log.length) : 0;
+    const listBottom = box.y + box.h - logRows;
+    let ry = box.y;
+    if (!rows.length) {
+        c.text(box.x + 1, ry, live ? 'no rows yet…' : 'coin list is live-mode only', { fg: t.dim, bg, i: true }, inner);
+    }
+    else {
+        const cap = Math.max(1, listBottom - box.y);
+        const startIdx = Math.max(0, Math.min(sel - Math.floor(cap / 2), Math.max(0, rows.length - cap)));
+        for (let i = startIdx; i < rows.length && ry < listBottom; i++) {
+            const r = rows[i];
+            const on = i === sel;
+            const rowBg = on ? mix(bg, t.accent, 0.3) : i % 2 ? mix(bg, t.panelAlt, 1) : bg;
+            c.fill(box.x + 1, ry, inner, 1, ' ', { bg: rowBg });
+            let rx = box.x + 1;
+            c.text(rx, ry, on ? '▸' : ' ', { fg: t.accent, bg: rowBg, b: true });
+            rx += 1;
+            c.text(rx, ry, r.symbol, { fg: t.text, bg: rowBg, b: on }, 9);
+            rx += 9;
+            const chg = r.chg.h24 ?? 0;
+            c.textR(rx, ry, 7, fmtPctDir(chg), { fg: chg >= 0 ? t.up : t.down, bg: rowBg });
+            rx += 8;
+            const liqW = Math.max(0, box.x + box.w - 1 - rx);
+            if (liqW >= 6)
+                c.textR(rx, ry, liqW, 'L' + fmtUsd(r.liq || 0, { digits: 0 }), { fg: t.dim, bg: rowBg });
+            ry += 1;
+        }
+    }
+    if (log.length) {
+        c.hline(box.x, listBottom, box.w, { fg: t.border, bg, soft: true });
+        c.put(box.x, listBottom, '├', { fg: t.border, bg, soft: true });
+        c.put(box.x + box.w - 1, listBottom, '┤', { fg: t.border, bg, soft: true });
+        c.text(box.x + 1, listBottom, ' ANALYST DID ', { fg: t.ai, bg });
+        let ly = listBottom + 1;
+        for (const l of log.slice(-2)) {
+            if (ly >= box.y + box.h)
+                break;
+            c.text(box.x + 1, ly, '✓ ' + l, { fg: t.ai, bg }, inner);
+            ly += 1;
+        }
+    }
+}
+/** The right-hand "what claude can see" rail: tool list, firewall note, guard rail, and a market pulse. */
+export function renderContextRail(c, x, y, w, h, state) {
+    const t = c.theme;
+    const fx = state.fx;
+    const rb = c.box(x, y, w, h, { title: 'CONTEXT', caption: 'what claude can see' });
+    let ry = rb.y;
+    const items = [
+        ['tools', 'screener_query · get_token · get_holders · get_trades · get_dev_history · rugcheck · watchlist_*'],
+        ['firewall', 'token names, descriptions, socials wrapped as untrusted data; instructions inside them are ignored'],
+        ['never', 'sign, send, or build a transaction. Trade panel requires your explicit confirm (v2).'],
+        ['model', 'your local claude CLI · session kept warm · no keys shipped by dexterm'],
+    ];
+    for (const [k, v] of items) {
+        c.text(rb.x + 1, ry, k.toUpperCase(), { fg: k === 'never' ? t.warn : t.dim, bg: rb.bg });
+        ry += 1;
+        for (const w2 of wrap(v, rb.w - 2)) {
+            if (ry >= rb.y + rb.h)
+                break;
+            c.text(rb.x + 1, ry, w2, { fg: k === 'never' ? t.warn : t.text, bg: rb.bg });
+            ry += 1;
+        }
+        ry += 1;
+    }
+    c.hline(rb.x, ry, rb.w, { fg: t.border, bg: rb.bg, soft: true });
+    ry += 1;
+    c.text(rb.x + 1, ry, 'MARKET PULSE', { fg: t.dim, bg: rb.bg });
+    c.heading(rb.x + 1, ry, 12);
+    ry += 1;
+    // task-1311 (QA M13): in live mode the pulse is the live screener's top rows — never the 2024
+    // fixture tickers (SIGMA/GOAT/…), which must not sit next to live data.
+    const live = state.screener.source !== 'fixtures';
+    const pulse = live
+        ? state.screener.rows.slice(0, 8).map((r) => ({ symbol: r.symbol, spark: r.spark, chg24: r.chg.h24 ?? 0 }))
+        : fx.tokens.slice(0, 8).map((k) => ({ symbol: k.symbol, spark: k.spark, chg24: k.chg.h24 }));
+    for (const k of pulse) {
+        if (ry >= rb.y + rb.h)
+            break;
+        c.text(rb.x + 1, ry, k.symbol, { fg: t.text, bg: rb.bg, b: true }, 9);
+        sparkline(c, rb.x + 11, ry, rb.w - 22, k.spark, { bg: rb.bg });
+        c.textR(rb.x + rb.w - 9, ry, 8, fmtPctDir(k.chg24), { fg: k.chg24 >= 0 ? t.up : t.down, bg: rb.bg });
+        ry += 1;
+    }
+    if (ry + 1 < rb.y + rb.h)
+        c.rainZone(rb.x + 1, ry + 1, rb.w - 2, rb.y + rb.h - ry - 1, 2);
+}

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

@@ -0,0 +1,74 @@
+// dexterm — boot sequence: full-screen rain, glitching DEXTERM logo, "jacking in" status lines.
+// state.boot.t ∈ [0,1] drives it. The logo and the status box clear their own rain zone so the
+// rain never crosses them (VISUAL-V2 §3 "Boot").
+import { Canvas, bootLogo, decryptText, spinnerGlyph, mix } from '../../../tui/src/index.js';
+// task-1311 (QA M13): the result column is the boot's intro texture, not a health report — it must
+// not fabricate latencies / rpm before a single request has gone out. Honest status words only.
+const LIVE_STEPS = [
+    ['dexscreener', 'GET /latest/dex/search?q=solana', 'link'],
+    ['jupiter', 'lite-api tokens/v2 + price/v3', 'link'],
+    ['geckoterminal', 'ohlcv/hour · 60 candles', 'link'],
+    ['rugcheck', 'summary · mint/freeze/LP', 'link'],
+    ['pumpportal', 'ws newToken · migration', 'link'],
+    ['claude -p', '--output-format stream-json · tools', 'local'],
+    ['data store', 'sqlite cache · limiter · health registry', 'init'],
+];
+const FIXTURE_STEPS = [
+    ...LIVE_STEPS.slice(0, 6),
+    ['fixtures', '34 tokens · 20 pairs · 6 watch · seed 7', 'loaded'],
+];
+export function renderBoot(c, state) {
+    const t = c.theme;
+    const v = state.vfx;
+    const p = state.boot ? state.boot.t : 1;
+    const steps = state.screener.source === 'fixtures' ? FIXTURE_STEPS : LIVE_STEPS;
+    c.fill(0, 0, c.w, c.h, ' ', { bg: t.bg });
+    c.rainZone(0, 0, c.w, c.h, 1);
+    const cx = Math.floor(c.w / 2);
+    const logoY = Math.max(2, Math.floor(c.h * 0.22));
+    // logo settles as p grows; it glitches hard at first, then only on sporadic frames
+    const intensity = p < 0.35 ? 0.9 - p : p < 0.85 ? 0.25 : 0.12;
+    const logo = bootLogo(c, cx, logoY, v, intensity);
+    const tag = 'terminal dex screener · claude inside';
+    c.textC(0, logoY + 6, c.w, tag, { fg: t.muted, bg: t.bg });
+    c.heading(cx - Math.floor(tag.length / 2), logoY + 6, tag.length);
+    // keep the logo column clear of rain so it reads
+    c.noRain(logo.x - 2, logo.y - 1, logo.w + 4, 9);
+    // jacking-in lines reveal one by one between p=0.2 and p=0.85
+    const boxW = Math.min(c.w - 8, 76);
+    const bx = cx - Math.floor(boxW / 2);
+    let y = logoY + 9;
+    const frame = v.frame;
+    const per = 0.65 / steps.length;
+    const title = ' JACKING IN ';
+    c.text(bx, y, title, { fg: '#000000', bg: t.borderFocus, b: true });
+    c.text(bx + title.length + 1, y, `${c.w}×${c.h} · ${state.colorDepth} · ${state.theme.name}`, { fg: t.dim, bg: t.bg });
+    c.noRain(bx - 1, y, boxW + 2, 2 + steps.length + 3);
+    y += 2;
+    for (let i = 0; i < steps.length; i++) {
+        const [name, what, result] = steps[i];
+        const start = 0.2 + i * per;
+        if (p < start)
+            break;
+        const local = Math.min(1, (p - start) / per);
+        const line = `${name.padEnd(14)} ${what}`;
+        const revealed = Math.floor(local * 1.6 * line.length);
+        const claude = name === 'claude -p';
+        c.text(bx, y, '▸', { fg: claude ? t.ai : t.accent, bg: t.bg, b: true });
+        decryptText(c, bx + 2, y, line, revealed, frame, { fg: claude ? t.ai : t.text, bg: t.bg }, boxW - 20, v.code);
+        if (local >= 0.7) {
+            const ok = result.startsWith('ok') || result === 'connected' || result === 'loaded' || result.startsWith('warm');
+            c.textR(bx, y, boxW, result, { fg: ok ? t.up : t.warn, bg: t.bg, b: true });
+        }
+        else {
+            c.textR(bx, y, boxW, spinnerGlyph(frame) + ' ', { fg: t.ai, bg: t.bg, b: true });
+        }
+        y += 1;
+    }
+    if (p >= 0.9) {
+        y += 1;
+        const msg = '◉ JACKED IN · press any key';
+        c.text(bx, y, msg, { fg: t.borderFocus, bg: mix(t.bg, t.borderFocus, 0.12), b: true });
+        c.heading(bx, y, msg.length);
+    }
+}

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

@@ -0,0 +1,255 @@
+// dexterm — BUBBLE MAP screen (task-1340, wallet intel W3/W4). The terminal rendering of the holder graph the
+// approved mocks showed (research/wallet-intel/mock/out): packed half-row discs (area ∝ share, colour = rule),
+// a CLUSTERS table, sample-captioned HOLDER INSIGHTS and the WHY THIS LABEL panel that prints every rule with
+// its confidence and evidence. Three honest states: loading, unavailable (reason + fix), ok (possibly degraded:
+// keyless runs show holders + static labels and say what a free Helius key adds). Pure renderer.
+import { Canvas, badge, statGrid, header, footer, breakpoint, isCalm, fmtNum, shortAddr, wrap, layoutBubbles, drawBubbles, drawTreemap, legendRow, kindColor, sampleCaption, } from '../../../tui/src/index.js';
+import { headerModel } from "../state.js";
+import { unavailableText } from "../live/intel.js";
+export function renderBubbles(c, state) {
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    header(c, headerModel(state));
+    const ui = state.intelUi ?? null;
+    const entry = ui && state.live?.intel ? state.live.intel.entry(ui.mint) : null;
+    const top = 2, bottom = c.h - 1;
+    // ---- title strip
+    let y = top;
+    c.fill(0, y, c.w, 1, ' ', { bg: t.bg });
+    let x = c.text(1, y, '‹ ', { fg: t.muted, bg: t.bg });
+    const symbol = ui?.symbol ?? '?';
+    x = c.text(x, y, `$${symbol}`, { fg: t.borderFocus, bg: t.bg, b: true });
+    c.heading(3, y, symbol.length + 1);
+    if (ui?.name && bp !== 'compact')
+        x = c.text(x + 1, y, ui.name.slice(0, 28), { fg: t.muted, bg: t.bg });
+    x = badge(c, x + 2, y, 'BUBBLE MAP', t.accent, { on: t.bg, bold: true });
+    if (ui?.mint)
+        x = c.text(x + 2, y, shortAddr(ui.mint, 6), { fg: t.dim, bg: t.bg });
+    const vm = entry?.state === 'ok' ? entry.bubbles : null;
+    const r = entry?.result?.state === 'ok' ? entry.result : null;
+    const right = vm && r ? `${r.depth} scan · ${r.via.history ? `${r.via.holders} + helius history` : `${r.via.holders} only`}${r.fromCache ? ' · cached' : ''} ` : entry?.state === 'loading' ? 'scanning… ' : '';
+    if (right && c.w - right.length - 1 > x + 2) {
+        c.text(c.w - 1 - right.length, y, right, { fg: t.dim, bg: t.bg });
+        c.rainZone(x + 1, y, c.w - right.length - x - 3, 1, 1);
+    }
+    else
+        c.rainZone(x + 1, y, Math.max(0, c.w - x - 2), 1, 1);
+    y += 1;
+    const sideW = bp === 'compact' ? 0 : bp === 'wide' ? 46 : 38;
+    const mapW = c.w - sideW;
+    const mapH = bottom - y;
+    const view = ui?.view ?? 'bubbles';
+    const title = `${symbol} · ${view === 'treemap' ? 'TREEMAP' : 'BUBBLES'}${ui?.focus ? ` · zoom ${ui.focus}` : ''}`;
+    const mb = c.box(0, y, mapW, mapH, { title, caption: view === 'treemap' ? 'area ∝ share · colour = rule' : 'area ∝ share · colour = rule · ring = linked cluster', focus: true });
+    const legendH = bp === 'compact' ? 2 : 1;
+    const innerH = mb.h - legendH - 1;
+    if (!vm) {
+        // loading / unavailable: say so, never draw a fake map
+        const lines = [];
+        if (!ui) {
+            lines.push(['no token: open a token and press M for its bubble map', t.muted]);
+        }
+        else if (!entry || entry.state === 'loading') {
+            lines.push(['scanning holders…', t.accent]);
+            lines.push(['top accounts → owners → owner kinds, then funders + the launch window (Helius)', t.dim]);
+        }
+        else {
+            const u = unavailableText(entry);
+            lines.push([`bubble map unavailable: ${u.reason}`, t.warn]);
+            if (u.fix)
+                lines.push([`fix: ${u.fix}`, t.muted]);
+            lines.push(['r rescans · esc back', t.dim]);
+        }
+        let ly = mb.y + Math.max(1, Math.floor(innerH / 2) - lines.length);
+        for (const [s, fg] of lines)
+            for (const ln of wrap(s, mb.w - 4)) {
+                if (ly >= mb.y + innerH)
+                    break;
+                c.textC(mb.x, ly, mb.w, ln, { fg, bg: mb.bg, i: true });
+                ly += 1;
+            }
+        c.rainZone(mb.x + 1, mb.y, mb.w - 2, Math.max(0, ly - mb.y - lines.length - 1), 2);
+    }
+    else if (view === 'treemap') {
+        drawTreemap(c, mb.x + 1, mb.y, mb.w - 2, innerH, vm, { bg: mb.bg, selected: ui?.selected ?? null });
+    }
+    else {
+        const key = `${entry?.at}|${mb.w}|${innerH}|${ui?.focus ?? ''}|${vm.holders.length}`;
+        let lay = ui?.layout && ui.layout.key === key ? ui.layout.lay : null;
+        if (!lay) {
+            lay = layoutBubbles(vm, mb.w - 2, innerH, { focus: ui?.focus ?? null });
+            if (ui)
+                ui.layout = { key, lay };
+        }
+        drawBubbles(c, mb.x + 1, mb.y, mb.w - 2, innerH, vm, lay, { bg: mb.bg, selected: ui?.selected ?? null });
+        if (lay.overflow)
+            c.text(mb.x + 1, mb.y, 'terminal too small to pack the map: grid view', { fg: t.warn, bg: mb.bg, i: true }, mb.w - 2);
+    }
+    const ly = mb.y + mb.h - legendH;
+    c.hline(mb.x, ly - 1, mb.w, { fg: t.border, bg: mb.bg, soft: true });
+    legendRow(c, mb.x + 1, ly, mb.w - 2, mb.bg);
+    if (bp === 'compact' && vm && ui?.selected != null && vm.holders[ui.selected]) {
+        const hd = vm.holders[ui.selected];
+        const first = hd.labels[0];
+        const cl0 = hd.cluster ? vm.clusters.find((k) => k.name === hd.cluster) : null;
+        const ev0 = cl0 ? cl0.evidence.find((e) => e.linked !== false && (e.a === hd.owner || e.b === hd.owner)) : null;
+        let sx = c.text(mb.x + 1, ly + 1, `${shortAddr(hd.owner, 4)} ${hd.pct.toFixed(2)}%`, { fg: t.borderFocus, bg: mb.bg, b: true });
+        sx = badge(c, sx + 1, ly + 1, hd.kind.toUpperCase(), kindColor(t, hd.kind), { on: mb.bg });
+        c.text(sx + 1, ly + 1, first ? `${first.label}: ${first.rule}` : ev0 ? `linked: ${ev0.rule}` : 'no rule matched · unlinked wallet', { fg: t.muted, bg: mb.bg }, mb.x + mb.w - 2 - sx - 1);
+    }
+    if (sideW)
+        sidePanels(c, mapW, y, sideW, mapH, vm, entry, ui);
+    const hints = [['esc', 'back'], ['j/k', 'select'], ['m', view === 'treemap' ? 'bubbles' : 'treemap'], ['z', ui?.focus ? 'unzoom' : 'zoom'], ['M', state.popups?.bubblesOpen?.() ? 'close popup' : 'popup'], ['D', 'deep scan'], ['r', 'rescan'], ['q', 'quit']];
+    footer(c, hints, t.name, isCalm(state.vfx));
+}
+function sidePanels(c, x, y, w, h, vm, entry, ui) {
+    const t = c.theme;
+    const r = entry?.result?.state === 'ok' ? entry.result : null;
+    const clH = Math.max(7, Math.min(12, Math.floor(h * 0.3)));
+    const insH = r?.degraded ? 13 : 11; // a degraded (keyless) scan prints its honest note inside the insights panel
+    const whyH = h - clH - insH;
+    // CLUSTERS
+    const cb = c.box(x, y, w, clH, { title: 'CLUSTERS', caption: vm ? `${vm.clusters.length} · ${vm.holders.length} wallets` : '' });
+    let cy = cb.y;
+    c.text(cb.x + 1, cy, 'ID   KIND        W     %  TOP WALLET', { fg: t.dim, bg: cb.bg }, cb.w - 2);
+    cy += 1;
+    const selOwner = vm && ui?.selected != null ? vm.holders[ui.selected]?.owner : null;
+    const sorted = vm ? vm.clusters.slice().sort((a, b) => b.pct - a.pct) : [];
+    for (const cl of sorted) {
+        if (cy >= cb.y + cb.h)
+            break;
+        const sel = !!selOwner && cl.members.includes(selOwner);
+        const rowBg = sel ? t.selBg : cb.bg;
+        c.fill(cb.x, cy, cb.w, 1, ' ', { bg: rowBg });
+        const color = kindColor(t, cl.kind);
+        let cx = c.text(cb.x + 1, cy, cl.name.padEnd(4), { fg: sel ? t.borderFocus : t.text, bg: rowBg, b: sel });
+        cx = c.text(cx + 1, cy, `${cl.members.length > 1 ? '●' : '○'} ${cl.kind}`.padEnd(11), { fg: color, bg: rowBg });
+        cx = c.textR(cx, cy, 3, String(cl.members.length), { fg: t.muted, bg: rowBg });
+        cx = c.textR(cx, cy, 6, `${cl.pct.toFixed(1)}`, { fg: cl.pct >= 10 ? t.warn : t.text, bg: rowBg });
+        c.text(cx + 2, cy, shortAddr(cl.members[0], 4), { fg: t.dim, bg: rowBg }, cb.w - (cx + 2 - cb.x) - 1);
+        cy += 1;
+    }
+    if (cy < cb.y + cb.h)
+        c.rainZone(cb.x + 1, cy, cb.w - 2, cb.y + cb.h - cy, 2);
+    // HOLDER INSIGHTS (sample-captioned; nulls when the history leg did not run)
+    const ib = c.box(x, y + clH, w, insH, { title: 'HOLDER INSIGHTS', caption: 'sample-bounded' });
+    let iy = ib.y;
+    if (r && vm) {
+        const I = r.analysis.insights;
+        const hist = I.coverage.launchTxs > 0;
+        const fund = I.coverage.fundingLookups > 0;
+        const pctS = (v) => (v == null ? 'n/a' : `${Number(v).toFixed(1)}%`);
+        iy += statGrid(c, ib.x + 1, iy, ib.w - 2, [
+            { label: 'top10 raw', value: pctS(I.top10.byTokenAccount), sub: 'by token acct' },
+            // task-1367: ex-pool (no POOL/CURVE/VAULT/LOCK/BURN owners) is the headline; the cluster-adjusted figure rides in the sub
+            typeof I.top10.exPool === 'number'
+                ? { label: 'top10 ex-pool', value: pctS(I.top10.exPool), sub: `adj ${pctS(I.top10.clusterAdjusted)} · -${I.top10.exPoolDropped ?? 0} venue`, style: { fg: I.top10.exPool >= 35 ? t.down : t.accent, b: true } }
+                : { label: 'top10 adj', value: pctS(I.top10.clusterAdjusted), sub: `excl ${I.top10.excludedCount} lbl`, style: { fg: t.accent, b: true } },
+            { label: 'snipers', value: hist ? String(I.snipers.count) : 'n/a', sub: hist && I.snipers.count ? `${pctS(I.snipers.launchWindowSharePct)} at launch` : hist ? 'first 3 slots' : 'needs history' },
+            { label: 'bundled', value: hist ? pctS(I.bundle.bundlePctOfTopSample) : 'n/a', sub: hist ? `${I.bundle.sameSlotCohorts} cohorts` : 'needs history' },
+            { label: 'dev', value: I.dev.creatorPctNow != null ? pctS(I.dev.creatorPctNow) : I.dev.creatorUpperBoundPct != null ? `≤${pctS(I.dev.creatorUpperBoundPct)}` : 'n/a', sub: !hist ? 'needs history' : I.dev.creatorPctNow == null ? 'not in sample' : 'now', style: { fg: t.warn, b: true } },
+            { label: 'fresh', value: fund ? pctS(I.fresh.freshAtBuyPctOfTopSample) : 'n/a', sub: fund ? `of ${pctS(I.fresh.measuredPct)} meas.` : 'needs history' },
+        ], { bg: ib.bg, cols: 2 });
+        const big = I.bigHolder;
+        if (big)
+            for (const ln of wrap(`⚠ main risk: ${big.tag} ${shortAddr(big.owner, 4)} holds ${big.pct.toFixed(1)}%`, ib.w - 2)) {
+                if (iy >= ib.y + ib.h)
+                    break;
+                c.text(ib.x + 1, iy, ln, { fg: t.down, bg: ib.bg, b: true });
+                iy += 1;
+            }
+        if (r.degraded)
+            for (const ln of wrap(`partial: ${r.degraded}`, ib.w - 2)) {
+                if (iy >= ib.y + ib.h)
+                    break;
+                c.text(ib.x + 1, iy, ln, { fg: t.warn, bg: ib.bg, i: true });
+                iy += 1;
+            }
+        for (const ln of wrap(sampleCaption(vm, fmtNum), ib.w - 2)) {
+            if (iy >= ib.y + ib.h)
+                break;
+            c.text(ib.x + 1, iy, ln, { fg: t.dim, bg: ib.bg });
+            iy += 1;
+        }
+    }
+    else {
+        c.text(ib.x + 1, iy, entry?.state === 'loading' ? 'scanning…' : 'no insights without a holder list', { fg: t.dim, bg: ib.bg, i: true }, ib.w - 2);
+        iy += 1;
+    }
+    if (iy < ib.y + ib.h)
+        c.rainZone(ib.x + 1, iy, ib.w - 2, ib.y + ib.h - iy, 2);
+    // WHY THIS LABEL
+    const wb = c.box(x, y + clH + insH, w, whyH, { title: '? WHY THIS LABEL', caption: 'rules, not facts' });
+    let wy = wb.y;
+    const hd = vm && ui?.selected != null ? vm.holders[ui.selected] ?? null : null;
+    if (!hd) {
+        c.text(wb.x + 1, wy, 'select a bubble (j/k) to see the rules behind its colour', { fg: t.dim, bg: wb.bg }, wb.w - 2);
+        return;
+    }
+    let hx = c.text(wb.x + 1, wy, shortAddr(hd.owner, 6), { fg: t.borderFocus, bg: wb.bg, b: true });
+    hx = c.text(hx + 1, wy, `${hd.pct.toFixed(2)}%`, { fg: t.text, bg: wb.bg, b: true });
+    hx = badge(c, hx + 1, wy, hd.kind.toUpperCase(), kindColor(t, hd.kind), { on: wb.bg });
+    if (hd.cluster)
+        c.textR(wb.x + 1, wy, wb.w - 2, hd.cluster, { fg: t.muted, bg: wb.bg });
+    wy += 1;
+    // task-1367: the holder's class (POOL / CURVE / … / UNLABELLED) and the on-chain reason, first
+    const cls = r?.analysis.holders.find((h) => h.owner === hd.owner)?.cls ?? null;
+    if (cls) {
+        const cx2 = badge(c, wb.x + 1, wy, cls.tag, cls.tag === 'UNLABELLED' ? t.muted : cls.tag === 'DEV' || cls.tag === 'LINKED' ? t.warn : t.accent, { on: wb.bg, bold: true });
+        const lines = wrap(cls.reason + (cls.lock ? ` · ${cls.lock.unlock ?? cls.lock.note}` : ''), Math.max(8, wb.w - (cx2 - wb.x) - 2));
+        for (const [i, ln] of lines.entries()) {
+            if (wy >= wb.y + wb.h)
+                break;
+            c.text(i === 0 ? cx2 + 1 : wb.x + 3, wy, ln, { fg: t.muted, bg: wb.bg }, wb.w - 3);
+            wy += 1;
+        }
+    }
+    if (hd.funder) {
+        c.text(wb.x + 1, wy, `funded by ${shortAddr(hd.funder.address, 4)}${hd.funder.label ? ` (${hd.funder.label})` : ''}${hd.funder.blockTime ? ` · ${new Date(hd.funder.blockTime * 1000).toISOString().slice(0, 10)}` : ''}`, { fg: t.muted, bg: wb.bg }, wb.w - 2);
+        wy += 1;
+    }
+    else if (hd.walletFirstSeen) {
+        c.text(wb.x + 1, wy, `first seen ${new Date(hd.walletFirstSeen * 1000).toISOString().slice(0, 10)} · funder not found in first txs`, { fg: t.muted, bg: wb.bg }, wb.w - 2);
+        wy += 1;
+    }
+    else {
+        c.text(wb.x + 1, wy, 'funding not looked up (outside the funded sample)', { fg: t.dim, bg: wb.bg }, wb.w - 2);
+        wy += 1;
+    }
+    wy += 1;
+    const cl = hd.cluster && vm ? vm.clusters.find((k) => k.name === hd.cluster) : null;
+    // a linked holder with no label of its own is explained by its cluster's rule (the evidence lines below say which)
+    const rules = hd.labels.length ? hd.labels : cl && cl.members.length > 1
+        ? [{ label: `linked · ${cl.kind}`, rule: `no label of its own; linked into ${cl.name} (${cl.members.length} wallets, ${cl.pct.toFixed(1)}%) by the evidence below`, confidence: 'on-chain' }]
+        : [{ label: 'unlinked', rule: 'no rule matched: no shared funder, same-slot buy, transfer or creator link found in the sample', confidence: 'n/a' }];
+    const ev = cl ? cl.evidence.filter((e) => e.linked !== false && (e.a === hd.owner || e.b === hd.owner)) : [];
+    for (const rl of rules) {
+        if (wy >= wb.y + wb.h)
+            break;
+        c.text(wb.x + 1, wy, '●', { fg: kindColor(t, rl.label === 'LP' || rl.label === 'contract' ? 'pool' : rl.label === 'multi-token-top20' ? 'whale' : rl.label === 'fresh-at-buy' || rl.label === 'same-slot-created' ? 'plain' : rl.label), bg: wb.bg });
+        c.text(wb.x + 3, wy, rl.label, { fg: t.text, bg: wb.bg, b: true });
+        c.textR(wb.x + 1, wy, wb.w - 2, rl.confidence || '', { fg: rl.confidence === 'seed' ? t.warn : t.dim, bg: wb.bg });
+        wy += 1;
+        for (const ln of wrap(rl.rule, wb.w - 5)) {
+            if (wy >= wb.y + wb.h)
+                break;
+            c.text(wb.x + 3, wy, ln, { fg: t.muted, bg: wb.bg });
+            wy += 1;
+        }
+    }
+    for (const e of ev.slice(0, 3)) {
+        if (wy >= wb.y + wb.h)
+            break;
+        for (const ln of wrap(`↳ ${shortAddr(e.a, 4)} ↔ ${shortAddr(e.b, 4)}: ${e.rule}`, wb.w - 3)) {
+            if (wy >= wb.y + wb.h)
+                break;
+            c.text(wb.x + 2, wy, ln, { fg: t.dim, bg: wb.bg, i: true });
+            wy += 1;
+        }
+    }
+    if (wy + 1 < wb.y + wb.h) {
+        c.text(wb.x + 1, wb.y + wb.h - 1, 'labels are heuristics (rule + evidence) · never asserted as fact', { fg: t.dim, bg: wb.bg }, wb.w - 2);
+        if (wy < wb.y + wb.h - 2)
+            c.rainZone(wb.x + 1, wy + 1, wb.w - 2, wb.y + wb.h - 2 - wy, 2);
+    }
+}