dexterm-cli 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,275 @@
+export function mulberry32(seed) {
+    let a = seed >>> 0;
+    return function () {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+function fakeMint(rnd, suffix = 'pump') {
+    let s = '';
+    for (let i = 0; i < 44 - suffix.length; i++)
+        s += B58[Math.floor(rnd() * B58.length)];
+    return s + suffix;
+}
+function fakeAddr(rnd) { return fakeMint(rnd, ''); }
+const NAMES = [
+    ['WIFHAT', 'dogwifhat classic', 'raydium'], ['PUDGY', 'Pudgy Terminal', 'pump.fun'], ['GIGA', 'Gigachad Protocol', 'pump.fun'],
+    ['MOODENG', 'Moo Deng Returns', 'meteora'], ['CATWIF', 'cat wif laser', 'pump.fun'], ['RETARDIO', 'retardio cousins', 'raydium'],
+    ['SNAIL', 'Snail Season', 'dbc'], ['HOUSE', 'housecoin', 'pump.fun'], ['FARTCOIN', 'Fartcoin', 'raydium'], ['PNUT', 'Peanut the Squirrel', 'raydium'],
+    ['ANSEM', 'ansem is back', 'pump.fun'], ['MANEKI', 'Maneki Neko', 'meteora'], ['GOAT', 'Goatseus Maximus', 'raydium'], ['ZEREBRO', 'zerebro', 'raydium'],
+    ['TITCOIN', 'titcoin', 'pump.fun'], ['FWOG', 'FWOG', 'raydium'], ['SIGMA', 'sigma grindset', 'pump.fun'], ['MICHI', 'michi', 'raydium'],
+    ['ALCH', 'Alchemist AI', 'dbc'], ['BUTTHOLE', 'butthole coin', 'pump.fun'], ['LOCKIN', 'lock in', 'raydium'], ['HARAMBE', 'Harambe on Solana', 'raydium'],
+    ['DADDY', 'DADDY TATE', 'raydium'], ['SKBDI', 'Skibidi Toilet', 'pump.fun'], ['CHILLGUY', 'Just a chill guy', 'raydium'], ['BRETT', 'Brett on Sol', 'meteora'],
+    ['NEIRO', 'Neiro', 'raydium'], ['SLERF', 'SLERF', 'raydium'], ['BOME', 'BOOK OF MEME', 'raydium'], ['POPCAT', 'Popcat', 'raydium'],
+    ['TRUMPCAT', 'Trump Cat', 'pump.fun'], ['MINI', 'mini', 'pump.fun'], ['AI16Z', 'ai16z', 'raydium'], ['ACT', 'Act I: The AI Prophecy', 'raydium'],
+];
+const NEWPAIR_NAMES = [
+    ['BOOP', 'boop the snoot', 'pump.fun'], ['CLAUDE', 'claude wif terminal', 'pump.fun'], ['GRIDLOCK', 'gridlock', 'dbc'], ['RATTO', 'ratto', 'pump.fun'],
+    ['MOONPIE', 'moon pie', 'bonk'], ['WAFFLE', 'waffle house', 'pump.fun'], ['PEBBLE', 'pebble', 'pump.fun'], ['HONK', 'honk honk', 'dbc'],
+    ['SIRLOIN', 'sirloin', 'pump.fun'], ['ORB', 'the orb', 'bonk'], ['DRIFTER', 'drifter', 'pump.fun'], ['GLIZZY', 'glizzy gobbler', 'pump.fun'],
+    ['NOODLE', 'noodle arms', 'dbc'], ['TUNA', 'tuna melt', 'pump.fun'], ['CRAB', 'crab rave', 'pump.fun'], ['FELIX', 'felix the cat', 'bonk'],
+    ['KERNEL', 'kernel panic', 'pump.fun'], ['BAGEL', 'everything bagel', 'pump.fun'], ['YAP', 'yapper', 'dbc'], ['PLONK', 'plonk', 'pump.fun'],
+];
+function walk(rnd, n, start, vol, drift = 0) {
+    const out = [start];
+    let p = start;
+    for (let i = 1; i < n; i++) {
+        const shock = rnd() < 0.04 ? (rnd() - 0.45) * vol * 6 : 0;
+        p = p * (1 + (rnd() - 0.5) * vol + drift + shock);
+        p = Math.max(p, start * 0.05);
+        out.push(p);
+    }
+    return out;
+}
+function candlesFrom(rnd, series, intervalMs, endMs, volBase) {
+    const out = [];
+    for (let i = 0; i < series.length - 1; i++) {
+        const o = series[i], c = series[i + 1];
+        const h = Math.max(o, c) * (1 + rnd() * 0.012);
+        const l = Math.min(o, c) * (1 - rnd() * 0.012);
+        const v = volBase * (0.3 + rnd() * 1.4) * (1 + Math.abs(c - o) / o * 25);
+        out.push({ o, h, l, c, v, t: endMs - (series.length - 1 - i) * intervalMs });
+    }
+    return out;
+}
+function makeToken(rnd, [symbol, name, launchpad], i, opts = {}) {
+    const fresh = !!opts.fresh;
+    const mcap = fresh ? 4e3 + rnd() * 90e3 : Math.exp(13 + rnd() * 6); // $440K .. $160M
+    const supply = 1e9;
+    const price = mcap / supply;
+    const liq = fresh ? mcap * (0.25 + rnd() * 0.3) : mcap * (0.04 + rnd() * 0.12);
+    const vol24 = fresh ? mcap * (0.5 + rnd() * 4) : mcap * (0.1 + rnd() * 1.6);
+    const ageMin = fresh ? rnd() * 90 : Math.exp(4 + rnd() * 7.5);
+    const holders = fresh ? Math.floor(20 + rnd() * 900) : Math.floor(Math.sqrt(mcap) * (2 + rnd() * 6));
+    const chg = {
+        m5: (rnd() - 0.5) * 8,
+        h1: (rnd() - 0.48) * 30,
+        h6: (rnd() - 0.47) * 70,
+        h24: (rnd() - 0.46) * 160,
+    };
+    if (fresh) {
+        chg.m5 = (rnd() - 0.4) * 40;
+        chg.h1 = (rnd() - 0.35) * 200;
+        chg.h6 = chg.h1;
+        chg.h24 = chg.h1;
+    }
+    const spark = walk(rnd, 48, price / (1 + chg.h24 / 100), 0.06);
+    spark[spark.length - 1] = price;
+    const buys = Math.floor(vol24 / (40 + rnd() * 400));
+    const sells = Math.floor(buys * (0.6 + rnd() * 0.7));
+    const org = fresh ? Math.floor(rnd() * 40) : Math.floor(20 + rnd() * 80);
+    const top10 = fresh ? 20 + rnd() * 50 : 8 + rnd() * 35;
+    const dev = fresh ? rnd() * 8 : rnd() * 4;
+    const lpLocked = launchpad === 'pump.fun' ? 100 : (rnd() < 0.7 ? 100 : Math.floor(rnd() * 100));
+    const mintAuth = rnd() < 0.08;
+    const freezeAuth = rnd() < 0.05;
+    const snipers = fresh ? Math.floor(rnd() * 30) : Math.floor(rnd() * 8);
+    const bundled = fresh ? rnd() * 30 : rnd() * 10;
+    const flags = [];
+    if (mintAuth)
+        flags.push('MINT');
+    if (freezeAuth)
+        flags.push('FREEZE');
+    if (top10 > 35)
+        flags.push('TOP10');
+    if (dev > 5)
+        flags.push('DEV');
+    if (bundled > 15)
+        flags.push('BUNDLE');
+    if (lpLocked < 50)
+        flags.push('LP');
+    const endMs = Date.UTC(2026, 9, 5, 23, 0, 0);
+    // 60 hourly candles; the walk is rescaled so the series ends exactly at the current price
+    const rawSeries = walk(rnd, 61, price, 0.05, (rnd() - 0.5) * 0.004);
+    const scale = price / rawSeries[rawSeries.length - 1];
+    const hourSeries = rawSeries.map((v) => v * scale);
+    const candles = candlesFrom(rnd, hourSeries, 3600e3, endMs, vol24 / 24);
+    const bonding = launchpad === 'pump.fun' && fresh ? Math.min(100, (mcap / 69e3) * 100) : null;
+    const mint = fakeMint(rnd, launchpad === 'pump.fun' ? 'pump' : launchpad === 'bonk' ? 'bonk' : '');
+    const holdersTop = Array.from({ length: 10 }, (_, k) => {
+        const pct = (top10 / 10) * (1.9 - k * 0.18) * (0.8 + rnd() * 0.4);
+        const kind = k === 0 && launchpad !== 'pump.fun' ? 'LP' : rnd() < 0.15 ? 'dev' : rnd() < 0.12 ? 'sniper' : rnd() < 0.1 ? 'cex' : '';
+        return { addr: fakeAddr(rnd), pct, kind, sol: pct / 100 * mcap / 120 };
+    });
+    const traders = Array.from({ length: 8 }, () => {
+        const pnl = (rnd() - 0.35) * 40000;
+        return { addr: fakeAddr(rnd), pnl, buys: Math.floor(rnd() * 40), sells: Math.floor(rnd() * 30), smart: rnd() < 0.3, winRate: 30 + rnd() * 60 };
+    }).sort((a, b) => b.pnl - a.pnl);
+    const trades = Array.from({ length: 24 }, (_, k) => {
+        const side = rnd() < 0.56 ? 'buy' : 'sell';
+        const usd = Math.exp(3 + rnd() * 6);
+        // PRNG draw order matters for parity with the prototype: ago, price, addr, then tag.
+        const ago = k * (4 + rnd() * 30);
+        const tradePrice = price * (1 + (rnd() - 0.5) * 0.02);
+        const addr = fakeAddr(rnd);
+        const tag = rnd() < 0.08 ? 'smart' : rnd() < 0.06 ? 'dev' : '';
+        return { ago, side, usd, price: tradePrice, addr, tag };
+    });
+    return {
+        id: i, symbol, name, launchpad, mint, price, mcap, fdv: mcap * (1 + rnd() * 0.1), liq, vol24, ageMin, holders,
+        holders24: Math.floor((rnd() - 0.3) * holders * 0.2), chg, spark, buys, sells, org, top10, dev, lpLocked, mintAuth, freezeAuth,
+        snipers, bundled, flags, candles, bonding, supply,
+        socials: { x: rnd() < 0.85, tg: rnd() < 0.7, web: rnd() < 0.6 },
+        xFollowers: Math.floor(rnd() * 60000),
+        devHistory: { launches: Math.floor(rnd() * 12), rugged: Math.floor(rnd() * 3), bestAth: Math.exp(10 + rnd() * 6) },
+        holdersTop, traders, trades,
+        rug: { score: Math.floor(rnd() * 100), risks: flags },
+        migrated: launchpad === 'pump.fun' ? !fresh : true,
+    };
+}
+export function makeFixtures(seed = 7) {
+    const rnd = mulberry32(seed);
+    const tokens = NAMES.map((n, i) => makeToken(rnd, n, i));
+    tokens.sort((a, b) => b.vol24 - a.vol24);
+    const newPairs = NEWPAIR_NAMES.map((n, i) => makeToken(rnd, n, 100 + i, { fresh: true }));
+    newPairs.forEach((p, k) => { p.ageMin = (k + 1) * (0.4 + rnd() * 1.6); });
+    const NOTES = ['thesis: CT rotation into cats', 'dev doxxed, LP burned', 'wait for retest of 1.2M', 'watch holder growth', 'claude flagged: wash vol', 'ATH breakout candidate'];
+    const watch = [tokens[1], tokens[4], tokens[7], tokens[12], newPairs[1], tokens[20]].map((t, i) => ({
+        token: t,
+        added: Math.floor(60 + rnd() * 3000),
+        entry: t.price / (1 + (rnd() - 0.35) * 0.8),
+        note: NOTES[i % NOTES.length],
+        alerts: [],
+    }));
+    const alerts = [
+        { ago: 0.3, kind: 'price', text: `${tokens[1].symbol} crossed +25% 1h (now ${fmtPctRaw(tokens[1].chg.h1)})`, level: 'up' },
+        { ago: 2.1, kind: 'holders', text: `${tokens[4].symbol} holders +312 in 10m (velocity 3.4x)`, level: 'info' },
+        { ago: 5.8, kind: 'risk', text: `${newPairs[1].symbol} dev wallet sold 60% of allocation`, level: 'down' },
+        { ago: 9.4, kind: 'migration', text: `${newPairs[3].symbol} graduated pump.fun → PumpSwap`, level: 'info' },
+        { ago: 14, kind: 'smart', text: `smart wallet 7xKp…q3Lm bought ${tokens[7].symbol} $12.4K`, level: 'up' },
+        { ago: 22, kind: 'ai', text: `claude: ${tokens[12].symbol} thesis invalidated (liq -40%)`, level: 'ai' },
+        { ago: 31, kind: 'price', text: `${tokens[20].symbol} -18% 5m, sell wall at $0.0042`, level: 'down' },
+    ];
+    const sol = { price: 120.73, chg24: -0.67 };
+    return { tokens, newPairs, watch, alerts, sol, seed };
+}
+function fmtPctRaw(n) { return (n > 0 ? '+' : '') + n.toFixed(1) + '%'; }
+/** Fixture analyst transcript for the token detail panel (what `claude -p` would return after tool calls). */
+export function aiTranscript(token) {
+    const s = token.symbol;
+    const verdict = token.org > 60 && token.top10 < 25 && !token.mintAuth ? 'watch' : token.flags.length >= 2 ? 'avoid' : 'speculative';
+    const lines = [];
+    lines.push({ role: 'user', text: `is $${s} worth a position here? what would invalidate it?` });
+    lines.push({ role: 'tool', text: `get_token(${s}) 84ms · get_holders(top=20) 131ms · get_trades(1h) 97ms · rugcheck 210ms` });
+    lines.push({ role: 'ai', verdict, text: verdictLine(verdict, token) });
+    lines.push({ role: 'ai', bullets: [
+            `${token.org >= 60 ? 'Organic score ' + token.org + '/100, real buyers outnumber bots' : 'Organic score ' + token.org + '/100: most volume looks automated'}`,
+            `Top 10 hold ${token.top10.toFixed(1)}% ${token.top10 > 30 ? '(concentrated, one wallet can nuke it)' : '(acceptable spread)'}`,
+            `${token.holders24 >= 0 ? '+' : ''}${token.holders24} holders 24h vs ${fmtK(token.vol24)} volume: ${token.holders24 > 0 ? 'accumulation' : 'distribution'} pattern`,
+            `Dev: ${token.devHistory.launches} prior launches, ${token.devHistory.rugged} rugged, holds ${token.dev.toFixed(2)}%`,
+            token.mintAuth ? 'Mint authority still enabled. Hard no until revoked.' : `Mint/freeze revoked, LP ${token.lpLocked}% locked`,
+        ] });
+    lines.push({ role: 'ai', text: `Invalidation: liquidity below ${fmtK(token.liq * 0.6)} or top-10 above 35%. I set two alerts for that. I don't trade; say "quote 0.5 SOL" and I'll show the Jupiter route for you to confirm.` });
+    lines.push({ role: 'user', text: `compare to the other cat coins in the screener` });
+    lines.push({ role: 'tool', text: `screener_query(filter="cat", sort=vol24) 42ms` });
+    lines.push({ role: 'ai', text: `3 matches. $${s} has the best organic/volume ratio but the thinnest liquidity of the three; CATWIF has 2.1x the holder growth. Want the comparison table?` });
+    return lines;
+}
+function verdictLine(v, t) {
+    if (v === 'watch')
+        return `Lean watch. Setup is decent: ${t.chg.h24 >= 0 ? 'momentum is positive' : 'pulling back on light volume'} and the on-chain basics check out.`;
+    if (v === 'avoid')
+        return `Avoid for now. ${t.flags.length} risk flags (${t.flags.join(', ')}) and the holder structure is fragile.`;
+    return `Speculative. Nothing disqualifying on-chain, but the activity is thin and the chart is mostly noise.`;
+}
+function fmtK(n) { return n >= 1e6 ? `$${(n / 1e6).toFixed(1)}M` : `$${(n / 1e3).toFixed(0)}K`; }
+const SPAWN_NAMES = [['WAGMI', 'we are all gonna make it', 'pump.fun'], ['JEET', 'jeet detector', 'pump.fun'], ['NGMI', 'ngmi club', 'dbc'], ['COPIUM', 'copium inhaler', 'bonk'], ['REKT', 'rekt capital', 'pump.fun']];
+/** Demo event: a brand-new pair lands at the top of the feed (fires the new-pair glitch in the loop). */
+export function spawnPair(fx, rnd) {
+    const n = SPAWN_NAMES[Math.floor(rnd() * SPAWN_NAMES.length)];
+    const p = makeToken(rnd, n, 200 + fx.newPairs.length, { fresh: true });
+    p.ageMin = 0.15;
+    p.bonding = 3 + rnd() * 10;
+    fx.newPairs.unshift(p);
+    fx.newPairs.pop();
+    return p;
+}
+/** Demo event: force a pump (pct > 0) or a dump on a token. Mutates price/changes/candles/tape so every widget reacts. */
+export function shock(tk, pct, rnd) {
+    const j = pct / 100;
+    tk.price *= 1 + j;
+    tk.mcap *= 1 + j;
+    tk.chg.m5 += pct * 0.8;
+    tk.chg.h1 += pct * 0.6;
+    tk.chg.h24 += pct * 0.4;
+    tk.spark.push(tk.price);
+    tk.spark.shift();
+    // spread the move over the last three candles so the chart scale survives (one giant candle looks like a bug)
+    const n = tk.candles.length;
+    const steps = [0.35, 0.7, 1];
+    let prevClose = tk.candles[n - 4].c;
+    for (let i = 0; i < 3; i++) {
+        const k = tk.candles[n - 3 + i];
+        const close = prevClose * (1 + j * (steps[i] - (i ? steps[i - 1] : 0)));
+        k.o = prevClose;
+        k.c = close;
+        k.h = Math.max(k.o, k.c) * 1.01;
+        k.l = Math.min(k.o, k.c) * 0.99;
+        k.v *= 1.4 + i * 0.3;
+        prevClose = close;
+    }
+    tk.candles[n - 1].c = tk.price;
+    tk.candles[n - 1].h = Math.max(tk.candles[n - 1].h, tk.price);
+    tk.candles[n - 1].l = Math.min(tk.candles[n - 1].l, tk.price);
+    const side = pct > 0 ? 'buy' : 'sell';
+    for (let i = 0; i < 4; i++)
+        tk.trades.unshift({ ago: i * 2, side, usd: 800 + rnd() * 9000, price: tk.price * (1 + (rnd() - 0.5) * 0.01), addr: tk.trades[i].addr, tag: i === 0 ? 'smart' : '' });
+    tk.trades.length = 24;
+    if (pct > 0)
+        tk.buys += 4;
+    else
+        tk.sells += 4;
+}
+/** Advance prices by a small jitter so the interactive demo feels alive. */
+export function tick(fx, rnd) {
+    for (const t of [...fx.tokens, ...fx.newPairs]) {
+        const j = (rnd() - 0.5) * (t.bonding != null ? 0.03 : 0.008);
+        t.price *= 1 + j;
+        t.mcap *= 1 + j;
+        t.chg.m5 += j * 100 * 0.5;
+        t.chg.h1 += j * 100 * 0.3;
+        t.spark.push(t.price);
+        t.spark.shift();
+        const last = t.candles[t.candles.length - 1];
+        last.c = t.price;
+        last.h = Math.max(last.h, t.price);
+        last.l = Math.min(last.l, t.price);
+        if (rnd() < 0.2) {
+            t.buys += 1;
+            t.vol24 += 50 + rnd() * 900;
+        }
+        if (rnd() < 0.12) {
+            t.sells += 1;
+        }
+        if (t.bonding != null)
+            t.bonding = Math.min(100, t.bonding + j * 50);
+    }
+    for (const p of fx.newPairs)
+        p.ageMin += 1 / 120;
+    for (const a of fx.alerts)
+        a.ago += 1 / 120;
+}

package/dist/packages/cli/src/follow-cmd.js

@@ -0,0 +1,221 @@
+// `dexterm follow …` — the copy-trading follow list from a shell (task-1360 Tier 1).
+//
+//   dexterm follow add <addr> [--name LABEL]     follow a wallet (label = your own words, firewalled, local only)
+//   dexterm follow remove <addr>
+//   dexterm follow list [--json]
+//   dexterm follow stats <addr> [--json]         one history fetch (Helius, 10 credits): trades, FIFO PnL, win rate (n)
+//   dexterm follow trades <addr> [--limit N]     the decoded swaps behind the stats
+//   dexterm follow purge --yes                   delete every follow and label (the local label store is deletable)
+//   dexterm follow auto <addr> [--per-trade USD] [--daily USD] [--max-open N] [--cooldown SEC] [--k X] [--disarm N]
+//                                               draft the auto-mirror caps (clamped down to the hard ceilings; auto stays OFF —
+//                                               enabling is a keypress in the app after the less-safe popup) · --off turns it off
+//   dexterm follow auto                          list the auto policies and their state
+//
+// Self-directed only: your list, your wallet, your keys. Nothing here trades, proposes or signs; `stats` needs a free
+// Helius key (keyless prints the fix) and reads public history. Secrets never print: the RPC URL stays inside the
+// data layer.
+import { createDataLayer, resolveRpcUrl, HeliusHistory } from '../../data/src/index.js';
+import { FollowStore, WalletTracker, defaultFollowsPath, isWalletAddress, shortAddr, CopyAuto, defaultCopyJournalPath, AUTO_HARD, autoSizeCap } from '../../data/src/trade/copy/index.js';
+import { PlanService, defaultPlansJournalPath } from '../../data/src/trade/plans/index.js';
+function flag(rest, name) { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : undefined; }
+function has(rest, name) { return rest.includes(name); }
+const USAGE = `dexterm follow <command>
+  add <addr> [--name LABEL]        follow a wallet (your own label, never inferred, local only)
+  remove <addr>
+  list [--json]
+  stats <addr> [--json]            one Helius history fetch: trades, FIFO realised PnL, win rate (hidden under n=10)
+  trades <addr> [--limit N]        the decoded swaps behind the stats
+  purge --yes                      delete every follow and label
+  auto <addr> [--per-trade USD] [--daily USD] [--max-open N] [--cooldown SEC] [--k X] [--disarm N] [--off]
+                                   draft the auto-mirror caps (always OFF here: enabling is a keypress in the app, U then A,
+                                   after the "less safe" popup) · --off turns a running policy off · no addr = list
+self-directed only: your list, your wallet, your keys · nothing here trades or signs`;
+function fmtStats(s) {
+    const out = [
+        `${shortAddr(s.wallet)}  ${s.trades} trades (${s.buys} buys · ${s.sells} sells · ${s.transfers} transfers) over ${s.mints} mints · ${s.sample.note}`,
+        `realised ${s.realisedSol >= 0 ? '+' : ''}${s.realisedSol.toFixed(4)} SOL${s.realisedUsd !== null ? ` (${s.realisedUsd >= 0 ? '+' : ''}$${s.realisedUsd.toFixed(2)} at $${s.solUsdAt}/SOL now)` : ' (no SOL price: USD not shown)'} · FIFO over fetched history, fees and tips included`,
+        `win rate ${s.winRate === null ? '—' : `${(s.winRate * 100).toFixed(0)}%`} · ${s.winRateNote} · open positions ${s.open}`,
+        `early-entry score ${s.earlyEntry.score === null ? '—' : s.earlyEntry.score.toFixed(2)} · ${s.earlyEntry.note}`,
+    ];
+    for (const p of s.positions.slice(0, 12))
+        out.push(`  ${shortAddr(p.mint)}  ${p.closed ? 'closed' : 'open  '}  realised ${p.realisedSol >= 0 ? '+' : ''}${p.realisedSol.toFixed(4)} SOL  ${p.buys}b/${p.sells}s${p.flagged ? '  (cost-0 lot: airdrop/transfer/unpriced leg)' : ''}`);
+    if (s.positions.length > 12)
+        out.push(`  … ${s.positions.length - 12} more mints`);
+    out.push('not a recommendation · a wallet\'s past fills say nothing about its next one');
+    return out;
+}
+export async function runFollow(rest, io, over = {}) {
+    const cmd = rest[0];
+    const out = (s) => io.stdout.write(s + '\n');
+    const errOut = (s) => io.stderr.write(s + '\n');
+    const store = new FollowStore({ path: over.followsPath === undefined ? defaultFollowsPath(io.env) : over.followsPath });
+    switch (cmd) {
+        case 'add': {
+            const addr = rest[1];
+            if (!addr || addr.startsWith('--')) {
+                errOut('usage: dexterm follow add <addr> [--name LABEL]');
+                return 2;
+            }
+            const r = store.add(addr, flag(rest, '--name'));
+            if (!r.ok) {
+                errOut(`dexterm follow add: ${r.reason}`);
+                return 1;
+            }
+            out(`following ${shortAddr(r.follow.addr)}${r.follow.name ? ` as "${r.follow.name}"` : ''} · ${store.list().length} followed · alerts show in the app (U)`);
+            return 0;
+        }
+        case 'remove': {
+            const addr = rest[1];
+            if (!addr) {
+                errOut('usage: dexterm follow remove <addr>');
+                return 2;
+            }
+            out(store.remove(addr) ? `unfollowed ${shortAddr(addr)}` : `${shortAddr(addr)} was not followed`);
+            return 0;
+        }
+        case 'list': {
+            const rows = store.list();
+            if (has(rest, '--json')) {
+                out(JSON.stringify(rows));
+                return 0;
+            }
+            if (!rows.length) {
+                out('no wallets followed · dexterm follow add <addr> [--name LABEL]');
+                return 0;
+            }
+            for (const f of rows)
+                out(`${f.addr}  ${f.name ?? '—'}  since ${new Date(f.since).toISOString().slice(0, 10)}`);
+            return 0;
+        }
+        case 'auto': {
+            const addr = rest[1] && !rest[1].startsWith('--') ? rest[1] : null;
+            const plans = new PlanService({ journalPath: over.plansJournalPath === undefined ? defaultPlansJournalPath(io.env) : over.plansJournalPath });
+            const auto = new CopyAuto({ plans, journalPath: over.copyJournalPath === undefined ? defaultCopyJournalPath(io.env) : over.copyJournalPath, market: async () => null, isFollowed: (w) => store.has(w) });
+            if (!addr) {
+                const pols = auto.list();
+                if (has(rest, '--json')) {
+                    out(JSON.stringify(pols));
+                    return 0;
+                }
+                if (!pols.length) {
+                    out('no auto-mirror policies · dexterm follow auto <addr> --per-trade 20 --daily 100');
+                    return 0;
+                }
+                for (const p of pols)
+                    out(`${p.wallet}  ${p.enabled ? 'ON ' : 'off'}  ≤ $${autoSizeCap(p).toFixed(2)}/mirror (¼ of $${Math.min(p.perTradeUsd, p.dailyUsd)})  $${p.dailyUsd}/day  max ${p.maxOpen} open  ${Math.round(p.cooldownMs / 1000)} s cooldown  k=${p.k}  disarm@${p.autoDisarmStreak}${p.offReason ? `  (${p.offReason})` : ''}`);
+                out('auto is OFF in every fresh process; enable it in the app: U → A (needs the less-safe popup, G on the O screen)');
+                return 0;
+            }
+            if (!isWalletAddress(addr)) {
+                errOut('usage: dexterm follow auto <addr> [caps…] [--off]');
+                return 2;
+            }
+            if (!store.has(addr)) {
+                errOut(`dexterm follow auto: ${shortAddr(addr)} is not followed (dexterm follow add <addr> first)`);
+                return 1;
+            }
+            if (has(rest, '--off')) {
+                const p = auto.disable(addr, 'user (cli)');
+                out(p ? `auto-mirror off for ${shortAddr(addr)}` : 'no policy for that wallet');
+                return 0;
+            }
+            const sec = flag(rest, '--cooldown');
+            try {
+                const p = auto.draft(addr, {
+                    perTradeUsd: flag(rest, '--per-trade') ? Number(flag(rest, '--per-trade')) : undefined,
+                    dailyUsd: flag(rest, '--daily') ? Number(flag(rest, '--daily')) : undefined,
+                    maxOpen: flag(rest, '--max-open') ? Number(flag(rest, '--max-open')) : undefined,
+                    cooldownMs: sec ? Number(sec) * 1000 : undefined,
+                    k: flag(rest, '--k') ? Number(flag(rest, '--k')) : undefined,
+                    autoDisarmStreak: flag(rest, '--disarm') ? Number(flag(rest, '--disarm')) : undefined,
+                });
+                if (has(rest, '--json')) {
+                    out(JSON.stringify(p));
+                    return 0;
+                }
+                out(`auto-mirror caps for ${shortAddr(addr)}: ≤ $${autoSizeCap(p).toFixed(2)} per mirror (¼ of the $${Math.min(p.perTradeUsd, p.dailyUsd)} per-trade cap, hands-free tier) · $${p.dailyUsd}/day · max ${p.maxOpen} open · ${Math.round(p.cooldownMs / 1000)} s cooldown · k=${p.k} · auto-disarm after ${p.autoDisarmStreak} refused/failed · ceilings $${AUTO_HARD.perTradeUsd}/trade $${AUTO_HARD.dailyUsd}/day`);
+                out('status: OFF · enable in the app with a keypress: U → A (after the "less safe" popup, G on the O screen) · mirror-sell is not built');
+                return 0;
+            }
+            catch (e) {
+                errOut(`dexterm follow auto: ${e instanceof Error ? e.message : String(e)}`);
+                return 1;
+            }
+        }
+        case 'purge': {
+            if (!has(rest, '--yes')) {
+                errOut('dexterm follow purge: add --yes to delete every follow and label');
+                return 2;
+            }
+            out(`purged ${store.purge()} follow(s) and their labels`);
+            return 0;
+        }
+        case 'stats':
+        case 'trades': {
+            const addr = rest[1];
+            if (!isWalletAddress(addr)) {
+                errOut(`usage: dexterm follow ${cmd} <addr>`);
+                return 2;
+            }
+            let dl = null;
+            let history;
+            if (over.history !== undefined)
+                history = over.history;
+            else {
+                const rpc = resolveRpcUrl({ env: io.env });
+                if (rpc.provider !== 'helius')
+                    history = null;
+                else {
+                    dl = createDataLayer({ rpcUrl: rpc.url, rpcFallbackUrl: rpc.fallbackUrl });
+                    history = dl.rpcPool.heliusUrl ? new HeliusHistory(dl.http, dl.rpcPool.heliusUrl) : null;
+                }
+            }
+            try {
+                const scratch = new FollowStore();
+                scratch.add(addr);
+                const tracker = new WalletTracker({ follows: scratch, history, solUsd: () => over.solUsd ?? null });
+                const st = tracker.status();
+                if (st.state === 'unavailable') {
+                    errOut(`dexterm follow ${cmd}: ${st.why}`);
+                    return 1;
+                }
+                await tracker.pollOnce();
+                const after = tracker.status();
+                if (after.state === 'degraded') {
+                    errOut(`dexterm follow ${cmd}: ${after.why}`);
+                    return 1;
+                }
+                if (cmd === 'stats') {
+                    const s = tracker.stats(addr);
+                    if (has(rest, '--json')) {
+                        out(JSON.stringify({ ...s, positions: s.positions.map((p) => ({ ...p, tokensRaw: p.tokensRaw.toString(), peakRaw: p.peakRaw.toString() })) }));
+                        return 0;
+                    }
+                    for (const line of fmtStats(s))
+                        out(line);
+                    return 0;
+                }
+                const limit = Number(flag(rest, '--limit') ?? 20);
+                const trades = tracker.trades(addr).slice(0, Number.isFinite(limit) && limit > 0 ? limit : 20);
+                if (!trades.length) {
+                    out('no swaps in the fetched history');
+                    return 0;
+                }
+                for (const tr of trades)
+                    out(`${tr.tKnown ? new Date(tr.t).toISOString().replace('T', ' ').slice(0, 19) : 'time unknown      '}  ${tr.side.toUpperCase().padEnd(8)} ${shortAddr(tr.mint)}  ${tr.solDelta !== null ? `${Math.abs(tr.solDelta).toFixed(4)} SOL` : 'unpriced   '}${tr.usd !== null ? ` ≈ $${tr.usd.toFixed(2)}` : ''}${tr.note ? `  (${tr.note})` : ''}  ${tr.sig.slice(0, 12)}…`);
+                return 0;
+            }
+            finally {
+                dl?.close();
+            }
+        }
+        default:
+            if (cmd) {
+                errOut(`dexterm follow: unknown subcommand ${JSON.stringify(cmd)}`);
+                errOut(USAGE);
+                return 2;
+            }
+            out(USAGE);
+            return 0;
+    }
+}

package/dist/packages/cli/src/images-config.js

@@ -0,0 +1,59 @@
+// dexterm — coin-image settings (task-1326). Three layers, strongest last: the file ~/.dexterm/images.json
+// (DEXTERM_HOME overrides the directory, same as popup.json / state.json), the DEXTERM_IMAGES environment
+// variable, and the --no-images flag. A missing or malformed file degrades to the defaults and never throws.
+//
+//   images.json: { "enabled": true, "blocks": "half" | "quad", "protocol": "auto" | "kitty" | "iterm" | "sixel" | "blocks",
+//                  "thumbMax": 96, "diskMb": 32, "replay": false }
+//   DEXTERM_IMAGES=0|off|false   images off      DEXTERM_IMAGES=kitty|iterm|sixel|blocks   force a protocol
+//   A --replay / DEXTERM_OFFLINE run has no network, so images there could only come from the disk cache: they stay
+//   OFF unless `replay: true` in the file or DEXTERM_IMAGES says on — recordings keep rendering exactly as recorded.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { dextermHome } from "./boot-state.js";
+export const DEFAULT_IMAGES_CONFIG = { enabled: true, blocks: 'half', protocol: 'auto', thumbMax: 96, diskMb: 32, replay: false, source: 'defaults' };
+export function imagesConfigPath(env = process.env) { return join(dextermHome(env), 'images.json'); }
+export function normalizeImagesConfig(raw, source = 'file') {
+    const o = (raw && typeof raw === 'object' ? raw : {});
+    const num = (v, lo, hi, d) => (typeof v === 'number' && Number.isFinite(v) ? Math.max(lo, Math.min(hi, v)) : d);
+    const protocol = typeof o.protocol === 'string' && ['auto', 'kitty', 'iterm', 'sixel', 'blocks'].includes(o.protocol) ? o.protocol : 'auto';
+    return {
+        enabled: typeof o.enabled === 'boolean' ? o.enabled : true,
+        blocks: o.blocks === 'quad' ? 'quad' : 'half',
+        protocol,
+        thumbMax: Math.round(num(o.thumbMax, 32, 192, DEFAULT_IMAGES_CONFIG.thumbMax)),
+        diskMb: Math.round(num(o.diskMb, 4, 512, DEFAULT_IMAGES_CONFIG.diskMb)),
+        replay: o.replay === true,
+        source,
+    };
+}
+/** The file's settings, or the defaults. Never throws. */
+export function loadImagesConfig(env = process.env) {
+    try {
+        return normalizeImagesConfig(JSON.parse(readFileSync(imagesConfigPath(env), 'utf8')), 'file');
+    }
+    catch {
+        return { ...DEFAULT_IMAGES_CONFIG };
+    }
+}
+/** File → env → flag. `noImagesFlag` is `--no-images`; `offline` = a --replay / DEXTERM_OFFLINE run (cache only). */
+export function resolveImagesConfig(env, noImagesFlag, opts = {}) {
+    const out = { ...(opts.file ?? loadImagesConfig(env)) };
+    const e = (env.DEXTERM_IMAGES || '').trim().toLowerCase();
+    let explicitOn = false;
+    if (e === '0' || e === 'off' || e === 'false' || e === 'no')
+        out.enabled = false;
+    else if (e === '1' || e === 'on' || e === 'true' || e === 'yes') {
+        out.enabled = true;
+        explicitOn = true;
+    }
+    else if (e === 'kitty' || e === 'iterm' || e === 'sixel' || e === 'blocks') {
+        out.enabled = true;
+        out.protocol = e;
+        explicitOn = true;
+    }
+    if (opts.offline && !out.replay && !explicitOn)
+        out.enabled = false;
+    if (noImagesFlag)
+        out.enabled = false;
+    return out;
+}

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

@@ -0,0 +1,31 @@
+// dexterm — library surface of the CLI package (used by tests and tools).
+export * from "./state.js";
+export * from "./fixtures.js";
+export { parseArgs, stateFromArgs, applyScreenerArgs, applyEffectArgs, applyAction, applyAnalystAction, applyKey, colorDepthFor, intensityFor, asciiRainFor, fpsFor, demoEvent, main, interactive, terminalGuard, describeError, buildScreenState, HELP, LIVE_REFRESH_MS, FPS_BY_INTENSITY, MAX_FPS, DEMO_KEYS, } from "./main.js";
+export { AnalystSession, parseResults, parseFilterApplied } from "./analyst/session.js";
+export { resolveAnalystResults } from "./analyst/results.js";
+export { runAnalyst, buildArgv, turnPrompt, analystContextBlock, untrusted, ASSETS as ANALYST_ASSETS, MCP_BIN } from "./analyst/backend.js";
+export { renderAnalystSession } from "./screens/analyst-session.js";
+export * from "./boot-state.js";
+export * from "./doctor.js";
+export { renderOverlay, renderGotoPrompt, OVERLAY_HINTS, helpRows } from "./screens/overlay.js";
+export * from "./audit.js";
+export { renderBoot } from "./screens/boot.js";
+export { renderScreener, screenerColumns, spotlight, COLUMN_GATE } from "./screens/screener.js";
+export { renderToken, analystPanel } from "./screens/token.js";
+export { renderNewPairs } from "./screens/newpairs.js";
+export { renderWatchlist } from "./screens/watchlist.js";
+export { renderAnalyst, renderContextRail, renderCoinList } from "./screens/analyst.js";
+export { renderTicket } from "./screens/ticket.js";
+export { renderPositions } from "./screens/positions.js";
+export * from "./trade.js";
+export { TradeTicketLive, PositionsLive, LivePositions, CombinedPositions, POSITIONS_REFRESH_MS } from "./live/trade.js";
+export { parseWalletCommand, WALLET_HELP } from "./wallet-command.js";
+export * from "./screener/filter.js";
+export * from "./screener/sort.js";
+export * from "./screener/presets.js";
+export * from "./screener/view.js";
+export { fromFixture, fromSnapshot, deriveFlags, impliedSpark, cleanText } from "./screener/rows.js";
+export * from "./feed.js";
+export * from "./images-config.js";
+export { drawCoin, imagesOn, popupImagePath } from "./screens/coin.js";