dexterm-cli 0.1.5 → 0.1.7

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

@@ -25,7 +25,7 @@ import { parseMintTarget, parseCoinTarget, resolveCoinTarget, isBareOpen } from
 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, 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 { 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, pnlChipFor } from "./state.js";
 import { mulberry32, tick, spawnPair, shock } from "./fixtures.js";
 import { createLiveFeed, createReplayFeed } from "./feed.js";
 import { LiveContext, INTERVALS, WATCH_REFRESH_MS, POSITIONS_REFRESH_MS, popupBubbleVM } from "./live/index.js";
@@ -39,9 +39,14 @@ import { parseFilter } from "./screener/filter.js";
 import { screenerView, setFilter, setSort, setPreset, stepPreset, clampSelection, openFilterEditor, openSortMenu, filterEditorKey, sortMenuKey, } from "./screener/view.js";
 import { readBootState, bootPlan, recordBoot, bootTrace, dextermHome } from "./boot-state.js";
 import { socialOf, kolOf, trendingRows, kolRows, nextSocialFilter, feedsPopupModel } from "./social/view.js";
-import { TokenPopups, tokenDetailVMFromView } from "./popup.js";
+import { TokenPopups, tokenDetailVMFromView, currentPositionFills } from "./popup.js";
+import { OwnPnlTracker } from "./screens/pnl-chip.js";
+import { positionRow } from "./live/trade.js";
 import { widgetPage, widgetEnabled, syncWidgetPopups } from "./widgets.js";
 import { recordLarpVerdict } from "./larp-record.js";
+import { newAutotradeUi, defaultDeps as autotradeDeps, autotradeCapturing, autotradeTick, reloadList as autotradeReload, refreshRunner as autotradeRefreshRunner } from "./screens/autotrade-ui.js";
+import { autotradeAction, autotradeKey } from "./screens/autotrade-keys.js";
+import { workerJobs as autotradeWorkerJobs } from "./screens/autotrade-worker.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";
@@ -49,20 +54,22 @@ import { readTelegramCreds, readDiscordCreds } from "./alerts/creds.js";
 import { launchIntelCells, launchRetryable } from "./live/intel.js";
 import { AnalystSession } from "./analyst/session.js";
 import { analystCliOnPath, parseEngineChoice, resolveEngine } from "./analyst/codex.js";
+import { analystEngineHas, analystAiChoice } from "./ai-cmd.js";
 import { resolveAnalystResults } from "./analyst/results.js";
 import { parseScanCommand, SCAN_FLAGS, checkScanFlag, SCAN_HELP } from "./scan/command.js";
 import { parseWalletCommand, WALLET_HELP } from "./wallet-command.js";
 import { X_HELP } from "./x-cmd.js";
-import { makeScanUi, MODE_LABEL, SCAN_ACTION_TYPES, SCAN_TICK_MS, SCAN_RECOMPUTE_MS } from "./scan/ui.js";
+import { makeScanUi, scanLog, MODE_LABEL, SCAN_ACTION_TYPES, SCAN_TICK_MS, SCAN_RECOMPUTE_MS } from "./scan/ui.js";
 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, SayTts, voiceStyleDefaults } from '../../voice/src/index.js';
-import { LivePlanExecutor, defaultPlansJournalPath } from '../../data/src/trade/plans/index.js';
+import { 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 { HUD_MIN_H, hudAnimating } from "./screens/agent-hud.js";
+import { isPriceMode, configPriceMode, takeBasisFlags, togglePriceMode, setPriceMode, parseDisplayCommand, priceModeNotice, priceModeOf, planLevels, configChartAxis, setChartAxis, chartAxisOf, configChartMarkers, setChartMarkers, chartMarkersOn } 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, applyAndJournal, policyCheck } from '../../custom/src/index.js';
@@ -124,19 +131,36 @@ export function buildScreenState(state) {
     const sc = state.screener;
     // The screener and the Analyst-tab coin list both show the filtered/sorted screener view, so the
     // selection + visible rows must come from that same view (task-1313); other screens use the raw pool.
-    const rows = state.screen === 'screener' || state.screen === 'analyst' ? screenerView(sc) : sc.rows;
+    // The new-pairs screen shows the live PumpPortal list (task-1443 capture r2: it used to report the screener pool
+    // here, so an agent watching new pairs could not read what was on screen or what was highlighted).
+    const newPairs = state.screen === 'newpairs' && live ? live.newpairs.list() : null;
+    const rows = state.screen === 'screener' || state.screen === 'analyst' ? screenerView(sc) : newPairs ?? sc.rows;
     const toRow = (r) => {
         const x = r;
         if (!x?.mint)
             return null;
-        return { mint: x.mint, symbol: x.symbol ?? '', priceUsd: x.price ?? null, chg1h: x.chg?.h1 ?? null, chg24h: x.chg?.h24 ?? null, liq: x.liq ?? null, vol24: x.vol24 ?? null };
+        // task-1537: the row's market cap rides along (the analyst's context leads with it by default)
+        return { mint: x.mint, symbol: x.symbol ?? '', priceUsd: x.price ?? null, mcap: x.mcap ?? null, chg1h: x.chg?.h1 ?? null, chg24h: x.chg?.h24 ?? null, liq: x.liq ?? null, vol24: x.vol24 ?? null };
     };
-    const visible = rows.slice(0, 12).map(toRow).filter((r) => r !== null);
+    const toNewPairRow = (r) => {
+        const x = r;
+        if (!x?.mint)
+            return null;
+        return {
+            mint: x.mint, symbol: x.symbol ?? '', priceUsd: x.price ?? null, chg1h: x.chg?.h1 ?? null, chg24h: null, liq: x.liq ?? null, vol24: x.vol ?? null,
+            ageSec: Number.isFinite(x.createdAt) ? Math.max(0, Math.round((Date.now() - x.createdAt) / 1000)) : null,
+            mcap: x.mcap ?? null, chg5m: x.chg?.m5 ?? null, bonding: x.bonding ?? null, buys: x.buys ?? null, sells: x.sells ?? null,
+        };
+    };
+    const mapRow = newPairs ? toNewPairRow : toRow;
+    const visible = rows.slice(0, 12).map(mapRow).filter((r) => r !== null);
     let selected = null;
     if (state.screen === 'token' && live?.token?.view)
         selected = { mint: live.token.view.mint, symbol: live.token.view.symbol };
     else {
-        const r = toRow(rows[state.selected || 0]);
+        // Same pick as the new-pairs screen's own highlight (selectedMint first, then the cursor row).
+        const hit = newPairs && state.selectedMint ? newPairs.find((x) => x.mint === state.selectedMint) : undefined;
+        const r = mapRow(hit ?? rows[state.selected || 0]);
         if (r)
             selected = { mint: r.mint, symbol: r.symbol };
     }
@@ -267,7 +291,7 @@ export function shouldDrawFrame(g) {
         return true;
     if (g.calm)
         return g.onTick;
-    if (g.fxBusy)
+    if (g.fxBusy || g.hud)
         return true;
     return g.frame % g.idleEvery === 0;
 }
@@ -279,14 +303,17 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   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 kb list|show|new|edit|check|reset|path     your knowledge-base entries (~/.dexterm/kb/entries) over the bundled 18
   dexterm skill list|show|new|edit|check|reset|path  your analyst skills (~/.dexterm/skills) over the bundled ones (read tools only)
   dexterm narrative [--window 1h|24h] [--summary]  the narrative board over recorded history (no network, no model)
   dexterm backtest [--subject heuristic|pack_verdicts] [--horizon SEC]  honest rug-model metrics over recorded outcomes (no network, no model)
-  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 ledger trades|positions|summary|equity|compare|export|card|sync|verify  the unified trade ledger: paper, agent desk, autotrade runs (no network; 'dexterm ledger help')
+  dexterm wallet link|unlink|status|panic|resume  link a Phantom wallet via a local bridge (pubkey only); panic halts autotrade + the paper desk, 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 mandate draft|list|arm|revoke            standing capped mandates (paper fills); arming needs a physical keypress — voice/agents can never arm
   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 ai [status|engine|model|host|restrictions|probe|ask|agent]  the AI engine: your claude / codex CLI or a free LOCAL model on
+                                              your own Ollama (localhost); restriction profiles observe|propose|paper|full ('dexterm ai help')
   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)
@@ -306,6 +333,8 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   --record FILE             save every live response (and the PumpPortal session) to FILE (replay it with --replay)
   --spectate-mcp            follow an MCP agent's allowed navigation in this terminal; Ctrl+P pauses, Ctrl+K stops,
                             and any normal user keypress takes control (refused actions never move the UI)
+  --spectate-thoughts FILE  (with --spectate-mcp) stream the agent's own words into the thought ribbon from a JSONL
+                            file it writes (e.g. claude -p --output-format stream-json); display only, scrubbed
   --agent-paper MANDATE_ID  (experimental, with --spectate-mcp) let that MCP agent PAPER-trade inside a mandate you
                             armed: simulated fills only, never signs or sends, never raises a cap; Ctrl+P / Ctrl+K /
                             any key also pause, stop or take over its paper trading
@@ -323,8 +352,9 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   --selected N              highlighted row / token index
   --seed N                  fixture PRNG seed (default 7)
   --no-ai                   hide the analyst panel on the token screen
-  --analyst-engine E        auto | claude | codex: which of YOUR installed CLIs runs the analyst (default auto = claude
-                            if installed, else codex; DEXTERM_ANALYST_ENGINE or config analyst.engine too; /engine in chat)
+  --analyst-engine E        auto | claude | codex | ollama: which of YOUR engines runs the analyst (default auto = claude
+                            if installed, else codex, else a local Ollama model; DEXTERM_ANALYST_ENGINE, config analyst.engine
+                            or ai.json too; /engine in chat). ollama = a free local model, see 'dexterm ai help'
 
   --intensity LEVEL         off | normal | fever (default fever: rain, trails, glitch, blink, scanlines at 30 fps;
                             normal: 15 fps, sparser rain, no idle aberration; off = calm: neon theme, no motion)
@@ -343,12 +373,16 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
                             result only; muted by default (also DEXTERM_SOUND=1); ~/.dexterm/sounds holds the WAVs
   --workspace NAME          start in a workspace: default | morning-hud | a file in ~/.dexterm/workspaces/ (task-1358);
                             in the app ctrl+w then w (list) · n/N (next/prev) · s (save as) · m (morning HUD) · o (popups) · d · 1-9
-  --price-mode MODE         price | mcap: show USD price or MARKET CAP (price × supply) on the tables, token screen and both
-                            charts for this run (default: config.json display.priceMode; \$ in the app toggles and saves it)
+  --price-mode MODE         mcap | price: show MARKET CAP (price × a known supply; the default) or USD price on every screen,
+                            the CLI text and in the assistants' language for this run (default: config.json display.priceMode,
+                            mcap; \$ in the app toggles and saves it). --mcap / --price (any command) and
+                            DEXTERM_PRICE_BASIS=mcap|price do the same for one run
+  --mcap / --price          the price basis for this run on ANY command (dexterm --price autotrade run …), not saved
   dexterm workspace list|show|remove|init         the workspace files (no network)
   dexterm theme list|show|init|check              user themes in ~/.dexterm/themes (extends a built-in; contrast + hue guarded)
   dexterm keymap [screen]                         the effective keys (defaults + config.keymap overrides, marked ·)
-  dexterm display [price|mcap]                    show or set the price display mode (market cap = price × supply)
+  dexterm display [mcap|price]                    show or set the price basis (default market cap = price × a known supply)
+  dexterm display markers [on|off]                show or hide the BUY/SELL markers of your fills on both charts
   dexterm rules list|add|remove|enable|disable|check|dry-run|fields
                             "when <cond> [for n ticks] then alert|ticket|ask|popup|tag|sound|watch" rules in config.json (task-1358);
                             parsed never eval'd; mandatory cooldown + max/h; rules only alert or PROPOSE (ctrl+r in the app)
@@ -361,14 +395,10 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   AI SCAN MODE (off by default; observe + analyze only — it can never open a ticket, sign or trade):
 ${SCAN_HELP}
 
-  LIVE TRADING (task-1328; devnet by default; a separate signer process holds the caps and signs via Phantom):
-  --mainnet                 allow MAINNET swaps (real funds) within the caps; without it the signer refuses mainnet
-  --max-usd N               per-trade USD cap (default $5; raising it needs --mainnet; hard ceiling $500)
-  --daily-usd N             daily USD cap (default $20; raising it needs --mainnet; hard ceiling $2000)
-  --max-sol-out N           SOL that may leave the wallet in one tx (default 1, ceiling 5)
-  --max-slippage-bps N      slippage ceiling (default 500, ceiling 1000)
-  --trade-rpc URL           the signer's RPC (default devnet; must be devnet unless --mainnet)
-  --no-live                 paper only: never start the signer process
+  WALLET + LIVE TRADING (dexterm never holds a key and never signs a transaction):
+  live trading happens in the Telegram trading bot of your choice, which holds its own wallet; dexterm sends alerts,
+  signals and run control to your chat through your own bot (dexterm telegram setup). dexterm places no live order.
+  --no-live                 accepted for older scripts; changes nothing (trading in dexterm is paper only)
 ${WALLET_HELP}
 
   LOGIN WITH X (task-1357; your own X app, your limits, your bill; read scopes only, no scraping, dexterm never posts):
@@ -393,17 +423,15 @@ ${X_HELP}
         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
         Login with X (task-1357): dexterm x login · then the SOCIAL panel + TRENDING read X with your own limits · KOL screen: X imports your X lists · o = only this handle
-        token: B/S buy/sell ticket (PAPER; L on the ticket flips LIVE when a wallet is linked) · P positions · w watch
+        token: B/S buy/sell ticket (PAPER) · P positions · w watch
         token: M bubble map (holder graph: clusters by funder / same-slot buys / transfers; colour = rule) · bubble map: M popup · m treemap · z zoom · D deep scan
         demo events on --fixtures: n new pair (glitch) · u pump (gold rain) · d dump (red rain) · x rug flag
         AI scan: Z on/off · R resume scanning after a lock · esc (on the locked coin) cancel the analysis
         any key skips the boot sequence or a blink transition
 
   State: ~/.dexterm/state.json remembers launches (DEXTERM_HOME overrides the directory).
-  DEXTERM_OFFLINE=1 refuses live data (tests and CI). Trading is PAPER by default — a simulated wallet
-  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.
+  DEXTERM_OFFLINE=1 refuses live data (tests and CI). Trading in dexterm is PAPER only — a simulated wallet
+  priced from live Jupiter quotes. dexterm never holds a key and never signs or sends a transaction.
   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.`;
@@ -417,9 +445,8 @@ export function parseArgs(argv) {
         scan: false, scanConfig: {},
         noRecorder: false,
         sound: false,
-        trade: [], live: true,
         workspace: null, priceMode: null,
-        spectateMcp: false, agentPaper: null,
+        spectateMcp: false, spectateThoughts: null, agentPaper: null,
         help: false, version: false, unknown: [],
     };
     for (let i = 0; i < argv.length; i++) {
@@ -512,7 +539,7 @@ export function parseArgs(argv) {
             const s = str();
             const e = parseEngineChoice(s);
             if (!e)
-                throw new Error(`unknown analyst engine ${s} (expected auto|claude|codex)`);
+                throw new Error(`unknown analyst engine ${s} (expected auto|claude|codex|ollama)`);
             a.analystEngine = e;
         }
         else if (k === '--calm')
@@ -590,18 +617,10 @@ export function parseArgs(argv) {
             a.noRecorder = true;
         else if (k === '--sound')
             a.sound = true;
-        // task-1328 LIVE trading flags: forwarded verbatim to the signer process, which validates them
-        // (over-ceiling values are refused there; without --mainnet the USD caps only go down).
-        else if (k === '--mainnet')
-            a.trade.push(k);
-        else if (k === '--max-usd' || k === '--daily-usd' || k === '--max-sol-out' || k === '--max-slippage-bps') {
-            a.trade.push(k, String(num()));
-        }
-        else if (k === '--trade-rpc') {
-            a.trade.push('--rpc', str());
-        }
-        else if (k === '--no-live')
-            a.live = false;
+        // task-1571: dexterm has no live trading of its own; `--no-live` (0.1.6) is accepted and changes nothing.
+        else if (k === '--no-live') { /* paper only is the only mode */ }
+        else if (k === '--price' || k === '--mcap')
+            a.priceMode = k === '--price' ? 'price' : 'mcap'; // task-1537 (main() also takes them before any subcommand)
         else if (k === '--price-mode') {
             const s = str();
             if (!isPriceMode(s))
@@ -611,6 +630,8 @@ export function parseArgs(argv) {
         // task-1421: follow an agent driving over MCP (the running terminal moves with it; a read-only stream opens).
         else if (k === '--spectate-mcp')
             a.spectateMcp = true;
+        else if (k === '--spectate-thoughts')
+            a.spectateThoughts = str();
         // task-1443: agent PAPER trading inside a mandate the user armed (validated against the plans journal at start).
         else if (k === '--agent-paper') {
             const s = str();
@@ -655,6 +676,8 @@ export function parseArgs(argv) {
         throw new Error('--scan needs live data or a recording (drop --fixtures)');
     if (a.scan && a.screen)
         throw new Error('--scan is interactive (drop --screen)');
+    if (a.spectateThoughts && !a.spectateMcp)
+        throw new Error('--spectate-thoughts needs --spectate-mcp (the thought ribbon is part of the follow view)');
     if (a.agentPaper && !a.spectateMcp)
         throw new Error('--agent-paper needs --spectate-mcp (every agent paper trade must be visible in this terminal)');
     if (a.agentPaper && a.db === ':memory:')
@@ -806,6 +829,8 @@ export function fastLaneEndpoints(rpc) {
     return out;
 }
 export async function main(argv, io = process, proc = process) {
+    // task-1537: `--price` / `--mcap` anywhere = the price basis for this run (every screen, CLI text and agent prompt).
+    argv = takeBasisFlags(argv, io.env);
     // `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') {
@@ -834,6 +859,17 @@ export async function main(argv, io = process, proc = process) {
         const { narrativeCommand } = await import("./narrative-cmd.js");
         return narrativeCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
     }
+    // `dexterm ledger …` → the unified trade ledger (task-1530): reads fold the file + the sources; only `sync` writes. No network, no model, no keys.
+    if (argv[0] === 'ledger') {
+        const { ledgerCommand } = await import("./ledger-cmd.js");
+        return ledgerCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
+    }
+    // `dexterm autotrade validate|list|backtest|sweep …` and `dexterm backtest --subject strategy` → the paper autotrade engine (task-1503). No network, no model, no keys.
+    if (argv[0] === 'autotrade' || argv[0] === 'backtest') {
+        const at = await import("./autotrade-cmd.js");
+        if (at.handles(argv))
+            return at.autotradeCommand(argv, { stdout: io.stdout, stderr: io.stderr, env: io.env, stdin: io.stdin });
+    }
     // `dexterm backtest [--subject heuristic|pack_verdicts] [--horizon SEC]` → honest rug-model metrics over recorded outcomes (task-1356). No network, no model.
     if (argv[0] === 'backtest') {
         const { backtestCommand } = await import("./backtest-cmd.js");
@@ -896,6 +932,12 @@ export async function main(argv, io = process, proc = process) {
         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 telegram setup|pair|status|approvals|notify|set|test|audit|revoke` → your own bot for the autotrade runner
+    // (task-1527). The token goes in the OS secret store (or a 0600 file), never config/argv/env/logs.
+    if (argv[0] === 'telegram') {
+        const { telegramCommand } = await import("./telegram-cmd.js");
+        return telegramCommand(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') {
@@ -918,6 +960,11 @@ export async function main(argv, io = process, proc = process) {
     }
     // `dexterm wallet <link|unlink|status>` → link a Phantom wallet via the loopback bridge (keys never
     // enter dexterm; only the pubkey is stored), unlink it, or show the link + trade caps (task-1310 T1).
+    // task-1571: `dexterm live …` (the 0.1.7 local signer) was removed before release. dexterm holds no key.
+    if (argv[0] === 'live') {
+        io.stderr.write('dexterm live: not available. dexterm never holds a key and never signs; live trading happens in the Telegram trading bot of your choice (dexterm telegram setup sends alerts and run control to your chat)\n');
+        return 2;
+    }
     if (argv[0] === 'wallet') {
         const { runWallet } = await import("./wallet-cmd.js");
         return runWallet(argv.slice(1), io);
@@ -949,6 +996,11 @@ export async function main(argv, io = process, proc = process) {
         const { voiceCommand } = await import("./voice-cmd.js");
         return voiceCommand(argv.slice(1), { stdin: io.stdin, stdout: io.stdout, stderr: io.stderr, env: io.env });
     }
+    // task-1543: `dexterm ai …` (engine, local model, restriction profile, probe) and `dexterm ask` (a headless question).
+    if (argv[0] === 'ai' || argv[0] === 'ask') {
+        const { aiCommand } = await import("./ai-cmd.js");
+        return aiCommand(argv[0] === 'ask' ? ['ask', ...argv.slice(1)] : 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");
@@ -1044,9 +1096,8 @@ export async function main(argv, io = process, proc = process) {
                 });
                 ctx = new LiveContext(feed.dl, {
                     mode: 'live', dbPath: dbOpt, rpc: { provider: rpc.provider, basis: rpc.basis }, record: args.record ? feed.recording ?? undefined : undefined, interval: args.interval, fastEndpoints: fastLaneEndpoints(rpc), onLog: args.verbose ? (l) => io.stderr.write(l) : undefined, allowedSigners: join(dextermHome(io.env), 'allowed_signers'),
-                    // task-1328: LIVE trading is available in a real live run (never replay/offline); the signer
-                    // process starts lazily on the first LIVE action with exactly these flags.
-                    ...(args.live && !io.env.DEXTERM_OFFLINE ? { trade: { signerArgv: args.trade } } : {}),
+                    // The wallet link (public key only) is available in a real live run (never replay/offline).
+                    ...(!io.env.DEXTERM_OFFLINE ? { trade: {} } : {}),
                 });
                 // task-1329: the history recorder listens to the data layer's normaliser (zero requests of its own)
                 // and keeps snapshots / feed membership / outcome labels in the same --db file. Live mode only (a
@@ -1064,7 +1115,7 @@ export async function main(argv, io = process, proc = process) {
                     ctx.newpairs.onCreator = (mint, creator, source, createdAt) => { recorder.recordCreator(mint, creator, source, undefined, createdAt); };
                 }
                 if (args.verbose)
-                    io.stderr.write(`dexterm: rpc ${rpc.provider} (${rpc.basis}) · db ${dbPath} · recorder ${ctx.recorder ? 'on' : 'off'} · live trading ${args.live && !io.env.DEXTERM_OFFLINE ? 'available' : 'off'}\n`);
+                    io.stderr.write(`dexterm: rpc ${rpc.provider} (${rpc.basis}) · db ${dbPath} · recorder ${ctx.recorder ? 'on' : 'off'} · paper trading only (dexterm holds no key)\n`);
             }
             if (args.preset && !feed.setPreset(args.preset)) {
                 const v = feed.presets().find((p) => p.id === args.preset);
@@ -1126,7 +1177,11 @@ export async function main(argv, io = process, proc = process) {
         }
         for (const e of state.custom.themeErrors)
             io.stderr.write(`dexterm: ${e}\n`);
-        state.priceMode = args.priceMode ?? configPriceMode(state.custom.config); // task-1366: --price-mode wins for the run
+        if (args.priceMode)
+            io.env.DEXTERM_PRICE_BASIS = args.priceMode; // task-1537: the agents follow the run's basis
+        state.priceMode = args.priceMode ?? configPriceMode(state.custom.config, io.env); // task-1366: --price-mode wins for the run; task-1537: then --price/--mcap/env, config, mcap
+        state.chartAxis = configChartAxis(state.custom.config); // task-1472: default MARKET CAP, `A` toggles + saves
+        state.chartMarkers = configChartMarkers(state.custom.config); // task-1483: BUY/SELL markers on both charts (default on)
         if (args.workspace) {
             const r = switchWorkspace(state, args.workspace, []);
             if (!r.ok) {
@@ -1359,6 +1414,18 @@ function followsMove(state, delta) {
     state.copyUi.selected = Math.max(0, Math.min(n - 1, state.copyUi.selected + delta));
     return true;
 }
+// task-1508: open (or return to) the AUTOTRADE screen; the strategy list and the runner status are re-read each time.
+function openAutotrade(state, stack) {
+    if (state.screen !== 'autotrade')
+        stack.push(state.screen);
+    state.screen = 'autotrade';
+    if (!state.autotradeUi) {
+        state.autotradeUi = newAutotradeUi(autotradeDeps(process.env, autotradeWorkerJobs(process.env)));
+        return;
+    }
+    autotradeReload(state.autotradeUi);
+    autotradeRefreshRunner(state.autotradeUi);
+}
 // task-1358 Tier 3: j/k on the RULES screen move the cursor of the active pane (frozen while a rule is being typed).
 function rulesScreenMove(state, delta) {
     if (state.screen !== 'rules' || !state.rulesUi)
@@ -1369,7 +1436,7 @@ function rulesScreenMove(state, delta) {
 function plansMove(state, delta) {
     if (state.screen !== 'plans' || !state.plansUi)
         return false;
-    if (state.plansUi.arming || state.plansUi.riskModal || state.plansUi.liveModal)
+    if (state.plansUi.arming || state.plansUi.riskModal)
         return true;
     const n = plansRows(state).length;
     if (n <= 0) {
@@ -1415,6 +1482,14 @@ export function applyAction(state, action, stack) {
         }
         return null;
     };
+    // task-1508 AUTOTRADE (paper): `Q` opens the screen; while it is open it handles its own verbs and movement
+    // (esc on its strategies list falls through to the normal back). Nothing it does reaches live mode or the signer.
+    if (action === 'screen.autotrade') {
+        openAutotrade(state, stack);
+        return;
+    }
+    if (state.screen === 'autotrade' && state.autotradeUi && autotradeAction(state.autotradeUi, action))
+        return;
     switch (action) {
         case 'quit': return 'quit';
         case 'screen.screener':
@@ -2064,24 +2139,6 @@ export function applyAction(state, action, stack) {
             }
             break;
         }
-        case 'plans.live': {
-            // task-1363: raise the FIRE PATH modal (paper ⇄ live devnet fast wallet). Exactly like arm and gate this
-            // ONLY sets a modal flag; the switch itself happens in the interactive key loop on a captured physical
-            // keypress, and PlanService.useLive refuses any gesture but 'keypress' — so applyAction (a pipe, an
-            // agent, the voice router) can never move fills off paper.
-            if (state.screen !== 'plans')
-                break;
-            const svc = state.plansSvc;
-            if (!svc)
-                break;
-            if (state.plansUi) {
-                state.plansUi.arming = null;
-                state.plansUi.riskModal = false;
-                state.plansUi.liveModal = true;
-                state.plansUi.notice = null;
-            }
-            break;
-        }
         // task-1360 copy trading Tier 1: the FOLLOWED WALLETS screen. Opening it binds the follow store (+ the live
         // tracker when there is one). `follows.add` only opens the typed-address line (the loop captures the keys);
         // `follows.remove` unfollows the selected row. Nothing here trades, proposes or signs.
@@ -2471,6 +2528,9 @@ export function applyAction(state, action, stack) {
         case 'display.priceMode':
             state.pendingToast = togglePriceMode(state);
             break; // task-1366: display only, persisted
+        case 'display.chartAxis':
+            state.pendingToast = setChartAxis(state);
+            break; // task-1472: both charts' Y axis, display only, persisted
         case 'theme.next':
             state.theme = state.custom ? cycleTheme(state.custom, state.theme) : nextTheme(state.theme);
             break; // task-1358: user themes join the cycle
@@ -2634,6 +2694,7 @@ export function scanCommand(state, cmd, stack, now = Date.now()) {
             if (!e.start(now))
                 return `AI scan is already on (${MODE_LABEL[e.mode]})`;
             live.scanMeter = scanMeterOf(e, now);
+            scanLog(scan, now, 'start', '', `scan on · observe-only · locks at score ≥ ${e.cfg.minScore} · liquidity ≥ $${Math.round(e.cfg.minLiqUsd / 1000)}K`);
             return `AI scan ON · observe-only · warming up ${e.cfg.warmupS}s · locks at score ≥ ${e.cfg.minScore} · ai ≤ ${e.cfg.maxAiPerHour}/h · Z stop`;
         case 'off': {
             if (!e.on)
@@ -2641,6 +2702,7 @@ export function scanCommand(state, cmd, stack, now = Date.now()) {
             stopTurn();
             const was = e.lock?.symbol;
             e.stop(now);
+            scanLog(scan, now, 'stop', was ?? '', was ? 'scan stopped · released' : 'scan stopped');
             live.scanMeter = null;
             scan.returnTo = null;
             return `AI scan stopped${was ? ` (released ${sym(was)})` : ''}`;
@@ -2653,6 +2715,7 @@ export function scanCommand(state, cmd, stack, now = Date.now()) {
             const locked = e.lock;
             stopTurn();
             e.resume(now);
+            scanLog(scan, now, 'release', locked?.symbol ?? '', `released · cooling down ${Math.round(e.cfg.coinCooldownS / 60)}m · watching for the next coin`);
             live.scanMeter = scanMeterOf(e, now);
             // back from the coin the lock pulled up to where the user was, so the ticker is in view
             if (locked && state.screen === 'token' && live.token?.view.mint === locked.mint)
@@ -2686,11 +2749,12 @@ export function applyScanAnalystAction(state, raw) {
  * The analyst engine for a run (0.1.5): `--analyst-engine`, then DEXTERM_ANALYST_ENGINE, then config
  * `analyst.engine`, then auto (claude when installed, else codex). Only the user picks it; models cannot.
  */
-export function analystEngineFor(flag, env, configured, has = (b) => analystCliOnPath(b, env)) {
-    const choice = parseEngineChoice(flag) ?? parseEngineChoice(env.DEXTERM_ANALYST_ENGINE) ?? parseEngineChoice(configured) ?? 'auto';
+export function analystEngineFor(flag, env, configured, has = (b) => analystCliOnPath(b, env), aiChoice) {
+    // task-1543: ai.json (provider / surfaces.analyst / DEXTERM_AI_PROVIDER) comes after the analyst's own settings.
+    const choice = parseEngineChoice(flag) ?? parseEngineChoice(env.DEXTERM_ANALYST_ENGINE) ?? parseEngineChoice(configured) ?? parseEngineChoice(aiChoice) ?? 'auto';
     return resolveEngine(choice, has);
 }
-/** `/engine [auto|claude|codex]` in the chat box (0.1.5). Null when the input is not this command. */
+/** `/engine [auto|claude|codex|ollama]` in the chat box (0.1.5; ollama task-1543). Null when the input is not this command. */
 export function parseEngineCommand(q) {
     const m = /^\/engine(?:\s+(\S+))?\s*$/i.exec(q.trim());
     if (!m)
@@ -2698,23 +2762,24 @@ export function parseEngineCommand(q) {
     if (!m[1])
         return { show: true };
     const c = parseEngineChoice(m[1]);
-    return c ? { choice: c } : { error: `unknown analyst engine "${m[1].slice(0, 16)}" (use /engine auto|claude|codex)` };
+    return c ? { choice: c } : { error: `unknown analyst engine "${m[1].slice(0, 16)}" (use /engine auto|claude|codex|ollama)` };
 }
 /**
  * Apply `/engine`: switch the CLI for NEW conversations this run (cached per-coin chats are dropped so the next
  * `a` starts on the chosen engine; a running turn finishes where it started). Returns the line to show.
  */
-export function engineCommand(state, cmd, env, has = (b) => analystCliOnPath(b, env)) {
-    const installed = ['claude', 'codex'].filter((b) => has(b));
-    const list = installed.length ? installed.join(' + ') : 'neither claude nor codex';
+export function engineCommand(state, cmd, env, has = analystEngineHas(env)) {
+    const installed = ['claude', 'codex', 'ollama'].filter((b) => has(b));
+    const list = installed.length ? installed.join(' + ') : 'no AI engine yet';
     if ('error' in cmd)
         return cmd.error;
     const cur = state.analystEngine ?? 'claude';
     if ('show' in cmd)
-        return `analyst engine: ${cur} · installed: ${list} · /engine claude|codex|auto switches (config analyst.engine keeps it)`;
+        return `analyst engine: ${cur} · installed: ${list} · /engine claude|codex|ollama|auto switches (config analyst.engine keeps it)`;
     const next = resolveEngine(cmd.choice, has);
+    const how = next === 'codex' ? 'npm i -g @openai/codex && codex login' : next === 'ollama' ? 'install Ollama (https://ollama.com/download), `ollama pull qwen3:8b`, `dexterm ai engine ollama`' : 'install Claude Code, then run claude once to log in';
     if (cmd.choice !== 'auto' && !has(next))
-        return `${next} is not installed (installed: ${list}); ${next === 'codex' ? 'npm i -g @openai/codex && codex login' : 'install Claude Code, then run claude once to log in'}`;
+        return `${next} is not ${next === 'ollama' ? 'set up' : 'installed'} (installed: ${list}); ${how}`;
     if (next !== cur) {
         for (const [k, sess] of state.analystByMint ?? []) {
             if (!sess.busy)
@@ -2724,6 +2789,8 @@ export function engineCommand(state, cmd, env, has = (b) => analystCliOnPath(b,
             state.analyst = null;
     }
     state.analystEngine = next;
+    if (next === 'ollama')
+        return 'analyst engine: ollama (a local model on your own Ollama, $0) for new conversations · `dexterm ai engine ollama` keeps it';
     return `analyst engine: ${next} (your own ${next} CLI and login) for new conversations · set analyst.engine in config.json to keep it`;
 }
 /**
@@ -2739,7 +2806,7 @@ export function createScanSession(state, mint, symbol, hooks = {}, deps = {}) {
         const type = typeof raw.type === 'string' ? raw.type.replace(/[^a-z_]/gi, '').slice(0, 24) : '?';
         hooks.onBlocked?.(type, r.error ?? 'refused');
     };
-    return new AnalystSession({ skill: 'token-dossier', mint, symbol, screenState: ss, onAction, actionTypes: SCAN_ACTION_TYPES, scan: true, ...(state.analystEngine === 'codex' ? { engine: 'codex' } : {}) }, hooks.onChange ?? (() => { }), deps);
+    return new AnalystSession({ skill: 'token-dossier', mint, symbol, screenState: ss, onAction, actionTypes: SCAN_ACTION_TYPES, scan: true, ...(state.analystEngine && state.analystEngine !== 'claude' ? { engine: state.analystEngine } : {}) }, hooks.onChange ?? (() => { }), deps);
 }
 /**
  * Resolve a mint to an openable seed from what the app already knows (screener view → new pairs →
@@ -2995,6 +3062,61 @@ export function applyAnalystAction(state, raw, stack) {
     times.push(now);
     return { ok: true, label: res.label };
 }
+/**
+ * task-1466: the price this terminal itself shows for a coin, to mark the followed agent's open PAPER position (the
+ * HUD's live PnL): the open token's push price (LIVE) or polled price, else the screener row's price. null if the
+ * terminal has no price for it. Never the agent's own number.
+ */
+export function markPriceFor(state, mint) {
+    const live = state.live;
+    if (live?.token?.view.mint === mint) {
+        const px = (live.badgeFor(mint) === 'LIVE' ? live.livePrice(mint) : null) ?? live.token.view.price;
+        if (typeof px === 'number' && Number.isFinite(px) && px > 0)
+            return px;
+    }
+    const row = state.screener.rows.find((r) => r.mint === mint);
+    if (row && typeof row.price === 'number' && Number.isFinite(row.price) && row.price > 0)
+        return row.price;
+    // task-1473: the held coin scrolled out of the list (run25): its fast-lane push price (the held mint is pinned there)
+    const fast = live?.livePrice(mint) ?? null;
+    return typeof fast === 'number' && Number.isFinite(fast) && fast > 0 ? fast : null;
+}
+let ownOpenedMemo = null;
+/**
+ * task-1473 r2: the user's OWN held position for the AI-scan PnL chip, marked with this terminal's own price (same
+ * task-1323 position row the token screen uses): the scan's locked coin when held, else the open token, else the
+ * first open mint (live first). null when flat. Reads the ledgers only (memoised); never trades, sizes or signs.
+ */
+export function ownHeldSample(state, now) {
+    const live = state.live;
+    if (!live)
+        return null;
+    const src = live.positionSource;
+    const open = src.openMints();
+    if (open.length === 0)
+        return null;
+    const prefer = [state.scan?.engine.lock?.mint, live.token?.view.mint].filter((m) => !!m);
+    const mint = prefer.find((m) => open.includes(m)) ?? open[0];
+    const held = src.held(mint);
+    if (!held)
+        return null;
+    const r = positionRow(held, markPriceFor(state, mint), state.sol?.price ?? src.solUsd());
+    if (!ownOpenedMemo || ownOpenedMemo.mint !== mint || now - ownOpenedMemo.at > 5000) {
+        let t = null;
+        try {
+            t = currentPositionFills(live.wallet.trades(500).filter((x) => x.mint === mint))[0]?.t ?? null;
+        }
+        catch {
+            t = null;
+        }
+        ownOpenedMemo = { mint, at: now, t };
+    }
+    return {
+        mint, symbol: held.symbol, kind: 'paper',
+        entryUsd: r.avgEntryUsd, markUsd: r.priceUsd, pnlPct: r.unrealizedPct, pnlUsd: r.unrealizedUsd,
+        openedAt: ownOpenedMemo.t, targetUsd: r.targetUsd,
+    };
+}
 /**
  * task-1421: move the REAL terminal to mirror an agent's navigation (follow mode, on the owner's own
  * machine). This is the same VIEW-ONLY navigation the analyst / go-to path uses — open a token, switch
@@ -3243,7 +3365,7 @@ export function applyKey(state, key, stack) {
                     popups.push('plans');
                 const widgets = (p?.openWidgets?.() ?? []).map((w) => w.key); // task-1358 Tier 5: open pack widgets are saved by ref
                 const entry = saveWorkspace(ui, {
-                    name, screen: state.screen, theme: state.theme.name, intensity: state.vfx.intensity, priceMode: state.priceMode ?? 'price',
+                    name, screen: state.screen, theme: state.theme.name, intensity: state.vfx.intensity, priceMode: priceModeOf(state),
                     screener: { preset: sc.preset, filter: sc.query ?? null, sort: `${sc.sort.key}:${sc.sort.dir}` },
                     token: { tape: !!state.tokenTape, social: !!state.tokenSocial, analyst: state.aiOpen !== false },
                     popups, widgets,
@@ -3269,6 +3391,12 @@ export function applyKey(state, key, stack) {
     // task-1360: typing a wallet address on the FOLLOWED WALLETS screen captures every key until ⏎ / esc.
     // task-1358 Tier 3: typing a rule on the RULES screen captures every key until ⏎ / esc. Every keystroke re-runs the
     // dry-run ("would match N rows right now"); ⏎ parses + saves (never eval'd), a refusal is the notice.
+    // task-1508: the AUTOTRADE screen's typed lines (a strategy id, a file to import, a field value) and the flatten
+    // confirm capture every key until ⏎ / esc, so q and the screen keys never leak out of a half-typed value.
+    if (state.screen === 'autotrade' && state.autotradeUi && autotradeCapturing(state.autotradeUi)) {
+        autotradeKey(state.autotradeUi, key);
+        return;
+    }
     if (state.screen === 'rules' && state.rulesUi && state.rulesUi.input !== null) {
         const ui = state.rulesUi;
         const cur = state.rulesUi.input;
@@ -3607,8 +3735,8 @@ export function fpsFor(args, intensity) {
 const SYNC_ON = '\x1b[?2026h';
 const SYNC_OFF = '\x1b[?2026l';
 export function interactive(state, io, depth, args, proc = process) {
-    // 0.1.5: the analyst engine for new conversations (the user's own claude or codex CLI; never a shipped key).
-    state.analystEngine ??= analystEngineFor(args.analystEngine, io.env, state.custom?.config.analyst?.engine);
+    // 0.1.5: the analyst engine for new conversations (the user's own claude or codex CLI, or task-1543 a local Ollama model; never a shipped key).
+    state.analystEngine ??= analystEngineFor(args.analystEngine, io.env, state.custom?.config.analyst?.engine, analystEngineHas(io.env), analystAiChoice(io.env));
     const out = io.stdout;
     const inp = io.stdin;
     const rnd = mulberry32(99);
@@ -3912,6 +4040,7 @@ export function interactive(state, io, depth, args, proc = process) {
         // task-1421: the MCP follow session (set below when `--spectate-mcp` is on). Declared here so the quit /
         // terminal-guard teardown closures can stop it.
         let followSession = null;
+        let lastHudMark = null; // task-1466: the last terminal price that marked the agent's PAPER position
         // task-1443: `--agent-paper <mandate-id>` (with --spectate-mcp) lets that agent PAPER-trade inside the mandate.
         const agentPaper = args.spectateMcp && args.agentPaper ? new AgentPaperSwitch({ env: io.env, mandateId: args.agentPaper, db: args.db ?? defaultDbPath(io.env) }) : null;
         // Idle economy (task-1303, retuned for task-1319 AC3): between events the ambient rain redraws at
@@ -4033,7 +4162,7 @@ export function interactive(state, io, depth, args, proc = process) {
                 // task-1340: a send in flight shows the neutral scanning sweep (never a verdict); it clears when the ticket settles.
                 if (reason === 'ticket') {
                     const ph = live.ticket?.ticket.phase;
-                    if (ph === 'filling' || ph === 'signing') {
+                    if (ph === 'filling') {
                         if (v.moment?.kind !== 'inflight')
                             fireInflight(v, live.ticket?.ticket.symbol ?? '', ticketOrigin());
                     }
@@ -4142,13 +4271,20 @@ export function interactive(state, io, depth, args, proc = process) {
                     }
                     scheduleDraw();
                 },
-                onStatus: (line) => { say(line, 'ai', 4); scheduleDraw(); },
+                // task-1466: the HUD dock says what the agent did; the toast is only the fallback for a terminal too short for it.
+                onStatus: (line) => { if (size()[1] < HUD_MIN_H)
+                    say(line, 'ai', 4); scheduleDraw(); },
                 onEvent: () => scheduleDraw(),
                 onControl: agentPaper ? (st) => agentPaper.control(st) : undefined,
                 snapshot: () => followSnapshot(state),
+                thoughtsFile: args.spectateThoughts ?? undefined,
             });
+            // task-1466 spectator v2: the agent HUD (phase rail, heartbeat, thought ribbon, call timeline, the PAPER
+            // execution moment, pause / kill) draws over this terminal while it follows. Calm mode = reduced motion.
+            state.agentHud = { story: followSession.story, clock: () => Date.now(), dataLabel: args.replay ? 'REPLAY DATA' : null };
             void followSession.start();
-            say('following agents over MCP · ctrl+p pause · ctrl+k stop · any key takes over', 'ai', 6);
+            if (size()[1] < HUD_MIN_H)
+                say('following agents over MCP · ctrl+p pause · ctrl+k stop · any key takes over', 'ai', 6);
             if (agentPaper)
                 say(agentPaper.start(), 'ai', 8);
         }
@@ -4218,7 +4354,7 @@ export function interactive(state, io, depth, args, proc = process) {
                     maybeSpeakVoiceAnswer(session); // task-1282: speak a voice-initiated answer when it settles
                     scheduleDraw();
                 };
-                const session = new AnalystSession({ skill: p.skill, mint: p.mint, symbol: p.symbol, screenState: buildScreenState(state), model: p.model, onAction, ...(state.analystEngine === 'codex' ? { engine: 'codex' } : {}) }, onChange);
+                const session = new AnalystSession({ skill: p.skill, mint: p.mint, symbol: p.symbol, screenState: buildScreenState(state), model: p.model, onAction, ...(state.analystEngine && state.analystEngine !== 'claude' ? { engine: state.analystEngine } : {}) }, onChange);
                 if (p.question)
                     session.ask(p.question, buildScreenState(state));
                 else
@@ -4256,6 +4392,7 @@ export function interactive(state, io, depth, args, proc = process) {
                 scan.blocked.push(type);
                 if (scan.blocked.length > 6)
                     scan.blocked.shift();
+                scanLog(scan, Date.now(), 'blocked', scan.engine.lock?.symbol ?? '', `blocked analyst action "${type}" · observe-only`);
             }
             scanSay(`AI scan blocked analyst action "${type}" · observe-only (${error})`, 'warn', 5);
             scheduleDraw();
@@ -4287,6 +4424,7 @@ export function interactive(state, io, depth, args, proc = process) {
                 state.aiFocused = false;
                 state.aiScroll = 0;
                 state.aiRevealAll = false;
+                scanLog(scan, Date.now(), 'lock', d.symbol, `locked · score ${d.score} · ${d.hits.map((h) => h.reason).join(' · ')}`);
                 startScanSession(d.mint, d.symbol, d.question, `AI scan · score ${d.score} · ${d.hits.map((h) => h.id).join(' + ')} → short read`);
                 syncAnalyst(state);
                 live.syncFastSet();
@@ -4304,6 +4442,7 @@ export function interactive(state, io, depth, args, proc = process) {
             const sess = scan.session;
             if (!sess)
                 return;
+            scanLog(scan, Date.now(), 'refresh', d.symbol, `moved: ${d.moved.join(', ')} · refreshing the read`);
             sess.ask(d.question, scanScreenState(state, d.mint, d.symbol), `AI scan refresh · ${d.moved.join(' · ')}`);
             if (state.analyst === sess) {
                 state.aiScroll = 0;
@@ -4342,7 +4481,8 @@ export function interactive(state, io, depth, args, proc = process) {
                 return;
             if (scan.session?.busy)
                 scan.session.interrupt();
-            scan.engine.cancelAnalysis(Date.now());
+            if (scan.engine.cancelAnalysis(Date.now()))
+                scanLog(scan, Date.now(), 'cancel', scan.engine.lock?.symbol ?? '', 'analysis cancelled by you · coin held, nothing else locks');
             if (live)
                 live.scanMeter = scanMeterOf(scan.engine, Date.now());
             scanSay(`analysis cancelled · scan holds $${cleanText(scan.engine.lock?.symbol ?? '', 12)} · R resume scan · Z stop`, 'ai', 5);
@@ -4424,10 +4564,18 @@ export function interactive(state, io, depth, args, proc = process) {
                         livePrice: (mint) => (live.badgeFor(mint) === 'LIVE' ? live.livePrice(mint) : null),
                         feed: (mint) => (live.badgeFor(mint) === 'LIVE' ? 'LIVE' : 'POLL'),
                         positions: live.positionSource,
-                        fills: (mint) => [...(live.livePositions?.records(200, mint) ?? []), ...live.wallet.trades(500).filter((t) => t.mint === mint)],
+                        fills: (mint) => live.wallet.trades(500).filter((t) => t.mint === mint),
                         solUsd: () => state.sol?.price ?? live.positions.solUsd(),
                         imagePath: (v) => popupImagePath(state, v.image),
                         priceMode: () => priceModeOf(state), // task-1366
+                        chartAxis: () => chartAxisOf(state), // task-1472: the popup's Y axis
+                        setChartAxis: (a) => { say(setChartAxis(state, a), 'info', 3); if (!done)
+                            draw(); }, // task-1472: the popup's MCAP | PRICE control
+                        pnlChip: () => pnlChipFor(state, state.agentHud?.clock() ?? Date.now()), // task-1473 r2: the chip on the chart popup
+                        markFills: (mint) => live.chartFills.for(mint), // task-1483: BUY/SELL markers (the paper ledger, no fetch)
+                        chartMarkers: () => chartMarkersOn(state),
+                        setChartMarkers: (on) => { say(setChartMarkers(state, on ? 'on' : 'off'), 'info', 3); if (!done)
+                            draw(); }, // task-1483: the popup's MARKERS control
                     } : null,
                 });
             }
@@ -4691,7 +4839,7 @@ export function interactive(state, io, depth, args, proc = process) {
                 else {
                     try {
                         const s = seedForMint(state, live, tk.mint, tk.symbol);
-                        live.openTicket({ mint: s.mint, symbol: s.symbol, name: s.name }, tk.side, 'paper');
+                        live.openTicket({ mint: s.mint, symbol: s.symbol, name: s.name }, tk.side);
                         if (state.screen !== 'ticket')
                             stack.push(state.screen);
                         state.screen = 'ticket';
@@ -4935,7 +5083,7 @@ export function interactive(state, io, depth, args, proc = process) {
                         const res = resolveVoiceToken(d.target);
                         if (res.kind === 'ok' && live) {
                             const s = seedForMint(state, live, res.mint);
-                            live.openTicket({ mint: s.mint, symbol: s.symbol, name: s.name }, d.side, 'paper');
+                            live.openTicket({ mint: s.mint, symbol: s.symbol, name: s.name }, d.side);
                             if (state.screen !== 'ticket')
                                 stack.push(state.screen);
                             state.screen = 'ticket';
@@ -5250,7 +5398,9 @@ export function interactive(state, io, depth, args, proc = process) {
                 // 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.
-                if (state.goto) {
+                // task-1508: the AUTOTRADE screen's typed lines (an id, a file, a field value) and its flatten confirm own the
+                // keyboard the same way, so v / m / c / n / d / x type instead of toggling voice, calm or a demo event.
+                if (state.goto || (state.screen === 'autotrade' && state.autotradeUi && autotradeCapturing(state.autotradeUi))) {
                     const before = state.screen;
                     try {
                         applyKey(state, key, stack);
@@ -5480,33 +5630,10 @@ export function interactive(state, io, depth, args, proc = process) {
                     }
                     // else: fall through to the keymap (quit/navigation remain responsive while filling)
                 }
-                // task-1328 LIVE: while the signer builds the plan, esc cancels; while Phantom has the plan
-                // (signing) no key does anything — the signer finishes or times out, and nothing here can
-                // confirm, so navigation keys still fall through to the keymap.
-                if (state.screen === 'ticket' && live?.ticket && live.ticket.ticket.phase === 'planning') {
-                    if (key.name === 'esc') {
-                        live.ticket.cancelPlan();
-                        draw();
-                        continue;
-                    }
-                    // task-1368: while Jupiter is rate limiting the signer the ticket waits and retries by itself; r retries now.
-                    if (key.name === 'char' && (key.ch === 'r' || key.ch === 'R') && !key.ctrl && !key.alt) {
-                        live.ticket.retryPlan();
-                        draw();
-                        continue;
-                    }
-                }
-                if (state.screen === 'ticket' && live?.ticket && live.ticket.ticket.phase === 'signing') {
-                    if (key.name === 'esc') {
-                        state.pendingToast = 'waiting for Phantom — approve or reject it in the browser';
-                        draw();
-                        continue;
-                    }
-                }
                 // PAPER trade ticket (task-1310): the ticket captures every key (digits/y/esc/tab/…) so the
                 // confirm gate can never be satisfied by a stray key, and `q`/`1`-`4` cannot quit or navigate
                 // out from under a half-typed order. `filling` is handled above so the user is never trapped.
-                const ticketActive = state.screen === 'ticket' && live?.ticket && live.ticket.ticket.phase !== 'filled' && live.ticket.ticket.phase !== 'error' && live.ticket.ticket.phase !== 'refused' && live.ticket.ticket.phase !== 'filling' && live.ticket.ticket.phase !== 'planning' && live.ticket.ticket.phase !== 'signing';
+                const ticketActive = state.screen === 'ticket' && live?.ticket && live.ticket.ticket.phase !== 'filled' && live.ticket.ticket.phase !== 'error' && live.ticket.ticket.phase !== 'filling';
                 if (ticketActive && live?.ticket) {
                     let eff;
                     try {
@@ -5612,79 +5739,6 @@ export function interactive(state, io, depth, args, proc = process) {
                 // 'keypress'}) — which the engine takes ONLY from a real keypress, journals, and auto-expires in 24h;
                 // restoreGate() puts it back. There is no path here for a pipe/agent (TTY-only loop, no way to raise
                 // the modal except a person pressing G), and signer caps/allow-lists/panic are unaffected either way.
-                // task-1363 — the FIRE PATH modal: paper ⇄ LIVE (devnet, the capped fast wallet). Same captured-keypress
-                // discipline as arm/gate: enter/y switches, esc cancels, every other key is swallowed. Going LIVE needs
-                // the run's signer process (never started in replay/offline/--no-live), the signer on DEVNET with a fast
-                // wallet loaded (checked by LivePlanExecutor.ready), and no armed/filled plans; PlanService.useLive
-                // takes ONLY a keypress gesture and journals the switch. Nothing here signs: fills still go through the
-                // signer's own policy, simulation and caps, and the fast wallet never signs for the main wallet.
-                if (state.screen === 'plans' && state.plansUi?.liveModal) {
-                    const ui = state.plansUi;
-                    if (key.name === 'esc') {
-                        ui.liveModal = false;
-                        ui.notice = 'fire path unchanged';
-                        draw();
-                        continue;
-                    }
-                    const confirmKey = key.name === 'enter' || (key.name === 'char' && !key.ctrl && !key.alt && (key.ch === 'y' || key.ch === 'Y'));
-                    if (confirmKey) {
-                        const svc = state.plansSvc;
-                        ui.liveModal = false;
-                        if (!svc) {
-                            ui.notice = 'no plan service';
-                            draw();
-                            continue;
-                        }
-                        if (svc.mode() === 'live') {
-                            try {
-                                svc.usePaper();
-                                ui.notice = 'fire path: PAPER — fills are simulated again';
-                            }
-                            catch (e) {
-                                ui.notice = `switch refused: ${describeError(e)}`;
-                            }
-                            draw();
-                            continue;
-                        }
-                        const port = live?.ensureSigner() ?? null;
-                        if (!port) {
-                            ui.notice = 'LIVE fills need the signer process: start dexterm live (not replay/offline/--no-live)';
-                            draw();
-                            continue;
-                        }
-                        if (svc.engine.openPlans().length) {
-                            ui.notice = `switch refused: cancel or finish ${svc.engine.openPlans().length} open plan(s) first`;
-                            draw();
-                            continue;
-                        }
-                        const ex = new LivePlanExecutor({ signer: port, clock: { now: () => Date.now(), sleep: (ms) => new Promise((r) => setTimeout(r, ms)) }, solUsd: () => state.sol?.price ?? live?.positions.solUsd() ?? null, onChange: () => { if (!done) {
-                                plansTick();
-                                draw();
-                            } }, log: (l) => args.verbose && io.stderr.write(`  plans-live    ${l}\n`) });
-                        ui.notice = 'checking the signer and the fast wallet…';
-                        void ex.ready().then((r) => {
-                            if (done)
-                                return;
-                            if (!r.ok) {
-                                ui.notice = `LIVE refused: ${r.why}`;
-                                draw();
-                                return;
-                            }
-                            try {
-                                svc.useLive(ex, { gesture: 'keypress' });
-                                ui.notice = `fire path: ${ex.describe(r.fastWallet)} · balance ${r.balanceLamports === null ? '?' : (Number(r.balanceLamports) / 1e9).toFixed(4)} SOL · L again for paper`;
-                            }
-                            catch (e) {
-                                ui.notice = `switch refused: ${describeError(e)}`;
-                            }
-                            draw();
-                        });
-                        draw();
-                        continue;
-                    }
-                    draw();
-                    continue;
-                }
                 if (state.screen === 'plans' && state.plansUi?.riskModal) {
                     const ui = state.plansUi;
                     if (key.name === 'esc') {
@@ -5741,7 +5795,7 @@ export function interactive(state, io, depth, args, proc = process) {
                             draw();
                             continue;
                         }
-                        // 0.1.5: `/engine [auto|claude|codex]` switches the analyst CLI for new conversations; never sent to a model.
+                        // 0.1.5: `/engine [auto|claude|codex|ollama]` switches the analyst engine for new conversations; never sent to a model.
                         const en0 = q.startsWith('/') ? parseEngineCommand(q) : null;
                         if (en0) {
                             state.aiInput = '';
@@ -5749,6 +5803,14 @@ export function interactive(state, io, depth, args, proc = process) {
                             draw();
                             continue;
                         }
+                        // task-1537: `/display mcap|price` (also `/basis …`, `/set basis …`) sets the price basis; never sent to a model.
+                        const dc0 = q.startsWith('/') ? parseDisplayCommand(q) : null;
+                        if (dc0) {
+                            state.aiInput = '';
+                            say('error' in dc0 ? dc0.error : 'mode' in dc0 ? setPriceMode(state, dc0.mode, '/display') : priceModeNotice(state), 'error' in dc0 ? 'warn' : 'info', 6);
+                            draw();
+                            continue;
+                        }
                         // task-1324: `/scan …` in the chat input is a command, never sent to claude.
                         const sc0 = q.startsWith('/') ? parseScanCommand(q) : null;
                         if (sc0) {
@@ -5909,7 +5971,8 @@ export function interactive(state, io, depth, args, proc = process) {
                 const sc = state.screener;
                 const editing = state.screen === 'screener' && sc.mode !== 'table';
                 const plain = key.name === 'char' && !key.ctrl && !key.alt && key.ch !== undefined;
-                if (!editing && plain && key.ch === 'c') {
+                // task-1508: on the AUTOTRADE screen `c` marks strategies to compare (calm stays reachable from any other screen).
+                if (!editing && plain && key.ch === 'c' && state.screen !== 'autotrade') {
                     // calm toggle: off ↔ the last active tier
                     if (isCalm(v)) {
                         v.intensity = lastIntensity;
@@ -5923,7 +5986,7 @@ export function interactive(state, io, depth, args, proc = process) {
                     flusher.invalidate();
                     continue;
                 }
-                if (!editing && plain && sc.source === 'fixtures' && Object.hasOwn(DEMO_KEYS, key.ch)) {
+                if (!editing && plain && sc.source === 'fixtures' && state.screen !== 'autotrade' && Object.hasOwn(DEMO_KEYS, key.ch)) {
                     const kind = DEMO_KEYS[key.ch];
                     try {
                         const text = demoEvent(state, kind, rnd);
@@ -5992,7 +6055,7 @@ export function interactive(state, io, depth, args, proc = process) {
             if (state.screen === 'plans')
                 syncPlansPopup(); // arm / cancel / tick status changes reach the popup
             syncWidgets(); // task-1358 Tier 5: open pack widgets follow the terminal (throttled per widget + topic)
-            // task-1328: `/wallet …` — performed here because link opens a browser and probe opens a LIVE ticket.
+            // task-1328: `/wallet …` — performed here because link opens a browser.
             if (state.pendingWallet) {
                 const wc = state.pendingWallet;
                 state.pendingWallet = null;
@@ -6004,12 +6067,6 @@ export function interactive(state, io, depth, args, proc = process) {
                     void live.walletCommand(wc).then((line) => {
                         if (done)
                             return;
-                        if (wc === 'probe' && live.ticket && live.ticket.ticket.mode === 'live') {
-                            if (state.screen !== 'ticket') {
-                                stack.push(state.screen);
-                                state.screen = 'ticket';
-                            }
-                        }
                         say(line, wc === 'panic' ? 'warn' : 'info', 8);
                         scheduleDraw();
                     }).catch((e) => { say(`wallet ${wc} failed: ${describeError(e)}`, 'warn', 6); scheduleDraw(); });
@@ -6112,6 +6169,9 @@ export function interactive(state, io, depth, args, proc = process) {
                         say(state.updateNotice, 'info', 8);
                         state.updateNotice = null;
                     }
+                    // task-1508: the autotrade screen re-reads the paper runner's status file every 2 s while it is open.
+                    if (state.screen === 'autotrade' && state.autotradeUi)
+                        autotradeTick(state.autotradeUi);
                     if (feed) {
                         if (!state.paused && Date.now() - lastRefresh >= LIVE_REFRESH_MS)
                             refresh();
@@ -6199,6 +6259,36 @@ export function interactive(state, io, depth, args, proc = process) {
                     }
                     // market → rain: EMA on activity every tick, mood from the data every 4 s unless an event holds it
                     blendActivity(v, activityFor(state), v.frame % (tickEvery * 8) === 0 && v.frame >= moodHoldUntil);
+                    // task-1466: the agent's open PAPER position is marked with this terminal's own live price (the HUD's PnL).
+                    // Only a NEW price marks (a 10 s-old view price must not overwrite a fresher one a tool result carried).
+                    if (followSession && state.live && state.live.heldMint !== followSession.story.heldMint) {
+                        state.live.heldMint = followSession.story.heldMint;
+                        state.live.syncFastSet();
+                    } // task-1473
+                    if (followSession) {
+                        const held = followSession.story.heldMint;
+                        const px = held ? markPriceFor(state, held) : null;
+                        if (held && px !== null && px !== lastHudMark) {
+                            followSession.story.mark(held, px, Date.now());
+                            lastHudMark = px;
+                        }
+                    }
+                    // task-1473 r2: AI scan mode + the user's OWN held position → the PnL chip (band row, dock, chart popup)
+                    if (state.scan?.engine.on && state.live) {
+                        state.ownPnl ??= new OwnPnlTracker();
+                        state.ownPnl.update(ownHeldSample(state, Date.now()), Date.now());
+                        if (!followSession && state.live.heldMint !== state.ownPnl.mint) {
+                            state.live.heldMint = state.ownPnl.mint;
+                            state.live.syncFastSet();
+                        } // run25: pin it
+                    }
+                    else if (state.ownPnl?.mint) {
+                        state.ownPnl.update(null, 0);
+                        if (!followSession && state.live?.heldMint) {
+                            state.live.heldMint = null;
+                            state.live.syncFastSet();
+                        }
+                    }
                 }
                 if (state.ai && state.ai.phase === 'thinking') {
                     state.ai.ticks += 1;
@@ -6228,6 +6318,7 @@ export function interactive(state, io, depth, args, proc = process) {
                 aiLive: !!(state.ai && state.ai.phase !== 'done'),
                 awake: v.frame < wakeUntil,
                 fxBusy: fxBusy(v),
+                hud: followSession !== null && hudAnimating(followSession.story.view(Date.now()), Date.now()),
                 frame: v.frame,
                 idleEvery,
             }))