dexterm-cli 0.1.4 → 0.1.6

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

@@ -12,6 +12,7 @@
 <div id="hud" class="hud">
   <div id="drag" class="drag"><span class="mark">✦</span><span id="title" class="title">dexterm · WATCH THE AGENT COOK</span><span id="status" class="status">connecting…</span><button id="close" class="close" type="button" aria-label="close">✕</button></div>
   <div class="stage"><canvas id="rain"></canvas><div class="body">
+    <div id="story" class="spec-story"></div>
     <div id="screen" class="spec-screen"></div>
     <div id="agents" class="spec-agents"></div>
     <div class="spec-activity-head">agent activity</div>

package/dist/packages/popup/src/pages/spectator.js

@@ -14,8 +14,77 @@
 
   let vm = null;
 
+  const pctS = (p) => (p == null ? '—' : `${p >= 0 ? '+' : '−'}${Math.abs(p * 100).toFixed(1)}%`);
+  const px = (n) => (n == null ? '—' : n >= 1 ? `$${n.toFixed(4)}` : `$${Number(n.toPrecision(3))}`);
+  const fmtMs = (ms) => (ms == null ? '·' : ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`);
+  const CHECKS = ['price', 'tape', 'chart', 'holders', 'rug', 'dev', 'larp', 'verdict'];
+
+  // task-1466 spectator v2: the agent story above the activity list (textContent only; strings redacted TUI-side).
+  function renderStory(st) {
+    const host = $('story'); host.textContent = '';
+    if (!st) return;
+    const rail = el('div', 'spec-rail');
+    const heart = el('span', 'spec-heart' + (st.control === 'killed' ? ' dead' : st.control !== 'running' ? ' still' : ''));
+    if (st.bpm > 0) heart.style.animationDuration = `${(60 / st.bpm).toFixed(2)}s`;
+    rail.appendChild(heart);
+    rail.appendChild(el('span', 'spec-bpm', st.control === 'killed' ? '— bpm' : `${st.bpm} bpm`));
+    const ai = st.rail.indexOf(st.phase);
+    st.rail.forEach((p, i) => {
+      if (i) rail.appendChild(el('span', 'spec-sep', '─'));
+      const on = i === ai && st.control !== 'killed';
+      rail.appendChild(el('span', 'spec-phase p-' + p + (on ? ' on' : i < ai ? ' done' : ''), (on ? '▸' : '') + p.toUpperCase() + (on && st.sub ? ` · ${st.sub}` : '')));
+    });
+    if (st.control !== 'running') rail.appendChild(el('span', 'spec-ctlstate ' + st.control, st.control === 'killed' ? '■ KILLED' : st.control === 'paused' ? '❚❚ PAUSED' : 'YOU ARE DRIVING'));
+    rail.appendChild(el('span', 'spec-paper', 'PAPER'));
+    host.appendChild(rail);
+    const th = (st.thoughts || []).slice().reverse();
+    const agentT = th.find((x) => x.source === 'agent');
+    const ours = th.find((x) => x.source === 'dexterm');
+    const pick = agentT && (!ours || agentT.t >= ours.t - 1500 || Date.now() - agentT.t < 9000) ? agentT : ours || agentT;
+    const rib = el('div', 'spec-ribbon' + (pick && pick.source === 'dexterm' ? ' ours' : ''));
+    if (pick) { if (pick.source === 'agent') rib.appendChild(el('span', 'spec-ribbon-who', '❯')); rib.appendChild(el('span', '', pick.text)); }
+    else rib.appendChild(el('span', 'spec-dim', 'the agent has not said anything yet'));
+    host.appendChild(rib);
+    const tl = el('div', 'spec-timeline');
+    (st.nodes || []).slice(-14).forEach((n, i) => {
+      if (i) tl.appendChild(el('span', 'spec-link', '──'));
+      const node = el('div', 'spec-node' + (n.paper ? ' paper' : ''));
+      node.appendChild(el('span', 'spec-node-l', `${n.status === 'refused' ? '✗' : n.paper ? '■' : '●'} ${n.label}${n.count > 1 ? ` ×${n.count}` : ''}`));
+      node.appendChild(el('span', 'spec-chip ' + n.status, n.status === 'refused' ? 'refused' : fmtMs(n.ms)));
+      tl.appendChild(node);
+    });
+    host.appendChild(tl);
+    const cards = el('div', 'spec-cards');
+    if (st.focus) {
+      const c = el('div', 'spec-card');
+      c.appendChild(el('span', 'spec-card-h', `VETTING $${st.focus.symbol}`));
+      const row = el('div');
+      for (const k of CHECKS) row.appendChild(el('span', 'spec-check' + (st.focus.checks.includes(k) ? ' ok' : ''), `${st.focus.checks.includes(k) ? '✓' : '·'}${k}`));
+      c.appendChild(row);
+      if (st.focus.larpFlags != null) c.appendChild(el('div', 'spec-kv', `LARP evidence: ${st.focus.larpFlags} flag${st.focus.larpFlags === 1 ? '' : 's'} (not a verdict)`));
+      if (st.focus.verdict) c.appendChild(el('div', 'spec-kv', `verdict ${st.focus.verdict}${st.focus.rug != null ? ` · rug heuristic ${Math.round(st.focus.rug * 100)}%` : ''}`));
+      cards.appendChild(c);
+    }
+    if (st.arc) {
+      const a = st.arc;
+      const c = el('div', 'spec-card trade');
+      c.appendChild(el('span', 'spec-card-h', `PAPER · $${a.symbol} · ${a.stage === 'closed' ? 'RESULT' : a.stage === 'open' ? 'HOLDING' : a.stage === 'refused' ? 'REFUSED' : 'TICKET'}`));
+      const big = a.stage === 'closed' ? a.resultPct : a.pnlPct;
+      if (big != null) c.appendChild(el('div', 'spec-big ' + (big >= 0 ? 'up' : 'down'), pctS(big)));
+      const kv = el('div', 'spec-kv');
+      kv.textContent = [a.sizeUsd != null ? `size $${a.sizeUsd.toFixed(2)}` : null, a.entryUsd != null ? `entry ${px(a.entryUsd)}` : null, a.markUsd != null && a.stage !== 'closed' ? `mark ${px(a.markUsd)}` : null,
+        a.peakPct != null ? `peak ${pctS(a.peakPct)}` : null, a.exits ? `exits ${a.exits}` : null, a.realizedSol != null ? `realized ${a.realizedSol >= 0 ? '+' : ''}${a.realizedSol.toFixed(4)} SOL` : null,
+        a.refusal ? `refused: ${a.refusal}` : null].filter(Boolean).join(' · ');
+      c.appendChild(kv);
+      c.appendChild(el('div', 'spec-dim', 'simulated paper trade · not a result'));
+      cards.appendChild(c);
+    }
+    if (cards.childNodes.length) host.appendChild(cards);
+  }
+
   function render() {
     if (!vm) return;
+    renderStory(vm.story || null);
 
     const scr = $('screen'); scr.textContent = '';
     const s = vm.screen || {};

package/dist/packages/popup/src/protocol.js

@@ -28,4 +28,6 @@ export const CHART_INDICATORS = ['ema9', 'ema21', 'vwap', 'volma', 'volume', 'ta
 export const CHART_STYLES = ['candles', 'line', 'area'];
 /** Price-scale mode: auto (normal, autoscaled), logarithmic, percent (from the first visible bar). */
 export const CHART_SCALES = ['auto', 'log', 'percent'];
+/** task-1472: what the chart's Y axis shows (the popup's MCAP | PRICE control / `A` ask the terminal to switch). */
+export const CHART_AXES = ['mcap', 'price'];
 export const PROTOCOL_VERSION = 'dexterm-popup/1';

package/dist/packages/popup/src/server.js

@@ -26,7 +26,7 @@ import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { readFileSync, existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
-import { PROTOCOL_VERSION, CHART_INTERVALS, CHART_INDICATORS, CHART_STYLES, CHART_SCALES, WIDGET_TOPICS, WIDGET_HTML_MAX } from "./protocol.js";
+import { PROTOCOL_VERSION, CHART_INTERVALS, CHART_INDICATORS, CHART_STYLES, CHART_SCALES, CHART_AXES, WIDGET_TOPICS, WIDGET_HTML_MAX } from "./protocol.js";
 import { auditWidgetHtml, inlineHashes, normalizeWidgetHtml } from "./widget-html.js";
 const here = path.dirname(fileURLToPath(import.meta.url));
 const PAGES_DIR = path.join(here, 'pages');
@@ -48,6 +48,8 @@ export const POPUP_EVENTS = new Set([
     'event:popup.close-request', 'event:popup.focus', 'event:popup.drag',
     // task-1325 chart v2 requests (payloads validated by validateEventPayload below)
     'event:chart.interval', 'event:chart.indicator', 'event:chart.style', 'event:chart.scale', 'event:chart.painted',
+    // task-1472: the chart's Y axis (market cap ⇄ price): a display preference the terminal saves, nothing else
+    'event:chart.axis',
     // task-1345 agent roster: per-agent pause / kick, by agent name (the only writes this popup can send)
     'event:roster.pause', 'event:roster.resume', 'event:roster.kick',
     // task-1355 order plans: cancel a plan by id (the ONLY write the plans popup can send — never arm/cap/sign)
@@ -94,6 +96,8 @@ export function validateEventPayload(name, payload) {
             return oneOf(CHART_STYLES, p.style) ? { style: p.style } : null;
         case 'chart.scale':
             return oneOf(CHART_SCALES, p.scale) ? { scale: p.scale } : null;
+        case 'chart.axis':
+            return oneOf(CHART_AXES, p.axis) ? { axis: p.axis } : null;
         case 'chart.painted':
             return (p.kind === 'first' || p.kind === 'data') && finiteIn(p.ms, 0, 600_000) && finiteIn(p.sentAt, 0, 1e15)
                 ? { kind: p.kind, ms: p.ms, sentAt: p.sentAt } : null;

package/dist/packages/recorder/src/dev-history.js

@@ -0,0 +1,133 @@
+// DEV HISTORY (0.1.5, task-1425): "has this deployer rugged before?" from dexterm's OWN recorded history, keyless.
+// The creator links come from the `creators` table (a keyless source naming the dev when dexterm saw the coin), the
+// outcomes from the recorder's code-only labeler (labels.ts: keyless-proxy tier), the dev-exit timing from the
+// recorded `dev_pct` series. Every number carries its source, sample size and age; no recorded prior launch is
+// `unknown`, never "clean". It is a risk flag from observed history, never a certificate.
+//
+// Point in time: with `asOf`, only links recorded before it and labels already known by then count (a label is known
+// once its observation t1, or t0 + horizon, has passed). The backtest uses this so a coin is never judged on the
+// future (the same leakage rule as export.ts).
+/** Label horizons in preference order: the 72 h label when known, else the longest one known. */
+const PREF_HORIZONS = [259200, 86400, 21600, 7200, 3600];
+/** Dev-exit rule: the dev held more than this % of supply, then this little. */
+export const DEV_EXIT = { heldPct: 0.5, exitPct: 0.1 };
+/** Prior rugs at/over this many = the `serial_rugger` flag (same threshold as the token-dossier pack). */
+export const SERIAL_RUGGER_MIN = 2;
+export const DEV_HISTORY_SOURCE = 'dexterm recorder (keyless creator links + code-only outcome labels)';
+const median = (xs) => {
+    if (!xs.length)
+        return null;
+    const s = [...xs].sort((a, b) => a - b);
+    const m = Math.floor(s.length / 2);
+    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+/** The creator dexterm recorded for `mint`, or null. */
+export function creatorOf(db, mint) {
+    try {
+        const r = db.prepare('SELECT mint, creator, source, first_t, created_at FROM creators WHERE mint = ?').get(mint);
+        return r ? { mint: r.mint, creator: r.creator, source: r.source, firstT: Number(r.first_t), createdAt: r.created_at === null ? null : Number(r.created_at) } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The creator's recorded track record. Never throws: a DB without the tables reads as `unknown`. */
+export function queryDevHistory(db, q) {
+    const asOf = q.asOf ?? Date.now();
+    const empty = {
+        creator: q.creator, status: 'unknown', asOf, source: DEV_HISTORY_SOURCE,
+        launches: { n: 0, newestT: null, ageSec: null },
+        labelled: { n: 0, rug: 0, dead: 0, fade: 0, flat: 0, runner: 0, horizon: '72h preferred', tier: 'keyless-proxy', newestT: null, ageSec: null },
+        rugRate: null, badRate: null, devExit: { n: 0, medianMin: null, within60m: 0, newestT: null, ageSec: null }, serialRugger: false, recent: [],
+    };
+    let links;
+    try {
+        links = db.prepare('SELECT mint, first_t, created_at FROM creators WHERE creator = ? AND first_t <= ? AND mint != ? ORDER BY first_t DESC LIMIT ?')
+            .all(q.creator, asOf, q.mint ?? '', q.limit ?? 300);
+    }
+    catch {
+        return empty;
+    }
+    if (!links.length)
+        return empty;
+    const outStmt = db.prepare("SELECT t0, horizon_sec, t1, label FROM outcomes WHERE mint = ? AND label != 'unobserved' ORDER BY t0 ASC");
+    const symStmt = db.prepare('SELECT symbol FROM token_snapshots WHERE mint = ? AND symbol IS NOT NULL ORDER BY t ASC LIMIT 1');
+    const devStmt = db.prepare('SELECT t, dev_pct FROM token_snapshots WHERE mint = ? AND dev_pct IS NOT NULL AND t <= ? ORDER BY t ASC LIMIT 400');
+    const counts = { rug: 0, dead: 0, fade: 0, flat: 0, runner: 0 };
+    let labelledN = 0, labelledNewest = null;
+    const exits = [];
+    let exitNewest = null;
+    const launches = [];
+    for (const l of links) {
+        const firstT = Number(l.first_t);
+        const createdAt = l.created_at === null ? null : Number(l.created_at);
+        const rows = outStmt.all(l.mint);
+        // the label of the EARLIEST anchor (closest to launch) at the longest horizon already known as of asOf
+        const known = rows.filter((r) => (r.t1 !== null ? Number(r.t1) : Number(r.t0) + Number(r.horizon_sec) * 1000) <= asOf);
+        let label = null, horizonSec = null, knownAt = null;
+        if (known.length) {
+            const t0 = Math.min(...known.map((r) => Number(r.t0)));
+            const at = known.filter((r) => Number(r.t0) === t0);
+            for (const h of PREF_HORIZONS) {
+                const hit = at.find((r) => Number(r.horizon_sec) === h);
+                if (hit) {
+                    label = hit.label;
+                    horizonSec = h;
+                    knownAt = hit.t1 !== null ? Number(hit.t1) : t0 + h * 1000;
+                    break;
+                }
+            }
+        }
+        if (label) {
+            labelledN++;
+            counts[label]++;
+            if (knownAt !== null)
+                labelledNewest = Math.max(labelledNewest ?? 0, knownAt);
+        }
+        let devExitMin = null;
+        if (q.devExit !== false) {
+            const series = devStmt.all(l.mint, asOf);
+            const held = series.findIndex((r) => r.dev_pct > DEV_EXIT.heldPct);
+            if (held >= 0) {
+                const out = series.slice(held + 1).find((r) => r.dev_pct <= DEV_EXIT.exitPct);
+                if (out) {
+                    const from = createdAt ?? Number(series[held].t);
+                    devExitMin = Math.max(0, (Number(out.t) - from) / 60_000);
+                    exits.push(devExitMin);
+                    exitNewest = Math.max(exitNewest ?? 0, Number(out.t));
+                }
+            }
+        }
+        if (launches.length < 10) {
+            const sym = symStmt.get(l.mint)?.symbol ?? null;
+            launches.push({ mint: l.mint, symbol: sym, firstT, createdAt, label, horizonSec, devExitMin });
+        }
+    }
+    const newestT = Number(links[0].first_t);
+    return {
+        ...empty,
+        status: 'ok',
+        launches: { n: links.length, newestT, ageSec: Math.max(0, Math.round((asOf - newestT) / 1000)) },
+        labelled: { ...empty.labelled, n: labelledN, ...counts, newestT: labelledNewest, ageSec: labelledNewest === null ? null : Math.max(0, Math.round((asOf - labelledNewest) / 1000)) },
+        rugRate: labelledN ? counts.rug / labelledN : null,
+        badRate: labelledN ? (counts.rug + counts.dead) / labelledN : null,
+        devExit: { n: exits.length, medianMin: median(exits), within60m: exits.filter((m) => m <= 60).length, newestT: exitNewest, ageSec: exitNewest === null ? null : Math.max(0, Math.round((asOf - exitNewest) / 1000)) },
+        serialRugger: counts.rug >= SERIAL_RUGGER_MIN,
+        recent: launches,
+    };
+}
+/** Compact age for a panel cell: `5m`, `3h`, `40d`; `age ?` when unknown. */
+export const ageShort = (sec) => sec === null ? 'age ?' : sec < 3600 ? `${Math.max(1, Math.round(sec / 60))}m` : sec < 172800 ? `${Math.round(sec / 3600)}h` : `${Math.round(sec / 86400)}d`;
+const ago = (sec) => sec === null ? 'age unknown' : `${ageShort(sec)} ago`;
+/**
+ * The one-line summary every surface shows (DEV panel, rug-signal row, MCP note): counts with the sample size and
+ * the age, or `unknown` with why. Plain wording: a risk flag from observed history, never "rug confirmed" or "safe".
+ */
+export function devHistoryLine(r) {
+    if (r.status === 'unknown')
+        return 'unknown: no prior launch by this wallet in dexterm\'s record';
+    const L = r.labelled;
+    if (!L.n)
+        return `${r.launches.n} prior launch${r.launches.n === 1 ? '' : 'es'} recorded, none labelled yet (newest ${ago(r.launches.ageSec)})`;
+    return `rugged ${L.rug} of ${L.n} labelled prior launches${L.dead ? ` (+${L.dead} dead)` : ''} · ${r.launches.n} recorded · labels ${ago(L.ageSec)}`;
+}

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

@@ -8,6 +8,7 @@ export * from "./export.js";
 export * from "./open.js";
 export * from "./verdicts.js";
 export * from "./schedule.js";
+export * from "./dev-history.js";
 export { recorderCli, RECORDER_HELP } from "./cli.js";
 /** `--no-recorder` / `DEXTERM_RECORDER=0` resolution: the recorder is on in live mode unless either says no. */
 export function recorderEnabled(env, flagOff) {

package/dist/packages/recorder/src/recorder.js

@@ -30,6 +30,7 @@ export const LABEL_RETRY_MS = 300_000;
 export const LABEL_BATCH = 300;
 /** In-memory last-row cache: entries not observed for this long are dropped (re-read from the DB on return). */
 export const SEEN_EVICT_MS = 2 * 3_600_000;
+const BASE58 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
 export class Recorder {
     enabled;
     path;
@@ -58,6 +59,8 @@ export class Recorder {
     /** Counters for the handoff / --verbose. */
     counters = { observed: 0, written: 0, heartbeat: 0, members: 0, sweepCalls: 0, labelled: 0 };
     stmts;
+    /** Mints whose creator link is already stored (this run), so a refresh costs no write. */
+    creatorKnown = new Set();
     constructor(opts = {}) {
         this.enabled = opts.enabled ?? true;
         this.path = opts.path ?? ':memory:';
@@ -87,6 +90,7 @@ export class Recorder {
             insertMember: this.db.prepare('INSERT OR IGNORE INTO feed_members (t, feed, rank, mint) VALUES (?, ?, ?, ?)'),
             lastIdentity: this.db.prepare('SELECT symbol, name, launchpad, created_at FROM token_snapshots WHERE mint = ? ORDER BY t DESC LIMIT 1'),
             lastLive: this.db.prepare(`SELECT t, hash, sources, ${cols} FROM token_snapshots WHERE mint = ? AND kind = 'live' ORDER BY t DESC LIMIT 1`),
+            insertCreator: this.db.prepare('INSERT OR IGNORE INTO creators (mint, creator, source, first_t, created_at) VALUES (?, ?, ?, ?, ?)'),
         };
     }
     /** Attach as the data layer's store listener (and detach any previous one). */
@@ -120,6 +124,10 @@ export class Recorder {
         const pending = [];
         for (const r of rows) {
             this.counters.observed++;
+            // 0.1.5 dev history: the creator the row's source names (Jupiter `dev`), stored once per mint.
+            const dev = r.audit?.devAddress;
+            if (r.mint && dev)
+                this.recordCreator(r.mint, dev, r.audit?.source ?? 'jupiter-tokens', now, r.token?.createdAt ?? null);
             if (!r.mint || !r.pair) {
                 res.skipped++;
                 continue;
@@ -173,6 +181,21 @@ export class Recorder {
         this.counters.heartbeat += res.heartbeat;
         return res;
     }
+    /**
+     * Record which wallet created `mint`, as `source` named it (0.1.5 dev history). First writer wins; a mint or
+     * creator that is not a base58 address is ignored. Returns true when a new link was stored.
+     */
+    recordCreator(mint, creator, source, now = this.clock.now(), createdAt = null) {
+        if (!this.enabled || this.closed || this.creatorKnown.has(mint))
+            return false;
+        if (!BASE58.test(mint) || !BASE58.test(creator) || mint === creator)
+            return false;
+        this.creatorKnown.add(mint);
+        if (this.creatorKnown.size > 200_000)
+            this.creatorKnown.clear();
+        const r = this.stmts.insertCreator.run(mint, creator, String(source).slice(0, 24), now, createdAt !== null && Number.isFinite(createdAt) ? Math.round(createdAt) : null);
+        return Number(r.changes) > 0;
+    }
     /** The mint's last stored live row (one indexed read; only paid the first time a mint is seen this run). */
     lastStored(mint) {
         const row = this.stmts.lastLive.get(mint);

package/dist/packages/recorder/src/schema.js

@@ -132,4 +132,15 @@ CREATE TABLE IF NOT EXISTS verdicts (
   run_file     TEXT
 );
 CREATE INDEX IF NOT EXISTS verdicts_mint_t ON verdicts (mint, t);
+
+-- 0.1.5 dev history: which wallet created a coin, as a keyless source named it when dexterm saw the coin
+-- (Jupiter tokens v2 \`dev\`, a PumpPortal create, RugCheck new_tokens). First writer wins; never a guess.
+CREATE TABLE IF NOT EXISTS creators (
+  mint        TEXT PRIMARY KEY,
+  creator     TEXT NOT NULL,
+  source      TEXT NOT NULL,             -- 'jupiter-tokens' | 'pumpportal' | 'rugcheck' | 'goplus'
+  first_t     INTEGER NOT NULL,          -- unix ms dexterm first recorded the link
+  created_at  INTEGER                    -- the coin's creation time when the source gave one
+) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS creators_creator ON creators (creator, first_t);
 `;

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

@@ -66,6 +66,11 @@ export class Canvas {
      */
     images;
     imageMode;
+    /**
+     * task-1466: where each keyed list row was drawn (a table with `rowKey`, e.g. a screener row by mint), so an
+     * overlay drawn later (the agent HUD's row glow / cursor) can find the row on screen. Not emitted anywhere.
+     */
+    rowMarks;
     constructor(w, h, theme) {
         this.w = w;
         this.h = h;
@@ -82,6 +87,7 @@ export class Canvas {
         this.shields = [];
         this.images = [];
         this.imageMode = 'cells';
+        this.rowMarks = [];
     }
     idx(x, y) { return y * this.w + x; }
     /** Copy every buffer of `src` (same size) into this canvas. */
@@ -97,6 +103,7 @@ export class Canvas {
         this.shields = src.shields.slice();
         this.images = src.images.slice();
         this.imageMode = src.imageMode;
+        this.rowMarks = src.rowMarks.slice();
     }
     put(x, y, ch, st = {}) {
         if (x < 0 || y < 0 || x >= this.w || y >= this.h)

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

@@ -119,6 +119,59 @@ export function fmtMcap(n) {
         return bare;
     return bare.startsWith('-') ? `-$${bare.slice(1)}` : `$${bare}`;
 }
+/**
+ * task-1472: THE chart number formatter (Y axis, crosshair/legend, last-value tag, volume): compact with a LOWERCASE k
+ * for thousands, then M, B, T. One decimal while the value is below 10 of its unit, none after, trailing `.0` dropped:
+ * 4930 → 4.9k, 42100 → 42k, 487000 → 487k, 1.23e6 → 1.2M, 4.8e7 → 48M, 1.3e9 → 1.3B, 999 → 999. The unit is promoted
+ * AFTER rounding, so 999 900 reads 1M (never 1000k). Below 1 it is the subscript price form (0.0000123 → 0.0₄123):
+ * never scientific notation, never a long run of zeros. `extra` (0..3) adds decimals when an axis needs them to keep
+ * two neighbouring ticks apart (see compactDecimalsFor). No currency symbol; fmtCompactUsd adds the `$`.
+ */
+export function fmtCompact(n, extra = 0) {
+    if (n == null || !Number.isFinite(n))
+        return '—';
+    if (n === 0)
+        return '0';
+    const sign = n < 0 ? '-' : '';
+    const a = Math.abs(n);
+    if (a < 1)
+        return sign + trimZeros(fmtPriceBare(a));
+    const units = ['', 'k', 'M', 'B', 'T'];
+    const x = Math.max(0, Math.min(3, Math.floor(extra)));
+    const round = (q) => Number(q.toFixed((q < 10 ? 1 : 0) + x));
+    let u = 0, v = a;
+    while (u < units.length - 1 && v >= 1000) {
+        v /= 1000;
+        u++;
+    }
+    let r = round(v);
+    if (r >= 1000 && u < units.length - 1) {
+        u++;
+        r = round(r / 1000);
+    }
+    return `${sign}${trimZeros(r.toFixed((r < 10 ? 1 : 0) + x))}${units[u]}`;
+}
+/** USD form of fmtCompact: `$4.9k`, `$48M`, `-$1.2k`. */
+export function fmtCompactUsd(n, extra = 0) {
+    const bare = fmtCompact(n, extra);
+    if (bare === '—')
+        return bare;
+    return bare.startsWith('-') ? `-$${bare.slice(1)}` : `$${bare}`;
+}
+/**
+ * task-1472: the extra decimals (0..3) fmtCompact needs so that axis ticks `step` apart around `around` never print
+ * the same label (a 48.1M–48.6M range would otherwise read 48M on every tick). 0 for a normal memecoin range.
+ */
+export function compactDecimalsFor(around, step) {
+    if (!Number.isFinite(around) || !Number.isFinite(step) || step <= 0 || Math.abs(around) < 1)
+        return 0;
+    for (let x = 0; x < 3; x++) {
+        const a = fmtCompact(around, x);
+        if (a !== fmtCompact(around + step, x) && a !== fmtCompact(around - step, x))
+            return x;
+    }
+    return 3;
+}
 export function fmtPct(n, { sign = true, digits = 1 } = {}) {
     if (n == null || Number.isNaN(n))
         return '—';

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

@@ -268,6 +268,10 @@ export const DEFAULT_KEYMAP = new Keymap([
     // the open coin. (`P` is already the global positions key, so chart uses `C`.) Collision-free with the
     // token screen's other capitals (B/S trade, W/X/T/L links, V vet).
     { keys: ['C'], action: 'popup.chart', label: 'chart popup', screen: 'token' },
+    // task-1472: `A` (axis) on the token screen flips the chart Y axis MARKET CAP ⇄ PRICE (both charts; saved as
+    // display.chartAxis). Free capital on the token screen (A is only auto-mirror on the follows screen); deliberately
+    // not Y, which confirms inside the PAPER ticket and the modals. The chart popup uses the same `A`.
+    { keys: ['A'], action: 'display.chartAxis', label: 'chart axis mcap ⇄ price', screen: 'token' },
     // task-1359: `I` on the token screen opens/toggles the TOKEN-DETAIL HUD (identity, market, risk, snipers/bundled
     // from the wallet-intel scan); `M` on the trending screen opens/toggles the FEEDS HUD (the keyless social feed +
     // official news, newest first; ⏎ in the window opens that coin here). Both are read-only windows. `I` is unused

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

@@ -5,7 +5,7 @@
 // background (hard cells); glow is only ever applied to neighbouring blank cells or to bg tints.
 import { Canvas } from "./canvas.js";
 import { mix, luminance } from "./color.js";
-import { fmtUsd, fmtPct, fmtNum, fmtPrice, fmtAgeSec, shortAddr, clamp } from "./fmt.js";
+import { fmtUsd, fmtPct, fmtNum, fmtPrice, fmtPriceBare, fmtCompactUsd, compactDecimalsFor, fmtAgeSec, shortAddr, clamp } from "./fmt.js";
 import { launchpadColor } from "./theme.js";
 export const BLOCKS = '▁▂▃▄▅▆▇█';
 // braille dot bits: column 0 rows 0..3, column 1 rows 0..3 (row 0 = top)
@@ -107,6 +107,7 @@ export function brailleLine(c, x, y, w, h, values, opts = {}) {
                 c.put(x + col, y + r, String.fromCharCode(0x2800 + bits), { fg: neon(color, col / (w - 1), bg), bg, soft: true });
         }
 }
+/** task-1472: the price axis never prints scientific notation: subscript zeros below 0.01 (0.0₅493), like fmtPrice. */
 function fmtPriceAxis(p) {
     if (p >= 1000)
         return p.toFixed(0);
@@ -114,7 +115,7 @@ function fmtPriceAxis(p) {
         return p.toFixed(3);
     if (p >= 0.001)
         return p.toFixed(5);
-    return p.toExponential(2);
+    return fmtPriceBare(p);
 }
 /**
  * Candlestick chart with right-hand price axis, last-price tag, volume strip and time axis.
@@ -137,7 +138,6 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
     // task-1366: the bars are laid out in price units either way (identical glyphs); only the labels are scaled
     const s = opts.scale && Number.isFinite(opts.scale) && opts.scale > 0 ? opts.scale : 1;
     const baseFmt = opts.axisFmt ?? fmtPriceAxis;
-    const fmtAxis = s === 1 ? baseFmt : (p) => baseFmt(p * s);
     let lo = Infinity, hi = -Infinity, vmax = 0;
     for (const k of data) {
         lo = Math.min(lo, k.l);
@@ -152,6 +152,9 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
     const gridStyle = { fg: mix(bg, t.border, 0.9), bg, soft: true };
     const labelStyle = { fg: t.muted, bg };
     const ticks = Math.max(2, Math.min(6, Math.floor(plotH / 3)));
+    // task-1472: one more decimal only when two neighbouring ticks would otherwise print the same compact label
+    const extra = opts.axisFmt ? compactDecimalsFor(((hi + lo) / 2) * s, (range / ticks) * s) : 0;
+    const fmtAxis = (p) => baseFmt(p * s, extra);
     for (let i = 0; i <= ticks; i++) {
         const row = Math.round((i / ticks) * (plotH - 1));
         const price = hi - (row / (plotH - 1)) * range;
@@ -245,7 +248,7 @@ export function candleChart(c, x, y, w, h, candles, opts = {}) {
             }
         }
         c.text(x + plotW + 1, vy, 'vol', labelStyle);
-        c.text(x + plotW + 1, vy + 1, fmtUsd(last.v, { digits: 1 }), { fg: t.text, bg });
+        c.text(x + plotW + 1, vy + 1, fmtCompactUsd(last.v), { fg: t.text, bg }); // task-1472: volume stays USD, compact k/M
     }
     const ty = y + h - 1;
     const labels = Math.max(2, Math.floor(plotW / 18));
@@ -386,6 +389,8 @@ export function table(c, x, y, w, h, spec) {
         const selected = ri === spec.selected;
         const rowBg = selected ? t.selBg : (r % 2 === 1 && spec.zebra !== false ? mix(bg, t.panelAlt, 1) : bg);
         c.fill(x, ry, w, 1, ' ', { bg: rowBg });
+        if (spec.rowKey)
+            c.rowMarks.push({ key: spec.rowKey(row), x, y: ry, w });
         if (selected)
             c.put(x - 1 >= 0 ? x - 1 : x, ry, '▎', { fg: t.accent, bg: rowBg, soft: true });
         cx = x;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dexterm-cli",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "mcpName": "io.github.dexterm-xyz/dexterm",
   "description": "dexterm: terminal DEX screener with a local Claude CLI analyst",
   "author": "The dexterm authors",