dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/mcp/src/spectator-sink.js

@@ -88,9 +88,94 @@ export function recordForToolCall(opts) {
         agent: opts.agent, transport: 'mcp', tool: opts.tool,
         summary: isErr ? `error: ${String(opts.result.error).slice(0, 80)}` : paperSummary(opts.tool, opts.args, opts.result) ?? `${opts.tool}${shortMint(opts.args)}`,
         ms: opts.ms, dataAgeSec: isErr ? null : maxAgeSec(opts.result), nav, ok: !isErr,
+        ...(() => { const d = detailFor(opts.tool, opts.args, opts.result); return d ? { detail: d } : {}; })(),
         ...(opts.token ? { token: opts.token } : {}),
     };
 }
+const num = (x) => (typeof x === 'number' && Number.isFinite(x) ? x : null);
+/** A firewalled field's inner text (`<untrusted …>X</untrusted>` → X; the inner text is already scrubbed upstream). */
+const unwrap = (x) => x.replace(/^<untrusted\b[^>]*>([\s\S]*?)<\/untrusted>$/, '$1');
+const str = (x, max = 16) => (typeof x === 'string' && x ? unwrap(x).slice(0, max) || null : null);
+const MINT_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+const mintOf = (x) => (typeof x === 'string' && MINT_RE.test(x) ? x : null);
+/**
+ * task-1466: the app-computed numbers behind one call, for the follow view (SpectatorDetail in @dexterm/agents).
+ * Copied from the tool's OWN result (a screener page, a verdict, a PAPER ticket / fill / position, the caps the
+ * desk replayed); agent-supplied args only name the coin. null when the call has nothing worth showing.
+ */
+export function detailFor(tool, args, result) {
+    const d = {};
+    if (typeof result.error === 'string') {
+        if (tool.startsWith('paper_') && typeof result.reason === 'string')
+            d.refusal = result.reason.slice(0, 40);
+        return Object.keys(d).length ? d : null;
+    }
+    if (tool === 'screener_query' && Array.isArray(result.rows)) {
+        d.rows = result.rows.slice(0, 12).flatMap((r) => {
+            const mint = mintOf(r.mint);
+            if (!mint)
+                return [];
+            const pc = (r.priceChange ?? {});
+            return [{ mint, symbol: str(r.symbol) ?? '?', chg: num(pc.h1) }];
+        });
+    }
+    if (tool === 'screen_state' && Array.isArray(result.visible)) {
+        d.rows = result.visible.slice(0, 12).flatMap((r) => {
+            const mint = mintOf(r.mint);
+            return mint ? [{ mint, symbol: str(r.symbol) ?? '?', chg: num(r.chg1h) }] : [];
+        });
+    }
+    if (tool === 'get_token') {
+        const tk = (result.token ?? {});
+        const pair = (result.pair ?? {});
+        const mint = mintOf(tk.mint) ?? mintOf(args.mint);
+        if (mint)
+            d.coin = { mint, symbol: str(tk.symbol), priceUsd: num(pair.priceUsd) };
+    }
+    else if (tool === 'analyze_token') {
+        const mint = mintOf(result.mint) ?? mintOf(args.mint);
+        if (mint)
+            d.coin = { mint, symbol: str(result.symbol) };
+        const label = str(result.deterministic_verdict, 18);
+        if (label)
+            d.verdict = { label, rug: num(result.rug_probability) };
+    }
+    else if (tool === 'larp_check') {
+        const mint = mintOf(result.mint) ?? mintOf(args.mint);
+        if (mint)
+            d.coin = { mint, symbol: str(result.symbol) };
+        const flags = Array.isArray(result.flags) ? result.flags.filter((f) => typeof f === 'string') : [];
+        d.larp = { flags: flags.length, items: flags.slice(0, 6).map((f) => f.slice(0, 60)) };
+    }
+    else if (['open_token', 'get_trades', 'get_candles', 'get_holders', 'rugcheck', 'get_dev_history', 'dev_history', 'get_dossier'].includes(tool)) {
+        const mint = mintOf(args.mint);
+        if (mint)
+            d.coin = { mint, symbol: str(args.symbol) };
+    }
+    if (tool === 'paper_open_ticket' || tool === 'paper_size_ticket') {
+        const t = (result.ticket ?? {});
+        const mint = mintOf(t.mint);
+        if (mint && (t.side === 'buy' || t.side === 'sell'))
+            d.ticket = { side: t.side, symbol: str(t.symbol) ?? '?', mint, usd: num(t.usd), fraction: num(t.fraction) };
+    }
+    if (tool === 'paper_confirm' || tool === 'paper_close') {
+        const f = (result.fill ?? {});
+        const mint = mintOf(f.mint);
+        if (mint && (f.side === 'buy' || f.side === 'sell') && num(f.solDelta) !== null && num(f.tokens) !== null) {
+            d.fill = { side: f.side, symbol: str(f.symbol) ?? '?', mint, sol: num(f.solDelta), qty: num(f.tokens), priceUsd: num(f.priceUsd), impactPct: num(f.priceImpactPct), realizedSol: num(f.realizedSol) };
+        }
+        const p = (result.position ?? null);
+        const pm = p ? mintOf(p.mint) : null;
+        if (p && pm && num(p.tokens) !== null && num(p.costSol) !== null)
+            d.position = { mint: pm, symbol: str(p.symbol) ?? '?', qty: num(p.tokens), costSol: num(p.costSol), realizedSol: num(p.realizedSol) ?? 0 };
+    }
+    if (tool === 'paper_pnl') {
+        const m = (result.mandate ?? null);
+        if (m && num(m.perTradeUsd) !== null && num(m.totalUsd) !== null)
+            d.caps = { perTradeUsd: num(m.perTradeUsd), totalUsd: num(m.totalUsd), maxPriceImpactPct: num(m.maxPriceImpactPct) };
+    }
+    return Object.keys(d).length ? d : null;
+}
 export function fileSpectatorSinkFromEnv(env) {
     const file = env.DEXTERM_SPECTATOR_FILE;
     if (!file)

package/dist/packages/packs/src/backtest.js

@@ -87,7 +87,9 @@ export function runBacktest(doc, req, now = Date.now()) {
         leakage_checks: { ...leakageOK },
     };
     if (req.kind === 'strategy') {
-        return { n: rows.length, base_rate: 0, precision: null, recall: null, brier: null, brier_base_rate: null, auc: null, ...base, note: 'strategy/paper subject not implemented in this tier (needs the position-fill simulator, §6)' };
+        // task-1503: a strategy is scored by the @dexterm/autotrade engine over a replay tape (positions, fills,
+        // exits), not by this t0-features harness; `dexterm backtest --subject strategy` routes there.
+        return { n: rows.length, base_rate: 0, precision: null, recall: null, brier: null, brier_base_rate: null, auc: null, ...base, note: 'strategy/paper subject not implemented in this t0 harness: it runs on the autotrade engine over a replay tape (dexterm backtest --subject strategy --strategy <id>)' };
     }
     if (req.kind === 'watch_rule') {
         return { n: rows.length, base_rate: 0, precision: null, recall: null, brier: null, brier_base_rate: null, auc: null, ...base, note: 'watch_rule subject not implemented in this tier (needs the rules engine, lane W-01)' };

package/dist/packages/packs/src/index.js

@@ -18,5 +18,6 @@ export * from "./backtest.js";
 // task-1359: LARP eval (recorded product verdicts vs outcome labels; counts only below n = 50).
 export * from "./larp-eval.js";
 export * from "./skill-backtest.js";
+export * from "./larp-score-backtest.js";
 // task-1414: skill care — rolling split, the proposal gate (new-coins + interval-noise + frozen canary), trend.
 export * from "./skill-care.js";

package/dist/packages/packs/src/larp-score-backtest.js

@@ -0,0 +1,119 @@
+// LARP score backtest + calibration (task-1471). Pure: input is the task-1401 eval set (skills-eval.json).
+//
+// The eval set holds, per coin, the URL-free link features the coin advertised at t0 and the recorder's 72 h
+// outcome (bad = rug or dead). That is the only part of the LARP score history can replay: pages, domains, GitHub
+// and X accounts were not captured point-in-time (and looking them up now leaks the outcome, because dead coins'
+// sites and accounts disappear). So this fits and scores the LINK-SHAPE flags only, and says so in every output.
+//
+// Pre-registered rule (written before the test split was scored):
+//  - fit on TRAIN only: for each link flag carried by ≥ LARP_SCORE_MIN_FLAG_N train coins,
+//    points = clamp(round(8 × ln OR), 0, 12), OR = Haldane-smoothed odds ratio of a bad outcome with vs without it;
+//    flags under that count keep their prior points;
+//  - bands are the fixed round thresholds 25 / 50 (LARP_SCORE_BANDS), never tuned;
+//  - report AUROC (ties count half) and P(bad) per band on train and on the held-out TEST split, with Wilson 95 %.
+import { LARP_SCORE_BANDS, LARP_SCORE_WEIGHTS, bandOf, linkFlagIds, linkScore } from '../../data/src/index.js';
+import { wilson } from "./larp-eval.js";
+export const LARP_SCORE_BACKTEST_SCHEMA = 'dexterm/packs/larp-score-backtest/1';
+export const LARP_SCORE_MIN_FLAG_N = 20;
+const SCALE = 8;
+const CAP = 12;
+/** The link-shape flags the eval set can carry (in a stable order). */
+export const LINK_FLAG_IDS = ['no_website', 'no_x', 'x_not_account', 'no_telegram', 'site_is_social', 'site_is_launchpad', 'site_linktree', 'site_free_host', 'domain_no_name_match', 'cheap_tld'];
+/** Fit the link-flag points on train rows. Throws on a test row (the split is fixed before tuning). */
+export function calibrateLinkPoints(train) {
+    if (train.some((r) => r.split !== 'train'))
+        throw new Error('calibrateLinkPoints: test rows are held out');
+    const N = train.length, B = train.filter((r) => r.bad).length;
+    return LINK_FLAG_IDS.map((id) => {
+        const has = train.filter((r) => linkFlagIds(r.link).includes(id));
+        const n = has.length, a = has.filter((r) => r.bad).length;
+        if (n < LARP_SCORE_MIN_FLAG_N)
+            return { id, n, bad: a, ln_or: null, points: LARP_SCORE_WEIGHTS[id].points, source: 'prior' };
+        const b = B - a, m = N - n;
+        const lnOr = Math.log(((a + 0.5) / (n - a + 0.5)) / ((b + 0.5) / (m - b + 0.5)));
+        return { id, n, bad: a, ln_or: Math.round(lnOr * 1000) / 1000, points: Math.max(0, Math.min(CAP, Math.round(SCALE * lnOr))), source: 'calibrated' };
+    });
+}
+/** AUROC with ties counted half. Null when a class is empty. */
+export function auroc(rows) {
+    const pos = rows.filter((r) => r.bad).map((r) => r.score), neg = rows.filter((r) => !r.bad).map((r) => r.score);
+    if (!pos.length || !neg.length)
+        return null;
+    let s = 0;
+    for (const p of pos)
+        for (const q of neg)
+            s += p > q ? 1 : p === q ? 0.5 : 0;
+    return s / (pos.length * neg.length);
+}
+function splitReport(rows, weights) {
+    const scored = rows.map((r) => ({ score: linkScore(r.link, weights), bad: r.bad }));
+    const by_band = { low: { n: 0, bad: 0, rate: null }, medium: { n: 0, bad: 0, rate: null }, high: { n: 0, bad: 0, rate: null } };
+    for (const s of scored) {
+        const b = by_band[bandOf(s.score)];
+        b.n++;
+        if (s.bad)
+            b.bad++;
+    }
+    for (const b of Object.values(by_band))
+        b.rate = b.n >= 20 ? wilson(b.bad, b.n) : null;
+    const B = scored.filter((s) => s.bad).length;
+    const at_threshold = [LARP_SCORE_BANDS.medium, LARP_SCORE_BANDS.high].map((t) => {
+        const f = scored.filter((s) => s.score >= t), tp = f.filter((s) => s.bad).length;
+        return { threshold: t, flagged: f.length, precision: f.length >= 20 ? wilson(tp, f.length) : null, recall: B ? wilson(tp, B) : null };
+    });
+    const sorted = scored.map((s) => s.score).sort((a, b) => a - b);
+    const q = (p) => sorted.length ? sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))] : 0;
+    const a = auroc(scored);
+    return { n: rows.length, bad: B, auroc: a === null ? null : Math.round(a * 1000) / 1000, by_band, at_threshold, score_quantiles: { p10: q(0.1), p50: q(0.5), p90: q(0.9), max: sorted.at(-1) ?? 0 } };
+}
+/** Fit on train, score train and test with the fitted points. */
+export function larpScoreBacktest(set) {
+    const train = set.rows.filter((r) => r.split === 'train'), test = set.rows.filter((r) => r.split === 'test');
+    const fit = calibrateLinkPoints(train);
+    const weights = Object.fromEntries(fit.map((f) => [f.id, f.points]));
+    return {
+        schema: LARP_SCORE_BACKTEST_SCHEMA,
+        eval: { built_at: set.built_at, horizon_sec: set.horizon_sec, rows: set.rows.length, label_rule: set.label_rule, split_rule: set.split_rule },
+        part: 'link-shape flags only (what the eval set holds point-in-time)',
+        method: [
+            `fit on the train split only (${train.length} coins): points = clamp(round(${SCALE} × ln odds ratio of a bad outcome), 0, ${CAP}) for a flag on ≥ ${LARP_SCORE_MIN_FLAG_N} train coins; rarer flags keep their prior points`,
+            `bands fixed before scoring: low < ${LARP_SCORE_BANDS.medium} ≤ medium < ${LARP_SCORE_BANDS.high} ≤ high (not tuned)`,
+            'AUROC with ties counted half; rates with 95% Wilson intervals, printed only for n ≥ 20',
+            'meaning: how well the link-shape points rank coins that went bad (a price outcome) above the rest, NOT whether a product is real',
+        ],
+        fit,
+        shipped_matches_fit: fit.every((f) => LARP_SCORE_WEIGHTS[f.id].points === f.points && LARP_SCORE_WEIGHTS[f.id].source === f.source),
+        train: splitReport(train, weights),
+        test: splitReport(test, weights),
+        not_measured: [
+            'website page flags (default page, wallet connect, drainer markers, never names the token): pages were not captured at t0',
+            'domain flags (new domain, registrant privacy) and GitHub flags: not captured at t0',
+            "X-account flags (new account, tiny following, no posts, suspended, handle mismatch): not captured at t0, and a lookup today leaks the outcome (dead coins' accounts get deleted or suspended); the X sources' robots.txt also rule out bulk crawling them for a backfill",
+            'the high band: link shape alone tops out below it by design, so its precision is unmeasured',
+        ],
+    };
+}
+const pct = (r) => (r === null ? 'counts only (n < 20)' : `${(r.value * 100).toFixed(1)}% [${(r.lo * 100).toFixed(0)}–${(r.hi * 100).toFixed(0)}]`);
+export function renderLarpScoreBacktestText(r) {
+    const L = [];
+    L.push(`LARP SCORE BACKTEST  ${r.part}`);
+    L.push(`  eval set built ${r.eval.built_at}, ${r.eval.rows} coins, horizon ${r.eval.horizon_sec}s; ${r.eval.label_rule}`);
+    L.push('  fitted points (train split):');
+    for (const f of r.fit)
+        L.push(`    ${f.id.padEnd(22)} n=${String(f.n).padStart(4)} bad=${String(f.bad).padStart(4)} ln OR=${f.ln_or === null ? '   —  ' : f.ln_or.toFixed(2).padStart(6)}  → ${String(f.points).padStart(2)} pts (${f.source})`);
+    L.push(`  shipped weights match this fit: ${r.shipped_matches_fit ? 'yes' : 'NO (re-tune or update LARP_SCORE_WEIGHTS)'}`);
+    for (const [name, s] of [['train', r.train], ['TEST (held out)', r.test]]) {
+        L.push(`  ${name}: n=${s.n} bad=${s.bad} (${((s.bad / Math.max(1, s.n)) * 100).toFixed(1)}%)  AUROC=${s.auroc === null ? '—' : s.auroc.toFixed(3)}  score p10/p50/p90/max=${s.score_quantiles.p10}/${s.score_quantiles.p50}/${s.score_quantiles.p90}/${s.score_quantiles.max}`);
+        for (const [b, v] of Object.entries(s.by_band))
+            L.push(`    band ${b.padEnd(6)} n=${String(v.n).padStart(4)} bad=${String(v.bad).padStart(4)}  P(bad)=${pct(v.rate)}`);
+        for (const t of s.at_threshold)
+            L.push(`    score ≥ ${t.threshold}: flagged ${t.flagged}  precision=${pct(t.precision)}  recall=${t.recall ? pct(t.recall) : '—'}`);
+    }
+    L.push('  method:');
+    for (const m of r.method)
+        L.push(`    - ${m}`);
+    L.push('  not measured:');
+    for (const m of r.not_measured)
+        L.push(`    - ${m}`);
+    return L.join('\n') + '\n';
+}

package/dist/packages/popup/src/pages/chart-lib.js

@@ -1,7 +1,7 @@
 // dexterm popup — chart v2 pure helpers (task-1325). No DOM, no network, no globals besides the export.
 // Inlined into the chart page (before chart.js) under the page's CSP nonce; test/chart-lib.test.ts loads the
 // same file through node:vm to unit-test the math. Everything here works on OUR data only: the ChartVM's
-// candles (from the terminal's cached/derived series), its trade tape and its position fills.
+// candles (from the terminal's cached/derived series), its trade tape and the ledgers' fills (task-1483 markers).
 (function (root) {
   'use strict';
   const INTERVALS = ['1m', '5m', '15m', '1h', '4h', '1d'];
@@ -121,28 +121,141 @@
     return out.sort((x, y) => x.time - y.time);
   }
 
-  /**
-   * Position fill markers (paper ledger fills of the current position) at their fill time and exact fill
-   * price when known. Fills outside the loaded series are skipped (the row still shows the position).
-   */
-  function fillMarkers(fills, periodMs, barTimes, colors) {
+  // ---- task-1483 BUY / SELL markers: a mirror of @dexterm/tui markers.ts (test/chart-lib parity-tests the two). Fills
+  // are bucketed to the bars on screen by their REAL time (bar.t, UTC ms); a fill older than the first bar, newer than
+  // the last, or in a period with no bar is omitted and counted, never moved onto a neighbour.
+  const EPS = 1e-9;
+  function cleanFills(fills) {
     const out = [];
-    let lastBar = -Infinity;
-    for (const t of barTimes) if (t > lastBar) lastBar = t;
     for (const f of fills || []) {
-      if (!f || !fin(f.t) || (f.side !== 'buy' && f.side !== 'sell')) continue;
-      let time = barTimeOf(f.t, periodMs);
-      // A fill newer than the last candle (the candle feed lags 1–2 min) sits on the forming/last bar, the way
-      // a trading chart shows a fresh execution — up to 3 periods ahead; older gaps are skipped.
-      if (!barTimes.has(time) && time > lastBar && time - lastBar <= (3 * periodMs) / 1000) time = lastBar;
-      if (!barTimes.has(time)) continue;
-      const text = `${f.side === 'buy' ? 'BUY' : 'SELL'} ${fin(f.sol) ? fmtSol(f.sol) : ''}`.trim();
-      const m = { time, shape: f.side === 'buy' ? 'arrowUp' : 'arrowDown', color: f.side === 'buy' ? colors.buy : colors.sell, text, size: 1.4, id: `fill-${f.side}-${f.t}` };
-      if (fin(f.priceUsd) && f.priceUsd > 0) { m.position = f.side === 'buy' ? 'atPriceBottom' : 'atPriceTop'; m.price = f.priceUsd; }
-      else m.position = f.side === 'buy' ? 'belowBar' : 'aboveBar';
-      out.push(m);
+      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.sort((x, y) => x.time - y.time);
+    return out.map((f, i) => [f, i]).sort((a, b) => a[0].t - b[0].t || a[1] - b[1]).map(([f]) => f);
+  }
+  /** Replay per source (average-cost ledger rule): partial / closing flags, the open average entry, closed round trips. */
+  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 = [], 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 };
+  }
+  function indexIn(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; }
+  /** Markers for the bars (`barTimes` = the bars' real UTC ms, ascending): one per (bar, side, source). */
+  function chartMarkers(fills, periodMs, barTimes) {
+    const rp = replayFills(fills);
+    const res = { markers: [], before: 0, after: 0, gap: 0, avgEntry: rp.avgEntry, trips: [] };
+    if (!(periodMs > 0) || !barTimes.length) { res.before = rp.fills.length; return res; }
+    const first = barTimes[0], last = barTimes[barTimes.length - 1];
+    const by = new Map();
+    for (const f of rp.fills) {
+      const b = Math.floor(f.t / periodMs) * periodMs;
+      if (b < first) { res.before++; continue; }
+      if (b > last) { res.after++; continue; }
+      const index = indexIn(barTimes, 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 += 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) => Math.floor(r.closeT / periodMs) * periodMs >= first && Math.floor(r.openT / periodMs) * periodMs <= last);
+    return res;
+  }
+  /**
+   * Re-bucket on zoom: when bars are narrower than `minPx`, markers of the same side + source in each run of `k` bars
+   * merge into one (token-weighted price, summed size and count, at the run's last bar), so glyphs never pile up.
+   */
+  function clusterMarkers(markers, barSpacingPx, minPx = 14) {
+    const k = fin(barSpacingPx) && barSpacingPx > 0 ? Math.max(1, Math.ceil(minPx / barSpacingPx)) : 1;
+    if (k === 1) return markers.map((m) => ({ ...m, span: 1 }));
+    const by = new Map();
+    for (const m of markers) {
+      const g = Math.floor(m.index / k);
+      const key = `${g}|${m.side}|${m.source}`;
+      const c = by.get(key);
+      if (!c) { by.set(key, { ...m, span: k, pTok: m.priceUsd !== null ? m.tokens : 0, pUsd: m.priceUsd !== null ? m.tokens * m.priceUsd : 0 }); continue; }
+      c.index = Math.max(c.index, m.index); c.bucket = Math.max(c.bucket, m.bucket);
+      c.t = Math.min(c.t, m.t); c.tLast = Math.max(c.tLast, m.tLast);
+      c.count += m.count; c.tokens += m.tokens; c.sol = c.sol === null || m.sol === null ? null : c.sol + m.sol;
+      if (m.priceUsd !== null) { c.pTok += m.tokens; c.pUsd += m.tokens * m.priceUsd; }
+      c.partial = c.partial || m.partial; c.closes = c.closes || m.closes;
+    }
+    return [...by.values()].map(({ pTok, pUsd, ...m }) => ({ ...m, priceUsd: pTok > 0 ? pUsd / pTok : null })).sort((a, b) => a.index - b.index);
+  }
+  /** Solid ▲ / ▼ = live, hollow △ / ▽ = paper; B / S always (reads without colour). */
+  function markerGlyph(side, source) { return source === 'paper' ? (side === 'buy' ? '△' : '▽') : (side === 'buy' ? '▲' : '▼'); }
+  function markerLetter(side) { return side === 'buy' ? 'B' : 'S'; }
+  /**
+   * Pixel geometry of one marker: the triangle's tip sits ON the fill price (a buy points up from below, a sell points
+   * down from above); with no price it sits against the bar (below the low / above the high). `x` = the bar's centre.
+   */
+  function markerShape(side, x, y, size = 6) {
+    const s = size, buy = side === 'buy';
+    const base = buy ? y + s * 1.6 : y - s * 1.6;
+    const tri = [[x, y], [x - s, base], [x + s, base]];
+    const labelY = buy ? base + 9 : base - 9;
+    return { tri, labelX: x, labelY, hit: { x0: x - s - 3, x1: x + s + 3, y0: Math.min(y, labelY) - 7, y1: Math.max(y, labelY) + 7 } };
+  }
+  /** The hover tooltip lines for a marker (time, price — mcap and price on an mcap axis — size, source). */
+  function markerTooltip(m, display, timeFmt) {
+    const f = axisFormatter(display);
+    const px = m.priceUsd === null ? 'price not recorded' : display && display.mode === 'mcap' ? `MC ${f(m.priceUsd)} (${fmtPrice(m.priceUsd)})` : fmtPrice(m.priceUsd);
+    const when = m.count > 1 ? `${timeFmt(m.t)} – ${timeFmt(m.tLast)}` : timeFmt(m.t);
+    const kind = m.side === 'buy' ? (m.partial ? 'BUY (added)' : 'BUY') : (m.closes ? 'SELL (closed)' : 'SELL (partial)');
+    return [
+      `${markerGlyph(m.side, m.source)}${markerLetter(m.side)} ${kind}${m.count > 1 ? ` ×${m.count}` : ''}`,
+      when,
+      `${m.count > 1 && m.priceUsd !== null ? 'avg ' : ''}${px}`,
+      `${fmtTokens(m.tokens)} tokens${m.sol !== null ? ` · ${fmtSol(m.sol)}` : ''}`,
+      m.source === 'paper' ? 'PAPER · simulated ledger' : 'LIVE · confirmed on-chain fill',
+    ];
+  }
+  function fmtTokens(n) { return !fin(n) ? '—' : n >= 1e12 ? `${(n / 1e12).toFixed(2)}T` : n >= 1e9 ? `${(n / 1e9).toFixed(2)}B` : n >= 1e6 ? `${(n / 1e6).toFixed(2)}M` : n >= 1e4 ? `${(n / 1e3).toFixed(1)}K` : n >= 1 ? String(Math.round(n * 100) / 100) : n.toPrecision(3); }
+  /** "△B ▽S paper  ▲B ▼S live" for the sources on screen; "+N fills off-chart (…)" for what was omitted. */
+  function markerLegend(markers) {
+    const has = (s) => markers.some((m) => m.source === s);
+    return [has('paper') ? '△B ▽S paper' : '', has('live') ? '▲B ▼S live' : ''].filter(Boolean).join('  ');
+  }
+  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(', ')})`;
   }
 
   /** LWC price format for a price magnitude: enough decimals for memecoin prices (down to 1e-12). */
@@ -180,22 +293,43 @@
     if (a >= 1e3) return `${s}$${(a / 1e3).toFixed(1)}K`;
     return `${s}$${a.toFixed(0)}`;
   }
-  // ---- task-1366 market cap (mirrors @dexterm/tui fmtMcapBare: K/M/B/T, ≤ 3 significant digits, never 1000K)
-  const MC_UNITS = ['', 'K', 'M', 'B', 'T'];
-  function fmtMcapAxis(n) {
+  // ---- task-1472 the one chart number formatter (mirrors @dexterm/tui fmtCompact, parity-tested): lowercase k, then
+  // M/B/T; one decimal while < 10 of the unit, none after; the unit is promoted after rounding (999 900 → 1M); below 1
+  // the subscript price form (0.0₅493): never scientific notation. `extra` (0..3) keeps two axis ticks apart.
+  const CU = ['', 'k', 'M', 'B', 'T'];
+  const trimZeros = (t) => (t.includes('.') ? t.replace(/0+$/, '').replace(/\.$/, '') : t);
+  function tinyBare(p) {
+    if (p >= 0.01) return p.toFixed(4);
+    const m = p.toFixed(12).match(/^0\.(0*)(\d+)/);
+    if (!m) return String(p);
+    const zeros = m[1].length;
+    const digits = m[2].replace(/0+$/, '').slice(0, 4) || '0';
+    if (zeros < 3) return `0.${m[1]}${digits}`;
+    return `0.0${String(zeros).split('').map((c) => SUB[Number(c)]).join('')}${digits}`;
+  }
+  function fmtCompact(n, extra = 0) {
     if (!fin(n)) return '—';
+    if (n === 0) return '0';
     const sign = n < 0 ? '-' : '';
-    let a = Math.abs(n);
-    if (a === 0) return '0';
-    if (a < 1) return sign + String(Number(a.toPrecision(2)));
-    let u = 0;
-    while (u < MC_UNITS.length - 1 && a >= 1000) { a /= 1000; u++; }
-    let r = Number(a.toPrecision(3));
-    if (r >= 1000 && u < MC_UNITS.length - 1) { r = Number((r / 1000).toPrecision(3)); u++; }
-    return `${sign}${r >= 1000 ? String(Math.round(r)) : String(r)}${MC_UNITS[u]}`;
+    const a = Math.abs(n);
+    if (a < 1) return sign + trimZeros(tinyBare(a));
+    const x = Math.max(0, Math.min(3, Math.floor(extra) || 0));
+    const round = (q) => Number(q.toFixed((q < 10 ? 1 : 0) + x));
+    let u = 0, v = a;
+    while (u < CU.length - 1 && v >= 1000) { v /= 1000; u++; }
+    let r = round(v);
+    if (r >= 1000 && u < CU.length - 1) { u++; r = round(r / 1000); }
+    return `${sign}${trimZeros(r.toFixed((r < 10 ? 1 : 0) + x))}${CU[u]}`;
+  }
+  /** `$4.9k`, `-$1.2k` (volume pane, legend volume). */
+  function fmtCompactUsd(n, extra = 0) {
+    const b = fmtCompact(n, extra);
+    return b === '—' ? b : b.startsWith('-') ? `-$${b.slice(1)}` : `$${b}`;
   }
+  /** task-1366 name kept: the mcap axis label is now the compact formatter. */
+  const fmtMcapAxis = (n) => fmtCompact(n);
   const MCAP_LABEL = 'mcap (current supply)';
-  const MCAP_FALLBACK = 'supply unknown · showing price';
+  const MCAP_FALLBACK = 'price (mcap unavailable)'; // task-1472: the card's wording (was 'supply unknown · showing price')
   /**
    * How the page shows numbers for a VM: `mcap` (with the supply multiplier) only when the terminal is in mcap mode AND
    * sent a usable supply; mcap mode without one is `price` + a visible note. Never invents a supply.
@@ -207,7 +341,7 @@
     if (supply) return { mode: 'mcap', supply, label: MCAP_LABEL, key: `mcap:${Number(supply.toPrecision(4))}` };
     return { mode: 'price', supply: null, label: wantMcap ? MCAP_FALLBACK : null, key: wantMcap ? 'price:fallback' : 'price' };
   }
-  /** The Y-axis / crosshair label formatter for a display: mcap = price × supply in K/M/B, else the price label. */
+  /** The Y-axis / crosshair label formatter for a display: mcap = price × supply in compact k/M/B, else the price label. */
   function axisFormatter(d) {
     if (d && d.mode === 'mcap' && fin(d.supply)) { const s = d.supply; return (p) => fmtMcapAxis(p * s); }
     return fmtAxis;
@@ -225,7 +359,7 @@
     const chg = base > 0 ? (bar.close - base) / base : null;
     const f = axisFormatter(display);
     const mc = !!display && display.mode === 'mcap';
-    return { o: f(bar.open), h: f(bar.high), l: f(bar.low), c: mc ? `${f(bar.close)} (${fmtPrice(bar.close)})` : f(bar.close), v: fmtUsd(bar.volume), chg: fmtPct(chg), up: bar.close >= bar.open };
+    return { o: f(bar.open), h: f(bar.high), l: f(bar.low), c: mc ? `${f(bar.close)} (${fmtPrice(bar.close)})` : f(bar.close), v: fmtCompactUsd(bar.volume), chg: fmtPct(chg), up: bar.close >= bar.open };
   }
 
   /** Index of the bar at `time` (binary search), or -1. */
@@ -257,6 +391,6 @@
     return bars[i].time + f * (bars[i + 1].time - bars[i].time);
   }
 
-  const api = { setTzOffset, chartTime, INTERVALS, PERIOD_MS, INDICATORS, STYLES, SCALES, toBars, mergeTail, ema, sma, vwap, volumes, barTimeOf, tapeMarkers, fillMarkers, priceFormatFor, fmtPrice, fmtAxis, fmtUsd, fmtPct, fmtSol, legendFor, fmtMcapAxis, displayOf, axisFormatter, MCAP_LABEL, MCAP_FALLBACK, indexOfTime, logicalOf, timeOfLogical };
+  const api = { setTzOffset, chartTime, INTERVALS, PERIOD_MS, INDICATORS, STYLES, SCALES, toBars, mergeTail, ema, sma, vwap, volumes, barTimeOf, tapeMarkers, cleanFills, replayFills, chartMarkers, clusterMarkers, markerGlyph, markerLetter, markerShape, markerTooltip, markerLegend, omittedNote, priceFormatFor, fmtPrice, fmtAxis, fmtUsd, fmtPct, fmtSol, legendFor, fmtMcapAxis, fmtCompact, fmtCompactUsd, displayOf, axisFormatter, MCAP_LABEL, MCAP_FALLBACK, indexOfTime, logicalOf, timeOfLogical };
   root.DTChart = Object.freeze(api);
 })(typeof window !== 'undefined' ? window : globalThis);

package/dist/packages/popup/src/pages/chart.css

@@ -28,6 +28,15 @@
 .ohlc .row1 b:first-child { margin-left: 0; }
 .ohlc .up { color: var(--up); } .ohlc .down { color: var(--down); }
 .ohlc .ind { margin-right: 10px; }
+.ohlc .row3 { color: var(--dim); }
+.ohlc .row3 .paper { color: var(--warn); }
+/* task-1483: the BUY / SELL marker hover card (textContent only; positioned by chart.js) */
+.mtip { position: absolute; z-index: 6; pointer-events: none; font-size: 11px; line-height: 1.45; padding: 5px 8px; border-radius: 4px;
+  background: var(--panel); border: 1px solid var(--border); color: var(--text); white-space: nowrap; box-shadow: 0 2px 10px rgba(0,0,0,.45); }
+.mtip .h { font-weight: 700; }
+.mtip .h.buy { color: var(--up); } .mtip .h.sell { color: var(--down); }
+.mtip .src { color: var(--dim); }
+.mtip .src.paper { color: var(--warn); }
 .hint { position: absolute; right: 70px; top: 6px; z-index: 5; font-size: 11px; color: var(--warn); pointer-events: none; }
 .pos { border-top: 1px solid var(--border); padding: 3px 10px 4px; font-size: 11px; background: rgba(245,255,45,.025); }
 .pos-head { display: flex; gap: 10px; }
@@ -48,3 +57,12 @@
 /* LWC attribution logo: the library injects this exact rule too (allowed by CSP hash); repeated here so the
    logo stays positioned even if a future build changes its inline style text. */
 a#tv-attr-logo { position: absolute; left: 10px; bottom: 10px; height: 19px; width: 35px; margin: 0; padding: 0; border: 0; z-index: 3; }
+/* task-1473 r2: the persistent POSITION PnL chip (the held coin, which need not be the charted coin). Display only. */
+.pnlchip { display: flex; flex-wrap: nowrap; gap: 0; padding: 2px 10px; font-size: 11px; white-space: nowrap; overflow: hidden; border-bottom: 1px solid var(--border); background: rgba(255,45,240,.07); color: var(--muted); }
+.pnlchip .seg + .seg::before { content: ' │ '; color: var(--border); }
+.pnlchip .head { color: var(--pump); font-weight: 700; }
+.pnlchip .pnl { font-weight: 700; }
+.pnlchip .pnl.up, .pnlchip .peak.up { color: var(--up); } .pnlchip .pnl.down, .pnlchip .peak.down { color: var(--down); }
+.pnlchip .dd { color: var(--warn); }
+.pnlchip .pnl.flash { background: var(--up); color: var(--bg, #000); padding: 0 3px; border-radius: 2px; }
+@media (prefers-reduced-motion: reduce) { .pnlchip .pnl.flash { background: none; color: var(--up); padding: 0; } }

package/dist/packages/popup/src/pages/chart.html

@@ -23,6 +23,10 @@
   <div id="toolbar" class="toolbar">
     <span class="grp" id="tf"></span>
     <span class="sep"></span>
+    <span class="grp" id="axis"></span>
+    <span class="sep"></span>
+    <span class="grp" id="marks"></span>
+    <span class="sep"></span>
     <span class="grp" id="styles"></span>
     <span class="sep"></span>
     <span class="grp" id="scales"></span>
@@ -31,6 +35,7 @@
     <span class="sep"></span>
     <span class="grp" id="draws"></span>
   </div>
+  <div id="pnlchip" class="pnlchip" hidden title="position PnL (display only)"></div>
   <div id="banner" class="banner" hidden></div>
   <div class="stage">
     <canvas id="rain"></canvas>
@@ -44,7 +49,7 @@
     <div id="pos-cells" class="pos-cells"></div>
   </div>
   <div id="foot" class="foot">
-    <span class="keys">1–6 tf · c style · a/l/p scale · e ema · w vwap · m vol·ma · v vol · b tape · h/t draw · f fit · esc close</span>
+    <span class="keys">1–6 tf · A/y mcap⇄price · k markers · c style · a/l/p scale · e ema · w vwap · m vol·ma · v vol · b tape · h/t draw · f fit · esc close</span>
     <span class="attr" title="TradingView Lightweight Charts v__LWC_VERSION__ (Apache-2.0), self-hosted"><span id="notice">__LWC_NOTICE__</span> · <a id="tv-link" href="https://www.tradingview.com/" target="_blank" rel="noopener noreferrer">https://www.tradingview.com/</a></span>
   </div>
 </div>