dexterm-cli 0.1.6 → 0.1.7

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

@@ -0,0 +1,288 @@
+// `dexterm ledger <sub>` (task-1530): the unified TRADE LEDGER. One row per round trip from every place dexterm books a
+// trade: the paper ticket (paper wallet), the agent paper desk (its journal), autotrade runs (their hash-chained run
+// ledgers) and the live signer (its trade ledger). Each row carries the strategy id + version + hash, the declared exit
+// profile and entry reason (and where each came from), the exit reason, size and % of book, entry / exit price AND
+// market cap, fees, impact, hold, rug flag, wallet mode and the model sessions that made it.
+//
+// Reads never write: every command folds $DEXTERM_HOME/ledger/trades.jsonl plus what the sources hold that the file
+// does not yet (shown as "pending"). `sync` appends those to the file (append-only, sha256-chained; a broken file is
+// refused, never rewritten) and `verify` recomputes the chain. No network, no model, no key, no signer.
+import { writeFileSync } from 'node:fs';
+export const LEDGER_HELP = `dexterm ledger: the unified trade ledger (paper, agent paper desk, autotrade runs, live). Read-only unless sync.
+
+  dexterm ledger trades     [filters] [--limit N] [--json]   one row per round trip, newest first
+  dexterm ledger positions  [filters] [--json]               the open trades (cost, % of book, held, profile)
+  dexterm ledger summary    [filters] [--json]               win rate (95% interval), P/L, drawdown, rug rate, by profile / exit / strategy / source / mode
+  dexterm ledger equity     [filters] [--json]               the realized equity curve and its max drawdown
+  dexterm ledger compare    [filters] [--json]               one row per strategy version: the forward-test table
+  dexterm ledger export csv|json|parquet-lite [filters] [--out FILE]   (or --format csv|json|parquet-lite)
+  dexterm ledger card <tradeId> [--square] [--price] [--exact] [--sol-usd N]   a PnL card (market cap at entry / exit)
+  dexterm ledger sync [--json]                                append what the sources hold to the ledger file
+  dexterm ledger verify [--json]                              recompute the ledger file's sha256 chain
+
+  filters: --source paper|desk|autotrade|live  --mode paper|devnet|live  --strategy ID[@VERSION|@HASH]  --profile P
+           --exit REASON  --mint MINT  --run RUN_ID  --account ID  --days N  --status open|closed  --wallet-db PATH
+
+  The file is $DEXTERM_HOME/ledger/trades.jsonl (default ~/.dexterm). PAPER rows are simulated; filter by --mode
+  before comparing results. Not financial advice.`;
+const VALUE_FLAGS = new Set(['source', 'mode', 'strategy', 'profile', 'exit', 'mint', 'run', 'account', 'days', 'status', 'limit', 'out', 'sol-usd', 'wallet-db', 'format']);
+function parse(argv) {
+    const o = { _: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (!a.startsWith('--')) {
+            o._.push(a);
+            continue;
+        }
+        const eq = a.indexOf('=');
+        const k = eq > 0 ? a.slice(2, eq) : a.slice(2);
+        if (VALUE_FLAGS.has(k)) {
+            const v = eq > 0 ? a.slice(eq + 1) : argv[++i];
+            if (v === undefined || v === '')
+                return `--${k} needs a value`;
+            o[k] = v;
+        }
+        else
+            o[k] = true;
+    }
+    return o;
+}
+/** CLI flags → the MCP tool args shape, validated by the same filterFromArgs the ledger tools use. */
+async function filterOf(o, now) {
+    const { filterFromArgs } = await import('../../mcp/src/index.js');
+    const a = {};
+    for (const [flag, key] of [['source', 'source'], ['mode', 'mode'], ['strategy', 'strategy'], ['profile', 'profile'], ['exit', 'exit_reason'], ['mint', 'mint'], ['run', 'run_id'], ['account', 'account'], ['status', 'status']]) {
+        if (typeof o[flag] === 'string')
+            a[key] = o[flag];
+    }
+    if (typeof o.days === 'string')
+        a.days = Number(o.days);
+    return filterFromArgs(a, now);
+}
+async function loadView(io, o, now) {
+    const at = await import('../../autotrade/src/index.js');
+    return at.loadLedgerView({ env: io.env, now, ...(typeof o['wallet-db'] === 'string' ? { walletDb: o['wallet-db'] } : {}) });
+}
+// ───────────────────────────── formatting ─────────────────────────────
+const pad = (s, n) => (s.length >= n ? s.slice(0, n) : s + ' '.repeat(n - s.length));
+const lpad = (s, n) => (s.length >= n ? s : ' '.repeat(n - s.length) + s);
+const num = (x, d = 2) => (x === null || x === undefined || !Number.isFinite(x) ? '—' : x.toFixed(d));
+const pct = (x) => (x === null || x === undefined || !Number.isFinite(x) ? '—' : `${x >= 0 ? '+' : ''}${x.toFixed(1)}%`);
+const frac = (x) => (x === null || x === undefined ? '—' : `${(x * 100).toFixed(0)}%`);
+export function fmtCap(v) {
+    if (v === null || v === undefined || !Number.isFinite(v))
+        return '—';
+    if (v >= 1e9)
+        return `$${(v / 1e9).toFixed(2)}B`;
+    if (v >= 1e6)
+        return `$${(v / 1e6).toFixed(2)}M`;
+    if (v >= 1e3)
+        return `$${(v / 1e3).toFixed(1)}K`;
+    return `$${v.toFixed(0)}`;
+}
+const hold = (sec) => (sec < 90 ? `${Math.round(sec)}s` : sec < 5400 ? `${Math.round(sec / 60)}m` : sec < 172800 ? `${(sec / 3600).toFixed(1)}h` : `${(sec / 86400).toFixed(1)}d`);
+const when = (t) => new Date(t).toISOString().slice(0, 16).replace('T', ' ');
+const stratOf = (t) => (t.strategy ? `${t.strategy.id}@${t.strategy.version ?? (t.strategy.hash ?? '').slice(0, 8)}` : 'manual');
+const tagOf = (id, source) => (id ? (source === 'structured' || source === 'rule' ? id : `${id}*`) : '—');
+function banner(v, rows) {
+    const out = [];
+    const f = v.file;
+    out.push(f.exists ? (f.check.ok ? `ledger ${v.path}: ${f.events.length} events, chain verified` : `ledger ${v.path}: FAILS its check at line ${f.check.at}: ${f.check.error}`) : `ledger ${v.path}: not written yet (\`dexterm ledger sync\` writes it)`);
+    if (v.pending.length)
+        out.push(`  + ${v.pending.length} events from the sources not in the file yet (shown here; \`dexterm ledger sync\` appends them)`);
+    for (const s of v.sources)
+        if (s.problem)
+            out.push(`  ! ${s.problem}`);
+    const modes = [...new Set(rows.map((t) => t.walletMode))];
+    if (modes.length > 1)
+        out.push('  PAPER, DEVNET and LIVE trades are mixed here: use --mode before comparing results.');
+    else if (modes[0] === 'paper')
+        out.push('  PAPER (simulated) trades.');
+    return out;
+}
+function tradesTable(rows) {
+    const head = `${pad('opened', 16)}  ${pad('symbol', 8)} ${pad('src', 9)} ${pad('mode', 6)} ${pad('strategy', 18)} ${pad('profile', 10)} ${pad('exit', 14)} ${lpad('size', 8)} ${lpad('%book', 6)} ${lpad('entry mc', 9)} ${lpad('exit mc', 9)} ${lpad('P/L', 8)} ${lpad('hold', 6)} ${lpad('MFE', 7)} ${lpad('MAE', 7)}  id`;
+    const out = [head];
+    for (const t of rows) {
+        const size = t.sizeSol !== null ? `${num(t.sizeSol, 3)}◎` : t.sizeUsd !== null ? `$${num(t.sizeUsd, 0)}` : '—';
+        out.push([
+            pad(when(t.openedAt), 16), ' ', pad(t.symbol, 8), ' ', pad(t.source, 9), ' ', pad(t.walletMode, 6), ' ', pad(stratOf(t), 18), ' ',
+            pad(tagOf(t.profile.id, t.profile.source), 10), ' ', pad(t.status === 'open' ? 'open' : `${t.exitReason.code ?? 'untagged'}${t.rug ? ' RUG' : ''}`, 14), ' ',
+            lpad(size, 8), ' ', lpad(t.pctOfBook === null ? '—' : `${t.pctOfBook.toFixed(0)}%`, 6), ' ', lpad(fmtCap(t.entryMcapUsd), 9), ' ', lpad(fmtCap(t.exitMcapUsd), 9), ' ',
+            lpad(t.status === 'open' ? '—' : pct(t.pnlPct), 8), ' ', lpad(hold(t.holdSec), 6), ' ', lpad(pct(t.mfePct), 7), ' ', lpad(pct(t.maePct), 7), '  ', t.tradeId,
+        ].join(''));
+    }
+    return out;
+}
+// ───────────────────────────── subcommands ─────────────────────────────
+export async function ledgerCommand(argv, io) {
+    const sub = argv[0];
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        io.stdout.write(`${LEDGER_HELP}\n`);
+        return 0;
+    }
+    const o = parse(argv.slice(1));
+    if (typeof o === 'string') {
+        io.stderr.write(`dexterm ledger: ${o}\n`);
+        return 2;
+    }
+    const now = Date.now();
+    const json = o.json === true;
+    const out = (s) => io.stdout.write(s.endsWith('\n') ? s : `${s}\n`);
+    try {
+        if (sub === 'verify') {
+            const { readTradeLedger, tradeLedgerPath } = await import('../../data/src/trade/ledger/index.js');
+            const path = tradeLedgerPath(io.env);
+            const r = readTradeLedger(path);
+            if (json)
+                out(JSON.stringify({ path, exists: r.exists, ...r.check }));
+            else if (!r.exists)
+                out(`${path}: not written yet (nothing to verify)`);
+            else
+                out(r.check.ok ? `${path}: ${r.check.events} events, chain verified, head ${r.check.head.slice(0, 16)}` : `${path}: FAILS at line ${r.check.at}: ${r.check.error}`);
+            return r.exists && !r.check.ok ? 1 : 0;
+        }
+        if (sub === 'sync') {
+            const at = await import('../../autotrade/src/index.js');
+            const r = at.syncLedger({ env: io.env, now, ...(typeof o['wallet-db'] === 'string' ? { walletDb: o['wallet-db'] } : {}) });
+            const problems = r.view.sources.filter((s) => s.problem).map((s) => s.problem);
+            if (json)
+                out(JSON.stringify({ path: r.view.path, added: r.added, skipped: r.skipped, events: r.events, head: r.head, sources: r.view.sources }));
+            else {
+                out(`${r.view.path}: +${r.added} events (${r.skipped} already there), ${r.events} total, head ${r.head.slice(0, 16)}`);
+                for (const s of r.view.sources)
+                    out(`  ${pad(s.source, 9)} ${s.label}: ${s.events} source events, ${s.pending} new${s.note ? ` · ${s.note}` : ''}`);
+                for (const p of problems)
+                    out(`  ! ${p}`);
+            }
+            return 0;
+        }
+        const fr = await filterOf(o, now);
+        if (!fr.ok) {
+            io.stderr.write(`dexterm ledger: ${fr.error}\n`);
+            return 2;
+        }
+        const { filterTrades, summarize, equityCurve, compareStrategies, exportTrades, EXPORT_FORMATS } = await import('../../data/src/trade/ledger/index.js');
+        const v = await loadView(io, o, now);
+        const filter = sub === 'positions' ? { ...fr.filter, status: 'open' } : fr.filter;
+        const rows = filterTrades(v.trades, filter).sort((a, b) => b.openedAt - a.openedAt);
+        switch (sub) {
+            case 'trades':
+            case 'positions': {
+                const limit = typeof o.limit === 'string' ? Math.max(1, Math.min(10_000, Number.parseInt(o.limit, 10) || 50)) : sub === 'positions' ? 10_000 : 50;
+                const shown = rows.slice(0, limit);
+                if (json) {
+                    out(JSON.stringify({ count: rows.length, trades: shown }));
+                    return 0;
+                }
+                for (const l of banner(v, rows))
+                    out(l);
+                if (!rows.length) {
+                    out(sub === 'positions' ? 'no open trades' : 'no trades match');
+                    return 0;
+                }
+                for (const l of tradesTable(shown))
+                    out(l);
+                out(`${shown.length} of ${rows.length} shown · profile/exit with * = not declared structurally (tag line, late, default)`);
+                return 0;
+            }
+            case 'summary': {
+                const s = summarize(rows);
+                if (json) {
+                    out(JSON.stringify(s));
+                    return 0;
+                }
+                for (const l of banner(v, rows))
+                    out(l);
+                const u = s.unit === 'SOL' ? '◎' : '$';
+                out(`trades ${s.trades} closed · ${s.open} open · wins ${s.wins} · losses ${s.losses}`);
+                out(`win rate ${s.winRate ? `${frac(s.winRate.value)} (95% ${frac(s.winRate.lo)}–${frac(s.winRate.hi)})` : '—'} · P/L ${num(s.pnl, s.unit === 'SOL' ? 3 : 2)}${u} · avg ${pct(s.avgPnlPct)} · median ${pct(s.medianPnlPct)} · best ${pct(s.bestPct)} · worst ${pct(s.worstPct)}`);
+                out(`profit factor ${num(s.profitFactor)} · max drawdown ${num(s.maxDrawdown, 3)}${u}${s.maxDrawdownPct !== null ? ` (${num(s.maxDrawdownPct, 1)}%)` : ''} · rugs ${s.rugs} (${frac(s.rugRate)}) · avg hold ${s.avgHoldSec === null ? '—' : hold(s.avgHoldSec)} · MFE ${pct(s.avgMfePct)} · MAE ${pct(s.avgMaePct)}`);
+                out(`fees ${num(s.feesSol, 4)}◎ · model cost $${num(s.modelCostUsd)} · declared profile ${frac(s.tagCoverage.profileDeclared)} · declared exit ${frac(s.tagCoverage.exitDeclared)}`);
+                for (const [title, gs] of [['by profile', s.byProfile], ['by exit reason', s.byExitReason], ['by strategy', s.byStrategy], ['by source', s.bySource], ['by mode', s.byMode]]) {
+                    if (!gs.length)
+                        continue;
+                    out(`\n${title}`);
+                    for (const g of gs)
+                        out(`  ${pad(g.key, 22)} ${lpad(String(g.trades), 4)} closed ${lpad(String(g.open), 3)} open  win ${lpad(frac(g.winRate), 4)}  P/L ${lpad(num(g.pnl, s.unit === 'SOL' ? 3 : 2), 9)}${u}  avg ${lpad(pct(g.avgPnlPct), 7)}  rugs ${g.rugs}`);
+                }
+                if (s.trades < 30)
+                    out(`\n${s.trades} closed trades: a small sample says little (see the interval).`);
+                return 0;
+            }
+            case 'equity': {
+                const c = equityCurve(rows);
+                if (json) {
+                    out(JSON.stringify(c));
+                    return 0;
+                }
+                for (const l of banner(v, rows))
+                    out(l);
+                const u = c.unit === 'SOL' ? '◎' : '$';
+                out(`realized equity (${c.unit}), ${c.points.length} closes · final ${num(c.final, 3)}${u} · max drawdown ${num(c.maxDrawdown, 3)}${u}${c.maxDrawdownPct !== null ? ` (${num(c.maxDrawdownPct, 1)}%)` : ''}`);
+                const step = Math.max(1, Math.ceil(c.points.length / 40));
+                for (const [i, p] of c.points.entries())
+                    if (i % step === 0 || i === c.points.length - 1)
+                        out(`  ${when(p.t)}  ${pad(p.symbol, 8)} ${lpad(num(p.pnl, 3), 9)}  cum ${lpad(num(p.cum, 3), 9)}  dd ${lpad(num(p.drawdown, 3), 8)}`);
+                return 0;
+            }
+            case 'compare': {
+                const c = compareStrategies(rows);
+                if (json) {
+                    out(JSON.stringify(c));
+                    return 0;
+                }
+                for (const l of banner(v, rows))
+                    out(l);
+                const u = c.unit === 'SOL' ? '◎' : '$';
+                out(`${pad('strategy', 24)} ${pad('modes', 12)} ${lpad('trades', 6)} ${lpad('open', 4)} ${lpad('win', 4)} ${pad(' (95%)', 10)} ${lpad(`P/L ${u}`, 9)} ${lpad('avg', 7)} ${lpad('maxDD', 8)} ${lpad('rugs', 5)} ${lpad('hold', 6)} ${lpad('MFE', 7)} ${lpad('MAE', 7)} ${lpad('model $', 8)}`);
+                for (const r of c.rows)
+                    out(`${pad(r.key, 24)} ${pad(r.modes.join(','), 12)} ${lpad(String(r.trades), 6)} ${lpad(String(r.open), 4)} ${lpad(frac(r.winRate?.value), 4)} ${pad(r.winRate ? ` ${frac(r.winRate.lo)}–${frac(r.winRate.hi)}` : '', 10)} ${lpad(num(r.pnl, 3), 9)} ${lpad(pct(r.avgPnlPct), 7)} ${lpad(num(r.maxDrawdown, 3), 8)} ${lpad(frac(r.rugRate), 5)} ${lpad(r.avgHoldSec === null ? '—' : hold(r.avgHoldSec), 6)} ${lpad(pct(r.avgMfePct), 7)} ${lpad(pct(r.avgMaePct), 7)} ${lpad(num(r.modelCostUsd), 8)}`);
+                return 0;
+            }
+            case 'export': {
+                const fmt = o._[0] ?? (typeof o.format === 'string' ? o.format : undefined);
+                if (!fmt || !EXPORT_FORMATS.includes(fmt)) {
+                    io.stderr.write(`dexterm ledger export: the format is ${EXPORT_FORMATS.join(' | ')}\n`);
+                    return 2;
+                }
+                const text = exportTrades(rows, fmt, { exportedAt: now, ledgerHead: v.file.check.ok ? v.file.check.head : null, unit: summarize(rows).unit, filters: { ...filter } });
+                if (typeof o.out === 'string') {
+                    writeFileSync(o.out, text, { mode: 0o600 });
+                    io.stderr.write(`wrote ${rows.length} trades to ${o.out}\n`);
+                }
+                else
+                    io.stdout.write(text);
+                return 0;
+            }
+            case 'card': {
+                const id = o._[0];
+                const t = id ? v.trades.find((x) => x.tradeId === id) : undefined;
+                if (!t) {
+                    io.stderr.write(`dexterm ledger card: ${id ? `no trade ${id}` : 'pass a tradeId (from `dexterm ledger trades`)'}\n`);
+                    return 2;
+                }
+                const card = await import("./pnl-card.js");
+                const solUsd = typeof o['sol-usd'] === 'string' ? Number(o['sol-usd']) : null;
+                if (solUsd !== null && !(solUsd > 0)) {
+                    io.stderr.write('dexterm ledger card: --sol-usd is a positive number\n');
+                    return 2;
+                }
+                const input = card.ledgerCardInput(t, { solUsd: solUsd ? { usd: solUsd, source: '--sol-usd' } : null });
+                const s = card.computeCard(input, now);
+                const opts = { aspect: o.square === true ? 'square' : 'wide', exactSize: o.exact === true, ...(o.price === true ? { basis: 'price' } : {}) };
+                const files = card.saveCard(s, opts, { env: io.env, now });
+                out(card.cardText(s, opts));
+                out(`saved ${files.wide}\n      ${files.square}\n      ${files.txt}`);
+                return 0;
+            }
+            default:
+                io.stderr.write(`dexterm ledger: unknown subcommand ${JSON.stringify(sub)}\n\n${LEDGER_HELP}\n`);
+                return 2;
+        }
+    }
+    catch (e) {
+        io.stderr.write(`dexterm ledger: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+}

package/dist/packages/cli/src/live/chart-fills.js

@@ -0,0 +1,46 @@
+const abs = (n) => (n < 0n ? -n : n);
+const fin = (n) => typeof n === 'number' && Number.isFinite(n) && n > 0;
+/** A paper ledger row → a chart fill (its own USD price when the paper engine recorded one). */
+export function paperChartFill(r) {
+    return {
+        t: r.t, side: r.side, source: 'paper',
+        priceUsd: fin(r.priceUsd) ? r.priceUsd : null,
+        tokens: Number(abs(r.tokenDelta)) / 10 ** r.decimals,
+        sol: Number(abs(r.grossLamports)) / 1e9,
+    };
+}
+/** How many paper rows are scanned for one mint (the wallet has no per-mint read; older history drops off first). */
+export const CHART_FILLS_PAPER_SCAN = 2000;
+/** How long one mint's fills are reused (the render loop asks every frame; the popup up to ~20×/s). */
+export const CHART_FILLS_MEMO_MS = 1000;
+/** Every paper fill for one mint, oldest first. A ledger that cannot be read contributes nothing. */
+export function chartFillsFor(mint, rd) {
+    const out = [];
+    try {
+        for (const r of rd.paper?.(CHART_FILLS_PAPER_SCAN) ?? [])
+            if (r.mint === mint)
+                out.push(paperChartFill(r));
+    }
+    catch { /* unreadable paper ledger: no paper marks */ }
+    return out.sort((a, b) => a.t - b.t);
+}
+/** chartFillsFor memoised per mint for CHART_FILLS_MEMO_MS (a fill shows on the chart within a second). */
+export class ChartFills {
+    memo = new Map();
+    rd;
+    now;
+    constructor(rd, now = Date.now) { this.rd = rd; this.now = now; }
+    for(mint) {
+        const now = this.now();
+        const m = this.memo.get(mint);
+        if (m && now - m.at >= 0 && now - m.at < CHART_FILLS_MEMO_MS)
+            return m.v;
+        const v = chartFillsFor(mint, this.rd);
+        if (this.memo.size > 32)
+            this.memo.clear();
+        this.memo.set(mint, { at: now, v });
+        return v;
+    }
+    /** Forget every memo (after a fill this run booked). */
+    invalidate() { this.memo.clear(); }
+}

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 '';
@@ -560,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/token-live.js

@@ -19,7 +19,7 @@ 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, chartTitle, priceModeOf, chartAxisOf, 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. */
@@ -139,8 +139,11 @@ export function renderTokenLive(c, state, v) {
     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;
@@ -322,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 });
@@ -337,7 +340,7 @@ export function renderTokenLive(c, state, v) {
     }
     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 });
+        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);
@@ -394,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;