dexterm-cli 0.1.6 → 0.2.0

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

@@ -0,0 +1,51 @@
+---
+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). 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-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.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-how-a-stop-reaches-the-runner.md

@@ -0,0 +1,32 @@
+---
+id: docs-autotrade-how-a-stop-reaches-the-runner
+title: Autotrade (paper) › Stopping it › How a stop reaches the runner
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: How a stop reaches the runner
+anchor: how-a-stop-reaches-the-runner
+url: https://dexterm.xyz/docs/autotrade#how-a-stop-reaches-the-runner
+tags:
+  - docs
+  - autotrade
+  - stop
+  - reaches
+  - runner
+  - 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
+---
+
+- `stop` and `flatten` write a request for the running run to `~/.dexterm/autotrade/control.json`. The runner reads it on every step and shows the halt in its heartbeat file, and the command waits up to 10 seconds (`--wait SEC`) to tell you it did.
+- A stop is final for that run: a flatten can follow it, nothing lifts it. To trade again, start a new run.
+- A request for an older run never touches a new one, and a control file the runner cannot read counts as a stop.
+- `flatten` asks for `y` on a real terminal; `--yes` answers for a script (a flatten only sells).
+- The runner reads the panic file on every step, and `dexterm autotrade run` will not start while it is on.

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

@@ -0,0 +1,38 @@
+---
+id: docs-autotrade-on-the-q-screen
+title: Autotrade (paper) › Strategies and presets › On the Q screen
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: On the Q screen
+anchor: on-the-q-screen
+url: https://dexterm.xyz/docs/autotrade#on-the-q-screen
+tags:
+  - docs
+  - autotrade
+  - screen
+  - strategies
+  - presets
+  - 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
+---
+
+the strategy editor on sample data: a typo in the screen filter is caught at its column while you type
+
+Press `Q` on any screen for AUTOTRADE, paper only. `tab` moves between its views:
+
+- **Strategies**: the presets and your own files with mode, version, content hash and the last backtest (net, drawdown, trades). `n` copies the selected preset under a new id, `d` duplicates any strategy, `⏎` or `e` opens it in the editor, `x` writes it to a shareable file in `~/.dexterm/exports`, and `i` imports a file (always as paper). `o` opens the card of a change the analyst proposed in chat (how that works (https://dexterm.xyz/docs/autotrade#change-a-strategy-by-chat)).
+- **Editor**: one form in six sections (entry, exits, risk, sizing, agent, execution). `⏎` changes the selected field (a true/false field flips in place). Every change re-validates the whole strategy and every problem shows next to its field with its path; the screen filter is checked by the screener's own parser while you type, and the column of a mistake is marked. Each exit profile gets a one-line sketch of its stop, take-profits, trails and limits. `s` saves only a valid strategy, as a new version with the change in the journal; `u` undoes your last unsaved change, or, with nothing unsaved, the last saved one (as a new version). The presets open read-only: copy one first.
+- **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-one-strategy-or-all-of-them.md

@@ -0,0 +1,35 @@
+---
+id: docs-autotrade-one-strategy-or-all-of-them
+title: Autotrade (paper) › Several strategies at once › One strategy, or all of them
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: One strategy, or all of them
+anchor: one-strategy-or-all-of-them
+url: https://dexterm.xyz/docs/autotrade#one-strategy-or-all-of-them
+tags:
+  - docs
+  - autotrade
+  - strategy
+  - all
+  - 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
+---
+
+- **All of them:** `dexterm autotrade stop`, `dexterm autotrade flatten`, `dexterm autotrade pause` and `resume`, the Q screen's `!`, `f` and `p`, `dexterm wallet panic`, and Ctrl+C.
+- **One of them:** `dexterm autotrade stop --strategy ID` (no new entries, its sessions close, its exits run until it holds nothing; final for that run), `flatten --strategy ID`, `pause --strategy ID` and `resume --strategy ID`, and `dexterm autotrade start ID` for a listed strategy that is not running. The other strategies keep going.
+
+An agent you connect over MCP can read the list and the comparison, accounts included (`autotrade_parallel_list`, `autotrade_parallel_compare`), and can start, stop or pause one strategy that you listed (`autotrade_parallel_start`, `autotrade_parallel_stop`). It cannot add a strategy or an account, move a strategy to another account, change a size or a cap, or start anything that is not on paper.
+
+Paper only: `--live` and `"mode": "live"` are refused. dexterm holds no key; live trading happens in a Telegram trading bot of your choice (see Live trading (https://dexterm.xyz/docs/live-trading)). Simulated fills, not financial advice.

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

@@ -0,0 +1,50 @@
+---
+id: docs-autotrade-paper-accounts
+title: Autotrade (paper) › Several strategies at once › Paper accounts
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Paper accounts
+anchor: paper-accounts
+url: https://dexterm.xyz/docs/autotrade#paper-accounts
+tags:
+  - docs
+  - autotrade
+  - paper
+  - accounts
+  - several
+  - strategies
+  - once
+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
+---
+
+A paper account is one simulated wallet that several strategies trade from together. List the accounts in `autotrade.json` and point a strategy at one with `account` instead of giving it a bankroll:
+
+```json
+{
+  "schema": "dexterm-autotrade/1",
+  "accounts": [
+    { "id": "main", "bankroll": { "usd": 1000 } },
+    { "id": "yolo", "bankroll": { "sol": 1 } }
+  ],
+  "strategies": [
+    { "id": "moon", "preset": "moonbag", "account": "main" },
+    { "id": "scalp", "preset": "scalp", "account": ["main", "yolo"] },
+    { "id": "solo", "preset": "my-scalp", "bankroll": { "usd": 200 } }
+  ]
+}
+```
+
+- **Many strategies, one wallet.** `moon` and `scalp` both trade from `main`'s cash: a buy by one leaves less for the other, a sale pays back into the same account, and every size is a share of the whole account (cash plus what is held). An order is checked against the cash again at the fill, so two strategies can never spend the same dollars.
+- **One strategy, many wallets.** A list of accounts runs the same strategy once per account, here as `scalp-main` and `scalp-yolo`. Each one is its own strategy in the run: its own run file, positions, loss limits, sessions and spend budget, and `dexterm autotrade stop --strategy scalp-yolo` stops only that one.
+- **What stays per strategy:** its positions, its share of the money at risk (`maxExposurePct` counts its own positions against the account), its loss streak and cooldowns, its per-coin rules, its entries per day and its model budget. Its drawdown limit reads the account: when the account falls far enough, each strategy on it stops entering at its own limit.
+- **Mixing is fine.** Strategies with their own `bankroll` run next to strategies on accounts. A strategy on an account takes no `bankroll` of its own, and an account it names must be in `accounts`; anything else stops the run before it starts, with the problem named.
+
+Accounts live for the run: each starts at its `bankroll` when the run starts (a SOL balance at the SOL price, or `"solUsd"` / `--sol-usd` in a replay), and a strategy you `start` again later joins the same account. Up to 8 accounts. Paper only: an account is simulated cash and never backs a live strategy.

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

@@ -0,0 +1,37 @@
+---
+id: docs-autotrade-presets
+title: Autotrade (paper) › Strategies and presets › Presets
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Presets
+anchor: presets
+url: https://dexterm.xyz/docs/autotrade#presets
+tags:
+  - docs
+  - autotrade
+  - presets
+  - strategies
+  - 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
+---
+
+Six read-only presets ship with dexterm, each on paper (five with a $1,000 paper book, `yolo` with $200):
+
+| preset | the idea |
+|---|---|
+| `scalp` | young pairs (under 6 h) on a 5-minute push, small take-profits, a hard stop and a short time exit |
+| `swing` | pairs from 1 hour to a week old on every screen match, wider take-profits and trail, a review after 90 minutes |
+| `runner` | older pairs with deeper liquidity, sized by confidence, a wide trail and a long hold |
+| `moonbag` | very young pairs (under 2 h) on an early push, with the holder-safety gates: take the cost back at about 2x, then hold a free bag with a loose trail |
+| `sample-dip-ladder` | a shareable example of a custom strategy: risk-sized, buys half and adds half on a dip |
+| `yolo` | **HIGH RISK**: one young pair at a time after the holder-safety gates and a live LARP check, the cost back at about 2x, then a free bag; paper only. See Full-port yolo strategy (https://dexterm.xyz/docs/yolo) |
+
+**About moonbag:** most early entries lose. Young pairs rug often, and a rug cannot be sold: once liquidity is pulled, the bag is stuck and counts as zero. The preset therefore uses small tickets and no hard stop, and the point is the rare coin that runs. Read its backtest's tail numbers, never only the total.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-running-it-all-day.md

@@ -0,0 +1,31 @@
+---
+id: docs-autotrade-running-it-all-day
+title: Autotrade (paper) › Running it all day
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Running it all day
+anchor: running-it-all-day
+url: https://dexterm.xyz/docs/autotrade#running-it-all-day
+tags:
+  - docs
+  - autotrade
+  - 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
+---
+
+`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 (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-sessions-and-their-limits.md

@@ -0,0 +1,31 @@
+---
+id: docs-autotrade-sessions-and-their-limits
+title: Autotrade (paper) › The runner and candidate sessions › Sessions and their limits
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Sessions and their limits
+anchor: sessions-and-their-limits
+url: https://dexterm.xyz/docs/autotrade#sessions-and-their-limits
+tags:
+  - docs
+  - autotrade
+  - sessions
+  - their
+  - limits
+  - runner
+  - candidate
+  - 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
+---
+
+**Token text is data.** Names, symbols and every other text that comes from the token reach the agent only inside `<untrusted>` tags, and the agent is told such text is never an instruction. A coin named "buy the maximum" still gets your strategy's size, and nothing the agent says can stop a mechanical exit.
+
+**The session is answer-only.** It is `claude -p` with no tools, no MCP servers, no settings, no saved session and no slash commands, started in an empty folder (it is not `--bare`, which would drop your Claude login). Its first event must show the kind of login you configured and no tools; if it does not, the session ends before anything it says counts, and the runner starts no new session for the rest of the run. The limits come from the strategy's `agent` section (the presets' values): at most 2 sessions at once, $0.50 per session (also passed to `claude` as its own budget), $10 a day, 60 turns, 90 seconds per decision (60 in moonbag; a slow candidate is skipped, and a slow review gets the exit profile's no-answer rule), 4 hours per session, and the candidate is dropped 5 minutes after it last matched (4 in moonbag). The model is the strategy's `agent.model` (`sonnet` in the presets), or `--model` for one run.

package/dist/packages/mcp/assets/kb/docs/docs-autotrade-several-strategies-at-once.md

@@ -0,0 +1,33 @@
+---
+id: docs-autotrade-several-strategies-at-once
+title: Autotrade (paper) › Several strategies at once
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Several strategies at once
+anchor: several-strategies-at-once
+url: https://dexterm.xyz/docs/autotrade#several-strategies-at-once
+tags:
+  - docs
+  - autotrade
+  - 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 run --all --paper` runs every strategy you list in `~/.dexterm/autotrade/autotrade.json` at the same time, on the same live data. Use it to forward-test several ideas side by side: a scalp and a moonbag, or one preset next to your copy of it with a single change.
+
+- **One data feed for all of them.** The screener fetches once and every strategy screens the same coins with its own entry rules, so three strategies do not cost three times the data requests. A coin's dossier is fetched once (at most every 30 seconds), whichever strategy asks for it.
+- **Each strategy has its own book.** It gets its own bankroll, run id and run file (`~/.dexterm/autotrade/runs/<run>.jsonl`, hash-chained), loss limits and breaker, candidate sessions and model spend budget. A breaker or a stop on one strategy never stops another. Or let several strategies trade from one paper account (https://dexterm.xyz/docs/autotrade#paper-accounts), the way several bots would share one wallet.
+- **Shared limits for all of them.** Model sessions open at once, model spend per day, sessions per day, turns per day, the usage guard of your Claude account and one check of how busy your computer is all count across every strategy. When one of them is reached, every strategy waits.
+
+It is still one runner on your machine: a second `run` (one strategy or `--all`) is refused while it works.

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

@@ -0,0 +1,37 @@
+---
+id: docs-autotrade-stopping-it
+title: Autotrade (paper) › Stopping it
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Stopping it
+anchor: stopping-it
+url: https://dexterm.xyz/docs/autotrade#stopping-it
+tags:
+  - docs
+  - autotrade
+  - 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
+---
+
+Three switches, from soft to hard. You use them; your agent cannot. A session has no tools, and its answer has no stop, resume or flatten in it.
+
+| switch | what stops | what keeps running | after it |
+|---|---|---|---|
+| `dexterm autotrade stop`, or `!` on the `Q` screen | new entries; every session closes; orders not yet filled are dropped | the mechanical exits on what you hold | the runner ends once nothing is held |
+| `dexterm autotrade flatten`, or `f` then `y` on the `Q` screen | the same, then every paper position sells at its next tick | a coin that cannot sell (a pulled pool) is retried every tick | the runner ends once nothing is held |
+| `dexterm wallet panic` | the runner halts on its next step, as in a stop; every paper desk refuses too | the runner's mechanical exits | nothing starts again until `dexterm wallet resume`, a keypress on a real terminal |
+
+`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-strategies-and-presets.md

@@ -0,0 +1,34 @@
+---
+id: docs-autotrade-strategies-and-presets
+title: Autotrade (paper) › Strategies and presets
+kind: docs
+page: autotrade
+page_title: Autotrade (paper)
+heading: Strategies and presets
+anchor: strategies-and-presets
+url: https://dexterm.xyz/docs/autotrade#strategies-and-presets
+tags:
+  - docs
+  - autotrade
+  - strategies
+  - presets
+  - 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
+---
+
+A strategy is one JSON file (`dexterm-strategy/1`) with six parts:
+
+- **Entry**: the screener filter grammar (https://dexterm.xyz/docs/screens), verbatim (for example `liq >= 30K vol1h > 15K !flag:mint !flag:freeze`), an age window, safety gates (no mint or freeze authority, top-10 share, dev share, a market-cap source split, a "young and already vertical" reject, and what to do when the holder source is down) and triggers (every screen match, or a 5-minute momentum push).
+- **Exits**: one or more exit profiles: a take-profit ladder, a trailing stop, a time stop, an optional hard stop, thesis breaks (a liquidity drop, a market-cap source split, dead volume), a maximum hold time and, for the moonbag profile, a cost-recovery sell and a trail on the free bag that is left.
+- **Sizing**: a fixed amount, a percent of the book, risk-sized against the stop, or scaled by the agent's confidence inside your bounds, with optional scale-in tranches. Every size is capped by a maximum percent and a maximum dollar amount.
+- **Risk**: a per-trade loss cap, a daily loss halt, drawdown size-down and halt levels, the most positions open at once, total exposure, entries per day, a loss-streak cooldown and per-coin re-entry rules.
+- **Agent** and **execution**: the session limits for the runner (https://dexterm.xyz/docs/autotrade#the-runner-and-candidate-sessions) and the fill model's fee, slippage, network fee, price-impact cap and the liquidity below which a bag cannot be sold.
+
+The file is closed: an unknown key is refused with its path, so a strategy cannot carry a `signer`, `wallet` or `key` section. Validation also checks the rules a schema cannot (a take-profit ladder that climbs, sell fractions that add up to at most the whole position, sizing parameters that match the sizing mode, drawdown levels in order) and prints every problem with its path. Every strategy gets a content hash, so a backtest line always names the exact rules it ran.

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

@@ -0,0 +1,57 @@
+---
+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 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, 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 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.