dexterm-cli 0.1.6 → 0.2.0

package/dist/packages/mcp/assets/kb/app-help/autotrade-chat.md

@@ -0,0 +1,48 @@
+---
+id: autotrade-chat
+title: Change an autotrade strategy by chat (paper)
+kind: app-help
+screen: autotrade
+feature: autotrade-chat
+tags:
+  - app-help
+  - autotrade
+  - strategy
+  - chat
+  - analyst
+  - proposal
+  - tune
+  - change
+  - diff
+  - looser
+  - less
+  - safe
+keys:
+  - a
+  - o
+actions:
+  - analyst.toggle
+  - autotrade.proposal
+tools:
+  - strategy_list
+  - strategy_get
+  - strategy_validate
+  - strategy_propose_edit
+  - strategy_propose_new
+  - strategy_backtest
+  - autotrade_status
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Ask the analyst to change one of your strategies ("make my swing exit faster"). It can only PROPOSE: the change arrives as a card on the AUTOTRADE screen (`Q`) with the field lines that change, the validation result and TIGHTER, NEUTRAL or LOOSER. `o` opens the card, `y` applies it as a new version (journaled with who proposed it), `n` dismisses it. When any risk number gets less safe (bigger size or exposure, more loss, a stop or safety gate removed) the edit is LOOSER and needs a second `y` on the less-safe popup. The mode, the book, the daily session budget and the exit-liquidity floor are yours only: the analyst cannot change them. It can backtest a proposal next to the current version on your recorded history (up to 14 days, read-only). Paper only.
+
+Keys: `a`, `o` (autotrade).

package/dist/packages/mcp/assets/kb/app-help/autotrade-executor-kit.md

@@ -0,0 +1,44 @@
+---
+id: autotrade-executor-kit
+title: Wire up a test executor, check it is alive, and get the digest (dexterm autotrade executor, signal test, report)
+kind: app-help
+screen: all
+feature: autotrade-executor-kit
+tags:
+  - app-help
+  - executor
+  - kit
+  - example
+  - heartbeat
+  - alive
+  - silent
+  - health
+  - test
+  - webhook
+  - receiver
+  - dry
+  - run
+  - digest
+  - report
+  - daily
+  - weekly
+  - divergence
+  - slippage
+  - latency
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade executor kit --out ~/my-executor` copies the reference executors: a webhook receiver, a `--signal-cmd` hook and a JSONL tail. Each verifies the HMAC, dedupes by nonce, honours the TTL, writes a receipt and a heartbeat, and is DRY RUN: it only logs what it would do, with no wallet code in it. Start one, point a channel at it (`dexterm autotrade signal channels --webhook http://127.0.0.1:8787/signal`), then `dexterm autotrade signal test` sends a test signal (`test: true`, no coin, nothing to trade) and shows, per channel, whether it was delivered, how long it took and the executor's receipt. `dexterm autotrade executor status` shows the last heartbeat, the last receipt and the lag; a real run pauses new buy signals (exits still go out) when nothing is heard for longer than your `executorSilenceMin` limit, and tells you. With receipts that carry fills, `signal status`, `autotrade audit` and `dexterm autotrade report` show paper vs real: slippage against dexterm's own paper fill, latency, partial fills and rejections. `report [--period day|week] [--telegram]` is the digest per strategy and mode with the win rate's interval and a small-sample note; `report --schedule daily|weekly` makes a run with your bot on send it.
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-journey.md

@@ -0,0 +1,46 @@
+---
+id: autotrade-journey
+title: Build a strategy by chat, back-test it, forward-test it, then promote it (paper, then real)
+kind: app-help
+screen: all
+feature: autotrade-journey
+tags:
+  - app-help
+  - autotrade
+  - strategy
+  - build
+  - chat
+  - journey
+  - ladder
+  - backtest
+  - held-out
+  - forward
+  - test
+  - promote
+  - promotion
+  - always-on
+  - real
+  - evidence
+commands:
+  - autotrade
+tools:
+  - strategy_journey
+  - strategy_forward_start
+  - strategy_forward_stop
+  - strategy_forward_report
+  - strategy_promote_propose
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+A strategy climbs one ladder, one rung at a time: draft → backtested → forward-tested → always-on (paper) → real. Each rung needs evidence measured on that strategy's exact rules; any rule change starts it again (a rename or arming keeps it). Ask the analyst to build one ("build me a strategy that buys young pairs on a 5-minute push and takes profit at 2x"): it proposes a copy of a preset with changes (strategy_propose_new), you apply it on the Q screen. BACKTESTED: `dexterm autotrade backtest <id>` or strategy_backtest runs it on recorded history and on each half of the held-out split (the newest 30% of coins); verdict rule 6 allows gain wording only with at least 20 trades in both halves and a held-out net above 0. FORWARD-TESTED: `dexterm autotrade forward start <id> --hours 24` (or `--trades N`, or strategy_forward_start from the chat) runs the same version on the LIVE tape, on paper, with its own bankroll and run file, in the background next to the always-on service; `forward status`, `forward stop` and `forward report` (the forward numbers next to the backtest: trades, win rate with its interval, net, drawdown, rug rate, fill cost drift, and a plain line when a sample is too small). Only a test that ran its whole window on live data counts. ALWAYS-ON: the analyst can propose it (strategy_promote_propose), you apply it with `dexterm autotrade promote apply <pp-id>` (y on your own terminal) or on the Q screen journey view (`J`, then `y`); it joins autotrade.json and the always-on service runs it on paper. REAL: you set your own limits (`dexterm autotrade limits set`; `signal caps set` sets four of them), then `dexterm autotrade promote <id> --to real` hands over to `signal arm` (evidence panel, typed phrase with a one-time code). No tool or model can apply a promotion, skip a rung, set a cap, pick a bankroll or arm real mode. `dexterm autotrade journey <id>` shows where a strategy stands. Paper by default; not financial advice.
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-limits.md

@@ -0,0 +1,48 @@
+---
+id: autotrade-limits
+title: Set your own real-mode limits: per trade, per day, open positions, loss stops, the breaker (dexterm autotrade limits)
+kind: app-help
+screen: all
+feature: autotrade-limits
+tags:
+  - app-help
+  - limits
+  - limit
+  - caps
+  - cap
+  - size
+  - sizing
+  - per
+  - trade
+  - daily
+  - loss
+  - drawdown
+  - breaker
+  - streak
+  - exposure
+  - slippage
+  - ttl
+  - rate
+  - raise
+  - lower
+  - scope
+commands:
+  - autotrade
+tools:
+  - trading_limits
+  - limits_propose
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Every limit real mode enforces is yours to set, in one file (`~/.dexterm/autotrade/real/limits.json`, schema `dexterm-limits/1`): per trade as SOL or as % of the book (the smaller wins), SOL and buys per day, open positions, exposure, min and max position, per coin per day, a daily loss stop, a drawdown breaker, a loss-streak pause, max hold time, the evidence floor for arming (`minForwardTrades`: closed paper trades in a completed forward test, placeholder 10), min liquidity and market cap, max slippage and price impact, the signal TTL, a buy rate limit, an optional sell rate (sells are never capped unless you set one) and how long a silent executor may stay silent. `dexterm autotrade limits show [--strategy ID] [--account ID]` lists what is in force and where each number comes from; `limits set perTradeSol=0.5 dailyLossSol=0.3` (or `--scope real|paper|strategy:ID|account:ID`) changes them: a global number replaces the placeholder default, every other scope can only tighten, and the stricter always wins. Paper runs ignore them unless you add a `paper` scope; then a single paper run (not `run --all`) obeys them on its own state (a replay then needs `--sol-usd N`). Daily counters cover the whole home (every strategy and account), so a strategy or account number can only stop buys sooner. Lowering is immediate, even for a running real run; raising shows the old -> new diff and needs the typed phrase on your own terminal, and applies from the next run. `limits diff`, `limits accept` (a hand-edited file), `limits reset`, `limits breaker reset` (typed) and `limits explain` do the rest. The defaults (0.25 SOL a trade, 1 SOL a day, 20 buys, 3 open, stop at -0.5 SOL a day) are placeholders: arming asks for your own numbers first. The analyst can read and explain them (`trading_limits`) and propose a change as a diff card (`limits_propose`); it can never apply one.
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-parallel.md

@@ -0,0 +1,42 @@
+---
+id: autotrade-parallel
+title: Run several autotrade strategies at once on paper (dexterm autotrade run --all)
+kind: app-help
+screen: all
+feature: autotrade-parallel
+tags:
+  - app-help
+  - autotrade
+  - parallel
+  - several
+  - multiple
+  - strategies
+  - compare
+  - side
+  - forward
+  - test
+  - bankroll
+  - fleet
+  - autotrade.json
+commands:
+  - autotrade
+tools:
+  - autotrade_parallel_list
+  - autotrade_parallel_compare
+  - autotrade_parallel_start
+  - autotrade_parallel_stop
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade run --all --paper` runs every strategy listed in ~/.dexterm/autotrade/autotrade.json at the same time on one data feed, to forward-test several ideas side by side. Each entry has an `id`, a `preset` (a shipped preset or your own strategy) or an absolute `file`, a `bankroll` in USD or SOL, optional `caps` that can only tighten it, and `enabled`. Each strategy gets its own paper book, run file, loss limits and breaker, sessions and model spend budget; a breaker or a stop on one never stops another. The screener fetches once for all of them, and the `global` limits (sessions open at once, model spend and sessions per day, one check of how busy the computer is) count across all of them. `dexterm autotrade status --all` and the runner view on the AUTOTRADE screen (`Q`) compare them: P/L, win rate with the closed count, rug exits and exposure, missed runners, spend per entry. `dexterm autotrade stop|flatten|pause|resume` act on every strategy; add `--strategy ID` to act on one, and `dexterm autotrade start ID` starts a listed one that is not running. An MCP agent can list and compare them and start or stop one listed strategy, never add one or change a size or a cap. Paper only: live is refused. Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#several-strategies-at-once
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-real-signal.md

@@ -0,0 +1,45 @@
+---
+id: autotrade-real-signal
+title: Real mode: send a strategy's trades to your own executor as LIVE TRADE FIRE signals (dexterm autotrade signal)
+kind: app-help
+screen: all
+feature: autotrade-real-signal
+tags:
+  - app-help
+  - real
+  - mode
+  - live
+  - trade
+  - fire
+  - signal
+  - signals
+  - executor
+  - webhook
+  - hook
+  - jsonl
+  - receipt
+  - receipts
+  - arm
+  - caps
+  - kill
+  - outbox
+  - nonce
+commands:
+  - autotrade
+tools:
+  - trade_fire_feed
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Real mode runs a strategy exactly like paper (the same clamp, exits, monitor and run file) and sends every buy and sell it fills, first, as a LIVE TRADE FIRE signal (`dexterm-trade-fire/1`: buy or sell, mint, symbol, size in SOL and % of book, the sell fraction and exit reason, strategy, run, account, an always-growing nonce, an idempotency id and an expiry) to YOUR executor: a Telegram trading bot of your choice or any script. dexterm holds no key and signs nothing. Set channels with `dexterm autotrade signal channels --webhook URL | --signal-cmd '["/abs/path"]' | --jsonl on | --mcp on | --telegram on` (they live in connectors.json next to the Telegram setup; a bot cannot read another bot, so the Telegram copy alone is not enough), a webhook HMAC secret with `signal secret generate --out FILE`, hard caps with `signal caps set` (raising needs a typed confirmation), then arm on your own terminal with `dexterm autotrade signal arm <id>` (evidence panel + a typed phrase with a one-time code; any later edit disarms; below the evidence floor, a completed forward test with your `minForwardTrades` closed paper trades and a backtest of these exact rules, or past a missing rung of the ladder, it refuses unless you first type a separate OVERRIDE phrase, which is journaled) and run `dexterm autotrade run <id> --real` (live data only, in the foreground: in 0.2.0 the always-on service runs paper strategies only). Delivery is at least once from a restart-safe outbox, in nonce order, retried until acked or expired; the executor dedupes by nonce, ignores expired signals and acts only on its own account. Every run ends with a `halted` signal that lists the positions still open; the run's last lines and the Telegram copy name them too. Open positions are carried to the next real run of the same strategy and account, whose exits keep firing; while no real run is running NO signal goes out, sells included, so manage them in your executor. Positions stay unconfirmed until `dexterm autotrade receipt <nonce> executed|rejected|failed` (data only). `signal kill` stops every signal; `signal status`, `signal tail`, `receipt list` and `autotrade audit` show the outbox, receipts and drift; agents can read the MCP feed with trade_fire_feed. No model, tool or chat tap can arm real mode, raise a cap or lift the kill switch. Experimental; not financial advice.
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-runner.md

@@ -0,0 +1,35 @@
+---
+id: autotrade-runner
+title: The autotrade paper runner and candidate sessions (dexterm autotrade run)
+kind: app-help
+screen: all
+feature: autotrade-runner
+tags:
+  - app-help
+  - autotrade
+  - runner
+  - run
+  - candidate
+  - session
+  - sessions
+  - agent
+  - replay
+  - ledger
+  - runner.json
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade run <id|file> --paper` runs one strategy on paper, headless, one runner per machine: the screener feeds it the same live data as the app (every 10 s, candidate and held coins every 5 s), and each coin that matches gets one session on your own Claude login with the full picture first, then only what changed. Your agent answers with a typed decision (enter, wait, skip, hold, exit, tighten, reprofile); every size is clamped by your strategy and the exits run on their own. At most 2 sessions at once, $0.50 per session and the day caps in ~/.dexterm/autotrade/runner.json (which Claude account, sessions and spend per day, a usage guard). Every step goes to ~/.dexterm/autotrade/runs/<run>.jsonl, hash-chained. `--replay FILE` paces a recorded tape instead of live data; `--stub` uses a scripted agent with no Claude cost. Paper only: a run never signs or touches a wallet, and there is no `--live` (dexterm holds no key and places no live order). Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#the-runner-and-candidate-sessions
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-stop.md

@@ -0,0 +1,37 @@
+---
+id: autotrade-stop
+title: Stop, flatten or audit the autotrade paper runner (dexterm autotrade stop|flatten|audit)
+kind: app-help
+screen: all
+feature: autotrade-runner
+tags:
+  - app-help
+  - autotrade
+  - stop
+  - kill
+  - halt
+  - flatten
+  - sell
+  - pause
+  - panic
+  - audit
+  - verify
+  - ledger
+  - resume
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade stop` is a soft stop of the paper runner: no new entries, every session closed, pending orders dropped, and the mechanical exits (stops, take-profits, trails, rug exits) keep running until nothing is held; then the runner ends. `dexterm autotrade flatten` stops it and sells every paper position at its next tick (a coin that cannot sell is retried every tick); it asks for y on a real terminal, or takes --yes. On the AUTOTRADE screen (`Q`): `!` stops, `p` pauses or resumes new entries, `f` then y flattens. A stop is final for that run. `dexterm wallet panic` is the harder switch: the runner reads it every step, a new run will not start while it is on, and only `dexterm wallet resume` on a real terminal lifts it. `dexterm autotrade audit --verify` recomputes the hash chain of every run file in ~/.dexterm/autotrade/runs/ and names the first edited, missing or reordered line. Paper only; your agent cannot stop, resume or flatten anything. Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#stopping-it
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-strategies.md

@@ -0,0 +1,35 @@
+---
+id: autotrade-strategies
+title: Autotrade strategies on paper (dexterm autotrade)
+kind: app-help
+screen: all
+feature: autotrade-strategies
+tags:
+  - app-help
+  - autotrade
+  - strategy
+  - strategies
+  - preset
+  - presets
+  - moonbag
+  - scalp
+  - swing
+  - sweep
+  - held-out
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade list|validate|new|import|remove|journal` manages strategy files in ~/.dexterm/strategies (one validated JSON file each, every change in an append-only journal); the presets scalp, swing, runner, moonbag, sample-dip-ladder and yolo (HIGH RISK, see the yolo entry) are read-only, copy one with `dexterm autotrade new <id> --from <preset>`. `dexterm autotrade backtest <id>` replays a strategy over your recorded history with modelled fills and always prints the limits of the data (`--every-candidate`, `--recall 5,10` for tail strategies); `dexterm autotrade sweep <id>` tunes on older coins and checks once on the newest 30% it never saw, with no gain wording unless both halves have 20+ trades and the held-out net is positive. Paper only: a strategy cannot hold a key, wallet or signer section, and a copy in mode live does not run (dexterm holds no key and places no live order). Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-telegram.md

@@ -0,0 +1,40 @@
+---
+id: autotrade-telegram
+title: Your own Telegram bot for the autotrade runner: notify, control, one-tap approvals (dexterm telegram)
+kind: app-help
+screen: all
+feature: autotrade-telegram
+tags:
+  - app-help
+  - telegram
+  - bot
+  - phone
+  - mobile
+  - notify
+  - notifications
+  - approve
+  - approval
+  - approvals
+  - pair
+  - pairing
+  - kill
+  - pause
+  - remote
+  - botfather
+commands:
+  - telegram
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Create a bot with @BotFather, then run `dexterm telegram setup`: paste the token at the hidden prompt (never as an argument), dexterm checks it and keeps it in your keychain (or the system keyring, or a 0600 file), then shows a 6-digit code; send `/pair <code>` to your bot from your own private chat and confirm the account it shows (@username and id) with `y` on your computer. Pairing is refused while a webhook or another program polls the bot. Only that account in that chat is answered. `dexterm autotrade run <id> --paper` then starts the bot by itself (`--no-telegram` keeps it off): entries, exits, PnL cards, halts and a daily summary reach your phone; `/status`, `/positions`, `/pause`, `/resume` (a pause only), `/kill`, `/flatten` and `/use` (each after a confirm button, `/use` only to an equal-or-tighter strategy; a change it cannot rank counts as looser) and `/approvals on` work from chat, which can make things safer and never less safe. With `entry.decide: "agent+approve"` or approvals on, every entry is a card with [Approve] [Half size] [Skip]: only a button approves, once, for that proposal, your account and your private chat; the price and your limits are checked again at the tap; no answer is a skip. Typed messages are never trades. `dexterm telegram status|test|audit --verify|revoke`. Nothing is hosted; paper only; never send keys or seed phrases in chat. Not financial advice. Full docs: https://dexterm.xyz/docs/telegram/
+
+CLI: `dexterm telegram`.

package/dist/packages/mcp/assets/kb/app-help/chart-trade-markers.md

@@ -0,0 +1,42 @@
+---
+id: chart-trade-markers
+title: See your buys and sells on the chart (B / S markers)
+kind: app-help
+screen: token
+feature: chart-trade-markers
+tags:
+  - app-help
+  - markers
+  - marker
+  - buy
+  - sell
+  - bought
+  - sold
+  - fills
+  - fill
+  - entry
+  - exit
+  - trades
+  - chart
+  - avg
+  - average
+  - paper
+  - live
+  - arrows
+commands:
+  - display
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Every fill of the open coin from your paper ledger (your own and an agent's PAPER trades) and the live ledger (confirmed real swaps) is marked on the token screen's chart and the chart popup, on every timeframe: `B` for a buy and `S` for a sell, at the fill's time and price. Hollow `△ ▽` = PAPER, solid `▲ ▼` = live, so it reads without colour too. Each partial sell gets its own marker (several in one bar show a count), a dashed `avg` line marks the average entry while the position is open, and a closed round trip gets a faint wash from entry to exit. A fill outside the candles on screen is not moved: the chart says how many are off-chart. In the popup, hover a marker for its time, price, size and ledger; `k` or the **MARKERS** button turns them off or on for both charts (saved as `display.chartMarkers`; also `dexterm display markers on|off`). Display only: no marker can arm, size, sign or confirm anything, and nothing is fetched to draw them.
+
+CLI: `dexterm display`.

package/dist/packages/mcp/assets/kb/app-help/link-a-wallet.md

@@ -1,6 +1,6 @@
 ---
 id: link-a-wallet
-title: Link a wallet for trading (dexterm wallet)
+title: Link a wallet to show its public key (dexterm wallet)
 kind: app-help
 screen: all
 feature: trading
@@ -12,17 +12,11 @@ tags:
   - phantom
   - connect
   - pubkey
-  - caps
-  - trade
+  - panic
+  - resume
 commands:
   - wallet
 flags:
-  - --mainnet
-  - --max-usd
-  - --daily-usd
-  - --max-sol-out
-  - --max-slippage-bps
-  - --trade-rpc
   - --no-live
 confidence: high
 owner: maintainers
@@ -36,6 +30,6 @@ sources:
 date: 2026-10-16
 ---
 
-`dexterm wallet link|unlink|status` links a Phantom wallet through a loopback bridge — your keys NEVER enter dexterm, only the public key is stored — and shows the link and the signer-side trade caps. dexterm is non-custodial: it builds and simulates transactions, your own wallet signs. The signer-side caps (`--max-usd`, `--daily-usd`, `--max-sol-out`, `--max-slippage-bps`) and the RPC (`--trade-rpc`) bound every trade and live on the signer; `--mainnet` opts in to mainnet and `--no-live` keeps it paper-only. The analyst can never link, unlink, sign, arm or change a cap.
+`dexterm wallet link|unlink|status` links a Phantom wallet through a loopback bridge (Phantom signs a MESSAGE, never a transaction): your keys NEVER enter dexterm, only the public key is stored, for display. dexterm holds no key and never signs or sends a transaction; trading in dexterm is paper, and live trading happens in the Telegram trading bot of your choice. `dexterm wallet panic` halts autotrade runs and the paper agent desk at once; only `dexterm wallet resume`, a keypress on a real terminal, clears it. `--no-live` (0.1.6) is accepted and changes nothing. The analyst can never link, unlink or resume.
 
 CLI: `dexterm wallet`.

package/dist/packages/mcp/assets/kb/app-help/live-trading.md

@@ -0,0 +1,38 @@
+---
+id: live-trading
+title: Live trading: dexterm holds no key; a Telegram trading bot of your choice trades
+kind: app-help
+screen: all
+feature: live-trading
+tags:
+  - app-help
+  - live
+  - trading
+  - real
+  - money
+  - telegram
+  - bot
+  - key
+  - wallet
+  - custody
+  - signer
+  - mainnet
+commands:
+  - telegram
+  - wallet
+  - live
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+dexterm never holds a key and never signs or sends a transaction: there is no trading wallet, no signer and no live order in dexterm. Live trading happens in a Telegram trading bot of your choice, which holds its own wallet; you act in that bot. dexterm's part is the Telegram connector to your OWN bot (`dexterm telegram setup`): alerts, signals and run control for your paper runs. dexterm does not place orders in a trading bot for you: in real mode (0.2.0, experimental) a strategy you armed on your own terminal sends a signal for each trade to an executor you run, and your executor places the order by its own rules (`dexterm autotrade signal`, https://dexterm.xyz/docs/real-mode/). Paper trading (the ticket, paper accounts, paper autotrade) is local. `dexterm wallet link` keeps a Phantom public key for display only. Not financial advice. Full docs: https://dexterm.xyz/docs/live-trading/
+
+CLI: `dexterm telegram`, `dexterm wallet`, `dexterm live`.

package/dist/packages/mcp/assets/kb/app-help/live-yolo.md

@@ -0,0 +1,34 @@
+---
+id: live-yolo
+title: The full-port yolo strategy on paper: replay and a paper run (HIGH RISK)
+kind: app-help
+screen: all
+feature: yolo-preset
+tags:
+  - app-help
+  - yolo
+  - full
+  - port
+  - all-in
+  - high
+  - risk
+  - preset
+  - replay
+  - paper
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+HIGH RISK, PAPER only; not financial advice. The `yolo` preset enters one young pair at a time on an early 5-minute push after the holder-safety gates (LP burned or locked, no mint or freeze authority, a LARP score of 49 or less checked live before a coin becomes a candidate, liquidity of $25K or more), takes the cost back at about 2x, lets the rest ride on a loose 50% trail, exits at once on a liquidity pull, a dev sell or dead volume, has a -50% stop and a 45-minute time stop, and never buys the same coin twice. On paper it caps an entry at 25% like every strategy. `dexterm autotrade yolo-replay yolo` measures every entry at full port over your recorded history (rugs, the loss spread, how often it zeroed the wallet); `dexterm autotrade run yolo --paper` runs it on paper (`--replay builtin:yolo-rehearsal --stub` for a short fixture run; next to other strategies, or on a shared paper account, through `autotrade.json` and `dexterm autotrade run --all --paper`). Stop: `dexterm autotrade stop`, /kill in Telegram, Ctrl-C. dexterm places no live order. Full docs: https://dexterm.xyz/docs/yolo/
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/order-plans.md

@@ -28,6 +28,6 @@ sources:
 date: 2026-10-16
 ---
 
-`dexterm plan list|add|remove|arm|disarm` sets conditional order plans (e.g. take-profit / stop levels). Voice and agents can only PROPOSE a plan; ARMING one needs your physical keypress, and the caps and panic-stop stay signer-side. Nothing here lets a model sign or raise a cap.
+`dexterm plan list|add|remove|arm|disarm` sets conditional order plans (e.g. take-profit / stop levels). Voice and agents can only PROPOSE a plan; ARMING one needs your physical keypress, and plans fill on PAPER (dexterm places no live order). Nothing here lets a model sign or raise a cap.
 
 CLI: `dexterm plan`.

package/dist/packages/mcp/assets/kb/app-help/price-or-marketcap.md

@@ -1,6 +1,6 @@
 ---
 id: price-or-marketcap
-title: Show price or market cap
+title: Market cap or price (market cap is the default)
 kind: app-help
 screen: all
 feature: price-display-mode
@@ -13,6 +13,7 @@ tags:
   - display
   - usd
   - cap
+  - basis
 keys:
   - $
 actions:
@@ -21,6 +22,8 @@ commands:
   - display
 flags:
   - --price-mode
+  - --price
+  - --mcap
 confidence: high
 owner: maintainers
 origin: app-help-generated
@@ -33,6 +36,6 @@ sources:
 date: 2026-10-16
 ---
 
-Press `$` to flip every price between USD price and MARKET CAP (screener, watchlist, new pairs, token, both charts, order-plan levels). Saved as `display.priceMode`; also `dexterm display price|mcap` or `--price-mode`. A coin with no known supply stays on price and says so. The analyst can set this for you.
+Market cap is the default basis: every screen, the CLI text, the chat assistant and the autotrade agents show and talk about a coin in market cap (entered at $69.7K, exited at $264.9K, 3.8x). Press `$` (or type `/display price` in the chat box, `/display mcap` to go back) to switch to USD price and back. Saved as `display.priceMode`; also `dexterm display mcap|price`. For one run: `--price` / `--mcap` on any command, `--price-mode`, or `DEXTERM_PRICE_BASIS=price`. Market cap = price × a known supply (the source's cap ÷ price, recorded FDV ÷ price, or pump.fun's 1B); a coin with no known supply shows its price marked ᵖ and says so. JSON keeps both `price` and `mcap`. The charts have their own axis setting (`A`). The analyst can propose this for you.
 
 Keys: `$`. CLI: `dexterm display`.

package/dist/packages/mcp/assets/kb/app-help/screen-analyst.md

@@ -67,6 +67,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -113,6 +114,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 tools:
   - get_dossier
   - kb_search
@@ -176,6 +178,7 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `type` — ask a follow-up · ⏎ send · esc clear/back
   `c` — calm mode (effects off)
   `?` — this help