dexterm-cli 0.1.4 → 0.1.5

package/dist/packages/cli/src/app-help-gen.js

@@ -85,7 +85,7 @@ export function appTools() {
 const SCREENS = [
     { screen: 'screener', title: 'The screener screen', feature: 'screener', tools: ['screener_query'],
         blurb: 'The live table of Solana tokens (DexScreener + Jupiter, refreshed every ~10 s): price, 5m/1h/6h/24h change, volume, liquidity, market cap, age, holders, organic score, flags and a sparkline, with a p(rug) column. Cells whose source is down show a dash and the caption says why — never a fabricated number.' },
-    { screen: 'token', title: 'The token screen', feature: 'token-intel', tools: ['get_dossier', 'get_token', 'get_holders', 'get_trades', 'get_candles', 'get_dev_history', 'rugcheck'],
+    { screen: 'token', title: 'The token screen', feature: 'token-intel', tools: ['get_dossier', 'get_token', 'get_holders', 'get_trades', 'get_candles', 'get_dev_history', 'dev_history', 'rugcheck'],
         blurb: 'One coin in depth: market stats, a candle chart, the trades tape, mint/freeze authority, top holders with their class (pool/dev/linked/…), RugCheck + GoPlus, snipers/bundled from the wallet-intel scan, and the ANALYST panel. Open it with ⏎ on any live row or `--mint <CA|link>`.' },
     { screen: 'newpairs', title: 'The new pairs screen', feature: 'new-pairs', tools: ['screener_query'],
         blurb: 'A live feed of just-launched tokens (PumpPortal new-token + migration push, plus Jupiter/RugCheck/DexScreener polls). Bonding progress is a create-time estimate and says so; SNIPE/BUNDLE columns fill in from the wallet-intel scan of the row the cursor rests on (Helius-keyed).' },
@@ -93,8 +93,8 @@ const SCREENS = [
         blurb: 'The coins you watch, persisted in SQLite, priced live every ~10 s with a LIVE/POLL badge. Add with `w` on any coin; remove with `d`.' },
     { screen: 'analyst', title: 'The analyst screen', feature: 'analyst', tools: ['get_dossier', 'kb_search', 'app_help'],
         blurb: 'Your own `claude` CLI as the dexterm analyst: it reads the read-only dexterm MCP tools, grounds every fact in a tool result, and answers in a few terse lines. ⏎ on a coin runs a full dossier; `a` runs a rug-check. Facts never come from model memory; token text passes the prompt firewall.' },
-    { screen: 'positions', title: 'The paper positions screen', feature: 'positions', tools: [],
-        blurb: 'Your simulated (PAPER) positions and their P&L. dexterm holds no keys and signs nothing; paper trading is a simulation for learning the flow.' },
+    { screen: 'positions', title: 'The paper positions screen', feature: 'positions', tools: ['paper_positions', 'paper_pnl'],
+        blurb: 'Your simulated (PAPER) positions and their P&L. dexterm holds no keys and signs nothing; paper trading is a simulation for learning the flow. An agent you enabled can read these over MCP with the read-only paper_positions and paper_pnl tools.' },
     { screen: 'trending', title: 'The trending screen', feature: 'trending-board', tools: ['narrative_board'],
         blurb: 'What is trending in the space — narratives and movers aggregated from the feed.' },
     { screen: 'kol', title: 'The KOL lists screen', feature: 'kol-lists', tools: [],
@@ -179,10 +179,16 @@ const TOPICS = [
     { id: 'ask-the-analyst', title: 'Ask the analyst a question', screen: 'analyst', tags: ['analyst', 'ask', 'claude', 'ai', 'question', 'dossier', 'chat'],
         actions: [{ action: 'analyst.toggle' }, { action: 'open', screen: 'screener' }], tools: ['get_dossier', 'kb_search', 'app_help', 'case_lookup'], feature: 'analyst',
         flags: ['--no-ai'],
-        body: 'The analyst is your own `claude` login. ⏎ on a coin runs a full dossier; `a` runs a rug-check (or a trench-scan of the screener when nothing is selected). Type a follow-up and ⏎ to send. If `claude` is missing or logged out the panel shows the one-line fix and the rest of dexterm keeps working. Start without AI using `--no-ai`.' },
+        body: 'The analyst is your own `claude` login (or your own `codex` login: `/engine codex`, see "Run the analyst on Codex"). ⏎ on a coin runs a full dossier; `a` runs a rug-check (or a trench-scan of the screener when nothing is selected). Type a follow-up and ⏎ to send. If `claude` is missing or logged out the panel shows the one-line fix and the rest of dexterm keeps working. Start without AI using `--no-ai`.' },
     { id: 'connect-an-agent', title: 'Connect your own agent (MCP)', screen: 'all', tags: ['mcp', 'agent', 'agents', 'connect', 'claude', 'tool', 'server', 'bot'],
         commands: ['mcp'], tools: ['screen_state', 'get_dossier', 'kb_search', 'app_help', 'app_state'], feature: 'mcp',
-        body: '`dexterm mcp` is a plain stdio MCP server exposing the same read-only tools the analyst uses. Add it to any Claude Code with `claude mcp add dexterm -- node packages/mcp/bin/dexterm-mcp.mjs`. Agents are untrusted: every tool is read-only and an agent can never sign, arm, raise a cap or touch keys. Use `app_help` for "how do I" questions and `app_state` to see what the user sees.' },
+        body: '`dexterm mcp` is a plain stdio MCP server exposing the same read-only tools the analyst uses. Add it to any Claude Code with `claude mcp add dexterm -- node packages/mcp/bin/dexterm-mcp.mjs`, or set up Claude Code, Claude Desktop, Cursor or Codex in one command with `dexterm mcp install <client>`. Agents are untrusted: every tool is read-only and an agent can never sign, arm, raise a cap or touch keys. Use `app_help` for "how do I" questions and `app_state` to see what the user sees.' },
+    { id: 'use-codex-analyst', title: 'Run the analyst on Codex instead of Claude', screen: 'all', tags: ['codex', 'openai', 'chatgpt', 'engine', 'analyst', 'claude', 'switch', 'backend'],
+        flags: ['--analyst-engine'], feature: 'analyst',
+        body: 'The analyst can run on your own Codex CLI login instead of Claude (0.1.5). Pick it with `--analyst-engine codex`, `DEXTERM_ANALYST_ENGINE=codex`, `"analyst": {"engine": "codex"}` in `~/.dexterm/config.json`, or type `/engine codex` in the chat box (new conversations; `/engine` alone shows the engine and what is installed). The default `auto` uses claude when it is installed, else codex. dexterm stores no credentials: your `codex login` does the work. The Codex run is locked read-only: only the read-only dexterm tools (plus the UI actions the session allows, none in scan mode), no shell, no file edits, no web search, no other MCP server; a turn that tries anything else is stopped. `dexterm doctor` shows a Codex CLI line (installed, version, logged in). Codex is also supported as an MCP client: `dexterm mcp install codex`.' },
+    { id: 'dev-history', title: 'Check if a coin\'s creator rugged before (dev history)', screen: 'token', tags: ['dev', 'deployer', 'creator', 'serial', 'rugger', 'rugged', 'history', 'launches'],
+        tools: ['dev_history', 'get_dev_history'], feature: 'token-intel',
+        body: 'The token screen\'s ON-CHAIN panel shows the creator\'s recorded track record (0.1.5): `Dev rugs (recorded)` (rugs out of labelled prior launches, with the sample n), `Dev launches seen`, `Dev sold its bag` (median minutes to the dev\'s exit) and `Dev linked` (funder or cluster from the wallet-intel scan). It comes from dexterm\'s own local history recorder (keyless creator links + code-only outcome labels), so it says `unknown` when there is no record; it is a risk flag from observed history, never a certificate. Alert on it with the rule field `devrugs`, e.g. `when devrugs >= 2 then alert(warn, "new coin from a wallet that rugged before") scope newpairs`. Agents and the analyst use the `dev_history` MCP tool.' },
     { id: 'configure-rpc-key', title: 'Configure a Helius / RPC key for holders', screen: 'all', tags: ['helius', 'rpc', 'key', 'holders', 'free', 'api', 'ranked'],
         feature: 'keyless',
         body: 'dexterm is free-forever and keyless by default. The one real keyless gap is the ranked top-holder list: add a free RPC key for it. Save a Helius key ONLY at `~/.dexterm/helius.key` (mode 600, never a repo or command line), or set `DEXTERM_RPC_URL` to any read-only RPC. `dexterm doctor` prints the exact command. Without a key the holders panel shows count + top-10% via Jupiter.' },
@@ -194,7 +200,10 @@ const TOPICS = [
         body: '`config.keymap` in `~/.dexterm/config.json` re-binds actions to keys; `dexterm keymap [screen]` shows the effective bindings including your overrides. Reserved keys (ctrl+c, esc, enter, y, !) and the confirm/dismiss/panic/quit actions cannot be rebound, and collisions refuse the whole keymap.' },
     { id: 'paper-trade', title: 'Paper trade a coin', screen: 'token', tags: ['paper', 'trade', 'buy', 'sell', 'ticket', 'simulate', 'practice'],
         actions: [{ action: 'trade.buy', screen: 'token' }, { action: 'trade.sell', screen: 'token' }], feature: 'paper-ticket',
-        body: 'Press `B` / `S` on the token screen to open a PAPER buy/sell ticket in its editing phase. dexterm holds no keys and signs nothing — paper trading is a simulation. Confirming a ticket needs your explicit keypress (the gate); a stray key never confirms. The analyst can open a PAPER ticket but can never size, confirm or send it.' },
+        body: 'Press `B` / `S` on the token screen to open a PAPER buy/sell ticket in its editing phase. dexterm holds no keys and signs nothing — paper trading is a simulation. Confirming a ticket needs your explicit keypress (the gate); a stray key never confirms. The in-app analyst can open a PAPER ticket but can never size, confirm or send it. If you separately arm a mandate and enable agent paper trading, a connected agent can open, size, confirm and close PAPER trades inside your caps (never raising them, never signing) — see "Let an agent paper trade".' },
+    { id: 'agent-paper-trade', title: 'Let an agent paper trade', screen: 'all', tags: ['agent', 'mcp', 'paper', 'autonomous', 'experimental', 'confirm', 'close', 'simulated'],
+        flags: ['--agent-paper'], tools: ['paper_open_ticket', 'paper_size_ticket', 'paper_confirm', 'paper_close', 'paper_positions', 'paper_pnl'], feature: 'mcp',
+        body: 'Experimental, paper only, off by default. Arm a mandate yourself (its caps, by keypress), then start `dexterm --spectate-mcp --agent-paper <mandate-id>`: an agent connected through `dexterm mcp` can then open, size, confirm and close SIMULATED (paper) trades inside those caps with paper_open_ticket / paper_size_ticket / paper_confirm / paper_close, and read paper_positions / paper_pnl. The agent is untrusted: it can never sign, send a real transaction, touch keys, or raise a cap; its per-trade cap is a quarter of the mandate\'s, and a size over any cap is refused. Caps are re-read from your armed mandate on every call, so revoking it or the panic key stops the agent. Every call is journaled and shows in this terminal\'s agent activity; Ctrl+P pauses, Ctrl+K stops for the rest of the run, any key takes over, and quitting turns it off. Figures are simulated and are not a result.' },
     { id: 'run-doctor', title: 'Diagnose problems with doctor', screen: 'all', tags: ['doctor', 'diagnose', 'check', 'troubleshoot', 'broken', 'fix', 'problem'],
         commands: ['doctor'], feature: 'doctor',
         body: '`dexterm doctor` is the first stop for any problem: non-interactive, never touches your keys, exits 0 when dexterm will run and 1 when something must be fixed. Every non-pass line prints the exact fix. `dexterm doctor --offline` skips the network probes.' },

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,99 @@
+import { 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.
+     */
+    forMint(mint, creatorHint, intel) {
+        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);
+        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) {
+    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;
+    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++;
+                linkedRugs += queryDevHistory(db, { creator: w, devExit: false }).labelled.rug;
+            }
+        }
+        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, source: h || c || a.funding[creator] ? 'wallet-intel scan' : null };
+}
+/** Rows for the token screen's DEV block: [label, value, level]. Every value names its source/sample/age or says unknown. */
+export function devRows(e) {
+    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 (recorded)', r && r.labelled.n ? `${r.labelled.rug}/${r.labelled.n} · n=${r.labelled.n}` : 'unknown', rugLevel()]);
+    rows.push(['Dev launches seen', r && r.status === 'ok' ? `${r.launches.n} prior · ${e.creator?.source === 'jupiter-tokens' ? 'jup' : e.creator?.source ?? ''}` : 'unknown', 'na']);
+    if (r && r.devExit.n)
+        rows.push(['Dev sold its bag', `median ${Math.round(r.devExit.medianMin)}m · n=${r.devExit.n}`, r.devExit.medianMin <= 60 ? 'warn' : 'ok']);
+    const l = e.linked;
+    if (l && (l.fundedBy || l.cluster))
+        rows.push(['Dev linked', l.cluster ? `${l.cluster.kind} ${l.cluster.members}w${l.linkedCreators ? ` · ${l.linkedCreators} devs ${l.linkedRugs} rugs` : ''}` : `funded by ${shortAddr(l.fundedBy)}`, 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/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/token-live.js

@@ -15,6 +15,7 @@ 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 { 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";
@@ -178,6 +179,12 @@ 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)) : [];
+        const devHead = devAll.slice(0, 1);
+        const devTail = devAll.slice(1);
         const sniperRow = [cells.snipers.text, cells.snipers.level];
         const bundleRow = [cells.bundle.text, cells.bundle.level];
         const rows = [
@@ -189,8 +196,10 @@ 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) {
             if (sy >= sb.y + sb.h)
@@ -435,7 +444,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/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/main.js

@@ -29,7 +29,9 @@ import { makeFixtureState, makeFeedState, syncFeed, renderFrame, isScreenKey, ac
 import { mulberry32, tick, spawnPair, shock } from "./fixtures.js";
 import { createLiveFeed, createReplayFeed } from "./feed.js";
 import { LiveContext, INTERVALS, WATCH_REFRESH_MS, POSITIONS_REFRESH_MS, popupBubbleVM } from "./live/index.js";
+import { FOLLOW_NAV_ACTIONS } from '../../mcp/src/index.js';
 import { McpFollowSession } from "./mcp-follow.js";
+import { AgentPaperSwitch } from "./agent-paper.js";
 import { TOKEN_REFRESH_MS, CandlePrefetcher } from "./live/token.js";
 import { PRESETS, presetSpec } from "./screener/presets.js";
 import { parseSortArg, SORT_KEYS } from "./screener/sort.js";
@@ -46,6 +48,7 @@ import { copyAlertToDelivery } from "./alerts/format.js";
 import { readTelegramCreds, readDiscordCreds } from "./alerts/creds.js";
 import { launchIntelCells, launchRetryable } from "./live/intel.js";
 import { AnalystSession } from "./analyst/session.js";
+import { analystCliOnPath, parseEngineChoice, resolveEngine } from "./analyst/codex.js";
 import { resolveAnalystResults } from "./analyst/results.js";
 import { parseScanCommand, SCAN_FLAGS, checkScanFlag, SCAN_HELP } from "./scan/command.js";
 import { parseWalletCommand, WALLET_HELP } from "./wallet-command.js";
@@ -101,6 +104,21 @@ export function appStateBlock(state) {
         alerts, // booleans only — never a token, webhook or key
     };
 }
+/**
+ * task-1443: the reduced screen snapshot a terminal following an EXTERNAL agent (`--spectate-mcp`) publishes for
+ * that agent's `dexterm mcp` server: what is on screen plus a VIEW-ONLY nav allow-list. Never the watchlist,
+ * tickets, positions or app settings, and only the four follow nav action types (no watchlist add, no ticket).
+ */
+export function followSnapshot(state) {
+    const ss = buildScreenState(state);
+    const a = ss.actions;
+    return {
+        screen: ss.screen, selected: ss.selected, selectedDetail: ss.selectedDetail, filter: ss.filter, sort: ss.sort,
+        visible: ss.visible, visibleMints: ss.visibleMints,
+        actions: { enabled: a.enabled, mints: a.mints, feeds: a.feeds, sortKeys: a.sortKeys, screens: a.screens, workspaces: [], themes: [], types: [...FOLLOW_NAV_ACTIONS] },
+        now: ss.now,
+    };
+}
 export function buildScreenState(state) {
     const live = state.live;
     const sc = state.screener;
@@ -288,6 +306,9 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   --record FILE             save every live response (and the PumpPortal session) to FILE (replay it with --replay)
   --spectate-mcp            follow an MCP agent's allowed navigation in this terminal; Ctrl+P pauses, Ctrl+K stops,
                             and any normal user keypress takes control (refused actions never move the UI)
+  --agent-paper MANDATE_ID  (experimental, with --spectate-mcp) let that MCP agent PAPER-trade inside a mandate you
+                            armed: simulated fills only, never signs or sends, never raises a cap; Ctrl+P / Ctrl+K /
+                            any key also pause, stop or take over its paper trading
   --max-requests N          hard cap on live requests for this run (default: none)
   --max-credits N           hard cap on Helius credits for this run (default: 5000)
   --mint MINT|LINK          token to open on the token screen (a CA or a dexscreener / pump.fun / solscan / birdeye link)
@@ -302,6 +323,8 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   --selected N              highlighted row / token index
   --seed N                  fixture PRNG seed (default 7)
   --no-ai                   hide the analyst panel on the token screen
+  --analyst-engine E        auto | claude | codex: which of YOUR installed CLIs runs the analyst (default auto = claude
+                            if installed, else codex; DEXTERM_ANALYST_ENGINE or config analyst.engine too; /engine in chat)
 
   --intensity LEVEL         off | normal | fever (default fever: rain, trails, glitch, blink, scanlines at 30 fps;
                             normal: 15 fps, sparser rain, no idle aberration; off = calm: neon theme, no motion)
@@ -389,14 +412,14 @@ export function parseArgs(argv) {
         screen: null, fixtures: false, replay: null, record: null, filter: null, sort: null, preset: null, maxRequests: 0, maxCredits: 0, db: null,
         mint: null, interval: '1h', listen: 20, verbose: false,
         width: null, height: null, html: null, export: null, theme: DEFAULT_THEME, selected: 0, seed: 7,
-        noAi: false, title: null, plain: false, ansi: false, color: null, tz: null,
+        noAi: false, analystEngine: null, title: null, plain: false, ansi: false, color: null, tz: null,
         calm: false, intensity: null, fps: null, frame: 0, t: 1, event: null, ai: null, mood: null, activity: null, noBoot: false, fit: null, fontPx: null, asciiRain: false, noImages: false,
         scan: false, scanConfig: {},
         noRecorder: false,
         sound: false,
         trade: [], live: true,
         workspace: null, priceMode: null,
-        spectateMcp: false,
+        spectateMcp: false, agentPaper: null,
         help: false, version: false, unknown: [],
     };
     for (let i = 0; i < argv.length; i++) {
@@ -485,6 +508,13 @@ export function parseArgs(argv) {
         }
         else if (k === '--no-ai')
             a.noAi = true;
+        else if (k === '--analyst-engine') {
+            const s = str();
+            const e = parseEngineChoice(s);
+            if (!e)
+                throw new Error(`unknown analyst engine ${s} (expected auto|claude|codex)`);
+            a.analystEngine = e;
+        }
         else if (k === '--calm')
             a.calm = true;
         else if (k === '--intensity') {
@@ -581,6 +611,13 @@ export function parseArgs(argv) {
         // task-1421: follow an agent driving over MCP (the running terminal moves with it; a read-only stream opens).
         else if (k === '--spectate-mcp')
             a.spectateMcp = true;
+        // task-1443: agent PAPER trading inside a mandate the user armed (validated against the plans journal at start).
+        else if (k === '--agent-paper') {
+            const s = str();
+            if (!/^[A-Za-z0-9_-]{1,64}$/.test(s))
+                throw new Error(`--agent-paper expects a mandate id (see \`dexterm mandate list\`), got ${JSON.stringify(s.slice(0, 20))}`);
+            a.agentPaper = s;
+        }
         else if (k === '--workspace') {
             const s = str();
             if (!/^[a-z][a-z0-9-]{0,39}(\/[a-z][a-z0-9-]{0,39})?$/.test(s))
@@ -618,6 +655,10 @@ export function parseArgs(argv) {
         throw new Error('--scan needs live data or a recording (drop --fixtures)');
     if (a.scan && a.screen)
         throw new Error('--scan is interactive (drop --screen)');
+    if (a.agentPaper && !a.spectateMcp)
+        throw new Error('--agent-paper needs --spectate-mcp (every agent paper trade must be visible in this terminal)');
+    if (a.agentPaper && a.db === ':memory:')
+        throw new Error('--agent-paper needs an on-disk --db (the agent books into the same paper wallet)');
     return a;
 }
 /**
@@ -1019,6 +1060,8 @@ export async function main(argv, io = process, proc = process) {
                     });
                     recorder.attach(feed.dl.store);
                     ctx.recorder = recorder;
+                    // 0.1.5 dev history: PumpPortal / RugCheck creators of new pairs go into the creator index too.
+                    ctx.newpairs.onCreator = (mint, creator, source, createdAt) => { recorder.recordCreator(mint, creator, source, undefined, createdAt); };
                 }
                 if (args.verbose)
                     io.stderr.write(`dexterm: rpc ${rpc.provider} (${rpc.basis}) · db ${dbPath} · recorder ${ctx.recorder ? 'on' : 'off'} · live trading ${args.live && !io.env.DEXTERM_OFFLINE ? 'available' : 'off'}\n`);
@@ -2639,6 +2682,50 @@ export function applyScanAnalystAction(state, raw) {
     const res = validateAnalystAction(raw, { ...allow, types: SCAN_ACTION_TYPES });
     return { ok: false, error: res.ok ? 'AI scan mode is observe-only' : res.error };
 }
+/**
+ * The analyst engine for a run (0.1.5): `--analyst-engine`, then DEXTERM_ANALYST_ENGINE, then config
+ * `analyst.engine`, then auto (claude when installed, else codex). Only the user picks it; models cannot.
+ */
+export function analystEngineFor(flag, env, configured, has = (b) => analystCliOnPath(b, env)) {
+    const choice = parseEngineChoice(flag) ?? parseEngineChoice(env.DEXTERM_ANALYST_ENGINE) ?? parseEngineChoice(configured) ?? 'auto';
+    return resolveEngine(choice, has);
+}
+/** `/engine [auto|claude|codex]` in the chat box (0.1.5). Null when the input is not this command. */
+export function parseEngineCommand(q) {
+    const m = /^\/engine(?:\s+(\S+))?\s*$/i.exec(q.trim());
+    if (!m)
+        return null;
+    if (!m[1])
+        return { show: true };
+    const c = parseEngineChoice(m[1]);
+    return c ? { choice: c } : { error: `unknown analyst engine "${m[1].slice(0, 16)}" (use /engine auto|claude|codex)` };
+}
+/**
+ * Apply `/engine`: switch the CLI for NEW conversations this run (cached per-coin chats are dropped so the next
+ * `a` starts on the chosen engine; a running turn finishes where it started). Returns the line to show.
+ */
+export function engineCommand(state, cmd, env, has = (b) => analystCliOnPath(b, env)) {
+    const installed = ['claude', 'codex'].filter((b) => has(b));
+    const list = installed.length ? installed.join(' + ') : 'neither claude nor codex';
+    if ('error' in cmd)
+        return cmd.error;
+    const cur = state.analystEngine ?? 'claude';
+    if ('show' in cmd)
+        return `analyst engine: ${cur} · installed: ${list} · /engine claude|codex|auto switches (config analyst.engine keeps it)`;
+    const next = resolveEngine(cmd.choice, has);
+    if (cmd.choice !== 'auto' && !has(next))
+        return `${next} is not installed (installed: ${list}); ${next === 'codex' ? 'npm i -g @openai/codex && codex login' : 'install Claude Code, then run claude once to log in'}`;
+    if (next !== cur) {
+        for (const [k, sess] of state.analystByMint ?? []) {
+            if (!sess.busy)
+                state.analystByMint.delete(k);
+        }
+        if (state.analyst && !state.analyst.busy && state.analyst.engine !== next)
+            state.analyst = null;
+    }
+    state.analystEngine = next;
+    return `analyst engine: ${next} (your own ${next} CLI and login) for new conversations · set analyst.engine in config.json to keep it`;
+}
 /**
  * The ONE way a scan-driven analyst conversation is built (task-1324; the loop and the safety tests both
  * use it): the locked coin as the selected coin, `actionTypes: []` (observe-only at the validator, the
@@ -2652,7 +2739,7 @@ export function createScanSession(state, mint, symbol, hooks = {}, deps = {}) {
         const type = typeof raw.type === 'string' ? raw.type.replace(/[^a-z_]/gi, '').slice(0, 24) : '?';
         hooks.onBlocked?.(type, r.error ?? 'refused');
     };
-    return new AnalystSession({ skill: 'token-dossier', mint, symbol, screenState: ss, onAction, actionTypes: SCAN_ACTION_TYPES, scan: true }, hooks.onChange ?? (() => { }), deps);
+    return new AnalystSession({ skill: 'token-dossier', mint, symbol, screenState: ss, onAction, actionTypes: SCAN_ACTION_TYPES, scan: true, ...(state.analystEngine === 'codex' ? { engine: 'codex' } : {}) }, hooks.onChange ?? (() => { }), deps);
 }
 /**
  * Resolve a mint to an openable seed from what the app already knows (screener view → new pairs →
@@ -3476,7 +3563,14 @@ export function terminalGuard(io, onFatal = () => { }, proc = process, hooks = {
         proc.exit(1);
     };
     const onExit = () => restore();
-    const onSignal = (sig) => { restore(); proc.exit(sig === 'SIGTERM' ? 143 : 129); };
+    const onSignal = (sig) => {
+        restore();
+        try {
+            hooks.onSignal?.();
+        }
+        catch { /* cleanup is best-effort; the exit still happens */ }
+        proc.exit(sig === 'SIGTERM' ? 143 : 129);
+    };
     const onTerm = () => onSignal('SIGTERM');
     const onHup = () => onSignal('SIGHUP');
     let installed = false;
@@ -3513,6 +3607,8 @@ export function fpsFor(args, intensity) {
 const SYNC_ON = '\x1b[?2026h';
 const SYNC_OFF = '\x1b[?2026l';
 export function interactive(state, io, depth, args, proc = process) {
+    // 0.1.5: the analyst engine for new conversations (the user's own claude or codex CLI; never a shipped key).
+    state.analystEngine ??= analystEngineFor(args.analystEngine, io.env, state.custom?.config.analyst?.engine);
     const out = io.stdout;
     const inp = io.stdin;
     const rnd = mulberry32(99);
@@ -3816,6 +3912,8 @@ export function interactive(state, io, depth, args, proc = process) {
         // task-1421: the MCP follow session (set below when `--spectate-mcp` is on). Declared here so the quit /
         // terminal-guard teardown closures can stop it.
         let followSession = null;
+        // task-1443: `--agent-paper <mandate-id>` (with --spectate-mcp) lets that agent PAPER-trade inside the mandate.
+        const agentPaper = args.spectateMcp && args.agentPaper ? new AgentPaperSwitch({ env: io.env, mandateId: args.agentPaper, db: args.db ?? defaultDbPath(io.env) }) : null;
         // Idle economy (task-1303, retuned for task-1319 AC3): between events the ambient rain redraws at
         // IDLE_FPS instead of the full frame cap, cutting idle CPU. A keypress opens a KEY_WAKE_S full-rate
         // window (`wakeUntil`) so input and transitions stay smooth; data landings paint at once on their own
@@ -3844,10 +3942,13 @@ export function interactive(state, io, depth, args, proc = process) {
                     say(`trade moment failed: ${describeError(e)}`, 'warn');
                 }
             };
-        const guard = terminalGuard(io, () => { done = true; prefetcher?.close(); if (timer)
-            clearInterval(timer); void followSession?.stop(); state.analyst?.cancel(); if (state.analystByMint)
+        const teardown = () => { done = true; prefetcher?.close(); if (timer)
+            clearInterval(timer); void followSession?.stop(); agentPaper?.stop(); state.analyst?.cancel(); if (state.analystByMint)
             for (const s of state.analystByMint.values())
-                s.cancel(); state.popups?.shutdown(); voice?.disable(); images?.close(); live?.close(); feed?.close(); }, proc, { beforeLeave: () => layer?.teardown() ?? '' });
+                s.cancel(); state.popups?.shutdown(); voice?.disable(); images?.close(); live?.close(); feed?.close(); };
+        // task-1443: SIGTERM/SIGHUP (a closed terminal window) runs the same teardown as a fatal error, so the agent-paper
+        // rendezvous, the spectator rendezvous and the --record file never outlive the terminal that owns them.
+        const guard = terminalGuard(io, teardown, proc, { beforeLeave: () => layer?.teardown() ?? '', onSignal: teardown });
         let lastTokenRefresh = 0;
         let lastWatchRefresh = 0;
         let lastPositionsRefresh = 0;
@@ -4043,9 +4144,13 @@ export function interactive(state, io, depth, args, proc = process) {
                 },
                 onStatus: (line) => { say(line, 'ai', 4); scheduleDraw(); },
                 onEvent: () => scheduleDraw(),
+                onControl: agentPaper ? (st) => agentPaper.control(st) : undefined,
+                snapshot: () => followSnapshot(state),
             });
             void followSession.start();
             say('following agents over MCP · ctrl+p pause · ctrl+k stop · any key takes over', 'ai', 6);
+            if (agentPaper)
+                say(agentPaper.start(), 'ai', 8);
         }
         // Launch a real Claude analyst session when a key asked for one (applyAction cannot spawn). A
         // `question` means start it as a chat turn, not a paid structured skill run (task-1311, QA B3).
@@ -4113,7 +4218,7 @@ export function interactive(state, io, depth, args, proc = process) {
                     maybeSpeakVoiceAnswer(session); // task-1282: speak a voice-initiated answer when it settles
                     scheduleDraw();
                 };
-                const session = new AnalystSession({ skill: p.skill, mint: p.mint, symbol: p.symbol, screenState: buildScreenState(state), model: p.model, onAction }, onChange);
+                const session = new AnalystSession({ skill: p.skill, mint: p.mint, symbol: p.symbol, screenState: buildScreenState(state), model: p.model, onAction, ...(state.analystEngine === 'codex' ? { engine: 'codex' } : {}) }, onChange);
                 if (p.question)
                     session.ask(p.question, buildScreenState(state));
                 else
@@ -5037,6 +5142,7 @@ export function interactive(state, io, depth, args, proc = process) {
             if (timer)
                 clearInterval(timer);
             void followSession?.stop();
+            agentPaper?.stop();
             guard.restore();
             guard.uninstall();
             cancelAllAnalysts();
@@ -5635,6 +5741,14 @@ export function interactive(state, io, depth, args, proc = process) {
                             draw();
                             continue;
                         }
+                        // 0.1.5: `/engine [auto|claude|codex]` switches the analyst CLI for new conversations; never sent to a model.
+                        const en0 = q.startsWith('/') ? parseEngineCommand(q) : null;
+                        if (en0) {
+                            state.aiInput = '';
+                            say(engineCommand(state, en0, io.env), typeof en0 === 'object' && 'error' in en0 ? 'warn' : 'info', 6);
+                            draw();
+                            continue;
+                        }
                         // task-1324: `/scan …` in the chat input is a command, never sent to claude.
                         const sc0 = q.startsWith('/') ? parseScanCommand(q) : null;
                         if (sc0) {