dexterm-cli 0.1.1 → 0.1.3

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

@@ -17,8 +17,13 @@
 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 { openPnl, loadPnl, pnlKey } from "./pnl-app.js";
+import { shareCard, runLocal } from "./pnl-card.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 { resolveRpcUrl, redactSecrets, defaultDbPath, extraRpcUrls, wsUrlFor, SOLANA_PUBLIC_RPC_WS, parseHttpUrl, validateAnalystAction, ACTION_RATE, ACTION_TIER, configChangeForAction, ImageService, encodePng, SummaryLimiter, buildSummaryWindow, KolStore, Cache, PackError, normalizeHandle, terminalSafe } from '../../data/src/index.js';
 import { Recorder, recorderEnabled, MaintenanceSchedule } from '../../recorder/src/index.js';
 import { makeFixtureState, makeFeedState, syncFeed, renderFrame, isScreenKey, activityFor, SCREEN_NAMES, analystKey, syncAnalyst, pinNewpairsSelection, ANALYST_TAB_KEY, computeNarrativeView, newPlansUi, plansService, plansRows, newFollowsUi, copyService, copyAutoService, MIRROR_DEFAULT_CAP_USD } from "./state.js";
 import { mulberry32, tick, spawnPair, shock } from "./fixtures.js";
@@ -35,6 +40,9 @@ 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 { 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 { resolveAnalystResults } from "./analyst/results.js";
@@ -46,13 +54,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, policyCheck } 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
@@ -60,6 +69,37 @@ import { DEFAULT_WORKSPACE, MORNING_HUD } from '../../custom/src/index.js';
  * that bounds what the analyst's UI actions may reference. Token-derived text stays raw here; the
  * context-block renderer wraps it as untrusted before a model sees it.
  */
+/** Screens the analyst's `switch_screen` action may target (task-1413); the user-facing set. */
+export const SWITCHABLE_SCREENS = ['screener', 'token', 'newpairs', 'watchlist', 'analyst', 'positions', 'trending', 'kol'];
+/**
+ * A read-only snapshot of local UI state for the `app_state` MCP tool (task-1413): what the user sees.
+ * NEVER includes a secret — alert channels report a boolean "configured", computed from creds presence,
+ * never the token/webhook/key itself. `null` when there is no live config (one-shot fixture frames).
+ */
+export function appStateBlock(state) {
+    const ui = state.custom;
+    if (!ui)
+        return null;
+    const cfg = ui.config;
+    const home = ui.home;
+    const ch = (cfg.alerts?.channels ?? {});
+    const alerts = {
+        // toast is on unless explicitly disabled; the rest are off unless enabled. telegram/discord also need creds.
+        toast: ch.toast?.enabled !== false,
+        desktop: ch.desktop?.enabled === true,
+        telegram: ch.telegram?.enabled === true && readTelegramCreds(home) !== null,
+        discord: ch.discord?.enabled === true && readDiscordCreds(home) !== null,
+    };
+    return {
+        theme: state.theme.name,
+        priceMode: priceModeOf(state),
+        intensity: state.vfx.intensity,
+        calm: isCalm(state.vfx),
+        voice: { name: cfg.voice?.name ?? null, rate: cfg.voice?.rate ?? null },
+        scan: { on: state.scan?.engine.on ?? false },
+        alerts, // booleans only — never a token, webhook or key
+    };
+}
 export function buildScreenState(state) {
     const live = state.live;
     const sc = state.screener;
@@ -122,7 +162,14 @@ export function buildScreenState(state) {
         watchlist,
         ticket,
         positions,
-        actions: { enabled: !!live, mints: [...mints], feeds, sortKeys: SORT_KEYS.map((k) => k.key) },
+        actions: {
+            enabled: !!live, mints: [...mints], feeds, sortKeys: SORT_KEYS.map((k) => k.key),
+            // task-1413: targets the new tiered actions may reference.
+            screens: [...SWITCHABLE_SCREENS],
+            workspaces: Object.keys(state.custom?.config.layout?.workspaces ?? {}),
+            themes: themeNames(state.custom),
+        },
+        app: appStateBlock(state),
         now: Date.now(),
     };
 }
@@ -205,10 +252,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)
@@ -217,7 +267,11 @@ export const HELP = `dexterm 0.1.1 (live: screener, token, new pairs, watchlist
   dexterm wallet link|unlink|status|panic|resume  link a Phantom wallet via a local bridge (pubkey only); panic disables live trading, resume needs a TTY keypress
   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 follow add|remove|list|stats|trades|mirror|purge  copy trading tier 1: follow a wallet (your list, local labels), its decoded swaps + FIFO PnL + win rate/early-entry; 'mirror' previews a one-key MIRROR TICKET from the wallet's latest buy (inert; arm 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|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 record run|install|uninstall|status  keep the history recorder fed with no TUI open, as a user-level launchd agent (no network beyond the data layer; 'dexterm record help')
   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 +286,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 +350,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
@@ -303,9 +358,10 @@ ${X_HELP}
   --version                 print the version
 
   Keys: 1-4 screens · tab cycle · j/k move · ⏎ open · esc back · a analyst · v voice · t theme · c calm · p pause · q quit
-        voice (JARVIS, macOS): v push-to-talk (press to talk, press to send) · m mute · , change voice · esc stop speaking
+        voice (JARVIS, macOS): v push-to-talk (press to talk, press to send) · m mute · , change voice · < / > slower/faster · esc stop speaking
                                voice asks the analyst or triggers safe actions (open/filter/watch/open a PAPER ticket);
                                a spoken "buy"/"sell" only OPENS a ticket — you still confirm it with a keypress
+                               spoken replies talk in market cap and round numbers (never a raw per-token price); < / > set the rate (saved to config)
         screener: / filter · s sort · [ ] presets · r refresh · g/G top/bottom
         social (task-1330): T trending in the space · K KOL lists · token screen: s social panel · f filter · x hidden spam
         dexterm kol list | create <name> | add <list> @handle | remove <list> @handle | mute @handle | unmute @handle | enable <list> | disable <list> | import <dir> | import-x
@@ -321,12 +377,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 +433,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 +459,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 +757,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`.
@@ -706,6 +769,12 @@ export async function main(argv, io = process, proc = process) {
         const { runAgent } = await import("./agent-cmd.js");
         return runAgent(argv.slice(1), io);
     }
+    // `dexterm spectate --replay FILE | --info` → watch an agent drive dexterm (task-1406, "watch the agent
+    // cook"): replay a saved session, or show the live read-only, token-gated, loopback spectator stream.
+    if (argv[0] === 'spectate') {
+        const { runSpectate } = await import("./spectate-cmd.js");
+        return runSpectate(argv.slice(1), io);
+    }
     // `dexterm recorder <cmd>` → the history recorder's tables: stats, label, prune, export (task-1329). No network.
     if (argv[0] === 'recorder') {
         const { recorderCli } = await import('../../recorder/src/index.js');
@@ -741,6 +810,12 @@ export async function main(argv, io = process, proc = process) {
         const { kbSkillCommand } = await import("./kb-skill-cmd.js");
         return kbSkillCommand(argv[0], argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env, isTTY: io.stdout.isTTY === true });
     }
+    // `dexterm help [topic]` → the app-help KB (task-1413): how the app works, with the exact key/command.
+    // Backed by the same generated entries the analyst's `app_help` tool uses. No network, no model.
+    if (argv[0] === 'help') {
+        const { helpCommand } = await import("./help-cmd.js");
+        return helpCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr });
+    }
     // `dexterm theme list|show|init|check` → user themes under ~/.dexterm/themes (task-1358 Tier 2). No network.
     if (argv[0] === 'theme') {
         const { themeCommand } = await import("./theme-cmd.js");
@@ -761,6 +836,25 @@ 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 record [run|install|uninstall|status]` → the headless collector that keeps the history recorder
+    // fed with no TUI open (task-1414), to be driven by a user-level launchd LaunchAgent. No signer, no trading;
+    // requests honour the data layer limits / health gate / sweep budgets, and the Helius key is never printed.
+    if (argv[0] === 'record') {
+        const { recordCommand } = await import("./record-cmd.js");
+        return recordCommand(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 +883,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 +944,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 +1038,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 +1171,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 +1201,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). */
@@ -1164,6 +1291,10 @@ function followsMove(state, delta) {
         return false;
     if (state.copyUi.input !== null || state.copyUi.mirror || state.copyUi.autoModal)
         return true;
+    if (state.copyUi.detail) {
+        state.copyUi.detail.scroll = Math.max(0, state.copyUi.detail.scroll + (delta > 0 ? 1 : -1));
+        return true;
+    } // task-1399: j/k scroll the detail view
     const n = state.copy?.follows().length ?? 0;
     if (n <= 0) {
         state.copyUi.selected = 0;
@@ -1449,6 +1580,10 @@ export function applyAction(state, action, stack) {
                 state.copyUi.notice = 'mirror preview closed';
                 break;
             } // task-1360: esc closes the mirror preview first
+            if (state.screen === 'follows' && state.copyUi?.detail) {
+                state.copyUi.detail = null;
+                break;
+            } // task-1399: esc closes the wallet detail view before leaving the screen
             const prev = stack.pop();
             if (prev)
                 state.screen = prev;
@@ -2269,6 +2404,14 @@ 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;
+        // task-1407 PNL CARD: the loop opens the preview (recorded fills only) and runs the share keys.
+        case 'pnl.card':
+            state.pendingPnl = true;
+            break;
         case 'display.priceMode':
             state.pendingToast = togglePriceMode(state);
             break; // task-1366: display only, persisted
@@ -2518,31 +2661,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 +2751,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
@@ -2594,6 +2783,12 @@ export function applyAnalystAction(state, raw, stack) {
     if (!res.ok)
         return { ok: false, error: res.error };
     const action = res.action;
+    // task-1413 tier (b): a persisted-config action is never applied by the model — return it as a PROPOSAL
+    // the user accepts with a keypress (applyAnalystConfig then journals it as actor 'analyst').
+    if (ACTION_TIER[action.type] === 'config') {
+        times.push(now);
+        return { ok: true, label: res.label, proposal: { action, summary: res.label } };
+    }
     // Resolve a mint to a row object from what is on screen (allow-list guarantees it was visible).
     const findSeed = (mint) => seedForMint(state, live, mint);
     const toScreen = (next) => { if (state.screen !== next) {
@@ -2633,6 +2828,10 @@ export function applyAnalystAction(state, raw, stack) {
         }
         case 'show_in_screener': {
             toScreen('screener');
+            if (action.preset && !setPreset(sc, action.preset))
+                return { ok: false, error: `preset "${action.preset}" is unavailable` };
+            if (action.preset && state.feed)
+                state.feed.setPreset(sc.preset);
             if (action.filter) {
                 const err = setFilter(sc, action.filter);
                 if (err)
@@ -2646,12 +2845,101 @@ export function applyAnalystAction(state, raw, stack) {
                     state.selected = i;
             }
             state.selected = clampSelection(sc, state.selected);
+            if (action.preset) {
+                times.push(now);
+                return { ok: true, label: res.label, refresh: true };
+            }
+            break;
+        }
+        // --- task-1413 view-only actions: applied immediately, shown as "analyst did X".
+        case 'switch_screen': {
+            toScreen(action.screen);
+            state.selected = 0;
+            break;
+        }
+        case 'switch_workspace': {
+            const r = switchWorkspace(state, action.name, stack);
+            if (!r.ok)
+                return { ok: false, error: r.reason };
+            times.push(now);
+            return { ok: true, label: res.label, refresh: r.refresh };
+        }
+        case 'chart_popup': {
+            // Open the chart popup (the loop performs the open/close); needs a selected coin to chart.
+            state.pendingPopup = action.open ? 'chart' : null;
+            break;
+        }
+        case 'toggle_calm': {
+            if (action.on) {
+                if (!isCalm(state.vfx)) {
+                    state.vfx.intensity = 'off';
+                    state.vfx.trail.clear();
+                }
+            }
+            else if (isCalm(state.vfx)) {
+                const back = 'fever';
+                state.vfx.intensity = back;
+                state.vfx.baseline = 0.12;
+            }
+            break;
+        }
+        case 'set_scan': {
+            scanCommand(state, action.on ? 'on' : 'off', stack);
+            break;
+        }
+        case 'export_view': {
+            state.pendingExport = true;
             break;
         }
     }
     times.push(now);
     return { ok: true, label: res.label };
 }
+/**
+ * task-1413: apply an accepted tier-(b) config proposal through the journaled path as actor `analyst`
+ * (so `ctrl+z` undoes it), creating the parent section when absent (exactly like the `$` / `,` handlers),
+ * then reflect it in the live UI where cheap. Throws on a refusal (schema / policy); the caller toasts it.
+ * Returns the one-line label for the confirmation toast.
+ */
+export function applyAnalystConfig(state, proposal) {
+    const ui = state.custom;
+    if (!ui)
+        throw new Error('config changes need a loaded config (not available on this run)');
+    const change = configChangeForAction(proposal.action);
+    if (!change)
+        throw new Error('not a persisted-config action');
+    const parent = ui.config[change.section];
+    const op = parent && typeof parent === 'object'
+        ? { op: 'add', path: change.path, value: change.value }
+        : { op: 'add', path: `/${change.section}`, value: { [change.key]: change.value } };
+    // THE GATE (task-1413 r2): re-run the model-actor policy on the exact journal op BEFORE writing. The
+    // analyst is not the user, so `DENIED_FOR_MODELS` applies — a config action can never reach a signer /
+    // trading / keys / caps / mandates / wallet / alerts / VOICE path, even behind the keypress confirm.
+    // CONFIG_ACTION_PATHS is already a closed non-denied allow-list; this is the server-side belt-and-braces.
+    const denied = policyCheck([op], 'claude');
+    if (denied.length)
+        throw new Error(`refused: ${denied.map((e) => e.msg).join('; ')}`);
+    const { config } = applyAndJournal(ui.home, [op], { actor: 'analyst', why: `analyst: ${proposal.summary}`, now: state.now.getTime() });
+    ui.config = config;
+    // Reflect the change in the running UI where it is cheap and local.
+    switch (proposal.action.type) {
+        case 'set_theme': {
+            const t = themeByName(ui, proposal.action.name);
+            if (t)
+                state.theme = t;
+            break;
+        }
+        case 'set_price_mode':
+            state.priceMode = proposal.action.mode;
+            break;
+        case 'set_intensity':
+            state.vfx.intensity = proposal.action.intensity;
+            state.vfx.baseline = proposal.action.intensity === 'fever' ? 0.12 : 0;
+            break;
+        default: break;
+    }
+    return proposal.summary;
+}
 /**
  * Route one decoded key: the screener's filter editor and sort menu swallow keys while open,
  * everything else goes through the keymap. Exported for tests.
@@ -2879,6 +3167,22 @@ export function applyKey(state, key, stack) {
             ui.input = cur + key.ch;
         return;
     }
+    // task-1399: on the follows screen (not typing, no modal), enter opens/closes the selected wallet's DETAIL view.
+    if (state.screen === 'follows' && state.copyUi && state.copyUi.input === null && !state.copyUi.mirror && !state.copyUi.autoModal && key.name === 'enter') {
+        const ui = state.copyUi;
+        if (ui.detail) {
+            ui.detail = null;
+            return;
+        }
+        const svc = state.copy;
+        const rows = svc?.follows() ?? [];
+        const f = rows[Math.max(0, Math.min(rows.length - 1, ui.selected))];
+        if (f)
+            ui.detail = { wallet: f.addr, scroll: 0 };
+        else
+            ui.notice = 'follow a wallet first (i)';
+        return;
+    }
     if (state.screen === 'kol' && state.kolInput !== null && state.kolInput !== undefined) {
         const kol = kolOf(state);
         if (key.name === 'esc') {
@@ -2918,6 +3222,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) {
@@ -3497,6 +3813,10 @@ export function interactive(state, io, depth, args, proc = process) {
         // Live bindings redraw as soon as something lands (one frame per macrotask at most).
         let drawPending = false;
         let lastFastDraw = 0;
+        // task-1399: a followed wallet's buy/sell also PUSHES through the alerts engine (desktop / Telegram / Discord)
+        // when the user enabled a push channel. Forward-declared; the real impl is set once the Notifier exists below.
+        // Read-only, like a rule alert — nothing here trades, arms or signs.
+        let pushCopyAlert = () => { };
         if (live) {
             // task-1360: poll the followed wallets for the whole run (live only; replay never spends credits) and toast
             // every new buy/sell a followed wallet made. Information only: no path from an alert to a trade exists here.
@@ -3509,6 +3829,8 @@ export function interactive(state, io, depth, args, proc = process) {
                         const a = as[as.length - 1];
                         const who = a.name ?? shortAddr(a.wallet);
                         say(`${who} ${a.trade.side === 'buy' ? 'BOUGHT' : 'SOLD'} ${shortAddr(a.trade.mint)}${a.trade.usd !== null ? ` ≈ $${a.trade.usd.toFixed(0)}` : ''}${a.lagMs !== null ? ` · lag ${Math.round(a.lagMs / 1000)}s` : ''}${as.length > 1 ? ` (+${as.length - 1} more · U)` : ' (U)'}`, a.trade.side === 'buy' ? 'up' : 'down', 6);
+                        for (const ca of as)
+                            pushCopyAlert(ca); // task-1399: push each one out through the alerts engine too
                     }
                 }
                 if (done || drawPending)
@@ -3629,6 +3951,15 @@ export function interactive(state, io, depth, args, proc = process) {
                 const r = applyAnalystAction(state, raw, stack);
                 if (!r.ok || !r.label)
                     return;
+                // task-1413 tier (b): a persisted-config request is a PROPOSAL — show it and wait for the user's key.
+                if (r.proposal) {
+                    // The proposal expires with its 8s toast (task-1413 defect c): a 'y' typed after it fades never
+                    // persists a stale change. `now` is the frame clock so it stays deterministic under replay.
+                    state.analystConfigProposal = { ...r.proposal, expiresAt: state.now.getTime() + 8000 };
+                    say(`analyst suggests: ${r.proposal.summary} — press y to accept, any other key to dismiss`, 'ai', 8);
+                    scheduleDraw();
+                    return;
+                }
                 const log = (state.analystActions ??= []);
                 log.push(r.label);
                 if (log.length > 6)
@@ -4099,6 +4430,28 @@ 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;
+        // task-1399: now the Notifier exists, a followed wallet's buy/sell can be pushed. Fire-and-forget; a slow
+        // channel never blocks the loop; routing's `levels` filter lets the user scope (a buy is `up`, a sell `down`).
+        if (alertNotifier)
+            pushCopyAlert = (ca) => { void alertNotifier.deliver(copyAlertToDelivery(ca)).catch(() => { }); };
+        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
@@ -4258,6 +4611,47 @@ export function interactive(state, io, depth, args, proc = process) {
                 return { price: np.price ?? null, mcap: np.mcap ?? null };
             return { price: null, mcap: null };
         };
+        // task-1411: a short instruction appended to a VOICE analyst question so the answer is built for the
+        // ear, not the screen — market cap not a per-token price, round numbers, short.
+        const VOICE_ANALYST_SPEECH_HINT = 'Answer out loud for text-to-speech: talk about price as market cap, never a raw per-token price; '
+            + 'round big numbers like "340 thousand" or "1.2 million"; no long addresses; keep it to two or three short sentences.';
+        // A spoken pronoun that points at the highlighted row ("this one", "this coin", "it").
+        const VOICE_SELECTION_PRONOUN = /\b(?:this (?:one|coin|token)|that (?:one|coin|token)|this|it)\b/i;
+        // A friendly, complete spoken ack for each navigable screen (the router's `say` is the terse key).
+        const NAV_ACK = {
+            screener: 'the screener', newpairs: 'new pairs', watchlist: 'your watchlist', analyst: 'the analyst', positions: 'your positions',
+        };
+        /**
+         * Run a VOICE-originated analyst question (task-1411). Fixes the screener silence: "what do you think
+         * of THIS ONE" aimed at a highlighted screener row used to start a context-free `trench-scan` with no
+         * mint, so the analyst never learned which coin "this one" was and answered with a short, useless
+         * fragment (the tester heard nothing useful). We now attach the SELECTED coin as a token-dossier target —
+         * exactly the context a token screen already gives — so it answers for real. The question also carries
+         * a short "answer for speech" instruction (market cap, round numbers, short).
+         */
+        const askVoiceAnalyst = (question) => {
+            const q = question.trim().slice(0, 400);
+            const instructed = `${q}\n\n${VOICE_ANALYST_SPEECH_HINT}`;
+            // A warm session: follow up on it so the model keeps context (the screen is already analyst/token).
+            if (state.analyst) {
+                state.analyst.ask(instructed, buildScreenState(state));
+                return;
+            }
+            const tv = live?.token?.view;
+            const sel = voiceSelected();
+            if (state.screen === 'token' && live && tv?.mint) {
+                state.pendingAnalyst = { skill: 'token-dossier', mint: tv.mint, symbol: tv.symbol, target: 'token', question: instructed };
+            }
+            else if (live && sel && VOICE_SELECTION_PRONOUN.test(q)) {
+                // the screener/analyst/watchlist/new-pairs highlighted coin IS "this one" (task-1411)
+                state.pendingAnalyst = { skill: 'token-dossier', mint: sel.mint, symbol: sel.symbol, target: 'analyst', question: instructed };
+            }
+            else {
+                state.pendingAnalyst = { skill: 'trench-scan', target: 'analyst', question: instructed };
+            }
+            if (state.pendingAnalyst)
+                beginAnalyst();
+        };
         /**
          * Perform a voice decision. Returns `false` when the app spoke its own reply (an ask / clarify), so
          * the controller does not read the decision's `say` line over it (task-1339, re-verify N1: the
@@ -4273,6 +4667,7 @@ export function interactive(state, io, depth, args, proc = process) {
                         const a = SCREEN_ACTION[d.screen];
                         if (a)
                             applyAction(state, a, stack);
+                        ask(NAV_ACK[d.screen] ?? d.say);
                         break;
                     }
                     case 'open-token': {
@@ -4397,14 +4792,14 @@ export function interactive(state, io, depth, args, proc = process) {
                     case 'analyst': {
                         // Route the question to the analyst, surface the chat, and let the answer be spoken when it lands.
                         // Capped like typed chat (400 chars): a runaway transcript never becomes a 200 KB argv (N7).
+                        // task-1411: askVoiceAnalyst attaches the highlighted coin as context so a screener "this one"
+                        // question is answered for real, and appends the "answer for speech" instruction.
                         if (state.screen !== 'token' && state.screen !== 'analyst') {
                             stack.push(state.screen);
                             state.screen = 'analyst';
                         }
                         syncAnalyst(state);
-                        sendChat(d.question.slice(0, 400));
-                        if (state.pendingAnalyst)
-                            beginAnalyst();
+                        askVoiceAnalyst(d.question);
                         break;
                     }
                     case 'workspace': {
@@ -4456,26 +4851,65 @@ 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 */ }
+        };
+        // task-1411: persist the < / > speaking-rate nudge to config.voice.rate (actor 'user', journaled →
+        // undo works). Best-effort: a failure keeps the rate for this run and never breaks the UI.
+        const persistVoiceRate = (rate) => {
+            const ui = state.custom;
+            if (!ui)
+                return;
+            try {
+                const op = ui.config.voice
+                    ? { op: 'add', path: '/voice/rate', value: rate }
+                    : { op: 'add', path: '/voice', value: { rate } };
+                const { config } = applyAndJournal(ui.home, [op], { actor: 'user', why: `voice rate ${rate}`, now: state.now.getTime() });
+                ui.config = config;
+            }
+            catch { /* keep the rate 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,
+                onRateChange: persistVoiceRate,
             });
             voice.enable();
             await voice.toggleTalk(); // the first `v` press both enables and starts listening
@@ -4539,6 +4973,35 @@ export function interactive(state, io, depth, args, proc = process) {
                     quit();
                     return;
                 }
+                // task-1413: a pending analyst config PROPOSAL owns the next key. `y` accepts and journals it as
+                // actor 'analyst' (ctrl+z undoes); any other key dismisses it. A stray key never persists a change.
+                // Two guards (defect c): the proposal does NOT steal a key while a TEXT INPUT is open — the GO-TO
+                // prompt or a focused analyst chat line — so a 'y' being typed goes into the field, not the accept;
+                // and an EXPIRED proposal (its 8s toast has faded) is silently dropped, never accepted by a late 'y'.
+                if (state.analystConfigProposal) {
+                    const inputOpen = !!state.goto || (state.aiFocused === true);
+                    const expired = state.now.getTime() >= state.analystConfigProposal.expiresAt;
+                    if (expired) {
+                        state.analystConfigProposal = null; // let the key fall through to its normal handler below
+                    }
+                    else if (!inputOpen) {
+                        const prop = state.analystConfigProposal;
+                        state.analystConfigProposal = null;
+                        if (key.ch === 'y' || key.ch === 'Y') {
+                            try {
+                                say(`analyst ${applyAnalystConfig(state, prop)} · ctrl+z undoes`, 'ai', 5);
+                            }
+                            catch (e) {
+                                say(`change refused: ${describeError(e)}`, 'warn', 4);
+                            }
+                        }
+                        else {
+                            say('dismissed the analyst change', 'ai', 3);
+                        }
+                        draw();
+                        continue;
+                    }
+                }
                 // task-1388 GO-TO prompt: while the "open any coin" input is open it owns the keyboard. Route the key
                 // straight to applyKey (which does the capture / open) and skip the voice, calm, demo and keymap
                 // handlers below — otherwise a base58 char like v / m / c would toggle voice or calm instead of typing.
@@ -4573,7 +5036,7 @@ export function interactive(state, io, depth, args, proc = process) {
                 // `micEngaged` also covers the window while the mic is still OPENING (listen() in flight), so a key
                 // pressed before the engine came up closes the session the moment it arrives (task-1339, N3/N8).
                 if (voice?.micEngaged) {
-                    const isVoiceCtl = key.name === 'char' && !key.ctrl && !key.alt && (key.ch === 'v' || key.ch === 'm' || key.ch === ',');
+                    const isVoiceCtl = key.name === 'char' && !key.ctrl && !key.alt && (key.ch === 'v' || key.ch === 'm' || key.ch === ',' || key.ch === '<' || key.ch === '>');
                     if (key.name === 'esc') {
                         voice.cancelListen();
                         draw();
@@ -4615,6 +5078,16 @@ export function interactive(state, io, depth, args, proc = process) {
                             draw();
                             continue;
                         }
+                        if (voice?.isEnabled && key.ch === '<') {
+                            voice.nudgeRate(-1);
+                            draw();
+                            continue;
+                        } // slower (task-1411)
+                        if (voice?.isEnabled && key.ch === '>') {
+                            voice.nudgeRate(1);
+                            draw();
+                            continue;
+                        } // faster (task-1411)
                     }
                 }
                 // A modal overlay (welcome/help) is open: any key dismisses it; `?` switches welcome→help (task-1305).
@@ -4633,6 +5106,32 @@ export function interactive(state, io, depth, args, proc = process) {
                     draw();
                     continue;
                 }
+                // task-1407: the PnL card preview owns the keys while open (share / save / toggles / other coin / esc).
+                if (state.overlay === 'pnl' && state.pnl) {
+                    const ui = state.pnl;
+                    const eff = pnlKey(ui, key);
+                    if (eff.kind === 'close') {
+                        state.overlay = null;
+                        state.pnl = null;
+                    }
+                    else if (eff.kind === 'reload') {
+                        ui.stats = null;
+                        ui.error = null;
+                        void loadPnl(state).then(() => { if (!done)
+                            draw(); });
+                    }
+                    else if (eff.kind === 'share' && ui.stats) {
+                        ui.busy = true;
+                        ui.notice = null;
+                        void shareCard(ui.stats, { ...ui.opts }, eff.action, { platform: process.platform, env: io.env, run: runLocal, openUrl: (u) => openInBrowser(u), copyText: copyToClipboard })
+                            .then((r) => { ui.notice = r.message; say(r.message, 'info', 10); })
+                            .catch((e) => { ui.notice = `card failed: ${describeError(e)}`; })
+                            .finally(() => { ui.busy = false; if (!done)
+                            draw(); });
+                    }
+                    draw();
+                    continue;
+                }
                 // task-1358: the WORKSPACES card — a digit picks a slot, j/k move, ⏎ activates, esc/q/ctrl+w w close.
                 if (state.overlay === 'workspaces' && state.custom) {
                     const ui = state.custom;
@@ -5016,6 +5515,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 +5768,29 @@ 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.pendingPnl) {
+                // task-1407: open the PnL card preview for this screen (recorded fills only), then build the card.
+                state.pendingPnl = false;
+                const why = openPnl(state);
+                if (why)
+                    say(why, 'warn', 6);
+                else
+                    void loadPnl(state).then(() => { if (!done)
+                        draw(); });
+            }
             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 +5854,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();
@@ -5328,6 +5870,9 @@ export function interactive(state, io, depth, args, proc = process) {
                                 lastTokenRefresh = Date.now();
                                 void live.token.load();
                             }
+                            // task-1404: keep the open token's credit-metered holder/rug intel LIVE (slow cadence, budget-gated inside).
+                            if (state.screen === 'token' && live.token)
+                                live.refreshOpenIntel(Date.now());
                             if (state.screen === 'watchlist' && Date.now() - lastWatchRefresh >= WATCH_REFRESH_MS) {
                                 lastWatchRefresh = Date.now();
                                 void live.watch.refresh();
@@ -5361,6 +5906,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 +5937,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)}`;