dexterm-cli 0.2.0 → 0.2.1

package/dist/packages/mcp/assets/kb/app-help/streamer-overlay.md

@@ -0,0 +1,36 @@
+---
+id: streamer-overlay
+title: Streamer overlay for OBS (dexterm overlay)
+kind: app-help
+screen: all
+feature: streamer-overlay
+tags:
+  - app-help
+  - overlay
+  - obs
+  - stream
+  - streamer
+  - browser source
+  - scene
+  - twitch
+  - spectator
+  - pnl
+  - coin card
+  - activity
+commands:
+  - overlay
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Put the agent session on a live stream. `dexterm overlay` serves three transparent scenes for an OBS Browser source on 127.0.0.1: the agent activity feed, the coin card the agent is on (name, LARP evidence and the deterministic verdict, a top-10 holder bar, the live holder/rug signals) and the PnL card (the same renderer as the H key; stamped PAPER for the agent's simulated fills, or PAPER / LIVE by wallet mode with `--ledger <tradeId>`). `--scene all` puts all three in one source, `--theme cyberspace|ice|neon` picks a preset. It watches the read-only spectator stream a running `dexterm --spectate-mcp` (or `dexterm agent serve --spectate`) opens; `--replay FILE` plays a saved session and every scene then says SAMPLE DATA. Each printed URL works once (a single-use ticket, 10 minutes to paste it; press n for fresh ones). Addresses are always shortened, every scene shows the age of its data, and the overlay can only watch: it sends nothing back and cannot pause, trade, arm or sign. Full docs: https://dexterm.xyz/docs/overlay/
+
+CLI: `dexterm overlay`.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-rug-proof-entries-experimental.md

@@ -0,0 +1,52 @@
+---
+id: docs-autotrade-rug-proof-entries-experimental
+title: Autotrade (paper) › Rug-proof entries (experimental)
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Rug-proof entries (experimental)
+anchor: rug-proof-entries-experimental
+url: https://dexterm.xyz/docs/autotrade#rug-proof-entries-experimental
+tags:
+  - docs
+  - autotrade
+  - rug-proof
+  - entries
+  - experimental
+  - paper
+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/autotrade.md
+date: 2026-10-16
+---
+
+Most of the losses in our own paper testing were creator liquidity pulls on hand-made pools: one transaction, no warning, nothing to sell into afterwards. A pull cannot be front-run, so the main defense is to refuse those pools before entering. Turn it on per strategy with `entry.safety.rugproof` (the defaults below are what `{}` gives you):
+
+```json
+"entry": { "safety": { "rugproof": {
+  "minPoolAgeMin": 10, "requireSafePool": true, "maxHolderLpPct": 10,
+  "maxWithdraws": 0, "withdrawScanTx": 25,
+  "liquidityRecheck": { "afterSec": 60, "floorX": 2, "maxDropPct": 15 },
+  "routeX": 2, "youngPool": { "underMin": 30, "maxSizePct": 50 },
+  "drainGuard": { "pollSec": 10, "liqDropPct": 25, "exitOnNoRoute": true, "minReserveSol": 0.5 }
+} } }
+```
+
+Before an entry, cheapest first, and **fail closed** (a gate that cannot be read refuses the coin as `-unknown` and looks again in 5 minutes):
+
+- **pool age**: the pool itself is at least `minPoolAgeMin` minutes old. On our paper record this one gate refused all 8 pools that were later pulled and none of the 5 coins that later ran;
+- **holders**: top-10 and dev shares under the strategy's own safety limits;
+- **a second liquidity read** `afterSec` apart, both well above the exit floor and not falling fast;
+- **pool structure**: a pump.fun migration, or a pool whose LP is verifiably burned or locked; a hand-made pool (wrapped SOL as the base mint) is refused, and so is LP held by its creator or by any one wallet over `maxHolderLpPct`;
+- **withdraw history**: no liquidity `Withdraw` among the pool's newest transactions (a scan that cannot read every transaction refuses);
+- **sell route**: Jupiter returns a token-to-SOL route for `routeX` times the position size.
+
+Young or partly verified pools get at most `youngPool.maxSizePct` of the strategy's size. After an entry, the **drain guard** polls the pool every `pollSec` seconds and sells the whole position at once when liquidity falls more than `liqDropPct` from the entry read, the reserve is near zero, or Jupiter finds no route. Every refusal and exit has a named rule (`rugproof:<gate>`) in the run file and the ledger.
+
+`execution.stuckWriteOffMin` (paper only, refused in any other mode) closes a paper bag that has been unsellable for that many minutes at what could actually be realized, so a dead coin stops holding a slot. In real mode the bag is still in your wallet and keeps its exit signals.
+
+A backtest evaluates only the tick gates (pool age, holders, liquidity) and a pump.fun-mint proxy; the pool, LP, withdraw and route gates need live data. On the history so far, rug-proofing cut the losses a lot and **was still negative per entry**: it loses money more slowly, it does not make a strategy profitable.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-the-always-on-service.md

@@ -28,6 +28,8 @@ date: 2026-10-16
 
 Install it once and the strategies in your `autotrade.json` (https://dexterm.xyz/docs/autotrade#the-autotradejson-file) keep running: they start when you log in, start again after a crash, never run twice, stop at once on any kill switch, and tell you when they cannot run.
 
+dexterm autotrade service status: three paper strategies on the always-on service
+
 ```
 dexterm autotrade service install --dry-run   # shows exactly what it would write; writes nothing
 dexterm autotrade service install --load      # writes it and loads it
@@ -38,7 +40,7 @@ dexterm autotrade service logs                # the end of its log
 dexterm autotrade service uninstall           # stop, unload, remove exactly what install wrote
 ```
 
-- **What install writes.** One small job that runs `dexterm autotrade service ensure` every minute and at login: a LaunchAgent in `~/Library/LaunchAgents/` on macOS (no `KeepAlive`), a systemd user timer in `~/.config/systemd/user/` on Linux, a scheduled task on Windows. Install prints every file in full and checks that it parses before writing anything; `--dry-run` stops there, and without `--load` nothing is loaded. It runs while you are logged in (on Linux, `loginctl enable-linger` is your choice for after logout). Each `DEXTERM_HOME` gets its own job, so a test home never replaces your real one.
+- **What install writes.** One small job that runs `dexterm autotrade service ensure` every minute and at login: a LaunchAgent in `~/Library/LaunchAgents/` on macOS (no `KeepAlive`), a systemd user timer in `~/.config/systemd/user/` on Linux (Windows is not supported). Install prints every file in full and checks that it parses before writing anything; `--dry-run` stops there, and without `--load` nothing is loaded. It runs while you are logged in (on Linux, `loginctl enable-linger` is your choice for after logout). Each `DEXTERM_HOME` gets its own job, so a test home never replaces your real one.
 - **What a tick does.** `ensure` does nothing while the service's heartbeat is fresh, and otherwise starts it. The service runs `dexterm autotrade run --all --paper` for every strategy you listed, with the same lock, run files, `Q` screen and switches as a run you start by hand. Flags for it go in `~/.dexterm/autotrade/service.json` (`{ "schema": "dexterm-autotrade-service-config/1", "runArgs": ["--model", "sonnet"] }`; only `--model`, `--sol-usd`, `--config`, `--replay`, `--ms-per-tick`, `--max-minutes` and `--stub`).
 - **After a crash or a restart.** A crash costs at most a minute. The new run checks the crashed run's file, takes over the paper positions it left open (their stops, take-profits, trails and maximum hold keep running from the original entry), and never buys a coin the crashed run already took. An order that had not filled never happened, and it is never sent again.
 - **A crash loop gives up.** Restarts after a crash wait 0, 0, 1, 2 and 4 minutes; the sixth crash within an hour leaves the service down with one notification. `dexterm autotrade service status --clear` lets it start again once you have read the log.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-the-strategy-dashboard-dexterm-dash.md

@@ -0,0 +1,37 @@
+---
+id: docs-autotrade-the-strategy-dashboard-dexterm-dash
+title: Autotrade (paper) › Several strategies at once › The strategy dashboard (dexterm dash)
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: The strategy dashboard (dexterm dash)
+anchor: the-strategy-dashboard-dexterm-dash
+url: https://dexterm.xyz/docs/autotrade#the-strategy-dashboard-dexterm-dash
+tags:
+  - docs
+  - autotrade
+  - strategy
+  - dashboard
+  - dexterm
+  - dash
+  - several
+  - strategies
+  - once
+  - paper
+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/autotrade.md
+date: 2026-10-16
+---
+
+```
+dexterm dash                          # http://127.0.0.1:4317/ until Ctrl-C
+dexterm dash --json                   # the same numbers, printed
+dexterm dash --export DIR --redact-mints   # a static read-only snapshot (the page + data.json)
+```
+
+The same run files, in a browser: an overview of every strategy, one strategy in detail (its book over time, drawdown, closed trades), rugs and stuck bags, a comparison against a baseline strategy you pick (`--baseline ID`) with a 95% interval, and live status, refreshed every 30 seconds. `--home DIR` reads another dexterm home (repeat it for several), `--books FILE` adds books your own scripts wrote (`dexterm-dash-books/1`). The server listens on 127.0.0.1 only, makes no network request, loads nothing from the internet and changes nothing; `--allow-host NAME` lets a private proxy you run in front of it answer. Paper results are simulated.

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

@@ -19,4 +19,6 @@ sources:
 date: 2026-10-16
 ---
 
-Strategies you write or copy from presets, validated in one file, and backtests on your own recorded history with a held-out check. Paper only, self-directed, not financial advice.
+Strategies you write or copy from presets, validated in one file, and backtests on your own recorded history with a held-out check. Paper by default, self-directed, not financial advice.
+
+a backtest and its held-out sweep on the Q screen (PAPER, a small recorded fixture tape)

package/dist/packages/mcp/assets/kb/docs/docs-beginners-before-any-experimental-trading.md

@@ -28,6 +28,6 @@ sources:
 date: 2026-10-16
 ---
 
-Stop here until you are comfortable reading the app. Trading in dexterm is PAPER simulation, which uses pretend funds, and the keypress gate (a required physical key press) is on by default. dexterm signs nothing and sends no transaction; live trading happens in a Telegram trading bot of your choice, outside dexterm. No analyst, voice, or connected program can trade.
+Stop here until you are comfortable reading the app. Trading in dexterm is PAPER simulation by default, which uses pretend funds, and the keypress gate (a required physical key press) is on by default. dexterm signs nothing and sends no transaction. Real mode is experimental; signals to your own executor; dexterm never holds a key; not financial advice. No analyst, voice, or connected program can trade or turn real mode on.
 
-Never enter a seed phrase, private key, password, API key, or authentication token. Read the paper trading guide (https://dexterm.xyz/docs/paper-trading) and live trading (https://dexterm.xyz/docs/live-trading) before considering anything beyond the read-only walkthrough.
+Never enter a seed phrase, private key, password, API key, or authentication token. Read the paper trading guide (https://dexterm.xyz/docs/paper-trading), real mode (https://dexterm.xyz/docs/real-mode) and live trading (https://dexterm.xyz/docs/live-trading) before considering anything beyond the read-only walkthrough.

package/dist/packages/mcp/assets/kb/docs/docs-beginners-copy-and-paste-without-surprises.md

@@ -34,6 +34,5 @@ Copy only the text inside a code box. Do not copy a leading `$`; it represents t
 |---|---|---|
 | macOS Terminal | Command-C | Command-V |
 | Linux terminal | Ctrl-Shift-C | Ctrl-Shift-V |
-| Windows Terminal | Ctrl-Shift-C | Ctrl-Shift-V |
 
 Right-click and choose **Paste** if the shortcut does not work. A multi-line paste can run several commands, so this guide uses one command per box. Never paste a command you do not understand; read the sentence above it first.

package/dist/packages/mcp/assets/kb/docs/docs-beginners-if-dexterm-says-command-not-found.md

@@ -31,6 +31,6 @@ sources:
 date: 2026-10-16
 ---
 
-Close and reopen the terminal first. Then run `npm prefix -g` to see npm's global install folder. On macOS/Linux, npm's executable folder must be on your PATH; the installer output normally tells you the exact line for your setup. Do not paste a PATH fix from a stranger. On Windows, rerun the Node.js installer and keep its “Add to PATH” option enabled, then reopen Windows Terminal.
+Close and reopen the terminal first. Then run `npm prefix -g` to see npm's global install folder. On macOS/Linux, npm's executable folder must be on your PATH; the installer output normally tells you the exact line for your setup. Do not paste a PATH fix from a stranger.
 
-You can confirm whether the shell can find dexterm with `command -v dexterm` on macOS/Linux or `Get-Command dexterm` in PowerShell.
+You can confirm whether the shell can find dexterm with `command -v dexterm`.

package/dist/packages/mcp/assets/kb/docs/docs-beginners-reopen-dexterm-later.md

@@ -27,7 +27,7 @@ sources:
 date: 2026-10-16
 ---
 
-Open Terminal, a Linux terminal, or PowerShell again and run:
+Open Terminal or a Linux terminal again and run:
 
 ```sh reopen dexterm
 dexterm

package/dist/packages/mcp/assets/kb/docs/docs-beginners-terminal-shell-prompt-command-output-and-path.md

@@ -30,8 +30,8 @@ sources:
 date: 2026-10-16
 ---
 
-- A **terminal** is a text window for giving your computer instructions. macOS calls its built-in app Terminal. Windows users should use PowerShell inside Windows Terminal. Linux includes a terminal app with the desktop.
-- A **shell** is the program inside that window that reads what you type. PowerShell is a shell; `zsh` and `bash` are common macOS and Linux shells. You do not need to learn which one you have.
+- A **terminal** is a text window for giving your computer instructions. macOS calls its built-in app Terminal. Linux includes a terminal app with the desktop. dexterm runs on macOS and Linux; Windows is not supported.
+- A **shell** is the program inside that window that reads what you type. `zsh` and `bash` are common macOS and Linux shells. You do not need to learn which one you have.
 - A **prompt** is the short text, often ending in `$` or `>`, that means the shell is ready. Do not type the prompt itself.
 - A **command** is one line you type after the prompt, such as `dexterm doctor`.
 - **Output** is the text the computer prints after a command. Output is an answer, not another command to copy blindly.

package/dist/packages/mcp/assets/kb/docs/docs-beginners-windows-expectations.md

@@ -26,4 +26,4 @@ sources:
 date: 2026-10-16
 ---
 
-Windows x64 is experimental: the full CI suite passed for 0.1.4, though some file-permission checks are skipped. File permissions rely on your Windows user profile; voice has no Windows speech engine; browser-opening actions show a URL instead; `doctor` may print a macOS/Linux repair command; and the npm-installed `claude.cmd` is not detected as a usable analyst binary. These limits do not change the key rule: dexterm never holds your wallet keys.
+dexterm supports macOS and Linux. Windows is not supported: private files rely on macOS and Linux file permissions, voice has no Windows engine, browser-opening actions and `doctor`'s repair commands assume macOS or Linux, and the npm-installed `claude.cmd` is not detected as a usable analyst binary. The supported platforms (https://dexterm.xyz/docs/getting-started#supported-platforms) table has the details.

package/dist/packages/mcp/assets/kb/docs/docs-beginners-windows.md

@@ -27,4 +27,4 @@ sources:
 date: 2026-10-16
 ---
 
-Open the Start menu, type **Windows Terminal**, and choose the **PowerShell** tab. Windows support is experimental and has not yet passed the project's test run; the known limits are listed under Windows expectations (https://dexterm.xyz/docs/beginners#windows-expectations).
+Windows is not supported. See Windows expectations (https://dexterm.xyz/docs/beginners#windows-expectations).

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

@@ -37,3 +37,5 @@ A strategy you build climbs one ladder, one rung at a time:
 | 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.
+
+the journey view (J on the Q screen): one rung at a time, the forward test set beside its backtest (PAPER)

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

@@ -22,3 +22,5 @@ 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.
+
+a strategy the analyst proposed in chat, as a diff you apply with a key (PAPER)

package/dist/packages/mcp/assets/kb/docs/docs-classifier-hosted-jev-with-your-own-key.md

@@ -0,0 +1,34 @@
+---
+id: docs-classifier-hosted-jev-with-your-own-key
+title: Classification models › Hosted Jev with your own key
+kind: docs
+page: classifier
+page_title: Classification models
+heading: Hosted Jev with your own key
+anchor: hosted-jev-with-your-own-key
+url: https://dexterm.xyz/docs/classifier#hosted-jev-with-your-own-key
+tags:
+  - docs
+  - classifier
+  - hosted
+  - jev
+  - own
+  - key
+  - 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 key set          paste your TypeSafe API key (hidden input; stored 0600 under ~/.dexterm/keys)
+dexterm classifier pick jev-hosted
+```
+
+dexterm never ships or shares a key. The key is sent only to `https://api.typesafe.ai`, never printed, and never stored in `classifier.json`. `TYPESAFE_API_KEY` in the environment works too. Each call counts tokens. Set your price per million input tokens in `~/.dexterm/classifier.json` (`jev.pricePerMTokUsd`) to see a cost in dollars; until you do, the cost shows as *unpriced*, never as $0. A daily call cap (`jev.maxCallsPerDay`, default 1,000) stops calls before they reach the network. A rate limit from the API is reported with its retry time.

package/dist/packages/mcp/assets/kb/docs/docs-classifier-how-they-measured-on-dexterm-s-own-history.md

@@ -0,0 +1,52 @@
+---
+id: docs-classifier-how-they-measured-on-dexterm-s-own-history
+title: Classification models › How they measured on dexterm's own history
+kind: docs
+page: classifier
+page_title: Classification models
+heading: How they measured on dexterm's own history
+anchor: how-they-measured-on-dexterm-s-own-history
+url: https://dexterm.xyz/docs/classifier#how-they-measured-on-dexterm-s-own-history
+tags:
+  - docs
+  - classifier
+  - they
+  - measured
+  - dexterm
+  - own
+  - history
+  - 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's benchmark (October 2026) asked each model about coins whose outcome we already know: 1,054 coins from the LARP eval set (rugged or dead within 72 hours?) and 1,800 coins from the recorder's history (drained within 6 hours?). The rules and the pick were fixed before the final held-out coins were scored, and those were scored once. AUROC says how well a model ranks the coins that went bad above the ones that did not: 0.5 is a coin flip, 1.0 is perfect.
+
+| model | where it ran | drained within 6 h (held-out) | bad within 72 h (held-out) | time per coin | cost |
+|---|---|---|---|---|---|
+| Built-in scores (default) | anywhere | 0.50 | 0.71 | under 1 ms | free |
+| Kev 0.8B (Q8) | Intel Mac mini CPU | 0.54 | 0.46 | 3-7 s | free |
+| Kev 4B (Q4) | desktop and Mac mini CPUs | 0.52 | 0.73 | 5-14 s | free |
+| Kev 9B (Q4) | RTX 4080 GPU | 0.53 | 0.79 | 0.06-0.2 s | free |
+| Claude haiku (comparison only) | Claude CLI | 0.62 | 0.86 | about 5 s | about $0.0009 |
+| Kev 27B, hosted Jev, open JEV | not measured | | | | |
+
+What this means:
+
+- **No model is good at this yet.** Predicting a coin's next six hours from what is known now is hard for everything we tried, including the built-in scores. Treat every estimate as one weak input, never as a verdict.
+- **Kev 0.8B ranks coins no better than chance** and gives almost the same number for every coin, so dexterm never suggests it.
+- **Kev 4B** is the model `dexterm classifier pull` suggests if you want a local model: it was the best Kev on the development coins. On the held-out coins it tied the built-in scores (no better, no worse), so the built-in scores stay the default.
+- **Claude (zero-shot) ranked best** on both questions, but it needs your Claude login, the network and a small cost per coin, so it is a comparison point, not a default.
+- **Kev 9B** (measured later, on a GPU) is fast, a fraction of a second per coin, but no better. On the development coins it trailed Kev 4B on the drain question. On the held-out coins it tied both the built-in scores and Kev 4B: its 0.79 on the LARP question and 0.53 on drain are within chance variation of theirs. So `kev-4b-q4` stays the suggestion, and the 9B model is there if you want to try it.
+- **Kev 27B and the open JEV models were not measured** (no file llama.cpp can run, or a GPU larger than 16 GB needed). They may do better; we do not know.
+- **Hosted Jev was not measured**: it needs a TypeSafe key, and dexterm's own tests run against a stand-in server only.
+- Kev was trained on general text decisions (intents, reviews, policies), not on memecoins. Its authors' accuracy figures are about those tasks, not this one.
+
+`dexterm classifier bench` times the model you picked on your own machine (seconds per coin and per 1,000 coins).

package/dist/packages/mcp/assets/kb/docs/docs-classifier-set-up-kev-on-your-own-machine.md

@@ -0,0 +1,39 @@
+---
+id: docs-classifier-set-up-kev-on-your-own-machine
+title: Classification models › Set up Kev on your own machine
+kind: docs
+page: classifier
+page_title: Classification models
+heading: Set up Kev on your own machine
+anchor: set-up-kev-on-your-own-machine
+url: https://dexterm.xyz/docs/classifier#set-up-kev-on-your-own-machine
+tags:
+  - docs
+  - classifier
+  - set
+  - kev
+  - own
+  - machine
+  - 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
+---
+
+```
+1. dexterm classifier doctor               your RAM, CPU and GPU, and the model tier it recommends
+2. dexterm classifier pull kev-4b-q4       shows the size and the source, asks, checks the disk, verifies the sha256
+3. dexterm classifier pick kev-local kev-4b-q4
+4. dexterm classifier serve                runs llama-server on 127.0.0.1 (leave it open)
+5. dexterm classifier try                  one labelled estimate, to see it work
+```
+
+You need llama.cpp's `llama-server` from a build released on 2026-10-02 or later: that is when it gained the `/v1/systemone` endpoint decision models use. Put it on your `PATH`, or point `DEXTERM_LLAMA_SERVER` at it. Downloads come from the pinned revision of the model's Hugging Face repo and are checked against a sha256 before use. Once a model is downloaded, it works fully offline.
+
+If the picked model is not running, the built-in scores answer instead, and the answer says it is a fallback.

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

@@ -0,0 +1,35 @@
+---
+id: docs-classifier-settings
+title: Classification models › Settings
+kind: docs
+page: classifier
+page_title: Classification models
+heading: Settings
+anchor: settings
+url: https://dexterm.xyz/docs/classifier#settings
+tags:
+  - docs
+  - classifier
+  - settings
+  - 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.json` (0600). Only `dexterm classifier` writes it.
+
+| key | what it does |
+|---|---|
+| `provider` | `heuristic` (default), `kev-local`, `jev-hosted`, `jev-open`, `claude`, `ollama-llm` |
+| `default` | the shipped recommendation for a local model |
+| `kev.endpoint`, `kev.model`, `kev.threads` | the local server (loopback only) and the model id |
+| `jev.endpoint`, `jev.model`, `jev.pricePerMTokUsd`, `jev.maxCallsPerDay` | hosted Jev |
+| `calibration` | optional Platt maps per model and question, fitted on labelled rows |
+| `fallback` | answer with the built-in scores when the provider is unreachable (default `true`) |

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

@@ -0,0 +1,36 @@
+---
+id: docs-classifier-the-choices
+title: Classification models › The choices
+kind: docs
+page: classifier
+page_title: Classification models
+heading: The choices
+anchor: the-choices
+url: https://dexterm.xyz/docs/classifier#the-choices
+tags:
+  - docs
+  - classifier
+  - choices
+  - 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
+---
+
+| provider | what it is | runs where | cost |
+|---|---|---|---|
+| `heuristic` | the built-in scores: the H1 rug score and the LARP link score | inside dexterm | $0, instant |
+| `kev-local` | Kev, an open decision model (Apache-2.0), run by llama.cpp | your machine | $0 per call after the download |
+| `jev-hosted` | Jev, TypeSafe's hosted flagship decision model | TypeSafe's API, with **your own** key | per call, on your TypeSafe account |
+| `jev-open` | the open JEV students (`autotrust/JEV-*`, Apache-2.0) on a vLLM server | your GPU server (24 GB or more) | $0 per call |
+| `claude`, `ollama-llm` | a chat model asked for probabilities (a comparison baseline) | your Claude CLI / your Ollama | your plan / $0 |
+
+A decision model reads the coin's facts once and scores every answer in one pass, without writing text. That is why it can be fast enough to score a whole screener.
+
+The default is `heuristic`: dexterm downloads nothing and calls nothing on first run.

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.2.0-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.2.0-src.tar.gz --repo dexterm-xyz/dexterm
-$ tar -xzf dexterm-0.2.0-src.tar.gz && cd dexterm-0.2.0
+$ 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
 ```