dexterm-cli 0.1.7 → 0.2.1

package/dist/packages/custom/src/rules.js

@@ -3,7 +3,8 @@ export const FIELDS = {
     vol5m: (r) => r.vol5m, vol1h: (r) => r.vol1h, vol24: (r) => r.vol24,
     holders: (r) => r.holders, org: (r) => r.org, top10: (r) => r.top10, dev: (r) => r.dev,
     lplocked: (r) => r.lpLocked, bundled: (r) => r.bundled, snipers: (r) => r.snipers,
-    cluster: (r) => r.cluster, larp: (r) => r.larp, devrugs: (r) => r.devRugs,
+    cluster: (r) => r.cluster, larp: (r) => r.larp, devrugs: (r) => r.devRugs, rugp: (r) => r.rugP,
+    narrative_rank: (r) => r.narrativeRank, narrative_score: (r) => r.narrativeScore,
     fresh: (r) => r.fresh, mintable: (r) => r.mintable, freezable: (r) => r.freezable,
     age: (r) => r.ageMin, m5: (r) => r.chg?.m5, h1: (r) => r.chg?.h1, h6: (r) => r.chg?.h6, h24: (r) => r.chg?.h24,
     buys: (r) => r.buys, sells: (r) => r.sells, bonding: (r) => r.bonding,
@@ -16,6 +17,9 @@ const TAGS = {
     flag: (r, v) => (v === 'clean' ? (r.flags ?? []).length === 0 : (r.flags ?? []).map((f) => f.toLowerCase()).includes(v.toLowerCase())),
     verified: (r, v) => (v === 'yes') === !!r.verified,
     sus: (r, v) => (v === 'yes') === !!r.sus,
+    // task-1818: `narrative:ignition` (or spark / peak / fading / dead) = the coin's narrative is in that lifecycle state;
+    // `narrative:saturated` = copy-cat saturated. An untracked coin matches nothing (so `!narrative:dead` is true for it).
+    narrative: (r, v) => { const k = v.toLowerCase(); return k === 'saturated' ? r.narrativeSaturated === true : !!r.narrativeLifecycle && r.narrativeLifecycle === k; },
 };
 export const TAG_NAMES = Object.keys(TAGS);
 export const ACTIONS = ['alert', 'ticket', 'ask', 'popup', 'tag', 'sound', 'watch'];

package/dist/packages/data/src/trade/ledger/schema.js

@@ -23,7 +23,7 @@ export const LEDGER_SCHEMA = 'dexterm-ledger/1';
 export const LEDGER_VERSION = 1;
 export const GENESIS = 'genesis';
 export const LEDGER_SOURCES = ['paper', 'desk', 'autotrade', 'live'];
-export const WALLET_MODES = ['paper', 'devnet', 'live'];
+export const WALLET_MODES = ['paper', 'devnet', 'live', 'real'];
 // ───────────────────────────── hygiene ─────────────────────────────
 /** A base58 secret key (64 bytes ≈ 87-88 chars) or a 64-number byte array: never stored, whatever field it is in. */
 const KEY_SHAPED = /(?:[1-9A-HJ-NP-Za-km-z]{85,90})|(?:\[(?:\s*\d{1,3}\s*,){63}\s*\d{1,3}\s*\])/g;

package/dist/packages/mcp/assets/kb/app-help/autotrade-executor-kit.md

@@ -0,0 +1,44 @@
+---
+id: autotrade-executor-kit
+title: Wire up a test executor, check it is alive, and get the digest (dexterm autotrade executor, signal test, report)
+kind: app-help
+screen: all
+feature: autotrade-executor-kit
+tags:
+  - app-help
+  - executor
+  - kit
+  - example
+  - heartbeat
+  - alive
+  - silent
+  - health
+  - test
+  - webhook
+  - receiver
+  - dry
+  - run
+  - digest
+  - report
+  - daily
+  - weekly
+  - divergence
+  - slippage
+  - latency
+commands:
+  - autotrade
+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 autotrade executor kit --out ~/my-executor` copies the reference executors: a webhook receiver, a `--signal-cmd` hook and a JSONL tail. Each verifies the HMAC, dedupes by nonce, honours the TTL, writes a receipt and a heartbeat, and is DRY RUN: it only logs what it would do, with no wallet code in it. Start one, point a channel at it (`dexterm autotrade signal channels --webhook http://127.0.0.1:8787/signal`), then `dexterm autotrade signal test` sends a test signal (`test: true`, no coin, nothing to trade) and shows, per channel, whether it was delivered, how long it took and the executor's receipt. `dexterm autotrade executor status` shows the last heartbeat, the last receipt and the lag; a real run pauses new buy signals (exits still go out) when nothing is heard for longer than your `executorSilenceMin` limit, and tells you. With receipts that carry fills, `signal status`, `autotrade audit` and `dexterm autotrade report` show paper vs real: slippage against dexterm's own paper fill, latency, partial fills and rejections. `report [--period day|week] [--telegram]` is the digest per strategy and mode with the win rate's interval and a small-sample note; `report --schedule daily|weekly` makes a run with your bot on send it.
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-journey.md

@@ -0,0 +1,46 @@
+---
+id: autotrade-journey
+title: Build a strategy by chat, back-test it, forward-test it, then promote it (paper, then real)
+kind: app-help
+screen: all
+feature: autotrade-journey
+tags:
+  - app-help
+  - autotrade
+  - strategy
+  - build
+  - chat
+  - journey
+  - ladder
+  - backtest
+  - held-out
+  - forward
+  - test
+  - promote
+  - promotion
+  - always-on
+  - real
+  - evidence
+commands:
+  - autotrade
+tools:
+  - strategy_journey
+  - strategy_forward_start
+  - strategy_forward_stop
+  - strategy_forward_report
+  - strategy_promote_propose
+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
+---
+
+A strategy climbs one ladder, one rung at a time: draft → backtested → forward-tested → always-on (paper) → real. Each rung needs evidence measured on that strategy's exact rules; any rule change starts it again (a rename or arming keeps it). Ask the analyst to build one ("build me a strategy that buys young pairs on a 5-minute push and takes profit at 2x"): it proposes a copy of a preset with changes (strategy_propose_new), you apply it on the Q screen. BACKTESTED: `dexterm autotrade backtest <id>` or strategy_backtest runs it on recorded history and on each half of the held-out split (the newest 30% of coins); verdict rule 6 allows gain wording only with at least 20 trades in both halves and a held-out net above 0. FORWARD-TESTED: `dexterm autotrade forward start <id> --hours 24` (or `--trades N`, or strategy_forward_start from the chat) runs the same version on the LIVE tape, on paper, with its own bankroll and run file, in the background next to the always-on service; `forward status`, `forward stop` and `forward report` (the forward numbers next to the backtest: trades, win rate with its interval, net, drawdown, rug rate, fill cost drift, and a plain line when a sample is too small). Only a test that ran its whole window on live data counts. ALWAYS-ON: the analyst can propose it (strategy_promote_propose), you apply it with `dexterm autotrade promote apply <pp-id>` (y on your own terminal) or on the Q screen journey view (`J`, then `y`); it joins autotrade.json and the always-on service runs it on paper. REAL: you set your own limits (`dexterm autotrade limits set`; `signal caps set` sets four of them), then `dexterm autotrade promote <id> --to real` hands over to `signal arm` (evidence panel, typed phrase with a one-time code). No tool or model can apply a promotion, skip a rung, set a cap, pick a bankroll or arm real mode. `dexterm autotrade journey <id>` shows where a strategy stands. Paper by default; not financial advice.
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-limits.md

@@ -0,0 +1,48 @@
+---
+id: autotrade-limits
+title: Set your own real-mode limits: per trade, per day, open positions, loss stops, the breaker (dexterm autotrade limits)
+kind: app-help
+screen: all
+feature: autotrade-limits
+tags:
+  - app-help
+  - limits
+  - limit
+  - caps
+  - cap
+  - size
+  - sizing
+  - per
+  - trade
+  - daily
+  - loss
+  - drawdown
+  - breaker
+  - streak
+  - exposure
+  - slippage
+  - ttl
+  - rate
+  - raise
+  - lower
+  - scope
+commands:
+  - autotrade
+tools:
+  - trading_limits
+  - limits_propose
+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
+---
+
+Every limit real mode enforces is yours to set, in one file (`~/.dexterm/autotrade/real/limits.json`, schema `dexterm-limits/1`): per trade as SOL or as % of the book (the smaller wins), SOL and buys per day, open positions, exposure, min and max position, per coin per day, a daily loss stop, a drawdown breaker, a loss-streak pause, max hold time, the evidence floor for arming (`minForwardTrades`: closed paper trades in a completed forward test, placeholder 10), min liquidity and market cap, max slippage and price impact, the signal TTL, a buy rate limit, an optional sell rate (sells are never capped unless you set one) and how long a silent executor may stay silent. `dexterm autotrade limits show [--strategy ID] [--account ID]` lists what is in force and where each number comes from; `limits set perTradeSol=0.5 dailyLossSol=0.3` (or `--scope real|paper|strategy:ID|account:ID`) changes them: a global number replaces the placeholder default, every other scope can only tighten, and the stricter always wins. Paper runs ignore them unless you add a `paper` scope; then a single paper run (not `run --all`) obeys them on its own state (a replay then needs `--sol-usd N`). Daily counters cover the whole home (every strategy and account), so a strategy or account number can only stop buys sooner. Lowering is immediate, even for a running real run; raising shows the old -> new diff and needs the typed phrase on your own terminal, and applies from the next run. `limits diff`, `limits accept` (a hand-edited file), `limits reset`, `limits breaker reset` (typed) and `limits explain` do the rest. The defaults (0.25 SOL a trade, 1 SOL a day, 20 buys, 3 open, stop at -0.5 SOL a day) are placeholders: arming asks for your own numbers first. The analyst can read and explain them (`trading_limits`) and propose a change as a diff card (`limits_propose`); it can never apply one.
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-real-signal.md

@@ -0,0 +1,45 @@
+---
+id: autotrade-real-signal
+title: Real mode: send a strategy's trades to your own executor as LIVE TRADE FIRE signals (dexterm autotrade signal)
+kind: app-help
+screen: all
+feature: autotrade-real-signal
+tags:
+  - app-help
+  - real
+  - mode
+  - live
+  - trade
+  - fire
+  - signal
+  - signals
+  - executor
+  - webhook
+  - hook
+  - jsonl
+  - receipt
+  - receipts
+  - arm
+  - caps
+  - kill
+  - outbox
+  - nonce
+commands:
+  - autotrade
+tools:
+  - trade_fire_feed
+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
+---
+
+Real mode runs a strategy exactly like paper (the same clamp, exits, monitor and run file) and sends every buy and sell it fills, first, as a LIVE TRADE FIRE signal (`dexterm-trade-fire/1`: buy or sell, mint, symbol, size in SOL and % of book, the sell fraction and exit reason, strategy, run, account, an always-growing nonce, an idempotency id and an expiry) to YOUR executor: a Telegram trading bot of your choice or any script. dexterm holds no key and signs nothing. Set channels with `dexterm autotrade signal channels --webhook URL | --signal-cmd '["/abs/path"]' | --jsonl on | --mcp on | --telegram on` (they live in connectors.json next to the Telegram setup; a bot cannot read another bot, so the Telegram copy alone is not enough), a webhook HMAC secret with `signal secret generate --out FILE`, hard caps with `signal caps set` (raising needs a typed confirmation), then arm on your own terminal with `dexterm autotrade signal arm <id>` (evidence panel + a typed phrase with a one-time code; any later edit disarms; below the evidence floor, a completed forward test with your `minForwardTrades` closed paper trades and a backtest of these exact rules, or past a missing rung of the ladder, it refuses unless you first type a separate OVERRIDE phrase, which is journaled) and run `dexterm autotrade run <id> --real` (live data only, in the foreground: in 0.2.0 the always-on service runs paper strategies only). Delivery is at least once from a restart-safe outbox, in nonce order, retried until acked or expired; the executor dedupes by nonce, ignores expired signals and acts only on its own account. Every run ends with a `halted` signal that lists the positions still open; the run's last lines and the Telegram copy name them too. Open positions are carried to the next real run of the same strategy and account, whose exits keep firing; while no real run is running NO signal goes out, sells included, so manage them in your executor. Positions stay unconfirmed until `dexterm autotrade receipt <nonce> executed|rejected|failed` (data only). `signal kill` stops every signal; `signal status`, `signal tail`, `receipt list` and `autotrade audit` show the outbox, receipts and drift; agents can read the MCP feed with trade_fire_feed. No model, tool or chat tap can arm real mode, raise a cap or lift the kill switch. Experimental; not financial advice.
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/classification-models.md

@@ -0,0 +1,41 @@
+---
+id: classification-models
+title: Pick a classification model (Kev, hosted Jev, or the built-in scores)
+kind: app-help
+screen: all
+feature: classifier
+tags:
+  - app-help
+  - classifier
+  - classification
+  - kev
+  - jev
+  - model
+  - probability
+  - rug
+  - drain
+  - llama
+  - calibrated
+  - typesafe
+  - experimental
+commands:
+  - classifier
+tools:
+  - classify_coin
+  - classify_batch
+  - classifier_status
+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
+---
+
+EXPERIMENTAL. A classification model answers typed questions about one coin with a probability per answer: p(drain within 6 h) and RUG / WIN / DUD over 6 h, or a narrative category. `dexterm classifier list` shows the choices: `heuristic` (the built-in H1 rug score and LARP link score; the default, no download), `kev-local` (an open Kev decision model on your own machine through llama.cpp: `dexterm classifier pull kev-4b-q4` shows the size and source and asks first, verifies the sha256, then `dexterm classifier pick kev-local kev-4b-q4` and `dexterm classifier serve`), `jev-hosted` (TypeSafe's hosted Jev with your own API key: `dexterm classifier key set`; per-call cost and a daily call cap), `jev-open` (the open JEV students on a vLLM server), and `claude` / `ollama-llm` zero-shot baselines. `dexterm classifier doctor` reads RAM, CPU and GPU/VRAM and recommends a tier. If the picked model is unreachable the built-in scores answer and say so. Agents use the `classify_coin`, `classify_batch` (triage: flag / pass / escalate) and `classifier_status` MCP tools; a watch rule can use `rugp` (e.g. `when rugp > 0.8 then alert(warn, "...")`). How each model scored on dexterm's own labelled history is on the docs page. Every answer is a model estimate with the model id, never advice. Docs: https://dexterm.xyz/docs/classifier/
+
+CLI: `dexterm classifier`.

package/dist/packages/mcp/assets/kb/app-help/live-trading.md

@@ -33,6 +33,6 @@ sources:
 date: 2026-10-16
 ---
 
-dexterm never holds a key and never signs or sends a transaction: there is no trading wallet, no signer and no live order in dexterm. Live trading happens in a Telegram trading bot of your choice, which holds its own wallet; you act in that bot. dexterm's part is the Telegram connector to your OWN bot (`dexterm telegram setup`): alerts, signals and run control for your paper runs. dexterm 0.1.7 does not place orders in a trading bot for you. Paper trading (the ticket, paper accounts, paper autotrade) is local. `dexterm wallet link` keeps a Phantom public key for display only. Not financial advice. Full docs: https://dexterm.xyz/docs/live-trading/
+dexterm never holds a key and never signs or sends a transaction: there is no trading wallet, no signer and no live order in dexterm. Live trading happens in a Telegram trading bot of your choice, which holds its own wallet; you act in that bot. dexterm's part is the Telegram connector to your OWN bot (`dexterm telegram setup`): alerts, signals and run control for your paper runs. dexterm does not place orders in a trading bot for you: in real mode (0.2.0, experimental) a strategy you armed on your own terminal sends a signal for each trade to an executor you run, and your executor places the order by its own rules (`dexterm autotrade signal`, https://dexterm.xyz/docs/real-mode/). Paper trading (the ticket, paper accounts, paper autotrade) is local. `dexterm wallet link` keeps a Phantom public key for display only. Not financial advice. Full docs: https://dexterm.xyz/docs/live-trading/
 
 CLI: `dexterm telegram`, `dexterm wallet`, `dexterm live`.

package/dist/packages/mcp/assets/kb/app-help/narratives-tracker.md

@@ -0,0 +1,45 @@
+---
+id: narratives-tracker
+title: Track memes and narratives (dexterm narratives, experimental)
+kind: app-help
+screen: narrative
+feature: narratives
+tags:
+  - app-help
+  - narratives
+  - narrative
+  - memes
+  - meme
+  - copycat
+  - lifecycle
+  - ignition
+  - heat
+  - saturated
+  - experimental
+keys:
+  - n
+  - enter
+actions:
+  - narrative.view
+  - narrative.drill
+commands:
+  - narratives
+tools:
+  - narratives_top
+  - narrative_detail
+  - narrative_of
+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
+---
+
+EXPERIMENTAL. The narratives tracker groups coins by the theme their name and ticker carry (ticker puns, animals, celebrities, AI agents, seasonal events, copy-cats of a runner) and measures each theme per window: coins, new-coin rate, volume share, unique-trader growth, top runner and drawdown, a lifecycle state (spark / ignition / peak / fading / dead, with the rule that set it) and a copy-cat saturation flag. On the N screen, n flips the board into the NARRATIVES table (the first switch reads the last 26 h of recorded history and takes tens of seconds), enter to see a narrative's coins in spawn order, esc to go back. `dexterm narratives [top|detail ID|of MINT|export]` prints the same from the recorder; the analyst uses narratives_top, narrative_detail and narrative_of. Rules can use narrative_rank, narrative_score and the tags narrative:ignition / narrative:saturated. Keyless and local; measured heat, not advice.
+
+Keys: `n` (narrative), `⏎` (narrative). CLI: `dexterm narratives`.

package/dist/packages/mcp/assets/kb/app-help/screen-autotrade.md

@@ -79,6 +79,10 @@ keys:
   - !
   - f
   - o
+  - J
+  - F
+  - X
+  - A
 actions:
   - quit
   - screen.screener
@@ -141,6 +145,10 @@ actions:
   - autotrade.pause
   - autotrade.flatten
   - autotrade.proposal
+  - autotrade.journey
+  - autotrade.forward
+  - autotrade.forwardstop
+  - autotrade.promote
 tools:
   - strategy_list
   - autotrade_status
@@ -214,4 +222,8 @@ Keys on this screen:
   `p` — pause new entries
   `f` — flatten (confirm)
   `o` — review chat proposal
+  `J` — journey (ladder)
+  `F` — forward test (paper)
+  `X` — stop forward test
+  `A` — review promotion
   `?` — this help

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/app-help/trade-ledger.md

@@ -49,6 +49,6 @@ sources:
 date: 2026-10-16
 ---
 
-`dexterm ledger trades` lists every round trip dexterm booked, from the paper ticket, the agent paper desk and autotrade runs, newest first: strategy version, the exit profile and entry reason it was opened with (marked * when not declared with the fill), the exit reason, size and % of book, entry and exit market cap, P/L, hold and MFE/MAE. `positions` shows the open ones. `summary` gives the win rate with its 95% interval, P/L, profit factor, drawdown and rug rate by profile, exit reason, strategy, source and mode; `equity` the realized equity curve; `compare` strategy versions side by side (for strategies run in parallel); `export csv|json|parquet-lite [--out FILE]`; `card <tradeId>` a PnL card from a row. Filters: --source, --mode paper|devnet|live, --strategy id[@version], --profile, --exit, --mint, --run, --days, --status. Reads never write; `dexterm ledger sync` appends to ~/.dexterm/ledger/trades.jsonl (sha256-chained) and `dexterm ledger verify` names the first edited line. Agents read the same rows with the read-only ledger_* tools; `trading_status` and `telegram_status` show settings and state, never a key, address, exact balance, bot token or chat id. A backtest an agent asks for (backtest_request) only runs when you run it: `dexterm autotrade requests`. PAPER rows are simulated; filter by --mode before comparing. Not financial advice. Full docs: https://dexterm.xyz/docs/paper-trading/#the-trade-ledger
+`dexterm ledger trades` lists every round trip dexterm booked, from the paper ticket, the agent paper desk and autotrade runs, newest first: strategy version, the exit profile and entry reason it was opened with (marked * when not declared with the fill), the exit reason, size and % of book, entry and exit market cap, P/L, hold and MFE/MAE. `positions` shows the open ones. `summary` gives the win rate with its 95% interval, P/L, profit factor, drawdown and rug rate by profile, exit reason, strategy, source and mode; `equity` the realized equity curve; `compare` strategy versions side by side (for strategies run in parallel); `export csv|json|parquet-lite [--out FILE]`; `card <tradeId>` a PnL card from a row. Filters: --source, --mode paper|devnet|live|real (real = a real-mode run: dexterm's model of the trades it signalled), --strategy id[@version], --profile, --exit, --mint, --run, --days, --status. Reads never write; `dexterm ledger sync` appends to ~/.dexterm/ledger/trades.jsonl (sha256-chained) and `dexterm ledger verify` names the first edited line. Agents read the same rows with the read-only ledger_* tools; `trading_status` and `telegram_status` show settings and state, never a key, address, exact balance, bot token or chat id. A backtest an agent asks for (backtest_request) only runs when you run it: `dexterm autotrade requests`. PAPER rows are simulated; filter by --mode before comparing. Not financial advice. Full docs: https://dexterm.xyz/docs/paper-trading/#the-trade-ledger
 
 CLI: `dexterm ledger`.

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

@@ -42,8 +42,10 @@ Applying checks the proposal again from scratch: if the strategy changed since i
 
 **What the analyst can never change.** The mode (so it can never switch a strategy to live), the book, the daily session budget and the exit-liquidity floor are yours only: a proposal that touches them, directly or by replacing the section around them, is refused before it reaches you. It cannot apply a proposal or skip the second key either. A shipped preset is read-only, so the analyst proposes a copy under a new id instead, always on paper.
 
-**A backtest next to it.** The analyst can backtest a proposal next to the current version on the same window of your recorded history (up to 14 days). That backtest is read-only (nothing is saved), runs one at a time and is rate-limited, and it carries the limits above (https://dexterm.xyz/docs/autotrade#backtests-and-their-limits): read the number of trades before the totals.
+**A backtest next to it.** The analyst can backtest a proposal next to the current version on the same window of your recorded history (up to 14 days). A proposal's backtest saves nothing (a backtest of a strategy itself is recorded as its evidence for the journey (https://dexterm.xyz/docs/build-a-strategy-by-chat)), runs one at a time and is rate-limited, and it carries the limits above (https://dexterm.xyz/docs/autotrade#backtests-and-their-limits): read the number of trades before the totals.
 
 An agent you connect over MCP (`dexterm mcp`) gets the same seven tools under the same rules: `strategy_list`, `strategy_get`, `strategy_validate`, `strategy_propose_edit`, `strategy_propose_new`, `strategy_backtest` and `autotrade_status`. An AI scan (https://dexterm.xyz/docs/scan) session cannot propose at all.
 
+**From a chat to an always-on strategy.** Building a whole strategy by chat, backtesting it with the held-out split, forward-testing it on live data on paper and promoting it one rung at a time (always-on, then real, each applied only by you) has its own page: build a strategy by chat (https://dexterm.xyz/docs/build-a-strategy-by-chat).
+
 Paper only. Not financial advice.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-on-the-q-screen.md

@@ -33,5 +33,6 @@ Press `Q` on any screen for AUTOTRADE, paper only. `tab` moves between its views
 - **Compare**: `c` on two strategies in the list shows them side by side with the fields that differ first, and `b` backtests both on the same window of recorded history.
 - **Backtest**: `b` backtests the selected strategy on the last 14 days of your recorded history and shows the report: trades, win rate with its interval, net, drawdown, the tail numbers, an equity line, results by exit rule, profile and trigger, the size clamps that fired, the refused entries and the limits box. `w` runs a sweep around the default exit profile's own settings with the held-out check described below; its verdict is printed as is. Both run in the background, so the app stays live.
 - **Runner**: a running paper runner's heartbeat, any halt, its candidates, sessions, positions and the last lines of its run file; a runner whose heartbeat is more than 30 seconds old shows as stale. `!` stops it, `p` pauses and resumes new entries, and `f` then `y` flattens it (see Stopping it (https://dexterm.xyz/docs/autotrade#stopping-it)).
+- **Journey**: `J` on a strategy shows its ladder (draft, backtested, forward-tested, always-on, real) with the evidence for each rung, the forward test running or its report next to the backtest, and any promotion waiting for you. `b` backtests it with the held-out split, `F` starts a 24-hour paper forward test on live data and `X` stops it, `A` then `y` applies a pending always-on promotion. Real is never applied from a key (see build a strategy by chat (https://dexterm.xyz/docs/build-a-strategy-by-chat)).
 
 Nothing on this screen can switch a strategy to live, arm a mandate or touch a wallet or a key: the mode is not an editable field, an import is always paper, and a strategy that says live is refused for backtests.

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-running-it-all-day.md

@@ -27,5 +27,5 @@ date: 2026-10-16
 `dexterm autotrade run` is a headless process: start it in a terminal (or a terminal multiplexer such as `tmux`) and it works until you stop it (https://dexterm.xyz/docs/autotrade#stopping-it), `--max-minutes` runs out, or you press Ctrl+C. A two-hour run is measured under What it costs (https://dexterm.xyz/docs/autotrade#what-it-costs-claude-usage-per-session). Screening uses no model at all, so a runner that is only watching costs no Claude usage; usage starts when a coin matches.
 
 - **One runner per machine.** A second `run` is refused while one is working. A lock left by a runner that crashed is taken over once its process is gone.
-- **Each run has its own paper book.** It starts from the strategy's `bankroll`, and a new run starts a fresh one. A run that ends with positions still open says how many on its last line and in its run file; nothing carries them into the next run.
-- **Leave the terminal open.** The runner stops when its terminal session ends, and the computer's sleep pauses it. A background service that starts it with your login and keeps it going is still to come.
+- **Each run has its own paper book.** It starts from the strategy's `bankroll`, and a new run starts a fresh one. A run that ends with positions still open says how many on its last line and in its run file; nothing carries them into the next run (the always-on service (https://dexterm.xyz/docs/autotrade#the-always-on-service) carries them over after a crash).
+- **In a terminal, leave it open.** A runner started by hand stops when its terminal session ends, and the computer's sleep pauses it. The always-on service below starts it with your login instead.

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

@@ -32,4 +32,6 @@ Three switches, from soft to hard. You use them; your agent cannot. A session ha
 
 `p` on the `Q` screen pauses new entries, and `p` again resumes them; open positions keep their exits either way.
 
+Under the always-on service (https://dexterm.xyz/docs/autotrade#the-always-on-service), a stop or flatten from any of these (or `dexterm autotrade service stop`) also keeps the service stopped until `dexterm autotrade service start`; a pause does not stop it.
+
 With several strategies at once (https://dexterm.xyz/docs/autotrade#several-strategies-at-once), these switches act on every strategy, and `--strategy ID` on `stop`, `flatten`, `pause` and `resume` acts on one. An agent you connect over MCP can stop or pause one strategy you listed there, never all of them and never the panic.

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

@@ -0,0 +1,59 @@
+---
+id: docs-autotrade-the-always-on-service
+title: Autotrade (paper) › Running it all day › The always-on service
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: The always-on service
+anchor: the-always-on-service
+url: https://dexterm.xyz/docs/autotrade#the-always-on-service
+tags:
+  - docs
+  - autotrade
+  - always-on
+  - service
+  - running
+  - all
+  - day
+  - 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
+---
+
+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
+dexterm autotrade service status              # running?, guard, crashes, each strategy
+dexterm autotrade service stop                # no new entries now; exits keep running; stays stopped
+dexterm autotrade service start               # start again (lifts a stop)
+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 (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.
+- **A stop stays a stop.** `service stop`, `dexterm autotrade stop`, `!` on the `Q` screen, `/kill` from your Telegram bot, `dexterm wallet panic`, or simply creating the file `~/.dexterm/autotrade/service/STOP`: new entries halt on the next step, open positions keep their exits until they close (`service stop --flatten --yes` sells them), and the service stays stopped until `dexterm autotrade service start`. Logging out or shutting down is not a stop: it starts again at your next login.
+- **The guard.** Every 10 seconds the service checks the machine and the data. These pause new entries until they clear, and never the exits on what you hold:
+
+  | guard | when |
+  |---|---|
+  | disk low | free space under `runner.json` `disk.minFreeGb` (5 GB by default); it lifts 1 GB above that |
+  | load high | the 1-minute load above `load.pauseAboveLoad1m` for `load.sustainSec`; it lifts below `load.resumeBelowLoad1m` |
+  | busy process | a `load.busyProcs` pattern is running (a render, a test suite) |
+  | stale data | no strategy has seen a market tick for 5 minutes |
+
+  It also tells you, without pausing anything, when the usage guard or a day cap holds new sessions back, when a strategy halts itself on its loss limits, when the strategies' heartbeat goes quiet, and when your market history has stopped growing (`dexterm record install` sets that up; the service trades without it, your backtests need it).
+- **Your bot.** When your Telegram bot (https://dexterm.xyz/docs/telegram) is set up, the service runs it: every strategy's alerts, `/status`, `/pause` and `/kill`, plus a message when the service is down, gives up after a crash loop, a guard trips, a strategy halts on its caps, or the data goes stale.
+- **Light on the machine.** It runs at low priority (nice 10, low IO priority), with a 512 MB memory cap (a leak ends in a restart, not a slow machine), and its logs in `~/.dexterm/autotrade/logs/` are capped at a few MB each.

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.