dexterm-cli 0.1.4 → 0.1.6

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

@@ -1,4 +1,5 @@
-// dexterm — the price display mode (task-1366): show USD price or MARKET CAP on every screen and both charts.
+// dexterm — the price display mode (task-1366): show USD price or MARKET CAP on every screen; task-1472: the chart
+// Y axis (both charts) is its own setting, `display.chartAxis`, default MARKET CAP, toggled with `A`.
 //
 // A DISPLAY mode only. Market cap = price × supply, where the supply is what the data layer already reports
 // (the row's mcap / price at the latest tick: the "supply ratio"). Historical candles are scaled by the CURRENT
@@ -7,13 +8,15 @@
 // missing / zero), the screen falls back to price and SAYS so; it never invents a number.
 //
 // No network calls, nothing here is read by the signer, the caps, tickets, plans or the confirm gate.
-import { fmtMcap, fmtMcapBare, fmtPrice } from '../../tui/src/index.js';
-import { applyAndJournal, configPath, dextermHome, loadConfig, DEFAULT_PRICE_MODE, PRICE_MODES } from '../../custom/src/index.js';
-export { PRICE_MODES, DEFAULT_PRICE_MODE };
+import { fmtMcap, fmtCompact, fmtPrice } from '../../tui/src/index.js';
+import { applyAndJournal, configPath, dextermHome, loadConfig, DEFAULT_PRICE_MODE, PRICE_MODES, CHART_AXES, DEFAULT_CHART_AXIS } from '../../custom/src/index.js';
+export { PRICE_MODES, DEFAULT_PRICE_MODE, CHART_AXES, DEFAULT_CHART_AXIS };
 /** Axis / caption label for an mcap chart: the history is scaled by today's supply, and says so. */
 export const MCAP_AXIS_LABEL = 'mcap (current supply)';
 /** Shown wherever mcap mode is on but a token's supply is unknown, so the number on screen is a price. */
 export const MCAP_FALLBACK_NOTE = 'supply unknown · showing price';
+/** task-1472: the chart title when the Y axis wants market cap but the token's supply is unknown (it plots price). */
+export const MCAP_UNAVAILABLE_LABEL = 'price (mcap unavailable)';
 /** Short per-cell marker for a price shown in an MCAP column (fallback). */
 export const FALLBACK_MARK = 'ᵖ';
 export function isPriceMode(v) { return PRICE_MODES.includes(v); }
@@ -78,14 +81,24 @@ export function fallbackCount(rows, get) {
 export function fallbackCaption(n) {
     return n > 0 ? `${FALLBACK_MARK} ${n} price${n > 1 ? 's' : ''} (supply unknown)` : null;
 }
-/** The chart scale for a token: mcap mode with a known supply scales by the CURRENT supply ratio, else prices (+ a note). */
+/**
+ * The chart scale for a token: an mcap axis with a known supply scales by the CURRENT supply ratio (labels in the shared
+ * compact k/M/B formatter), else prices (+ `price (mcap unavailable)`). task-1472: the charts pass the chart axis
+ * (chartAxisOf, default mcap); the token header still passes the table price mode.
+ */
 export function chartMode(mode, price, mcap) {
     if (mode !== 'mcap')
         return { scale: null, axisFmt: undefined, kind: 'price', label: null };
     const ratio = supplyRatio(price, mcap);
     if (ratio === null)
-        return { scale: null, axisFmt: undefined, kind: 'price', label: MCAP_FALLBACK_NOTE };
-    return { scale: ratio, axisFmt: fmtMcapBare, kind: 'mcap', label: MCAP_AXIS_LABEL };
+        return { scale: null, axisFmt: undefined, kind: 'price', label: MCAP_UNAVAILABLE_LABEL };
+    return { scale: ratio, axisFmt: fmtCompact, kind: 'mcap', label: MCAP_AXIS_LABEL };
+}
+/** task-1472: the chart box title: `WIF · MCAP (current supply) · 1h`, `WIF/USD · 1h`, or `WIF/USD · price (mcap unavailable) · 1h`. */
+export function chartTitle(symbol, interval, cm, quote = 'USD') {
+    if (cm.kind === 'mcap')
+        return `${symbol} · MCAP ${MCAP_AXIS_LABEL.replace(/^mcap /, '')} · ${interval}`;
+    return cm.label ? `${symbol}/${quote} · ${cm.label} · ${interval}` : `${symbol}/${quote} · ${interval}`;
 }
 /**
  * One plan level with BOTH numbers, in the order the mode prefers: mcap mode `mc ≤ $300K ($0.0003)`, price mode
@@ -145,7 +158,7 @@ export function configPriceMode(cfg) {
 export function togglePriceMode(state) {
     const next = priceModeOf(state) === 'mcap' ? 'price' : 'mcap';
     state.priceMode = next;
-    const what = next === 'mcap' ? `showing MARKET CAP · charts: ${MCAP_AXIS_LABEL}` : 'showing USD PRICE';
+    const what = next === 'mcap' ? 'showing MARKET CAP' : 'showing USD PRICE'; // task-1472: the charts follow A, not $
     const ui = state.custom;
     if (!ui)
         return `${what} (not saved: no config on this run)`;
@@ -159,6 +172,37 @@ export function togglePriceMode(state) {
         return `${what} (not saved: ${e.message})`;
     }
 }
+export function isChartAxis(v) { return CHART_AXES.includes(v); }
+/** task-1472: the chart Y axis in effect: the state's (from config or `A`), default MARKET CAP. */
+export function chartAxisOf(state) {
+    return state?.chartAxis === 'price' ? 'price' : 'mcap';
+}
+/** task-1472: the chart axis a run starts with: config.display.chartAxis, else mcap (also for configs written before it). */
+export function configChartAxis(cfg) {
+    const a = cfg?.display?.chartAxis;
+    return isChartAxis(a) ? a : DEFAULT_CHART_AXIS;
+}
+/**
+ * task-1472: set the chart Y axis (both chart surfaces) and persist it to config.display.chartAxis through the journal
+ * (actor user, so `undo` works). `next` absent = flip. Returns the toast text; a save failure keeps it for this run.
+ */
+export function setChartAxis(state, next) {
+    const axis = next ?? (chartAxisOf(state) === 'mcap' ? 'price' : 'mcap');
+    state.chartAxis = axis;
+    const what = axis === 'mcap' ? 'chart Y axis: MARKET CAP' : 'chart Y axis: PRICE';
+    const ui = state.custom;
+    if (!ui)
+        return `${what} (not saved: no config on this run)`;
+    try {
+        const op = ui.config.display ? { op: 'add', path: '/display/chartAxis', value: axis } : { op: 'add', path: '/display', value: { chartAxis: axis } };
+        const { config } = applyAndJournal(ui.home, [op], { actor: 'user', why: `A chart axis ${axis}`, now: state.now.getTime() });
+        ui.config = config;
+        return `${what} · saved (A to switch)`;
+    }
+    catch (e) {
+        return `${what} (not saved: ${e.message})`;
+    }
+}
 export const DISPLAY_USAGE = 'usage: dexterm display [price|mcap]   show or set display.priceMode in ~/.dexterm/config.json ($ in the app toggles it)';
 /** `dexterm display [price|mcap]`: print the saved price display mode, or set it (journaled, actor user). No network. */
 export function displayCommand(argv, io) {
@@ -171,7 +215,9 @@ export function displayCommand(argv, io) {
             return 1;
         }
         const m = configPriceMode(loaded.config);
-        io.stdout.write(`display.priceMode = ${m}${m === 'mcap' ? ` (tables show MCAP; charts: ${MCAP_AXIS_LABEL}; tokens without a supply fall back to price)` : ' (USD price per token)'}\n`);
+        io.stdout.write(`display.priceMode = ${m}${m === 'mcap' ? ' (tables show MCAP; tokens without a supply fall back to price)' : ' (USD price per token)'}\n`);
+        const a = configChartAxis(loaded.config);
+        io.stdout.write(`display.chartAxis = ${a}${a === 'mcap' ? ` (charts: ${MCAP_AXIS_LABEL}; A switches)` : ' (charts plot USD price; A switches)'}\n`);
         return 0;
     }
     if (!isPriceMode(arg)) {

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

@@ -17,6 +17,7 @@ import { XTokenStore } from '../../data/src/index.js';
 import { SayTts, voiceDoctor, resolveVoice, WHISPER_MODEL, resolvePiperRuntime, pickPlayer, PIPER_MODEL } from '../../voice/src/index.js';
 import { loadConfig, dextermHome } from '../../custom/src/index.js';
 import { kbStore, skillStore } from "./kb-skill-cmd.js";
+import { analystCliOnPath, CODEX_MIN_VERSION, parseEngineChoice, resolveEngine, versionAtLeast } from "./analyst/codex.js";
 /** The minimum Node that runs dexterm (type-stripping of the .ts entry needs 22.18). */
 export const MIN_NODE = [22, 18, 0];
 /** Cheap PATH lookup (no spawn). Windows (task-1423): PATH is `;`-separated and commands carry an extension
@@ -141,6 +142,32 @@ export async function claudeProbe(timeoutMs = 4000, platform = process.platform,
         }
     });
 }
+/**
+ * Default codex probe (0.1.5): PATH (spawnable form only), then `codex --version` and `codex login status`. The
+ * status command is the user's own CLI reporting on its own login; dexterm never reads the credential itself.
+ */
+export async function codexProbe(timeoutMs = 4000, env = process.env) {
+    if (!analystCliOnPath('codex', env))
+        return { state: 'missing' };
+    const { execFile } = await import('node:child_process');
+    const run = (args) => new Promise((resolve) => {
+        try {
+            const child = execFile('codex', args, { timeout: timeoutMs, env }, (err, stdout, stderr) => {
+                const code = err ? (typeof err.code === 'number' ? err.code : null) : 0;
+                resolve({ code, out: `${stdout ?? ''}${stderr ?? ''}` });
+            });
+            child.on('error', () => resolve({ code: null, out: '' }));
+        }
+        catch {
+            resolve({ code: null, out: '' });
+        }
+    });
+    const v = await run(['--version']);
+    const version = /(\d+\.\d+\.\d+[\w.-]*)/.exec(v.out)?.[1] ?? null;
+    const st = await run(['login', 'status']);
+    const loggedIn = st.code === 0 ? !/not logged in/i.test(st.out) : st.code === null ? null : false;
+    return { state: 'present', version, loggedIn };
+}
 /** Default writable check: create the directory, write and remove a temp file. Returns an error message or null. */
 export function writableProbe(dir) {
     try {
@@ -162,6 +189,8 @@ export function defaultDeps(env = process.env, isTTY = process.stdout.isTTY ===
         nodeVersion: process.versions.node,
         platform: process.platform,
         claude: () => claudeProbe(),
+        codex: () => codexProbe(4000, env),
+        analystEngine: env.DEXTERM_ANALYST_ENGINE ?? loadConfig(dextermHome(env)).config.analyst?.engine ?? null,
         probe: (url) => livingProbe(url),
         checkWritable: writableProbe,
         offline: env.DEXTERM_OFFLINE === '1' || env.DEXTERM_OFFLINE === 'true',
@@ -230,11 +259,20 @@ export async function runDoctor(deps) {
     }
     // 3. Claude CLI (the analyst). Not required to browse; required for the `a` analyst.
     const claude = await deps.claude();
-    if (claude === 'missing') {
+    // 0.1.5: codex is the optional second engine; a missing claude is fine when codex can run the analyst.
+    const codex = deps.codex ? await deps.codex() : null;
+    const codexUsable = codex?.state === 'present';
+    if (claude === 'missing' && codexUsable) {
+        checks.push({
+            name: 'Claude CLI', status: 'pass',
+            detail: 'not found on PATH (optional now): the analyst runs on your codex CLI instead',
+        });
+    }
+    else if (claude === 'missing') {
         checks.push({
             name: 'Claude CLI', status: 'warn',
             detail: 'not found on PATH; the analyst (a) is disabled, the rest of dexterm works',
-            fix: 'Install Claude Code (https://claude.com/claude-code) and run `claude` once to log in.',
+            fix: 'Install Claude Code (https://claude.com/claude-code) and run `claude` once to log in, or use Codex: `npm i -g @openai/codex && codex login`.',
         });
     }
     else {
@@ -243,6 +281,24 @@ export async function runDoctor(deps) {
             detail: 'found on PATH (the analyst runs your local `claude`; log in once with `claude` if the analyst errors)',
         });
     }
+    // 3b. Codex CLI (0.1.5): optional second analyst engine, the user's own codex login. Read-only lock needs >= CODEX_MIN_VERSION.
+    if (codex) {
+        const choice = parseEngineChoice(deps.analystEngine) ?? 'auto';
+        const engine = resolveEngine(choice, (b) => b === 'claude' ? claude !== 'missing' : codexUsable);
+        const eng = `analyst engine: ${engine}${choice === 'auto' ? ' (auto)' : ''}`;
+        if (codex.state === 'missing') {
+            checks.push({ name: 'Codex CLI', status: engine === 'codex' ? 'warn' : 'pass', detail: `not installed (optional second analyst engine) · ${eng}`, ...(engine === 'codex' ? { fix: 'npm i -g @openai/codex && codex login, or set analyst.engine to claude' } : {}) });
+        }
+        else if (codex.version && !versionAtLeast(codex.version, CODEX_MIN_VERSION)) {
+            checks.push({ name: 'Codex CLI', status: 'warn', detail: `codex-cli ${codex.version} is older than ${CODEX_MIN_VERSION}; the read-only analyst lock needs ${CODEX_MIN_VERSION}+ · ${eng}`, fix: 'npm i -g @openai/codex@latest' });
+        }
+        else if (codex.loggedIn === false) {
+            checks.push({ name: 'Codex CLI', status: 'warn', detail: `found${codex.version ? ` (codex-cli ${codex.version})` : ''}, not logged in · ${eng}`, fix: 'codex login' });
+        }
+        else {
+            checks.push({ name: 'Codex CLI', status: 'pass', detail: `found${codex.version ? ` (codex-cli ${codex.version})` : ''}${codex.loggedIn ? ', logged in' : ''}; runs the analyst read-only on your own codex login (/engine codex) · ${eng}` });
+        }
+    }
     // 4b. Login with X (optional, task-1357): the user's own X app + login unlock X posts in the SOCIAL panel / TRENDING.
     {
         const xs = new XTokenStore({ env: deps.env });

package/dist/packages/cli/src/live/dev-history.js

@@ -0,0 +1,115 @@
+import { ageShort, creatorOf, devHistoryLine, queryDevHistory } from '../../../recorder/src/index.js';
+export const DEV_TTL_MS = 60_000;
+/** Short creator/funder address for the panel (never a full address in a 40-column cell). */
+export const shortAddr = (a) => (a ? `${a.slice(0, 4)}…${a.slice(-4)}` : '—');
+export class DevHistoryBook {
+    cache = new Map();
+    db;
+    now;
+    ttlMs;
+    constructor(db, now = () => Date.now(), ttlMs = DEV_TTL_MS) {
+        this.db = db;
+        this.now = now;
+        this.ttlMs = ttlMs;
+    }
+    /**
+     * The entry for `mint` (cached for `ttlMs`). `creatorHint` is the dev wallet a source named on screen (Jupiter
+     * `dev`) for a coin the recorder has not linked yet; `intel` is the coin's settled wallet-intel scan, if any, and
+     * `intelAt` when that scan settled (the linked row's age).
+     */
+    forMint(mint, creatorHint, intel, intelAt) {
+        const now = this.now();
+        const hit = this.cache.get(mint);
+        if (hit && now - hit.at < this.ttlMs && (hit.creator || !creatorHint) && (hit.linked || !intel))
+            return hit;
+        const db = this.db() ?? null;
+        let creator = db ? creatorOf(db, mint) : null;
+        if (!creator && creatorHint && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(creatorHint))
+            creator = { mint, creator: creatorHint, source: 'jupiter-tokens', firstT: now, createdAt: null };
+        let report = null;
+        let linked = null;
+        if (creator && db) {
+            try {
+                report = queryDevHistory(db, { creator: creator.creator, mint, asOf: now });
+            }
+            catch {
+                report = null;
+            }
+        }
+        if (creator && intel)
+            linked = linkedFrom(intel, creator.creator, db, intelAt ?? null);
+        const line = !db ? 'unknown: the history recorder is off (--no-recorder / DEXTERM_RECORDER=0)'
+            : !creator ? 'unknown: no source named the creator yet'
+                : report ? devHistoryLine(report) : 'unknown: dev history unreadable';
+        const e = { mint, creator, report, linked, line, at: now };
+        this.cache.set(mint, e);
+        if (this.cache.size > 2000)
+            this.cache.delete(this.cache.keys().next().value);
+        return e;
+    }
+    /** The `devrugs` rule field: labelled prior rugs by this coin's creator; null = unknown (clauses on it are false). */
+    rugsFor(mint) {
+        const e = this.forMint(mint);
+        return e.report && e.report.labelled.n > 0 ? e.report.labelled.rug : null;
+    }
+}
+/** Linked wallets from a settled wallet-intel scan: the creator's funder and any multi-wallet cluster it sits in. */
+export function linkedFrom(a, creator, db, at = null) {
+    const h = a.holders.find((x) => x.owner === creator);
+    const fundedBy = h?.funder?.address ?? a.funding[creator]?.funder ?? null;
+    const c = a.clusters.find((x) => x.members.includes(creator) && x.members.length > 1) ?? null;
+    let linkedCreators = 0, linkedRugs = 0, linkedNewestT = null;
+    if (c && db) {
+        try {
+            const others = c.members.filter((m) => m !== creator).slice(0, 50);
+            const launched = db.prepare('SELECT COUNT(*) AS n FROM creators WHERE creator = ?');
+            for (const w of others) {
+                if (Number(launched.get(w).n) <= 0)
+                    continue;
+                linkedCreators++;
+                const r = queryDevHistory(db, { creator: w, devExit: false });
+                linkedRugs += r.labelled.rug;
+                if (r.labelled.newestT !== null)
+                    linkedNewestT = Math.max(linkedNewestT ?? 0, r.labelled.newestT);
+            }
+        }
+        catch { /* an old DB without the table: nothing linked */ }
+    }
+    return { fundedBy, cluster: c ? { name: c.name, kind: c.kind, members: c.members.length, pct: c.pct } : null, linkedCreators, linkedRugs, linkedNewestT, source: h || c || a.funding[creator] ? 'wallet-intel scan' : null, at };
+}
+/** Short source tags for a panel cell: `rec` = dexterm's recorder, `scan` = the wallet-intel scan; creator links by feed. */
+const LINK_TAG = { 'jupiter-tokens': 'jup', pumpportal: 'pump', rugcheck: 'rc' };
+const linkTag = (src) => (src ? LINK_TAG[src] ?? src : '?');
+const ageAt = (t, now) => ageShort(t === null || t === undefined ? null : Math.max(0, Math.round((now - t) / 1000)));
+/**
+ * Rows for the token screen's DEV block: [label, value, level]. Every value names its source, sample and age (or
+ * says unknown): `rec` = dexterm's recorder, `scan` = the wallet-intel scan, `dev:jup` = which feed named the creator.
+ * Ages are measured from `now` (default: when the entry was read): the newest label / sighting / exit / scan behind it.
+ */
+export function devRows(e, now = e.at) {
+    const rows = [];
+    const r = e.report;
+    const rugLevel = () => !r || r.labelled.n === 0 ? 'na' : r.serialRugger ? 'bad' : r.labelled.rug > 0 || (r.badRate ?? 0) >= 0.5 ? 'warn' : 'ok';
+    rows.push(['Dev rugs', r && r.labelled.n ? `${r.labelled.rug}/${r.labelled.n} · n=${r.labelled.n} · rec ${ageAt(r.labelled.newestT, now)}` : 'unknown', rugLevel()]);
+    rows.push(['Dev launches', r && r.status === 'ok' ? `n=${r.launches.n} · rec ${ageAt(r.launches.newestT, now)} · dev:${linkTag(e.creator?.source)}` : 'unknown', 'na']);
+    if (r && r.devExit.n)
+        rows.push(['Dev sold bag', `med ${Math.round(r.devExit.medianMin)}m · n=${r.devExit.n} · rec ${ageAt(r.devExit.newestT, now)}`, r.devExit.medianMin <= 60 ? 'warn' : 'ok']);
+    const l = e.linked;
+    if (l && (l.fundedBy || l.cluster)) {
+        const scan = `scan ${ageAt(l.at, now)}`;
+        rows.push(['Dev linked', l.cluster ? `${l.cluster.kind} ${l.cluster.members}w · ${scan}` : `funded by ${shortAddr(l.fundedBy)} · ${scan}`, 'na']);
+        if (l.linkedCreators)
+            rows.push(['Linked dev rugs', `${l.linkedRugs} · n=${l.linkedCreators} devs · rec ${ageAt(l.linkedNewestT, now)}`, l.linkedRugs > 0 ? 'bad' : 'na']);
+    }
+    return rows;
+}
+/** The app's one book (created on first use), reading the live recorder's DB. Null when there is no recorder. */
+export function devBookOf(state) {
+    if (!state.live?.recorder)
+        return null;
+    if (!state.devBook) {
+        const live = state.live;
+        state.devBook = new DevHistoryBook(() => live?.recorder?.database ?? null);
+    }
+    return state.devBook;
+}

package/dist/packages/cli/src/live/index.js

@@ -332,13 +332,17 @@ export class LiveContext {
         }
         catch { /* keep the last value */ }
     }
-    /** The fast set = the open token first, then the watchlist (the fast lane caps and drops the rest). */
+    /** task-1473: a coin the followed agent holds (PAPER): kept in the fast set so its mark survives list changes. */
+    heldMint = null;
+    /** The fast set = the open token first, then a followed agent's held coin, then the watchlist (the fast lane caps and drops the rest). */
     syncFastSet() {
         if (!this.fastLane)
             return;
         const mints = [];
         if (this.token)
             mints.push(this.token.mint);
+        if (this.heldMint && !mints.includes(this.heldMint))
+            mints.push(this.heldMint);
         for (const e of this.watchStore.list())
             if (!mints.includes(e.mint))
                 mints.push(e.mint);

package/dist/packages/cli/src/live/newpairs.js

@@ -20,6 +20,8 @@ export class NewPairsLive {
     dl;
     now;
     onChange;
+    /** 0.1.5 dev history: called once per row when its creator becomes known (the recorder stores the link). */
+    onCreator;
     limit;
     polls;
     rows = new Map();
@@ -84,6 +86,12 @@ export class NewPairsLive {
         this.mode = 'replay';
         return this.client.replay(rec, speed);
     }
+    tellCreator(mint, creator, source, createdAt) {
+        try {
+            this.onCreator?.(mint, creator, source, createdAt);
+        }
+        catch { /* the recorder must never break the feed */ }
+    }
     addCreate(c) {
         const rowAt = this.now();
         const existing = this.rows.get(c.mint);
@@ -105,6 +113,8 @@ export class NewPairsLive {
         }
         else {
             this.rows.set(c.mint, row);
+            if (row.creator)
+                this.tellCreator(c.mint, row.creator, c.creator ? 'pumpportal' : 'rugcheck', row.createdAt);
             this.latencies.push(row.latencyMs);
             if (this.latencies.length > 500)
                 this.latencies.shift();
@@ -227,6 +237,8 @@ export class NewPairsLive {
                 const row = this.rows.get(t.mint);
                 if (!row)
                     continue;
+                if (!row.creator && t.creator)
+                    this.tellCreator(t.mint, t.creator, 'rugcheck', row.createdAt);
                 row.creator = row.creator ?? t.creator;
                 if (t.mintAuthority !== null)
                     row.mintAuth = t.mintAuthority;

package/dist/packages/cli/src/live/screens/newpairs-live.js

@@ -125,7 +125,7 @@ export function renderNewPairsLive(c, state, live) {
             } },
     ];
     if (rows.length)
-        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows, selected: sel, scroll: 0, bg: box.bg });
+        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: cols, rows, selected: sel, scroll: 0, bg: box.bg, rowKey: (r) => r.mint });
     else {
         const s = st.stream;
         const msg = st.mode === 'off' ? 'push feed off · r to poll jup recent' : s?.state === 'open' ? `connected to pumpportal · waiting for the first create (≈15/min measured)` : `pumpportal ${s?.state ?? 'connecting'}${s?.lastError ? ` · ${s.lastError}` : ''} · polling jup recent`;

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

@@ -14,10 +14,12 @@ import { renderScanWhy, renderScanTicker } from "../../scan/ui.js";
 import { drawCoin, imagesOn } from "../../screens/coin.js";
 import { COIN_HERO_W, COIN_HERO_H } from '../../../../tui/src/index.js';
 import { renderSocialPanel } from "../../screens/social-panel.js";
+import { brainFor, factsFromView, renderBrainPanel } from "../../screens/brain.js";
 import { launchIntelCells, holderTags } from "../intel.js";
+import { devBookOf, devRows } from "../dev-history.js";
 import { EX_POOL_TAGS } from '../../../../data/src/index.js';
 import { layoutFor } from "../../custom.js";
-import { chartMode, priceModeOf, mcapAt, positionPriceCells } from "../../display.js";
+import { chartMode, chartTitle, priceModeOf, chartAxisOf, mcapAt, positionPriceCells } from "../../display.js";
 const dash = '—';
 const EX_POOL_TAG_SET = EX_POOL_TAGS;
 /** task-1367 holder-class badge colours: venues/escrows accent, the creator/linked warn, the rest muted. */
@@ -86,13 +88,13 @@ export function renderTokenLive(c, state, v) {
     const shownPx = livePx ?? v.price;
     // task-1366: mcap mode leads with the market cap (the live price × the polled supply ratio) and keeps the price beside it;
     // without a supply it shows the price and says so.
-    const cm = chartMode(priceModeOf(state), v.price, v.mcap);
-    if (cm.kind === 'mcap' && shownPx !== null) {
-        x = c.text(x0, y, fmtMcap(mcapAt(shownPx, cm.scale)), { fg: t.text, bg: t.bg, b: true });
+    const pm = chartMode(priceModeOf(state), v.price, v.mcap);
+    if (pm.kind === 'mcap' && shownPx !== null) {
+        x = c.text(x0, y, fmtMcap(mcapAt(shownPx, pm.scale)), { fg: t.text, bg: t.bg, b: true });
         x = c.text(x + 1, y, `(${fmtPrice(shownPx)})`, { fg: t.dim, bg: t.bg });
     }
     else
-        x = c.text(x0, y, shownPx === null ? dash : fmtPrice(shownPx), { fg: cm.label && shownPx !== null ? t.warn : t.text, bg: t.bg, b: true });
+        x = c.text(x0, y, shownPx === null ? dash : fmtPrice(shownPx), { fg: pm.label && shownPx !== null ? t.warn : t.text, bg: t.bg, b: true });
     if (state.live?.fastLane)
         x = badge(c, x + 1, y, liveBadge, liveBadge === 'LIVE' ? t.up : t.muted, { on: t.bg });
     const deltas = [['5m', v.chg.m5], ['1h', v.chg.h1], ['6h', v.chg.h6], ['24h', v.chg.h24]];
@@ -130,7 +132,9 @@ export function renderTokenLive(c, state, v) {
     const chartH = Math.max(10, Math.floor((bottom - y - posH) * lay.chartFrac));
     const cp = v.panels.candles;
     const chartCap = clip(cp.state === 'ok' || cp.fetchedAt !== null ? `ohlcv: geckoterminal${cp.stale || cp.state === 'error' ? ' · stale' : ''}` : panelCaption(cp, now, 'ohlcv unavailable'), 40);
-    const cb = c.box(0, y, mainW, chartH, { title: cm.label ? (cm.kind === 'mcap' ? `${v.symbol} ${cm.label} · ${v.interval}` : `${v.symbol}/USD · ${cm.label} · ${v.interval}`) : `${v.symbol}/USD · ${v.interval}`, caption: chartCap, captionFg: cp.state === 'error' && cp.fetchedAt === null ? t.warn : undefined });
+    // task-1472: the chart's Y axis is its own setting (default MARKET CAP, `A` toggles); the header above keeps `$`.
+    const cm = chartMode(chartAxisOf(state), v.price, v.mcap);
+    const cb = c.box(0, y, mainW, chartH, { title: chartTitle(v.symbol, v.interval, cm), caption: chartCap, captionFg: cp.state === 'error' && cp.fetchedAt === null ? t.warn : undefined });
     // timeframe tabs sit on the top border, left of the caption (same spot as the fixture screen)
     let tx = cb.x + cb.w - 2 - (chartCap.length + 4) - INTERVALS.reduce((s, f) => s + f.length + 1, 0);
     for (const f of INTERVALS)
@@ -141,9 +145,12 @@ export function renderTokenLive(c, state, v) {
         c.textC(cb.x, cb.y + Math.floor(cb.h / 2), cb.w, cp.state === 'loading' ? 'loading candles…' : `no candles · ${cp.reason ?? 'source did not answer'}`, { fg: t.muted, bg: cb.bg, i: true });
     y += chartH;
     if (prow && src) {
-        positionPanel(c, 0, y, mainW, prow, held?.kind ?? src.kind, priceModeOf(state), cm.scale);
+        positionPanel(c, 0, y, mainW, prow, held?.kind ?? src.kind, priceModeOf(state), pm.scale);
         y += posH;
     }
+    // task-1473: what the ON-CHAIN band derived this frame, for the brain view's vetting list (null under SOCIAL)
+    let brainTop10 = null;
+    let brainDev = null;
     // ---- task-1330: the SOCIAL panel (`s`) replaces the ON-CHAIN / HOLDERS band; the chart + position stay.
     if (state.tokenSocial) {
         renderSocialPanel(c, 0, y, mainW, bottom - y, state, { mint: v.mint, symbol: v.symbol, now });
@@ -178,6 +185,14 @@ export function renderTokenLive(c, state, v) {
         const top10Rows = tags.top10
             ? [['Top 10 ex-pool', `${tags.top10.exPool.toFixed(1)}%`, t10lvl(tags.top10.exPool)], ['Top 10 raw', `${tags.top10.raw.toFixed(1)}%`, 'na']]
             : [['Top 10 holders', ...(v.top10 === null ? na(v.panels.holders.state === 'needs-key' ? 'needs key' : dash) : [`${v.top10.toFixed(1)}%${v.panels.holders.state === 'ok' ? '' : ' (jup)'}`, t10lvl(v.top10)])]];
+        // 0.1.5 dev history (task-1425): the creator's recorded track record from the local recorder (keyless). The rugs
+        // row sits with the other rug signals; launches / bag-exit / linked wallets follow the safety list.
+        const book = devBookOf(state);
+        const devAll = book ? devRows(book.forMint(v.mint, v.devAddress ?? null, state.live?.intel?.analysis(v.mint) ?? null, state.live?.intel?.entry(v.mint)?.at ?? null), now) : [];
+        const devHead = devAll.slice(0, 1);
+        const devTail = devAll.slice(1);
+        brainTop10 = tags.top10 ? tags.top10.exPool : v.top10;
+        brainDev = (devHead[0] ? [`${devHead[0][0]}: ${devHead[0][1]}`, devHead[0][2]] : v.devMints === null ? null : [`${v.devMints} mints by dev (jup)`, v.devMints > 3 ? 'warn' : 'ok']);
         const sniperRow = [cells.snipers.text, cells.snipers.level];
         const bundleRow = [cells.bundle.text, cells.bundle.level];
         const rows = [
@@ -189,10 +204,12 @@ export function renderTokenLive(c, state, v) {
             ['Mint authority', ...(v.mintAuth === null ? na(dash) : [v.mintAuth ? 'ENABLED' : 'revoked', v.mintAuth ? 'bad' : 'ok'])],
             ['Freeze authority', ...(v.freezeAuth === null ? na(dash) : [v.freezeAuth ? 'ENABLED' : 'revoked', v.freezeAuth ? 'bad' : 'ok'])],
             ['Dev history', ...(v.devMints === null ? needsHistory : [`${v.devMints} mints by dev (jup)`, v.devMints > 3 ? 'warn' : 'ok'])],
+            ...devHead,
             ['RugCheck score', ...(v.rug === null || v.rug.score === null ? na(v.panels.rugcheck.state === 'error' ? `unavailable: ${v.panels.rugcheck.reason ?? ''}`.trim() : dash) : [`${Math.round(v.rug.score)}/100`, v.rug.score < 30 ? 'ok' : v.rug.score < 60 ? 'warn' : 'bad'])],
             ['GoPlus', ...goplusRow(v)],
+            ...devTail,
         ];
-        for (const [label, val0, lvl] of rows) {
+        for (const [label, val0, lvl] of fitRows(rows, sb.y + sb.h - sy)) {
             if (sy >= sb.y + sb.h)
                 break;
             const color = lvl === 'ok' ? t.up : lvl === 'warn' ? t.warn : lvl === 'bad' ? t.down : t.dim;
@@ -318,8 +335,15 @@ export function renderTokenLive(c, state, v) {
             }
         }
     }
-    if (showAi)
-        analystPlaceholder(c, mainW, top, aiW, bottom - top, v, state);
+    if (showAi) {
+        // task-1473: in an auto mode (following an agent / AI scan) the panel is the BRAIN VIEW; otherwise the analyst
+        const facts = factsFromView(v, { top10: brainTop10, dev: brainDev, larpVerdict: state.larpByMint?.get(v.mint)?.verdict ?? null, price: shownPx });
+        const brain = brainFor(state, facts, isCalm(state.vfx), state.live?.scanMeterLabel?.() ?? '');
+        if (brain)
+            renderBrainPanel(c, mainW, top, aiW, bottom - top, brain.model, brain.opts);
+        else
+            analystPlaceholder(c, mainW, top, aiW, bottom - top, v, state);
+    }
     const watched = state.live?.watch?.has(v.mint) ? 'unwatch' : 'watch';
     // task-1311: `i` asks claude about this token (chat), `a` runs the paid dossier on demand, `y`
     // copies the full contract address.
@@ -393,6 +417,21 @@ function positionPanel(c, x, y, w, r, kind, mode = 'price', supply = null) {
 function clip(s, max) {
     return s.length > max ? s.slice(0, Math.max(1, max - 1)) + '…' : s;
 }
+/**
+ * task-1463: the ON-CHAIN rows for a panel `space` lines tall. When they all fit they are returned unchanged. When
+ * they do not, a short panel must not drop a red flag silently (e.g. `Dev rugs 2/3`, the last rows of the list):
+ * bad rows are kept first, then warn rows, then the rest in order, the kept rows stay in their order, and the last
+ * line says how many rows are hidden.
+ */
+export function fitRows(rows, space) {
+    if (rows.length <= space || space <= 0)
+        return rows;
+    const slots = space - 1;
+    const rank = (l) => (l === 'bad' ? 0 : l === 'warn' ? 1 : 2);
+    const keep = new Set(rows.map((r, i) => [rank(r[2]), i]).sort((a, b) => a[0] - b[0] || a[1] - b[1]).slice(0, slots).map(([, i]) => i));
+    const hidden = rows.length - keep.size;
+    return [...rows.filter((_, i) => keep.has(i)), [`+${hidden} rows hidden`, 'taller window', 'na']];
+}
 /** Token amounts up to trillions (fmtNum stops at B). */
 function fmtAmt(n) {
     if (n >= 1e12)
@@ -435,7 +474,8 @@ function analystPlaceholder(c, x, y, w, h, v, state) {
     // task-1311 (QA M5): the pre-run state. Opening a token no longer spends a paid dossier; this panel
     // waits until you ask for one with `a` (dossier) or type a question with `i`. No fake verdicts.
     const t = c.theme;
-    const box = c.box(x, y, w, h, { title: '✦ ANALYST · claude', titleFg: t.ai, caption: 'read-only · local claude · on demand', captionFg: t.dim, border: mix(t.border, t.ai, 0.35) });
+    const eng = state.analystEngine ?? 'claude'; // 0.1.5: the user's own CLI that will answer
+    const box = c.box(x, y, w, h, { title: `✦ ANALYST · ${eng}`, titleFg: t.ai, caption: `read-only · local ${eng} · on demand`, captionFg: t.dim, border: mix(t.border, t.ai, 0.35) });
     const bg = box.bg;
     const inner = box.w - 2;
     let cy = box.y;

package/dist/packages/cli/src/live/screens/watchlist-live.js

@@ -89,7 +89,7 @@ export function renderWatchlistLive(c, state, live) {
             } });
     }
     if (rows.length)
-        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: promoteMcap(cols, mode), rows, selected: sel, bg: box.bg });
+        table(c, box.x + 1, box.y, box.w - 2, box.h, { columns: promoteMcap(cols, mode), rows, selected: sel, bg: box.bg, rowKey: (r) => r.entry.mint });
     else
         c.textC(box.x, box.y + Math.min(3, Math.floor(box.h / 2)), box.w, 'watchlist is empty · press w on any token (screener, new pairs, token screen) to add it', { fg: t.muted, bg: box.bg, i: true });
     const y2 = top + listH;

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

@@ -266,6 +266,7 @@ export class TokenLive {
                 v.top10 = audit?.top10Pct ?? v.top10;
             v.dev = audit?.devPct ?? null;
             v.devMints = audit?.devMints ?? null;
+            v.devAddress = audit?.devAddress ?? v.devAddress ?? null;
             v.sources = [...new Set([...v.sources, ...r.sources])];
             const SHORT = { dexscreener: 'ds', 'jupiter-tokens': 'jup', 'jupiter-price': 'jup-price' };
             this.ok('market', r.sources.map((x) => SHORT[x] ?? x).join('+'), pair.fetchedAt, r.stale);

package/dist/packages/cli/src/live/trade.js

@@ -669,6 +669,8 @@ export function positionRow(h, tickUsd, solUsd) {
 }
 /** How long a `held()` lookup is reused before re-reading the ledger (the render loop calls it per frame). */
 export const HELD_MEMO_MS = 250;
+/** task-1473 r2: how long the open-mints list is reused (a ledger read; the chip samples it every tick). */
+export const OPEN_MINTS_MEMO_MS = 1000;
 /** Minimum spacing of the token screen's automatic mark pass for a held coin missing SOL/USD or a mark. */
 export const HELD_AUTOMARK_MS = 30_000;
 /** Live PAPER positions + PnL: marks held tokens from the keyless price feed. */
@@ -738,6 +740,22 @@ export class PositionsLive {
         }
         return v;
     }
+    /** task-1473 r2: mints of the open paper positions (the AI-scan PnL chip), memoised OPEN_MINTS_MEMO_MS. */
+    openMints() {
+        const now = this.now();
+        if (this.openMemo && now - this.openMemo.at >= 0 && now - this.openMemo.at < OPEN_MINTS_MEMO_MS)
+            return this.openMemo.v;
+        let v = [];
+        try {
+            v = this.wallet.positions().filter((p) => p.tokensRaw > 0n).map((p) => p.mint);
+        }
+        catch {
+            v = [];
+        }
+        this.openMemo = { at: now, v };
+        return v;
+    }
+    openMemo = null;
     /**
      * Mark held tokens in SOL. Prices come from DexScreener (its own fast 300 rpm bucket), not the
      * keyless `jupiter` bucket the screener feed and quotes share — so a mark never queues behind them.
@@ -917,6 +935,8 @@ export class LivePositions {
         this.memo.set(mint, { at: now, v });
         return v;
     }
+    /** task-1473 r2: mints of the open live positions (the AI-scan PnL chip). Memoised with positions(). */
+    openMints() { return this.positions().filter((p) => p.tokensRaw > 0n).map((p) => p.mint); }
     /** Forget memoised reads (after a fill). */
     invalidate() { this.memo.clear(); this.rowsMemo = null; }
 }
@@ -936,6 +956,8 @@ export class CombinedPositions {
         return p;
     }
     solUsd() { return this.paper.solUsd() ?? this.live?.solUsd() ?? null; }
+    /** task-1473 r2: every open mint, live first (the AI-scan PnL chip picks one). */
+    openMints() { return [...new Set([...(this.live?.openMints() ?? []), ...this.paper.openMints()])]; }
 }
 function msg(e) {
     return e instanceof Error ? e.message : String(e);