dexterm-cli 0.1.4 → 0.1.6

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

@@ -7,11 +7,16 @@
 // The record carries NOTHING an agent could act on — it only describes a read/navigation call that
 // already completed. The file is local and token-marked; raw addresses live only on this loopback channel
 // and are redacted before anything leaves the machine.
-import { appendFileSync, readFileSync, statSync } from 'node:fs';
+import { appendFileSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 /** The UI-action tools that move the screen (so follow mode can visibly perform them). */
-const NAV_TOOLS = new Set(['open_token', 'show_in_screener', 'switch_feed', 'add_to_watchlist', 'open_ticket']);
+const NAV_TOOLS = new Set(['open_token', 'show_in_screener', 'switch_feed', 'switch_screen', 'add_to_watchlist', 'open_ticket']);
+/**
+ * task-1443: the view-only UI tools an EXTERNAL agent may use to move a terminal that follows it over MCP. Nothing
+ * here changes user data or settings (no watchlist add, no ticket, no theme/workspace): the screen only moves.
+ */
+export const FOLLOW_NAV_ACTIONS = ['open_token', 'show_in_screener', 'switch_feed', 'switch_screen'];
 function navFor(tool, args) {
     const s = (v) => (typeof v === 'string' ? v : undefined);
     if (tool === 'open_token')
@@ -19,7 +24,10 @@ function navFor(tool, args) {
     if (tool === 'switch_feed')
         return { screen: 'screener', feed: s(args.feed) };
     if (tool === 'show_in_screener')
-        return { screen: 'screener', filter: s(args.filter), highlight: s(args.highlight) };
+        return { screen: 'screener', feed: s(args.preset), filter: s(args.filter), highlight: s(args.highlight) };
+    // task-1443: the task-1413 view-only screen switch moves a following terminal too (e.g. to positions).
+    if (tool === 'switch_screen')
+        return s(args.screen) ? { screen: s(args.screen) } : null;
     if (tool === 'add_to_watchlist')
         return { screen: 'watchlist', mint: s(args.mint) };
     if (tool === 'open_ticket')
@@ -46,6 +54,29 @@ function shortMint(args) {
     const m = typeof args.mint === 'string' ? args.mint : typeof args.symbol === 'string' ? args.symbol : '';
     return m ? ` ${m.length > 10 ? m.slice(0, 6) + '…' : m}` : '';
 }
+/**
+ * task-1443: a readable, PAPER-labelled summary for an agent paper-trading call, so the activity panel says what
+ * the agent did to the simulated ledger (side, size, symbol), not just the tool name. null for any other tool.
+ */
+export function paperSummary(tool, args, result) {
+    if (!tool.startsWith('paper_'))
+        return null;
+    const s = (v) => (typeof v === 'string' ? v.slice(0, 16) : '');
+    const t = (result.ticket ?? {});
+    const f = (result.fill ?? {});
+    switch (tool) {
+        case 'paper_open_ticket': return `PAPER open ${s(args.side)} ticket ${s(args.symbol)}`.trim();
+        case 'paper_size_ticket': return typeof t.usd === 'number' ? `PAPER size ${s(t.symbol)} $${t.usd.toFixed(2)}` : typeof t.fraction === 'number' ? `PAPER size ${s(t.symbol)} ${Math.round(t.fraction * 100)}%` : 'PAPER size';
+        case 'paper_confirm':
+        case 'paper_close': {
+            const sol = typeof f.solDelta === 'number' ? ` ${f.solDelta > 0 ? '+' : ''}${f.solDelta.toFixed(4)} SOL` : '';
+            return `PAPER ${tool === 'paper_close' ? 'close' : s(f.side) || 'fill'} ${s(f.symbol)}${sol}`;
+        }
+        case 'paper_positions': return `PAPER positions (${Array.isArray(result.positions) ? result.positions.length : 0})`;
+        case 'paper_pnl': return 'PAPER pnl';
+        default: return null;
+    }
+}
 /** Build one spectator record for a completed MCP tool call. */
 export function recordForToolCall(opts) {
     const isErr = typeof opts.result.error === 'string';
@@ -55,11 +86,96 @@ export function recordForToolCall(opts) {
         // `nav` phase is the enforcement boundary that prevents a denied MCP call from moving the owner's TUI.
         v: 1, seq: opts.seq, t: (opts.now ?? Date.now)(), phase: isErr ? 'refused' : nav ? 'nav' : 'result',
         agent: opts.agent, transport: 'mcp', tool: opts.tool,
-        summary: isErr ? `error: ${String(opts.result.error).slice(0, 80)}` : `${opts.tool}${shortMint(opts.args)}`,
+        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)
@@ -88,6 +204,44 @@ function spectatorHome(env) {
     return env.DEXTERM_HOME && env.DEXTERM_HOME.trim() ? env.DEXTERM_HOME : join(homedir(), '.dexterm');
 }
 export function rendezvousPath(env) { return join(spectatorHome(env), MCP_SPECTATOR_RENDEZVOUS); }
+// task-1443: an EXTERNAL `dexterm mcp` server has no DEXTERM_SCREEN_STATE (the running app did not spawn it), so it
+// could never validate a navigation call against "the tokens currently on screen" and every nav tool failed — the
+// following terminal never moved. While a terminal follows over MCP it publishes a reduced snapshot of its screen
+// (screen, visible rows, selection, the action allow-list; no wallet, positions, tickets or app settings) here,
+// refreshed about once a second; the server validates nav calls against it exactly as it does for the in-app analyst.
+/** The follow-mode screen snapshot file name under ~/.dexterm. */
+export const MCP_FOLLOW_SCREEN = 'mcp-screen.json';
+/** A snapshot older than this is ignored (the terminal quit or froze): nav calls then fail closed. */
+export const FOLLOW_SCREEN_MAX_AGE_MS = 10_000;
+export function followScreenPath(env) { return join(spectatorHome(env), MCP_FOLLOW_SCREEN); }
+/** Write the follow-mode snapshot (0600). Best-effort: a write failure only means nav calls fail closed. */
+export function writeFollowScreen(env, snapshot) {
+    try {
+        writeFileSync(followScreenPath(env), JSON.stringify(snapshot) + '\n', { mode: 0o600 });
+    }
+    catch { /* fail closed */ }
+}
+/** Remove the follow-mode snapshot (the terminal quit or stopped following). */
+export function clearFollowScreen(env) {
+    try {
+        rmSync(followScreenPath(env), { force: true });
+    }
+    catch { /* ignore */ }
+}
+/** Read the follow-mode screen snapshot, or null when absent, malformed or stale. Never throws. */
+export function readFollowScreen(env, now = Date.now()) {
+    const path = followScreenPath(env);
+    try {
+        const st = statSync(path);
+        if (now - st.mtimeMs > FOLLOW_SCREEN_MAX_AGE_MS)
+            return null;
+        const o = JSON.parse(readFileSync(path, 'utf8'));
+        return o && typeof o === 'object' && !Array.isArray(o) ? o : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Resolve the spectator sink for a `dexterm mcp` server. DEXTERM_SPECTATOR_FILE (the running app spawned us,
  * e.g. the in-app analyst) wins and is always active; otherwise the sink watches the rendezvous file under

package/dist/packages/mcp/src/user-content.js

@@ -84,6 +84,7 @@ export function parseEntryFile(file, origin = 'bundled') {
 const MONEY_WORDS = new Set([
     'trade', 'swap', 'sign', 'signer', 'send', 'arm', 'ticket', 'order', 'transfer', 'withdraw', 'buy', 'sell',
     'confirm', 'execute', 'submit', 'panic', 'cap', 'caps', 'mandate', 'mandates', 'approve', 'pay', 'payment', 'fund',
+    'close', // task-1443: paper_close books a (simulated) sell — a skill may never name it
 ]);
 /** Tools that exist in dexterm and are money-adjacent by name, refused even though the server knows them. */
 export const MONEY_TOOLS = ['open_ticket'];

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

@@ -180,22 +180,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 +228,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 +246,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 +278,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, fillMarkers, 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

@@ -48,3 +48,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,8 @@
   <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="styles"></span>
     <span class="sep"></span>
     <span class="grp" id="scales"></span>
@@ -31,6 +33,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 +47,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 · 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>

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

@@ -12,6 +12,7 @@
   const $ = (id) => document.getElementById(id);
   const titleEl = $('title'), legendEl = $('legend'), liveEl = $('live'), bannerEl = $('banner'), hintEl = $('hint');
   const posEl = $('pos'), posTitleEl = $('pos-title'), posCapEl = $('pos-cap'), posCellsEl = $('pos-cells');
+  const chipEl = $('pnlchip');
   const imgSlot = $('coin-img-slot');
   const chartEl = $('chart'), drawCv = $('draw'), dctx = drawCv.getContext('2d');
   const STALE_MS = 20_000;
@@ -57,7 +58,7 @@
     if (type === 2) return String(d.getUTCDate());
     return `${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}`;
   }
-  const volFmt = (v) => C.fmtUsd(v);
+  const volFmt = (v) => C.fmtCompactUsd(v); // task-1472: volume stays USD, compact k/M
 
   // ---------------------------------------------------------------- chart + series
   const chart = L.createChart(chartEl, {
@@ -80,7 +81,7 @@
     handleScroll: { mouseWheel: true, pressedMouseMove: true, horzTouchDrag: true, vertTouchDrag: false },
     handleScale: { axisPressedMouseMove: { time: true, price: true }, axisDoubleClickReset: true, mouseWheel: true, pinch: true },
   });
-  // task-1366: the axis formatter follows the terminal's price mode (mcap = price × the current supply, K/M/B)
+  // task-1366/1472: the axis formatter follows the terminal's chart axis (mcap = price × the current supply, compact k/M/B)
   const pricePF = (p) => ({ type: 'custom', formatter: C.axisFormatter(S.display), minMove: C.priceFormatFor(p).minMove });
   // Keep the position levels (entry / stop / target) and the live price in view: autoscale widens to include them
   // when they are within 3× of the last close (a far-away level would squash the candles; its row cell still shows it).
@@ -159,13 +160,16 @@
   DT.onTheme(applyChartTheme);
 
   // ---------------------------------------------------------------- toolbar (buttons built with textContent only)
-  const btns = { tf: new Map(), styles: new Map(), scales: new Map(), inds: new Map(), draws: new Map() };
+  const btns = { tf: new Map(), axis: new Map(), styles: new Map(), scales: new Map(), inds: new Map(), draws: new Map() };
   function mkBtn(group, id, label, title, onClick) {
     const b = document.createElement('button'); b.type = 'button'; b.className = 'tb'; b.textContent = label; b.title = title;
     b.addEventListener('click', (e) => { e.preventDefault(); onClick(); });
     $(group).appendChild(b); btns[group].set(id, b); return b;
   }
   C.INTERVALS.forEach((iv, i) => mkBtn('tf', iv, iv, `timeframe ${iv} (${i + 1})`, () => requestInterval(iv)));
+  // task-1472: MCAP | PRICE asks the terminal to switch (and save) the chart axis; the next VM re-labels the page
+  mkBtn('axis', 'mcap', 'MCAP', 'Y axis: market cap (A / y toggles; saved by the terminal)', () => setAxis('mcap'));
+  mkBtn('axis', 'price', 'PRICE', 'Y axis: USD price (A / y toggles; saved by the terminal)', () => setAxis('price'));
   mkBtn('styles', 'candles', 'candles', 'candlesticks (c cycles)', () => setStyle('candles', true));
   mkBtn('styles', 'line', 'line', 'line (c cycles)', () => setStyle('line', true));
   mkBtn('styles', 'area', 'area', 'area (c cycles)', () => setStyle('area', true));
@@ -183,6 +187,8 @@
   mkBtn('draws', 'x', '✕ clear', 'clear drawings (x; backspace = undo last)', () => clearDrawings());
   function syncToolbar() {
     for (const [iv, b] of btns.tf) { b.classList.toggle('on', iv === S.interval); b.classList.toggle('pending', iv === S.pendingInterval && iv !== S.interval); }
+    const ax = S.vm && S.vm.priceMode === 'mcap' ? 'mcap' : 'price';
+    for (const [k, b] of btns.axis) b.classList.toggle('on', k === ax);
     for (const [k, b] of btns.styles) b.classList.toggle('on', k === S.style);
     for (const [k, b] of btns.scales) b.classList.toggle('on', k === S.scale);
     for (const [k, b] of btns.inds) b.classList.toggle('on', S.ind.has(k));
@@ -196,6 +202,11 @@
     S.pendingInterval = iv; S.reqAt = performance.now(); syncToolbar();
     DT.send({ type: 'event', name: 'chart.interval', payload: { interval: iv } });
   }
+  /** task-1472: ask the terminal for a Y axis; nothing changes here until its next VM carries the new mode. */
+  function setAxis(axis) {
+    if (axis !== 'mcap' && axis !== 'price') return;
+    DT.send({ type: 'event', name: 'chart.axis', payload: { axis } });
+  }
   function setStyle(st, user) {
     if (!C.STYLES.includes(st) || st === S.style) return;
     S.style = st;
@@ -397,6 +408,23 @@
     }
   }
 
+  // task-1473 r2: the POSITION PnL chip (formatted terminal-side; textContent only, display only)
+  function renderChip() {
+    const chip = S.vm && S.vm.chip;
+    if (!chipEl) return;
+    if (!chip || !Array.isArray(chip.segments) || !chip.segments.length) { chipEl.hidden = true; return; }
+    chipEl.hidden = false;
+    while (chipEl.firstChild) chipEl.removeChild(chipEl.firstChild);
+    const tone = ['up', 'down'].includes(chip.tone) ? chip.tone : '';
+    for (const sg of chip.segments.slice(0, 8)) {
+      const id = ['head', 'pnl', 'peak', 'px', 'held', 'dd', 'tp'].includes(sg.id) ? sg.id : 'x';
+      let cls = `seg ${id}`;
+      if (id === 'pnl') cls += ` ${tone}${chip.newPeak ? ' flash' : ''}`;
+      if (id === 'peak') cls += ` ${/^peak −/.test(String(sg.text)) ? 'down' : 'up'}`;
+      chipEl.appendChild(el('span', cls, String(sg.text).slice(0, 48)));
+    }
+  }
+
   // ---------------------------------------------------------------- incoming view models
   function onData(vm) {
     if (!vm || typeof vm !== 'object') return;
@@ -409,7 +437,7 @@
     // task-1366: a mode / supply change re-labels the axis in place (the bars are prices either way)
     const disp = C.displayOf(vm);
     if (disp.key !== S.display.key) { S.display = disp; applyPriceFormat(); }
-    if (tail && (!vm.seriesKey || vm.seriesKey !== S.key)) { S.vm = { ...vm, candles: [] }; renderHeader(); renderPosition(); renderOverlays(); return; }
+    if (tail && (!vm.seriesKey || vm.seriesKey !== S.key)) { S.vm = { ...vm, candles: [] }; renderHeader(); renderPosition(); renderChip(); renderOverlays(); return; }
     const intervalChanged = vm.interval !== S.interval;
     S.interval = vm.interval;
     const answered = S.pendingInterval === vm.interval ? S.reqAt : null;
@@ -425,7 +453,7 @@
       if (intervalChanged || S.key !== prevKey) S.fitNext = true;
       renderFull();
     }
-    renderHeader(); renderLegend(S.hover); renderDataBanner(); renderPosition(); syncToolbar(); renderLive();
+    renderHeader(); renderLegend(S.hover); renderDataBanner(); renderPosition(); renderChip(); syncToolbar(); renderLive();
     // rain mood follows direction (gold on a pump, red-shift on a dump), as in the v1 HUD; chg is in percent
     const dir = vm.chg ? (vm.chg.h24 ?? vm.chg.h1 ?? 0) : 0;
     if (rain) { rain.setMood(dir > 1 ? 'rainPump' : dir < -1 ? 'rainDump' : 'rain'); rain.setActivity(Math.min(1, 0.4 + Math.abs(dir) / 100)); rain.setSources([String(vm.symbol || ''), String(vm.mint || '').slice(0, 6)]); }
@@ -514,6 +542,7 @@
     const n = parseInt(k, 10);
     if (n >= 1 && n <= 6) { requestInterval(C.INTERVALS[n - 1]); return; }
     switch (k) {
+      case 'A': case 'y': setAxis(S.vm && S.vm.priceMode === 'mcap' ? 'price' : 'mcap'); break; // task-1472
       case 'c': setStyle(C.STYLES[(C.STYLES.indexOf(S.style) + 1) % C.STYLES.length], true); break;
       case 'a': setScale('auto', true); break;
       case 'l': setScale(S.scale === 'log' ? 'auto' : 'log', true); break;

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

@@ -43,3 +43,48 @@
 .spec-act-age { color: var(--warn); }
 
 .spec-foot-redact { color: var(--up); font-weight: 600; }
+
+/* task-1466 spectator v2: the agent story (phase rail + heartbeat, thought ribbon, call timeline, vetting + PAPER cards) */
+.spec-story { display: flex; flex-direction: column; gap: 8px; margin-bottom: 10px; font: 12px ui-monospace, Menlo, monospace; }
+.spec-rail { display: flex; flex-wrap: wrap; align-items: center; gap: 4px; }
+.spec-heart { width: 10px; height: 10px; border-radius: 50%; background: var(--down); margin-right: 6px; box-shadow: 0 0 8px var(--down); animation: spec-beat 1s infinite ease-out; }
+.spec-heart.still { animation: none; background: var(--warn); box-shadow: none; }
+.spec-heart.dead { animation: none; background: var(--dim); box-shadow: none; }
+@keyframes spec-beat { 0% { transform: scale(1.35); opacity: 1; } 30% { transform: scale(0.9); opacity: 0.7; } 100% { transform: scale(1); opacity: 0.85; } }
+.spec-bpm { color: var(--muted); margin-right: 8px; min-width: 44px; }
+.spec-phase { padding: 2px 8px; border-radius: 4px; color: var(--dim); border: 1px solid transparent; letter-spacing: 0.05em; }
+.spec-phase.done { color: var(--muted); }
+.spec-phase.on { color: #000; background: var(--accent); font-weight: 700; box-shadow: 0 0 12px color-mix(in srgb, var(--accent) 60%, transparent); }
+.spec-phase.on.p-vetting { background: var(--borderFocus); box-shadow: 0 0 12px color-mix(in srgb, var(--borderFocus) 60%, transparent); }
+.spec-phase.on.p-sizing { background: var(--warn); }
+.spec-phase.on.p-executing { background: var(--up); }
+.spec-phase.on.p-holding { background: var(--pump); }
+.spec-phase.on.p-exiting { background: var(--ai, var(--accent)); }
+.spec-sep { color: var(--border); }
+.spec-paper { margin-left: auto; padding: 1px 6px; border-radius: 4px; background: var(--warn); color: #000; font-weight: 700; }
+.spec-ctlstate { padding: 1px 6px; border-radius: 4px; font-weight: 700; color: #000; }
+.spec-ctlstate.paused { background: var(--warn); }
+.spec-ctlstate.takeover { background: var(--accent); }
+.spec-ctlstate.killed { background: var(--down); color: #fff; }
+.spec-ribbon { padding: 6px 8px; border-left: 3px solid var(--ai, var(--accent)); background: color-mix(in srgb, var(--panel) 85%, transparent); color: var(--text); min-height: 1.4em; }
+.spec-ribbon.ours { border-left-color: var(--border); color: var(--muted); font-style: italic; }
+.spec-ribbon-who { color: var(--ai, var(--accent)); margin-right: 6px; font-style: normal; }
+.spec-timeline { display: flex; align-items: flex-start; gap: 0; overflow: hidden; justify-content: flex-end; }
+.spec-node { display: flex; flex-direction: column; align-items: center; gap: 2px; padding: 0 2px; }
+.spec-node-l { color: var(--text); white-space: nowrap; }
+.spec-node.paper .spec-node-l { color: var(--warn); font-weight: 700; }
+.spec-chip { font-size: 10px; padding: 0 5px; border-radius: 3px; background: color-mix(in srgb, var(--up) 18%, transparent); color: var(--up); }
+.spec-chip.slow { background: color-mix(in srgb, var(--warn) 18%, transparent); color: var(--warn); }
+.spec-chip.fail, .spec-chip.refused { background: color-mix(in srgb, var(--down) 22%, transparent); color: var(--down); }
+.spec-link { color: var(--border); align-self: flex-start; margin-top: 1px; }
+.spec-cards { display: flex; flex-wrap: wrap; gap: 8px; }
+.spec-card { flex: 1 1 220px; border: 1px solid var(--border); border-radius: 6px; padding: 6px 8px; background: color-mix(in srgb, var(--panel) 85%, transparent); }
+.spec-card-h { color: #000; background: var(--borderFocus); font-weight: 700; padding: 0 6px; border-radius: 3px; display: inline-block; margin-bottom: 4px; }
+.spec-card.trade .spec-card-h { background: var(--pump); }
+.spec-check { margin-right: 8px; color: var(--dim); }
+.spec-check.ok { color: var(--up); font-weight: 600; }
+.spec-big { font-size: 30px; font-weight: 800; letter-spacing: 0.02em; line-height: 1.1; }
+.spec-big.up { color: var(--up); text-shadow: 0 0 14px color-mix(in srgb, var(--up) 45%, transparent); }
+.spec-big.down { color: var(--down); }
+.spec-kv { color: var(--muted); }
+.spec-kv b { color: var(--text); font-weight: 600; }