dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/tui/src/keymap.js

@@ -268,6 +268,10 @@ export const DEFAULT_KEYMAP = new Keymap([
     // the open coin. (`P` is already the global positions key, so chart uses `C`.) Collision-free with the
     // token screen's other capitals (B/S trade, W/X/T/L links, V vet).
     { keys: ['C'], action: 'popup.chart', label: 'chart popup', screen: 'token' },
+    // task-1472: `A` (axis) on the token screen flips the chart Y axis MARKET CAP ⇄ PRICE (both charts; saved as
+    // display.chartAxis). Free capital on the token screen (A is only auto-mirror on the follows screen); deliberately
+    // not Y, which confirms inside the PAPER ticket and the modals. The chart popup uses the same `A`.
+    { keys: ['A'], action: 'display.chartAxis', label: 'chart axis mcap ⇄ price', screen: 'token' },
     // task-1359: `I` on the token screen opens/toggles the TOKEN-DETAIL HUD (identity, market, risk, snipers/bundled
     // from the wallet-intel scan); `M` on the trending screen opens/toggles the FEEDS HUD (the keyless social feed +
     // official news, newest first; ⏎ in the window opens that coin here). Both are read-only windows. `I` is unused
@@ -335,7 +339,6 @@ export const DEFAULT_KEYMAP = new Keymap([
     { keys: ['!'], action: 'plans.panic', label: 'PANIC', screen: 'plans' },
     { keys: ['M'], action: 'plans.popup', label: 'popup', screen: 'plans' },
     { keys: ['G'], action: 'plans.gate', label: 'hands-free gate', screen: 'plans' },
-    { keys: ['L'], action: 'plans.live', label: 'fire path paper/live', screen: 'plans' },
     // task-1360 copy trading. `U` opens the FOLLOWED WALLETS screen from anywhere (free capital: not B/S/P/W/V/X/T/L/C/F/Z/R/
     // K/M/N/D/O/G/I). On it: `i` types a wallet address (+ optional label) to follow, `d` unfollows the selected wallet,
     // `r` (global refresh) polls now. Nothing on this screen trades: a buy/sell alert is information only.
@@ -364,4 +367,25 @@ export const DEFAULT_KEYMAP = new Keymap([
     { keys: ['d'], action: 'rules.remove', label: 'delete rule', screen: 'rules' },
     { keys: ['tab'], action: 'rules.tab', label: 'rules ⇄ proposals', screen: 'rules' },
     { keys: ['x'], action: 'rules.dismiss', label: 'dismiss proposal', screen: 'rules' },
+    // task-1508 AUTOTRADE (paper). `Q` (free capital everywhere) opens the screen; tab cycles its five views (strategies,
+    // editor, compare, backtest, runner). The lowercase verbs below override the global w/b/x/p/i/s on this screen only.
+    // `!` soft-stops the paper runner, `p` pauses its new entries, `f` flattens after a y confirm. Edits only touch the
+    // user's own strategy files (validated, journaled); there is no key here for live mode, mandates or the signer.
+    { keys: ['Q'], action: 'screen.autotrade', label: 'autotrade (paper)' },
+    { keys: ['tab'], action: 'autotrade.view', label: 'next view', screen: 'autotrade' },
+    { keys: ['n'], action: 'autotrade.new', label: 'new from preset', screen: 'autotrade' },
+    { keys: ['d'], action: 'autotrade.dup', label: 'duplicate', screen: 'autotrade' },
+    { keys: ['e'], action: 'autotrade.edit', label: 'edit', screen: 'autotrade' },
+    { keys: ['c'], action: 'autotrade.compare', label: 'mark to compare', screen: 'autotrade' },
+    { keys: ['b'], action: 'autotrade.backtest', label: 'backtest', screen: 'autotrade' },
+    { keys: ['w'], action: 'autotrade.sweep', label: 'sweep (held-out)', screen: 'autotrade' },
+    { keys: ['x'], action: 'autotrade.export', label: 'export file', screen: 'autotrade' },
+    { keys: ['i'], action: 'autotrade.import', label: 'import file', screen: 'autotrade' },
+    { keys: ['r'], action: 'autotrade.run', label: 'runner', screen: 'autotrade' },
+    { keys: ['s'], action: 'autotrade.save', label: 'save (new version)', screen: 'autotrade' },
+    { keys: ['u'], action: 'autotrade.undo', label: 'undo', screen: 'autotrade' },
+    { keys: ['!'], action: 'autotrade.kill', label: 'kill (soft stop)', screen: 'autotrade' },
+    { keys: ['p'], action: 'autotrade.pause', label: 'pause new entries', screen: 'autotrade' },
+    { keys: ['f'], action: 'autotrade.flatten', label: 'flatten (confirm)', screen: 'autotrade' },
+    { keys: ['o'], action: 'autotrade.proposal', label: 'review chat proposal', screen: 'autotrade' },
 ]);

package/dist/packages/tui/src/markers.js

@@ -0,0 +1,219 @@
+// @dexterm/tui — task-1483 BUY / SELL markers: the pure model every chart draws from (terminal candles, the agent
+// views' traces, and — mirrored in packages/popup/src/pages/chart-lib.js, parity-tested — the chart popup).
+//
+// Input: the fills the app already holds (the paper ledger's trades and the live ledger's confirmed swaps), never a
+// fetch. Output: one marker per (bar, side, source) for the bars on screen, the open position's average entry per
+// source, and the closed round trips. Display only: nothing here can arm, size, sign or confirm anything.
+//
+// Placement rules (the card's "never clamped to a wrong place"):
+//   - a fill belongs to the bar whose period contains its time (bar open = floor(t / period) · period);
+//   - a fill older than the first bar on screen, newer than the last bar, or in a period with no bar (a quiet coin
+//     can skip a minute) is OMITTED and counted, never moved onto a neighbouring bar;
+//   - the price is the fill's own USD price (token-weighted when one bar holds several fills of a side); with no
+//     known price the marker is drawn against the bar (below it for a buy, above it for a sell) and says so.
+// The axis never changes a marker's position: bars and markers are both laid out in USD price; an mcap axis only
+// relabels (price × the current supply, task-1366/1472).
+/** Bar periods by the app's timeframe names. */
+export const MARKER_PERIOD_MS = { '1m': 60e3, '5m': 300e3, '15m': 900e3, '1h': 3600e3, '4h': 14400e3, '1d': 86400e3 };
+/** The open time of the bar a time falls in. */
+export function bucketOf(t, periodMs) { return Math.floor(t / periodMs) * periodMs; }
+const fin = (n) => typeof n === 'number' && Number.isFinite(n);
+const EPS = 1e-9;
+/** Valid fills only (finite time, a side, a source, a positive token amount), oldest first; stable for equal times. */
+export function cleanFills(fills) {
+    const out = [];
+    for (const f of fills ?? []) {
+        if (!f || !fin(f.t) || (f.side !== 'buy' && f.side !== 'sell') || (f.source !== 'paper' && f.source !== 'live'))
+            continue;
+        if (!fin(f.tokens) || f.tokens <= 0)
+            continue;
+        out.push({ t: f.t, side: f.side, source: f.source, priceUsd: fin(f.priceUsd) && f.priceUsd > 0 ? f.priceUsd : null, tokens: f.tokens, sol: fin(f.sol) && f.sol >= 0 ? f.sol : null });
+    }
+    return out.map((f, i) => [f, i]).sort((a, b) => a[0].t - b[0].t || a[1] - b[1]).map(([f]) => f);
+}
+/**
+ * Replay the fills per source (oldest first) the way the ledgers book them: a buy adds tokens and cost, a sell
+ * removes tokens at the average cost. A sell bigger than what the replay holds (the history was truncated) is
+ * treated as closing. Returns every fill annotated, the open position's average entry, and the closed trips.
+ */
+export function replayFills(fills) {
+    const st = {
+        paper: { held: 0, cost: 0, costOk: true, trip: null },
+        live: { held: 0, cost: 0, costOk: true, trip: null },
+    };
+    const out = [];
+    const trips = [];
+    for (const f of cleanFills(fills)) {
+        const s = st[f.source];
+        const before = s.held;
+        if (f.side === 'buy') {
+            if (s.held <= EPS) {
+                s.held = 0;
+                s.cost = 0;
+                s.costOk = true;
+                s.trip = { openT: f.t, bTok: 0, bUsd: 0, bOk: true, sTok: 0, sUsd: 0, sOk: true };
+            }
+            s.held += f.tokens;
+            if (f.priceUsd === null)
+                s.costOk = false;
+            else
+                s.cost += f.tokens * f.priceUsd;
+            if (s.trip) {
+                s.trip.bTok += f.tokens;
+                if (f.priceUsd === null)
+                    s.trip.bOk = false;
+                else
+                    s.trip.bUsd += f.tokens * f.priceUsd;
+            }
+            out.push({ ...f, heldBefore: before, heldAfter: s.held, partial: before > EPS, closes: false });
+            continue;
+        }
+        const sold = Math.min(f.tokens, s.held);
+        const frac = s.held > EPS ? sold / s.held : 1;
+        s.cost -= s.cost * frac;
+        s.held = Math.max(0, s.held - f.tokens);
+        const closes = s.held <= f.tokens * 1e-9 || s.held <= EPS;
+        if (closes)
+            s.held = 0;
+        if (s.trip) {
+            s.trip.sTok += f.tokens;
+            if (f.priceUsd === null)
+                s.trip.sOk = false;
+            else
+                s.trip.sUsd += f.tokens * f.priceUsd;
+        }
+        out.push({ ...f, heldBefore: before, heldAfter: s.held, partial: !closes, closes });
+        if (closes) {
+            if (s.trip)
+                trips.push({ source: f.source, openT: s.trip.openT, closeT: f.t, entryUsd: s.trip.bOk && s.trip.bTok > 0 ? s.trip.bUsd / s.trip.bTok : null, exitUsd: s.trip.sOk && s.trip.sTok > 0 ? s.trip.sUsd / s.trip.sTok : null });
+            s.trip = null;
+            s.cost = 0;
+            s.costOk = true;
+        }
+    }
+    const avg = (src) => { const s = st[src]; return s.held > EPS && s.costOk && s.cost > 0 ? s.cost / s.held : null; };
+    return { fills: out, avgEntry: { paper: avg('paper'), live: avg('live') }, trips };
+}
+/** Index of `t` in an ascending list, or -1 (binary search). */
+function indexOf(times, t) {
+    let lo = 0, hi = times.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const v = times[mid];
+        if (v === t)
+            return mid;
+        if (v < t)
+            lo = mid + 1;
+        else
+            hi = mid - 1;
+    }
+    return -1;
+}
+/**
+ * The markers for a window of bars: one per (bar, side, source), oldest first; buys before sells within a bar.
+ * Fills outside the window (or in a period with no bar) are counted in before / after / gap, never placed.
+ */
+export function chartMarkers(fills, win) {
+    const rp = replayFills(fills);
+    const times = win.barTimes;
+    const empty = () => ({ markers: [], before: 0, after: 0, gap: 0, avgEntry: rp.avgEntry, trips: [] });
+    if (!(win.periodMs > 0) || !times.length) {
+        const e = empty();
+        e.before = rp.fills.length;
+        return e;
+    }
+    const first = times[0], last = times[times.length - 1];
+    const res = empty();
+    const by = new Map();
+    for (const f of rp.fills) {
+        const b = bucketOf(f.t, win.periodMs);
+        if (b < first) {
+            res.before++;
+            continue;
+        }
+        if (b > last) {
+            res.after++;
+            continue;
+        }
+        const index = indexOf(times, b);
+        if (index < 0) {
+            res.gap++;
+            continue;
+        }
+        const key = `${b}|${f.side}|${f.source}`;
+        let m = by.get(key);
+        if (!m) {
+            m = { side: f.side, source: f.source, bucket: b, index, t: f.t, tLast: f.t, priceUsd: null, tokens: 0, sol: 0, count: 0, partial: false, closes: false, pTok: 0, pUsd: 0, solOk: true };
+            by.set(key, m);
+        }
+        m.count++;
+        m.tLast = f.t;
+        m.tokens += f.tokens;
+        if (f.sol === null)
+            m.solOk = false;
+        else
+            m.sol = (m.sol ?? 0) + f.sol;
+        if (f.priceUsd !== null) {
+            m.pTok += f.tokens;
+            m.pUsd += f.tokens * f.priceUsd;
+        }
+        if (f.partial)
+            m.partial = true;
+        if (f.closes)
+            m.closes = true;
+    }
+    const order = (m) => (m.side === 'buy' ? 0 : 1) * 2 + (m.source === 'live' ? 1 : 0);
+    res.markers = [...by.values()].map(({ pTok, pUsd, solOk, ...m }) => ({ ...m, priceUsd: pTok > 0 ? pUsd / pTok : null, sol: solOk ? m.sol : null }))
+        .sort((a, b) => a.index - b.index || order(a) - order(b));
+    res.trips = rp.trips.filter((r) => bucketOf(r.closeT, win.periodMs) >= first && bucketOf(r.openT, win.periodMs) <= last);
+    return res;
+}
+/** The glyph for a marker: solid ▲ / ▼ for live fills, hollow △ / ▽ for paper. Reads without colour (NO_COLOR). */
+export function markerGlyph(side, source) {
+    if (source === 'paper')
+        return side === 'buy' ? '△' : '▽';
+    return side === 'buy' ? '▲' : '▼';
+}
+/** The letter for a marker (always shown with the glyph, so BUY / SELL never depends on colour). */
+export function markerLetter(side) { return side === 'buy' ? 'B' : 'S'; }
+/** "△ ▽ paper  ▲ ▼ live" — the legend for the sources actually on screen (empty when none). */
+export function markerLegend(markers, avgShown = false) {
+    const has = (s) => markers.some((m) => m.source === s);
+    const parts = [];
+    if (has('paper'))
+        parts.push('△B ▽S paper');
+    if (has('live'))
+        parts.push('▲B ▼S live');
+    if (avgShown)
+        parts.push('┄ avg entry');
+    return parts.join('  ');
+}
+/** "+2 fills off-chart (1 earlier, 1 newer than the last candle)" — what the window omitted, or ''. */
+export function omittedNote(s) {
+    const n = s.before + s.after + s.gap;
+    if (!n)
+        return '';
+    const why = [];
+    if (s.before)
+        why.push(`${s.before} earlier`);
+    if (s.after)
+        why.push(`${s.after} newer than the last candle`);
+    if (s.gap)
+        why.push(`${s.gap} in a period with no candle`);
+    return `+${n} fill${n === 1 ? '' : 's'} off-chart (${why.join(', ')})`;
+}
+/**
+ * The plot row of a price on a terminal chart laid out between `lo` and `hi` over `plotH` rows (row 0 = `hi`), the same
+ * mapping candleChart uses for candle bodies. Null when the price is outside the plotted range (omitted, not clamped).
+ */
+export function markerRow(priceUsd, lo, hi, plotH) {
+    if (!fin(priceUsd) || !(hi > lo) || plotH < 1)
+        return null;
+    const r = Math.floor(((hi - priceUsd) / (hi - lo)) * plotH);
+    return r >= 0 && r < plotH ? r : null;
+}
+/** "B 41.2k" / "S×2 0.0₄123": the compact terminal label (axis value = price × scale, formatted by the axis). */
+export function markerLabel(m, fmt, scale = 1) {
+    const head = `${markerLetter(m.side)}${m.count > 1 ? `×${m.count}` : ''}`;
+    return m.priceUsd === null ? head : `${head} ${fmt(m.priceUsd * (scale > 0 ? scale : 1))}`;
+}

package/dist/packages/tui/src/widgets.js

@@ -5,8 +5,9 @@
 // background (hard cells); glow is only ever applied to neighbouring blank cells or to bg tints.
 import { Canvas } from "./canvas.js";
 import { mix, luminance } from "./color.js";
-import { fmtUsd, fmtPct, fmtNum, fmtPrice, fmtAgeSec, shortAddr, clamp } from "./fmt.js";
+import { fmtUsd, fmtPct, fmtNum, fmtPrice, fmtPriceBare, fmtCompactUsd, compactDecimalsFor, fmtAgeSec, shortAddr, clamp } from "./fmt.js";
 import { launchpadColor } from "./theme.js";
+import { chartMarkers, markerGlyph, markerLetter, markerLabel, markerLegend, markerRow, omittedNote, MARKER_PERIOD_MS } from "./markers.js";
 export const BLOCKS = '▁▂▃▄▅▆▇█';
 // braille dot bits: column 0 rows 0..3, column 1 rows 0..3 (row 0 = top)
 const BR_L = [0x01, 0x02, 0x04, 0x40];
@@ -107,6 +108,7 @@ export function brailleLine(c, x, y, w, h, values, opts = {}) {
                 c.put(x + col, y + r, String.fromCharCode(0x2800 + bits), { fg: neon(color, col / (w - 1), bg), bg, soft: true });
         }
 }
+/** task-1472: the price axis never prints scientific notation: subscript zeros below 0.01 (0.0₅493), like fmtPrice. */
 function fmtPriceAxis(p) {
     if (p >= 1000)
         return p.toFixed(0);
@@ -114,7 +116,7 @@ function fmtPriceAxis(p) {
         return p.toFixed(3);
     if (p >= 0.001)
         return p.toFixed(5);
-    return p.toExponential(2);
+    return fmtPriceBare(p);
 }
 /**
  * Candlestick chart with right-hand price axis, last-price tag, volume strip and time axis.
@@ -130,20 +132,37 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
     const plotW = w - axisW;
     const plotH = h - volH - timeH;
     if (plotW < 10 || plotH < 4 || candles.length === 0)
-        return;
+        return null;
     const CW = 4; // 3-col body with centered wick + 1-col gap
     const n = Math.min(candles.length, Math.floor(plotW / CW));
     const data = candles.slice(-n);
     // task-1366: the bars are laid out in price units either way (identical glyphs); only the labels are scaled
     const s = opts.scale && Number.isFinite(opts.scale) && opts.scale > 0 ? opts.scale : 1;
     const baseFmt = opts.axisFmt ?? fmtPriceAxis;
-    const fmtAxis = s === 1 ? baseFmt : (p) => baseFmt(p * s);
     let lo = Infinity, hi = -Infinity, vmax = 0;
     for (const k of data) {
         lo = Math.min(lo, k.l);
         hi = Math.max(hi, k.h);
         vmax = Math.max(vmax, k.v);
     }
+    // task-1483: the trade marks for the bars on screen. Their prices (and the avg entry) widen the range when they sit
+    // within 3× of the last close, like the popup's levels; a farther price is left off the plot rather than squashing it.
+    const tm = opts.trades && (opts.trades.fills.length || opts.trades.avgEntry) ? opts.trades : null;
+    const period = MARKER_PERIOD_MS[String(opts.interval || '1h')] ?? 3600e3;
+    const set = tm ? chartMarkers(tm.fills, { periodMs: period, barTimes: data.map((k) => k.t) }) : null;
+    const lastC = data[data.length - 1].c;
+    const near = (p) => typeof p === 'number' && Number.isFinite(p) && p > 0 && lastC > 0 && p / lastC < 3 && lastC / p < 3;
+    if (set)
+        for (const m of set.markers)
+            if (near(m.priceUsd)) {
+                lo = Math.min(lo, m.priceUsd);
+                hi = Math.max(hi, m.priceUsd);
+            }
+    const avgUsd = tm?.avgEntry && near(tm.avgEntry.usd) ? tm.avgEntry.usd : null;
+    if (avgUsd !== null) {
+        lo = Math.min(lo, avgUsd);
+        hi = Math.max(hi, avgUsd);
+    }
     const pad = (hi - lo) * 0.06 || hi * 0.01;
     lo -= pad;
     hi += pad;
@@ -152,6 +171,9 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
     const gridStyle = { fg: mix(bg, t.border, 0.9), bg, soft: true };
     const labelStyle = { fg: t.muted, bg };
     const ticks = Math.max(2, Math.min(6, Math.floor(plotH / 3)));
+    // task-1472: one more decimal only when two neighbouring ticks would otherwise print the same compact label
+    const extra = opts.axisFmt ? compactDecimalsFor(((hi + lo) / 2) * s, (range / ticks) * s) : 0;
+    const fmtAxis = (p) => baseFmt(p * s, extra);
     for (let i = 0; i <= ticks; i++) {
         const row = Math.round((i / ticks) * (plotH - 1));
         const price = hi - (row / (plotH - 1)) * range;
@@ -159,6 +181,30 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
             c.put(x + k, y + row, '·', gridStyle);
         c.textR(x + plotW, y + row, axisW, ' ' + fmtAxis(price), labelStyle);
     }
+    // task-1483: closed round trips, entry bar → exit bar, as a faint wash behind the candles (green = sold above the entry)
+    if (set && tm?.band !== false) {
+        for (const r of set.trips) {
+            const a = Math.max(0, data.findIndex((k) => k.t + period > r.openT));
+            let b = n - 1;
+            for (let i = n - 1; i >= 0; i--)
+                if (data[i].t <= r.closeT) {
+                    b = i;
+                    break;
+                }
+            const win = r.entryUsd !== null && r.exitUsd !== null ? r.exitUsd >= r.entryUsd : null;
+            const tint = mix(bg, win === null ? t.muted : win ? t.up : t.down, 0.07);
+            for (let i = a; i <= b; i++)
+                for (let q = 0; q < CW; q++)
+                    for (let row = 0; row < plotH; row++) {
+                        const cx = x + i * CW + q;
+                        if (cx >= x + plotW)
+                            continue;
+                        const gi = c.idx(cx, y + row);
+                        if (!c.hard[gi])
+                            c.bg[gi] = tint;
+                    }
+        }
+    }
     // last price line + tag
     const last = data[data.length - 1];
     const lastRow = Math.round(rowsOf(last.c));
@@ -226,6 +272,7 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
             }
         }
     }
+    const info = set ? drawTradeMarks(c, { x, y, plotW, plotH, n, CW, bg, lo, hi, axisW, fmtAxis, lastRow: lastRow >= 0 && lastRow < plotH ? lastRow : null, data, set, avgUsd, avgSource: tm?.avgEntry?.source ?? 'paper', scale: s }) : null;
     if (volH) {
         const vy = y + plotH;
         for (let i = 0; i < n; i++) {
@@ -245,7 +292,7 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
             }
         }
         c.text(x + plotW + 1, vy, 'vol', labelStyle);
-        c.text(x + plotW + 1, vy + 1, fmtUsd(last.v, { digits: 1 }), { fg: t.text, bg });
+        c.text(x + plotW + 1, vy + 1, fmtCompactUsd(last.v), { fg: t.text, bg }); // task-1472: volume stays USD, compact k/M
     }
     const ty = y + h - 1;
     const labels = Math.max(2, Math.floor(plotW / 18));
@@ -257,6 +304,108 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
         c.text(cx, ty, lab, labelStyle);
     }
     c.textR(x + plotW, ty, axisW, (opts.interval || '1h') + ' UTC', { fg: t.dim, bg });
+    return info;
+}
+const freeCell = (c, cx, cy) => { const ch = c.ch[c.idx(cx, cy)]; return ch === ' ' || ch === '·' || ch === '┄'; };
+/**
+ * task-1483: the avg-entry line, the B / S markers and their legend, on top of the drawn candles. Glyph + letter on
+ * every marker (△B ▽S paper, ▲B ▼S live), so NO_COLOR and calm read the same; colour only adds to it.
+ */
+function drawTradeMarks(c, g) {
+    const t = c.theme;
+    const { x, y, plotW, plotH, CW, bg } = g;
+    const rowsOf = (p) => ((g.hi - p) / (g.hi - g.lo)) * plotH;
+    // the open position's average entry: a dashed line through the empty cells (candles stay on top) + an axis tag
+    let avgRow = null;
+    let avgShown = false;
+    if (g.avgUsd !== null) {
+        avgRow = markerRow(g.avgUsd, g.lo, g.hi, plotH);
+        if (avgRow !== null) {
+            const col = g.avgSource === 'paper' ? t.warn : t.text;
+            for (let k = 0; k < plotW; k++)
+                if (freeCell(c, x + k, y + avgRow)) {
+                    c.put(x + k, y + avgRow, '┄', { fg: mix(bg, col, 0.8), bg, soft: true });
+                    avgShown = true;
+                }
+            // `avg` at the line's left end so it reads without colour (also over the last-price dashes when both share a row),
+            // and the value as an axis tag
+            const labelOk = (cx) => freeCell(c, cx, y + avgRow) || c.ch[c.idx(cx, y + avgRow)] === '╌';
+            if (labelOk(x) && labelOk(x + 1) && labelOk(x + 2)) {
+                c.text(x, y + avgRow, 'avg', { fg: col, bg, b: true, hard: true });
+                avgShown = true;
+            }
+            if (avgRow !== g.lastRow) {
+                c.fill(x + plotW, y + avgRow, g.axisW, 1, ' ', { bg }); // the grid label under it goes, not half of it
+                c.textR(x + plotW, y + avgRow, g.axisW, ' ' + g.fmtAxis(g.avgUsd), { fg: '#000000', bg: col, b: true });
+                avgShown = true;
+            }
+        }
+    }
+    const used = new Set();
+    const drawn = [];
+    let offPlot = 0;
+    for (const m of g.set.markers) {
+        const k = g.data[m.index];
+        const col0 = x + m.index * CW;
+        const buy = m.side === 'buy';
+        // the fill's own price; no price → against the bar (below the low for a buy, above the high for a sell)
+        let row = m.priceUsd !== null ? markerRow(m.priceUsd, g.lo, g.hi, plotH) : Math.floor(rowsOf(buy ? k.l : k.h)) + (buy ? 1 : -1);
+        if (row === null || row < 0 || row >= plotH) {
+            offPlot++;
+            continue;
+        }
+        // two marks in one bar on the same row (buy + sell, or paper + live): step away from the bar, never across it
+        while (row >= 0 && row < plotH && (used.has((row << 12) | m.index)))
+            row += buy ? 1 : -1;
+        if (row < 0 || row >= plotH) {
+            offPlot++;
+            continue;
+        }
+        used.add((row << 12) | m.index);
+        const sideCol = buy ? t.up : t.down;
+        const st = m.source === 'live' ? { fg: '#000000', bg: sideCol, b: true, hard: true } : { fg: sideCol, bg: mix(bg, sideCol, 0.2), b: true, hard: true };
+        c.put(col0 + 1, y + row, markerGlyph(m.side, m.source), st);
+        c.put(col0 + 2, y + row, markerLetter(m.side), st);
+        if (m.count > 1 && col0 + 3 < x + plotW)
+            c.put(col0 + 3, y + row, m.count > 9 ? '+' : String(m.count), st);
+        drawn.push({ marker: m, col: col0 + 1, row });
+    }
+    // the newest marker gets a compact label (B 41k) where the row has room, right of it first, else left
+    const newest = drawn[drawn.length - 1];
+    if (newest) {
+        const label = markerLabel(newest.marker, g.fmtAxis, 1);
+        const fits = (sx) => sx >= x && sx + label.length <= x + plotW && [...label].every((_, i) => freeCell(c, sx + i, y + newest.row));
+        const right = newest.col + 3 + (newest.marker.count > 1 ? 1 : 0);
+        const sx = fits(right) ? right : fits(newest.col - 2 - label.length) ? newest.col - 2 - label.length : null;
+        if (sx !== null)
+            c.text(sx, y + newest.row, label, { fg: newest.marker.side === 'buy' ? t.up : t.down, bg, hard: true });
+    }
+    // legend + what was left off, on the top plot row where it is empty (else the bottom row), never over a candle
+    const note = [markerLegend(drawn.map((d) => d.marker), avgShown), omittedNote(g.set)].filter(Boolean).join(' · ');
+    if (note) {
+        const text = note.length > plotW - 2 ? note.slice(0, Math.max(0, plotW - 3)) + '…' : note;
+        // the outermost rows first (top, bottom, then inwards); in a row, the leftmost run of empty cells long enough
+        const rows = [];
+        for (let i = 0; i < Math.ceil(plotH / 2); i++) {
+            rows.push(i);
+            if (plotH - 1 - i !== i)
+                rows.push(plotH - 1 - i);
+        }
+        const len = [...text].length;
+        place: for (const row of rows) {
+            if (row === avgRow || row === g.lastRow || drawn.some((d) => d.row === row))
+                continue;
+            let run = 0;
+            for (let cx = x + 1; cx < x + plotW; cx++) {
+                run = freeCell(c, cx, y + row) ? run + 1 : 0;
+                if (run === len) {
+                    c.text(cx - len + 1, y + row, text, { fg: t.dim, bg, i: true });
+                    break place;
+                }
+            }
+        }
+    }
+    return { set: g.set, drawn, offPlot, avgRow };
 }
 /** Horizontal progress bar: gradient fill, hot head cell, one-cell ▓ glow past the head, ░ empty. pct 0..100 */
 export function bar(c, x, y, w, pct, opts = {}) {
@@ -386,6 +535,8 @@ export function table(c, x, y, w, h, spec) {
         const selected = ri === spec.selected;
         const rowBg = selected ? t.selBg : (r % 2 === 1 && spec.zebra !== false ? mix(bg, t.panelAlt, 1) : bg);
         c.fill(x, ry, w, 1, ' ', { bg: rowBg });
+        if (spec.rowKey)
+            c.rowMarks.push({ key: spec.rowKey(row), x, y: ry, w });
         if (selected)
             c.put(x - 1 >= 0 ? x - 1 : x, ry, '▎', { fg: t.accent, bg: rowBg, soft: true });
         cx = x;
@@ -478,7 +629,8 @@ export function tradeTape(c, x, y, w, h, trades, now, opts = {}) {
             continue;
         }
         cx = c.textR(cx + 1, yy, 8, fmtUsd(tr.usd), { fg: t.text, bg });
-        cx = c.text(cx + 2, yy, tr.price > 0 ? fmtPrice(tr.price) : '—', { fg: t.muted, bg }, Math.max(0, x + w - cx - 2));
+        // task-1537: the caller's price basis (a market cap at the coin's supply by default); plain price without one
+        cx = c.text(cx + 2, yy, tr.price > 0 ? (opts.priceFmt ?? fmtPrice)(tr.price) : '—', { fg: t.muted, bg }, Math.max(0, x + w - cx - 2));
         c.text(cx + 2, yy, shortAddr(tr.wallet, 3), { fg: t.dim, bg }, Math.max(0, x + w - cx - 2));
         n += 1;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dexterm-cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "mcpName": "io.github.dexterm-xyz/dexterm",
   "description": "dexterm: terminal DEX screener with a local Claude CLI analyst",
   "author": "The dexterm authors",
@@ -25,6 +25,7 @@
   },
   "devDependencies": {
     "@dexterm/agents": "0.0.1",
+    "@dexterm/autotrade": "0.0.1",
     "@dexterm/custom": "0.0.1",
     "@dexterm/data": "0.0.1",
     "@dexterm/mcp": "0.0.1",