dexterm-cli 0.1.6 → 0.2.0

package/dist/packages/cli/src/autotrade-cmd.js

@@ -0,0 +1,214 @@
+// `dexterm autotrade <sub>` (task-1503 AT-1, AUTOTRADE-SPEC). No keys, no wallet, no signer: paper, or real mode
+// (task-1645: trade-fire signals to the user's own executor, `signal` / `receipt` rows).
+//
+// A dispatcher table: each subcommand is one row that lazy-loads its own module under ./autotrade-cmd/, so
+// later cards add a row (run, service, stop, flatten, audit) without editing anyone else's lines.
+// `dexterm backtest --subject strategy …` is routed here too (the strategy subject runs on this engine).
+export const SUBCOMMANDS = {
+    list: {
+        usage: 'dexterm autotrade list [--json]',
+        summary: 'your strategies (~/.dexterm/strategies) and the shipped presets: version, hash, mode, profiles, last backtest',
+        load: () => import("./autotrade-cmd/strategies.js").then((m) => m.listCmd),
+    },
+    validate: {
+        usage: 'dexterm autotrade validate <id|file> [--json]',
+        summary: 'check a strategy file or a stored strategy; every problem is printed with its path',
+        load: () => import("./autotrade-cmd/strategies.js").then((m) => m.validateCmd),
+    },
+    new: {
+        usage: 'dexterm autotrade new <new-id> --from <preset|id> [--name TEXT]',
+        summary: 'copy a preset (or one of your strategies) into ~/.dexterm/strategies/<new-id>.json to edit',
+        load: () => import("./autotrade-cmd/strategies.js").then((m) => m.newCmd),
+    },
+    import: {
+        usage: 'dexterm autotrade import <file> [--replace]',
+        summary: 'validate a strategy file and store it (mode is forced to paper; --replace needs a higher version)',
+        load: () => import("./autotrade-cmd/strategies.js").then((m) => m.importCmd),
+    },
+    remove: {
+        usage: 'dexterm autotrade remove <id>',
+        summary: 'move one of your strategies to ~/.dexterm/strategies/.removed/ (journaled; presets cannot be removed)',
+        load: () => import("./autotrade-cmd/strategies.js").then((m) => m.removeCmd),
+    },
+    journal: {
+        usage: 'dexterm autotrade journal [<id>] [--json]',
+        summary: 'the append-only change journal: who changed what, with the before and after hashes',
+        load: () => import("./autotrade-cmd/strategies.js").then((m) => m.journalCmd),
+    },
+    backtest: {
+        usage: 'dexterm autotrade backtest <id|file> [--tape FILE | --db PATH [--days N | --since T] [--until T]] [--every-candidate [--unit-usd 20]] [--recall 5,10] [--json]',
+        summary: 'replay a strategy over recorded history with modelled fills (paper); the limits of the data are always printed',
+        load: () => import("./autotrade-cmd/backtest.js").then((m) => m.backtestCmd),
+    },
+    sweep: {
+        usage: 'dexterm autotrade sweep <id|file> [--tape FILE | --db PATH] [--grid JSON] [--mode grid|random] [--max N] [--seed N] [--json]',
+        summary: 'tune on the older coins, check once on the newest 30% it never saw; no gain wording without enough trades and a held-out profit',
+        load: () => import("./autotrade-cmd/backtest.js").then((m) => m.sweepCmd),
+    },
+    'yolo-replay': {
+        usage: 'dexterm autotrade yolo-replay <id|file> [--tape FILE | --db PATH [--days N | --since T] [--until T]] [--seed N] [--json]',
+        summary: 'HIGH RISK check before arming a full-port strategy: replay it at 100% of the book over recorded history (paper): rugs, the loss spread, how often it zeroed the wallet',
+        load: () => import("./autotrade-cmd/backtest.js").then((m) => m.yoloReplayCmd),
+    },
+    requests: {
+        usage: 'dexterm autotrade requests [list [--all] [--json] | run <br_id> | dismiss <br_id>]',
+        summary: 'backtests an agent asked for over MCP (backtest_request): nothing runs until you run one here (paper, recorded data)',
+        load: () => import("./autotrade-cmd/requests.js").then((m) => m.requestsCmd),
+    },
+    run: {
+        usage: 'dexterm autotrade run <id|file> --paper|--real [--replay TAPE [--ms-per-tick 2000]] [--model M] [--max-minutes N] [--sol-usd N] [--stub] [--raw] [--quiet] [--no-telegram]',
+        summary: 'the runner: the screener hands each candidate to your own Claude (runner.json picks the account), every size clamped; ledger in autotrade/runs/; your paired Telegram bot starts with it (dexterm telegram setup). --real (a strategy you armed with signal arm) runs in the FOREGROUND only, on live data: the always-on service runs paper strategies, and while no real run is running NO signal goes out, sells included',
+        load: () => import("./autotrade-cmd/run.js").then((m) => m.runCmd),
+    },
+    'run --all': {
+        usage: 'dexterm autotrade run --all --paper [--config FILE] [--replay TAPE] [--sol-usd N] [--stub] [--max-minutes N]',
+        summary: 'every strategy of autotrade/autotrade.json at once on one data feed: each its own bankroll, ledger, caps and budget, under global caps',
+        load: () => import("./autotrade-cmd/fleet.js").then((m) => m.fleetRunCmd),
+    },
+    status: {
+        usage: 'dexterm autotrade status [--all] [--json]',
+        summary: 'the paper runner now; --all: every strategy of a parallel run side by side (P/L, win rate, rug exposure, missed runners, spend per entry)',
+        load: () => import("./autotrade-cmd/strategy-control.js").then((m) => m.statusCmd),
+    },
+    start: {
+        usage: 'dexterm autotrade start <strategy> [--wait SEC] [--json]',
+        summary: 'start one strategy of autotrade.json inside the running `run --all` (paper, its own book and caps)',
+        load: () => import("./autotrade-cmd/strategy-control.js").then((m) => m.startCmd),
+    },
+    pause: {
+        usage: 'dexterm autotrade pause [--strategy ID] [--json]',
+        summary: 'no new entries (every strategy, or just one with --strategy); open positions keep their exits',
+        load: () => import("./autotrade-cmd/strategy-control.js").then((m) => m.pauseCmd),
+    },
+    resume: {
+        usage: 'dexterm autotrade resume [--strategy ID] [--json]',
+        summary: 'lift a pause (every strategy, or just one with --strategy); a stop is final and is never lifted',
+        load: () => import("./autotrade-cmd/strategy-control.js").then((m) => m.resumeCmd),
+    },
+    stop: {
+        usage: 'dexterm autotrade stop [--strategy ID] [--wait SEC] [--json]',
+        summary: 'soft-stop the paper runner: no new entries, sessions closed, orders dropped; mechanical exits keep running until nothing is held',
+        load: () => import("./autotrade-cmd/stop.js").then((m) => m.stopCmd),
+    },
+    flatten: {
+        usage: 'dexterm autotrade flatten [--strategy ID] [--yes] [--wait SEC] [--json]',
+        summary: 'stop, then sell every paper position at its next tick (confirm with y on a terminal, or --yes)',
+        load: () => import("./autotrade-cmd/flatten.js").then((m) => m.flattenCmd),
+    },
+    audit: {
+        usage: 'dexterm autotrade audit [<run-id>|--last] [--verify] [--json]',
+        summary: 'list the run ledgers; --verify recomputes each hash chain and names the first edited, missing or reordered event',
+        load: () => import("./autotrade-cmd/audit.js").then((m) => m.auditCmd),
+    },
+    signal: {
+        usage: 'dexterm autotrade signal status|channels|secret|arm|disarm|caps|kill|unkill|held|release|test|flush|tail|reconcile …',
+        summary: 'real mode: a LIVE TRADE FIRE signal per trade to YOUR executor (webhook, --signal-cmd, JSONL, MCP, Telegram copy); arm on your own terminal; hard caps, kill switch; dexterm holds no key',
+        load: () => import("./autotrade-cmd/signal.js").then((m) => m.signalCmd),
+    },
+    receipt: {
+        usage: 'dexterm autotrade receipt <nonce|id> executed|rejected|failed [--price USD] [--size-sol N] [--tokens N] [--tx SIG] [--reason TEXT] | receipt list [--json]',
+        summary: 'what your executor did with a trade-fire signal, as data only (positions stay unconfirmed until a receipt); the drift between signals and fills',
+        load: () => import("./autotrade-cmd/receipt.js").then((m) => m.receiptCmd),
+    },
+    service: {
+        usage: 'dexterm autotrade service install|uninstall|ensure|run|start|stop|status|logs [--home PATH]',
+        summary: 'the always-on service: your PAPER strategies (autotrade.json) start at login, restart after a crash, stop on any kill switch and tell you when they cannot run; real mode does not run under it (run --real, in the foreground)',
+        load: () => import("./autotrade-cmd/service.js").then((m) => m.serviceCmd),
+    },
+    forward: {
+        usage: 'dexterm autotrade forward start <id> [--hours H] [--trades N] [--bankroll-usd N] | status [<id>] | stop <id> | report <id> [--json]',
+        summary: 'forward test: the strategy on the LIVE tape, on paper, own bankroll and run file, for hours or N trades; the report sets it next to its backtest',
+        load: () => import("./autotrade-cmd/forward.js").then((m) => m.forwardCmd),
+    },
+    journey: {
+        usage: 'dexterm autotrade journey [<id>] [--json]',
+        summary: 'where a strategy stands on the ladder draft → backtested → forward-tested → always-on → real, and what the next rung needs',
+        load: () => import("./autotrade-cmd/journey.js").then((m) => m.journeyCmd),
+    },
+    promote: {
+        usage: 'dexterm autotrade promote <id> --to always-on|real | list | show <pp-id> | apply <pp-id> | dismiss <pp-id>',
+        summary: 'a promotion with its evidence card: always-on needs your y on a real terminal; real needs the evidence floor (a completed forward test with minForwardTrades closed paper trades + a backtest) and hands over to signal arm (your caps, a typed phrase); no rung is skipped',
+        load: () => import("./autotrade-cmd/journey.js").then((m) => m.promoteCmd),
+    },
+    limits: {
+        usage: 'dexterm autotrade limits show|set|diff|reset|accept|breaker reset|explain|schema …',
+        summary: 'real mode: every limit is yours (per trade SOL or % of book, per day, open positions, exposure, loss limits, breaker, rate, slippage, TTL, executor silence), global / per mode / per strategy / per account, the stricter wins; raising is typed on your own terminal',
+        load: () => import("./autotrade-cmd/limits.js").then((m) => m.limitsCmd),
+    },
+    executor: {
+        usage: 'dexterm autotrade executor status [--json] | heartbeat [--name N] [--account ID] [--dry-run] [--nonce N] | kit --out DIR',
+        summary: 'real mode: is YOUR executor alive (heartbeat, last receipt, lag)? A silent executor pauses new buy signals; `kit --out DIR` copies the dry-run reference executors (webhook, signal-cmd, JSONL tail)',
+        load: () => import("./autotrade-cmd/executor.js").then((m) => m.executorCmd),
+    },
+    report: {
+        usage: 'dexterm autotrade report [--period day|week] [--strategy ID] [--json] [--telegram]',
+        summary: 'the digest per strategy and mode: trades, win rate with its interval, net, drawdown, refusals, limits hit, executor health, paper vs real fills, an honest small-sample note',
+        load: () => import("./autotrade-cmd/report.js").then((m) => m.reportCmd),
+    },
+    extract: {
+        usage: 'dexterm autotrade extract --out FILE [--db PATH] [--max-mints N] [--min-peak-liq USD] [--span-hours H]',
+        summary: 'save a replay tape from your recorder history (read-only) to a file you can backtest offline',
+        load: () => import("./autotrade-cmd/backtest.js").then((m) => m.extractCmd),
+    },
+};
+export function autotradeHelp() {
+    return [
+        'dexterm autotrade: strategies, backtests and the runner. PAPER by default; mode real sends a LIVE TRADE FIRE signal per trade to YOUR executor (`signal arm`, on your own terminal; dexterm holds no key). Not financial advice.',
+        '',
+        ...Object.values(SUBCOMMANDS).map((s) => `  ${s.usage}\n      ${s.summary}`),
+        '',
+        '  Strategies live in $DEXTERM_HOME/strategies (default ~/.dexterm/strategies), one JSON file each, with an',
+        '  append-only .journal.jsonl. Presets: scalp, swing, runner, moonbag, sample-dip-ladder, yolo (HIGH RISK) (read-only; copy one with `new`).',
+        '  `dexterm backtest --subject strategy --strategy <id|file>` runs the same backtest.',
+    ].join('\n') + '\n';
+}
+/** The value of `--subject` (or `--subject=x`) in an argv, if any. */
+function subjectOf(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '--subject')
+            return argv[i + 1];
+        if (argv[i].startsWith('--subject='))
+            return argv[i].slice('--subject='.length);
+    }
+    return undefined;
+}
+/** True for `dexterm autotrade …` and `dexterm backtest --subject strategy …`. */
+export function handles(argv) {
+    return argv[0] === 'autotrade' || (argv[0] === 'backtest' && subjectOf(argv) === 'strategy');
+}
+export async function autotradeCommand(argv, io) {
+    let rest;
+    if (argv[0] === 'backtest') {
+        // `dexterm backtest --subject strategy [--strategy X] …` → `dexterm autotrade backtest [X] …`
+        rest = ['backtest'];
+        for (let i = 1; i < argv.length; i++) {
+            if (argv[i] === '--subject') {
+                i++;
+                continue;
+            }
+            if (argv[i].startsWith('--subject='))
+                continue;
+            rest.push(argv[i]);
+        }
+    }
+    else
+        rest = argv.slice(1);
+    const sub = rest[0];
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        io.stdout.write(autotradeHelp());
+        return 0;
+    }
+    // `run --all` has its own row (parallel strategies, task-1529) so its --help shows its own flags.
+    const key = sub === 'run' && rest.includes('--all') ? 'run --all' : sub;
+    const row = Object.hasOwn(SUBCOMMANDS, key) ? SUBCOMMANDS[key] : undefined;
+    if (!row) {
+        io.stderr.write(`dexterm autotrade: unknown subcommand ${JSON.stringify(sub)}\n\n${autotradeHelp()}`);
+        return 2;
+    }
+    if (rest.includes('--help') || rest.includes('-h')) {
+        io.stdout.write(`${row.usage}\n  ${row.summary}\n`);
+        return 0;
+    }
+    const fn = await row.load();
+    return fn(rest.slice(1), io);
+}

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

@@ -9,8 +9,9 @@
 //
 // No network calls, nothing here is read by the signer, the caps, tickets, plans or the confirm gate.
 import { fmtMcap, fmtCompact, fmtPrice } from '../../tui/src/index.js';
-import { applyAndJournal, configPath, dextermHome, loadConfig, DEFAULT_PRICE_MODE, PRICE_MODES, CHART_AXES, DEFAULT_CHART_AXIS } from '../../custom/src/index.js';
-export { PRICE_MODES, DEFAULT_PRICE_MODE, CHART_AXES, DEFAULT_CHART_AXIS };
+import { applyAndJournal, configPath, dextermHome, loadConfig, DEFAULT_PRICE_MODE, PRICE_MODES, CHART_AXES, DEFAULT_CHART_AXIS, CHART_MARKERS, DEFAULT_CHART_MARKERS } from '../../custom/src/index.js';
+import { knownSupply, pickBasis, PRICE_BASIS_ENV } from '../../data/src/basis.js';
+export { PRICE_MODES, DEFAULT_PRICE_MODE, CHART_AXES, DEFAULT_CHART_AXIS, CHART_MARKERS, DEFAULT_CHART_MARKERS };
 /** Axis / caption label for an mcap chart: the history is scaled by today's supply, and says so. */
 export const MCAP_AXIS_LABEL = 'mcap (current supply)';
 /** Shown wherever mcap mode is on but a token's supply is unknown, so the number on screen is a price. */
@@ -142,29 +143,65 @@ export function positionPriceCells(mode, supply, avgUsd, priceUsd, avgText, pric
     const mark = mode === 'mcap' ? FALLBACK_MARK : '';
     return { avg: { label: 'AVG ENTRY', value: avgText === '—' ? avgText : avgText + mark }, price: { label: 'PRICE', value: priceText === '—' ? priceText : priceText + mark } };
 }
-/** The mode in effect: the state's (set from config, a workspace or `$`), default price. */
+/**
+ * task-1537: the known supply for a coin the app is showing: the open token view's (mcap ÷ price at its latest tick),
+ * else its screener row's, else pump.fun's fixed 1B (the PnL card's rule, @dexterm/data/basis knownSupply). Never
+ * guessed: null means the caller shows the price and marks it.
+ */
+export function supplyForMint(state, mint) {
+    if (!mint)
+        return null;
+    const v = state.live?.token?.view;
+    if (v && v.mint === mint) {
+        const r = supplyRatio(v.price, v.mcap);
+        if (r !== null)
+            return r;
+    }
+    const row = state.screener?.rows.find((x) => x.mint === mint);
+    if (row) {
+        const r = supplyRatio(row.price, row.mcap);
+        if (r !== null)
+            return r;
+    }
+    return knownSupply({ mint, launchpad: row?.launchpad ?? (v && v.mint === mint ? v.launchpad : null) })?.tokens ?? null;
+}
+/**
+ * task-1537: one more price LEVEL in a row (a stop, a target, a fill, a tape trade): its market cap at the given supply
+ * in mcap mode, else the price (marked ᵖ when mcap mode had no supply). Display only.
+ */
+export function levelCell(mode, supply, usd) {
+    if (usd === null || usd === undefined || !Number.isFinite(usd))
+        return '—';
+    if (mode === 'mcap' && supply != null && supply > 0)
+        return fmtMcap(usd * supply);
+    return fmtPrice(usd) + (mode === 'mcap' ? FALLBACK_MARK : '');
+}
+/** The mode in effect: the state's (set from config, a workspace, `$` or a one-run override), default MARKET CAP (task-1537). */
 export function priceModeOf(state) {
-    return state?.priceMode === 'mcap' ? 'mcap' : 'price';
+    return state?.priceMode === 'price' ? 'price' : 'mcap';
 }
-/** The mode a run starts in: config.display.priceMode, else price. */
-export function configPriceMode(cfg) {
-    const m = cfg?.display?.priceMode;
-    return isPriceMode(m) ? m : DEFAULT_PRICE_MODE;
+/**
+ * The mode a run starts in: the one-run override (`DEXTERM_PRICE_BASIS=price|mcap`, which `--price` / `--mcap` /
+ * `--price-mode` also set), else config.display.priceMode, else market cap (task-1537: @dexterm/data/basis pickBasis).
+ */
+export function configPriceMode(cfg, env) {
+    return pickBasis(cfg?.display?.priceMode, env);
 }
 /**
- * `$`: flip the mode and persist it to config.display.priceMode through the journal (actor user, so `undo` works).
- * Returns the notice for the toast. Persistence failure keeps the new mode for this run and says why.
+ * `$` (and `/display mcap|price` in the chat box, task-1537): set the mode (`next` absent = flip) and persist it to
+ * config.display.priceMode through the journal (actor user, so `undo` works). Returns the notice for the toast.
+ * Persistence failure keeps the new mode for this run and says why.
  */
-export function togglePriceMode(state) {
-    const next = priceModeOf(state) === 'mcap' ? 'price' : 'mcap';
-    state.priceMode = next;
-    const what = next === 'mcap' ? 'showing MARKET CAP' : 'showing USD PRICE'; // task-1472: the charts follow A, not $
+export function setPriceMode(state, next, why = '$') {
+    const mode = next ?? (priceModeOf(state) === 'mcap' ? 'price' : 'mcap');
+    state.priceMode = mode;
+    const what = mode === 'mcap' ? 'showing MARKET CAP' : 'showing USD PRICE'; // task-1472: the charts follow A, not $
     const ui = state.custom;
     if (!ui)
         return `${what} (not saved: no config on this run)`;
     try {
-        const op = ui.config.display ? { op: 'add', path: '/display/priceMode', value: next } : { op: 'add', path: '/display', value: { priceMode: next } };
-        const { config } = applyAndJournal(ui.home, [op], { actor: 'user', why: `$ price mode ${next}`, now: state.now.getTime() });
+        const op = ui.config.display ? { op: 'add', path: '/display/priceMode', value: mode } : { op: 'add', path: '/display', value: { priceMode: mode } };
+        const { config } = applyAndJournal(ui.home, [op], { actor: 'user', why: `${why} price mode ${mode}`, now: state.now.getTime() });
         ui.config = config;
         return `${what} · saved ($ to switch back)`;
     }
@@ -172,6 +209,49 @@ export function togglePriceMode(state) {
         return `${what} (not saved: ${e.message})`;
     }
 }
+/** `$`: flip the mode and persist it (see setPriceMode). */
+export function togglePriceMode(state) { return setPriceMode(state); }
+/**
+ * task-1537: the chat box command for the price basis, never sent to a model: `/display` (show), `/display mcap|price`,
+ * `/basis mcap|price`, `/set basis mcap|price` (also `/set priceMode …`). null = not this command.
+ */
+export function parseDisplayCommand(q) {
+    const w = q.trim().replace(/^\//, '').split(/\s+/).filter(Boolean).map((x) => x.toLowerCase());
+    let arg;
+    if (w[0] === 'display' || w[0] === 'basis') {
+        if (w[1] === 'markers')
+            return null;
+        arg = w[1];
+    }
+    else if (w[0] === 'set' && (w[1] === 'basis' || w[1] === 'pricemode' || w[1] === 'price-basis' || w[1] === 'display.pricemode'))
+        arg = w[2];
+    else
+        return null;
+    if (arg === undefined)
+        return { show: true };
+    return isPriceMode(arg) ? { mode: arg } : { error: `/display expects mcap or price, got ${JSON.stringify(arg.slice(0, 20))}` };
+}
+/** The toast for `/display` with no argument. */
+export function priceModeNotice(state) {
+    return priceModeOf(state) === 'mcap'
+        ? 'price basis: MARKET CAP (default) · coins with no known supply show price ᵖ · /display price or $ to switch'
+        : 'price basis: USD PRICE · /display mcap or $ to switch back to market cap';
+}
+/**
+ * task-1537: the one-run basis flags, accepted before any subcommand (`dexterm --price positions`, `dexterm autotrade
+ * list --mcap`): `--price` / `--mcap` are removed from argv and set DEXTERM_PRICE_BASIS in `env` for this process (so
+ * child agents and every CLI text follow it); nothing is saved. Returns argv without them.
+ */
+export function takeBasisFlags(argv, env) {
+    const out = [];
+    for (const a of argv) {
+        if (a === '--price' || a === '--mcap')
+            env[PRICE_BASIS_ENV] = a.slice(2);
+        else
+            out.push(a);
+    }
+    return out;
+}
 export function isChartAxis(v) { return CHART_AXES.includes(v); }
 /** task-1472: the chart Y axis in effect: the state's (from config or `A`), default MARKET CAP. */
 export function chartAxisOf(state) {
@@ -203,7 +283,38 @@ export function setChartAxis(state, next) {
         return `${what} (not saved: ${e.message})`;
     }
 }
-export const DISPLAY_USAGE = 'usage: dexterm display [price|mcap]   show or set display.priceMode in ~/.dexterm/config.json ($ in the app toggles it)';
+export function isChartMarkers(v) { return CHART_MARKERS.includes(v); }
+/** task-1483: are the BUY / SELL markers on (both charts)? Default on; only an explicit 'off' hides them. */
+export function chartMarkersOn(state) {
+    return state?.chartMarkers !== 'off';
+}
+/** task-1483: the markers setting a run starts with: config.display.chartMarkers, else on. */
+export function configChartMarkers(cfg) {
+    const m = cfg?.display?.chartMarkers;
+    return isChartMarkers(m) ? m : DEFAULT_CHART_MARKERS;
+}
+/**
+ * task-1483: show / hide the chart BUY / SELL markers (both chart surfaces) and persist config.display.chartMarkers through
+ * the journal (actor user, so `undo` works). `next` absent = flip. Returns the toast text. Display only.
+ */
+export function setChartMarkers(state, next) {
+    const v = next ?? (chartMarkersOn(state) ? 'off' : 'on');
+    state.chartMarkers = v;
+    const what = v === 'on' ? 'chart BUY/SELL markers: ON' : 'chart BUY/SELL markers: OFF';
+    const ui = state.custom;
+    if (!ui)
+        return `${what} (not saved: no config on this run)`;
+    try {
+        const op = ui.config.display ? { op: 'add', path: '/display/chartMarkers', value: v } : { op: 'add', path: '/display', value: { chartMarkers: v } };
+        const { config } = applyAndJournal(ui.home, [op], { actor: 'user', why: `chart markers ${v}`, now: state.now.getTime() });
+        ui.config = config;
+        return `${what} · saved`;
+    }
+    catch (e) {
+        return `${what} (not saved: ${e.message})`;
+    }
+}
+export const DISPLAY_USAGE = 'usage: dexterm display [price|mcap]   show or set display.priceMode in ~/.dexterm/config.json ($ in the app toggles it)\n       dexterm display markers [on|off]   show or set display.chartMarkers (BUY/SELL markers on both charts)';
 /** `dexterm display [price|mcap]`: print the saved price display mode, or set it (journaled, actor user). No network. */
 export function displayCommand(argv, io) {
     const home = dextermHome(io.env);
@@ -218,6 +329,34 @@ export function displayCommand(argv, io) {
         io.stdout.write(`display.priceMode = ${m}${m === 'mcap' ? ' (tables show MCAP; tokens without a supply fall back to price)' : ' (USD price per token)'}\n`);
         const a = configChartAxis(loaded.config);
         io.stdout.write(`display.chartAxis = ${a}${a === 'mcap' ? ` (charts: ${MCAP_AXIS_LABEL}; A switches)` : ' (charts plot USD price; A switches)'}\n`);
+        const mk = configChartMarkers(loaded.config);
+        io.stdout.write(`display.chartMarkers = ${mk}${mk === 'on' ? ' (charts mark your paper and live fills; dexterm display markers off hides them)' : ' (no fill markers on the charts)'}\n`);
+        return 0;
+    }
+    // task-1483: `dexterm display markers [on|off]`
+    if (arg === 'markers') {
+        const v = argv[1];
+        if (v === undefined) {
+            if (!loaded.ok) {
+                io.stderr.write(`dexterm display: ${loaded.errors[0]}\n`);
+                return 1;
+            }
+            io.stdout.write(`display.chartMarkers = ${configChartMarkers(loaded.config)}\n`);
+            return 0;
+        }
+        if (!isChartMarkers(v)) {
+            io.stderr.write(`dexterm display markers: expected on or off, got ${JSON.stringify(v.slice(0, 20))}\n${DISPLAY_USAGE}\n`);
+            return 2;
+        }
+        try {
+            const op = loaded.config.display ? { op: 'add', path: '/display/chartMarkers', value: v } : { op: 'add', path: '/display', value: { chartMarkers: v } };
+            applyAndJournal(home, [op], { actor: 'user', why: `dexterm display markers ${v}` });
+        }
+        catch (e) {
+            io.stderr.write(`dexterm display: ${e.message}\n`);
+            return 1;
+        }
+        io.stdout.write(`display.chartMarkers = ${v} (saved to ${configPath(home)})\n`);
         return 0;
     }
     if (!isPriceMode(arg)) {

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

@@ -18,6 +18,7 @@ import { SayTts, voiceDoctor, resolveVoice, WHISPER_MODEL, resolvePiperRuntime,
 import { loadConfig, dextermHome } from '../../custom/src/index.js';
 import { kbStore, skillStore } from "./kb-skill-cmd.js";
 import { analystCliOnPath, CODEX_MIN_VERSION, parseEngineChoice, resolveEngine, versionAtLeast } from "./analyst/codex.js";
+import { OllamaClient, SUGGESTED_MODELS, SURFACES, belowBar, effectiveRestriction, engineChoiceFor, loadAiConfig, ollamaSettings, pickModel, probeModel, remoteHostWarning } from '../../mcp/src/engine/index.js';
 /** The minimum Node that runs dexterm (type-stripping of the .ts entry needs 22.18). */
 export const MIN_NODE = [22, 18, 0];
 /** Cheap PATH lookup (no spawn). Windows (task-1423): PATH is `;`-separated and commands carry an extension
@@ -142,6 +143,18 @@ export async function claudeProbe(timeoutMs = 4000, platform = process.platform,
         }
     });
 }
+/** Default Ollama facts: ai.json + a short probe of the configured host (127.0.0.1 by default). Never throws. */
+export async function ollamaFacts(env = process.env) {
+    const c = loadAiConfig(env).config;
+    const set = ollamaSettings(c, env);
+    const client = new OllamaClient({ host: set.host, metaTimeoutMs: 2500 });
+    const probe = await probeModel(client, set.model, { numCtx: set.numCtx });
+    if (!probe.model && probe.models.length)
+        probe.model = null;
+    const surfaces = SURFACES.filter((sf) => engineChoiceFor(sf, c, env) === 'ollama');
+    const eff = effectiveRestriction(c, set.model ?? pickModel(probe.models), env);
+    return { probe, setUp: !!set.model || surfaces.length > 0, surfaces, level: eff.level, note: eff.note, hostWarning: remoteHostWarning(set.host) };
+}
 /**
  * Default codex probe (0.1.5): PATH (spawnable form only), then `codex --version` and `codex login status`. The
  * status command is the user's own CLI reporting on its own login; dexterm never reads the credential itself.
@@ -190,6 +203,7 @@ export function defaultDeps(env = process.env, isTTY = process.stdout.isTTY ===
         platform: process.platform,
         claude: () => claudeProbe(),
         codex: () => codexProbe(4000, env),
+        ollama: () => ollamaFacts(env),
         analystEngine: env.DEXTERM_ANALYST_ENGINE ?? loadConfig(dextermHome(env)).config.analyst?.engine ?? null,
         probe: (url) => livingProbe(url),
         checkWritable: writableProbe,
@@ -262,7 +276,16 @@ export async function runDoctor(deps) {
     // 0.1.5: codex is the optional second engine; a missing claude is fine when codex can run the analyst.
     const codex = deps.codex ? await deps.codex() : null;
     const codexUsable = codex?.state === 'present';
-    if (claude === 'missing' && codexUsable) {
+    // task-1543: a reachable Ollama with a pulled model can run the analyst too (a free local engine).
+    const ol = deps.ollama ? await deps.ollama().catch(() => null) : null;
+    const ollamaUsable = !!ol && ol.probe.reachable && (ol.probe.model ? ol.probe.present : ol.probe.models.length > 0);
+    if (claude === 'missing' && !codexUsable && ollamaUsable) {
+        checks.push({
+            name: 'Claude CLI', status: 'pass',
+            detail: 'not found on PATH (optional now): the analyst runs on your local Ollama model instead',
+        });
+    }
+    else if (claude === 'missing' && codexUsable) {
         checks.push({
             name: 'Claude CLI', status: 'pass',
             detail: 'not found on PATH (optional now): the analyst runs on your codex CLI instead',
@@ -272,7 +295,7 @@ export async function runDoctor(deps) {
         checks.push({
             name: 'Claude CLI', status: 'warn',
             detail: 'not found on PATH; the analyst (a) is disabled, the rest of dexterm works',
-            fix: 'Install Claude Code (https://claude.com/claude-code) and run `claude` once to log in, or use Codex: `npm i -g @openai/codex && codex login`.',
+            fix: 'Set up an AI backend: install Claude Code (https://claude.com/claude-code) and run `claude` once to log in, or Codex (`npm i -g @openai/codex && codex login`), or a free local model (install Ollama from https://ollama.com/download, `ollama pull qwen3:8b`, `dexterm ai engine ollama`).',
         });
     }
     else {
@@ -284,7 +307,7 @@ export async function runDoctor(deps) {
     // 3b. Codex CLI (0.1.5): optional second analyst engine, the user's own codex login. Read-only lock needs >= CODEX_MIN_VERSION.
     if (codex) {
         const choice = parseEngineChoice(deps.analystEngine) ?? 'auto';
-        const engine = resolveEngine(choice, (b) => b === 'claude' ? claude !== 'missing' : codexUsable);
+        const engine = resolveEngine(choice, (b) => b === 'claude' ? claude !== 'missing' : b === 'codex' ? codexUsable : ollamaUsable && !!ol?.setUp);
         const eng = `analyst engine: ${engine}${choice === 'auto' ? ' (auto)' : ''}`;
         if (codex.state === 'missing') {
             checks.push({ name: 'Codex CLI', status: engine === 'codex' ? 'warn' : 'pass', detail: `not installed (optional second analyst engine) · ${eng}`, ...(engine === 'codex' ? { fix: 'npm i -g @openai/codex && codex login, or set analyst.engine to claude' } : {}) });
@@ -299,6 +322,9 @@ export async function runDoctor(deps) {
             checks.push({ name: 'Codex CLI', status: 'pass', detail: `found${codex.version ? ` (codex-cli ${codex.version})` : ''}${codex.loggedIn ? ', logged in' : ''}; runs the analyst read-only on your own codex login (/engine codex) · ${eng}` });
         }
     }
+    // 3c. Local engine (task-1543): the user's own Ollama on this machine, the model, tool calling, context, profile.
+    if (ol)
+        checks.push(ollamaCheck(ol, claude !== 'missing' || codexUsable));
     // 4b. Login with X (optional, task-1357): the user's own X app + login unlock X posts in the SOCIAL panel / TRENDING.
     {
         const xs = new XTokenStore({ env: deps.env });
@@ -445,3 +471,36 @@ export function renderDoctor(result, opts = {}) {
         lines.push(paint(`${fails} check${fails === 1 ? '' : 's'} failed — fix the ✗ lines above, then re-run \`dexterm doctor\`.`, color ? ANSI.fail : ''));
     return lines.join('\n');
 }
+/**
+ * The Ollama line (task-1543). Optional while claude/codex can run the analyst; a warning with the 2-minute
+ * setup when nothing can, or when the user chose ollama and it is not ready.
+ */
+export function ollamaCheck(o, otherEngine) {
+    const p = o.probe;
+    const pull = `ollama pull ${SUGGESTED_MODELS[0].name}`;
+    const setup = `Install Ollama (https://ollama.com/download) and open it, then \`${pull}\` and \`dexterm ai engine ollama\` (\`dexterm ai model ${SUGGESTED_MODELS[0].name}\`).`;
+    const used = o.surfaces.length ? ` · runs: ${o.surfaces.join(', ')}` : '';
+    const prof = ` · profile ${o.level}${o.note ? ` (${o.note})` : ''}`;
+    const remote = o.hostWarning ? ` · WARNING ${o.hostWarning}` : '';
+    if (!p.reachable) {
+        // task-1551: a redirect is refused before anything is sent on; say so, whatever the setup state.
+        if (p.redirect)
+            return { name: 'Ollama (local AI)', status: 'warn', detail: `${p.host} answered with a redirect: refused, nothing was sent on${used}${remote}`, fix: 'dexterm never follows a redirect for the local engine (it would send your prompt to another host). Point it at the Ollama server itself with `dexterm ai host <host:port>` (or DEXTERM_OLLAMA_HOST), then re-run `dexterm doctor`.' };
+        if (!o.setUp)
+            return otherEngine
+                ? { name: 'Ollama (local AI)', status: 'pass', detail: 'not set up (optional free local engine; no login, no key, nothing leaves this machine)' }
+                : { name: 'Ollama (local AI)', status: 'warn', detail: 'no AI engine on this machine yet: a free local model works without any login or key', fix: setup };
+        return { name: 'Ollama (local AI)', status: 'warn', detail: `not reachable at ${p.host}${used}${remote}`, fix: `Start Ollama (open the app, or run \`ollama serve\`), then re-run \`dexterm doctor\`. Not installed? ${setup}` };
+    }
+    if (!p.model) {
+        const pick = pickModel(p.models);
+        return { name: 'Ollama (local AI)', status: o.setUp || !otherEngine ? 'warn' : 'pass', detail: `Ollama ${p.version ?? ''} running · pulled: ${p.models.slice(0, 5).join(', ') || 'none'} · no model chosen${used}${remote}`, ...(o.setUp || !otherEngine ? { fix: pick ? `dexterm ai model ${pick}` : `${pull} && dexterm ai model ${SUGGESTED_MODELS[0].name}` } : {}) };
+    }
+    if (!p.present)
+        return { name: 'Ollama (local AI)', status: 'warn', detail: `${p.model} is not pulled on ${p.host}${used}${remote}`, fix: `ollama pull ${p.model}` };
+    const warns = belowBar(o.level, p);
+    const facts = `${p.model} · tools ${p.tools === null ? '?' : p.tools ? 'yes' : 'no'} · context ${p.contextLength ?? '?'}`;
+    if (warns.length || o.hostWarning)
+        return { name: 'Ollama (local AI)', status: 'warn', detail: `${facts}${used}${prof}${remote}${warns.length ? ` · ${warns[0]}` : ''}`, fix: warns.length ? `\`dexterm ai probe --json\` checks it in detail; pull a stronger tool-capable model (e.g. ${pull}) or lower the profile (\`dexterm ai restrictions observe\`).` : 'Point dexterm at this machine: dexterm ai host 127.0.0.1' };
+    return { name: 'Ollama (local AI)', status: 'pass', detail: `${facts} · ${p.local ? 'local' : 'remote'} · $0${used}${prof}` };
+}

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

@@ -12,6 +12,7 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { Canvas, rasterizeCanvas, fmtUsd, fmtPrice, fmtPct } from '../../tui/src/index.js';
 import { encodePng } from '../../data/src/index.js';
+import { priceModeOf } from "./display.js";
 import { dextermHome } from "./boot-state.js";
 import { cleanText } from "./screener/rows.js";
 import { rugP, fmtRugP, RUG_MODEL_LABEL } from "./screener/rug.js";
@@ -152,8 +153,15 @@ const yesNo = (b) => (b === null ? 'unknown' : b ? 'ENABLED' : 'revoked');
 export function tokenReport(state, v, now) {
     const L = [];
     L.push(`coin        $${cleanText(v.symbol, 16)}${v.name ? ` · ${cleanText(v.name, 40)}` : ''} · ${v.launchpad}`);
-    L.push(`price       ${fmtPrice(v.price)}   5m ${fmtPct(v.chg.m5)}   1h ${fmtPct(v.chg.h1)}   6h ${fmtPct(v.chg.h6)}   24h ${fmtPct(v.chg.h24)}`);
-    L.push(`market cap  ${fmtUsd(v.mcap)}${v.mcapFlagged ? ' (flagged)' : ''}   liquidity ${fmtUsd(v.liq)}   vol 24h ${fmtUsd(v.vol24)}`);
+    const moves = `5m ${fmtPct(v.chg.m5)}   1h ${fmtPct(v.chg.h1)}   6h ${fmtPct(v.chg.h6)}   24h ${fmtPct(v.chg.h24)}`;
+    if (priceModeOf(state) === 'mcap' && v.mcap !== null) { // task-1537: the market cap leads by default; both numbers stay
+        L.push(`market cap  ${fmtUsd(v.mcap)}${v.mcapFlagged ? ' (flagged)' : ''}   price ${fmtPrice(v.price)}   ${moves}`);
+        L.push(`liquidity   ${fmtUsd(v.liq)}   vol 24h ${fmtUsd(v.vol24)}`);
+    }
+    else {
+        L.push(`price       ${fmtPrice(v.price)}   ${moves}`);
+        L.push(`market cap  ${fmtUsd(v.mcap)}${v.mcapFlagged ? ' (flagged)' : ''}   liquidity ${fmtUsd(v.liq)}   vol 24h ${fmtUsd(v.vol24)}`);
+    }
     L.push(`holders     ${v.holders ?? '—'}   top-10 ${v.top10 === null ? '—' : `${v.top10.toFixed(1)}%`}   dev ${v.dev === null ? '—' : `${v.dev.toFixed(1)}%`}${v.holdersSample ? `   (${v.holdersSample})` : ''}`);
     L.push(`age         ${v.ageMin === null ? '—' : fmtAge(v.ageMin * 60)}`);
     L.push(`authorities mint ${yesNo(v.mintAuth)} · freeze ${yesNo(v.freezeAuth)}${v.riskyExtensions.length ? ` · risky extensions: ${v.riskyExtensions.join(', ')}` : ''}`);

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

@@ -19,7 +19,7 @@ export { renderAnalyst, renderContextRail, renderCoinList } from "./screens/anal
 export { renderTicket } from "./screens/ticket.js";
 export { renderPositions } from "./screens/positions.js";
 export * from "./trade.js";
-export { TradeTicketLive, PositionsLive, LivePositions, CombinedPositions, POSITIONS_REFRESH_MS } from "./live/trade.js";
+export { TradeTicketLive, PositionsLive, POSITIONS_REFRESH_MS } from "./live/trade.js";
 export { parseWalletCommand, WALLET_HELP } from "./wallet-command.js";
 export * from "./screener/filter.js";
 export * from "./screener/sort.js";