dexterm-cli 0.1.6 → 0.1.7

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

@@ -72,6 +72,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -123,6 +124,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 confidence: high
 owner: maintainers
 origin: app-help-generated
@@ -186,5 +188,6 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `c` — calm mode (effects off)
   `?` — this help

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

@@ -68,6 +68,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -115,6 +116,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 tools:
   - screener_query
 confidence: high
@@ -177,5 +179,6 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `c` — calm mode (effects off)
   `?` — this help

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

@@ -69,6 +69,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -116,6 +117,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 tools:
   - paper_positions
   - paper_pnl
@@ -179,5 +181,6 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `c` — calm mode (effects off)
   `?` — this help

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

@@ -76,6 +76,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -128,6 +129,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 tools:
   - screener_query
 confidence: high
@@ -195,5 +197,6 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `c` — calm mode (effects off)
   `?` — this help

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

@@ -84,6 +84,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -154,6 +155,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 tools:
   - get_dossier
   - get_token
@@ -240,5 +242,6 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `c` — calm mode (effects off)
   `?` — this help

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

@@ -71,6 +71,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -123,6 +124,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 tools:
   - narrative_board
 confidence: high
@@ -188,5 +190,6 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `c` — calm mode (effects off)
   `?` — this help

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

@@ -68,6 +68,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -116,6 +117,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 confidence: high
 owner: maintainers
 origin: app-help-generated
@@ -177,5 +179,6 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `c` — calm mode (effects off)
   `?` — this help

package/dist/packages/mcp/assets/kb/app-help/standing-mandates.md

@@ -28,6 +28,6 @@ sources:
 date: 2026-10-16
 ---
 
-`dexterm mandate list|add|remove|arm|disarm` sets a standing mandate — a longer-lived conditional rule bounded by a budget. As with plans, a model may only PROPOSE; arming needs your physical keypress and the signer-side caps bound it. The analyst can never arm a mandate or change its caps.
+`dexterm mandate list|add|remove|arm|disarm` sets a standing mandate — a longer-lived conditional rule bounded by a budget. As with plans, a model may only PROPOSE; arming needs your physical keypress and its caps bound it; fills are PAPER. The analyst can never arm a mandate or change its caps.
 
 CLI: `dexterm mandate`.

package/dist/packages/mcp/assets/kb/app-help/trade-ledger.md

@@ -0,0 +1,54 @@
+---
+id: trade-ledger
+title: See every trade in one ledger: win rate, profiles, exit reasons, strategy versions (dexterm ledger)
+kind: app-help
+screen: all
+feature: trade-ledger
+tags:
+  - app-help
+  - ledger
+  - journal
+  - trades
+  - history
+  - results
+  - stats
+  - win
+  - rate
+  - drawdown
+  - profile
+  - exit
+  - reason
+  - compare
+  - export
+  - csv
+  - equity
+  - mfe
+  - mae
+commands:
+  - ledger
+tools:
+  - ledger_trades
+  - ledger_positions
+  - ledger_summary
+  - ledger_equity
+  - ledger_compare
+  - candidate_dossier
+  - outcomes_lookup
+  - trading_status
+  - telegram_status
+  - backtest_requests
+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 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
+
+CLI: `dexterm ledger`.

package/dist/packages/mcp/assets/kb/app-help/use-local-model.md

@@ -0,0 +1,38 @@
+---
+id: use-local-model
+title: Run dexterm's AI on a free local model (Ollama)
+kind: app-help
+screen: all
+feature: analyst
+tags:
+  - app-help
+  - ollama
+  - local
+  - model
+  - free
+  - offline
+  - engine
+  - llama
+  - qwen
+  - restrictions
+  - privacy
+commands:
+  - ai
+  - ask
+flags:
+  - --analyst-engine
+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's AI can run on a free model on your own machine through Ollama: no login, no key, $0 per answer, and it talks only to http://127.0.0.1:11434 by default. Set it up in two minutes: install Ollama (https://ollama.com/download), `ollama pull qwen3:8b`, `dexterm ai engine ollama`, `dexterm ai model qwen3:8b`, then `dexterm doctor` (the Ollama line should pass). In the chat box `/engine ollama` switches new conversations, `/engine claude` switches back; `--analyst-engine ollama` and `DEXTERM_ANALYST_ENGINE=ollama` work too, and `dexterm ai engine ollama --surface autotrade` picks one surface. The local engine uses the same dexterm tools and the same firewalled context as Claude. What it may do is your restriction profile: `observe` (analyse only), `propose` (the default for a new setup: UI actions, a PAPER ticket you confirm, strategy proposals you apply), `paper` (adds paper autotrade sessions and agent paper trading in a mandate you armed: `dexterm ai restrictions paper`), `full` (only after `dexterm ai engine ollama --full` and typing ENABLE FULL, for one model). Caps, the kill switch, mandate tiers, live gating and Telegram buttons are enforced outside the model for every engine. `dexterm ai probe --json` checks tool calling, context and decision formatting; a model without tools answers from the dossier dexterm fetches and says so. Paper autotrade on it: `dexterm autotrade run <strategy> --paper --engine ollama`. Headless: `dexterm ask "question"`, `dexterm ai agent "goal"`. Docs: https://dexterm.xyz/docs/ollama/
+
+CLI: `dexterm ai`, `dexterm ask`.

package/dist/packages/mcp/assets/kb/docs/docs-agents-agent-paper-trading.md

@@ -32,13 +32,16 @@ Two steps, both yours:
 1. Draft and arm a mandate (`dexterm mandate draft` / `arm`, or the plans screen). Its caps are per-trade, per-coin and total size, a loss limit, open positions, price impact, allowed sides and an optional mint allow-list, and arming needs a physical keypress. For bigger simulated sizes, draft a **paper-only** mandate with `dexterm mandate draft --paper` (see paper-only mandates (https://dexterm.xyz/docs/paper-trading#paper-only-mandates)): only the agent paper desk can use it.
 2. Start the terminal with the agent activity view and name that mandate: `dexterm --spectate-mcp --agent-paper <mandate-id>`. Quitting turns it off again.
 
-While it is on, the agent can use six tools:
+While it is on, the agent can use seven tools:
 
 - `paper_open_ticket` opens a simulated ticket for a mint and side. It stays inert until confirmed.
 - `paper_size_ticket` sets the simulated size. A buy over any cap is **refused**, never clamped up.
 - `paper_confirm` re-checks the caps and your controls, fetches a fresh keyless quote and books the simulated fill.
 - `paper_close` closes a fraction of a held simulated position. If the keyless quote for that close is rate-limited, the desk waits briefly and asks for a fresh quote by itself (up to 4 tries in about 25 seconds, each retry shown in the agent activity) and books the fill on that later quote, never on an old one.
 - `paper_positions` and `paper_pnl` read the simulated positions and PnL. They are read-only.
+- `paper_tag` records a declaration apart from a fill: a REPROFILE while it holds a coin, or a PROFILE / EXIT it did not pass with the fill (marked as declared late). It books nothing.
+
+`paper_confirm` takes the exit profile and the entry reason (`profile`, `reason`) and `paper_close` the exit reason (`exit_reason`, `reason`) as typed fields, or the verbatim PROFILE / EXIT line in `tag_line`. They go to the trade ledger (https://dexterm.xyz/docs/paper-trading#the-trade-ledger) with the fill, so your results can be read by profile and by exit reason.
 
 The guarantees, each covered by tests:
 

package/dist/packages/mcp/assets/kb/docs/docs-agents-reading-your-trade-ledger.md

@@ -0,0 +1,31 @@
+---
+id: docs-agents-reading-your-trade-ledger
+title: Bring your own agent › Reading your trade ledger
+kind: docs
+page: agents
+page_title: Bring your own agent
+heading: Reading your trade ledger
+anchor: reading-your-trade-ledger
+url: https://dexterm.xyz/docs/agents#reading-your-trade-ledger
+tags:
+  - docs
+  - agents
+  - reading
+  - trade
+  - ledger
+  - bring
+  - own
+  - agent
+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/agents.md
+date: 2026-10-16
+---
+
+Any connected agent can read the trade ledger (https://dexterm.xyz/docs/paper-trading#the-trade-ledger) with the same read-only tools as the rest of the data: `ledger_trades`, `ledger_positions`, `ledger_summary`, `ledger_equity` and `ledger_compare`, plus `candidate_dossier` (what an autotrade run saw and decided about one coin) and `outcomes_lookup` (what a coin, or every candidate of a run, turned into). `trading_status` and `telegram_status` describe your live signer and your Telegram bot: settings and state only, never a key, a seed, an address, an exact balance, a bot token or a chat id.
+
+`backtest_request` lets an agent ask for a longer backtest than `strategy_backtest` runs. It only files the request: you see it with `dexterm autotrade requests` and run or dismiss it yourself, and the agent reads the one-line result with `backtest_requests`.

package/dist/packages/mcp/assets/kb/docs/docs-agents-untrusted-by-default.md

@@ -31,6 +31,6 @@ Every agent is treated as potentially compromised or buggy:
 - **The gate.** One function every call passes on every transport: session open, name not on the never-list, tier sufficient, inside any mandate, arguments valid against a **closed** schema and within a size cap, rate limits and quotas with room, and an idempotency key on every proposal.
 - **Rate, quota and flood control.** Reads/min, navigation/10s and proposals/hour are per agent; sustained refusals trip a breaker that auto-pauses the agent.
 - **Prompt firewall.** Every untrusted string an agent receives (token names, bios, tweets, fetched page text) is wrapped and sanitised; terminal-escape, bidi-override and zero-width characters are stripped from every result, event and audit line.
-- **Proposals, never actions.** An order-plan proposal is a draft with `armed: false`, full stop; only your physical keypress arms it, and the signer-side caps still apply.
+- **Proposals, never actions.** An order-plan proposal is a draft with `armed: false`, full stop; only your physical keypress arms it, and it fills on paper.
 - **Roster + audit.** The roster popup lists every connected agent (name, tier, last activity, reads/proposals, rate usage) with per-agent **pause** and **kick**, and the full audit log records every connect, call, refusal, proposal and disconnect.
 - **Watching adds no power.** The spectator view (https://dexterm.xyz/docs/spectator) only observes calls the gate already allowed or refused; its stream has no inbound command path and its window can send only pause, resume, take over and kill.

package/dist/packages/mcp/assets/kb/docs/docs-analyst-if-claude-is-missing.md

@@ -22,4 +22,4 @@ sources:
 date: 2026-10-16
 ---
 
-The panel shows a one-line fix (`npm i -g @anthropic-ai/claude-code && claude login`) and the rest of dexterm keeps working. `dexterm doctor` reports the Claude CLI line as a warning, not a failure. With Codex installed, `auto` runs the analyst on Codex instead.
+The panel says to set up an AI backend, with both ways in one line (`npm i -g @anthropic-ai/claude-code && claude login`, or a free local model with Ollama), and the rest of dexterm keeps working. `dexterm doctor` reports the Claude CLI line as a warning, not a failure. With Codex installed, `auto` runs the analyst on Codex instead; with neither but a local model (https://dexterm.xyz/docs/ollama) set up, on the local model.

package/dist/packages/mcp/assets/kb/docs/docs-analyst-use-a-local-model-instead.md

@@ -0,0 +1,27 @@
+---
+id: docs-analyst-use-a-local-model-instead
+title: The analyst › Use a local model instead
+kind: docs
+page: analyst
+page_title: The analyst
+heading: Use a local model instead
+anchor: use-a-local-model-instead
+url: https://dexterm.xyz/docs/analyst#use-a-local-model-instead
+tags:
+  - docs
+  - analyst
+  - use
+  - local
+  - model
+  - instead
+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/analyst.md
+date: 2026-10-16
+---
+
+The analyst can also run on **a free model on your own machine** through Ollama: no login, no key, $0 per answer, and with the default host (`127.0.0.1`) nothing leaves the machine. `dexterm ai engine ollama`, `--analyst-engine ollama` or `/engine ollama` in the chat box. Same tools, same firewalled context, same skills; what the local engine may do is set by a restriction profile you choose. See Use a local model with Ollama (https://dexterm.xyz/docs/ollama).

package/dist/packages/mcp/assets/kb/docs/docs-analyst-what-it-sees.md

@@ -23,4 +23,6 @@ date: 2026-10-16
 
 Every turn carries a firewalled **CONTEXT** block: the screen you are on, the filter and sort, the selected or hovered coin, the visible rows (price, change, liquidity, volume), your watchlist, and any open PAPER ticket or position. So "this coin", "it" and "the highlighted one" resolve without asking. Token names, descriptions, socials, RugCheck text and fetched page text are wrapped as `<untrusted>` data before the model sees them; instruction-like text inside such a block is itself reported as a red flag (`injection_detected`) and never followed.
 
+**It talks in market cap.** By default the analyst speaks the way traders do: the cap at entry and the cap now, targets and stops as market-cap levels, moves as x-multiples ("in at $69.7K, now $264.9K, 3.8x"); its live snapshot leads with the market cap and reads the price history as caps at the current supply. With the price display mode (https://dexterm.xyz/docs/configuration#price-display-mode) set to price (`$` or `/display price`) it switches to USD price on the next turn. A coin without a known supply is discussed in price, and it says so.
+
 Facts come only from tools. The system prompt forbids token facts from model memory: every number, address, flag and level must come from a tool result in the session, each carrying its source and age. The knowledge base explains mechanics and patterns; it never holds a fact about a live token.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-backtests-and-their-limits.md

@@ -0,0 +1,56 @@
+---
+id: docs-autotrade-backtests-and-their-limits
+title: Autotrade (paper) › Backtests and their limits
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Backtests and their limits
+anchor: backtests-and-their-limits
+url: https://dexterm.xyz/docs/autotrade#backtests-and-their-limits
+tags:
+  - docs
+  - autotrade
+  - backtests
+  - their
+  - limits
+  - 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 autotrade backtest my-swing               # over your recorder history (read-only)
+dexterm autotrade backtest moonbag --every-candidate --recall 5,10
+dexterm autotrade sweep scalp                    # tune on older coins, check on the newest ones
+dexterm backtest --subject strategy --strategy swing
+```
+
+A backtest replays the strategy over the history the recorder (https://dexterm.xyz/docs/data-sources) saved on your machine, with the same entry rules, clamp and exit logic a run would use, and mechanical entries (no agent). It never touches the network or a model. The report gives the trades, wins and losses with a 95% interval on the win rate, the net, the drawdown on marked equity, how many bags could not be sold, and which exit rule, profile and trigger each result came from. Below 20 trades it says to read the counts, not the rates.
+
+For strategies that live on a rare tail, like moonbag, it also prints:
+
+- the **tail**: trades that ended at -80% or worse or could not be sold, how many took their cost back, the net without the single best trade, the result per dollar staked with a bootstrap 95% interval, and the exit-multiple median, 90th percentile and maximum;
+- `--every-candidate`: every candidate entered at a fixed $20 with the book's caps lifted, so each entry is an independent sample and the result does not depend on which coins arrived first;
+- `--recall 5,10`: of the coins that later ran 5x or 10x, how many the entry rules passed, which rule refused the others, and how each entered one was closed.
+
+**The held-out check.** `sweep` tries a grid of parameters (for example the trail width or the first take-profit). It splits the coins by when they were first seen: the newest 30% are held out, and no coin is in both halves. It tunes on the older coins only, then checks the held-out coins exactly twice, with the unchanged strategy and with the tuned one. It only reports a gain when both halves have at least 20 trades **and** the tuned strategy makes money on the held-out coins. A tuned strategy that only loses less is reported as exactly that.
+
+**Finer history for the coins that matter.** The recorder's snapshots are written on moves of about 5% at the screen's refresh pace, which hides the path a stop or a take-profit lives on. Run the headless recorder with `dexterm record run --focus-ticks` and it also samples the coins you hold on paper or have open every 5 seconds, and your watchlist and autotrade candidates every 10 seconds, with 1-minute candles built from those samples. A backtest reads those samples in time order next to the snapshots, so for those coins a stop fills at the next 5- or 10-second sample instead of the next snapshot. The slower fields (24-hour volume, holders, top-10 share, authorities) come from the coin's latest earlier snapshot, never a later one. Samples are kept 14 days and candles 90 days. With `--retention-mb N` the recorder removes the oldest history to stay under N MB instead of pausing; what is kept and for how long is in recorded history (https://dexterm.xyz/docs/data-sources#recorded-history-and-retention).
+
+**On the history recorded so far, every preset lost money when entered mechanically.** The engine is a way to test your own rules honestly, not a source of profitable ones, and a backtest is not a forecast.
+
+The limits are printed with every report:
+
+- **Coarse prices.** Most of the history is recorder snapshots (written on moves of about 5% or every 30 minutes while a coin was listed), not trades, so stops and take-profits fill at the next recorded price. Coins sampled with `--focus-ticks` are finer (5 to 10 seconds), but a move between two samples is still invisible, and their candles' highs and lows are of the samples, not of every trade.
+- **Modelled fills.** Price impact on the recorded pool, plus fee, slippage and network fee; not real quotes.
+- **Survivorship.** Only coins the app recorded are in the history; coins nobody saw are absent.
+- **Rugs.** A bag below the exit-liquidity floor cannot be sold and counts as zero, and a rug between two snapshots fills at whatever the next snapshot says.
+- **Early entries look later than they are.** A young pair enters the history only once a feed lists it, and pairs that rugged before any feed saw them are missing, so the measured rug rate is a floor.
+- **Missing signals.** Narrative, followed-wallet, social and dev-sell signals are not in the history, so those triggers and exits never fire in a backtest.
+- **No agent.** A backtest has no agent latency and no agent judgement; agent backtests cost Claude usage and stay small.

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

@@ -0,0 +1,49 @@
+---
+id: docs-autotrade-change-a-strategy-by-chat
+title: Autotrade (paper) › Change a strategy by chat
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Change a strategy by chat
+anchor: change-a-strategy-by-chat
+url: https://dexterm.xyz/docs/autotrade#change-a-strategy-by-chat
+tags:
+  - docs
+  - autotrade
+  - change
+  - strategy
+  - chat
+  - 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
+---
+
+Ask the analyst (`a`) to change one of your strategies in plain words, for example "make my swing exit faster" or "fewer entries a day on my copy of moonbag". The analyst can read your strategies and backtest them, but it can only **propose** a change: nothing it says changes a file.
+
+A proposal is a small set of field changes (at most 20) with a one-line reason. Before you see it, dexterm applies it to a copy, validates the result like any strategy, and compares every risk number with the current version:
+
+- **TIGHTER**: at least one risk number got safer and none got less safe.
+- **NEUTRAL**: nothing that moves risk changed (a name, a description, a take-profit step).
+- **LOOSER**: at least one risk number got less safe: a bigger size or exposure, a higher loss limit, a stop or a trail removed or widened, a safety gate removed, a screen clause dropped, more or costlier agent sessions, or a cheaper fill model.
+
+The proposal shows up as a card on the `Q` screen under PROPOSALS FROM CHAT. `o` opens the newest one (the selected strategy's first) with every changed field, old and new, who proposed it and why:
+
+- `y` applies a tighter or neutral proposal as a new version of the strategy. The change journal records the proposal's id, who proposed it, the change and the content hash before and after.
+- A LOOSER proposal needs two keys: the first `y` opens the "less safe" popup that lists every field getting looser, and only a second `y` applies it. Any other key cancels.
+- `n` dismisses the proposal; `esc` closes the card and keeps it for later.
+
+Applying checks the proposal again from scratch: if the strategy changed since it was made, it is refused (dismiss it and ask again), and the tighter or looser verdict is worked out again rather than taken from the card.
+
+**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.
+
+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.
+
+Paper only. Not financial advice.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-checking-the-record-of-a-run.md

@@ -0,0 +1,28 @@
+---
+id: docs-autotrade-checking-the-record-of-a-run
+title: Autotrade (paper) › Stopping it › Checking the record of a run
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Checking the record of a run
+anchor: checking-the-record-of-a-run
+url: https://dexterm.xyz/docs/autotrade#checking-the-record-of-a-run
+tags:
+  - docs
+  - autotrade
+  - checking
+  - record
+  - run
+  - stopping
+  - 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 autotrade audit` lists your runs. `dexterm autotrade audit --verify` (all runs, `--last`, or one run id) recomputes each run file's hash chain and checks it against the run's summary, so an edited, missing, reordered or cut-off line is named by its event number. It exits with code 1 when a run does not verify.

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

@@ -0,0 +1,41 @@
+---
+id: docs-autotrade-comparing-them
+title: Autotrade (paper) › Several strategies at once › Comparing them
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Comparing them
+anchor: comparing-them
+url: https://dexterm.xyz/docs/autotrade#comparing-them
+tags:
+  - docs
+  - autotrade
+  - comparing
+  - them
+  - 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 autotrade status --all` (and the Q screen's runner view while a parallel run works) shows one row per strategy:
+
+| Column | What it counts |
+|---|---|
+| ACCOUNT | the paper account it trades from (shown when any strategy uses one) |
+| P/L, P/L % | the strategy's paper book against its own bankroll; on a paper account, its own trades against the account's balance |
+| WIN, CLOSED | the share of closed trades that made money, next to how many closed |
+| OPEN | positions it holds now |
+| RUGS, RUG EXP | exits caused by a rug or a liquidity pull, and the share of the money it put in that went into those coins |
+| MISSED | coins it saw as candidates, did not enter, that later traded at 2x or more of the price it saw |
+| SPEND, $/ENTRY | its model spend, and that spend per entry |
+
+Below the table: one row per paper account (start, equity, cash, P/L, open positions and the strategies on it), the strategies together with each account counted once, and the shared limits in use today. `--json` gives the same numbers for a script. Read the closed-trade counts before the percentages: a few hours of paper trading is not evidence that one strategy is better.

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

@@ -0,0 +1,76 @@
+---
+id: docs-autotrade-exits-and-wakes
+title: Autotrade (paper) › Exits and wakes
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Exits and wakes
+anchor: exits-and-wakes
+url: https://dexterm.xyz/docs/autotrade#exits-and-wakes
+tags:
+  - docs
+  - autotrade
+  - exits
+  - wakes
+  - 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
+---
+
+Exits never wait for your agent. On every tick of a coin you hold, a position monitor runs your exit profile's mechanical rules at once, in this order, and a full exit ends that tick:
+
+1. **Rug or liquidity pull**: the pool is under the strategy's `execution.minExitLiquidityUsd`. A bag that cannot be sold is marked stuck and tried again on every tick.
+2. **Thesis breaks**: liquidity down by the profile's percent from its recent high, a market-cap source split (the two sources count supplies more than 5× apart; a price move alone never counts, even when one source's figure is minutes old), or dead volume. (The dev-sell exit needs on-chain sell events, which are not recorded yet, so it does not fire.)
+3. **Maximum hold** (`maxHoldMinutes`): the position's own dead-man.
+4. **Hard stop**, when the profile has one.
+5. **Cost recovery** (moonbag): once, at the profile's gain (+100% in moonbag), sell the slice whose proceeds pay back what the position cost, at most `maxSellFrac` of the bag (60% in moonbag). What is left is a free bag.
+6. **The take-profit ladder**: several steps can fill on one jump.
+7. **The bag trail** (moonbag): only after the cost came back, measured from the peak since entry (55% in moonbag).
+8. **The trailing stop.**
+9. **The time stop**, when its action is `exit`.
+10. **Scale-in tranches** (`sizing.ladder`), each re-capped by your strategy.
+
+**Wakes.** Only after those rules ran does the position's session hear anything, and everything from one tick goes out as one message:
+
+```
+EVENT tp_filled: TP1 filled at +62.0%; 67% of the original size left
+position p1: profile swing, cost $20.00, +62.0% on the mid price, TP filled 1, 67% of the size left, liq $100K
+Reply with one of: hold, exit, tighten, reprofile.
+```
+
+| event | when | your agent may answer | no answer, or no session |
+|---|---|---|---|
+| `tp_filled` | a take-profit step filled (when the profile asks for it) | hold, exit, tighten, reprofile | hold |
+| `cost_recovered` | the cost-recovery sell filled (moonbag) | hold, exit, tighten | hold |
+| `time_review` / `time_tighten` | the profile's clock ran out below its target | hold, exit, tighten | the profile's `wake.noAnswer` (swing: exit, runner: hold) |
+| `drawdown` | the position fell to the profile's `wake.drawdownPct` | hold, exit, tighten | hold |
+| `thesis_warning` | liquidity fell part of the way to a thesis exit | hold, exit, tighten | hold |
+| `mechanical_exit` | after any mechanical exit (for information) | hold | — |
+| `stuck` | a sell could not execute | hold | tried again every tick |
+
+**What an answer can do.** Your agent can only lower the risk:
+
+- `exit` sells everything, and `exit` with a `fraction` trims.
+- `tighten` arms the trailing stop now; on a free bag it halves the bag trail (never below 10%), and nothing can loosen it again.
+- `reprofile` moves only along the profile's `reprofileTo` edges, and a move to a profile that allows a bigger size needs the first take-profit filled.
+- It can never add size: an `enter` or a size on a held coin is refused and written down.
+- It can never stop or delay a mechanical exit: the next tick's rules run whether a reply is pending or not. A reply that lands after its position closed, or after `agent.decideWithinSec`, is written down and never executed.
+
+**On the paper desk.** When the monitor runs as its own process, its orders go through the same paper desk (https://dexterm.xyz/docs/agents#agent-paper-trading) that agents use, so every fence there applies around your strategy's own clamp:
+
+- A paper-only mandate you armed yourself with a keypress (`dexterm mandate draft --paper`). Its caps apply at the agent tier (a quarter of the per-trade cap), and an entry is refused without one.
+- Each entry registers an exit plan with the desk, and each monitor sell is journaled as `agent.paper.exit.<rule>` (for example `agent.paper.exit.cost-recovery` or `agent.paper.exit.bag-trail`). Every fill carries a short note naming the run, the position, the profile and the exit rule.
+- A cost-recovery slice is sized on at most three Jupiter quotes (one for the largest allowed slice, one to confirm the estimate, at most one correction); without a quote it waits for the next tick instead of guessing.
+- A `close-only` control state lets exits run while every new buy is refused, also after the mandate has expired. `dexterm wallet panic` stops everything, exits included.
+
+**Restarts and the dead-man.** The monitor rebuilds its positions from the paper journal and the run files. An exit that was journaled but had not filled when it stopped is never sent again; the next tick decides afresh. Paper positions it did not open are left alone. It writes `~/.dexterm/autotrade/monitor-status.json` every 10 seconds, and entries are refused when that is more than 30 seconds old. It keeps exiting while the runner is down, but it adds no scale-in tranche then.
+
+**Today's limits.** The monitor and the desk changes are in the app, but `dexterm autotrade run` does not use them yet. Until it does, these same rules run in the same order on the engine's own paper book, the one backtests use.
+
+Paper only: the monitor refuses a strategy in live mode, and nothing in it can arm a mandate, sign, or touch a wallet or a key.