dexterm-cli 0.1.4 → 0.1.6

package/dist/packages/cli/src/screens/pnl-chip.js

@@ -0,0 +1,143 @@
+// dexterm — the persistent POSITION PnL chip (task-1473). While an auto mode runs and a position is open, one compact
+// readout is on every terminal screen and on the chart popup: coin, mark PnL % with sign (and $ when the size is
+// known), entry → mark, peak, drawdown from the peak, time held and the take-profit. Sources (state.ts pnlChipFor):
+//   · following an agent (task-1466 HUD) that holds a PAPER ticket — the folded story, TP = what the agent said;
+//   · AI scan mode with the user's OWN paper or live position (OwnPnlTracker; session peak, TP = the ledger target).
+// Where it draws: the HUD dock's signal row when the dock is up (≥ HUD_MIN_H rows while following), else the band
+// under the header (row 1, right-aligned: short terminals, scan mode), and the chart popup's chip strip (ChartVM.chip).
+// It updates on every mark tick, flashes on a new peak (a ★ glyph says the same under calm mode / NO_COLOR) and drops
+// fields from the right as the width shrinks. Display only: it has no input and reads only folded / ledger state.
+import { mix } from '../../../tui/src/index.js';
+import { fmtPx } from '../../../agents/src/index.js';
+import { planFromThoughts, fmtDur } from "./brain.js";
+export const PEAK_FLASH_MS = 1200;
+/** The chip for the followed agent's open PAPER position, or null when nothing is held. */
+export function pnlChipVM(v, now) {
+    const a = v.arc;
+    if (!a || a.stage !== 'open')
+        return null;
+    const dd = a.pnlPct !== null && a.peakPct !== null ? (1 + a.pnlPct) / (1 + a.peakPct) - 1 : null;
+    return {
+        kind: 'PAPER',
+        symbol: a.symbol,
+        pnlPct: a.pnlPct,
+        pnlUsd: a.pnlPct !== null && a.sizeUsd !== null ? a.sizeUsd * a.pnlPct : null,
+        entry: a.entryUsd !== null ? `$${fmtPx(a.entryUsd)}` : '—',
+        mark: a.mark ? `$${fmtPx(a.mark.priceUsd)}` : '—',
+        peakPct: a.peakPct,
+        ddPct: dd,
+        heldMs: a.filledAt !== null ? now - a.filledAt : null,
+        tp: planFromThoughts(v.thoughts, a.openedAt).tp,
+        newPeak: a.peakAt !== null && now - a.peakAt < PEAK_FLASH_MS && a.peakPct !== null && a.peakPct > 0,
+    };
+}
+/**
+ * The user's own position chip in AI scan mode. The ledgers keep no peak, so the peak is this session's highest
+ * mark (reset when the held coin or ledger changes, or the position goes flat). Display only.
+ */
+export class OwnPnlTracker {
+    cur = null;
+    update(s, now) {
+        if (!s) {
+            this.cur = null;
+            return;
+        }
+        const seed = !this.cur || this.cur.s.mint !== s.mint || this.cur.s.kind !== s.kind;
+        if (seed)
+            this.cur = { s, peakPct: s.pnlPct, peakAt: null }; // the first mark is not a "new peak" flash
+        const c = this.cur;
+        c.s = s;
+        if (!seed && s.pnlPct !== null && (c.peakPct === null || s.pnlPct > c.peakPct + 1e-9)) {
+            c.peakPct = s.pnlPct;
+            c.peakAt = now;
+        }
+    }
+    get mint() { return this.cur?.s.mint ?? null; }
+    vm(now) {
+        const c = this.cur;
+        if (!c)
+            return null;
+        const s = c.s;
+        const dd = s.pnlPct !== null && c.peakPct !== null ? (1 + s.pnlPct) / (1 + c.peakPct) - 1 : null;
+        return {
+            kind: s.kind === 'live' ? 'LIVE' : 'PAPER',
+            symbol: s.symbol,
+            pnlPct: s.pnlPct,
+            pnlUsd: s.pnlUsd,
+            entry: s.entryUsd !== null ? `$${fmtPx(s.entryUsd)}` : '—',
+            mark: s.markUsd !== null ? `$${fmtPx(s.markUsd)}` : '—',
+            peakPct: c.peakPct,
+            ddPct: dd,
+            heldMs: s.openedAt !== null ? Math.max(0, now - s.openedAt) : null,
+            tp: s.targetUsd !== null ? `$${fmtPx(s.targetUsd)}` : null,
+            tpNone: 'not set',
+            newPeak: c.peakAt !== null && now - c.peakAt < PEAK_FLASH_MS && c.peakPct !== null && c.peakPct > 0,
+        };
+    }
+}
+const pct = (r) => `${r >= 0 ? '+' : '−'}${Math.abs(r * 100).toFixed(1)}%`;
+const usd = (n) => `${n >= 0 ? '+' : '−'}$${Math.abs(n).toFixed(2)}`;
+/** The chip's segments in priority order (the first ones survive the narrowest widths). */
+export function chipSegments(m) {
+    const segs = [];
+    const dir = m.pnlPct === null ? '·' : m.pnlPct >= 0 ? '▲' : '▼';
+    segs.push({ id: 'head', text: `${m.kind} $${m.symbol}` });
+    segs.push({ id: 'pnl', text: `${dir} ${m.pnlPct === null ? '—' : pct(m.pnlPct)}${m.pnlUsd !== null ? ` ${usd(m.pnlUsd)}` : ''}` });
+    if (m.peakPct !== null)
+        segs.push({ id: 'peak', text: `peak ${pct(m.peakPct)}${m.newPeak ? ' ★' : ''}` });
+    segs.push({ id: 'px', text: `${m.entry} → ${m.mark}` });
+    if (m.heldMs !== null)
+        segs.push({ id: 'held', text: `held ${fmtDur(m.heldMs)}` });
+    if (m.ddPct !== null && m.ddPct < -0.0005)
+        segs.push({ id: 'dd', text: `dd ${pct(m.ddPct)}` });
+    segs.push({ id: 'tp', text: m.tp ? `TP ${m.tp}` : `TP ${m.tpNone ?? 'agent-managed'}` });
+    return segs;
+}
+const SEP = ' │ ';
+/** The chip text that fits in `maxW` (segments drop from the end). Pure, for tests. */
+export function chipText(m, maxW) {
+    const segs = chipSegments(m);
+    let n = segs.length;
+    const join = (k) => ` ${segs.slice(0, k).map((s) => s.text).join(SEP)} `;
+    while (n > 1 && join(n).length > maxW)
+        n--;
+    const s = join(n);
+    return s.length <= maxW ? s : '';
+}
+/**
+ * Draw the chip right-aligned to `right` (exclusive) on row `y`, no wider than `maxW`. Returns the x it starts at
+ * (or `right` when nothing fits).
+ */
+export function renderPnlChip(c, right, y, maxW, m, o) {
+    const t = c.theme;
+    const text = chipText(m, maxW);
+    if (!text)
+        return right;
+    const x0 = right - text.length;
+    const bg = mix(t.bg, t.magenta, 0.22);
+    const col = m.pnlPct === null ? t.muted : m.pnlPct >= 0 ? t.up : t.down;
+    c.text(x0, y, text, { fg: t.text, bg });
+    // re-colour the segments: head magenta, PnL red/green bold (flash on a new peak), peak green, dd warn
+    let x = x0 + 1;
+    for (const s of chipSegments(m)) {
+        if (x + s.text.length > right - 1)
+            break;
+        if (s.id === 'head')
+            c.text(x, y, s.text, { fg: t.magenta, bg, b: true });
+        else if (s.id === 'pnl') {
+            const flash = m.newPeak && !o.reduced;
+            c.text(x, y, s.text, flash ? { fg: t.bg, bg: t.up, b: true } : { fg: col, bg, b: true });
+        }
+        else if (s.id === 'peak')
+            c.text(x, y, s.text, { fg: m.peakPct !== null && m.peakPct >= 0 ? t.up : t.down, bg, b: m.newPeak });
+        else if (s.id === 'dd')
+            c.text(x, y, s.text, { fg: t.warn, bg });
+        else
+            c.text(x, y, s.text, { fg: t.muted, bg });
+        x += s.text.length;
+        if (x + SEP.length < right)
+            c.text(x, y, SEP, { fg: mix(bg, t.border, 0.8), bg });
+        x += SEP.length;
+    }
+    return x0;
+}

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

@@ -195,6 +195,7 @@ export function renderScreener(c, state) {
         : null;
     table(c, box.x + 1, box.y, box.w - 2, box.h, {
         columns: screenerColumns(c, bp, sc.gates, state.larpByMint ?? null, icon, mode), rows, selected: sel, scroll: Math.max(0, scroll), sortKey: sc.sort.key, sortDir: sc.sort.dir, bg: box.bg,
+        rowKey: (r) => r.mint, // task-1466: the agent HUD finds the rows it scanned
     });
     if (rows.length === 0)
         emptyState(c, box, sc);

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

@@ -8,8 +8,9 @@ import { renderTokenLive } from "../live/screens/token-live.js";
 import { aiTranscript } from "../fixtures.js";
 import { renderAnalystSession } from "./analyst-session.js";
 import { renderSocialPanel } from "./social-panel.js";
+import { brainFor, factsFromFixture, renderBrainPanel } from "./brain.js";
 import { layoutFor } from "../custom.js";
-import { chartMode, priceModeOf } from "../display.js";
+import { chartMode, chartTitle, chartAxisOf, priceModeOf } from "../display.js";
 export function renderToken(c, state) {
     if (state.live?.token && state.screener.source !== 'fixtures')
         return renderTokenLive(c, state, state.live.token.view); // task-1298: live data path
@@ -48,13 +49,13 @@ export function renderToken(c, state) {
     // price line: pump glow = gold bg band, dump = red band (the rain ramp of the moment)
     const priceBg = pumping ? mix(t.bg, t.rainPump[2], 0.3) : dumping ? mix(t.bg, t.rainDump[2], 0.3) : t.bg;
     // task-1366: mcap mode leads with the market cap and keeps the price beside it (fixture tokens always carry a supply)
-    const cm = chartMode(priceModeOf(state), tk.price, tk.mcap);
-    if (cm.kind === 'mcap') {
+    const pm = chartMode(priceModeOf(state), tk.price, tk.mcap);
+    if (pm.kind === 'mcap') {
         x = c.text(1, y, fmtMcap(tk.mcap), { fg: pumping ? t.rainPump[3] : t.text, bg: priceBg, b: true });
         x = c.text(x, y, ` (${fmtPrice(tk.price)})`, { fg: t.dim, bg: priceBg });
     }
     else
-        x = c.text(1, y, fmtPrice(tk.price), { fg: cm.label ? t.warn : pumping ? t.rainPump[3] : t.text, bg: priceBg, b: true });
+        x = c.text(1, y, fmtPrice(tk.price), { fg: pm.label ? t.warn : pumping ? t.rainPump[3] : t.text, bg: priceBg, b: true });
     const deltas = [['5m', tk.chg.m5], ['1h', tk.chg.h1], ['6h', tk.chg.h6], ['24h', tk.chg.h24]];
     x = c.text(x, y, '  ', { bg: t.bg });
     for (const [k, vv] of deltas) {
@@ -70,7 +71,9 @@ export function renderToken(c, state) {
     y += 1;
     // ---- chart
     const chartH = Math.max(10, Math.floor((bottom - y) * lay.chartFrac));
-    const cb = c.box(0, y, mainW, chartH, { title: cm.label ? (cm.kind === 'mcap' ? `${tk.symbol} ${cm.label} · 1h` : `${tk.symbol}/SOL · ${cm.label} · 1h`) : `${tk.symbol}/SOL · 1h`, caption: 'ohlcv: geckoterminal' });
+    // task-1472: the chart Y axis is its own setting (default MARKET CAP, `A` toggles); the header above keeps `$`
+    const cm = chartMode(chartAxisOf(state), tk.price, tk.mcap);
+    const cb = c.box(0, y, mainW, chartH, { title: chartTitle(tk.symbol, '1h', cm, 'SOL'), caption: 'ohlcv: geckoterminal' });
     const tfx = cb.x + cb.w - 2;
     const tfs = ['1m', '5m', '15m', '1h', '4h', '1d'];
     let tx = tfx - tfs.reduce((s, f) => s + f.length + 1, 0) - 24;
@@ -171,8 +174,14 @@ export function renderToken(c, state) {
             }
         }
     }
-    if (showAi)
-        analystPanel(c, mainW, top, aiW, bottom - top, tk, state);
+    if (showAi) {
+        // task-1473: in an auto mode (following an agent / AI scan) the panel is the BRAIN VIEW; otherwise the analyst
+        const brain = brainFor(state, factsFromFixture(tk, state.larpByMint?.get(tk.mint)?.verdict ?? null), isCalm(v), state.live?.scanMeterLabel?.() ?? '');
+        if (brain)
+            renderBrainPanel(c, mainW, top, aiW, bottom - top, brain.model, brain.opts);
+        else
+            analystPanel(c, mainW, top, aiW, bottom - top, tk, state);
+    }
     footer(c, state.tokenSocial
         ? [['esc', 'back'], ['s', 'on-chain'], ['f', 'filter'], ['x', state.socialShowSpam ? 'hide spam' : 'show hidden'], ['K', 'KOL lists'], ['a', showAi ? 'hide analyst' : 'analyst'], ['w', 'watch'], ['q', 'quit']]
         : [['esc', 'back'], ['g', 'go to'], ['a', showAi ? 'hide analyst' : 'analyst'], ['h/t/r', 'holders/trades/traders'], ['w', 'watch'], ['b', 'alert'], ['1-6', 'timeframe'], ['q', 'quit']], state.theme.name, isCalm(v));

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

@@ -70,7 +70,7 @@ export function renderTrending(c, state) {
     if (rows.length === 0)
         c.textC(box.x, box.y + 2, box.w, all.length ? 'no rows match the filter — f cycles filters, n clears the narrative' : 'nothing trending yet — the keyless venues refresh every 60 s', { fg: t.muted, bg, i: true });
     else
-        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows, selected: sel, scroll, bg });
+        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows, selected: sel, scroll, bg, rowKey: (r) => r.mint });
     // sub-panels
     const sy = top + boardH;
     const news = feed.newsItems(12);

package/dist/packages/cli/src/state.js

@@ -1,11 +1,13 @@
 // dexterm — app state consumed by the screens. Screens are pure render(canvas, state) functions;
 // renderFrame() draws the screen, the toast, then runs the effects post-pass (VISUAL-V2 §3).
-import { Canvas, THEMES, applyFx, toast, makeVfx, setSources, marketActivity, candleActivity, isCalm, } from '../../tui/src/index.js';
+import { Canvas, THEMES, applyFx, toast, makeVfx, setSources, marketActivity, candleActivity, isCalm, breakpoint, } from '../../tui/src/index.js';
 import { makeFixtures } from "./fixtures.js";
 import { fromFixture } from "./screener/rows.js";
 import { makeScreenerState, screenerView } from "./screener/view.js";
 import { renderScreener } from "./screens/screener.js";
 import { renderToken } from "./screens/token.js";
+import { agentBrainActive } from "./screens/brain.js";
+import { pnlChipVM, renderPnlChip } from "./screens/pnl-chip.js";
 import { renderNewPairs } from "./screens/newpairs.js";
 import { renderWatchlist } from "./screens/watchlist.js";
 import { renderAnalyst } from "./screens/analyst.js";
@@ -28,7 +30,9 @@ import { openTicket } from "./trade.js";
 import { computeFill } from '../../data/src/index.js';
 import { renderScanTicker, scanIndicator } from "./scan/ui.js";
 import { renderVoiceHud } from "./voice-hud.js";
+import { composeHud, DOCK_ROWS, HUD_MIN_H } from "./screens/agent-hud.js";
 import { workspaceBadge } from "./custom.js";
+import { chartAxisOf, supplyRatio } from "./display.js";
 /** Map key for the Analyst-tab's own conversation (not tied to a single token). */
 export const ANALYST_TAB_KEY = '__analyst_tab__';
 /**
@@ -426,8 +430,54 @@ export function refreshVfx(state) {
     state.vfx.activity = act.activity;
     state.vfx.mood = act.mood;
 }
-/** Render one frame of the current screen into a fresh canvas: screen → toast → effects. */
+/**
+ * Render one frame of the current screen into a fresh canvas: screen → toast → effects. task-1466: while the
+ * terminal follows an agent, the screen renders DOCK_ROWS shorter and the agent HUD's dock takes the bottom rows
+ * (so no data is hidden), with its overlays (row glow, cursor, cards, flashes, the kill cut) over the screen.
+ */
 export function renderFrame(state, w, h) {
+    const hud = state.agentHud;
+    if (!hud || state.screen === 'boot' || h < HUD_MIN_H)
+        return renderScreenFrame(state, w, h, true);
+    const now = hud.clock();
+    const screen = renderScreenFrame(state, w, h - DOCK_ROWS, false);
+    const view = hud.story.view(now);
+    // task-1473: on the token screen the analyst panel is the agent's brain view (same rule the screen used)
+    const brain = state.screen === 'token' && state.aiOpen !== false && breakpoint(w) !== 'compact' && !state.aiFocused && agentBrainActive(view, now);
+    return composeHud(new Canvas(w, h, state.theme), screen, view, {
+        now, reduced: !!hud.reduced || isCalm(state.vfx), depth: state.colorDepth, dataLabel: hud.dataLabel ?? null, screen: state.screen, brain,
+        chip: pnlChipFor(state, now, view),
+        mcapScale: chartAxisOf(state) === 'mcap' ? (mint) => hudMcapScale(state, mint) : undefined, // task-1472
+    });
+}
+/** task-1472: the supply ratio for the HUD's position card: the open token's (live, else fixture), else its screener row. */
+function hudMcapScale(state, mint) {
+    const v = state.live?.token?.view;
+    if (v && v.mint === mint)
+        return supplyRatio(v.price, v.mcap);
+    const tk = state.token;
+    if (tk && tk.mint === mint)
+        return supplyRatio(tk.price, tk.mcap);
+    const row = state.screener.rows.find((r) => r.mint === mint); // the card also shows over the lists (task-1473)
+    return row ? supplyRatio(row.price, row.mcap) : null;
+}
+/**
+ * task-1473: the POSITION PnL chip for the app's current auto mode, or null. Following an agent: its open PAPER
+ * ticket (the folded story). Else, while AI scan mode runs: the user's own held paper / live position (ownPnl).
+ * The same chip feeds the HUD dock, the band row (no dock) and the chart popup. Display only.
+ */
+export function pnlChipFor(state, now, view) {
+    const hud = state.agentHud;
+    if (hud) {
+        const m = pnlChipVM(view ?? hud.story.view(now), now);
+        if (m)
+            return m;
+    }
+    if (state.scan?.engine.on && state.ownPnl)
+        return state.ownPnl.vm(now);
+    return null;
+}
+function renderScreenFrame(state, w, h, bandChip = false) {
     const c = new Canvas(w, h, state.theme);
     c.fill(0, 0, w, h, ' ', { bg: state.theme.bg });
     c.imageMode = state.images && state.imageProtocol && state.imageProtocol !== 'blocks' ? 'pixels' : 'cells';
@@ -445,11 +495,25 @@ export function renderFrame(state, w, h) {
         renderVoiceHud(c, state.voice, state.theme);
     // task-1358: the workspace badge (non-default name, a pending ctrl+w chord, the save-as input) on the band
     // under the header, right-aligned, drawn after the effects so it is always legible. Nothing on `default`.
+    // task-1473 r2: no HUD dock (short terminal, or AI scan mode): the PnL chip rides the band, right-aligned,
+    // and the workspace badge moves to its left.
+    let bandRight = w - 1;
+    if (bandChip && state.screen !== 'boot') {
+        const now = state.agentHud?.clock() ?? state.now.getTime();
+        const chip = pnlChipFor(state, now);
+        if (chip) {
+            const x0 = renderPnlChip(c, w - 1, 1, Math.max(36, Math.floor(w * 0.7)), chip, { now, reduced: !!state.agentHud?.reduced || isCalm(state.vfx) });
+            if (x0 < w - 1) {
+                c.noRain(x0, 1, w - 1 - x0, 1);
+                bandRight = x0 - 1;
+            }
+        }
+    }
     const badge = state.screen !== 'boot' ? workspaceBadge(state.custom, state.now.getTime()) : null;
-    if (badge) {
+    if (badge && bandRight > 4) {
         const t = state.theme;
-        const text = badge.text.slice(0, Math.max(0, w - 2));
-        const x = Math.max(0, w - text.length - 1);
+        const text = badge.text.slice(0, Math.max(0, bandRight - 1));
+        const x = Math.max(0, bandRight - text.length);
         c.noRain(x, 1, text.length, 1);
         c.text(x, 1, text, badge.kind === 'input' ? { fg: t.text, bg: t.accentSoft, b: true } : badge.kind === 'chord' ? { fg: t.warn, bg: t.warnSoft, b: true } : { fg: t.accent, bg: t.headBg, b: true });
     }

package/dist/packages/cli/src/version.js

@@ -1,3 +1,3 @@
 // The one place the app's version lives (task-1397). --version, the help banner and `dexterm update` read it;
 // cli.test.ts keeps it equal to packages/cli/package.json (release.yml refuses a tag that differs).
-export const VERSION = '0.1.4';
+export const VERSION = '0.1.6';

package/dist/packages/custom/src/rules.js

@@ -3,13 +3,13 @@ export const FIELDS = {
     vol5m: (r) => r.vol5m, vol1h: (r) => r.vol1h, vol24: (r) => r.vol24,
     holders: (r) => r.holders, org: (r) => r.org, top10: (r) => r.top10, dev: (r) => r.dev,
     lplocked: (r) => r.lpLocked, bundled: (r) => r.bundled, snipers: (r) => r.snipers,
-    cluster: (r) => r.cluster, larp: (r) => r.larp,
+    cluster: (r) => r.cluster, larp: (r) => r.larp, devrugs: (r) => r.devRugs,
     fresh: (r) => r.fresh, mintable: (r) => r.mintable, freezable: (r) => r.freezable,
     age: (r) => r.ageMin, m5: (r) => r.chg?.m5, h1: (r) => r.chg?.h1, h6: (r) => r.chg?.h6, h24: (r) => r.chg?.h24,
     buys: (r) => r.buys, sells: (r) => r.sells, bonding: (r) => r.bonding,
 };
 export const FIELD_NAMES = Object.keys(FIELDS);
-const ALIASES = { vol: 'vol24', volume: 'vol24', liquidity: 'liq', cap: 'mcap', mc: 'mcap', holder: 'holders', organic: 'org', top: 'top10', locked: 'lplocked', 'cluster%': 'cluster', clusterpct: 'cluster', freshwallets: 'fresh', mintauth: 'mintable', freezeauth: 'freezable' };
+const ALIASES = { vol: 'vol24', volume: 'vol24', liquidity: 'liq', cap: 'mcap', mc: 'mcap', holder: 'holders', organic: 'org', top: 'top10', locked: 'lplocked', 'cluster%': 'cluster', clusterpct: 'cluster', freshwallets: 'fresh', mintauth: 'mintable', freezeauth: 'freezable', devrug: 'devrugs', serialrugger: 'devrugs' };
 const OPS = { '>': (a, b) => a > b, '>=': (a, b) => a >= b, '<': (a, b) => a < b, '<=': (a, b) => a <= b, '=': (a, b) => a === b, '==': (a, b) => a === b, '!=': (a, b) => a !== b };
 const TAGS = {
     launchpad: (r, v) => (r.launchpad ?? '').toLowerCase().replace('.fun', '') === v.toLowerCase().replace('.fun', ''),

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

@@ -140,6 +140,12 @@ export const LAYOUT_SCREENS = ['screener', 'token', 'newpairs', 'watchlist', 'an
  */
 export const PRICE_MODES = ['price', 'mcap'];
 export const DEFAULT_PRICE_MODE = 'price';
+/**
+ * task-1472: what the CHART Y axis shows (the terminal token chart and the chart popup), separate from the table/header
+ * price mode: `mcap` (default; absent = mcap, so existing configs get it too) or `price`. `A` / the popup control toggle it.
+ */
+export const CHART_AXES = ['mcap', 'price'];
+export const DEFAULT_CHART_AXIS = 'mcap';
 const tokenProps = () => Object.fromEntries([...THEME_TOKENS.map((t) => [t, 'hex']), ...THEME_RAMPS.map((t) => [t, 'ramp'])]);
 export const SCHEMAS = {
     hex: { type: 'string', pattern: HEX },
@@ -236,8 +242,8 @@ export const SCHEMAS = {
                     user: { type: 'object', values: 'userTheme' },
                 } },
             fx: { type: 'object', additional: false, props: { intensity: { type: 'string', enum: ['off', 'normal', 'fever'] }, sound: { type: 'boolean' } } },
-            /** task-1366: display options. `priceMode` price | mcap (the `$` key toggles and persists it). */
-            display: { type: 'object', additional: false, props: { priceMode: { type: 'string', enum: PRICE_MODES } } },
+            /** task-1366: display options. `priceMode` price | mcap (the `$` key toggles and persists it). task-1472: `chartAxis` mcap | price (`A`; absent = mcap). */
+            display: { type: 'object', additional: false, props: { priceMode: { type: 'string', enum: PRICE_MODES }, chartAxis: { type: 'string', enum: CHART_AXES } } },
             layout: { type: 'object', additional: false, props: {
                     workspace: { type: 'string', pattern: WS_NAME },
                     workspaces: { type: 'object', values: 'workspace' },
@@ -261,6 +267,10 @@ export const SCHEMAS = {
                     /** Reserved: the trading gate is NOT here (signer policy owns it); listed so a proposal that tries gets a precise refusal. */
                     gate: { type: 'string', enum: ['keypress'] },
                 } },
+            /** 0.1.5: which of the user's own CLIs runs the analyst. `/analyst` is user-only (DENIED_FOR_MODELS): a model never picks its own engine. */
+            analyst: { type: 'object', additional: false, props: {
+                    engine: { type: 'string', enum: ['auto', 'claude', 'codex'] },
+                } },
             /** task-1393: voice-out preferences. `/voice` is user-only (DENIED_FOR_MODELS), so only the keyboard sets it. */
             voice: { type: 'object', additional: false, props: {
                     name: { type: 'string', max: 64 },
@@ -426,7 +436,7 @@ export function applyOps(doc, ops) {
 export const DENIED_FOR_MODELS = [
     /^\/signer(\/|$)/, /^\/trading(\/|$)/, /^\/keys(\/|$)/, /^\/caps(\/|$)/, /^\/mandates?(\/|$)/, /^\/wallet(\/|$)/,
     /^\/packs(\/|$)/, /^\/plugins\/[^/]+\/(capabilities|enabled)(\/|$)/, /^\/plugins\/[^/]+$/, /^\/plugins$/,
-    /^\/jarvis\/gate(\/|$)/, /^\/jarvis\/configAssistant$/, /^\/voice(\/|$)/, /^\/alerts(\/|$)/, /^\/agents(\/|$)/, /^\/version$/,
+    /^\/jarvis\/gate(\/|$)/, /^\/jarvis\/configAssistant$/, /^\/voice(\/|$)/, /^\/analyst(\/|$)/, /^\/alerts(\/|$)/, /^\/agents(\/|$)/, /^\/version$/,
     /^\/rules\/(\d+|-)\/then\/(\d+|-)\/args\/(arm|armed|auto|autoArm|confirm|execute|sign|send)(\/|$)/,
 ];
 /** Keys a model-authored VALUE may never contain at any depth (money/secret-shaped), whatever the path. */

package/dist/packages/data/src/fixtures.js

@@ -62,21 +62,43 @@ export class FixtureStore {
     }
     save(path, note) {
         mkdirSync(dirname(path), { recursive: true });
-        const file = {
+        const raw = {
             version: 1,
             recordedAt: new Date().toISOString(),
             note: note ?? this.note,
             entries: this.list(),
         };
         if (this.streams.length)
-            file.streams = this.streams;
-        const text = JSON.stringify(file, null, 1) + '\n';
-        // Belt and braces: the key is redacted at capture time; refuse to write a file that still carries one.
-        if (containsSecret(text))
+            raw.streams = this.streams;
+        // Request URLs are redacted at capture time, but live response bodies echo third-party URLs with key-shaped
+        // params (DexScreener image URLs carry `&key=<cache id>`); refusing those threw away whole live sessions at
+        // quit (task-1443). Redact every string instead. Replay still matches: requestKey() redacts the same way.
+        const file = scrubSecrets(raw);
+        // Belt and braces: never write a file that still carries a key value (checked per string, so escaping is moot).
+        if (anyString(file, containsSecret))
             throw new Error('refusing to save a recording that contains an api-key value');
-        writeFileSync(path, text);
+        writeFileSync(path, JSON.stringify(file, null, 1) + '\n');
     }
 }
+/** A deep copy of `v` with redactSecrets() applied to every string. */
+function scrubSecrets(v) {
+    if (typeof v === 'string')
+        return redactSecrets(v);
+    if (Array.isArray(v))
+        return v.map(scrubSecrets);
+    if (v && typeof v === 'object')
+        return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, scrubSecrets(x)]));
+    return v;
+}
+function anyString(v, pred) {
+    if (typeof v === 'string')
+        return pred(v);
+    if (Array.isArray(v))
+        return v.some((x) => anyString(x, pred));
+    if (v && typeof v === 'object')
+        return Object.values(v).some((x) => anyString(x, pred));
+    return false;
+}
 export function toEntry(req, res, recordedAt = new Date().toISOString()) {
     let body = res.body;
     let bodyIsJson = false;

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

@@ -38,6 +38,9 @@ export * from "./trade/tx-decode.js";
 export * from "./trade/sol-usd.js";
 export * from "./trade/kill-switch.js";
 export * from "./trade/token-delta.js";
+// task-1443: the paper agent desk + its rendezvous (agents paper-trade inside an armed mandate; never sign/send).
+export * from "./trade/agent/paper-desk.js";
+export * from "./trade/agent/rendezvous.js";
 export * from "./trade/signer/protocol.js";
 export * from "./trade/signer/service.js";
 export * from "./trade/signer/host.js";
@@ -50,6 +53,8 @@ export * from "./larp/links.js";
 export * from "./larp/safe-fetch.js";
 export * from "./larp/evidence.js";
 export * from "./larp/link-baseline.js";
+export * from "./larp/x-account.js";
+export * from "./larp/score.js";
 // task-1401: parse a CA / coin link from any input (go-to, analyst chat, filter line, --mint, MCP refs).
 export * from "./coin-target.js";
 export * from "./analyst-actions.js";