dexterm-cli 0.1.6 → 0.2.0

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

@@ -0,0 +1,39 @@
+---
+id: docs-build-a-strategy-by-chat-the-ladder
+title: Build a strategy by chat › The ladder
+kind: docs
+page: build-a-strategy-by-chat
+page_title: Build a strategy by chat
+heading: The ladder
+anchor: the-ladder
+url: https://dexterm.xyz/docs/build-a-strategy-by-chat#the-ladder
+tags:
+  - docs
+  - build-a-strategy-by-chat
+  - ladder
+  - 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
+---
+
+A strategy you build climbs one ladder, one rung at a time:
+
+**draft → backtested → forward-tested → always-on (paper) → real**
+
+| rung | what it needs | who does it |
+|---|---|---|
+| draft | a strategy that validates | the analyst proposes it, you apply it with a key |
+| backtested | a backtest on your recorded history, with the held-out split | you or the analyst |
+| forward-tested | a forward test that ran its whole window on live data, on paper | you or the analyst starts it; it runs by itself |
+| always-on | a member of `autotrade.json`, run by the always-on service (https://dexterm.xyz/docs/autotrade#the-always-on-service) on paper | the analyst can propose it; only you apply it |
+| real | real mode armed on your own terminal, with caps you set, above the evidence floor: a completed forward test with at least 10 closed paper trades and a backtest | only you, with a typed phrase (real mode (https://dexterm.xyz/docs/real-mode)) |
+
+Every rung counts evidence measured on the strategy's **exact rules**. Renaming it, rewording its description or arming it for real keeps its evidence; changing any rule (an entry filter, a size, an exit, a limit) starts the ladder again from draft. No rung can be skipped, and `dexterm autotrade journey <id>` (or `J` on the `Q` screen) always shows where a strategy stands and what the next rung needs.

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

@@ -0,0 +1,31 @@
+---
+id: docs-build-a-strategy-by-chat-the-report
+title: Build a strategy by chat › 3. Forward-test it on live data (paper) › The report
+kind: docs
+page: build-a-strategy-by-chat
+page_title: Build a strategy by chat
+heading: The report
+anchor: the-report
+url: https://dexterm.xyz/docs/build-a-strategy-by-chat#the-report
+tags:
+  - docs
+  - build-a-strategy-by-chat
+  - report
+  - forward-test
+  - live
+  - data
+  - paper
+  - 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
+---
+
+`forward report` sets the forward test next to the backtest of the **same rules**, column by column: trades, win rate with its 95% interval, net, max drawdown, rug rate, and the fill cost against the mid price (with the drift from the backtest). It flags a forward win rate outside the backtest's interval, a deeper drawdown and more rugs than the history showed. Under 20 closed forward trades it says plainly that the sample is too small to claim anything, and it allows gain wording only when the backtest passes the evidence rule **and** the forward test made money on 20 or more trades.

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

@@ -0,0 +1,30 @@
+---
+id: docs-build-a-strategy-by-chat-what-the-analyst-knows
+title: Build a strategy by chat › What the analyst knows
+kind: docs
+page: build-a-strategy-by-chat
+page_title: Build a strategy by chat
+heading: What the analyst knows
+anchor: what-the-analyst-knows
+url: https://dexterm.xyz/docs/build-a-strategy-by-chat#what-the-analyst-knows
+tags:
+  - docs
+  - build-a-strategy-by-chat
+  - analyst
+  - knows
+  - 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
+---
+
+The analyst's tools for this: `strategy_journey` (the ladder for one strategy), `strategy_backtest` (with the held-out split), `strategy_forward_start`, `strategy_forward_stop`, `strategy_forward_report` and `strategy_promote_propose`. It is told the whole ladder, refuses to skip a rung, and reports numbers with their trade counts and the verdict lines as they are. An observe-only scan session gets none of the starting, stopping or proposing tools.
+
+Paper by default; experimental; not financial advice.

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-configuration-chart-markers.md

@@ -0,0 +1,30 @@
+---
+id: docs-configuration-chart-markers
+title: Configuration and files on disk › Chart markers
+kind: docs
+page: configuration
+page_title: Configuration and files on disk
+heading: Chart markers
+anchor: chart-markers
+url: https://dexterm.xyz/docs/configuration#chart-markers
+tags:
+  - docs
+  - configuration
+  - chart
+  - markers
+  - files
+  - disk
+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/configuration.md
+date: 2026-10-16
+---
+
+Both charts mark your own fills: the terminal token chart and the popup chart (https://dexterm.xyz/docs/popup-chart#buy-and-sell-markers). Every fill of the coin in the paper ledger and the live ledger is a `B` or `S` at its time and price, hollow `△ ▽` for PAPER and solid `▲ ▼` for live, so it reads with `NO_COLOR` too. A dashed `avg` line marks the average entry while a position is open. Markers are on by default; the popup's **MARKERS** control (or `k` in the popup) turns them off and on, and saves `"display": { "chartMarkers": "off" }` (or `"on"`; absent means `on`) through the journal, so `ctrl+z` undoes it. `dexterm display markers [on|off]` shows or sets it from the command line. Display only: nothing that trades reads it.
+
+- The terminal chart puts the glyph and letter on the fill's candle (`△B`, `▽S`; a count when one candle holds several fills), labels the newest marker with its price or market cap, and prints a one-line legend with how many fills are off the chart.
+- When the agent HUD or the brain view is up, the brain view's candle trace shows a `B` or `S` cell on each fill's candle, and the agent's PAPER position card marks its fills under its PnL trace.

package/dist/packages/mcp/assets/kb/docs/docs-configuration-chart-y-axis.md

@@ -29,4 +29,4 @@ Both charts, the terminal token chart and the popup chart (https://dexterm.xyz/d
 - Axis labels, the last-value tag, the crosshair legend and the volume use one compact formatter: a lowercase k for thousands, then M, B, T; one decimal below 10 of the unit and none after (`$4.9k`, `$42k`, `$487k`, `$1.2M`, `$48M`, `$1.3B`), never scientific notation. When two neighbouring ticks would read the same, the axis adds one decimal (`48.3M`).
 - Historical candles are scaled by the **current** supply, and the chart title says `MCAP (current supply)` so nobody reads it as the exact market cap at that time (a burn or a mint since then is not reflected). The bars stay USD prices underneath, so indicators, PAPER entry / stop / target lines and fills keep their meaning; only the labels change.
 - A token without a known supply plots its price and the title says `price (mcap unavailable)`. In price mode tiny prices use the subscript form (`0.0₅493`).
-- While following an agent, the HUD's PAPER position card reads entry and mark as market cap (`entry MC $4.7k`) when the axis is market cap and the supply is known.
+- While following an agent, the HUD's PAPER position card and ticket read entry and mark as market cap (`entry MC $4.7k`) when the price display mode (https://dexterm.xyz/docs/configuration#price-display-mode) is market cap (the default) and the supply is known.

package/dist/packages/mcp/assets/kb/docs/docs-configuration-environment-variables.md

@@ -33,7 +33,10 @@ date: 2026-10-16
 | `DEXTERM_INTENSITY` | `off` · `normal` · `fever` |
 | `DEXTERM_OFFLINE=1` | refuse live data; `--fixtures` or `--replay` only (tests and CI) |
 | `DEXTERM_ANALYST_MODEL` | the Claude model for analyst turns (default `(generated from the app: see https://dexterm.xyz/docs/configuration#environment-variables; app-help has the exact keys and commands)`) |
-| `DEXTERM_ANALYST_ENGINE` | `auto` (default) · `claude` · `codex`: which of your CLIs runs the analyst (since 0.1.5; also `--analyst-engine` and `analyst.engine` in `config.json`) |
+| `DEXTERM_ANALYST_ENGINE` | `auto` (default) · `claude` · `codex` · `ollama`: which engine runs the analyst (since 0.1.5; `ollama` = a local model (https://dexterm.xyz/docs/ollama); also `--analyst-engine` and `analyst.engine` in `config.json`) |
+| `DEXTERM_AI_PROVIDER` | `auto` · `claude` · `codex` · `ollama`: the engine for every surface, over `~/.dexterm/ai.json` (see local model (https://dexterm.xyz/docs/ollama#pick-the-engine-globally-or-per-surface)) |
+| `DEXTERM_OLLAMA_HOST` · `DEXTERM_OLLAMA_MODEL` | the Ollama host (default `http://127.0.0.1:11434`; another machine is warned about) and the local model |
+| `DEXTERM_AI_RESTRICTIONS` | `observe` · `propose` · `paper` · `full`: can only LOWER the local engine's profile for this run |
 | `DEXTERM_CODEX_MODEL` | pin the Codex model for analyst turns (default: your Codex default) |
 | `DEXTERM_POPUP_SHELL` | path to a prebuilt native chart window |
 | `DEXTERM_POPUP_HOTKEY` · `DEXTERM_POPUP_HOTKEY_CLOSE` | override the popup chords without a config file |

package/dist/packages/mcp/assets/kb/docs/docs-configuration-files-on-disk.md

@@ -35,6 +35,7 @@ date: 2026-10-16
 | `~/.dexterm/piper/` · `~/.dexterm/models/` | the neural voice: a private Python environment with Piper (macOS, written by `dexterm voice setup`), and the downloaded voice models (`en_GB-alan-medium`, whisper `base.en`) | optional; `dexterm voice uninstall` removes the runtime, `--purge-model` the Piper voice too. See voice (https://dexterm.xyz/docs/voice#the-voice-neural-by-default) |
 | `~/.dexterm/exports/` | PNG and text files from `E` (export a view) and `H` (PnL cards (https://dexterm.xyz/docs/paper-trading#pnl-cards)) | directory 700, files 600; local only, nothing is uploaded |
 | `~/.dexterm/spectator.json` | the spectator stream (https://dexterm.xyz/docs/spectator#2-the-read-only-stream-spectate)'s loopback port and per-session token, while `dexterm agent serve --spectate` runs | mode 600; never printed or passed as an argument |
+| `~/.dexterm/wallet-link.json` · `~/.dexterm/trading.panic` | a linked wallet's **public key** (from `dexterm wallet link`; never a private key), and the kill switch while `dexterm wallet panic` is engaged | optional; dexterm holds no key and has no trading wallet |
 | `~/.local/bin/dexterm` | the launcher `install.sh` writes | user-level |
 | `packages/popup/shell/wry/target/release/dexterm-shell-wry` | the native chart window, if built | `DEXTERM_POPUP_SHELL` points elsewhere |
 

package/dist/packages/mcp/assets/kb/docs/docs-configuration-headless-recorder-dexterm-record.md

@@ -36,9 +36,11 @@ $ dexterm record status                   # db size, snapshots, outcomes, today'
 $ dexterm record install --dry-run        # print the macOS LaunchAgent it would write; writes nothing
 $ dexterm record install --load           # write it to ~/Library/LaunchAgents (no sudo) and load it
 $ dexterm record uninstall --unload       # stop and remove it
+$ dexterm record run --focus-ticks --retention-mb 3000   # also sample focus coins every 5-10 s; evict old history at 3 GB
 ```
 
 - **Nothing turns itself on.** The collector runs only when you start it. `install` writes a user-level LaunchAgent and loads it only with `--load`. A LaunchAgent does not start before you log in.
 - **Same budgets as the app.** Every request goes through the data layer's rate limiter and health gate, and the outcome sweeps keep their own per-sweep and per-day caps. It never builds a signer, never trades and never prints an RPC key.
-- **A disk cap.** Above `--max-db-mb` (1024 by default) it pauses new observations, while labels and retention keep running, so the database cannot grow without bound.
+- **A disk cap.** Above `--max-db-mb` (1024 by default) it pauses new observations, while labels and retention keep running, so the database cannot grow without bound. With `--retention-mb N` it never pauses: once the used space reaches N MB the oldest history goes first (the newest hour is always kept). `--retention-days D` expires snapshot rows, outcome re-checks included, after D days instead of 90.
+- **Focus ticks for autotrade backtests** (`--focus-ticks`): a sample every 5 seconds for coins you hold on paper or have open and every 10 seconds for your watchlist and autotrade candidates, plus 1-minute candles built from those samples, in DexScreener batches of 30 with a daily call ceiling. What is kept and for how long is in recorded history (https://dexterm.xyz/docs/data-sources#recorded-history-and-retention). `install` writes these flags into the LaunchAgent only when you pass them.
 - **Recurring backtests.** 0.1.3 also ships the logic behind recurring skill backtests: a rolling held-out window, a frozen comparison set, and a gate that only *proposes* a tuning when it beats the noise. Nothing changes a skill on your machine. A tuning reaches you only through a normal release, with its measured numbers, including weak ones (see LARP detector (https://dexterm.xyz/docs/larp)).

package/dist/packages/mcp/assets/kb/docs/docs-configuration-price-display-mode.md

@@ -25,11 +25,13 @@ sources:
 date: 2026-10-16
 ---
 
-Memecoin traders think in market cap, so every token price can be shown as **market cap** instead of the USD price per token. It is a display mode only: the same data underneath, no extra requests, and nothing that trades (signer, caps, tickets, plans, the confirm gate) reads it.
+Memecoin traders think in market cap, so dexterm shows and talks about every coin in **market cap by default**: the screens, the CLI text, the chat assistant and the autotrade agents ("entered at $69.7K, exited at $264.9K, 3.8x"). USD price per token is the alternative. It is a display and wording setting only: the same data underneath, no extra requests, and nothing that trades (signer, caps, tickets, plans, the confirm gate, the autotrade engine) reads it.
 
-- `$` flips price ⇄ market cap on every screen (the charts have their own Y axis setting (https://dexterm.xyz/docs/configuration#chart-y-axis)), and saves it to `config.json` as `"display": { "priceMode": "mcap" }` (or `"price"`, the default) through the journal, so `ctrl+z` undoes it. `dexterm display [price|mcap]` shows or sets it from the command line; `--price-mode price|mcap` overrides it for one run; a workspace may carry `"priceMode"` and switches to it while active.
-- Market cap = price × supply, where the supply is what the data sources already report (the row's market cap ÷ its price at the latest tick). The screener, watchlist and new pairs lead with **MCAP** (the PRICE column moves to MCAP's old place, every sort key works as before, `mcap` still sorts by market cap); the watchlist's entry becomes **ENTRY MC**; spotlights and the token header lead with the market cap and keep the price beside it.
+- The setting is `"display": { "priceMode": "mcap" }` in `config.json` (`"price"` for USD price). `$` flips it on every screen and saves it through the journal, so `ctrl+z` undoes it; `/display mcap|price` in the chat box (also `/basis …`, `/set basis …`) does the same, and `/display` alone says which is on. `dexterm display [mcap|price]` shows or sets it from the command line. For one run: `--mcap` / `--price` on any command (`dexterm --price autotrade run …`), `--price-mode mcap|price`, or `DEXTERM_PRICE_BASIS=mcap|price`; nothing is saved. A workspace may carry `"priceMode"` and switches to it while active.
+- Market cap = price × a **known** supply: the market cap a source reports at the same tick (its market cap ÷ its price), the recorded FDV ÷ price, or pump.fun's fixed 1B for a pump.fun coin (the same rule as the PnL cards (https://dexterm.xyz/docs/paper-trading)). A supply is never guessed: without one the slot shows the price and says so (`ᵖ` after the number in a table, the panel caption counts them; `supply unknown · showing price` on a spotlight or header; `price; supply unknown` in a sentence).
+- Screens: the screener, watchlist and new pairs lead with **MCAP** (PRICE moves to MCAP's old column, every sort key works as before); the watchlist's entry becomes **ENTRY MC**; spotlights, the token header and the export report lead with the market cap and keep the price beside it. Position rows read **AVG MC** / **MCAP**, and STOP / TARGET, the trade tape, the ticket's price line and PAPER fill line (`@ $69.7K mcap (0.0000004 SOL)`), the trade history, the PnL chip, the brain view and the agent HUD's cards read market caps too. Profit and loss stay in USD (or SOL on the paper screen). The analyst's coin tables lead with MCAP.
 - Charts have their own setting, the chart Y axis (https://dexterm.xyz/docs/configuration#chart-y-axis) (market cap by default); `$` does not change it.
-- Order plans already trigger on market cap: the `O` screen and the plans popup show each level with both numbers (`entry mc ≤ $300K ($0.0₃3)`), the price taken from the plan's own supply snapshot. Position rows read **AVG MC** / **MCAP**; profit and loss stay in USD (or SOL on the paper screen).
-- A token without a known supply falls back to its price and says so: `ᵖ` after the number in a table (the panel caption counts them), `supply unknown · showing price` on the spotlight and the header. Nothing is estimated.
-- `config.json` moved to **v4** for this: an older file is migrated on load (`display.priceMode = price` added, a backup kept as `config.json.bak-v3`), nothing else changes.
+- Order plans already trigger on market cap: the `O` screen and the plans popup show each level with both numbers (`entry mc ≤ $300K ($0.0₃3)`), the price taken from the plan's own supply snapshot.
+- The assistants speak the same basis, read at run time: the chat assistant's instructions and its live context (cap at entry, cap now, cap targets and stops, x-multiples), the autotrade candidate and position agents (their DOSSIER, ENGINE notes and EVENTs), and the MCP tools (https://dexterm.xyz/docs/analyst#mcp-tools): every price field has a market-cap twin (`mcap`, `entryMcap`, `lastMcap`, …; `null` when the supply is unknown) and the tool descriptions tell an external agent to talk in market cap unless the user chose price.
+- JSON keeps **both** numbers always: a price field is never removed or renamed, its cap twin sits beside it (the autotrade ledger's fills carry `price` and `mcap`, `avgPrice` and `avgMcap`). Only the human-facing text switches.
+- `config.json` moved to **v5** for this: a file saved with the old default (`priceMode: "price"`, written by every first save) is moved to market cap on load, with a backup kept as `config.json.bak-v4`; a `price` you chose yourself (`$`, `dexterm display price`, an approved proposal, all in the journal) is kept.

package/dist/packages/mcp/assets/kb/docs/docs-copy-trading-stage-2-the-one-key-mirror-ticket-a-proposal.md

@@ -53,4 +53,4 @@ $ dexterm follow mirror <addr> --propose      # write it as an INERT proposed or
 $ dexterm follow mirror <addr> --json         # machine-readable preview
 ```
 
-A refused mirror prints every failed check and exits non-zero. `--propose` writes a plan with status `proposed` and no mandate. The command has no arm, sign or execute path, so the plan can only be armed in the app through the keypress or Phantom gate. A replay test drives a followed wallet's buy through `--propose` and checks that the plan exists, is not armed and that no execute path was reached. This is the copy-trade mirror ticket of the 0.1.3 release (its first copy-trading step in the release notes): **a proposal only. Nothing arms or fires on its own.**
+A refused mirror prints every failed check and exits non-zero. `--propose` writes a plan with status `proposed` and no mandate. The command has no arm, sign or execute path, so the plan can only be armed in the app through the keypress gate. A replay test drives a followed wallet's buy through `--propose` and checks that the plan exists, is not armed and that no execute path was reached. This is the copy-trade mirror ticket of the 0.1.3 release (its first copy-trading step in the release notes): **a proposal only. Nothing arms or fires on its own.**

package/dist/packages/mcp/assets/kb/docs/docs-copy-trading-stage-3-capped-auto-mirror-default-off-less.md

@@ -32,7 +32,7 @@ sources:
 date: 2026-10-16
 ---
 
-`A` on a followed wallet raises the **AUTO-MIRROR** prompt. Turning it on is a held physical keypress, and it is refused unless the plan engine's own "this is less safe" popup (`G` on the `O` screen, keypress-only, 24 h expiry) is active. That one gesture drafts and arms a **copy mandate** in the plan engine, the signer trust domain: buy-only, `maxTier: hands-free`, with exactly the policy's caps, clamped to the engine's hard ceilings.
+`A` on a followed wallet raises the **AUTO-MIRROR** prompt. Turning it on is a held physical keypress, and it is refused unless the plan engine's own "this is less safe" popup (`G` on the `O` screen, keypress-only, 24 h expiry) is active. That one gesture drafts and arms a **copy mandate** in the plan engine: buy-only, `maxTier: hands-free`, with exactly the policy's caps, clamped to the engine's hard ceilings.
 
 Every later buy by that wallet then runs the Stage 2 checks and, if they pass, is proposed and armed automatically with the **weakest confirmation tier**. The engine therefore sizes it at **¼ of the per-trade cap** (the same rule a spoken confirmation gets) and re-checks the per-trade, per-coin, total and daily-loss caps, the allow-list and the panic state at arming and on every fill. On top, the policy keeps a per-wallet **daily cap** (the mandate's total), **max open mirrors**, a **cooldown** between mirrors, a **size factor** against the leader, and an **auto-disarm streak**: that many refused or failed mirrors in a row turn it off.
 

package/dist/packages/mcp/assets/kb/docs/docs-copy-trading-what-is-proven-what-is-not.md

@@ -29,7 +29,7 @@ date: 2026-10-16
 
 Proven on fixtures and a fake clock: the decoder on synthetic histories and the three spike recordings; the tracker's backfill-then-alert replay; every mirror refusal and the size rule; the proposal's inertness; the auto path end to end on the paper executor (enable, ¼-size arming, fill, cooldown, max-open, daily cap, the engine's own refusal of a hand-armed extra plan); the kill paths; the restart rule; and a compromised-model suite in which spoken, agent and forged gestures, a spoofed alert, a widened policy and a plan the service did not create all fail to enable, widen or auto-arm anything.
 
-Not built or not proven: **mirror-sell** (you close every mirror yourself, so auto-disarm counts refusals and failed fills, not realised losses); an early-entry score with the "reached 3×" filter; a live run against real Helius history on this machine; and any mirror on devnet or mainnet.
+Not built or not proven: **mirror-sell** (you close every mirror yourself, so auto-disarm counts refusals and failed fills, not realised losses); an early-entry score with the "reached 3×" filter; and a live run against real Helius history on this machine. Mirrors never trade real funds.
 
 **Confirmation provenance:** the engine rejects fabricated, copied, modified, cross-engine and reused proof objects. Copy automation receives a private operation scoped to its physically armed mandate; it can create new copy buys, never adopt an existing voice or agent proposal. Automation proofs stay inside the engine. The engine re-checks the less-safe opt-in, mandate lifetime, panic and existing caps. These are in-process checks: the trusted terminal captures physical input; this is not isolation against arbitrary code execution inside that trusted process.
 

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

@@ -26,6 +26,6 @@ date: 2026-10-16
 
 Follow a wallet and see its decoded swaps and PnL; turn its buys into a mirror PROPOSAL with one key; or let a capped, keypress-armed auto-mirror propose and arm them for you. Your wallet, your caps, your keys.
 
-Copy trading in dexterm is a **personal tool for your own wallet**. You pick the wallets, you set the caps, your own keys sign (or the paper wallet simulates). dexterm never holds funds, never copies for anyone else, never offers pooled or hosted copying, never publishes a leader list, and takes no fee on a mirrored trade. The whole feature is labelled **in progress**: it is on main and tested on fixtures and the task-1286 spike recordings, but no mirror has moved real funds, and the auto tier fires through the paper executor unless the plans fire path is switched to the devnet fast wallet (see the live fire path (https://dexterm.xyz/docs/paper-trading#the-live-fire-path-devnet-the-fast-wallet)).
+Copy trading in dexterm is a **personal tool for your own wallet**. You pick the wallets, you set the caps, and the paper wallet simulates every mirror. dexterm never holds funds or keys, never signs, never copies for anyone else, never offers pooled or hosted copying, never publishes a leader list, and takes no fee on a mirrored trade. The whole feature is labelled **in progress**: it is on main and tested on fixtures and the task-1286 spike recordings, and every mirror, the auto tier included, fills through the paper executor. No mirror moves real funds.
 
 It is built in three stages, each behind the previous one's gate.

package/dist/packages/mcp/assets/kb/docs/docs-data-sources-recorded-history-and-retention.md

@@ -0,0 +1,36 @@
+---
+id: docs-data-sources-recorded-history-and-retention
+title: Data sources and rate limits › Recorded history and retention
+kind: docs
+page: data-sources
+page_title: Data sources and rate limits
+heading: Recorded history and retention
+anchor: recorded-history-and-retention
+url: https://dexterm.xyz/docs/data-sources#recorded-history-and-retention
+tags:
+  - docs
+  - data-sources
+  - recorded
+  - history
+  - retention
+  - data
+  - sources
+  - rate
+  - limits
+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/data-sources.md
+date: 2026-10-16
+---
+
+What the local recorder keeps, all in your own `--db` file and never uploaded (see the recorder (https://dexterm.xyz/docs/configuration#history-recorder)):
+
+- **Snapshots**: a row per coin when its price, liquidity, holders or volume moved materially (about 5%), or every 30 minutes, while a screen listed it, plus outcome re-checks at 1 h to 72 h after it left. Raw JSON goes after 7 days, rows thin to one per coin per minute after 24 hours, and rows expire after 90 days (`--retention-days D` sets that age).
+- **Autotrade ticks** (`autotrade_ticks`, opt-in with `dexterm record run --focus-ticks`): a sample every 5 seconds for coins you hold on paper or have open, every 10 seconds for your watchlist and autotrade candidates: price, liquidity, market cap, 5-minute and 1-hour volume, buys and sells, and price change. At most 60 coins, in DexScreener batches of 30 (never one call per coin, and no Jupiter calls), queued inside the app's own limiter, skipped while DexScreener is rate-limiting, with a daily ceiling of 36,000 calls. Kept 14 days.
+- **1m candles** (`autotrade_candles_1m`): open, high, low and close per minute for the same coins, built from those samples, so a high or low is the highest or lowest sample, not every trade. Kept 90 days.
+- **Outcome labels**, verdicts and coin creators: kept.
+- **Size cap** (opt-in, `dexterm record run --retention-mb N`): when the database's used space reaches the cap, cached answers more than a day past their expiry are cleared first; if that is not enough, the oldest history (ticks, candles and snapshots, outcome re-checks included) is removed first until it is back under, and recording never pauses; the newest hour is always kept. Without it, the older `--max-db-mb` cap pauses new snapshots instead. SQLite reuses the freed space rather than shrinking the file.

package/dist/packages/mcp/assets/kb/docs/docs-data-sources-sources.md

@@ -35,6 +35,7 @@ date: 2026-10-16
 | security checks | RugCheck + GoPlus | none | one may be `unavailable`, the other covers |
 | new pairs | PumpPortal `subscribeNewToken` + `subscribeMigration`, Jupiter `recent` poll, RugCheck `new_tokens` | Helius: per-curve bonding % | rows from the poll; bonding is a create-time estimate |
 | watchlist prices | DexScreener + Jupiter, persisted in SQLite | Jupiter free key: higher rate | fully keyless |
+| autotrade ticks and 1m candles (opt-in, `dexterm record run --focus-ticks`) | DexScreener `tokens/v1`, batches of 30 coins per call | none | backtests use the coarser recorder snapshots only |
 | fast-lane live price | public RPC WebSocket `accountSubscribe` on the pump.fun bonding curve, price computed on-chain | free Helius key: lower latency, higher limits (used first) | the polled price (POLL badge) |
 | paper quotes | Jupiter `swap/v1/quote` (quote only; no build, no execute) | Jupiter free key: lower latency | fully keyless |
 | product vetting | the token's own site, RDAP, the GitHub API | none | a claim stays unverifiable |

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

@@ -24,7 +24,7 @@ sources:
 date: 2026-10-16
 ---
 
-The first launch shows the full glitch boot and then a one-screen welcome card: what dexterm is, the keys that get you around, and the safety stance (non-custodial, your keys never enter dexterm, trading is PAPER by default, not financial advice). Press any key to enter the live screener. Later launches boot in about a second.
+The first launch shows the full glitch boot and then a one-screen welcome card: what dexterm is, the keys that get you around, and the safety stance (non-custodial, no wallet and no keys, trading is PAPER, not financial advice). Press any key to enter the live screener. Later launches boot in about a second.
 
 - `?` on any screen shows every key for that screen.
 - `q` quits. The terminal is always restored, even after a crash or a signal.

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.6-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.6-src.tar.gz --repo dexterm-xyz/dexterm
-$ tar -xzf dexterm-0.1.6-src.tar.gz && cd dexterm-0.1.6
+$ 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.6 is out (2026-10-20), 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-getting-started.md

@@ -22,6 +22,6 @@ date: 2026-10-16
 
 Requirements, install, first run and dexterm doctor.
 
-dexterm is a terminal screener for Solana memecoins with a local Claude analyst. It runs on your machine, reads public data with no key and never holds a wallet key. Trading is PAPER by default; any live swap is signed in your own Phantom wallet after you approve it (see paper trading (https://dexterm.xyz/docs/paper-trading)). This page gets you from nothing to the live screener.
+dexterm is a terminal screener for Solana memecoins with a local Claude analyst. It runs on your machine, reads public data with no key and never holds a wallet key. Trading in dexterm is PAPER (see paper trading (https://dexterm.xyz/docs/paper-trading)); dexterm signs nothing, and live trading happens in a Telegram trading bot of your choice (see live trading (https://dexterm.xyz/docs/live-trading)). This page gets you from nothing to the live screener.
 
 > note: Never used a terminal before? Start with the complete beginner guide (https://dexterm.xyz/docs/beginners). It defines every term, shows exactly what to copy on macOS, Linux and Windows, and ends with a ten-minute read-only coin review.

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.