dexterm-cli 0.1.5 → 0.1.7

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

@@ -49,13 +49,15 @@ function keysDisplay(b) {
  * `--fixtures`.
  */
 export function OVERLAY_HINTS(screen, fixtures) {
+    // task-1508: on the AUTOTRADE screen c / n / u / d / x are its own verbs (the loop skips calm and the demo keys there).
+    const own = screen === 'autotrade';
     const rows = [
-        { keys: 'c', label: 'calm mode (effects off)' },
+        ...(own ? [] : [{ keys: 'c', label: 'calm mode (effects off)' }]),
         { keys: '?', label: 'this help' },
     ];
     if (screen === 'analyst')
         rows.unshift({ keys: 'type', label: 'ask a follow-up · ⏎ send · esc clear/back' });
-    if (fixtures)
+    if (fixtures && !own)
         rows.push({ keys: 'n/u/d/x', label: 'demo: new pair · pump · dump · rug' });
     return rows;
 }
@@ -102,6 +104,7 @@ const SCREEN_TITLE = {
     ticket: 'Paper trade ticket', positions: 'Paper positions',
     trending: 'Trending in the space', kol: 'KOL lists', bubbles: 'Bubble map', narrative: 'Narrative board',
     plans: 'Order plans & mandates', follows: 'Followed wallets', rules: 'Rules (alerts + proposals only)',
+    autotrade: 'Autotrade (paper)',
 };
 /** Draw a centered modal card and return its inner rect, or null when the terminal is too small. */
 function card(c, want, title, caption) {

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

@@ -27,11 +27,10 @@ export function renderPlans(c, state) {
     const top = 2, bottom = c.h - 1;
     const risk = svc ? svc.riskStatus() : { gateOff: false, acceptedAt: null, expiresAt: null, active: false };
     const gateLabel = risk.active ? 'HANDS-FREE' : 'GATE ON';
-    // task-1363: the fire path. Anything not provably paper renders LIVE (fail-safe).
-    const liveFire = svc ? svc.mode() === 'live' : false;
-    const fireLabel = liveFire ? '◉ LIVE · DEVNET · FAST WALLET' : 'PAPER';
+    // task-1571: plans fire on PAPER only (dexterm holds no key; there is no live fire path).
+    const fireLabel = 'PAPER';
     const title = `ORDER PLANS & MANDATES · ${tab === 'plans' ? `${plans.length} plans` : `${mandates.length} mandates`} · ${fireLabel} · ${gateLabel}`;
-    const caption = bp === 'compact' ? undefined : 'voice/agents PROPOSE only · arming needs a physical keypress hold · caps are signer-side · panic revokes all';
+    const caption = bp === 'compact' ? undefined : 'voice/agents PROPOSE only · arming needs a physical keypress hold · paper fills only · panic revokes all';
     const box = c.box(0, top, c.w, bottom - top, { title, caption, focus: true });
     const bg = box.bg;
     const now = state.now.getTime();
@@ -89,7 +88,7 @@ export function renderPlans(c, state) {
         const mbox = c.box(mx, my, mw, mh, { title: '⚠ ARM — physical keypress', focus: true });
         const label = a.kind === 'plan' ? `Arm plan ${a.id} into ${a.mandateId}?` : `Arm standing mandate ${a.id}?`;
         c.textC(mbox.x, mbox.y, mbox.w, label, { fg: t.text, bg: mbox.bg, b: true });
-        c.textC(mbox.x, mbox.y + 1, mbox.w, a.kind === 'mandate' ? 'armed plans can fire at machine speed from the capped fast wallet' : 'the signer re-checks caps on every fill; voice/agents can never arm', { fg: t.muted, bg: mbox.bg });
+        c.textC(mbox.x, mbox.y + 1, mbox.w, a.kind === 'mandate' ? 'armed plans can fire at machine speed on paper (simulated fills)' : 'the caps are re-checked on every paper fill; voice/agents can never arm', { fg: t.muted, bg: mbox.bg });
         c.textC(mbox.x, mbox.y + 3, mbox.w, 'Hold and release [enter] or [y] to confirm · [esc] cancels · a pipe/agent cannot arm', { fg: t.accent, bg: mbox.bg });
     }
     // The "less safe" hands-free opt-in modal (Tier 4): keypress-only, journaled, auto-expires 24h, reversible.
@@ -102,17 +101,6 @@ export function renderPlans(c, state) {
         c.textC(mbox.x, mbox.y + 3, mbox.w, 'signer caps, allow-lists and panic still apply · this auto-expires in 24h · logged to the journal', { fg: t.muted, bg: mbox.bg });
         c.textC(mbox.x, mbox.y + 5, mbox.w, risk.active ? 'Hold+release [enter]/[y] to restore the gate · [esc] cancels' : 'Hold+release [enter]/[y] to accept (keypress only) · [esc] cancels · a pipe/agent cannot', { fg: t.accent, bg: mbox.bg });
     }
-    // task-1363: the FIRE PATH modal (paper ⇄ live). Switched by a captured keypress in the loop; this paints the prompt.
-    if (ui?.liveModal) {
-        const mw = Math.min(box.w - 4, 78), mh = 9;
-        const mx = box.x + Math.floor((box.w - mw) / 2), my = box.y + Math.floor((box.h - mh) / 2);
-        const mbox = c.box(mx, my, mw, mh, { title: liveFire ? 'FIRE PATH — back to PAPER' : '⚠ FIRE PATH — go LIVE on DEVNET', focus: true });
-        c.textC(mbox.x, mbox.y, mbox.w, liveFire ? 'Switch plan fills back to the paper executor?' : 'Fire armed plans through the SIGNER from the capped fast wallet (devnet)?', { fg: t.text, bg: mbox.bg, b: true });
-        c.textC(mbox.x, mbox.y + 2, mbox.w, liveFire ? 'fills are then simulated again at the tick price; nothing on chain' : 'real devnet lamports move (fees of a wrap-and-unwrap sized to the plan); the token leg is modelled — Jupiter has no devnet', { fg: liveFire ? t.muted : t.down, bg: mbox.bg });
-        c.textC(mbox.x, mbox.y + 3, mbox.w, 'the signer re-checks policy, simulation, USD per-trade/daily caps and the 0.05 SOL per-fill ceiling on every fill', { fg: t.muted, bg: mbox.bg });
-        c.textC(mbox.x, mbox.y + 4, mbox.w, 'needs: a live run with the signer, `dexterm wallet fast create`, no armed/filled plans · never mainnet · journaled', { fg: t.muted, bg: mbox.bg });
-        c.textC(mbox.x, mbox.y + 6, mbox.w, 'Hold+release [enter]/[y] to switch (keypress only) · [esc] cancels · a pipe/agent/voice cannot', { fg: t.accent, bg: mbox.bg });
-    }
     // task-1366: the selected plan's levels with BOTH market cap and price (display only; mc first in mcap mode)
     if (tab === 'plans' && svc && !ui?.notice) {
         const r = rows[sel];
@@ -122,5 +110,5 @@ export function renderPlans(c, state) {
     }
     if (ui?.notice)
         c.text(box.x + 1, box.y + box.h - 1, ui.notice, { fg: t.accent, bg });
-    footer(c, [['↑↓', 'move'], ['tab', 'plans/mandates'], ['a', 'arm (hold)'], tab === 'plans' ? ['c', 'cancel'] : ['r', 'revoke'], ['L', liveFire ? 'paper' : 'live (devnet)'], ['G', risk.active ? 'gate on' : 'hands-free'], ['!', 'PANIC'], ['esc', 'back'], ['q', 'quit']], t.name);
+    footer(c, [['↑↓', 'move'], ['tab', 'plans/mandates'], ['a', 'arm (hold)'], tab === 'plans' ? ['c', 'cancel'] : ['r', 'revoke'], ['G', risk.active ? 'gate on' : 'hands-free'], ['!', 'PANIC'], ['esc', 'back'], ['q', 'quit']], t.name);
 }

package/dist/packages/cli/src/screens/pnl-chip.js

@@ -0,0 +1,144 @@
+// dexterm — the persistent POSITION PnL chip (task-1473). While an auto mode runs and a position is open, one compact
+// readout is on every terminal screen and on the chart popup: coin, mark PnL % with sign (and $ when the size is
+// known), entry → mark, peak, drawdown from the peak, time held and the take-profit. Sources (state.ts pnlChipFor):
+//   · following an agent (task-1466 HUD) that holds a PAPER ticket — the folded story, TP = what the agent said;
+//   · AI scan mode with the user's OWN paper or live position (OwnPnlTracker; session peak, TP = the ledger target).
+// Where it draws: the HUD dock's signal row when the dock is up (≥ HUD_MIN_H rows while following), else the band
+// under the header (row 1, right-aligned: short terminals, scan mode), and the chart popup's chip strip (ChartVM.chip).
+// It updates on every mark tick, flashes on a new peak (a ★ glyph says the same under calm mode / NO_COLOR) and drops
+// fields from the right as the width shrinks. Display only: it has no input and reads only folded / ledger state.
+import { mix } from '../../../tui/src/index.js';
+import { fmtPx } from '../../../agents/src/index.js';
+import { planFromThoughts, fmtDur } from "./brain.js";
+export const PEAK_FLASH_MS = 1200;
+export const CHIP_PRICE_LEVEL = (u) => `$${fmtPx(u)}`;
+const PRICE_LEVEL = CHIP_PRICE_LEVEL;
+export function pnlChipVM(v, now, lvl = PRICE_LEVEL) {
+    const a = v.arc;
+    if (!a || a.stage !== 'open')
+        return null;
+    const dd = a.pnlPct !== null && a.peakPct !== null ? (1 + a.pnlPct) / (1 + a.peakPct) - 1 : null;
+    return {
+        kind: 'PAPER',
+        symbol: a.symbol,
+        pnlPct: a.pnlPct,
+        pnlUsd: a.pnlPct !== null && a.sizeUsd !== null ? a.sizeUsd * a.pnlPct : null,
+        entry: a.entryUsd !== null ? lvl(a.entryUsd, a.mint) : '—',
+        mark: a.mark ? lvl(a.mark.priceUsd, a.mint) : '—',
+        peakPct: a.peakPct,
+        ddPct: dd,
+        heldMs: a.filledAt !== null ? now - a.filledAt : null,
+        tp: planFromThoughts(v.thoughts, a.openedAt).tp,
+        newPeak: a.peakAt !== null && now - a.peakAt < PEAK_FLASH_MS && a.peakPct !== null && a.peakPct > 0,
+    };
+}
+/**
+ * The user's own position chip in AI scan mode. The ledgers keep no peak, so the peak is this session's highest
+ * mark (reset when the held coin or ledger changes, or the position goes flat). Display only.
+ */
+export class OwnPnlTracker {
+    cur = null;
+    update(s, now) {
+        if (!s) {
+            this.cur = null;
+            return;
+        }
+        const seed = !this.cur || this.cur.s.mint !== s.mint || this.cur.s.kind !== s.kind;
+        if (seed)
+            this.cur = { s, peakPct: s.pnlPct, peakAt: null }; // the first mark is not a "new peak" flash
+        const c = this.cur;
+        c.s = s;
+        if (!seed && s.pnlPct !== null && (c.peakPct === null || s.pnlPct > c.peakPct + 1e-9)) {
+            c.peakPct = s.pnlPct;
+            c.peakAt = now;
+        }
+    }
+    get mint() { return this.cur?.s.mint ?? null; }
+    vm(now, lvl = PRICE_LEVEL) {
+        const c = this.cur;
+        if (!c)
+            return null;
+        const s = c.s;
+        const dd = s.pnlPct !== null && c.peakPct !== null ? (1 + s.pnlPct) / (1 + c.peakPct) - 1 : null;
+        return {
+            kind: s.kind === 'live' ? 'LIVE' : 'PAPER',
+            symbol: s.symbol,
+            pnlPct: s.pnlPct,
+            pnlUsd: s.pnlUsd,
+            entry: s.entryUsd !== null ? lvl(s.entryUsd, s.mint) : '—',
+            mark: s.markUsd !== null ? lvl(s.markUsd, s.mint) : '—',
+            peakPct: c.peakPct,
+            ddPct: dd,
+            heldMs: s.openedAt !== null ? Math.max(0, now - s.openedAt) : null,
+            tp: s.targetUsd !== null ? lvl(s.targetUsd, s.mint) : null,
+            tpNone: 'not set',
+            newPeak: c.peakAt !== null && now - c.peakAt < PEAK_FLASH_MS && c.peakPct !== null && c.peakPct > 0,
+        };
+    }
+}
+const pct = (r) => `${r >= 0 ? '+' : '−'}${Math.abs(r * 100).toFixed(1)}%`;
+const usd = (n) => `${n >= 0 ? '+' : '−'}$${Math.abs(n).toFixed(2)}`;
+/** The chip's segments in priority order (the first ones survive the narrowest widths). */
+export function chipSegments(m) {
+    const segs = [];
+    const dir = m.pnlPct === null ? '·' : m.pnlPct >= 0 ? '▲' : '▼';
+    segs.push({ id: 'head', text: `${m.kind} $${m.symbol}` });
+    segs.push({ id: 'pnl', text: `${dir} ${m.pnlPct === null ? '—' : pct(m.pnlPct)}${m.pnlUsd !== null ? ` ${usd(m.pnlUsd)}` : ''}` });
+    if (m.peakPct !== null)
+        segs.push({ id: 'peak', text: `peak ${pct(m.peakPct)}${m.newPeak ? ' ★' : ''}` });
+    segs.push({ id: 'px', text: `${m.entry} → ${m.mark}` });
+    if (m.heldMs !== null)
+        segs.push({ id: 'held', text: `held ${fmtDur(m.heldMs)}` });
+    if (m.ddPct !== null && m.ddPct < -0.0005)
+        segs.push({ id: 'dd', text: `dd ${pct(m.ddPct)}` });
+    segs.push({ id: 'tp', text: m.tp ? `TP ${m.tp}` : `TP ${m.tpNone ?? 'agent-managed'}` });
+    return segs;
+}
+const SEP = ' │ ';
+/** The chip text that fits in `maxW` (segments drop from the end). Pure, for tests. */
+export function chipText(m, maxW) {
+    const segs = chipSegments(m);
+    let n = segs.length;
+    const join = (k) => ` ${segs.slice(0, k).map((s) => s.text).join(SEP)} `;
+    while (n > 1 && join(n).length > maxW)
+        n--;
+    const s = join(n);
+    return s.length <= maxW ? s : '';
+}
+/**
+ * Draw the chip right-aligned to `right` (exclusive) on row `y`, no wider than `maxW`. Returns the x it starts at
+ * (or `right` when nothing fits).
+ */
+export function renderPnlChip(c, right, y, maxW, m, o) {
+    const t = c.theme;
+    const text = chipText(m, maxW);
+    if (!text)
+        return right;
+    const x0 = right - text.length;
+    const bg = mix(t.bg, t.magenta, 0.22);
+    const col = m.pnlPct === null ? t.muted : m.pnlPct >= 0 ? t.up : t.down;
+    c.text(x0, y, text, { fg: t.text, bg });
+    // re-colour the segments: head magenta, PnL red/green bold (flash on a new peak), peak green, dd warn
+    let x = x0 + 1;
+    for (const s of chipSegments(m)) {
+        if (x + s.text.length > right - 1)
+            break;
+        if (s.id === 'head')
+            c.text(x, y, s.text, { fg: t.magenta, bg, b: true });
+        else if (s.id === 'pnl') {
+            const flash = m.newPeak && !o.reduced;
+            c.text(x, y, s.text, flash ? { fg: t.bg, bg: t.up, b: true } : { fg: col, bg, b: true });
+        }
+        else if (s.id === 'peak')
+            c.text(x, y, s.text, { fg: m.peakPct !== null && m.peakPct >= 0 ? t.up : t.down, bg, b: m.newPeak });
+        else if (s.id === 'dd')
+            c.text(x, y, s.text, { fg: t.warn, bg });
+        else
+            c.text(x, y, s.text, { fg: t.muted, bg });
+        x += s.text.length;
+        if (x + SEP.length < right)
+            c.text(x, y, SEP, { fg: mix(bg, t.border, 0.8), bg });
+        x += SEP.length;
+    }
+    return x0;
+}

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

@@ -4,7 +4,7 @@
 import { Canvas, header, footer, breakpoint, mix, isCalm, fmtPriceBare, fmtMcap, fmtNum, fmtPct, fmtAgeSec, shortAddr, } from '../../../tui/src/index.js';
 import { lamportsToSol, rawToTokens, positionPnl } from '../../../data/src/index.js';
 import { headerModel } from "../state.js";
-import { priceModeOf, supplyRatio, FALLBACK_MARK } from "../display.js";
+import { priceModeOf, supplyRatio, supplyForMint, FALLBACK_MARK } from "../display.js";
 export function sol(n, digits = 4) {
     return `${n >= 0 ? '' : '-'}${Math.abs(n).toFixed(digits)}`;
 }
@@ -75,7 +75,7 @@ export function renderPositions(c, state) {
     // task-1366: mcap mode reads AVG / PRICE as market cap = SOL price × SOL/USD × the token's CURRENT supply (from the
     // screener rows); a token without a supply (or no SOL/USD yet) keeps its SOL price, marked ᵖ. PnL stays SOL.
     const mode = priceModeOf(state);
-    const supplyOf = (mint) => { const row = state.screener.rows.find((x) => x.mint === mint); return row ? supplyRatio(row.price, row.mcap) : null; };
+    const supplyOf = (mint) => supplyForMint(state, mint); // task-1537: + the open token view and pump.fun's 1B
     const mcCell = (pSol, mint) => {
         if (pSol === null)
             return '—';
@@ -126,33 +126,9 @@ export function renderPositions(c, state) {
         }
         py += 1;
     }
-    // task-1328: LIVE positions (the signer's ledger file, read-only), only when there are any.
-    const liveSrc = state.live?.livePositions ?? null;
-    const livePos = liveSrc ? liveSrc.positions().filter((p) => p.tokensRaw > 0n) : [];
     y += half;
-    if (livePos.length > 0) {
-        const lh = Math.min(livePos.length + 3, Math.max(5, Math.floor((bottom - y) * 0.4)));
-        const lb = c.box(0, y, c.w, lh, { title: '◉ LIVE POSITIONS', titleFg: t.up, caption: 'confirmed on-chain fills · signer ledger' });
-        let ly = lb.y;
-        for (const p of livePos) {
-            if (ly >= lb.y + lb.h)
-                break;
-            const mark = liveSrc?.held(p.mint)?.markSol ?? null;
-            const pnl = positionPnl(p, mark);
-            let cx = c.text(lb.x + 1, ly, `$${p.symbol}`, { fg: t.text, bg: lb.bg, b: true });
-            cx = c.text(cx + 2, ly, fmtNum(rawToTokens(p.tokensRaw, p.decimals)), { fg: t.muted, bg: lb.bg });
-            cx = c.text(cx + 2, ly, `cost ${sol(pnl.costSol)} SOL`, { fg: t.dim, bg: lb.bg });
-            if (pnl.avgEntrySol !== null)
-                cx = c.text(cx + 2, ly, `avg ${fmtPriceBare(pnl.avgEntrySol)}`, { fg: t.dim, bg: lb.bg });
-            if (pnl.unrealizedSol !== null)
-                c.text(cx + 2, ly, `uPnL ${signedSol(pnl.unrealizedSol)} SOL${pnl.unrealizedPct !== null ? ` ${fmtPct(pnl.unrealizedPct * 100)}` : ''}`, { fg: pnl.unrealizedSol >= 0 ? t.up : t.down, bg: lb.bg, b: true });
-            c.textR(lb.x + 1, ly, lb.w - 2, `${shortAddr(p.mint, 4)} · LIVE`, { fg: t.up, bg: lb.bg });
-            ly += 1;
-        }
-        y += lh;
-    }
     // history
-    const hb = c.box(0, y, c.w, bottom - y, { title: 'TRADE HISTORY', caption: `${v.history.length} paper fills${liveSrc ? ` · ${liveSrc.records(50).length} live` : ''}` });
+    const hb = c.box(0, y, c.w, bottom - y, { title: 'TRADE HISTORY', caption: `${v.history.length} paper fills` });
     let yy = hb.y;
     for (const h of v.history) {
         if (yy >= hb.y + hb.h)
@@ -163,7 +139,9 @@ export function renderPositions(c, state) {
         let cx = c.text(hb.x + 1, yy, fmtAgeSec(Math.max(0, Math.round((state.now.getTime() - h.t) / 1000))).padStart(4), { fg: t.dim, bg: hb.bg });
         cx = c.text(cx + 1, yy, h.side === 'buy' ? '▲ BUY ' : '▼ SELL', { fg: sideColor, bg: hb.bg, b: true });
         cx = c.text(cx + 1, yy, `$${h.symbol}`, { fg: t.text, bg: hb.bg, b: true });
-        cx = c.text(cx + 1, yy, `${fmtNum(gotTokens)} @ ${fmtPriceBare(h.priceSol)} SOL`, { fg: t.muted, bg: hb.bg });
+        // task-1537: a fill reads as the market cap it filled at (the coin's current known supply), the SOL price kept
+        const hsup = mode === 'mcap' ? supplyOf(h.mint) : null;
+        cx = c.text(cx + 1, yy, `${fmtNum(gotTokens)} @ ${hsup !== null && v.solPriceUsd ? `${fmtMcap(h.priceSol * v.solPriceUsd * hsup)} mcap (${fmtPriceBare(h.priceSol)} SOL)` : `${fmtPriceBare(h.priceSol)} SOL`}`, { fg: t.muted, bg: hb.bg });
         cx = c.text(cx + 2, yy, `${signedSol(solAmt)} SOL`, { fg: solAmt >= 0 ? t.up : t.muted, bg: hb.bg });
         if (h.side === 'sell')
             c.text(cx + 2, yy, `pnl ${signedSol(lamportsToSol(h.realizedLamports))}`, { fg: h.realizedLamports >= 0n ? t.up : t.down, bg: hb.bg });

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

@@ -195,6 +195,7 @@ export function renderScreener(c, state) {
         : null;
     table(c, box.x + 1, box.y, box.w - 2, box.h, {
         columns: screenerColumns(c, bp, sc.gates, state.larpByMint ?? null, icon, mode), rows, selected: sel, scroll: Math.max(0, scroll), sortKey: sc.sort.key, sortDir: sc.sort.dir, bg: box.bg,
+        rowKey: (r) => r.mint, // task-1466: the agent HUD finds the rows it scanned
     });
     if (rows.length === 0)
         emptyState(c, box, sc);