dexterm-cli 0.1.6 → 0.1.7

package/dist/packages/cli/src/screens/autotrade-worker.js

@@ -0,0 +1,89 @@
+// dexterm — AUTOTRADE screen backtests off the render loop (task-1508). A lockstep backtest over two weeks of
+// recorded history is CPU-bound for seconds and a sweep for much longer, so the Q screen runs them in a worker
+// thread: the worker opens the recorder DB read-only, builds the tape once, runs the engine and posts the
+// report back. PAPER, recorded data only: no network, no model, no keys. The same module is the worker entry
+// (it checks workerData) and the main-thread client (workerJobs). Tests use inlineJobs over a fixture tape.
+import { existsSync } from 'node:fs';
+import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { defaultDbPath } from '../../../data/src/index.js';
+import { openHistoryReadOnly } from '../../../recorder/src/index.js';
+import { backtest, sweep, tapeFromDb, tapeFromDoc } from '../../../autotrade/src/index.js';
+const DAY_MS = 86_400_000;
+/** The equity curve is resampled to this many points before it crosses the thread boundary (it feeds a sparkline). */
+const CURVE_POINTS = 240;
+const TAG = 'dexterm-autotrade-job/1';
+function resample(xs, n) {
+    if (xs.length <= n)
+        return xs;
+    return Array.from({ length: n }, (_, i) => xs[Math.round((i * (xs.length - 1)) / (n - 1))]);
+}
+/** The recorder's history as a tape, read-only (the same window rules as `dexterm autotrade backtest --days N`). */
+export function tapeFromRecorder(dbPath, days, until) {
+    const none = `no recorded history in ${dbPath} (run the app with the recorder on first)`;
+    if (!existsSync(dbPath))
+        throw new Error(none);
+    let db;
+    try {
+        db = openHistoryReadOnly(dbPath);
+    }
+    catch {
+        throw new Error(none);
+    }
+    if (!db)
+        throw new Error(none);
+    try {
+        return tapeFromDoc(tapeFromDb(db, { since: until - days * DAY_MS, until, minPeakLiqUsd: 20_000, spanHours: 80 }));
+    }
+    finally {
+        db.close();
+    }
+}
+export async function backtestOn(tape, ss) {
+    const out = [];
+    for (const s of ss) {
+        const { report, run } = await backtest(s, tape);
+        out.push({ report, curve: resample(run.equityCurve.map((p) => p.equity), CURVE_POINTS) });
+    }
+    return out;
+}
+/** Jobs that run on the calling thread over a tape the caller supplies (tests, over a committed fixture tape). */
+export function inlineJobs(tape) {
+    return {
+        backtest: async (ss) => backtestOn(tape(), ss),
+        sweep: async (s, grid) => sweep(s, tape(), grid),
+    };
+}
+/** Jobs in a worker thread over the recorder DB (the app). One worker per job; it exits when done. */
+export function workerJobs(env = process.env) {
+    const dbPath = env.DEXTERM_DB_PATH || defaultDbPath(env);
+    const run = (job) => new Promise((resolve, reject) => {
+        const w = new Worker(new URL(import.meta.url), { workerData: { tag: TAG, job } });
+        w.unref();
+        w.once('message', (m) => { if (m.ok)
+            resolve(m.value);
+        else
+            reject(new Error(m.error)); });
+        w.once('error', reject);
+        w.once('exit', (code) => { if (code !== 0)
+            reject(new Error(`backtest worker exited with code ${code}`)); });
+    });
+    return {
+        backtest: (strategies, o) => run({ kind: 'backtest', strategies, days: o.days, until: o.until, dbPath }),
+        sweep: (strategy, grid, o) => run({ kind: 'sweep', strategy, grid, days: o.days, until: o.until, dbPath }),
+    };
+}
+// ───────────────────────────── worker entry ─────────────────────────────
+if (!isMainThread && parentPort && workerData?.tag === TAG) {
+    const job = workerData.job;
+    const port = parentPort;
+    void (async () => {
+        try {
+            const tape = tapeFromRecorder(job.dbPath, job.days, job.until);
+            const value = job.kind === 'backtest' ? await backtestOn(tape, job.strategies) : await sweep(job.strategy, tape, job.grid);
+            port.postMessage({ ok: true, value });
+        }
+        catch (e) {
+            port.postMessage({ ok: false, error: e.message ?? String(e) });
+        }
+    })();
+}

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

@@ -6,7 +6,8 @@
 //      mode: the scan's own log plus the scan analyst's answer.
 //   2. VETTING $SYM: the checklist for the coin in focus, each box with the number the app computed and pass / warn /
 //      fail / pending (pending = the number is not in yet). A ◆ marks the checks the agent itself ran.
-//   3. DATA: mcap, price, liquidity, 5m / 1h, buy/sell flow, holders, and a candle trace.
+//   3. DATA: mcap, price, liquidity, 5m / 1h, buy/sell flow, holders, and a candle trace (task-1483: with a B / S cell
+//      on the candle of every paper / live fill of the coin, from the ledgers; the rest is said, never moved).
 //   4. PLAN · POSITION (only while a PAPER ticket / position exists): entry, size, TP / stop, mark PnL, peak, time held,
 //      what it is waiting for.
 //   5. DECISIONS: the session log (passed X because…, rejected Y, entered Z) and the scoreboard (PAPER, simulated).
@@ -15,7 +16,7 @@
 // panel has no input. Agent text arrives scrubbed and clipped (story.ribbonText) with addresses shortened.
 // Smaller panels drop blocks in priority order (decisions, then data, then the vetting list folds to two columns);
 // calm mode shows the same information with no typing; NO_COLOR keeps meaning in glyphs (✓ ! ✗ · ◆ ❯ ›).
-import { mix, clock, decryptText, fmtUsd, fmtPrice, fmtNum, wrap } from '../../../tui/src/index.js';
+import { mix, clock, decryptText, fmtUsd, fmtPrice, fmtMcap, fmtNum, wrap, chartMarkers, markerLetter, MARKER_PERIOD_MS } from '../../../tui/src/index.js';
 import { ribbonText, ribbonLines, fmtPx } from '../../../agents/src/index.js';
 // ---------------------------------------------------------------------------------------------------------------
 // formatting (deterministic, no locale)
@@ -73,8 +74,18 @@ export function factsFromView(v, extra = {}) {
         holders: v.holders, top10: extra.top10 ?? v.top10, mintAuth: v.mintAuth, freezeAuth: v.freezeAuth, lpLocked: v.lpLocked,
         dev: extra.dev ?? (v.devMints === null ? null : [`${v.devMints} mints by dev (jup)`, v.devMints > 3 ? 'warn' : 'ok']),
         rugScore: v.rug?.score ?? null, larpVerdict: extra.larpVerdict ?? null, closes: v.candles.map((k) => k.c),
+        closeTimes: v.candles.map((k) => k.t), periodMs: MARKER_PERIOD_MS[v.interval], fills: extra.fills ?? undefined,
     };
 }
+/** task-1483: the trace's B / S cells for the last `width` closes (the same model as the charts; display only). */
+export function traceMarks(f, width = 240) {
+    if (!f || !f.fills?.length || !f.closeTimes || f.closeTimes.length !== f.closes.length || !f.periodMs)
+        return null;
+    const times = f.closeTimes.slice(-width);
+    const set = chartMarkers(f.fills, { periodMs: f.periodMs, barTimes: times });
+    const off0 = f.closes.length - times.length;
+    return { cells: set.markers.map((m) => ({ index: off0 + m.index, side: m.side, source: m.source, count: m.count })), off: set.before + set.after + set.gap };
+}
 // ---------------------------------------------------------------------------------------------------------------
 // 1) reasoning stream
 /** Agent thoughts and dexterm narration, newest last (≤ max). */
@@ -216,12 +227,18 @@ export function planFromThoughts(thoughts, since) {
     return { tp, stop };
 }
 /** The PLAN / POSITION block for the agent's PAPER arc (null when there is no ticket or position). */
-export function planVM(v, now) {
+/** task-1537: the coin's supply from its facts (mcap ÷ price at the same tick), null when either is missing. */
+function capScale(f) {
+    return f.mcap !== null && f.price !== null && f.price > 0 && f.mcap > 0 ? { mint: f.mint, supply: f.mcap / f.price } : null;
+}
+export function planVM(v, now, cap = null) {
     const a = v.arc;
     if (!a || a.stage === 'closed' || a.stage === 'refused')
         return null;
     const said = planFromThoughts(v.thoughts, a.openedAt);
     const open = a.stage === 'open';
+    // task-1537: entry / mark as market caps when the card's coin has a known supply, else prices
+    const lvl = (u) => (cap && cap.mint === a.mint ? fmtMcap(u * cap.supply) : `$${fmtPx(u)}`);
     const pnlUsd = open && a.pnlPct !== null && a.sizeUsd !== null ? a.sizeUsd * a.pnlPct : null;
     const dd = open && a.pnlPct !== null && a.peakPct !== null ? (1 + a.pnlPct) / (1 + a.peakPct) - 1 : null;
     const tp = said.tp ? `TP ${said.tp} (agent's plan)` : 'TP agent-managed';
@@ -231,12 +248,12 @@ export function planVM(v, now) {
         : said.tp ? `TP ${said.tp} · agent-managed exit, no resting order on PAPER` : 'the agent\'s exit call · no resting orders on PAPER';
     return {
         symbol: a.symbol, stage: a.stage,
-        entry: a.entryUsd !== null ? `$${fmtPx(a.entryUsd)}` : '—',
+        entry: a.entryUsd !== null ? lvl(a.entryUsd) : '—',
         size: a.sizeUsd !== null ? `$${a.sizeUsd.toFixed(2)}${a.spentSol > 0 ? ` (${a.spentSol.toFixed(4)} SOL)` : ''}` : a.spentSol > 0 ? `${a.spentSol.toFixed(4)} SOL` : 'sizing…',
         tp, stop,
         pnlPct: open ? a.pnlPct : null, pnlUsd, peakPct: open ? a.peakPct : null, ddPct: dd,
         heldMs: open && a.filledAt !== null ? now - a.filledAt : null,
-        mark: a.mark ? `$${fmtPx(a.mark.priceUsd)}` : '—',
+        mark: a.mark ? lvl(a.mark.priceUsd) : '—',
         waiting, trace: a.trace.map((s) => s.pct),
         refused: open && a.refusal && v.beats.refusedAt !== null && now - v.beats.refusedAt < 3500 ? a.refusal : null,
     };
@@ -261,15 +278,15 @@ export function scanLogLines(log, tz) {
 }
 // ---------------------------------------------------------------------------------------------------------------
 // the whole model
-export function agentBrainModel(v, facts, now, tz) {
+export function agentBrainModel(v, facts, now, tz, mcap = false) {
     const s = agentStream(v, tz);
     const status = v.control === 'paused' ? '❚❚ paused by you · its next call is held' : v.control === 'takeover' ? 'you are driving · the agent is frozen' : null;
     return {
         mode: 'agent', title: `✦ BRAIN · ${v.agent}`, streamLabel: s.label, demo: s.demo, stream: s.lines, status,
         coin: facts ? { symbol: facts.symbol, mint: facts.mint } : v.focus ? { symbol: v.focus.symbol, mint: v.focus.mint } : null,
         vet: facts ? vetRows(facts, v.focus) : [],
-        data: facts ? dataCells(facts) : [], closes: facts?.closes ?? [],
-        plan: planVM(v, now), log: decisionLog(v, tz), score: scoreLine(v.score),
+        data: facts ? dataCells(facts) : [], closes: facts?.closes ?? [], marks: traceMarks(facts),
+        plan: planVM(v, now, mcap && facts ? capScale(facts) : null), log: decisionLog(v, tz), score: scoreLine(v.score),
     };
 }
 export function scanBrainModel(s, facts, tz) {
@@ -279,7 +296,7 @@ export function scanBrainModel(s, facts, tz) {
         mode: 'scan', title: '✦ BRAIN · AI scan', streamLabel: 'scan log + the scan analyst (observe-only)', demo: false,
         stream: scanStream(s.log, s.answer, tz), status: `◉ ${s.mode}${s.lock ? ` $${s.lock.symbol} · score ${s.lock.score} · read ${s.lock.reads}` : ''} · ${s.scanned} coins${s.note ? ` · ${s.note}` : ''}`,
         coin: facts ? { symbol: facts.symbol, mint: facts.mint } : null,
-        vet: facts ? vetRows(facts, null, s.floorUsd) : [], data: facts ? dataCells(facts) : [], closes: facts?.closes ?? [],
+        vet: facts ? vetRows(facts, null, s.floorUsd) : [], data: facts ? dataCells(facts) : [], closes: facts?.closes ?? [], marks: traceMarks(facts),
         plan: null, log: scanLogLines(s.log, tz), score: `locks ${locks} · reads ${reads} · ${s.usage || 'ai cap'} · observe-only · never trades`,
     };
 }
@@ -491,7 +508,7 @@ function drawVet(c, x, y, w, rows, m, compact, bg) {
 }
 function drawData(c, x, y, w, m, bg) {
     const t = c.theme;
-    section(c, x, y, w, 'DATA', 'app numbers · no extra fetch', bg, t.accent);
+    section(c, x, y, w, 'DATA', m.marks?.cells.length ? 'app numbers · B/S = your fills' : 'app numbers · no extra fetch', bg, t.accent);
     let cx = x + 1;
     for (const d of m.data) {
         const need = d.k.length + 1 + d.v.length + 2;
@@ -510,6 +527,15 @@ function drawData(c, x, y, w, m, bg) {
         const up = cl[cl.length - 1] >= cl[0];
         c.text(x + 1, y + 2, up ? '▲' : '▼', { fg: up ? t.up : t.down, bg, b: true });
         cl.forEach((v, i) => c.put(x + 3 + i, y + 2, LV[Math.round(((v - lo) / span) * 7)], { fg: mix(bg, up ? t.up : t.down, 0.45 + 0.55 * (i / Math.max(1, cl.length - 1))), bg, soft: true }));
+        // task-1483: a B / S cell on the candle of each fill (live = solid, paper = tinted); a buy wins a shared cell's colour
+        const first = m.closes.length - cl.length;
+        for (const mk of m.marks?.cells ?? []) {
+            const i = mk.index - first;
+            if (i < 0 || i >= cl.length)
+                continue;
+            const col = mk.side === 'buy' ? t.up : t.down;
+            c.put(x + 3 + i, y + 2, markerLetter(mk.side), mk.source === 'live' ? { fg: '#000000', bg: col, b: true, hard: true } : { fg: col, bg: mix(bg, col, 0.25), b: true, hard: true });
+        }
     }
     else
         c.text(x + 1, y + 2, '· no candles yet', { fg: t.dim, bg, i: true });
@@ -586,7 +612,7 @@ export function brainFor(h, facts, calm, scanUsage = '') {
         const now = hud.clock();
         const v = hud.story.view(now);
         if (agentBrainActive(v, now))
-            return { model: agentBrainModel(v, facts, now, h.timeZone), opts: { now, calm: calm || !!hud.reduced, depth: h.colorDepth, frame: h.vfx.frame } };
+            return { model: agentBrainModel(v, facts, now, h.timeZone, h.priceMode !== 'price'), opts: { now, calm: calm || !!hud.reduced, depth: h.colorDepth, frame: h.vfx.frame } };
     }
     const scan = h.scan;
     if (scan?.engine.on) {

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

@@ -11,8 +11,9 @@ 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;
-/** The chip for the followed agent's open PAPER position, or null when nothing is held. */
-export function pnlChipVM(v, now) {
+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;
@@ -22,8 +23,8 @@ export function pnlChipVM(v, now) {
         symbol: a.symbol,
         pnlPct: a.pnlPct,
         pnlUsd: a.pnlPct !== null && a.sizeUsd !== null ? a.sizeUsd * a.pnlPct : null,
-        entry: a.entryUsd !== null ? `$${fmtPx(a.entryUsd)}` : '—',
-        mark: a.mark ? `$${fmtPx(a.mark.priceUsd)}` : '—',
+        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,
@@ -53,7 +54,7 @@ export class OwnPnlTracker {
         }
     }
     get mint() { return this.cur?.s.mint ?? null; }
-    vm(now) {
+    vm(now, lvl = PRICE_LEVEL) {
         const c = this.cur;
         if (!c)
             return null;
@@ -64,12 +65,12 @@ export class OwnPnlTracker {
             symbol: s.symbol,
             pnlPct: s.pnlPct,
             pnlUsd: s.pnlUsd,
-            entry: s.entryUsd !== null ? `$${fmtPx(s.entryUsd)}` : '—',
-            mark: s.markUsd !== null ? `$${fmtPx(s.markUsd)}` : '—',
+            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 ? `$${fmtPx(s.targetUsd)}` : 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,
         };

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 });