dexterm-cli 0.1.5 → 0.1.7

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

@@ -2,20 +2,21 @@
 // run, created over the screener feed's data layer so every screen shares the cache, limiter, health
 // registry and (when the Helius key is configured) the credit meter. Screens stay pure renderers: the
 // context owns the loaders and tells the UI loop when to redraw.
-import { PumpPortalClient, PUMPPORTAL_WS, WatchlistStore, PaperWallet, PaperExecutor, FastLane, WalletLinkStore, WalletBridge, KillSwitch, CapLedger, SignerClient, defaultLiveLedgerPath, defaultLinkPath, defaultPanicPath, defaultCapLedgerPath, shortPubkey, } from '../../../data/src/index.js';
+import { PumpPortalClient, PUMPPORTAL_WS, WatchlistStore, PaperWallet, PaperExecutor, FastLane, WalletLinkStore, WalletBridge, KillSwitch, defaultLinkPath, defaultPanicPath, shortPubkey, } from '../../../data/src/index.js';
 import { SocialFeed, KolStore, socialDeps, chainSignalsFromToken, chainSignalsFromIntel, chainSignalToRaw, RSS_FEEDS, JUPITER_HOSTS } from '../../../data/src/index.js';
 import { XSource, XApi, XOAuth, XTokenStore, XSpendMeter } from '../../../data/src/index.js';
 import { TokenLive, INTERVALS } from "./token.js";
 import { NewPairsLive } from "./newpairs.js";
 import { WatchlistLive } from "./watchlist.js";
-import { TradeTicketLive, PositionsLive, LivePositions, CombinedPositions, POSITIONS_REFRESH_MS } from "./trade.js";
+import { TradeTicketLive, PositionsLive, POSITIONS_REFRESH_MS } from "./trade.js";
 import { IntelLive } from "./intel.js";
 import { LiveSignalsLive } from "./signals.js";
 import { CopyLive } from "./copy.js";
+import { ChartFills } from "./chart-fills.js";
 export { TokenLive, INTERVALS, panelCaption, emptyView } from "./token.js";
 export { NewPairsLive, latencyStats, percentile, RECENT_POLL_MS, NEW_TOKENS_POLL_MS, ENRICH_POLL_MS } from "./newpairs.js";
 export { WatchlistLive, WATCH_REFRESH_MS } from "./watchlist.js";
-export { TradeTicketLive, PositionsLive, LivePositions, CombinedPositions, POSITIONS_REFRESH_MS } from "./trade.js";
+export { TradeTicketLive, PositionsLive, POSITIONS_REFRESH_MS } from "./trade.js";
 export { IntelLive, popupBubbleVM, unavailableText, INTEL_AUTOSCAN_DELAY_MS } from "./intel.js";
 export { LiveSignalsLive, buildObservation, SIGNALS_LOG_MAX } from "./signals.js";
 export { renderTokenLive } from "./screens/token-live.js";
@@ -37,17 +38,14 @@ export class LiveContext {
     watch;
     /** PAPER trading (task-1310): the simulated wallet, its executor and the two screens' bindings. */
     wallet;
-    /** The linked (non-custodial) wallet pubkey, or null. Shown in the status bar (T1). */
+    /** The linked wallet's PUBLIC key, or null. Shown in the status bar (display only; nothing signs with it). */
     linkedWallet = null;
     executor;
     positions;
-    /** LIVE positions from the signer's ledger file (read-only); null when live trading is off for this run. */
-    livePositions;
-    /** Paper + live behind the task-1323 PositionSource (token screen row, popup chart). */
+    /** The paper ledger behind the task-1323 PositionSource (token screen row, popup chart). */
     positionSource;
-    /** The signer process handle once started (lazily, on the first LIVE action). Never respawned. */
-    signer = null;
-    signerFailed = null;
+    /** task-1483: every paper fill per mint (memoised 1 s) for the chart BUY/SELL markers. */
+    chartFills;
     trade;
     linkStore;
     ticket = null;
@@ -68,8 +66,8 @@ export class LiveContext {
     /** task-1360 copy trading Tier 1: the follow store + wallet tracker (alerts on a followed wallet's buys/sells). */
     copy;
     /**
-     * task-1340 trade moments: set by the UI loop; the ticket calls it once per SETTLED outcome (paper fill, live
-     * fill, refusal, failure) and never for a quote, plan or in-flight send. Effects + sound hang off this only.
+     * task-1340 trade moments: set by the UI loop; the ticket calls it once per SETTLED outcome (paper fill or
+     * failure) and never for a quote or an in-flight fill. Effects + sound hang off this only.
      */
     onSettled = () => { };
     /**
@@ -173,12 +171,8 @@ export class LiveContext {
         this.linkedWallet = this.linkStore.get();
         this.executor = new PaperExecutor(this.wallet, { clock: dl.clock });
         this.positions = new PositionsLive(dl, this.wallet, { now: this.now, onChange: () => emit('positions') });
-        // task-1328: live positions read the signer's ledger file (read-only). Present whenever live trading
-        // is configured for the run, so a position booked by a previous run shows even before the signer starts.
-        this.livePositions = this.trade
-            ? new LivePositions(this.trade.paths?.liveLedger ?? defaultLiveLedgerPath(), { now: this.now, mark: (m) => this.positions.markOf(m), solUsd: () => this.positions.solUsd() ?? this.solUsd })
-            : null;
-        this.positionSource = new CombinedPositions(this.positions, this.livePositions);
+        this.positionSource = this.positions;
+        this.chartFills = new ChartFills({ paper: (n) => this.wallet.trades(n) }, this.now);
         this.intel = new IntelLive(dl, { now: this.now, onChange: () => { this.syncIntelRows(); this.observeSignals(); emit('intel'); }, isWatched: (mint) => this.watch.has(mint) });
         // task-1404: the live holder/rug signals engine. A fired signal sets a transient notice and redraws; the
         // token screen shows the recent signals, and the rules engine reads `signals.fields()` so each is an alert trigger.
@@ -186,64 +180,33 @@ export class LiveContext {
         // task-1360: followed wallets are polled only in a real live run (replay never spends credits); the store is always readable.
         this.copy = new CopyLive(opts.mode === 'live' ? dl : null, { onChange: (r) => emit(r), solUsd: () => this.solUsd, env: opts.copy?.env, followsPath: opts.copy?.followsPath, history: opts.copy?.history, pollMs: opts.copy?.pollMs });
     }
-    /** Open a trade ticket (PAPER by default; `L` flips it LIVE when a wallet is linked). Replaces any open ticket. */
-    openTicket(seed, side, mode = 'paper') {
-        const live = this.trade ? {
-            signer: () => this.ensureSigner(),
-            linked: () => this.linkedWallet,
-            onFill: () => { this.livePositions?.invalidate(); this.onChange('positions'); },
-        } : undefined;
+    /** Open a PAPER trade ticket. Replaces any open ticket. */
+    openTicket(seed, side) {
         const t = new TradeTicketLive(this.dl, this.wallet, this.executor, { mint: seed.mint, symbol: seed.symbol, decimals: seed.decimals, side, mode: 'paper' }, {
-            now: this.now, onChange: () => this.onChange('ticket'), live, onSettled: (tx) => this.onSettled(tx),
-            livePositionRaw: (mint) => { const p = this.livePositions?.positions().find((x) => x.mint === mint); return p?.tokensRaw ?? 0n; },
+            now: this.now, onChange: () => this.onChange('ticket'), onSettled: (tx) => this.onSettled(tx),
         });
         this.ticket = t;
-        if (mode === 'live')
-            t.setMode('live');
         return t;
     }
-    /**
-     * The signer process (task-1328), started on first use with the run's caps argv. A signer that
-     * failed to start or died is never respawned: LIVE stays off until dexterm restarts (fail closed).
-     */
-    ensureSigner() {
-        if (!this.trade || this.signerFailed)
-            return this.signer;
-        if (!this.signer) {
-            try {
-                this.signer = this.trade.createSigner ? this.trade.createSigner() : new SignerClient({ argv: this.trade.signerArgv ?? [], log: this.onLog ? (l) => this.onLog?.(`  signer        ${l}\n`) : undefined });
-            }
-            catch (e) {
-                this.signerFailed = e instanceof Error ? e.message : String(e);
-                return null;
-            }
-        }
-        return this.signer;
-    }
     /** `/wallet …` typed in the app (task-1328). Returns the line to show. */
     async walletCommand(cmd) {
         const paths = this.trade?.paths ?? {};
         switch (cmd) {
             case 'status': {
-                const linked = this.linkedWallet ? `linked: ${shortPubkey(this.linkedWallet.publicKey)}` : 'no wallet linked (/wallet link)';
+                const linked = this.linkedWallet ? `linked: ${shortPubkey(this.linkedWallet.publicKey)} (public key only)` : 'no wallet linked (/wallet link)';
                 const ks = new KillSwitch(paths.panic ?? defaultPanicPath()).engaged();
-                const s = this.signer?.alive ? await this.signer.status().catch(() => null) : null;
-                if (s) {
-                    const caps = s.caps;
-                    return `${linked} · signer ${s.network.toUpperCase()} (${s.rpcHost}) · $${caps.perTradeUsd}/trade $${caps.dailyUsd}/day · spent $${s.spentTodayUsd.toFixed(2)}${s.panic || s.ledgerLocked ? ' · ⛔ PANICKED' : ''}`;
-                }
-                return `${linked} · signer ${this.signer ? (this.signerFailed ?? 'stopped') : 'not started (starts on the first LIVE plan)'}${ks ? ' · ⛔ PANICKED' : ''}${this.trade ? '' : ' · live trading off in this run'}`;
+                return `${linked}${ks ? ' · ⛔ PANICKED' : ''} · dexterm holds no key and signs nothing`;
             }
             case 'link': {
                 if (!this.trade)
-                    return 'live trading is off in this run';
-                const bridge = new WalletBridge(this.trade.open ? { open: this.trade.open } : {});
+                    return 'wallet link is off in this run (replay / offline)';
+                const bridge = new WalletBridge(this.trade?.open ? { open: this.trade.open } : {});
                 try {
                     const res = await bridge.link();
-                    const rec = this.linkStore.set(res.publicKey, { network: 'devnet' });
+                    const rec = this.linkStore.set(res.publicKey);
                     this.linkedWallet = rec;
                     this.onChange('wallet');
-                    return `linked: ${shortPubkey(rec.publicKey)} (public key only) · L on a ticket for LIVE`;
+                    return `linked: ${shortPubkey(rec.publicKey)} (public key only; dexterm never signs with it)`;
                 }
                 catch (e) {
                     return `wallet link failed: ${e instanceof Error ? e.message : String(e)}`;
@@ -252,40 +215,15 @@ export class LiveContext {
             case 'unlink': {
                 const had = this.linkStore.clear();
                 this.linkedWallet = null;
-                if (this.ticket?.ticket.mode === 'live')
-                    this.ticket.setMode('paper');
                 this.onChange('wallet');
                 return had ? 'unlinked' : 'no wallet was linked';
             }
             case 'panic': {
-                // Local first (the kill-switch FILE every signer re-reads + the shared ledger lock), then the signer.
+                // The kill-switch FILE every autotrade runner and the paper agent desk re-read.
                 const ks = new KillSwitch(paths.panic ?? defaultPanicPath());
                 ks.engage('panic from dexterm UI', this.now());
-                try {
-                    const l = new CapLedger({ path: paths.capLedger ?? defaultCapLedgerPath(), clock: this.dl.clock });
-                    try {
-                        l.lock('panic from dexterm UI', this.now());
-                    }
-                    finally {
-                        l.close();
-                    }
-                }
-                catch { /* the file alone disables trading */ }
-                if (this.signer?.alive)
-                    await this.signer.panic('panic from dexterm UI').catch(() => { });
-                if (this.ticket?.ticket.mode === 'live') {
-                    this.ticket.ticket.phase = 'refused';
-                    this.ticket.ticket.message = '⛔ PANIC — live signing disabled';
-                }
                 this.onChange('wallet');
-                return '⛔ PANIC: live signing disabled everywhere · re-enable only from a shell: dexterm wallet resume';
-            }
-            case 'probe': {
-                if (!this.trade)
-                    return 'live trading is off in this run';
-                const t = this.openTicket({ mint: this.WSOL, symbol: 'SOL', decimals: 9 }, 'buy');
-                const why = t.startProbe();
-                return why ?? 'devnet probe: review the plan, then Y to sign the wrap-and-unwrap in Phantom (fees only)';
+                return '⛔ PANIC: autotrade runs and the paper agent desk halted · clear it only from a shell: dexterm wallet resume';
             }
         }
         return '';
@@ -332,13 +270,17 @@ export class LiveContext {
         }
         catch { /* keep the last value */ }
     }
-    /** The fast set = the open token first, then the watchlist (the fast lane caps and drops the rest). */
+    /** task-1473: a coin the followed agent holds (PAPER): kept in the fast set so its mark survives list changes. */
+    heldMint = null;
+    /** The fast set = the open token first, then a followed agent's held coin, then the watchlist (the fast lane caps and drops the rest). */
     syncFastSet() {
         if (!this.fastLane)
             return;
         const mints = [];
         if (this.token)
             mints.push(this.token.mint);
+        if (this.heldMint && !mints.includes(this.heldMint))
+            mints.push(this.heldMint);
         for (const e of this.watchStore.list())
             if (!mints.includes(e.mint))
                 mints.push(e.mint);
@@ -556,10 +498,6 @@ export class LiveContext {
             this.social.close();
         }
         catch { /* ignore */ }
-        try {
-            this.signer?.close();
-        }
-        catch { /* ignore */ }
         try {
             this.intel.close();
         }

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

@@ -125,7 +125,7 @@ export function renderNewPairsLive(c, state, live) {
             } },
     ];
     if (rows.length)
-        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows, selected: sel, scroll: 0, bg: box.bg });
+        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows, selected: sel, scroll: 0, bg: box.bg, rowKey: (r) => r.mint });
     else {
         const s = st.stream;
         const msg = st.mode === 'off' ? 'push feed off · r to poll jup recent' : s?.state === 'open' ? `connected to pumpportal · waiting for the first create (≈15/min measured)` : `pumpportal ${s?.state ?? 'connecting'}${s?.lastError ? ` · ${s.lastError}` : ''} · polling jup recent`;

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

@@ -14,11 +14,12 @@ import { renderScanWhy, renderScanTicker } from "../../scan/ui.js";
 import { drawCoin, imagesOn } from "../../screens/coin.js";
 import { COIN_HERO_W, COIN_HERO_H } from '../../../../tui/src/index.js';
 import { renderSocialPanel } from "../../screens/social-panel.js";
+import { brainFor, factsFromView, renderBrainPanel } from "../../screens/brain.js";
 import { launchIntelCells, holderTags } from "../intel.js";
 import { devBookOf, devRows } from "../dev-history.js";
 import { EX_POOL_TAGS } from '../../../../data/src/index.js';
 import { layoutFor } from "../../custom.js";
-import { chartMode, priceModeOf, mcapAt, positionPriceCells } from "../../display.js";
+import { chartMode, chartTitle, priceModeOf, chartAxisOf, chartMarkersOn, mcapAt, positionPriceCells, levelCell, supplyRatio } from "../../display.js";
 const dash = '—';
 const EX_POOL_TAG_SET = EX_POOL_TAGS;
 /** task-1367 holder-class badge colours: venues/escrows accent, the creator/linked warn, the rest muted. */
@@ -87,13 +88,13 @@ export function renderTokenLive(c, state, v) {
     const shownPx = livePx ?? v.price;
     // task-1366: mcap mode leads with the market cap (the live price × the polled supply ratio) and keeps the price beside it;
     // without a supply it shows the price and says so.
-    const cm = chartMode(priceModeOf(state), v.price, v.mcap);
-    if (cm.kind === 'mcap' && shownPx !== null) {
-        x = c.text(x0, y, fmtMcap(mcapAt(shownPx, cm.scale)), { fg: t.text, bg: t.bg, b: true });
+    const pm = chartMode(priceModeOf(state), v.price, v.mcap);
+    if (pm.kind === 'mcap' && shownPx !== null) {
+        x = c.text(x0, y, fmtMcap(mcapAt(shownPx, pm.scale)), { fg: t.text, bg: t.bg, b: true });
         x = c.text(x + 1, y, `(${fmtPrice(shownPx)})`, { fg: t.dim, bg: t.bg });
     }
     else
-        x = c.text(x0, y, shownPx === null ? dash : fmtPrice(shownPx), { fg: cm.label && shownPx !== null ? t.warn : t.text, bg: t.bg, b: true });
+        x = c.text(x0, y, shownPx === null ? dash : fmtPrice(shownPx), { fg: pm.label && shownPx !== null ? t.warn : t.text, bg: t.bg, b: true });
     if (state.live?.fastLane)
         x = badge(c, x + 1, y, liveBadge, liveBadge === 'LIVE' ? t.up : t.muted, { on: t.bg });
     const deltas = [['5m', v.chg.m5], ['1h', v.chg.h1], ['6h', v.chg.h6], ['24h', v.chg.h24]];
@@ -131,20 +132,28 @@ export function renderTokenLive(c, state, v) {
     const chartH = Math.max(10, Math.floor((bottom - y - posH) * lay.chartFrac));
     const cp = v.panels.candles;
     const chartCap = clip(cp.state === 'ok' || cp.fetchedAt !== null ? `ohlcv: geckoterminal${cp.stale || cp.state === 'error' ? ' · stale' : ''}` : panelCaption(cp, now, 'ohlcv unavailable'), 40);
-    const cb = c.box(0, y, mainW, chartH, { title: cm.label ? (cm.kind === 'mcap' ? `${v.symbol} ${cm.label} · ${v.interval}` : `${v.symbol}/USD · ${cm.label} · ${v.interval}`) : `${v.symbol}/USD · ${v.interval}`, caption: chartCap, captionFg: cp.state === 'error' && cp.fetchedAt === null ? t.warn : undefined });
+    // task-1472: the chart's Y axis is its own setting (default MARKET CAP, `A` toggles); the header above keeps `$`.
+    const cm = chartMode(chartAxisOf(state), v.price, v.mcap);
+    const cb = c.box(0, y, mainW, chartH, { title: chartTitle(v.symbol, v.interval, cm), caption: chartCap, captionFg: cp.state === 'error' && cp.fetchedAt === null ? t.warn : undefined });
     // timeframe tabs sit on the top border, left of the caption (same spot as the fixture screen)
     let tx = cb.x + cb.w - 2 - (chartCap.length + 4) - INTERVALS.reduce((s, f) => s + f.length + 1, 0);
     for (const f of INTERVALS)
         tx = c.text(tx, cb.y - 1, f, f === v.interval ? { fg: t.accent, bg: cb.bg, b: true } : { fg: t.dim, bg: cb.bg }) + 1;
+    // task-1483: BUY / SELL markers for every paper + live fill of this coin (the ledgers, no fetch) and the open position's
+    // average entry as a dashed line (the position row's own figure); `display.chartMarkers off` hides them.
+    const trades = chartMarkersOn(state) ? { fills: state.live?.chartFills?.for(v.mint) ?? [], avgEntry: prow && prow.avgEntryUsd !== null ? { usd: prow.avgEntryUsd, source: held?.kind ?? src?.kind ?? 'paper' } : null } : null;
     if (v.candles.length)
-        candleChart(c, cb.x + 1, cb.y, cb.w - 2, cb.h, v.candles, { bg: cb.bg, interval: v.interval, scale: cm.scale ?? undefined, axisFmt: cm.axisFmt });
+        candleChart(c, cb.x + 1, cb.y, cb.w - 2, cb.h, v.candles, { bg: cb.bg, interval: v.interval, scale: cm.scale ?? undefined, axisFmt: cm.axisFmt, trades });
     else
         c.textC(cb.x, cb.y + Math.floor(cb.h / 2), cb.w, cp.state === 'loading' ? 'loading candles…' : `no candles · ${cp.reason ?? 'source did not answer'}`, { fg: t.muted, bg: cb.bg, i: true });
     y += chartH;
     if (prow && src) {
-        positionPanel(c, 0, y, mainW, prow, held?.kind ?? src.kind, priceModeOf(state), cm.scale);
+        positionPanel(c, 0, y, mainW, prow, held?.kind ?? src.kind, priceModeOf(state), pm.scale);
         y += posH;
     }
+    // task-1473: what the ON-CHAIN band derived this frame, for the brain view's vetting list (null under SOCIAL)
+    let brainTop10 = null;
+    let brainDev = null;
     // ---- task-1330: the SOCIAL panel (`s`) replaces the ON-CHAIN / HOLDERS band; the chart + position stay.
     if (state.tokenSocial) {
         renderSocialPanel(c, 0, y, mainW, bottom - y, state, { mint: v.mint, symbol: v.symbol, now });
@@ -182,9 +191,11 @@ export function renderTokenLive(c, state, v) {
         // 0.1.5 dev history (task-1425): the creator's recorded track record from the local recorder (keyless). The rugs
         // row sits with the other rug signals; launches / bag-exit / linked wallets follow the safety list.
         const book = devBookOf(state);
-        const devAll = book ? devRows(book.forMint(v.mint, v.devAddress ?? null, state.live?.intel?.analysis(v.mint) ?? null)) : [];
+        const devAll = book ? devRows(book.forMint(v.mint, v.devAddress ?? null, state.live?.intel?.analysis(v.mint) ?? null, state.live?.intel?.entry(v.mint)?.at ?? null), now) : [];
         const devHead = devAll.slice(0, 1);
         const devTail = devAll.slice(1);
+        brainTop10 = tags.top10 ? tags.top10.exPool : v.top10;
+        brainDev = (devHead[0] ? [`${devHead[0][0]}: ${devHead[0][1]}`, devHead[0][2]] : v.devMints === null ? null : [`${v.devMints} mints by dev (jup)`, v.devMints > 3 ? 'warn' : 'ok']);
         const sniperRow = [cells.snipers.text, cells.snipers.level];
         const bundleRow = [cells.bundle.text, cells.bundle.level];
         const rows = [
@@ -201,7 +212,7 @@ export function renderTokenLive(c, state, v) {
             ['GoPlus', ...goplusRow(v)],
             ...devTail,
         ];
-        for (const [label, val0, lvl] of rows) {
+        for (const [label, val0, lvl] of fitRows(rows, sb.y + sb.h - sy)) {
             if (sy >= sb.y + sb.h)
                 break;
             const color = lvl === 'ok' ? t.up : lvl === 'warn' ? t.warn : lvl === 'bad' ? t.down : t.dim;
@@ -314,7 +325,7 @@ export function renderTokenLive(c, state, v) {
                     c.text(hb.x + 1, hy, 'TAPE', { fg: t.dim, bg: hb.bg });
                     c.textR(hb.x + 1, hy, hb.w - 2, tp.state === 'ok' || tp.fetchedAt !== null ? `geckoterminal · 20s poll${tp.stale || tp.state === 'error' ? ' · stale' : ''}` : panelCaption(tp, now, 'tape unavailable'), { fg: tp.state === 'error' && tp.fetchedAt === null ? t.warn : t.dim, bg: hb.bg });
                     hy += 1;
-                    hy += tradeTape(c, hb.x + 1, hy, hb.w - 2, hb.y + hb.h - hy, v.trades, now, { bg: hb.bg });
+                    hy += tradeTape(c, hb.x + 1, hy, hb.w - 2, hb.y + hb.h - hy, v.trades, now, { bg: hb.bg, priceFmt: (p) => levelCell(priceModeOf(state), supplyRatio(v.price, v.mcap), p) }); // task-1537
                 }
                 else if (flow) {
                     c.text(hb.x + 1, hy, 'BUY/SELL FLOW', { fg: t.dim, bg: hb.bg });
@@ -327,8 +338,15 @@ export function renderTokenLive(c, state, v) {
             }
         }
     }
-    if (showAi)
-        analystPlaceholder(c, mainW, top, aiW, bottom - top, v, state);
+    if (showAi) {
+        // task-1473: in an auto mode (following an agent / AI scan) the panel is the BRAIN VIEW; otherwise the analyst
+        const facts = factsFromView(v, { top10: brainTop10, dev: brainDev, larpVerdict: state.larpByMint?.get(v.mint)?.verdict ?? null, price: shownPx, fills: trades?.fills ?? null });
+        const brain = brainFor(state, facts, isCalm(state.vfx), state.live?.scanMeterLabel?.() ?? '');
+        if (brain)
+            renderBrainPanel(c, mainW, top, aiW, bottom - top, brain.model, brain.opts);
+        else
+            analystPlaceholder(c, mainW, top, aiW, bottom - top, v, state);
+    }
     const watched = state.live?.watch?.has(v.mint) ? 'unwatch' : 'watch';
     // task-1311: `i` asks claude about this token (chat), `a` runs the paid dossier on demand, `y`
     // copies the full contract address.
@@ -379,9 +397,9 @@ function positionPanel(c, x, y, w, r, kind, mode = 'price', supply = null) {
     if (r.realizedSol !== 0)
         cols.push({ label: 'REALIZED', value: usd && r.realizedUsd !== null ? signedUsd(r.realizedUsd) : `${signedSol(r.realizedSol)} SOL`, st: { fg: pnlColor(r.realizedSol), bg }, prio: 2 });
     if (r.stopUsd !== null)
-        cols.push({ label: 'STOP', value: `${fmtPrice(r.stopUsd)}${r.stopDistPct !== null ? ` ${signedPctOf(r.stopDistPct)}` : ''}`, st: { fg: t.down, bg }, prio: 3 });
+        cols.push({ label: 'STOP', value: `${levelCell(mode, supply, r.stopUsd)}${r.stopDistPct !== null ? ` ${signedPctOf(r.stopDistPct)}` : ''}`, st: { fg: t.down, bg }, prio: 3 });
     if (r.targetUsd !== null)
-        cols.push({ label: 'TARGET', value: `${fmtPrice(r.targetUsd)}${r.targetDistPct !== null ? ` ${signedPctOf(r.targetDistPct)}` : ''}`, st: { fg: t.up, bg }, prio: 3 });
+        cols.push({ label: 'TARGET', value: `${levelCell(mode, supply, r.targetUsd)}${r.targetDistPct !== null ? ` ${signedPctOf(r.targetDistPct)}` : ''}`, st: { fg: t.up, bg }, prio: 3 });
     const gap = 3;
     const widthOf = (list) => list.reduce((s, k) => s + Math.max(k.label.length, k.value.length) + gap, -gap);
     const inner = box.w - 2;
@@ -402,6 +420,21 @@ function positionPanel(c, x, y, w, r, kind, mode = 'price', supply = null) {
 function clip(s, max) {
     return s.length > max ? s.slice(0, Math.max(1, max - 1)) + '…' : s;
 }
+/**
+ * task-1463: the ON-CHAIN rows for a panel `space` lines tall. When they all fit they are returned unchanged. When
+ * they do not, a short panel must not drop a red flag silently (e.g. `Dev rugs 2/3`, the last rows of the list):
+ * bad rows are kept first, then warn rows, then the rest in order, the kept rows stay in their order, and the last
+ * line says how many rows are hidden.
+ */
+export function fitRows(rows, space) {
+    if (rows.length <= space || space <= 0)
+        return rows;
+    const slots = space - 1;
+    const rank = (l) => (l === 'bad' ? 0 : l === 'warn' ? 1 : 2);
+    const keep = new Set(rows.map((r, i) => [rank(r[2]), i]).sort((a, b) => a[0] - b[0] || a[1] - b[1]).slice(0, slots).map(([, i]) => i));
+    const hidden = rows.length - keep.size;
+    return [...rows.filter((_, i) => keep.has(i)), [`+${hidden} rows hidden`, 'taller window', 'na']];
+}
 /** Token amounts up to trillions (fmtNum stops at B). */
 function fmtAmt(n) {
     if (n >= 1e12)

package/dist/packages/cli/src/live/screens/watchlist-live.js

@@ -89,7 +89,7 @@ export function renderWatchlistLive(c, state, live) {
             } });
     }
     if (rows.length)
-        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: promoteMcap(cols, mode), rows, selected: sel, bg: box.bg });
+        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: promoteMcap(cols, mode), rows, selected: sel, bg: box.bg, rowKey: (r) => r.entry.mint });
     else
         c.textC(box.x, box.y + Math.min(3, Math.floor(box.h / 2)), box.w, 'watchlist is empty · press w on any token (screener, new pairs, token screen) to add it', { fg: t.muted, bg: box.bg, i: true });
     const y2 = top + listH;