dexterm-cli 0.2.0 → 0.2.2

package/dist/packages/mcp/assets/kb/app-help/strategy-dashboard.md

@@ -0,0 +1,38 @@
+---
+id: strategy-dashboard
+title: Track how your autotrade strategies perform in a browser, on this machine only (dexterm dash)
+kind: app-help
+screen: all
+tags:
+  - app-help
+  - dash
+  - dashboard
+  - performance
+  - strategies
+  - track
+  - equity
+  - drawdown
+  - compare
+  - baseline
+  - rugs
+  - stuck
+  - browser
+  - web
+  - phone
+commands:
+  - dash
+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
+---
+
+`dexterm dash` reads your own autotrade run ledgers ($DEXTERM_HOME/autotrade/runs) and serves a dashboard on http://127.0.0.1:4317/ (loopback only; no account, no cloud, nothing leaves the machine; read-only). Views: Overview (every strategy side by side with an equity sparkline), Strategy (equity curve, drawdown, exit reasons, open positions with the engine mark and the realizable value from the last cached pool read, every trade), Rugs & stuck (closed at -80% or worse and stuck positions written off at what they actually sold), Compare (each strategy minus a --baseline with the 95% interval of the difference) and Live status; it refreshes every 30 s. Every number carries its sample size; under 20 closed trades a strategy is exploratory. Flags: --port, --home (repeat for several homes), --baseline ID, --books FILE (your own script's books), --allow-host NAME (a private proxy in front), --json, --export DIR [--redact-mints] (a static read-only snapshot). PAPER results are simulated. Not financial advice.
+
+CLI: `dexterm dash`.

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-confidence-tiers-experimental-unproven-paper-only.md

@@ -0,0 +1,56 @@
+---
+id: docs-autotrade-confidence-tiers-experimental-unproven-paper-only
+title: Autotrade (paper) › Confidence tiers (experimental, unproven, paper only)
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Confidence tiers (experimental, unproven, paper only)
+anchor: confidence-tiers-experimental-unproven-paper-only
+url: https://dexterm.xyz/docs/autotrade#confidence-tiers-experimental-unproven-paper-only
+tags:
+  - docs
+  - autotrade
+  - confidence
+  - tiers
+  - experimental
+  - unproven
+  - paper
+  - only
+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
+---
+
+**Unproven.** On our held-out data no tier made money, and our November research found no dexterm strategy with a proven edge. This is a way to test a sizing rule on paper; it is not a signal and not a reason to trade real money. Off unless a strategy turns it on, and refused outside paper.
+
+Turn it on per strategy with `sizing.tiers` (paper mode, and the rug-proof block (https://dexterm.xyz/docs/autotrade#rug-proof-entries-experimental) with `minPoolAgeMin` 10 or more):
+
+```json
+"sizing": { "tiers": { "table": "v4-1785", "experimental": "paper-only" } }
+```
+
+The engine, not the agent, then scores every candidate on two figures from that coin's own tick:
+
+- **turnover1h** = 1 h volume / liquidity, a point at **9.878 or less**;
+- **bs5m** = buys / sells over 5 minutes, a point at **3.714 or more**.
+
+Score 0 is **T0, a skip**: no entry. Score 1 is T3, score 2 is T4. **No tier runs above 25% of the book**: the table configures T3 at 75% and T4 at 100%, and both run at 25%. The cap is in the engine's code; no strategy field, table entry or agent answer lifts it, and it also holds across the scale-in tranches of a tiered position. After that every limit you set still applies and the stricter one wins (`maxPctOfBankroll`, `maxUsd`, the profile's max, per-trade loss, exposure, cash, price impact, the drawdown size-down, the rug-proof young-pool cap). The agent can ask for less, never more, and its confidence does not change the tier. One open position at a time unless you add `"oneOpen": false`; an entry still waiting for its fill (the execution latency) or for your approval counts as open, for this and for `maxConcurrent`, and its dollars count against your exposure and cash.
+
+A tier also needs, or it is T0: liquidity of $30,000 or more, a token at least 10 minutes old, not young (under 2 h) and vertical (1 h change of 150% or more), a 1 h change at all for a young coin, and a live tick no older than 5 minutes at the moment of the decision. A missing, negative or non-numeric figure never scores a point.
+
+Paper only, three times over: `dexterm autotrade validate` refuses the block in mode `real` or `live`, the runner refuses it in a real-signal run, and the engine refuses it outside paper.
+
+Where you see it: `dexterm autotrade validate <id>` prints the verdict and every tier with its held-out numbers, `dexterm autotrade list` marks the strategy `EXPERIMENTAL tiers (unproven, paper only)`, every candidate writes a `TIER` line in the run log with its score, size and the verdict, and the ledger's clamp event records the tier.
+
+The table's held-out numbers (frozen before the held-out set was scored once, per entry, 95% interval):
+
+| tier | when | runs at | held-out |
+|---|---|---|---|
+| T0 | score 0 or a failed gate | skip | 19 entries, mean -17.0% (-35.7% … +3.4%) |
+| T3 | score 1 | 25% | 17 entries, mean -7.6% (-31.8% … +16.8%) |
+| T4 | score 2 | 25% | no entries (too few to say anything) |

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,36 @@
+---
+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 owner-only 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.
+
+The key file must be readable by your account only: on macOS and Linux it is saved with mode 0600, and a file other users can read is refused. On Windows (not supported, see Windows expectations (https://dexterm.xyz/docs/beginners#windows-expectations)) file modes mean nothing, so `key set` locks the file to your Windows account with `icacls` and every read checks its access list; a file other accounts can read, or one whose access list cannot be checked, is refused. `dexterm classifier key status` says why a file is refused. If `icacls` or PowerShell is blocked on your machine, set `TYPESAFE_API_KEY` in your environment instead.

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.