dexterm-cli 0.1.7 → 0.2.0

package/dist/packages/mcp/assets/kb/docs/docs-build-a-strategy-by-chat.md

@@ -0,0 +1,24 @@
+---
+id: docs-build-a-strategy-by-chat
+title: Build a strategy by chat
+kind: docs
+page: build-a-strategy-by-chat
+page_title: Build a strategy by chat
+url: https://dexterm.xyz/docs/build-a-strategy-by-chat
+tags:
+  - docs
+  - build-a-strategy-by-chat
+  - build
+  - strategy
+  - chat
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/build-a-strategy-by-chat.md
+date: 2026-10-16
+---
+
+Ask the analyst for a strategy, then back-test it on your recorded history, forward-test it on live data on paper, and promote it one step at a time to the always-on service and, only if you choose, to real mode. Every step needs evidence; nothing is promoted by the model. Paper by default, not financial advice.

package/dist/packages/mcp/assets/kb/docs/docs-getting-started-install.md

@@ -41,10 +41,10 @@ $ dexterm doctor
 The package is named `dexterm-cli` because npm refuses the name `dexterm` as too similar to `xterm`. The command it installs is `dexterm`. The package ships compiled JavaScript, so it needs no build step. Every GitHub release carries a build-provenance attestation and `SHA256SUMS` you can verify (see the trust page (https://dexterm.xyz/trust/)).
 
 ```sh install from the release
-$ # download dexterm-0.1.7-src.tar.gz and SHA256SUMS from the releases page, then:
+$ # download dexterm-0.2.0-src.tar.gz and SHA256SUMS from the releases page, then:
 $ shasum -a 256 -c SHA256SUMS --ignore-missing
-$ gh attestation verify dexterm-0.1.7-src.tar.gz --repo dexterm-xyz/dexterm
-$ tar -xzf dexterm-0.1.7-src.tar.gz && cd dexterm-0.1.7
+$ gh attestation verify dexterm-0.2.0-src.tar.gz --repo dexterm-xyz/dexterm
+$ tar -xzf dexterm-0.2.0-src.tar.gz && cd dexterm-0.2.0
 $ ./install.sh
 $ dexterm doctor
 ```

package/dist/packages/mcp/assets/kb/docs/docs-getting-started-requirements.md

@@ -32,4 +32,4 @@ date: 2026-10-16
 | optional: a free RPC key | the ranked top-20 holder list and faster chain reads | Helius, Alchemy, QuickNode or Ankr free tier; see configuration (https://dexterm.xyz/docs/configuration). |
 | optional: Rust (`cargo`) | the native docked chart window | without it the chart popup opens in your browser; see popup chart (https://dexterm.xyz/docs/popup-chart). |
 
-> note: dexterm 0.1.7 is out (2026-10-22), open source under AGPL-3.0-only at github.com/dexterm-xyz/dexterm (https://github.com/dexterm-xyz/dexterm). It is early: trading is experimental and has known bugs. The release ships checksums, a build-provenance attestation and an SBOM, and its VirusTotal result (including flags we explain) is on the trust page (https://dexterm.xyz/trust/). It is also on npm as `dexterm-cli` (https://www.npmjs.com/package/dexterm-cli); the command it installs is still `dexterm`.
+> note: dexterm 0.2.0 is out (2026-10-25), open source under AGPL-3.0-only at github.com/dexterm-xyz/dexterm (https://github.com/dexterm-xyz/dexterm). It is early: trading is experimental and has known bugs. The release ships checksums, a build-provenance attestation and an SBOM, and its VirusTotal result (including flags we explain) is on the trust page (https://dexterm.xyz/trust/). It is also on npm as `dexterm-cli` (https://www.npmjs.com/package/dexterm-cli); the command it installs is still `dexterm`.

package/dist/packages/mcp/assets/kb/docs/docs-going-real-executor-health.md

@@ -0,0 +1,38 @@
+---
+id: docs-going-real-executor-health
+title: Going real, safely › Executor health
+kind: docs
+page: going-real
+page_title: Going real, safely
+heading: Executor health
+anchor: executor-health
+url: https://dexterm.xyz/docs/going-real#executor-health
+tags:
+  - docs
+  - going-real
+  - executor
+  - health
+  - going
+  - real
+  - safely
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/going-real.md
+date: 2026-10-16
+---
+
+dexterm counts three signs of life from your executor:
+- a heartbeat: a `dexterm-executor-heartbeat/1` line in `~/.dexterm/autotrade/real/executor.jsonl`, `dexterm autotrade executor heartbeat`, or a POST to the listener a real run opens with `--executor-port N` (127.0.0.1 only, HMAC required when a secret is set);
+- a receipt;
+- an ack on the webhook or the command hook.
+
+`dexterm autotrade executor status`, `signal status`, the `Q` screen and Telegram's `/status` show:
+- whether your executor is alive, and when it was last heard;
+- its last receipt;
+- the median lag from a signal to its receipt.
+
+**When it goes quiet** for longer than `executorSilenceMin`, a real run **pauses new buy signals** and tells you in the run log and on Telegram. Exits keep going out. When the executor is heard again, buys resume and you are told. A heartbeat is only evidence of life: it cannot raise a limit, reset the breaker, lift the kill switch or confirm a position.

package/dist/packages/mcp/assets/kb/docs/docs-going-real-paper-vs-real.md

@@ -0,0 +1,33 @@
+---
+id: docs-going-real-paper-vs-real
+title: Going real, safely › Paper vs real
+kind: docs
+page: going-real
+page_title: Going real, safely
+heading: Paper vs real
+anchor: paper-vs-real
+url: https://dexterm.xyz/docs/going-real#paper-vs-real
+tags:
+  - docs
+  - going-real
+  - paper
+  - real
+  - going
+  - safely
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/going-real.md
+date: 2026-10-16
+---
+
+When your executor's receipts carry fills (`priceUsd`, `sizeSol`, `tokens`), dexterm compares each one with its own paper fill for that signal:
+- slippage, positive when the real fill was worse than paper;
+- latency from the signal to its receipt;
+- partial fills;
+- rejections and failures, with their reasons.
+
+This shows in `dexterm autotrade signal status`, `dexterm autotrade audit`, every run file's receipt rows and the digest. Use it to calibrate: if real fills land 4% worse than paper, the backtests and forward tests are 4% optimistic per trade. With few receipts the numbers say little, and the report says so.

package/dist/packages/mcp/assets/kb/docs/docs-going-real-the-digest.md

@@ -0,0 +1,36 @@
+---
+id: docs-going-real-the-digest
+title: Going real, safely › The digest
+kind: docs
+page: going-real
+page_title: Going real, safely
+heading: The digest
+anchor: the-digest
+url: https://dexterm.xyz/docs/going-real#the-digest
+tags:
+  - docs
+  - going-real
+  - digest
+  - going
+  - real
+  - safely
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/going-real.md
+date: 2026-10-16
+---
+
+`dexterm autotrade report [--period day|week] [--strategy ID]` prints, for each strategy and mode:
+- the closed trades, and the win rate with its 95% interval;
+- the net, and the max drawdown;
+- refusals, the limits that were hit, and the limits that clamped a size;
+- receipts and paper vs real fills;
+- your executor's health.
+
+It always ends with a note on the sample size. Five trades say almost nothing, and the interval shows how little.
+
+`--telegram` sends it to your paired chat through your own bot. `--json` prints it as data. `dexterm autotrade report --schedule daily|weekly|off` makes a run with your bot on send it by itself: once a day after local midnight, or on Mondays. It is off by default.

package/dist/packages/mcp/assets/kb/docs/docs-going-real-the-executor-kit.md

@@ -0,0 +1,48 @@
+---
+id: docs-going-real-the-executor-kit
+title: Going real, safely › The executor kit
+kind: docs
+page: going-real
+page_title: Going real, safely
+heading: The executor kit
+anchor: the-executor-kit
+url: https://dexterm.xyz/docs/going-real#the-executor-kit
+tags:
+  - docs
+  - going-real
+  - executor
+  - kit
+  - going
+  - real
+  - safely
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/going-real.md
+date: 2026-10-16
+---
+
+`dexterm autotrade executor kit --out ~/my-executor` copies three small executors, plain Node with no dependencies:
+
+| file | channel | point dexterm at it |
+|---|---|---|
+| `webhook-executor.mjs` | webhook (127.0.0.1 only) | `dexterm autotrade signal channels --webhook http://127.0.0.1:8787/signal` |
+| `signal-cmd-executor.mjs` | command hook | `dexterm autotrade signal channels --signal-cmd '["/abs/path/node","/abs/path/signal-cmd-executor.mjs","--account","main"]'` |
+| `jsonl-tail-executor.mjs` | the JSONL stream | `dexterm autotrade signal channels --jsonl on --jsonl-signed on` |
+
+Each one handles every signal the same way:
+
+1. It checks the HMAC (`--secret-file`, the file `dexterm autotrade signal secret generate --out FILE` writes).
+2. It checks the account.
+3. It ignores a repeat by nonce. The seen set survives a restart.
+4. It ignores anything past its expiry.
+5. It writes a receipt and sends a heartbeat.
+
+They are **dry run**: they log what they would do, and their receipts say so. There is no wallet code, no key and no chain call in the kit. To trade, you replace one function (`act()` in `kit.mjs`) with your own code, or hand the order to the Telegram trading bot you chose. The kit's `telegram-bot-recipe.md` explains that set-up: a bot cannot read another bot's messages, so a small relay of yours hands each signal to the bot.
+
+`--jsonl-signed on` writes each stream line as an envelope carrying the same HMAC as the webhook, so a stream reader can check it too.
+
+**Prove it end to end:** `dexterm autotrade signal test` sends a signal marked `test: true` that names no coin, so there is nothing in it to trade. For each channel it shows whether the signal was delivered and how long that took, then your executor's receipt (`--wait SEC`, `--json`). The Telegram copy is for you, so it waits for the next run.

package/dist/packages/mcp/assets/kb/docs/docs-going-real-the-whole-path.md

@@ -0,0 +1,37 @@
+---
+id: docs-going-real-the-whole-path
+title: Going real, safely › The whole path
+kind: docs
+page: going-real
+page_title: Going real, safely
+heading: The whole path
+anchor: the-whole-path
+url: https://dexterm.xyz/docs/going-real#the-whole-path
+tags:
+  - docs
+  - going-real
+  - whole
+  - path
+  - going
+  - real
+  - safely
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/going-real.md
+date: 2026-10-16
+---
+
+> **0.2.0, experimental.** Real mode can lead to real trades in a wallet you fund. dexterm never holds a key, never signs and never sends a transaction. Your executor does, by its own rules. Not financial advice.
+
+1. **Build and test on paper.** Make a strategy (from a preset, by chat, or in a file), backtest it on your recorded history, then forward-test it on paper on live data (`dexterm autotrade forward start my-strategy --hours 24`). Arming for real needs a completed forward test with at least 10 closed paper trades and a backtest (the evidence floor, `minForwardTrades`). Paper is the default for every new strategy.
+2. **Wire up an executor, dry run.** Copy the executor kit (https://dexterm.xyz/docs/going-real#the-executor-kit), start one of its executors, point a channel at it, and send a test signal. Nothing can trade yet.
+3. **Set your own limits.** `dexterm autotrade limits set …` (your limits (https://dexterm.xyz/docs/going-real#your-limits)). The defaults are placeholders, and your numbers win.
+4. **Arm on your own terminal.** `dexterm autotrade signal arm my-strategy`. On a first arming dexterm asks for your numbers, then shows the evidence (backtest, forward test), the limits in force for this strategy and account, and your executor's health. Typing the phrase it shows confirms all of it. Below the evidence floor, or past a missing rung of the ladder, it refuses unless you first type a separate OVERRIDE phrase, which is journaled.
+5. **Run it real.** `dexterm autotrade run my-strategy --real`, in the foreground (in 0.2.0 the always-on service runs paper strategies only). Every buy and sell goes to your executor as a LIVE TRADE FIRE signal (https://dexterm.xyz/docs/real-mode#the-signal), inside your limits. When no real run is running, no signal goes out, sells included: positions still open at the end are printed, listed in the `halted` signal and carried (https://dexterm.xyz/docs/real-mode#the-channels) to the next real run; until then, manage them in your executor.
+6. **Watch and calibrate.** `signal status`, the `Q` screen and your Telegram chat show the limits, the executor's health and how far real fills land from paper. The digest (https://dexterm.xyz/docs/going-real#the-digest) sums it up each day or week.
+
+At any point, `dexterm autotrade signal kill` stops every signal, sells included (one final `halted` still goes out, listing the positions still open; it closes nothing), and `dexterm autotrade signal disarm my-strategy` puts the strategy back on paper.

package/dist/packages/mcp/assets/kb/docs/docs-going-real-what-dexterm-does-and-never-does.md

@@ -0,0 +1,44 @@
+---
+id: docs-going-real-what-dexterm-does-and-never-does
+title: Going real, safely › What dexterm does, and never does
+kind: docs
+page: going-real
+page_title: Going real, safely
+heading: What dexterm does, and never does
+anchor: what-dexterm-does-and-never-does
+url: https://dexterm.xyz/docs/going-real#what-dexterm-does-and-never-does
+tags:
+  - docs
+  - going-real
+  - dexterm
+  - does
+  - never
+  - going
+  - real
+  - safely
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/going-real.md
+date: 2026-10-16
+---
+
+**It does:**
+- run your strategy exactly like paper;
+- turn each trade into a signed, numbered, expiring signal for your executor, inside your limits;
+- keep the signal until it is delivered;
+- record what your executor reports;
+- pause new buys when your executor is silent or a loss limit trips;
+- tell you each time.
+
+**It never:**
+- holds, imports or asks for a key or a seed phrase;
+- signs or sends a transaction, or builds one;
+- lets a model, a tool or a chat tap arm real mode, change a limit, lift the kill switch or reset the breaker;
+- trades a test signal;
+- promises a fill or a profit.
+
+Your executor decides, at its own price, with its own fees.

package/dist/packages/mcp/assets/kb/docs/docs-going-real-your-limits.md

@@ -0,0 +1,77 @@
+---
+id: docs-going-real-your-limits
+title: Going real, safely › Your limits
+kind: docs
+page: going-real
+page_title: Going real, safely
+heading: Your limits
+anchor: your-limits
+url: https://dexterm.xyz/docs/going-real#your-limits
+tags:
+  - docs
+  - going-real
+  - limits
+  - going
+  - real
+  - safely
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/going-real.md
+date: 2026-10-16
+---
+
+Every number real mode enforces is yours. They live in one file, `~/.dexterm/autotrade/real/limits.json` (schema `dexterm-limits/1`; `dexterm autotrade limits schema` prints its JSON Schema), outside the model.
+
+**Sizing:**
+- `perTradeSol` and `perTradePct`: the most one buy may spend, in SOL or as a percent of the book. With both set, the smaller wins.
+- `dailySol` and `buysPerDay`: what all buys may spend, and how many there may be, per local day.
+- `maxOpenPositions`: counted across every real holding on this machine.
+- `maxExposurePct`: everything open together, as a percent of the book.
+- `minPositionSol` and `maxPositionSol`: no dust orders, and a cap on one position with its adds.
+- `perCoinSolPerDay` and `perCoinBuysPerDay`: how much one coin may take in a day, re-entries included.
+- `bookSol`: the size of YOUR account, which the percent limits use. Unset, they use the strategy's own book.
+
+**Risk:**
+- `dailyLossSol`: once the day's realized loss reaches it, no new buy goes out until tomorrow.
+- `maxDrawdownSol`: the drawdown breaker. It stops new buys until you reset it with `dexterm autotrade limits breaker reset` (typed). The reset also lifts a loss-streak pause and starts the streak count again.
+- `lossStreak` and `lossStreakPauseMin`: that many losing closes in a row pause new buys for that long.
+- `maxHoldMinutes`: the stricter of this and each exit profile's own cap.
+- `minLiquidityUsd` and `minMcapUsd`: floors on the coin. While one is set, an unknown value is refused.
+- `maxSlippageBps` and `maxPriceImpactPct`: the tolerance a signal states. A buy is cut to the price-impact cap on the pool.
+- `signalTtlSec`: how long your executor may act on a signal.
+- `maxBuysPerMinute`: the signal rate limit.
+
+**Sells:** never capped, unless you set `maxSellsPerMinute`. Only the kill switch stops exits.
+
+**Evidence:** `minForwardTrades`, the evidence floor for arming: the closed paper trades a completed forward test of the strategy's exact rules must have, with a backtest on record. Lowering it or turning it `off` (no trade minimum; the completed forward test and the backtest are still needed) is a raise.
+
+**Executor:** `executorSilenceMin`, how long your executor may be silent before new buys pause (see executor health (https://dexterm.xyz/docs/going-real#executor-health)).
+
+Loss limits are counted on dexterm's own fills: the paper view of every signal.
+
+**Scopes, and the stricter wins.**
+- A number in `global` replaces the placeholder default. `off` turns a global limit off, which is a raise.
+- `real` / `paper` (a mode), `strategy:<id>` and `account:<id>` can only tighten. Whichever scope sets the stricter number, that number is in force: a smaller cap, or a larger floor.
+- Paper runs ignore limits unless you add a `paper` scope. Then a single paper run (`dexterm autotrade run <id> --paper`, a forward test included) obeys them too, the way a real run would, on its own state (it never touches real mode's counters). Limits are in SOL, so a paper replay with a `paper` scope needs `--sol-usd N`. Running several strategies at once (`run --all --paper`) does not apply the paper scope yet.
+- The day's counters (buys, SOL spent, realized loss, per coin) count every real buy from this home: all strategies and accounts together. A `strategy:` or `account:` number is compared with that total, so it can only stop buys sooner, never later.
+
+```
+dexterm autotrade limits show --strategy my-strategy --account main   # what is in force, and where each number comes from
+dexterm autotrade limits set perTradeSol=0.5 dailySol=2 dailyLossSol=0.4
+dexterm autotrade limits set --scope strategy:my-strategy perTradePct=2 maxOpenPositions=1
+dexterm autotrade limits explain maxExposurePct
+```
+
+**Lowering is free and immediate.** A running real run re-reads the file and uses the stricter of what it started with and what the file says now.
+
+**Raising needs you.** `limits set` shows every change old -> new, marks each RAISE, and asks for a typed phrase with a one-time code on your own terminal. A pipe, a flag, an agent or MCP cannot give it. A raise applies from the next run.
+
+**Hand edits.** If you edit `limits.json` by hand, a real run accepts the edit only when it lowers. One that raises anything is refused until you review it (`dexterm autotrade limits diff`) and accept it (`dexterm autotrade limits accept`, typed). Everything is journaled. Caps you set before 0.2.0 (`caps.json`) carry over as your global numbers, unless they differ from what dexterm last saved: then they count as a hand edit too.
+
+**The placeholders** are 0.25 SOL a trade, 1 SOL a day, 20 buys a day, 3 open positions, a stop at -0.5 SOL a day, a pause after 5 losing closes in a row (60 min), at most 3 buys a minute, a pause when your executor is silent for 15 minutes, and an evidence floor of 10 closed paper trades. They are a cautious starting point, not advice. Real mode never arms on them silently: the first arming asks for your own numbers, and every arming shows the limits it confirms.
+
+**The analyst can explain, never apply.** Ask it "why was that buy refused?" or "what would a 1 SOL daily cap change?". It reads the limits (`trading_limits`) and can propose a change as a diff card (`limits_propose`) with the exact command for you to run. No tool, chat command or model decision can change a limit.

package/dist/packages/mcp/assets/kb/docs/docs-going-real.md

@@ -0,0 +1,24 @@
+---
+id: docs-going-real
+title: Going real, safely
+kind: docs
+page: going-real
+page_title: Going real, safely
+url: https://dexterm.xyz/docs/going-real
+tags:
+  - docs
+  - going-real
+  - going
+  - real
+  - safely
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/going-real.md
+date: 2026-10-16
+---
+
+The whole path from a paper strategy to real trades through your own executor. Your own limits on every number, a dry-run executor kit to wire up first, executor health, paper vs real fills, and the daily digest. What dexterm does, and what it never does. Experimental; not financial advice.

package/dist/packages/mcp/assets/kb/docs/docs-live-trading-changed-in-0-1-7.md

@@ -23,4 +23,4 @@ sources:
 date: 2026-10-16
 ---
 
-Earlier 0.1.7 test builds had an experimental local live signer with a dedicated trading wallet, and a LIVE trade ticket signed in Phantom. Both were removed before release, because dexterm should not hold a key. Sending orders to a trading bot of your choice automatically is next (0.1.8, see the roadmap (https://dexterm.xyz/roadmap/)), still with no key in dexterm.
+Earlier 0.1.7 test builds had an experimental local live signer with a dedicated trading wallet, and a LIVE trade ticket signed in Phantom. Both were removed before release, because dexterm should not hold a key. Sending a strategy's trades to an executor of your choice automatically is real mode (https://dexterm.xyz/docs/real-mode), new in 0.2.0, still with no key in dexterm.

package/dist/packages/mcp/assets/kb/docs/docs-live-trading-real-mode-your-strategy-s-trades-to-your.md

@@ -0,0 +1,31 @@
+---
+id: docs-live-trading-real-mode-your-strategy-s-trades-to-your
+title: Live trading › Real mode: your strategy's trades to your executor (0.2.0, experimental)
+kind: docs
+page: live-trading
+page_title: Live trading
+heading: Real mode: your strategy's trades to your executor (0.2.0, experimental)
+anchor: real-mode-your-strategy-s-trades-to-your-executor-0-2-0-experimental
+url: https://dexterm.xyz/docs/live-trading#real-mode-your-strategy-s-trades-to-your-executor-0-2-0-experimental
+tags:
+  - docs
+  - live-trading
+  - real
+  - mode
+  - strategy
+  - trades
+  - executor
+  - experimental
+  - live
+  - trading
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/live-trading.md
+date: 2026-10-16
+---
+
+In real mode (https://dexterm.xyz/docs/real-mode) a strategy you armed on your own terminal sends every buy and sell it decides to your executor as a LIVE TRADE FIRE signal: a local webhook, a command, a stream file or MCP (a bot cannot read another bot's messages), with a copy in your Telegram chat. Your executor holds the wallet and acts on it; dexterm still holds no key and signs nothing. Hard caps, a kill switch (`dexterm autotrade signal kill`) and receipts of what your executor did are all on your machine. Experimental; not financial advice.

package/dist/packages/mcp/assets/kb/docs/docs-live-trading-the-short-version.md

@@ -24,7 +24,7 @@ sources:
 date: 2026-10-16
 ---
 
-> **0.1.7, experimental:** dexterm never holds a key and never signs; live trading happens in the Telegram trading bot of your choice; dexterm 0.1.7 sends alerts and signals to your own bot and does not place orders in it yet; automated order forwarding is next (0.1.8). This path has not been exercised end to end on mainnet yet; testing continues.
+> **0.2.0, experimental:** dexterm never holds a key and never signs. Live trades happen in the executor you choose (a Telegram trading bot behind your own relay, or any script): in real mode (https://dexterm.xyz/docs/real-mode) your strategy sends it a signal for each trade, and it acts by its own rules. Not financial advice.
 
 - **dexterm never holds a key and never signs a transaction.** It has no trading wallet, no signer and no place to keep a private key. It builds no transaction and sends none.
 - **Live trading happens in a Telegram trading bot of your choice.** That bot holds its own wallet and places the orders. You pick it, you fund it, and its rules and fees are its own.

package/dist/packages/mcp/assets/kb/docs/docs-live-trading-using-a-trading-bot-with-dexterm.md

@@ -29,5 +29,3 @@ date: 2026-10-16
 2. Set up dexterm's own bot for your chat: `dexterm telegram setup`, then `dexterm telegram pair`. See Telegram (https://dexterm.xyz/docs/telegram). This is a separate bot that only talks to you.
 3. Run a strategy on paper (`dexterm autotrade run <id> --paper`). Its alerts arrive in your chat.
 4. When you want to act on one, do it in your trading bot.
-
-dexterm has not been tested with any particular trading bot.

package/dist/packages/mcp/assets/kb/docs/docs-live-trading-what-dexterm-does-not-do.md

@@ -24,7 +24,7 @@ sources:
 date: 2026-10-16
 ---
 
-- It does not place an order in your trading bot for you. In this version you act in the bot yourself.
+- It does not place an order in your trading bot for you. In real mode (https://dexterm.xyz/docs/real-mode) it sends your executor a signal; your executor places the order, by its own rules.
 - It does not hold, import, create, decrypt or ask for a private key or seed phrase. Anything that asks you for one is not dexterm.
 - It does not sign or send a transaction. `dexterm wallet link` only proves which wallet is yours with a signed **message** in Phantom; dexterm keeps the public key to show your address. It never asks Phantom to sign a transaction.
 - It does not know what your trading bot did. Positions, fills and P/L in dexterm are paper.

package/dist/packages/mcp/assets/kb/docs/docs-real-mode-receipts-what-your-executor-did.md

@@ -0,0 +1,42 @@
+---
+id: docs-real-mode-receipts-what-your-executor-did
+title: Real mode (LIVE TRADE FIRE signals) › Receipts: what your executor did
+kind: docs
+page: real-mode
+page_title: Real mode (LIVE TRADE FIRE signals)
+heading: Receipts: what your executor did
+anchor: receipts-what-your-executor-did
+url: https://dexterm.xyz/docs/real-mode#receipts-what-your-executor-did
+tags:
+  - docs
+  - real-mode
+  - receipts
+  - executor
+  - did
+  - real
+  - mode
+  - live
+  - trade
+  - fire
+  - signals
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/real-mode.md
+date: 2026-10-16
+---
+
+dexterm cannot see your executor's wallet trades, so a real position stays **unconfirmed** until a receipt arrives. A receipt is data only: it never makes dexterm buy, sell or change anything.
+
+```
+dexterm autotrade receipt 42 executed --size-sol 0.049 --price 0.00121 --tokens 40500 --tx <signature>
+dexterm autotrade receipt 43 rejected --reason "slippage too high"
+dexterm autotrade receipt list
+```
+
+Your executor can also append one line per signal to `~/.dexterm/autotrade/real/receipts.jsonl`: `{"schema":"dexterm-trade-receipt/1","signalId":"…","nonce":42,"accountId":"main","status":"executed","at":1792000004000,"fill":{"priceUsd":0.00121,"sizeSol":0.049,"tokens":40500,"txSig":"…"},"reason":null,"executor":"my-bot"}`. A receipt for an unknown nonce, another account or a mismatched id is counted and ignored.
+
+The exits keep firing on dexterm's own view of the market whether or not a receipt came. A receipt with a fill also says how far the real fill landed from dexterm's paper fill (paper vs real (https://dexterm.xyz/docs/going-real#paper-vs-real)). The drift between signals and receipts (unconfirmed, rejected, failed, filled size and price against the signal) shows in `receipt list`, `signal status`, `dexterm autotrade audit` and the run file (receipt rows). `dexterm autotrade signal reconcile --wallet <your PUBLIC address>` reads that address's SOL balance and token holdings (two read-only calls) and lists the coins the real book holds that the wallet does not, and back. It never takes a key.

package/dist/packages/mcp/assets/kb/docs/docs-real-mode-safety.md

@@ -0,0 +1,34 @@
+---
+id: docs-real-mode-safety
+title: Real mode (LIVE TRADE FIRE signals) › Safety
+kind: docs
+page: real-mode
+page_title: Real mode (LIVE TRADE FIRE signals)
+heading: Safety
+anchor: safety
+url: https://dexterm.xyz/docs/real-mode#safety
+tags:
+  - docs
+  - real-mode
+  - safety
+  - real
+  - mode
+  - live
+  - trade
+  - fire
+  - signals
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/real-mode.md
+date: 2026-10-16
+---
+
+- **Only you switch a strategy to real**, on your own terminal, with the typed phrase. A model cannot: the mode is on the list of fields only you may change, the agent's decisions have no such verb, no MCP tool arms, and a file edited by hand to `"mode": "real"` is not armed. Arming, an evidence override, disarming, caps and the kill switch are all journaled in `~/.dexterm/autotrade/real/journal.jsonl`.
+- **The limits live outside the model** (all of them (https://dexterm.xyz/docs/going-real#your-limits)). A buy is cut to the per-trade, position, exposure and price-impact limits. A buy over the daily SOL, buys per day, per coin or open positions limit is refused (open positions means every real holding on this machine, whichever run opened it). So is a buy after a loss stop, the drawdown breaker or a loss streak, or while your executor is silent. Sells are never blocked by a limit unless you set the optional sell rate, so an exit always goes out.
+- **The real-mode kill switch**: `dexterm autotrade signal kill` stops every trade-fire signal at once, sells included. It never closes a position: it prints the open ones, and a running real run halts at its next tick and sends one `halted` that lists them for your executor. `dexterm autotrade signal unkill` (typed confirmation) lifts it. The panic switch (`dexterm wallet panic`) halts real runs too: no new entries, exits keep going out.
+- **Chat approvals stay paper.** A one-tap approval never authorises a real signal: a strategy that waits for a tap (`entry.decide: "agent+approve"`, or `dexterm telegram approvals on`) does not start in real mode. Your executor is the last gate.
+- The prompt firewall, the strategy clamp and the session caps apply exactly as on paper.

package/dist/packages/mcp/assets/kb/docs/docs-real-mode-set-it-up.md

@@ -0,0 +1,47 @@
+---
+id: docs-real-mode-set-it-up
+title: Real mode (LIVE TRADE FIRE signals) › Set it up
+kind: docs
+page: real-mode
+page_title: Real mode (LIVE TRADE FIRE signals)
+heading: Set it up
+anchor: set-it-up
+url: https://dexterm.xyz/docs/real-mode#set-it-up
+tags:
+  - docs
+  - real-mode
+  - set
+  - real
+  - mode
+  - live
+  - trade
+  - fire
+  - signals
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/real-mode.md
+date: 2026-10-16
+---
+
+1. **A channel your executor can read** (one or more), saved next to your Telegram setup (https://dexterm.xyz/docs/telegram) in `connectors.json`:
+
+   ```
+   dexterm autotrade signal channels --webhook http://127.0.0.1:8787/fire
+   dexterm autotrade signal channels --signal-cmd '["/usr/local/bin/my-executor","--fast"]'
+   dexterm autotrade signal channels --jsonl on
+   dexterm autotrade signal channels --mcp on
+   dexterm autotrade signal channels --telegram on --ttl 60
+   ```
+
+   `off` turns one off. `dexterm telegram status` shows the channels too.
+2. **A webhook secret** (recommended for the webhook): `dexterm autotrade signal secret generate --out /path/for/your/executor.secret` makes a random secret, keeps it in your keychain (like the bot token) and writes it to that file (0600) for your executor. It is never printed. `secret set` reads one from a pipe; `secret remove` deletes it.
+3. **Your limits**: `dexterm autotrade limits set perTradeSol=0.25 dailySol=1 buysPerDay=20 maxOpenPositions=3 dailyLossSol=0.5`, and any of the others (Going real, safely (https://dexterm.xyz/docs/going-real#your-limits)): per trade in SOL or % of book, exposure, position size, per coin, loss stops, the drawdown breaker, max hold, floors, slippage, TTL, rate. You can set them globally, per mode, per strategy or per account, and the stricter wins. Raising any of them asks for a typed confirmation on your terminal; lowering does not. The numbers shown are placeholders. `signal caps set --per-trade-sol …` still sets the first four.
+4. **Arm the strategy** on your own terminal: `dexterm autotrade signal arm my-strategy [--account main]`. On a first arming it asks for your own limits (Enter keeps a placeholder). Then you see the evidence panel: the last backtest of this version, a forward-test report if there is one, the limits in force for this strategy and account, your executor's health and the channels. Then you type the phrase it shows, which confirms those limits, with its one-time code (`REAL my-strategy 7KQ4`). **The evidence floor**: arming needs a completed forward test of these exact rules with at least 10 closed paper trades (your limit `minForwardTrades`) and a backtest on record. Below it, or when arming now would skip a rung of the ladder (https://dexterm.xyz/docs/build-a-strategy-by-chat#the-ladder), arming refuses and says what is missing; only you can go on anyway, by first typing a separate phrase it shows (`OVERRIDE my-strategy 3HXR`, its own one-time code). The override is journaled. No model, tool, flag or pipe can give it. Arming saves the strategy as a new version in mode `real`, and the arming is bound to that exact version: any later edit disarms it. Presets cannot be armed; copy one with `dexterm autotrade new` first.
+5. **Test the channels**: `dexterm autotrade signal test` sends a `test` signal (`test: true`, no coin: nothing to trade) through each channel and shows, per channel, delivered or not, the latency, and your executor's receipt. The dry-run executor kit (https://dexterm.xyz/docs/going-real#the-executor-kit) answers it out of the box.
+6. **Run it**: `dexterm autotrade run my-strategy --real`. In 0.2.0 real mode runs **in the foreground only**: the always-on service runs paper strategies, never a real one. Real mode runs on live data only (a replay would send old prices to your executor). `--sol-usd N` fixes the SOL price for sizes in SOL; without it dexterm reads SOL/USD from DexScreener (keyless) and refuses to start without one.
+
+`dexterm autotrade signal disarm my-strategy` puts it back on paper. `dexterm autotrade run my-strategy --paper` runs a real strategy's paper twin: no signal goes out. `run --all` stays paper: a real strategy runs on its own.

package/dist/packages/mcp/assets/kb/docs/docs-real-mode-the-channels.md

@@ -0,0 +1,42 @@
+---
+id: docs-real-mode-the-channels
+title: Real mode (LIVE TRADE FIRE signals) › The channels
+kind: docs
+page: real-mode
+page_title: Real mode (LIVE TRADE FIRE signals)
+heading: The channels
+anchor: the-channels
+url: https://dexterm.xyz/docs/real-mode#the-channels
+tags:
+  - docs
+  - real-mode
+  - channels
+  - real
+  - mode
+  - live
+  - trade
+  - fire
+  - signals
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/real-mode.md
+date: 2026-10-16
+---
+
+| Channel | How your executor gets it | What counts as delivered |
+|---|---|---|
+| webhook | `POST` of the line to `http://127.0.0.1`, `localhost` or `[::1]` on any port, or to an `https://` URL of yours. Headers `x-dexterm-signature`, `x-dexterm-nonce`, `idempotency-key`. Redirects are refused. | 2xx; 409 means "already have it". 408, 425, 429, 5xx or no answer is retried; any other 4xx is a rejection. |
+| `--signal-cmd` | Your program is started with its argv (an absolute path; no shell, no PATH lookup), the line on stdin, a minimal environment (`DEXTERM_SIGNAL_NONCE`, `DEXTERM_SIGNAL_ID`, `DEXTERM_SIGNAL_SIGNATURE` when a secret is set; nothing else of dexterm's). 10 seconds per call. | exit 0; exit 3 means "already have it"; exit 2 is a rejection; anything else is retried. |
+| JSONL stream | One line per signal appended to `~/.dexterm/autotrade/real/signals.jsonl` (0600), or the path you set. Tail it. | the line is written. |
+| MCP | The read-only MCP tool `trade_fire_feed` returns the signals after a nonce, plus real mode's state. | the line is written to the feed. |
+| Telegram | A `LIVE TRADE FIRE` message to your paired chat, as plain text. For you to read, not for your executor. | Telegram accepted it. |
+
+**Delivery.** A signal is written to the outbox (`~/.dexterm/autotrade/real/outbox.jsonl`) before its fill is booked, so the book never holds anything a signal did not announce. Each channel gets the signals in nonce order, retried with backoff from 1 second up to 30, until it acks, rejects one, or the signal expires (then it is marked expired and never sent late). A restart picks the outbox up where it stopped; nothing is sent twice on purpose, and your executor dedupes the rest by nonce. One process writes the outbox at a time. `dexterm autotrade signal flush` delivers what is pending, and `signal tail` lists the newest signals with their delivery and receipt state.
+
+**The dead-man.** Every signal carries its TTL. A run that ends, halts or is killed sends one final `halted` signal with its outstanding nonces. A runner that dies without one (a crash, a power cut) gets its `halted`, with the reason `runner-lost`, the next time the outbox opens: the next real run or `dexterm autotrade signal flush`.
+
+**A run that ends holding a position.** Ending a real run (its time limit, Ctrl-C, a stop, the kill switch, a halt, a crash) does not sell anything: what is still open is carried. dexterm keeps its real holdings in `~/.dexterm/autotrade/real/held.json`, across runs. You cannot miss them: the run's last lines print the open coins (`REAL POSITIONS STILL OPEN`), the final `halted` signal lists them in `open`, and its Telegram copy says "these positions are still open: manage them in your executor". **When no real run is running, NO signals go out, sells included**: an open position gets no exit from dexterm until the next real run of its strategy, so manage it in your executor. The next real run of the same strategy and account takes them over and their exits keep firing, so a carried coin still gets its sell signal. A carried coin is never bought again while it is held, it counts against the open-position cap, and a coin another strategy holds is not bought. `dexterm autotrade signal held` lists the holdings; if you closed one yourself in your executor, `dexterm autotrade signal release <mint>` (typed confirmation) forgets it.