dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/mcp/assets/kb/docs/docs-paper-trading-the-trade-ledger.md

@@ -0,0 +1,42 @@
+---
+id: docs-paper-trading-the-trade-ledger
+title: Paper trading and the safety model › The trade ledger
+kind: docs
+page: paper-trading
+page_title: Paper trading and the safety model
+heading: The trade ledger
+anchor: the-trade-ledger
+url: https://dexterm.xyz/docs/paper-trading#the-trade-ledger
+tags:
+  - docs
+  - paper-trading
+  - trade
+  - ledger
+  - paper
+  - trading
+  - safety
+  - model
+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/paper-trading.md
+date: 2026-10-16
+---
+
+`dexterm ledger` puts every trade dexterm booked in one table: the paper ticket, the agent paper desk and autotrade runs. One row is one round trip: the strategy and its version, the **exit profile** and entry reason the trade was opened with, the **exit reason**, size and share of the book, entry and exit as price and **market cap**, fees, hold time, the best and worst move while held (MFE / MAE, from the fills), and whether it rugged. Every row dexterm books is PAPER.
+
+- `dexterm ledger trades` lists them, newest first; `positions` shows what is open.
+- `dexterm ledger summary` gives the win rate with its 95% interval, P/L, profit factor, max drawdown, rug rate and hold time, broken down by profile, exit reason, strategy, source and mode. `equity` draws the realized equity curve.
+- `dexterm ledger compare` puts strategy versions side by side, which is how you read strategies you forward-test in parallel.
+- `dexterm ledger export csv|json|parquet-lite` writes the rows out for your own spreadsheet or notebook.
+- `dexterm ledger card <tradeId>` makes a PnL card (https://dexterm.xyz/docs/paper-trading#pnl-cards) from a ledger row, with market cap at entry and exit.
+- Filters: `--source`, `--mode`, `--strategy id[@version]`, `--profile`, `--exit`, `--mint`, `--run`, `--account`, `--days`, `--status`. `--account ID` keeps the trades of the strategies on one paper account (https://dexterm.xyz/docs/autotrade#paper-accounts); the export has an `account` column.
+
+**Declared, not guessed.** An agent declares its exit profile when it buys and its exit reason when it sells, as typed fields on the paper desk (or a PROFILE / EXIT line), and the ledger shows where each tag came from: declared with the fill, from an exit rule, from a tag line, declared later, or missing. Undeclared trades are counted, not filled in.
+
+**Your file, append-only.** Reads never write. `dexterm ledger sync` appends what the sources hold to `~/.dexterm/ledger/trades.jsonl`, where every line is sha256-chained to the one before; `dexterm ledger verify` recomputes the chain and names the first edited line, and an edited file is never appended to. No network, no model, no key.
+
+PAPER rows are simulated. A small number of trades says little, and the summary says so. Not financial advice.

package/dist/packages/mcp/assets/kb/docs/docs-paper-trading-the-wallet.md

@@ -1,9 +1,9 @@
 ---
 id: docs-paper-trading-the-wallet
-title: Paper trading, live trading and the safety model › The wallet
+title: Paper trading and the safety model › The wallet
 kind: docs
 page: paper-trading
-page_title: Paper trading, live trading and the safety model
+page_title: Paper trading and the safety model
 heading: The wallet
 anchor: the-wallet
 url: https://dexterm.xyz/docs/paper-trading#the-wallet
@@ -13,7 +13,6 @@ tags:
   - wallet
   - paper
   - trading
-  - live
   - safety
   - model
 confidence: high
@@ -29,6 +28,6 @@ date: 2026-10-16
 - starts at (generated from the app: see https://dexterm.xyz/docs/paper-trading#the-wallet; app-help has the exact keys and commands) SOL (configurable), persisted in the same SQLite file as the cache and watchlist (`--db`; `:memory:` for a throwaway session);
 - books every fill append-only with the simulated fee (5 000 lamports per fill, labelled as a simulation);
 - marks positions from DexScreener's USD price over the live SOL price every (generated from the app: see https://dexterm.xyz/docs/paper-trading#the-wallet; app-help has the exact keys and commands) s on the positions screen;
-- shows a `◈ POSITION · PAPER` row under the chart on any token you hold, and the same row plus entry line and fill markers in the chart popup (https://dexterm.xyz/docs/popup-chart). A confirmed LIVE fill shows the same way, marked live, read from the signer's own ledger.
+- shows a `◈ POSITION · PAPER` row under the chart on any token you hold, and the same row plus entry line and fill markers in the chart popup (https://dexterm.xyz/docs/popup-chart).
 
-The analyst can open a PAPER ticket for you (`open_ticket`, pre-filled, editing phase) when you ask it to buy or sell. It cannot size it past what you typed, arm it, confirm it, or flip it LIVE; it tells you to confirm yourself.
+The analyst can open a PAPER ticket for you (`open_ticket`, pre-filled, editing phase) when you ask it to buy or sell. It cannot size it past what you typed, arm it or confirm it; it tells you to confirm yourself.

package/dist/packages/mcp/assets/kb/docs/docs-paper-trading-trade-moments.md

@@ -1,9 +1,9 @@
 ---
 id: docs-paper-trading-trade-moments
-title: Paper trading, live trading and the safety model › Trade moments
+title: Paper trading and the safety model › Trade moments
 kind: docs
 page: paper-trading
-page_title: Paper trading, live trading and the safety model
+page_title: Paper trading and the safety model
 heading: Trade moments
 anchor: trade-moments
 url: https://dexterm.xyz/docs/paper-trading#trade-moments
@@ -14,7 +14,6 @@ tags:
   - moments
   - paper
   - trading
-  - live
   - safety
   - model
 confidence: high
@@ -27,6 +26,6 @@ sources:
 date: 2026-10-16
 ---
 
-The cyberspace look reacts to a trade, but only to its **result**. A confirmed buy fires a green shockwave from the ticket with coins streaming up; a profitable sell a gold burst and gold rain; a loss red static that collapses down the screen (no shake, no mockery); a signer refusal or a failed send a red lockout flicker in the bands; and while a send is in flight a neutral cyan scanning sweep that is never a verdict. Normal and fever tiers differ in length and density; `--calm` shows none of it and the result card still lands at once; any key skips a running moment.
+The cyberspace look reacts to a trade, but only to its **result**. A confirmed buy fires a green shockwave from the ticket with coins streaming up; a profitable sell a gold burst and gold rain; a loss red static that collapses down the screen (no shake, no mockery); and a refused or failed order a red lockout flicker in the bands. Normal and fever tiers differ in length and density; `--calm` shows none of it and the result card still lands at once; any key skips a running moment.
 
-Two things are mechanical, not conventions. **Only a settled outcome can fire a moment:** the ticket reports exactly one outcome per booked paper fill, confirmed live fill, signer refusal or send failure, and the effects engine refuses anything without a confirmed-or-failed status; a quote, a PLAN, an armed order or a `send-unknown` (the chain may still confirm it) fires nothing, and a test checks the one call site. **The ticket is shielded:** every cell of the ticket and the PAPER / LIVE banner is marked off-limits on the cell buffer, so rain, glitch, datamosh, scanlines and the moments cannot write a glyph, a colour or a background into it in any phase (tested byte-identical against a calm render at 176, 120 and 90 columns). `--sound` (or `DEXTERM_SOUND=1`) adds short synthesized cues after the same outcome: a buy chirp, a sell sweep then a chime or a thud, a buzz on a failure. Muted by default; the WAVs are written once to `~/.dexterm/sounds` and played detached so the render loop never waits.
+Two things are mechanical, not conventions. **Only a settled outcome can fire a moment:** the ticket reports exactly one outcome per booked paper fill or failure, and the effects engine refuses anything without a confirmed-or-failed status; a quote or an armed order fires nothing, and a test checks the one call site. **The ticket is shielded:** every cell of the ticket and the PAPER banner is marked off-limits on the cell buffer, so rain, glitch, datamosh, scanlines and the moments cannot write a glyph, a colour or a background into it in any phase (tested byte-identical against a calm render at 176, 120 and 90 columns). `--sound` (or `DEXTERM_SOUND=1`) adds short synthesized cues after the same outcome: a buy chirp, a sell sweep then a chime or a thud, a buzz on a failure. Muted by default; the WAVs are written once to `~/.dexterm/sounds` and played detached so the render loop never waits.

package/dist/packages/mcp/assets/kb/docs/docs-paper-trading.md

@@ -1,16 +1,15 @@
 ---
 id: docs-paper-trading
-title: Paper trading, live trading and the safety model
+title: Paper trading and the safety model
 kind: docs
 page: paper-trading
-page_title: Paper trading, live trading and the safety model
+page_title: Paper trading and the safety model
 url: https://dexterm.xyz/docs/paper-trading
 tags:
   - docs
   - paper-trading
   - paper
   - trading
-  - live
   - safety
   - model
 confidence: high
@@ -23,10 +22,10 @@ sources:
 date: 2026-10-16
 ---
 
-The PAPER ticket, the simulated wallet, the confirm gate; the LIVE path behind a separate signer process (devnet first), and the invariants it keeps.
+The PAPER ticket, the simulated wallet, the confirm gate, order plans on paper, PnL cards and the trade ledger. dexterm holds no key and signs nothing.
 
 Trading in dexterm is **PAPER by default**: a simulated wallet priced from live, keyless Jupiter quotes. Nothing is signed, no key is held, no transaction is sent, and the paper code imports no wallet or signing library of any kind. Every ticket and positions frame says so in a banner that is never hidden.
 
-A **LIVE** path exists on main, devnet first and labelled in progress: your own Phantom signs, a separate signer process holds the caps, and a Jupiter swap (a mainnet transaction) is refused unless you start dexterm with `--mainnet`. It is described in Live trading (devnet first) (https://dexterm.xyz/docs/paper-trading#live-trading-devnet-first) below.
+dexterm has no live trading path of its own: it holds no key, has no trading wallet and builds or sends no transaction. Live trading happens in a Telegram trading bot of your choice; see Live trading (https://dexterm.xyz/docs/live-trading).
 
 PAPER positions on sample data

package/dist/packages/mcp/assets/kb/docs/docs-popup-chart-buy-and-sell-markers.md

@@ -0,0 +1,37 @@
+---
+id: docs-popup-chart-buy-and-sell-markers
+title: Popup chart › Buy and sell markers
+kind: docs
+page: popup-chart
+page_title: Popup chart
+heading: Buy and sell markers
+anchor: buy-and-sell-markers
+url: https://dexterm.xyz/docs/popup-chart#buy-and-sell-markers
+tags:
+  - docs
+  - popup-chart
+  - buy
+  - sell
+  - markers
+  - popup
+  - chart
+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/popup-chart.md
+date: 2026-10-16
+---
+
+Every fill of the coin in your ledgers is marked on the chart: the **paper ledger** (your PAPER trades and an agent's PAPER trades) and the **live ledger** (confirmed real swaps from a linked wallet). Nothing is fetched to draw them, and they show whether or not you still hold the coin.
+
+- A buy is a triangle pointing up with `B` under it, its tip on the fill price; a sell points down with `S` above it. **Hollow** triangles (`△ ▽`) are PAPER, **solid** ones (`▲ ▼`) are live, and the colour only adds to that.
+- Each fill sits on the bar whose period contains its time, on every timeframe: switch from 1m to 1h and the markers move to their 1h bars. Two fills of one side in one bar make one marker with a count (`S×2`) at their size-weighted price, so a position sold in three parts shows three sells on 1m and fewer, counted ones on 1h. Zoom far out and neighbouring markers merge the same way, so they never pile up.
+- Hover a marker for its time, price (market cap with the price in brackets on the market cap axis), size in tokens and SOL, and the ledger it came from. A sell that left tokens says `partial`; the one that closed the position says `closed`.
+- While a position is open, the average entry is a dashed line. A closed round trip gets a faint wash from the entry bar to the exit bar (green when it sold above the entry).
+- A fill outside the candles on screen is never moved onto another bar. The legend says how many are off the chart and why: older than the first candle, newer than the last one (the candle feed lags a minute or two), or in a minute with no trades.
+- **MARKERS** in the toolbar, or `k`, turns them off and on for both charts; the terminal saves it as `display.chartMarkers` (see chart markers (https://dexterm.xyz/docs/configuration#chart-markers)). A fill with no recorded USD price is drawn against its bar and says `price not recorded`.
+
+Display only: no marker can arm, size, sign or confirm anything.

package/dist/packages/mcp/assets/kb/docs/docs-popup-chart-market-cap-axis.md

@@ -25,4 +25,4 @@ sources:
 date: 2026-10-16
 ---
 
-When the terminal is in market cap mode (https://dexterm.xyz/docs/configuration#price-display-mode) (`$`), the popup follows it within a tick: the Y axis, the last-value and position-line labels, the EMA / VWAP values and the header read **market cap** in K / M / B (`300K`, `1.2M`), and the crosshair legend shows the market cap with the price in parentheses (`C 1.2M ($0.0₃12)`). The window title says `mcap (current supply)`: every bar is scaled by today's supply (market cap ÷ price at the latest tick, as the terminal knows it), so older bars are not the exact market cap of their time. The bars themselves stay USD prices, so the entry, stop and target lines and the fill markers keep their meaning; only the labels change. When the coin has no known supply the popup keeps prices and the title says `supply unknown · showing price`. The position row reads AVG MC / MCAP; profit and loss stay in USD.
+The Y axis shows **market cap by default**. The **MCAP | PRICE** control in the toolbar, `A` or `y` in the popup, or `A` on the terminal's token screen switches it; the terminal saves the choice (`display.chartAxis`, see chart Y axis (https://dexterm.xyz/docs/configuration#chart-y-axis)) and the popup follows within a tick. In market cap the Y axis, the last-value and position-line labels (ENTRY, STOP, TARGET), the EMA / VWAP values and the header read **market cap** in compact form with a lowercase k (`4.9k`, `487k`, `1.2M`, `1.3B`), and the crosshair legend shows the market cap with the price in parentheses (`C 1.2M ($0.0₃12)`). The volume pane stays USD, also compact (`$20k`). In price mode the axis uses the subscript form for tiny prices (`0.0₅493`), never scientific notation. The window title says `mcap (current supply)`: every bar is scaled by today's supply (market cap ÷ price at the latest tick, as the terminal knows it), so older bars are not the exact market cap of their time. The bars themselves stay USD prices, so the entry, stop and target lines and the fill markers keep their meaning; only the labels change. When the coin has no known supply the popup keeps prices and the title says `price (mcap unavailable)`. The position row reads AVG MC / MCAP; profit and loss stay in USD.

package/dist/packages/mcp/assets/kb/docs/docs-popup-chart-what-it-shows.md

@@ -26,5 +26,7 @@ date: 2026-10-16
 - candles, line or area; a volume pane; crosshair with the OHLCV, change and indicator values of the bar under it; wheel and pinch zoom, drag pan; auto, log or percent scale; local-time axis.
 - the last-price line, and a dotted **LIVE** price line while the terminal's fast lane is streaming the coin; a `◌ STALE Ns` badge when no tick has arrived for 20 s.
 - buy and sell markers from the trade tape, EMA 9/21, VWAP (anchored to the UTC day), a volume 20-MA, horizontal and trend lines you draw (page memory only; they go when the popup closes).
-- when you hold a PAPER position in the coin: an ENTRY line labelled with size and PnL %, BUY and SELL fill markers for the current position, STOP and TARGET lines when a ledger sets them, and the same position row the terminal shows under its chart.
+- **your own buys and sells** on every timeframe: every fill of the coin from the paper ledger and the live ledger, open position or closed, as BUY and SELL markers (https://dexterm.xyz/docs/popup-chart#buy-and-sell-markers).
+- when you hold a position in the coin: a dashed **AVG ENTRY** line labelled with size and PnL %, STOP and TARGET lines when a ledger sets them, and the same position row the terminal shows under its chart.
+- while an auto mode runs and a position is open (an agent you follow holds a PAPER position, or AI scan mode with your own position), the PnL chip (https://dexterm.xyz/docs/spectator#the-brain-view-and-the-pnl-chip) under the toolbar, with the same fields as the terminal's. It is about the held coin, which need not be the coin on the chart. Display only.
 - the six timeframes are the popup's own. 5m and 15m are derived from the cached 1m base, 4h and 1d from the cached 1h base, so switching costs no fetch; a base the terminal has not fetched yet shows an honest "warming … no extra requests" banner until it lands. **1s is not offered:** the only trade source is a ≤60-trade tape refreshed at most every 20 s, so 1-second bars would be sparse and stale.

package/dist/packages/mcp/assets/kb/docs/docs-scan-the-read.md

@@ -23,3 +23,5 @@ date: 2026-10-16
 ---
 
 A lock opens the coin exactly as `⏎` would (the same loader, the same fetches that token costs anyway) and starts a chat turn asking for the short read, with the WHY reasons passed as **numbers only, never token text**. Refreshes ask the same warm session what changed. Answers follow the short style (https://dexterm.xyz/docs/analyst#answer-style): call, why, levels, size, one risk.
+
+While the scan is on, the token screen's analyst panel is the scan's **brain view** (on the locked coin, or on any coin while it is still scanning). It shows the scan's own log (on, locks with their score and reasons, refreshes, releases, cancels and blocked actions) with the scan analyst's answer streaming under it, the vetting checklist and data strip for the coin with the app's numbers, and a `SCAN LOG` with `locks · reads · ai usage · observe-only · never trades`. It is the same layout as the agent brain view (https://dexterm.xyz/docs/spectator#the-brain-view-and-the-pnl-chip), with no position block, because the scan never trades. Typing into the analyst, or stopping the scan, brings the normal panel back. While the scan runs and you hold a paper or live position yourself, the PnL chip (https://dexterm.xyz/docs/spectator#the-brain-view-and-the-pnl-chip) shows it on the band under the header of every screen and on the chart popup. It shows the coin the scan locked if you hold it, otherwise the coin on screen, otherwise your first open position. The peak is this session's highest mark, and TP is the ledger's target (`TP not set` when there is none). The scan still never trades.

package/dist/packages/mcp/assets/kb/docs/docs-screens-autotrade-paper.md

@@ -0,0 +1,26 @@
+---
+id: docs-screens-autotrade-paper
+title: Screens tour › Autotrade (paper)
+kind: docs
+page: screens
+page_title: Screens tour
+heading: Autotrade (paper)
+anchor: autotrade-paper
+url: https://dexterm.xyz/docs/screens#autotrade-paper
+tags:
+  - docs
+  - screens
+  - autotrade
+  - paper
+  - tour
+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/screens.md
+date: 2026-10-16
+---
+
+`Q` from anywhere opens AUTOTRADE: your strategies and the presets, a strategy editor that re-validates on every change, a side-by-side compare, backtests and held-out sweeps on your recorded history, and the runner view. `tab` moves between them. Everything on it is paper; nothing on it can switch a strategy to live or touch a wallet. The views and keys are in Autotrade (paper) (https://dexterm.xyz/docs/autotrade#on-the-q-screen).

package/dist/packages/mcp/assets/kb/docs/docs-screens-dev-history.md

@@ -25,16 +25,19 @@ date: 2026-10-16
 
 *Since 0.1.5.* "Has this deployer rugged before?" The ON-CHAIN panel adds the creator's **recorded** track record, from dexterm's own history recorder (https://dexterm.xyz/docs/configuration#history-recorder), keyless:
 
-| row | what it shows |
-| --- | --- |
-| Dev rugs (recorded) | rugs out of the creator's **labelled** prior launches, with the sample (`2/5 · n=5`); red at two or more (the `serial_rugger` flag), `unknown` with no labelled record |
-| Dev launches seen | prior launches the recorder linked to this wallet, and which source named the creator |
-| Dev sold its bag | median minutes from launch to the dev's exit on prior launches (held over 0.5 % of supply, then 0.1 % or less), with n |
-| Dev linked | the creator's funder or the linked cluster it sits in (same funder, same-block bundle, transfers) from the wallet-intel scan (https://dexterm.xyz/docs/screens#bubble-map), and how many of those wallets launched coins that rugged |
+| row | what it shows | example |
+| --- | --- | --- |
+| Dev rugs | rugs out of the creator's **labelled** prior launches, the sample, and how long ago the newest of those labels settled; red at two or more (the `serial_rugger` flag), `unknown` with no labelled record | `2/5 · n=5 · rec 3d` |
+| Dev launches | prior launches the recorder linked to this wallet, how long ago the newest was seen, and which feed named the creator (`jup`, `pump`, `rc`) | `n=5 · rec 2h · dev:jup` |
+| Dev sold bag | median minutes from launch to the dev's exit on prior launches (held over 0.5 % of supply, then 0.1 % or less), the sample, and the age of the newest exit seen | `med 20m · n=3 · rec 1d` |
+| Dev linked | the creator's funder or the linked cluster it sits in (same funder, same-block bundle, transfers) from the wallet-intel scan (https://dexterm.xyz/docs/screens#bubble-map), and how long ago that scan ran | `funder 3w · scan 4m` |
+| Linked dev rugs | labelled rugs by the other wallets in that cluster that dexterm saw launching coins, how many such wallets, and the age of their newest label | `1 · n=1 devs · rec 7d` |
+
+`rec` is dexterm's own recorder, `scan` the wallet-intel scan; every age is how old the newest datum behind the number is.
 
 - **Where the creator comes from.** The wallet a keyless source names when dexterm sees the coin: Jupiter's `dev` field on every token row, a PumpPortal create, or RugCheck's new-token feed. The first source wins and is recorded with the time. GoPlus is asked only by the MCP tool, as a last resort.
 - **Where the outcomes come from.** The recorder's code-only labels (rug, dead, fade, flat, runner; the 72-hour label when known, else the longest one settled). They are the keyless-proxy tier: a rug is a liquidity collapse the recorder saw, not a verified on-chain drain.
-- **Honest by construction.** Every number names its sample and age. No record is `unknown`, never "clean". Only coins this machine's recorder saw count, so a deployer's launches dexterm never saw are missing; run `dexterm record` (https://dexterm.xyz/docs/configuration#headless-recorder-dexterm-record) to keep it fed. It is a risk flag from observed history, never a certificate.
+- **Honest by construction.** Every row names its source, its sample and the age of its newest datum. No record is `unknown`, never "clean". Only coins this machine's recorder saw count, so a deployer's launches dexterm never saw are missing; run `dexterm record` (https://dexterm.xyz/docs/configuration#headless-recorder-dexterm-record) to keep it fed. It is a risk flag from observed history, never a certificate. On a window too short for every ON-CHAIN row, the red, then amber rows stay and the last line says how many rows are hidden (`+3 rows hidden`).
 - **Alerts.** The rule field `devrugs` is the creator's labelled rugs (unknown = no match). A brand-new pair from a wallet with a record joins the rule rows, so this fires on launch:
 
 ```text

package/dist/packages/mcp/assets/kb/docs/docs-screens-order-plans.md

@@ -23,4 +23,4 @@ sources:
 date: 2026-10-16
 ---
 
-`O` from anywhere opens the order-plans screen: a PLANS / MANDATES tab strip (`tab` flips), each plan on one line with its status tone (proposed, armed, filled, done, cancelled, expired) and the signer's read-back of what it will do. `a` on a row opens a hold-to-arm prompt; only a key held at the terminal arms, and the prompt is unreachable from the popup, voice, an agent or piped input. `c` cancels a plan, `r` revokes a mandate, `!` is panic (revoke everything), `M` opens the read-only plans popup, `G` shows the hands-free gate setting (GATE ON by default), and `L` raises the fire-path prompt: a held keypress switches plan fills between PAPER and LIVE · DEVNET · fast wallet (refused while plans are armed, without the signer process, off devnet or without a fast wallet). The header says PAPER unless a fill path is provably live. Plans, mandates, caps and the journal are in order plans and standing mandates (https://dexterm.xyz/docs/paper-trading#order-plans-and-standing-mandates).
+`O` from anywhere opens the order-plans screen: a PLANS / MANDATES tab strip (`tab` flips), each plan on one line with its status tone (proposed, armed, filled, done, cancelled, expired) and the plan's read-back of what it will do. `a` on a row opens a hold-to-arm prompt; only a key held at the terminal arms, and the prompt is unreachable from the popup, voice, an agent or piped input. `c` cancels a plan, `r` revokes a mandate, `!` is panic (revoke everything), `M` opens the read-only plans popup, `G` shows the hands-free gate setting (GATE ON by default), and `L` raises the fire-path prompt: a held keypress switches plan fills between PAPER and LIVE · DEVNET · fast wallet (refused while plans are armed, without the signer process, off devnet or without a fast wallet). The header says PAPER unless a fill path is provably live. Plans, mandates, caps and the journal are in order plans and standing mandates (https://dexterm.xyz/docs/paper-trading#order-plans-and-standing-mandates).

package/dist/packages/mcp/assets/kb/docs/docs-screens-token-screen.md

@@ -29,6 +29,8 @@ Everything about one coin: candles (1m to 1d, `1`–`6`), market stats, mint and
 
 The price badge says **LIVE** only while a fresh on-chain push is flowing for that coin over the fast lane (one WebSocket on its pump.fun bonding curve), otherwise **POLL**. When you hold a PAPER position in the coin a `◈ POSITION · PAPER` row renders under the chart with side, size, value, average entry, price and unrealized PnL.
 
+**Your buys and sells on the chart.** Every fill of the coin in your paper ledger and live ledger is marked on its candle: `△B` / `▽S` for PAPER, `▲B` / `▼S` for live, with a count when one candle holds several (each partial sell of a position gets its own marker on a fine timeframe). While a position is open a dashed `avg` line marks the average entry, and a closed round trip gets a faint wash from entry to exit. A fill outside the candles on screen is not moved; the legend says how many are off the chart. See chart markers (https://dexterm.xyz/docs/configuration#chart-markers).
+
 **Who holds it.** Once the wallet-intel scan (https://dexterm.xyz/docs/screens#bubble-map) lands (about 1.5 s after the token opens), every row of the HOLDERS panel carries a class read from the chain, never guessed: **POOL** (an AMM / CLMM / DLMM pool vault: Raydium, Orca, Meteora, PumpSwap), **CURVE** (a bonding curve: pump.fun, Meteora DBC for Jupiter Studio and Meteora launches, Raydium LaunchLab), **VAULT** (Meteora dynamic and Alpha vaults), **LOCK** (a Streamflow or Jupiter Lock escrow), **CEX** (seed-list exchange wallet, always *unverified*), **BURN** (the incinerator), **DEV** (the creator), **LINKED** (tied to another top holder by a funder, bundle or transfer rule) and **UNLABELLED** for everything else, including an account of a program dexterm does not list. The class comes from the token account's owner and the owner account's program (the same account lookup the scan already makes, no new request); the constant pool-authority addresses are re-derived in the tests. The single Top 10 holders row then becomes two: **Top 10 ex-pool** drops POOL / CURVE / VAULT / LOCK / BURN owners and is what the colour reads, **Top 10 raw** is what explorers show, so a fresh launch whose curve still holds 70 % no longer reads as a 78 % whale. Unlabelled owners are always counted. When a counted owner holds more than 30 % the panel says so on its first line (`⚠ main risk: UNLABELLED Ab12…Cd34 holds 71.6%`); when the biggest holder is a venue it says which (`· top holder 70.0% is CURVE (Meteora DBC): not counted in ex-pool`). A lock or vault names its escrow and program; dexterm does not decode the unlock schedule yet and says so.
 
 When the Snipers and Bundled supply rows have no number they give the reason: `needs Helius key` only when no key is configured, otherwise `Helius paused · r` (rate-limited), `Helius cap today` (the daily credit budget is spent), `history failed · r` (the history call errored) or `no launch txs read`. `r` on the token screen re-runs a scan whose launch window did not land.

package/dist/packages/mcp/assets/kb/docs/docs-spectator-follow-over-mcp-in-the-running-terminal.md

@@ -32,7 +32,7 @@ date: 2026-10-16
 An agent connected over MCP (Claude Code, Claude Desktop, Cursor, Codex — set up with `dexterm mcp install`) runs the `dexterm mcp` server as its own process, which the app cannot see into. Since 0.1.4, run the app with `dexterm --spectate-mcp` and the running terminal **follows** that agent:
 
 - While the flag is on, the app writes a small local rendezvous under `~/.dexterm` (mode 0600). The `dexterm mcp` server notices it and starts emitting one record per tool call to a local channel the app tails. When you are not following, the file is absent and the server writes nothing — there is no cost when nobody is watching.
-- A **navigation** call (open a token, switch screen or feed, set a filter, highlight a row, open the paper ticket) moves the real screen, with a status line like `agent <name>: opened BONK`. These are the same read-only moves the analyst makes; nothing an agent does here can size, confirm, sign, send or raise a cap. From 0.1.5, if you start with `--agent-paper <mandate-id>`, the agent's **simulated** trades show here too as `PAPER …` rows. They never move your screen, and Ctrl+P, Ctrl+K and taking over halt them (agent paper trading (https://dexterm.xyz/docs/agents#agent-paper-trading)).
+- A **navigation** call (open a token, switch screen or feed, set a filter, highlight a row, open the paper ticket) moves the real screen. The agent HUD (https://dexterm.xyz/docs/spectator#the-agent-hud-spectator-v2) shows the move (a terminal shorter than 24 rows gets a status line like `agent <name>: opened BONK` instead). These are the same read-only moves the analyst makes; nothing an agent does here can size, confirm, sign, send or raise a cap. From 0.1.5, if you start with `--agent-paper <mandate-id>`, the agent's **simulated** trades show here too as `PAPER …` rows. They never move your screen, and Ctrl+P, Ctrl+K and taking over halt them (agent paper trading (https://dexterm.xyz/docs/agents#agent-paper-trading)).
 - The controls are at your keyboard: **ctrl+p** pauses and resumes the mirroring, **ctrl+k** stops following (it removes the rendezvous, so the server stops emitting), and **any other key** hands control back to you — the agent can never move the screen out from under you.
 - A read-only, loopback, token-gated stream opens too, so `dexterm spectate --info` shows its endpoint while you follow. Every record is authenticated by the rendezvous token before it is folded, and every shared copy is redacted (see what is redacted (https://dexterm.xyz/docs/spectator#what-is-redacted)). This is on the owner's own machine, so follow mode itself shows full detail.
 

package/dist/packages/mcp/assets/kb/docs/docs-spectator-limits.md

@@ -29,6 +29,8 @@ Stated plainly, as of `(generated from the app: see https://dexterm.xyz/docs/spe
 
 - **The AGENT ACTIVITY window is a separate window with its own screen model.** Its `screen` line shows the screen the agent *asked for*, built from its navigation events, and the bus runs in its own process (`dexterm agent serve`), so that window is not a mirror of your terminal. The running terminal itself **does** move when you follow with `dexterm --spectate-mcp` (follow mode) — that is a different surface from the popup window.
 - **MCP agents are shown in follow mode, which you turn on.** Agents connected through `dexterm mcp` (Claude Code, Claude Desktop, Cursor or Codex, set up with `dexterm mcp install`) appear once you run the app with `dexterm --spectate-mcp`; the terminal then follows them and a read-only stream opens. Without the flag the MCP server emits nothing. The built-in analyst drives the terminal through its own action channel and shows `analyst did X`.
+- **The thought ribbon only shows what the agent writes down.** dexterm cannot read an agent's mind: without `--spectate-thoughts FILE`, the ribbon narrates the calls themselves. The agent label in the dock is the one this terminal gives it (`mcp-agent`); the MCP server does not tell the app which client is calling.
+- **The mark PnL is approximate.** It is the move of the coin's price since the paper entry, at this terminal's last price for it (or the last price a tool call returned), before fees. The paper ledger's own numbers are on the fill, the position panel and the result card.
 - **Replay is text.** `dexterm spectate --replay` prints the session in the terminal. It does not reopen the window.
 - **No stream viewer ships.** The raw stream is for your own tooling.
 - **Redaction matches patterns.** It masks anything shaped like an address or a key. Other text, such as a token symbol, a filter or a number, is shown as it is.

package/dist/packages/mcp/assets/kb/docs/docs-spectator-the-agent-hud-spectator-v2.md

@@ -0,0 +1,58 @@
+---
+id: docs-spectator-the-agent-hud-spectator-v2
+title: Spectator view (watch the agent cook) › Follow over MCP in the running terminal › The agent HUD (spectator v2)
+kind: docs
+page: spectator
+page_title: Spectator view (watch the agent cook)
+heading: The agent HUD (spectator v2)
+anchor: the-agent-hud-spectator-v2
+url: https://dexterm.xyz/docs/spectator#the-agent-hud-spectator-v2
+tags:
+  - docs
+  - spectator
+  - agent
+  - hud
+  - follow
+  - over
+  - mcp
+  - running
+  - terminal
+  - view
+  - watch
+  - cook
+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/spectator.md
+date: 2026-10-16
+---
+
+While the terminal follows an MCP agent, it shows the agent working, not a list of calls. The app's own screen renders a few rows shorter, so nothing of it is hidden, and an **agent dock** sits under it:
+
+- **The heartbeat and the phase rail.** A heartbeat trace beats faster as the agent calls more tools. The rail `SCANNING ─ VETTING ─ SIZING ─ EXECUTING ─ HOLDING ─ EXITING` lights the phase it is in. While it holds a position and checks other coins, the rail stays on HOLDING and shows the side activity next to it.
+- **The thought ribbon.** The agent's own words, typed in as it thinks, when you pass `--spectate-thoughts FILE` (see below). Otherwise dexterm narrates what each call did, from the call's own numbers ("scanning 12 rows · 3 moving up", "verdict WATCH · rug heuristic 11%").
+- **The call timeline.** Each call is a node, newest on the right, spaced by the time between calls. Under each node is a result chip: green for ok, amber for slow, red for a failure or a refusal. PAPER calls are marked.
+- **`PAPER` and the controls are always on screen**: **^P** pause, **^K** kill.
+
+Over the screen itself:
+
+- The **rows the agent scans glow**, with a beam sweeping down them. The row it opens gets the **agent cursor** (`▶ … ◀ AGENT`), and the token screen assembles top-down as it opens.
+- A **vetting card** fills in the checks the agent ran (price, tape, chart, holders, rug, dev, LARP, verdict). Its **LARP gauge** sweeps to the number of evidence flags `larp_check` found; that number is evidence, not a verdict.
+- **The PAPER execution moment** (with `--agent-paper`): an order ticket assembles with the size, your per-trade cap and the gate as it really is (your keypress armed the mandate; inside it there is no keypress per paper trade, and the desk enforces the caps). Then the fill lands with a flash and the entry from the paper fill, and the ticket turns into a **position panel**. That panel shows the mark PnL as a big number with a trace, the peak and the time held. The mark is this terminal's own price for the coin, or the price a tool call returned, never a number the agent typed. Each exit flashes. When the position is flat, a **result card** shows the realized PAPER result, the hold time and the exits.
+- **Kill is a hard stop.** **^K** cuts the screen with a red flash and a short glitch, stamps `KILLED`, closes the agent's session and stops its paper desk for the rest of the run. The dock then stays on `AGENT KILLED`. **^P** pauses (the band under the header says so and the screen is framed in amber), and any other key hands the screen to you.
+
+Every number the HUD shows comes from the app: a tool's own result (the rows a scan returned, the verdict, the paper ticket, fill and position, the caps the desk replayed) or this terminal's price. The agent's text is display only: it is scrubbed and clipped, and nothing in it is acted on.
+
+**Motion and colour.** Calm mode (`--calm` or the `C` key) is the reduced-motion setting here as everywhere else. The sweeps, flashes, the glitch and the typing go away, and every card and number appears at once. With `NO_COLOR` the meaning stays in glyphs: `▸` marks the active phase, chips carry `✓ ! ✗`, and the cursor is `▶`. A terminal shorter than 24 rows gets no HUD; the status lines are shown as toasts instead, and the PnL chip moves to the band under the header.
+
+#### The thought ribbon: `--spectate-thoughts FILE`
+
+dexterm cannot see inside your agent, so its words come from a file the agent writes. Pass `--spectate-thoughts FILE` (with `--spectate-mcp`). The file can be:
+
+- Claude Code's stream output (`claude -p --output-format stream-json --verbose … > FILE`): text and thinking blocks;
+- a JSONL file with `{"thought": "…"}` lines.
+
+The file is tailed for display only, and each line is scrubbed: control and bidirectional characters are removed, addresses are masked and markdown is dropped. One message becomes one short line.

package/dist/packages/mcp/assets/kb/docs/docs-spectator-the-brain-view-and-the-pnl-chip.md

@@ -0,0 +1,46 @@
+---
+id: docs-spectator-the-brain-view-and-the-pnl-chip
+title: Spectator view (watch the agent cook) › Follow over MCP in the running terminal › The brain view and the PnL chip
+kind: docs
+page: spectator
+page_title: Spectator view (watch the agent cook)
+heading: The brain view and the PnL chip
+anchor: the-brain-view-and-the-pnl-chip
+url: https://dexterm.xyz/docs/spectator#the-brain-view-and-the-pnl-chip
+tags:
+  - docs
+  - spectator
+  - brain
+  - view
+  - pnl
+  - chip
+  - follow
+  - over
+  - mcp
+  - running
+  - terminal
+  - watch
+  - agent
+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/spectator.md
+date: 2026-10-16
+---
+
+While the agent is active (it made a call in the last 3 minutes, or it holds a PAPER ticket or position), the **ANALYST panel on the token screen becomes the agent's BRAIN VIEW** instead of the "press a for a dossier" help. Top to bottom:
+
+- **REASONING.** The agent's thoughts (from `--spectate-thoughts`) typing in, newest at the bottom, each with its clock time and the phase it was in (`SCANNING`, `VETTING`, `SIZING`, ...). Older lines dim, and long lines are clipped. With no thoughts feed, the header says `dexterm narration · no thoughts feed` and the lines are dexterm's own narration of each call. Lines a demo or stand-in feed marks as scripted (`"demo": true`) carry the coral `claude lines: demo text` tag.
+- **VETTING $COIN.** The checklist for the coin on screen: momentum, liquidity against the $10K floor, tape buys/sells and wallet count, top-10 concentration, mint/freeze authority, LP lock, dev history, LARP flags, the rug heuristic and the verdict. Each box shows the number the app computed and `pass`, `warn`, `fail` or `pending` (pending = that number is not in yet). `◆` marks the checks the agent itself ran.
+- **DATA.** Market cap, price, liquidity, 5m and 1h moves, buy/sell flow and holders, with a candle trace. A `B` or `S` cell on the trace marks the candle of each fill of the coin in your ledgers (the chart markers (https://dexterm.xyz/docs/configuration#chart-markers)). These are the numbers already on screen; there is no extra fetch.
+- **PLAN / POSITION** (while a PAPER ticket or position is open): entry, size, the take-profit and stop the agent *said* (labelled `agent's plan`, or `no stop`), mark PnL in % and paper $, peak, drawdown from the peak, time held, and what it is waiting for. A desk refusal is stamped here.
+- **DECISIONS.** The session log (`rejected DECOY · verdict AVOID`, `entered`, `sold`, `desk refused`) and a scoreboard: `PAPER simulated · vetted · entries · closed · realized SOL`.
+
+The normal analyst panel returns when the agent is killed, goes quiet, or before its first call, and also while you type into the analyst. Smaller panels drop blocks in order: the decision log first, then the data strip, then the checklist folds into two columns. The plan and the reasoning stay.
+
+**The PnL chip.** While the agent holds a PAPER position, a chip shows it: `PAPER $COIN │ ▲ +24.0% +$2.40 │ peak +31.0% │ $0.0100 → $0.0124 │ held 1m04s │ dd −5.3% │ TP +40%`. It is on every terminal screen (screener, new pairs, watchlist, token screen, analyst) and on the chart popup (https://dexterm.xyz/docs/popup-chart#what-it-shows). On a terminal with 24 rows or more it sits in the dock's top row. On a shorter terminal there is no dock, and the chip sits on the band under the header instead. It updates on every mark tick and flashes on a new peak (a `★` under calm mode and `NO_COLOR`). Fields drop from the right on narrower terminals. The held coin stays in the fast price lane, so the chip keeps marking after the coin scrolls off the screener. In AI scan mode (https://dexterm.xyz/docs/scan#the-read) the same chip shows your own open paper or live position. The chip only shows in these two auto modes. The other popups (token, bubble map, feeds) do not carry it.
+
+Both are display only. They have no input and cannot arm, size, sign, confirm or raise a cap. The agent's text is scrubbed and clipped, and addresses are shortened.

package/dist/packages/mcp/assets/kb/docs/docs-spectator-the-three-surfaces.md

@@ -30,7 +30,7 @@ All three read the same events from one in-memory hub, which `agent serve` creat
 
 | surface | start it with | what you get |
 | --- | --- | --- |
-| AGENT ACTIVITY window | `dexterm agent serve --spectator-popup` | a window titled "watch the agent cook" with live activity and the pause, take over and kill controls |
+| AGENT ACTIVITY window | `dexterm agent serve --spectator-popup` | a window titled "watch the agent cook": the agent's phase rail and heartbeat, its thought ribbon, a call timeline with result chips, the coin it is vetting and its PAPER trade, over the live activity, with the pause, take over and kill controls |
 | read-only stream | `dexterm agent serve --spectate` | a loopback WebSocket that sends events out and accepts no commands |
 | save and replay | `dexterm agent serve --record FILE`, then `dexterm spectate --replay FILE` | a redacted JSONL file of the session that you can replay offline |
 

package/dist/packages/mcp/assets/kb/docs/docs-spectator.md

@@ -22,7 +22,7 @@ sources:
 date: 2026-10-16
 ---
 
-Watch a connected agent work in real time. An AGENT ACTIVITY window with pause, take over and kill, a read-only loopback stream, and redacted save and replay. Covers what is redacted, the security model, how to capture it for a stream, and its limits.
+Watch a connected agent work in real time. The agent HUD in the running terminal (phase rail, heartbeat, thought ribbon, call timeline, the PAPER execution moment), an AGENT ACTIVITY window with pause, take over and kill, a read-only loopback stream, and redacted save and replay. Covers what is redacted, the security model, how to capture it for a stream, and its limits.
 
 The spectator view lets you watch an agent work: each time a connected agent calls a tool (opens a token, runs a LARP check, scans new pairs, reads a bubble map, makes a proposal, gets refused), the call shows up with its result, how long it took and how old its data was. It is for watching and for demos ("watch the agent cook"). It adds no new power: agents stay untrusted (https://dexterm.xyz/docs/agents#untrusted-by-default), and nothing in the spectator view can arm, sign, confirm or send anything.
 

package/dist/packages/mcp/assets/kb/docs/docs-telegram-approve-one-tap-entries.md

@@ -0,0 +1,50 @@
+---
+id: docs-telegram-approve-one-tap-entries
+title: Telegram (your own bot) › Approve: one-tap entries
+kind: docs
+page: telegram
+page_title: Telegram (your own bot)
+heading: Approve: one-tap entries
+anchor: approve-one-tap-entries
+url: https://dexterm.xyz/docs/telegram#approve-one-tap-entries
+tags:
+  - docs
+  - telegram
+  - approve
+  - one-tap
+  - entries
+  - own
+  - bot
+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/telegram.md
+date: 2026-10-16
+---
+
+Approvals are on for a strategy whose `entry.decide` is `"agent+approve"`, and for every strategy after `/approvals on` (or `dexterm telegram approvals on`). Your agent still decides and your strategy still clamps the size; the entry then becomes a **proposal** instead of an order:
+
+```
+PAPER · PROPOSAL · moonbag v1.0.0 (67fc4c95)
+token "SYM" abcd…wxyz
+buy $20.00 (2.0% of book) @ 0.0001645 · liq $36.6K · impact ~0.40%
+plan: moonbag: cost back at +100%, then a 55% bag trail, out after 7 days, no hard stop
+why (the agent's words, unverified): "Fresh pair 34 min old, buyers 1.6x sellers."
+expires in 90 s · #k3Jd9aQx
+Only these buttons approve. Replies are ignored.
+[Approve] [Half size] [Skip]
+```
+
+- **No answer is a skip.** A proposal expires after 90 seconds (set 60 to 120 with `dexterm telegram set expiry`), on your computer's clock. There is no auto-approve.
+- **[Half size]** only ever halves. **[Skip]** skips.
+- **The price is checked again at your tap.** If it moved more than 3 % (never more than the strategy's own slippage), the liquidity fell more than 10 %, or the impact would pass the strategy's cap, the card is re-quoted with fresh numbers and new buttons and you confirm once more. A second move is a skip.
+- **Your limits are checked again at your tap**, against the book as it is then: the size can shrink, or the entry is refused.
+- **One tap, once.** Every button is bound to a one-time code, the proposal's exact numbers, its expiry, your account and your private chat. A double tap, a second device or an old button gets "Already handled"; a forwarded card tapped by someone else, or in a group, is refused.
+- **A kill, a pause or a halt** cancels every open proposal and removes its buttons. If the runner restarts, open proposals expire; they are never brought back.
+- **Exits never wait for chat.** Stops, take-profits, trails and rug exits run on their own, and a [Sell] on `/positions` only ever sells.
+- At most as many proposals are open at once as the strategy allows sessions; the rest are skipped and counted.
+
+The order then goes through the paper book with a single-use approval for exactly that order (bound to its hash and the proposal): a different order, a different coin, a bigger size or a second use is refused.

package/dist/packages/mcp/assets/kb/docs/docs-telegram-control-the-commands.md

@@ -0,0 +1,43 @@
+---
+id: docs-telegram-control-the-commands
+title: Telegram (your own bot) › Control: the commands
+kind: docs
+page: telegram
+page_title: Telegram (your own bot)
+heading: Control: the commands
+anchor: control-the-commands
+url: https://dexterm.xyz/docs/telegram#control-the-commands
+tags:
+  - docs
+  - telegram
+  - control
+  - commands
+  - own
+  - bot
+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/telegram.md
+date: 2026-10-16
+---
+
+The list is closed. Anything else gets the help text.
+
+| command | what it does | from chat |
+|---|---|---|
+| `/status` | the runner state, strategy, open positions, the day's P/L %, spend, approvals | always |
+| `/positions` | each open position with a [Sell] button | always |
+| `/pause` | no new entries; exits keep running | always |
+| `/resume` | lifts a **pause** | only a pause: never a kill, the panic switch, a loss-limit halt or a guard; those clear on your computer |
+| `/kill` (or `/stop`) | the same as `dexterm autotrade stop`: no new entries, sessions closed, pending orders dropped, exits keep running until nothing is held | always |
+| `/flatten` | stop, then sell every position at its next tick | after a [Yes, flatten] button |
+| `/strategies` | your validated strategies and the presets, marked when `/use` may pick them | always |
+| `/use <strategy>` | switch to another strategy | only to one that is **equal or tighter** than the running one, after a [Yes, switch] button. Any change dexterm cannot rank (a field with no safety rule, or a value it cannot compare) counts as looser, and so do a bigger bankroll and a dip-buying ladder. New entries stop at once; the new strategy starts once the open positions have closed. It never changes paper or live |
+| `/approvals on` | every new entry waits for your tap | always. `off` is local only: `dexterm telegram approvals off` |
+
+Never from chat, because no such command exists: live mode, looser caps or strategies, approvals off, resuming after a kill or the panic switch, moving funds.
+
+Chat writes the same control file `dexterm autotrade stop` and the AUTOTRADE screen write, so it is a remote control for the runner on your computer and adds no way around its limits. Commands are limited to 10 a minute; `/kill`, `/stop`, `/pause` and `/flatten` are never limited. A command sent while nothing was polling is not acted on when the bot comes back. Commands count only in your private chat, and a forwarded message or one sent through an inline bot is never a command.

package/dist/packages/mcp/assets/kb/docs/docs-telegram-if-something-goes-wrong.md

@@ -0,0 +1,30 @@
+---
+id: docs-telegram-if-something-goes-wrong
+title: Telegram (your own bot) › If something goes wrong
+kind: docs
+page: telegram
+page_title: Telegram (your own bot)
+heading: If something goes wrong
+anchor: if-something-goes-wrong
+url: https://dexterm.xyz/docs/telegram#if-something-goes-wrong
+tags:
+  - docs
+  - telegram
+  - something
+  - goes
+  - wrong
+  - own
+  - bot
+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/telegram.md
+date: 2026-10-16
+---
+
+- **Telegram is down, or a message cannot be sent:** the proposal is a skip. Notifications retry. The runner never waits on chat, and your exits are unaffected.
+- **Someone else uses your token** (a webhook appears on the bot, or another program polls it): the bot stops every approval, you are warned on your computer, and every local control keeps working (`dexterm autotrade stop`, the AUTOTRADE screen, `dexterm wallet panic`). Messages from accounts that are not paired get no answer; five in an hour raise a "possible token leak" warning on your computer.
+- **Revoke it:** `dexterm telegram revoke` removes the token from your computer and forgets every paired chat. If the token may have leaked, also send `/revoke` to @BotFather for that bot and run setup again.