dexterm-cli 0.1.1 → 0.1.2

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

@@ -17,6 +17,9 @@
 import { writeFileSync, existsSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { writeExport, exportViewFor } from "./export.js";
+import { parseMintTarget, parseCoinTarget, resolveCoinTarget, isBareOpen } from "./coin-target.js";
 import { THEMES, isThemeName, DEFAULT_THEME, THEME_NAMES, Flusher, ENTER_SCREEN, LEAVE_SCREEN, DEFAULT_KEYMAP, Keymap, nextTheme, parseKeys, keyId, detectColorDepth, parseColorDepth, blinkFrame, blinkFrames, stepVfx, pulse, isCalm, fxBusy, blendActivity, ImageLayer, queryTerminal, resolveProtocol, fireMoment, fireInflight, clearInflight, skipMoment, momentKindFor, playMoment, soundOn, breakpoint, fmtUsd as fmtUsdTui, } from '../../tui/src/index.js';
 import { resolveRpcUrl, redactSecrets, defaultDbPath, extraRpcUrls, wsUrlFor, SOLANA_PUBLIC_RPC_WS, parseHttpUrl, validateAnalystAction, ACTION_RATE, ImageService, encodePng, SummaryLimiter, buildSummaryWindow, KolStore, Cache, PackError, normalizeHandle, terminalSafe } from '../../data/src/index.js';
 import { Recorder, recorderEnabled, MaintenanceSchedule } from '../../recorder/src/index.js';
@@ -35,6 +38,7 @@ import { TokenPopups, tokenDetailVMFromView } from "./popup.js";
 import { widgetPage, widgetEnabled, syncWidgetPopups } from "./widgets.js";
 import { recordLarpVerdict } from "./larp-record.js";
 import { rulesUiOf, rulesTick, rulesMove, beginRuleInput, saveRuleInput, dryRunNow, removeSelectedRule, toggleSelectedRule, dismissSelectedProposal, actOnSelectedProposal, RULE_INPUT_MAX } from "./rules.js";
+import { buildNotifier, hasPushChannel } from "./alerts/notifier.js";
 import { launchIntelCells, launchRetryable } from "./live/intel.js";
 import { AnalystSession } from "./analyst/session.js";
 import { resolveAnalystResults } from "./analyst/results.js";
@@ -46,13 +50,14 @@ import { buildObservations, observeSig } from "./scan/observe.js";
 import { cleanText } from "./screener/rows.js";
 import { resolveImagesConfig } from "./images-config.js";
 import { popupImagePath } from "./screens/coin.js";
-import { VoiceController, selectStt, selectTts } from '../../voice/src/index.js';
+import { VoiceController, selectStt, selectTts, SayTts, voiceStyleDefaults } from '../../voice/src/index.js';
 import { LivePlanExecutor, defaultPlansJournalPath } from '../../data/src/trade/plans/index.js';
 import { isWalletAddress, shortAddr, buildMirror, leaderSoldSince, autoSizeCap } from '../../data/src/trade/copy/index.js';
 import { FOLLOW_INPUT_MAX } from "./screens/follows.js";
 import { isPriceMode, configPriceMode, togglePriceMode, priceModeOf, planLevels } from "./display.js";
+import { VERSION } from "./version.js";
 import { initCustom, planWorkspace, planPopupOpens, findWorkspace, nextWorkspaceName, workspaceSlots, saveWorkspace, themeFor, themeByName, cycleTheme, themeNames, CHORD_TTL_MS, MAX_WORKSPACE_NAME } from "./custom.js";
-import { DEFAULT_WORKSPACE, MORNING_HUD } from '../../custom/src/index.js';
+import { DEFAULT_WORKSPACE, MORNING_HUD, applyAndJournal } from '../../custom/src/index.js';
 /**
  * Context the `screen_state` MCP tool returns AND the per-turn context block is rendered from
  * (task-1313): what the user is looking at right now — selected/hovered coin, screen, the visible
@@ -205,10 +210,13 @@ export function shouldDrawFrame(g) {
         return true;
     return g.frame % g.idleEvery === 0;
 }
-export const HELP = `dexterm 0.1.1 (live: screener, token, new pairs, watchlist · analyst = your local claude CLI · cyberspace look)
+export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watchlist · analyst = your local claude CLI · cyberspace look)
 
   dexterm                                     interactive, live data (needs a TTY)
   dexterm doctor                              check this machine is ready (Node, colour, claude, network, Helius key)
+  dexterm voice [status|download <model>]     voice engines on this machine; download whisper/piper models (asks first, checksum-verified)
+  dexterm update [--off|--on]                 check npm + GitHub for a newer version and print the upgrade command;
+                                              --off/--on toggles the once-a-day startup notice (no telemetry)
   dexterm recorder stats|label|prune|export   the history recorder's tables (no network; 'dexterm recorder help')
   dexterm kb list|show|new|edit|check|reset|path     your knowledge-base entries (~/.dexterm/kb/entries) over the bundled 17
   dexterm skill list|show|new|edit|check|reset|path  your analyst skills (~/.dexterm/skills) over the bundled ones (read tools only)
@@ -218,6 +226,9 @@ export const HELP = `dexterm 0.1.1 (live: screener, token, new pairs, watchlist
   dexterm plan propose|list|arm|cancel|journal     conditional order plans (entry/ladder/take-profit/moon bag/stop); arming needs a physical keypress
   dexterm mandate draft|list|arm|revoke            standing capped mandates (fast wallet); arming needs a physical keypress — voice/agents can never arm
   dexterm follow add|remove|list|stats|trades|purge  copy trading tier 1: follow a wallet (your list, local labels), its decoded swaps + FIFO PnL; alerts in the app
+  dexterm mcp [install <client>|doctor]            read-only MCP server for your own agent; 'install' writes the config for claude-code|claude-desktop|cursor|codex|openclaw|generic (asks first, idempotent, backs up); 'doctor' verifies the connection
+  dexterm alerts status|enable|disable|set-telegram|set-discord|test  where rule alerts are delivered (desktop / your Telegram / Discord; creds stay local, never logged)
+  dexterm watch [--interval S] [--once] [--replay FILE]  run your rules headless and push alerts when the terminal is closed (no signer, proposals only)
   dexterm --fixtures                          interactive demo on seeded fixtures
   dexterm --screen <name>                     one-shot frame to stdout (live)
   dexterm --screen <name> --fixtures          one-shot frame from fixtures
@@ -232,7 +243,7 @@ export const HELP = `dexterm 0.1.1 (live: screener, token, new pairs, watchlist
   --record FILE             save every live response (and the PumpPortal session) to FILE (replay it with --replay)
   --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               token to open on the token screen
+  --mint MINT|LINK          token to open on the token screen (a CA or a dexscreener / pump.fun / solscan / birdeye link)
   --interval IV             candle interval for the token screen: ${INTERVALS.join(' | ')} (default 1h)
   --listen SECONDS          one-shot new pairs: how long to listen to PumpPortal (default 20)
   --db PATH                 SQLite path for cache, watchlist, credit meter and history (default: ~/.local/share/dexterm/dexterm.db; ':memory:' for none)
@@ -296,6 +307,7 @@ ${X_HELP}
   --plain                   monochrome text (snapshot surface)
   --ansi                    ANSI output even when stdout is not a TTY (24-bit unless --color / NO_COLOR)
   --html FILE               write a standalone HTML page (for screenshots); --fit WxH --font PX for video frames
+  --export [DIR]            write the frame as a PNG + a text report with data ages (default ~/.dexterm/exports; local only)
   --color DEPTH             truecolor | 256 | none (default: detected; NO_COLOR honoured)
   --tz ZONE                 header clock zone (default America/New_York, the prototype's; 'local' = machine zone)
   --title TEXT              HTML page title
@@ -321,12 +333,14 @@ ${X_HELP}
   priced from live Jupiter quotes. LIVE (L on a ticket, /wallet link first): a separate signer process
   quotes, builds, decodes, simulates and enforces the caps; Phantom signs in your browser; dexterm never
   holds a key. The analyst, voice and scan mode can never open, confirm or sign a live trade.
-  RPC: DEXTERM_RPC_URL, else ~/.dexterm/helius.key (Helius, metered with a credit meter), else the public RPC.`;
+  RPC: DEXTERM_RPC_URL, else ~/.dexterm/helius.key (Helius, metered with a credit meter), else the public RPC.
+  Updates: at most once a day a live run asks npm + GitHub for the newest version (two anonymous GETs, no telemetry)
+  and shows one toast if there is one; DEXTERM_NO_UPDATE_CHECK=1 or 'dexterm update --off' turns that off.`;
 export function parseArgs(argv) {
     const a = {
         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, theme: DEFAULT_THEME, selected: 0, seed: 7,
+        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,
         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: {},
@@ -375,10 +389,13 @@ export function parseArgs(argv) {
         else if (k === '--max-credits')
             a.maxCredits = num();
         else if (k === '--mint') {
+            // task-1401: a bare mint, or a dexscreener / pump.fun / solscan / birdeye link (a dexscreener pool is resolved to its coin at open)
             const m = str();
-            if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(m))
-                throw new Error(`--mint expects a base58 Solana address, got ${JSON.stringify(m.slice(0, 20))}`);
-            a.mint = m;
+            const t = parseCoinTarget(m);
+            if (!t || (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(m.trim()) && t.via === 'address'))
+                throw new Error(`--mint expects a base58 Solana address or a coin link, got ${JSON.stringify(m.slice(0, 20))}`);
+            a.mint = t.address;
+            a.mintVia = t.via;
         }
         else if (k === '--interval') {
             const iv = str();
@@ -398,6 +415,8 @@ export function parseArgs(argv) {
             a.height = num();
         else if (k === '--html')
             a.html = str();
+        else if (k === '--export')
+            a.export = argv[i + 1] && !argv[i + 1].startsWith('--') ? str() : '';
         else if (k === '--theme')
             a.theme = str();
         else if (k === '--selected')
@@ -694,11 +713,11 @@ export function fastLaneEndpoints(rpc) {
     return out;
 }
 export async function main(argv, io = process, proc = process) {
-    // `dexterm mcp` → the standalone read-only MCP server on stdio (SPEC §5.1; `claude mcp add dexterm -- dexterm mcp`).
+    // `dexterm mcp` → the read-only MCP server on stdio (SPEC §5.1; `claude mcp add dexterm -- dexterm mcp`),
+    // plus `dexterm mcp install <client>` (one-command setup) and `dexterm mcp doctor` (verify the connection).
     if (argv[0] === 'mcp') {
-        const { runStdioServer } = await import('../../mcp/src/index.js');
-        await runStdioServer({ argv: argv.slice(1) });
-        return 0;
+        const { runMcp } = await import("./mcp-cmd.js");
+        return runMcp(argv.slice(1), io);
     }
     // `dexterm agent <cmd>` → bring-your-own-agent registry + loopback bus (task-1345): add/list/rotate/
     // remove/tier/pause/resume/kick/audit/packs, `serve` (a standalone bus on fixtures) and `connect`.
@@ -761,6 +780,18 @@ export async function main(argv, io = process, proc = process) {
         const { rulesCommand } = await import("./rules-cmd.js");
         return rulesCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
     }
+    // `dexterm alerts status|enable|disable|levels|proposals|set-telegram|set-discord|test` → where rule alerts
+    // are delivered (task-1398). Credentials live in ~/.dexterm/*.json (0600), never config.json/argv/logs.
+    if (argv[0] === 'alerts') {
+        const { alertsCommand } = await import("./alerts-cmd.js");
+        return alertsCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env, stdin: io.stdin });
+    }
+    // `dexterm watch [--interval S] [--once|--ticks N] [--replay FILE]` → run the rules engine headless and
+    // PUSH alerts to the enabled channels so they reach you when the terminal is closed (task-1398). No signer.
+    if (argv[0] === 'watch') {
+        const { watchCommand } = await import("./watch-cmd.js");
+        return watchCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
+    }
     // `dexterm pack list|verify|add|remove|export|lock|sign|trust|signers|keymap|widget` → shareable packs (task-1358 Tier 4):
     // plain files + sha256 lock + optional ssh signature. No network, no model; a pack never runs code (widgets land
     // disabled, unsigned rules load disabled, a keymap merges only on the explicit command).
@@ -789,6 +820,18 @@ export async function main(argv, io = process, proc = process) {
         const { runFollow } = await import("./follow-cmd.js");
         return runFollow(argv.slice(1), io);
     }
+    // `dexterm update [--off|--on]` → is there a newer version, and the exact upgrade command for this install (task-1397).
+    // Two anonymous GETs (npm registry, GitHub releases); never upgrades anything itself.
+    if (argv[0] === 'update') {
+        const { updateCommand } = await import("./update.js");
+        return updateCommand(argv.slice(1), io);
+    }
+    // `dexterm voice [status|download <model>]` → inspect the voice engines and download the optional
+    // voice models (whisper base.en, Piper voice). Downloads ask first and are checksum-verified (task-1408).
+    if (argv[0] === 'voice') {
+        const { voiceCommand } = await import("./voice-cmd.js");
+        return voiceCommand(argv.slice(1), { stdin: io.stdin, stdout: io.stdout, stderr: io.stderr, env: io.env });
+    }
     // `dexterm doctor` → a pre-flight that says whether dexterm will run here and how to fix what won't (task-1305).
     if (argv[0] === 'doctor') {
         const { defaultDeps, runDoctor, renderDoctor } = await import("./doctor.js");
@@ -838,7 +881,7 @@ export async function main(argv, io = process, proc = process) {
         return 0;
     }
     if (args.version) {
-        io.stdout.write('0.1.1\n');
+        io.stdout.write(`${VERSION}\n`);
         return 0;
     }
     if (args.unknown.length) {
@@ -932,6 +975,8 @@ export async function main(argv, io = process, proc = process) {
                 feed.extraMints = () => [...liveCtx.newpairs.rows.keys()];
             applyScreenerArgs(state, args);
             if (args.mint) {
+                if (args.mintVia === 'dexscreener')
+                    args.mint = (await resolveCoinTarget({ address: args.mint, via: 'dexscreener', rest: '' }, ctx.dl)).mint;
                 ctx.openToken({ mint: args.mint, symbol: args.mint.slice(0, 4) + '…', name: '', launchpad: 'unknown' });
                 if (args.screen === null)
                     state.screen = 'token';
@@ -1063,7 +1108,13 @@ export async function main(argv, io = process, proc = process) {
         }
         const c = renderFrame(state, w, h);
         ctx?.newpairs.markDrawn();
-        if (args.html) {
+        if (args.export !== null) {
+            // task-1401: `--export [DIR]` writes the same PNG + text report the `E` key does (default ~/.dexterm/exports).
+            const now = Date.now();
+            const r = writeExport(exportViewFor(state, w, h, now), { now, env: io.env, dir: args.export || undefined });
+            io.stderr.write(`wrote ${r.png} (${r.bytes} bytes) and ${r.txt}\n`);
+        }
+        else if (args.html) {
             // task-1326: `--html … --color 256` renders through the xterm palette (a Terminal.app-faithful proof)
             writeFileSync(args.html, c.toHtml({ title: args.title || `dexterm — ${args.screen} — ${state.theme.name}`, fit: args.fit, fontPx: args.fontPx ?? 15, depth: args.color ?? 'truecolor' }));
             io.stderr.write(`wrote ${args.html} (${w}×${h})\n`);
@@ -1087,7 +1138,20 @@ export async function main(argv, io = process, proc = process) {
         feed?.close();
         return 0;
     }
-    return interactive(state, io, depth, args, proc);
+    // task-1397: live interactive runs only: the cached "new version" notice (no network) plus, at most once a day,
+    // a background refresh that never blocks the start. Off with DEXTERM_NO_UPDATE_CHECK=1 / `dexterm update --off`.
+    const update = live ? (await import("./update.js")).startupCheck(io.env) : null;
+    if (update) {
+        state.updateNotice = update.notice;
+        void update.refresh?.then((n) => { if (n)
+            state.updateNotice = n; });
+    }
+    try {
+        return await interactive(state, io, depth, args, proc);
+    }
+    finally {
+        update?.cancel();
+    }
 }
 const SCREEN_ORDER = ['screener', 'newpairs', 'watchlist', 'analyst'];
 /** Rows PgUp/PgDn jump through the list (task-1303). */
@@ -2269,6 +2333,10 @@ export function applyAction(state, action, stack) {
         case 'goto.open':
             state.goto = { input: '', notice: null };
             break;
+        // task-1401 EXPORT: the loop renders the current view calm and writes the PNG + report (local files only).
+        case 'export.view':
+            state.pendingExport = true;
+            break;
         case 'display.priceMode':
             state.pendingToast = togglePriceMode(state);
             break; // task-1366: display only, persisted
@@ -2518,31 +2586,81 @@ function seedForMint(state, live, mint, symbol) {
 // task-1388 GO-TO prompt: the longest input we keep (a bare base58 mint is ≤ 44; the longest coin URL we
 // accept is well under this), so a huge paste can never balloon the buffer.
 const GOTO_INPUT_MAX = 120;
-/** A full base58 Solana mint: 32–44 chars, no 0/O/I/l. Same shape `--mint` validates (main.ts parseArgs). */
-const GOTO_MINT_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+// task-1388's parser now lives in coin-target.ts (shared with the analyst chat, the filter line and --mint).
+export { parseMintTarget };
 /**
- * task-1388: turn a pasted/typed go-to target into a mint, or null when there is none. Accepts a bare base58
- * mint, or a dexscreener / pump.fun / solscan URL (or any text) by pulling the first base58 run of mint length.
- * Base58 excludes 0, O, I and l, so splitting on every non-base58 character also splits on them and on the URL
- * punctuation (/, :, ., ?, =, &), leaving each path/query segment as its own token; a real mint is never cut.
- * Pure and total: it only ever returns a validated mint string or null, and never throws. Exported for tests.
+ * task-1401: open a pasted coin target (a CA, or a dexscreener / pump.fun / solscan / birdeye link) on the LIVE token
+ * screen — the same read-only path `--screen token --mint` and the analyst's open_token use. A mint opens at once; a
+ * dexscreener link is first resolved to its coin (its address is usually the pool) and opens when that answers.
+ * `onOpened` runs after the open either way (the chat uses it to ask its question about the coin). Returns a notice
+ * when it cannot open (fixtures mode), else null. Never trades, never signs.
  */
-export function parseMintTarget(raw) {
-    const s = raw.trim();
-    if (!s)
+export function openCoinTarget(state, stack, t, onOpened) {
+    const live = state.live && state.screener.source !== 'fixtures' ? state.live : null;
+    if (!live)
+        return 'opening a coin by address needs live mode (not --fixtures)';
+    const open = (mint) => {
+        if (!(state.screen === 'token' && live.token?.view.mint === mint))
+            live.openToken(seedForMint(state, live, mint)); // already open: keep its loaded view
+        if (state.screen !== 'token') {
+            stack.push(state.screen);
+            state.screen = 'token';
+        }
+        onOpened?.(mint);
+    };
+    if (t.via !== 'dexscreener') {
+        open(t.address);
         return null;
-    if (GOTO_MINT_RE.test(s))
-        return s;
-    for (const tok of s.split(/[^1-9A-HJ-NP-Za-km-z]+/))
-        if (GOTO_MINT_RE.test(tok))
-            return tok;
+    }
+    live.notice = 'resolving the dexscreener link…';
+    void resolveCoinTarget(t, live.dl).then(({ mint, fromPair }) => {
+        if (live.isClosed)
+            return;
+        live.notice = fromPair ? `dexscreener pool → coin ${mint.slice(0, 4)}…${mint.slice(-4)}` : null;
+        open(mint);
+        state.aiFocused = false;
+        syncAnalyst(state);
+        live.onChange('goto');
+    });
     return null;
 }
+/**
+ * task-1401: the analyst chat's ⏎. When the typed text names a coin (a CA or a coin link), open that coin's token
+ * view and, if a question came with it ("is <CA> a rug?"), ask it about THAT coin; returns true when it handled
+ * the input. Plain questions return false and go to the analyst as before.
+ */
+export function chatOpenCoin(state, stack, q, hooks) {
+    const ct = q ? parseCoinTarget(q) : null;
+    if (!ct)
+        return false;
+    state.aiInput = '';
+    const question = isBareOpen(ct.rest) ? '' : ct.rest;
+    const notice = openCoinTarget(state, stack, ct, (mint) => {
+        syncAnalyst(state);
+        if (question) {
+            state.aiOpen = true;
+            try {
+                hooks.ask(question);
+            }
+            catch (e) {
+                state.screener.notice = `⚠ ask failed: ${describeError(e)}`;
+            }
+        }
+        else {
+            state.aiFocused = false;
+            hooks.say(`opened ${mint.slice(0, 4)}…${mint.slice(-4)} from the chat`, 'info', 4);
+        }
+    });
+    if (notice)
+        hooks.say(notice, 'warn', 5);
+    return true;
+}
 /**
  * task-1388: resolve the GO-TO prompt's input to a coin and open its live token screen (read-only — the same
  * path `--screen token --mint` and the analyst's open_token use: live.openToken(seedForMint(...)), which seeds
  * an unknown-launchpad stub when the mint is not already on a screen). Bad input keeps the prompt open with a
  * one-line notice and changes nothing; a good open closes the prompt and pushes the current screen on the stack.
+ * task-1401: a dexscreener link is resolved pool → coin first (openCoinTarget).
  */
 function openGotoTarget(state, stack) {
     const g = state.goto;
@@ -2558,17 +2676,13 @@ function openGotoTarget(state, stack) {
         g.notice = 'not a contract address or a dexscreener / pump.fun / solscan link';
         return;
     }
-    const live = state.live && state.screener.source !== 'fixtures' ? state.live : null;
-    if (!live) {
-        g.notice = 'opening a coin by address needs live mode (not --fixtures)';
+    const t = parseCoinTarget(raw) ?? { address: mint, via: 'address', rest: '' };
+    const notice = openCoinTarget(state, stack, t);
+    if (notice) {
+        g.notice = notice;
         return;
     }
-    live.openToken(seedForMint(state, live, mint));
     state.goto = null;
-    if (state.screen !== 'token') {
-        stack.push(state.screen);
-        state.screen = 'token';
-    }
 }
 /**
  * Apply one analyst-requested UI action to the state (task-1313). This is the trust boundary: every
@@ -2918,6 +3032,18 @@ export function applyKey(state, key, stack) {
                 state.pendingToast = typeof cmd === 'object' ? cmd.error : scanCommand(state, cmd, stack);
                 return;
             }
+            // task-1401: a pasted CA or coin link on the `/` line opens that coin (no filter field is a 32-44 char base58
+            // run); the editor closes and the previous filter stays applied.
+            const ct = parseCoinTarget(sc.edit.text);
+            if (ct && isBareOpen(ct.rest)) {
+                sc.mode = 'table';
+                sc.edit.text = sc.query ?? '';
+                sc.edit.error = null;
+                const notice = openCoinTarget(state, stack, ct);
+                if (notice)
+                    state.pendingToast = notice;
+                return;
+            }
             // task-1328: `/wallet …` is a command too (the loop performs it: link opens a browser, probe opens a ticket).
             const wc = parseWalletCommand(sc.edit.text);
             if (wc) {
@@ -4099,6 +4225,24 @@ export function interactive(state, io, depth, args, proc = process) {
                 say(`skipped ${plan.skipped.map((s) => `${s.kind} (${s.why})`).join(', ')}`, 'info', 5);
             scheduleDraw();
         };
+        // task-1398: PUSH delivery while the TUI is open. Built only when the user enabled a push channel
+        // (desktop/telegram/discord); otherwise null and there is no behaviour change. The in-app toast is
+        // still state.pendingToast, so the Notifier's toast sink is a no-op here (routing may still include it,
+        // harmlessly). Delivery is fire-and-forget: a slow channel never blocks the frame.
+        const alertNotifier = state.custom && hasPushChannel(state.custom.config.alerts)
+            ? buildNotifier(state.custom.home, state.custom.config.alerts, { toastSink: () => { } })
+            : null;
+        const drainDeliveries = () => {
+            const ui = state.rulesUi;
+            if (!ui || !ui.pendingDeliveries.length)
+                return;
+            const ds = ui.pendingDeliveries;
+            ui.pendingDeliveries = [];
+            if (!alertNotifier)
+                return;
+            for (const d of ds)
+                void alertNotifier.deliver(d).catch(() => { });
+        };
         // task-1358 Tier 3: perform what the rules engine / an accepted proposal queued. A ticket proposal opens the
         // PAPER ticket in its editing phase (the user sizes + confirms there; signer caps apply) — never a live ticket,
         // never a confirm. An ask proposal is a question to the analyst. Popups are the same read-only windows the keys
@@ -4456,26 +4600,49 @@ export function interactive(state, io, depth, args, proc = process) {
             else
                 voice.abortTurn(session.status === 'error' ? "Sorry — the analyst hit an error. Try again." : "Okay, stopped.");
         };
+        // task-1393: persist the `,` voice choice to config.voice.name (actor 'user', journaled → undo works).
+        // Best-effort: a persistence failure keeps the voice for this run and never breaks the UI.
+        const persistVoiceChoice = (voiceName) => {
+            const ui = state.custom;
+            if (!ui)
+                return;
+            try {
+                const op = ui.config.voice
+                    ? { op: 'add', path: '/voice/name', value: voiceName }
+                    : { op: 'add', path: '/voice', value: { name: voiceName } };
+                const { config } = applyAndJournal(ui.home, [op], { actor: 'user', why: `, voice ${voiceName}`, now: state.now.getTime() });
+                ui.config = config;
+            }
+            catch { /* keep the voice for this run; nothing to surface */ }
+        };
         const initVoice = async () => {
             if (voiceInitStarted)
                 return;
             voiceInitStarted = true;
             state.voice = { enabled: true, mode: 'idle', muted: false, voice: null, transcript: null, say: null, message: 'preparing voice…' };
             scheduleDraw();
+            // task-1393: the user's saved voice/rate (if any). A missing/banned name is resolved to a safe
+            // deep British male by selectTts — it never falls back to the machine's system voice.
+            const cfgVoice = state.custom?.config.voice;
             let stt = null, tts = null;
             try {
-                [stt, tts] = await Promise.all([selectStt(), selectTts()]);
+                [stt, tts] = await Promise.all([selectStt(), selectTts(undefined, cfgVoice?.name ?? null)]);
             }
             catch { /* both null → degrade to text */ }
             if (done)
                 return;
+            // Seed the controller with the ENGINE's resolved voice so its cycle/status start on the British male,
+            // not on voices[0] (which could be a novelty voice like "Albert").
+            const resolvedVoice = tts instanceof SayTts ? tts.voiceName : undefined;
+            const style = voiceStyleDefaults(resolvedVoice); // the picked voice's own rate/pitch, unless the user saved theirs
             voice = new VoiceController({
-                stt, tts, getScreenState: voiceScreenState,
+                stt, tts, voice: resolvedVoice, rate: cfgVoice?.rate ?? style?.rate, pitch: cfgVoice?.pitch ?? style?.pitch, getScreenState: voiceScreenState,
                 onState: () => { if (!done && voice) {
                     state.voice = toHud();
                     scheduleDraw();
                 } },
                 onDecision: handleVoiceDecision,
+                onVoiceChange: persistVoiceChoice,
             });
             voice.enable();
             await voice.toggleTalk(); // the first `v` press both enables and starts listening
@@ -5016,6 +5183,21 @@ export function interactive(state, io, depth, args, proc = process) {
                             draw();
                             continue;
                         }
+                        // task-1401: a CA or a dexscreener / pump.fun / solscan / birdeye link in the chat opens that coin's token
+                        // view (read-only, the go-to path); any question typed with it is then asked about THAT coin.
+                        const before = state.screen;
+                        if (chatOpenCoin(state, stack, q, { ask: sendChat, say })) {
+                            if (state.screen !== before) {
+                                try {
+                                    startTransition();
+                                }
+                                catch {
+                                    transition = null;
+                                }
+                            }
+                            draw();
+                            continue;
+                        }
                         if (q) {
                             state.aiInput = '';
                             try {
@@ -5254,6 +5436,19 @@ export function interactive(state, io, depth, args, proc = process) {
                 copyToClipboard(m);
                 say(`copied CA  ${m.slice(0, 4)}…${m.slice(-4)}`, 'info');
             }
+            if (state.pendingExport) {
+                // task-1401: one key → PNG + text report of the current view in ~/.dexterm/exports. Nothing is uploaded.
+                state.pendingExport = false;
+                try {
+                    const [ew, eh] = size();
+                    const now = Date.now();
+                    const r = writeExport(exportViewFor(state, ew, eh, now), { now, env: io.env });
+                    say(`exported PNG + report → ${r.png.replace(homedir(), '~')} · local only, nothing uploaded`, 'info', 8);
+                }
+                catch (e) {
+                    say(`export failed: ${describeError(e)}`, 'warn', 6);
+                }
+            }
             if (state.pendingToast) {
                 // task-1315: surface the link list / "no link" reply as a durable toast. Drained BEFORE
                 // pendingOpen so that on a successful open the "opened <url>" toast overwrites the "open <url>" one.
@@ -5317,6 +5512,11 @@ export function interactive(state, io, depth, args, proc = process) {
                         endBoot();
                 }
                 if (v.frame % tickEvery === 0) {
+                    // task-1397: the "new version available" toast, once, after the boot and never over the welcome card.
+                    if (state.updateNotice && state.screen !== 'boot' && !state.overlay) {
+                        say(state.updateNotice, 'info', 8);
+                        state.updateNotice = null;
+                    }
                     if (feed) {
                         if (!state.paused && Date.now() - lastRefresh >= LIVE_REFRESH_MS)
                             refresh();
@@ -5361,6 +5561,7 @@ export function interactive(state, io, depth, args, proc = process) {
                                     if (rulesTick(state, Date.now()))
                                         flusher.invalidate();
                                     drainRulesPending();
+                                    drainDeliveries();
                                 }
                                 catch (e) {
                                     state.screener.notice = `⚠ rules tick failed: ${describeError(e)}`;
@@ -5391,6 +5592,7 @@ export function interactive(state, io, depth, args, proc = process) {
                                 if (rulesTick(state, Date.now()))
                                     flusher.invalidate();
                                 drainRulesPending();
+                                drainDeliveries();
                             }
                             catch (e) {
                                 state.screener.notice = `⚠ rules tick failed: ${describeError(e)}`;