dexterm-cli 0.1.7 → 0.2.1

package/dist/packages/mcp/assets/kb/docs/docs-classifier-where-it-plugs-in.md

@@ -0,0 +1,29 @@
+---
+id: docs-classifier-where-it-plugs-in
+title: Classification models › Where it plugs in
+kind: docs
+page: classifier
+page_title: Classification models
+heading: Where it plugs in
+anchor: where-it-plugs-in
+url: https://dexterm.xyz/docs/classifier#where-it-plugs-in
+tags:
+  - docs
+  - classifier
+  - where
+  - plugs
+  - classification
+  - models
+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/classifier.md
+date: 2026-10-16
+---
+
+- **Agents (MCP)**: `classify_coin` (one coin), `classify_batch` (up to 100 coins, with triage: flag, pass, or escalate the uncertain ones to Claude or to you) and `classifier_status`.
+- **Watch rules**: the `rugp` field is the drain estimate of a coin the classifier has scored, for example `when rugp > 0.8 then alert(warn, "classifier: high drain estimate") scope watchlist`. A coin that has not been scored never matches.
+- **Research**: the benchmark writes each coin's probabilities as columns, so entry-gate research can test them as one more input.

package/dist/packages/mcp/assets/kb/docs/docs-classifier-which-model-for-which-machine.md

@@ -0,0 +1,42 @@
+---
+id: docs-classifier-which-model-for-which-machine
+title: Classification models › Set up Kev on your own machine › Which model for which machine
+kind: docs
+page: classifier
+page_title: Classification models
+heading: Which model for which machine
+anchor: which-model-for-which-machine
+url: https://dexterm.xyz/docs/classifier#which-model-for-which-machine
+tags:
+  - docs
+  - classifier
+  - which
+  - model
+  - machine
+  - set
+  - kev
+  - own
+  - classification
+  - models
+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/classifier.md
+date: 2026-10-16
+---
+
+`dexterm classifier doctor` reads your RAM, CPU and GPU and suggests one of these:
+
+| your machine | suggestion | what to expect |
+|---|---|---|
+| NVIDIA GPU with 12 GB or more | `kev-4b-q4` (`kev-9b-q4` also fits) | Kev 9B took about 0.1-0.2 s per coin on an RTX 4080 but scored no better than Kev 4B (see below) |
+| NVIDIA GPU with 6 GB or more | `kev-4b-q4` (3 GB download) | |
+| Apple Silicon with 16 GB or more | `kev-4b-q4` | |
+| A CPU with 16 GB of RAM and 8 threads or more | `kev-4b-q4`, for one coin at a time | 5-20 s per coin measured on shared desktop CPUs: fine for a coin you open, too slow to score a whole screener |
+| Anything smaller | the built-in scores | |
+
+`kev-0.8b-q8` is in the list but not suggested: on dexterm's own history it ranked coins no better than chance.
+Serving uses about 2.5 GB of RAM for the 0.8B model and about 5.5 GB for the 4B model; the 9B model used about 6.6 GB of GPU memory.

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

@@ -0,0 +1,32 @@
+---
+id: docs-classifier
+title: Classification models
+kind: docs
+page: classifier
+page_title: Classification models
+url: https://dexterm.xyz/docs/classifier
+tags:
+  - docs
+  - classifier
+  - classification
+  - models
+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/classifier.md
+date: 2026-10-16
+---
+
+Pick the model that scores coins with probabilities (an open Kev model on your own machine, TypeSafe's hosted Jev with your own key, or the built-in scores), with how each one measured on dexterm's own labelled history.
+
+**Experimental.** A classification model answers *typed questions* about one coin with a probability for every possible answer. dexterm asks two questions:
+
+- `drain_6h`: will this coin be drained within 6 hours (liquidity pulled, or the price under a fifth of now)?
+- `outcome_6h`: RUG, WIN (at least 3x on a pool that still holds $10k) or DUD over the next 6 hours.
+
+A third set, `narrative`, sorts a coin into a narrative category (animal, AI, politics, celebrity, culture, tech, other).
+
+Every answer is a **model estimate**: it carries the model id, the latency, the cost and a note on how its probabilities were calibrated. It is not advice and not a trade signal. Nothing here signs, trades, arms a strategy or changes a limit. The token's own text (name, symbol, description) goes through the prompt firewall first, and text that tries to steer the model (a bio that tells it what to answer) is removed before any model sees it.

package/dist/packages/mcp/assets/kb/docs/docs-cli-invocations.md

@@ -36,7 +36,7 @@ $ dexterm --screen screener --replay /tmp/rec.json           # the same frame, n
 $ dexterm mcp                                 # the read-only MCP server on stdio
 $ dexterm popup --self-test                   # chart popup self-test
 $ dexterm x login                             # Login with X (your own X app; read scopes only)
-$ dexterm --workspace morning-hud             # start in a workspace (task-1358)
+$ dexterm --workspace morning-hud             # start in a workspace
 $ dexterm pack verify ./some-pack             # the install card for a shareable pack
 ```
 

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

@@ -37,10 +37,13 @@ $ dexterm record install --dry-run        # print the macOS LaunchAgent it would
 $ 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
+$ dexterm record run --exit-probes --focus-module ./my-focus.mjs   # + a sell quote a minute for held coins; extra focus coins from your module
 ```
 
 - **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. 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.
+- **Exit probes** (`--exit-probes`, implies `--focus-ticks`): once a minute, for every coin you hold, a keyless Jupiter quote to sell $50 of it into SOL, written as the SOL out, the price impact and the hops, or the error ("no route" is a drained pool). Quotes only: nothing is built, signed or sent. At most 4 quotes a minute for all coins together and a daily ceiling, from the same Jupiter budget as the app.
+- **Your own focus coins** (`--focus-module PATH`, implies `--focus-ticks`): an ES module whose `focus(now)` returns extra coins (a mint and a role: `held`, `open`, `candidate` or `watch`) for the tick lane, for coins your own tools hold outside dexterm.
 - **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-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, 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.
+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 wallet-intel 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

@@ -32,5 +32,6 @@ What the local recorder keeps, all in your own `--db` file and never uploaded (s
 - **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.
+- **Exit probes** (`exit_probes`, opt-in with `dexterm record run --exit-probes`): a Jupiter sell quote of $50 a minute per held coin: SOL out, price impact, route hops or the error. Kept with the ticks; the size cap may evict them.
 - **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-getting-started-install.md

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

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

@@ -26,10 +26,10 @@ date: 2026-10-16
 | need | why | notes |
 |---|---|---|
 | Node.js 22.18 or newer | dexterm runs its TypeScript sources directly; no build step | `node -v` to check. The installer can fetch a verified Node for you. |
-| a terminal with 24-bit colour | the cyberspace look | iTerm2, WezTerm, Ghostty, Kitty, Alacritty, Windows Terminal. 256-colour and monochrome terminals still work, flattened. |
+| a terminal with 24-bit colour | the cyberspace look | iTerm2, WezTerm, Ghostty, Kitty, Alacritty. 256-colour and monochrome terminals still work, flattened. |
 | an internet connection | all data is public and keyless | nothing goes through a dexterm server; see data sources (https://dexterm.xyz/docs/data-sources). |
 | optional: Claude Code logged in | only the analyst needs it | `claude` on your PATH, logged in with your own account. Everything else works without it. |
 | optional: a free RPC key | the ranked top-20 holder list and faster chain reads | Helius, Alchemy, QuickNode or Ankr free tier; see configuration (https://dexterm.xyz/docs/configuration). |
 | optional: Rust (`cargo`) | the native docked chart window | without it the chart popup opens in your browser; see popup chart (https://dexterm.xyz/docs/popup-chart). |
 
-> note: dexterm 0.1.7 is out (2026-10-22), open source under AGPL-3.0-only at github.com/dexterm-xyz/dexterm (https://github.com/dexterm-xyz/dexterm). It is early: trading is experimental and has known bugs. The release ships checksums, a build-provenance attestation and an SBOM, and its VirusTotal result (including flags we explain) is on the trust page (https://dexterm.xyz/trust/). It is also on npm as `dexterm-cli` (https://www.npmjs.com/package/dexterm-cli); the command it installs is still `dexterm`.
+> note: dexterm 0.2.1 is out (2026-10-30), 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-supported-platforms.md

@@ -24,21 +24,12 @@ sources:
 date: 2026-10-16
 ---
 
-This table says what each platform has actually been through, not what we expect to work. "Tested" means the typecheck, the full offline test suite and an install smoke (`npm pack`, `npm i -g` of that tarball into an empty prefix with a fresh home, then `dexterm --version` and `dexterm doctor`) have passed there.
+dexterm supports **macOS and Linux**. Windows is not supported. This table says what each platform has actually been through, not what we expect to work. "Tested" means the typecheck, the full offline test suite and an install smoke (`npm pack`, `npm i -g` of that tarball into an empty prefix with a fresh home, then `dexterm --version` and `dexterm doctor`) have passed there.
 
 | platform | status | what has run on it |
 |---|---|---|
 | Linux x64, Node 22 and 24 | tested | the full suite on every push in CI (Ubuntu), and the same steps in Docker (`node:22-bookworm`, `node:24-bookworm`), including the install smoke |
 | macOS on Intel | tested | the full suite on every change, the install smoke, and a Homebrew install (slow: Homebrew builds Node from source on Intel) |
 | macOS on Apple Silicon | tested in CI (0.1.4) | the full suite on an Apple Silicon runner (`macos-14`) passed on the 0.1.4 release candidate. The manual Homebrew job (tap, trust, install, `brew test`) has not run yet |
-| Windows x64 | experimental, tested in CI (0.1.4) | the `windows-latest` leg runs the full suite and it passed on the 0.1.4 release candidate (a few tests that need POSIX file permissions or Unix-only tools are skipped, and ACL-based file isolation is not verified). Known gaps are listed below |
 | WSL2 | not tested separately | it is Linux, so expect the Linux behaviour |
-
-Known gaps on Windows (none of them affect key safety: dexterm never holds a wallet key on any platform):
-
-- Files dexterm keeps private (tokens, the optional RPC key) are written with POSIX mode `0600`. Windows ignores that mode, so on Windows they are protected only by your user profile's normal permissions.
-- The analyst runs `claude` without a shell, so it can start Claude Code's native installer build (`claude.exe`) but not the `claude.cmd` script an npm install creates. Doctor counts only `claude.exe` as found, so with an npm install it reports the Claude CLI as missing.
-- Voice mode has no Windows speech engine (see voice (https://dexterm.xyz/docs/voice#linux-and-windows)).
-- Opening a token's links and the PnL card's "share to X" do not start a browser on Windows; dexterm shows the URL to open yourself.
-- `doctor` prints its fixes as POSIX shell commands (`mkdir -p`, `chmod`); in PowerShell, do the equivalent by hand.
-- `dexterm kb edit` and `dexterm skill edit` do not open `$EDITOR`; they print the file to edit instead.
+| Windows | not supported | a CI leg ran the suite on Windows for 0.1.4, but Windows is not a supported platform: private files rely on POSIX file modes, voice has no Windows engine, and browser links and `doctor`'s fixes assume macOS or Linux |

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 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.
+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 by default (see paper trading (https://dexterm.xyz/docs/paper-trading)) and dexterm signs nothing. Real mode is experimental; signals to your own executor; dexterm never holds a key; not financial advice (see real mode (https://dexterm.xyz/docs/real-mode) and 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.
+> 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 and Linux, 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.

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

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

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

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

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

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

package/dist/packages/mcp/assets/kb/docs/docs-larp-measured-accuracy.md

@@ -29,7 +29,7 @@ date: 2026-10-16
 
 - **LARP check, links only.** The links-based baseline is a weak signal: MCC 0.039 before tuning, 0.054 after. Its tuned `LARP` grade caught 4 of 14 bad coins, too few to rate. `EARLY_BUT_REAL` coins still went bad 10.3 % of the time, and coins with no website 29.2 %. The skill now treats the baseline as a weak prior and never calls `LARP` from links alone.
 - **Rug check.** The verdict rules improved from MCC 0.043 to 0.159. Liquidity under $5k is the one strong signal (`SPECULATIVE` coins went bad 54.8 % of the time, `WATCH` 14.4 %). Dev percentage, organic score and top-10 share did not predict a worse 72 h outcome and now only lower confidence.
-- **LARP score, link-shape part** (`dexterm backtest --subject larp-score`, task-1471). Points fitted on the train split only. On the 328 held-out coins its AUROC is 0.69 (0.73 on train): a modest ranking signal. 27 of 218 low-band coins went bad (12.4 %), 34 of 110 medium-band coins (30.9 %), against 18.6 % overall; no coin reaches the high band from link shape alone. The page, domain, GitHub and X points are not measured: that evidence was not recorded at the time, and looking it up now would leak the outcome (dead coins' sites and accounts disappear).
+- **LARP score, link-shape part** (`dexterm backtest --subject larp-score`). Points fitted on the train split only. On the 328 held-out coins its AUROC is 0.69 (0.73 on train): a modest ranking signal. 27 of 218 low-band coins went bad (12.4 %), 34 of 110 medium-band coins (30.9 %), against 18.6 % overall; no coin reaches the high band from link shape alone. The page, domain, GitHub and X points are not measured: that evidence was not recorded at the time, and looking it up now would leak the outcome (dead coins' sites and accounts disappear).
 - **Not measured.** The model stage (fetched pages, RDAP, GitHub) cannot be replayed: a past page cannot be fetched as it was. It is measured going forward with `dexterm backtest --subject larp`, below.
 
 The method, every number and the limits are in the repository at `packages/packs/eval/README.md`. A grade is a risk flag, not a certificate.
@@ -38,7 +38,7 @@ Measured 2026-10-12 with `dexterm backtest --subject larp` over this project's l
 
 | history | outcome labels at 1 h (observed) | LARP verdicts recorded | matched |
 |---|---|---|---|
-| research recorder (task-1287 prototype DB) | 149 (137 flat · 9 fade · 2 runner · 1 dead; 29 unobserved) | 0 | 0 |
+| research recorder (prototype DB) | 149 (137 flat · 9 fade · 2 runner · 1 dead; 29 unobserved) | 0 | 0 |
 | the app's recorder on the development machine | 0 | 0 | 0 |
 | the same, re-measured later that day after the recorder fix | 401 (361 flat · 18 dead · 13 runner · 5 fade · 4 rug; 1,206 unobserved) | 0 | 0 |
 

package/dist/packages/mcp/assets/kb/docs/docs-larp-paste-a-coin-on-the-web.md

@@ -26,7 +26,7 @@ date: 2026-10-16
 
 A no-install version is in preview at the preview checker (https://dexterm-larp-preview.dexterm-site.workers.dev/check/), not deployed to dexterm.xyz. Paste a Solana mint or a DexScreener / pump.fun / Solscan link and get the grade in your browser, read-only, no wallet. It runs on a Cloudflare Worker and reuses the app's tuned link-shape grade (`larp-links-v1`) and the same prompt firewall, so a hostile coin name or symbol is stripped and shown as inert text, never obeyed.
 
-What the web checker shows, each datum with its source and the age of the reading: the **LARP grade** from the coin's advertised link shape (`LARP` / `REAL?` / `UNKNOWN`), **top-10 holder concentration** and **holder count** (Jupiter), and **liquidity** in USD (DexScreener). It never shows a price, a market cap or a buy/sell call. A **shareable PNG card** carries the grade, those facts, the heuristic label and a dexterm.xyz link.
+What the web checker shows, each datum with its source and the age of the reading: the **LARP grade** from the coin's advertised link shape (`LARP` / `REAL?` / `UNKNOWN`), the **LARP score** from the same link shape with its top three reasons, **top-10 holder concentration** and **holder count** (Jupiter), and **liquidity** in USD (DexScreener). The web checker does not fetch the website, the domain, GitHub or the X account, so those count as not checked: the score shows how far they could still raise it ("12, could be up to 100") rather than treating them as clean. It never shows a price, a market cap or a buy/sell call. A **shareable PNG card** carries the grade, the score with its top three reasons, those facts, the heuristic label and a dexterm.xyz link.
 
 The preview defaults to the **keyless** tier. The full in-app LARP check above — fetching the website (SSRF-safe), the RDAP domain lookup and the GitHub read, graded by the analyst — is not part of the web checker. The bundle / sniper checkbox runs the app's wallet-intel rules and Helius history adapter as an optional second step, only when a dedicated site key and real Turnstile configuration are present. The visible preview test mode disables paid deep scans. Missing credentials refuse scans or disable the deep step; there is no silent test-secret fallback.
 

package/dist/packages/mcp/assets/kb/docs/docs-larp-the-larp-score.md

@@ -55,6 +55,6 @@ date: 2026-10-16
 
 **Missing data never lowers the score.** A page that could not be read, an RDAP or X lookup that failed, goes to a `missing` list with the points it could have added, and the result shows the range: "37, could be up to 58". Nothing unread is scored as clean.
 
-Where it shows: the `larp_check` MCP result (`score`, `band`, and `larp_score` with every flag, its points, its weight and its evidence, the range and the `missing` list; the existing fields are unchanged), the analyst panel after a LARP check (a gauge with the three biggest reasons, drawn from the tool's own result, never from the model's text).
+Where it shows: the `larp_check` MCP result (`score`, `band`, and `larp_score` with every flag, its points, its weight and its evidence, the range and the `missing` list; the existing fields are unchanged), the analyst panel after a LARP check (a gauge with the three biggest reasons, drawn from the tool's own result, never from the model's text), and the web checker's result and share card.
 
 > warn: a LARP verdict is a risk flag, not a certificate. Public HTML cannot prove a working product, a team's identity or who owns an account; domain age, a clean script scan and a GitHub with commits are evidence, not proof, and a real product can still go to zero.

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

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