dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/cli/src/app-help-gen.js

@@ -99,6 +99,8 @@ const SCREENS = [
         blurb: 'What is trending in the space — narratives and movers aggregated from the feed.' },
     { screen: 'kol', title: 'The KOL lists screen', feature: 'kol-lists', tools: [],
         blurb: 'Key-opinion-leader wallet lists and their activity (official/authorized sources only).' },
+    { screen: 'autotrade', title: 'The autotrade (paper) screen', feature: 'autotrade-strategies', tools: ['strategy_list', 'autotrade_status'],
+        blurb: 'Press `Q` anywhere for AUTOTRADE, paper only. tab cycles five views: STRATEGIES (the presets and your own files with mode, version, hash and the last backtest), EDITOR (one form in six sections: entry, exits, risk, sizing, agent, execution; every change re-validates, errors show inline with their path, the screen filter is checked by the screener\'s own parser and its error column is marked; `s` saves only a valid draft as a new version, `u` undoes), COMPARE (two marked strategies side by side, changed fields first, both backtested on the same tape), BACKTEST (the report with attribution, an equity sparkline, clamps, refusals and the limits box; `w` runs a sweep whose verdict comes from coins it never tuned on) and RUNNER (the paper runner\'s heartbeat, halt reason, candidates, sessions, positions and ledger tail). Presets are read-only: `d` makes your own copy. Nothing on this screen switches a strategy to live, arms a mandate or touches a wallet. A strategy edit the analyst proposed in chat shows as a card: `o` opens its diff, `y` applies it, and a LOOSER edit (any risk number less safe) needs a second `y` on the less-safe popup.' },
 ];
 /** The screen keys that get an overview entry (for the drift test's forward key-coverage check). */
 export const SCREENS_DOCUMENTED = SCREENS.map((s) => s.screen);
@@ -158,21 +160,24 @@ const TOPICS = [
     { id: 'open-chart-popup', title: 'Open the chart popup', screen: 'token', tags: ['chart', 'popup', 'candles', 'window', 'dock', 'graph'],
         actions: [{ action: 'popup.chart', screen: 'token' }], feature: 'popup-chart',
         body: 'Press `C` on the token screen to open the docked chart popup (a native window, or your browser as fallback). It is fed only by the terminal\'s caches over one loopback WebSocket and never sees your keys. The analyst can open or close it for you.' },
+    { id: 'chart-trade-markers', title: 'See your buys and sells on the chart (B / S markers)', screen: 'token', tags: ['markers', 'marker', 'buy', 'sell', 'bought', 'sold', 'fills', 'fill', 'entry', 'exit', 'trades', 'chart', 'avg', 'average', 'paper', 'live', 'arrows'],
+        commands: ['display'], feature: 'chart-trade-markers',
+        body: 'Every fill of the open coin from your paper ledger (your own and an agent\'s PAPER trades) and the live ledger (confirmed real swaps) is marked on the token screen\'s chart and the chart popup, on every timeframe: `B` for a buy and `S` for a sell, at the fill\'s time and price. Hollow `△ ▽` = PAPER, solid `▲ ▼` = live, so it reads without colour too. Each partial sell gets its own marker (several in one bar show a count), a dashed `avg` line marks the average entry while the position is open, and a closed round trip gets a faint wash from entry to exit. A fill outside the candles on screen is not moved: the chart says how many are off-chart. In the popup, hover a marker for its time, price, size and ledger; `k` or the **MARKERS** button turns them off or on for both charts (saved as `display.chartMarkers`; also `dexterm display markers on|off`). Display only: no marker can arm, size, sign or confirm anything, and nothing is fetched to draw them.' },
     { id: 'switch-theme', title: 'Switch the theme', screen: 'all', tags: ['theme', 'themes', 'colour', 'colours', 'color', 'colors', 'look', 'cyberspace', 'midnight', 'ember', 'paper'],
         actions: [{ action: 'theme.next' }], commands: ['theme'], flags: ['--theme'], feature: 'themes-keymaps',
         body: 'Press `t` to cycle themes (cyberspace → midnight → ember → paper). `dexterm theme list|show|init|check` manages your own themes in `~/.dexterm/themes/`; a shared theme cannot hide a warning or swap buy/sell colours (a contrast + hue guard). The analyst can propose a theme change you confirm with a keypress.' },
     { id: 'calm-mode', title: 'Turn on calm mode (effects off)', screen: 'all', tags: ['calm', 'effects', 'rain', 'glitch', 'quiet', 'still', 'intensity'],
         flags: ['--calm', '--intensity'], feature: 'look',
         body: 'Press `c` to toggle calm mode: rain, glitch, blink and scanlines off, back to the last intensity when pressed again. Start calm with `--calm` (or `DEXTERM_CALM=1`); `--intensity normal|fever|off` picks a tier. The analyst can toggle calm for you.' },
-    { id: 'price-or-marketcap', title: 'Show price or market cap', screen: 'all', tags: ['price', 'mcap', 'marketcap', 'market', 'display', 'usd', 'cap'],
-        actions: [{ action: 'display.priceMode' }], commands: ['display'], flags: ['--price-mode'], feature: 'price-display-mode',
-        body: 'Press `$` to flip every price between USD price and MARKET CAP (screener, watchlist, new pairs, token, both charts, order-plan levels). Saved as `display.priceMode`; also `dexterm display price|mcap` or `--price-mode`. A coin with no known supply stays on price and says so. The analyst can set this for you.' },
+    { id: 'price-or-marketcap', title: 'Market cap or price (market cap is the default)', screen: 'all', tags: ['price', 'mcap', 'marketcap', 'market', 'display', 'usd', 'cap', 'basis'],
+        actions: [{ action: 'display.priceMode' }], commands: ['display'], flags: ['--price-mode', '--price', '--mcap'], feature: 'price-display-mode',
+        body: 'Market cap is the default basis: every screen, the CLI text, the chat assistant and the autotrade agents show and talk about a coin in market cap (entered at $69.7K, exited at $264.9K, 3.8x). Press `$` (or type `/display price` in the chat box, `/display mcap` to go back) to switch to USD price and back. Saved as `display.priceMode`; also `dexterm display mcap|price`. For one run: `--price` / `--mcap` on any command, `--price-mode`, or `DEXTERM_PRICE_BASIS=price`. Market cap = price × a known supply (the source\'s cap ÷ price, recorded FDV ÷ price, or pump.fun\'s 1B); a coin with no known supply shows its price marked ᵖ and says so. JSON keeps both `price` and `mcap`. The charts have their own axis setting (`A`). The analyst can propose this for you.' },
     { id: 'scan-mode', title: 'Use AI scan mode', screen: 'all', tags: ['scan', 'watcher', 'observe', 'auto', 'ai', 'monitor'],
         actions: [{ action: 'scan.toggle' }, { action: 'scan.resume' }], flags: ['--scan'], feature: 'scan',
-        body: 'Scan mode is an observe-only AI watcher (off by default, zero extra requests). Toggle it with `Z` (or `/scan on|off` on the screener line, or `--scan` at launch); `R` resumes a paused scan. It can only surface findings, never take a UI action or trade (structurally observe-only). The analyst can turn it on or off for you.' },
-    { id: 'larp-check', title: 'Run the LARP check (is the product real?)', screen: 'token', tags: ['larp', 'fake', 'real', 'legit', 'website', 'product', 'domain', 'github', 'vet'],
-        tools: ['larp_check', 'get_links', 'fetch_page', 'check_domain', 'check_github'], feature: 'larp-check',
-        body: 'The LARP check vets whether a real product exists (website, domain age, GitHub) read-only — it is not a price call. Ask the analyst "is <coin> a larp?" (skill `larp-check`), or an agent can call the `larp_check` MCP tool. A grade is a risk flag, never a certificate; it never recommends buy/sell.' },
+        body: 'Scan mode is an observe-only AI watcher (off by default, zero extra requests). Toggle it with `Z` (or `/scan on|off` on the screener line, or `--scan` at launch); `R` resumes a paused scan. It can only surface findings, never take a UI action or trade (structurally observe-only). While it is on, the token screen\'s analyst panel shows its brain view: the scan log (locks, refreshes, releases, blocked actions) with the read streaming under it, the vetting checklist and the data strip. While it runs and you hold a paper or live position, a PnL chip shows it on the band under the header of every screen and on the chart popup; display only. The analyst can turn it on or off for you.' },
+    { id: 'larp-check', title: 'Run the LARP check (is the product real?)', screen: 'token', tags: ['larp', 'fake', 'real', 'legit', 'website', 'product', 'domain', 'github', 'vet', 'score', 'x', 'twitter'],
+        tools: ['larp_check', 'get_links', 'fetch_page', 'check_domain', 'check_github', 'check_x'], feature: 'larp-check',
+        body: 'The LARP check vets whether a real product exists (website, domain age, GitHub, the X account) read-only — it is not a price call. Ask the analyst "is <coin> a larp?" (skill `larp-check`), or an agent can call the `larp_check` MCP tool. It returns a 0-100 LARP score: the sum of named flags with their points (low under 25, medium 25-49, high 50+), plus a list of what could not be read, which widens the range instead of lowering the score. A score is a summary of flags, never a certificate; it never recommends buy/sell.' },
     { id: 'rug-check', title: 'Check if a coin is a rug', screen: 'token', tags: ['rug', 'safe', 'honeypot', 'scam', 'risk', 'check', 'authority', 'mint'],
         actions: [{ action: 'analyst.toggle' }], tools: ['analyze_token', 'get_dossier', 'rugcheck'], feature: 'analyst',
         body: 'Press `a` to run a rug-check on the selected coin: authorities, token program, LP, holder concentration, creator history and tape, with a p(rug) from the H1 heuristic (a ranking, not a calibrated probability). The verdict is WATCH / SPECULATIVE / AVOID. Facts come only from tools; it is not financial advice.' },
@@ -186,9 +191,12 @@ const TOPICS = [
     { id: 'use-codex-analyst', title: 'Run the analyst on Codex instead of Claude', screen: 'all', tags: ['codex', 'openai', 'chatgpt', 'engine', 'analyst', 'claude', 'switch', 'backend'],
         flags: ['--analyst-engine'], feature: 'analyst',
         body: 'The analyst can run on your own Codex CLI login instead of Claude (0.1.5). Pick it with `--analyst-engine codex`, `DEXTERM_ANALYST_ENGINE=codex`, `"analyst": {"engine": "codex"}` in `~/.dexterm/config.json`, or type `/engine codex` in the chat box (new conversations; `/engine` alone shows the engine and what is installed). The default `auto` uses claude when it is installed, else codex. dexterm stores no credentials: your `codex login` does the work. The Codex run is locked read-only: only the read-only dexterm tools (plus the UI actions the session allows, none in scan mode), no shell, no file edits, no web search, no other MCP server; a turn that tries anything else is stopped. `dexterm doctor` shows a Codex CLI line (installed, version, logged in). Codex is also supported as an MCP client: `dexterm mcp install codex`.' },
+    { id: 'use-local-model', title: 'Run dexterm\'s AI on a free local model (Ollama)', screen: 'all', tags: ['ollama', 'local', 'model', 'free', 'offline', 'engine', 'llama', 'qwen', 'restrictions', 'privacy'],
+        commands: ['ai', 'ask'], flags: ['--analyst-engine'], feature: 'analyst',
+        body: '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/' },
     { id: 'dev-history', title: 'Check if a coin\'s creator rugged before (dev history)', screen: 'token', tags: ['dev', 'deployer', 'creator', 'serial', 'rugger', 'rugged', 'history', 'launches'],
         tools: ['dev_history', 'get_dev_history'], feature: 'token-intel',
-        body: 'The token screen\'s ON-CHAIN panel shows the creator\'s recorded track record (0.1.5): `Dev rugs (recorded)` (rugs out of labelled prior launches, with the sample n), `Dev launches seen`, `Dev sold its bag` (median minutes to the dev\'s exit) and `Dev linked` (funder or cluster from the wallet-intel scan). It comes from dexterm\'s own local history recorder (keyless creator links + code-only outcome labels), so it says `unknown` when there is no record; it is a risk flag from observed history, never a certificate. Alert on it with the rule field `devrugs`, e.g. `when devrugs >= 2 then alert(warn, "new coin from a wallet that rugged before") scope newpairs`. Agents and the analyst use the `dev_history` MCP tool.' },
+        body: 'The token screen\'s ON-CHAIN panel shows the creator\'s recorded track record (0.1.5): `Dev rugs` (rugs out of labelled prior launches, e.g. `2/3 · n=3 · rec 7d`), `Dev launches` (`n=3 · rec 2h · dev:jup`: which feed named the creator), `Dev sold bag` (median minutes to the dev\'s exit, `med 20m · n=3 · rec 1d`), `Dev linked` (funder or cluster from the wallet-intel scan, with the scan\'s age) and `Linked dev rugs` (rugs by other wallets in that cluster). Every value names its source (`rec` = the recorder, `scan` = the wallet-intel scan), its sample (n=) and the age of its newest datum. It comes from dexterm\'s own local history recorder (keyless creator links + code-only outcome labels), so it says `unknown` when there is no record; it is a risk flag from observed history, never a certificate. Alert on it with the rule field `devrugs`, e.g. `when devrugs >= 2 then alert(warn, "new coin from a wallet that rugged before") scope newpairs`. Agents and the analyst use the `dev_history` MCP tool.' },
     { id: 'configure-rpc-key', title: 'Configure a Helius / RPC key for holders', screen: 'all', tags: ['helius', 'rpc', 'key', 'holders', 'free', 'api', 'ranked'],
         feature: 'keyless',
         body: 'dexterm is free-forever and keyless by default. The one real keyless gap is the ranked top-holder list: add a free RPC key for it. Save a Helius key ONLY at `~/.dexterm/helius.key` (mode 600, never a repo or command line), or set `DEXTERM_RPC_URL` to any read-only RPC. `dexterm doctor` prints the exact command. Without a key the holders panel shows count + top-10% via Jupiter.' },
@@ -216,6 +224,34 @@ const TOPICS = [
     { id: 'backtest', title: 'Backtest the rug model or skills', screen: 'all', tags: ['backtest', 'eval', 'accuracy', 'model', 'metrics', 'history'],
         commands: ['backtest'], tools: ['rug_backtest'], feature: 'skill-backtest',
         body: '`dexterm backtest --subject heuristic|skills|larp|pack_verdicts` scores a subject against the recorder\'s outcome-labelled history and prints honest metrics (precision/recall, Brier vs base rate, AUC, calibration) with leakage checks. With no labelled outcomes it says so and prints no metrics rather than fabricating any.' },
+    { id: 'autotrade-strategies', title: 'Autotrade strategies on paper (dexterm autotrade)', screen: 'all', tags: ['autotrade', 'strategy', 'strategies', 'preset', 'presets', 'moonbag', 'scalp', 'swing', 'sweep', 'held-out'],
+        commands: ['autotrade'], feature: 'autotrade-strategies',
+        body: '`dexterm autotrade list|validate|new|import|remove|journal` manages strategy files in ~/.dexterm/strategies (one validated JSON file each, every change in an append-only journal); the presets scalp, swing, runner, moonbag, sample-dip-ladder and yolo (HIGH RISK, see the yolo entry) are read-only, copy one with `dexterm autotrade new <id> --from <preset>`. `dexterm autotrade backtest <id>` replays a strategy over your recorded history with modelled fills and always prints the limits of the data (`--every-candidate`, `--recall 5,10` for tail strategies); `dexterm autotrade sweep <id>` tunes on older coins and checks once on the newest 30% it never saw, with no gain wording unless both halves have 20+ trades and the held-out net is positive. Paper only: a strategy cannot hold a key, wallet or signer section, and a copy in mode live does not run (dexterm holds no key and places no live order). Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/' },
+    { id: 'autotrade-runner', title: 'The autotrade paper runner and candidate sessions (dexterm autotrade run)', screen: 'all', tags: ['autotrade', 'runner', 'run', 'candidate', 'session', 'sessions', 'agent', 'replay', 'ledger', 'runner.json'],
+        commands: ['autotrade'], feature: 'autotrade-runner',
+        body: '`dexterm autotrade run <id|file> --paper` runs one strategy on paper, headless, one runner per machine: the screener feeds it the same live data as the app (every 10 s, candidate and held coins every 5 s), and each coin that matches gets one session on your own Claude login with the full picture first, then only what changed. Your agent answers with a typed decision (enter, wait, skip, hold, exit, tighten, reprofile); every size is clamped by your strategy and the exits run on their own. At most 2 sessions at once, $0.50 per session and the day caps in ~/.dexterm/autotrade/runner.json (which Claude account, sessions and spend per day, a usage guard). Every step goes to ~/.dexterm/autotrade/runs/<run>.jsonl, hash-chained. `--replay FILE` paces a recorded tape instead of live data; `--stub` uses a scripted agent with no Claude cost. Paper only: a run never signs or touches a wallet, and there is no `--live` (dexterm holds no key and places no live order). Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#the-runner-and-candidate-sessions' },
+    { id: 'live-trading', title: 'Live trading: dexterm holds no key; a Telegram trading bot of your choice trades', screen: 'all', tags: ['live', 'trading', 'real', 'money', 'telegram', 'bot', 'key', 'wallet', 'custody', 'signer', 'mainnet'],
+        commands: ['telegram', 'wallet', 'live'], feature: 'live-trading',
+        body: '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/' },
+    { id: 'live-yolo', title: 'The full-port yolo strategy on paper: replay and a paper run (HIGH RISK)', screen: 'all', tags: ['yolo', 'full', 'port', 'all-in', 'high', 'risk', 'preset', 'replay', 'paper'],
+        commands: ['autotrade'], feature: 'yolo-preset',
+        body: 'HIGH RISK, PAPER only; not financial advice. The `yolo` preset enters one young pair at a time on an early 5-minute push after the holder-safety gates (LP burned or locked, no mint or freeze authority, a LARP score of 49 or less checked live before a coin becomes a candidate, liquidity of $25K or more), takes the cost back at about 2x, lets the rest ride on a loose 50% trail, exits at once on a liquidity pull, a dev sell or dead volume, has a -50% stop and a 45-minute time stop, and never buys the same coin twice. On paper it caps an entry at 25% like every strategy. `dexterm autotrade yolo-replay yolo` measures every entry at full port over your recorded history (rugs, the loss spread, how often it zeroed the wallet); `dexterm autotrade run yolo --paper` runs it on paper (`--replay builtin:yolo-rehearsal --stub` for a short fixture run; next to other strategies, or on a shared paper account, through `autotrade.json` and `dexterm autotrade run --all --paper`). Stop: `dexterm autotrade stop`, /kill in Telegram, Ctrl-C. dexterm places no live order. Full docs: https://dexterm.xyz/docs/yolo/' },
+    { id: 'autotrade-stop', title: 'Stop, flatten or audit the autotrade paper runner (dexterm autotrade stop|flatten|audit)', screen: 'all', tags: ['autotrade', 'stop', 'kill', 'halt', 'flatten', 'sell', 'pause', 'panic', 'audit', 'verify', 'ledger', 'resume'],
+        commands: ['autotrade'], feature: 'autotrade-runner',
+        body: '`dexterm autotrade stop` is a soft stop of the paper runner: no new entries, every session closed, pending orders dropped, and the mechanical exits (stops, take-profits, trails, rug exits) keep running until nothing is held; then the runner ends. `dexterm autotrade flatten` stops it and sells every paper position at its next tick (a coin that cannot sell is retried every tick); it asks for y on a real terminal, or takes --yes. On the AUTOTRADE screen (`Q`): `!` stops, `p` pauses or resumes new entries, `f` then y flattens. A stop is final for that run. `dexterm wallet panic` is the harder switch: the runner reads it every step, a new run will not start while it is on, and only `dexterm wallet resume` on a real terminal lifts it. `dexterm autotrade audit --verify` recomputes the hash chain of every run file in ~/.dexterm/autotrade/runs/ and names the first edited, missing or reordered line. Paper only; your agent cannot stop, resume or flatten anything. Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#stopping-it' },
+    { id: 'autotrade-parallel', title: 'Run several autotrade strategies at once on paper (dexterm autotrade run --all)', screen: 'all', tags: ['autotrade', 'parallel', 'several', 'multiple', 'strategies', 'compare', 'side', 'forward', 'test', 'bankroll', 'fleet', 'autotrade.json'],
+        commands: ['autotrade'], tools: ['autotrade_parallel_list', 'autotrade_parallel_compare', 'autotrade_parallel_start', 'autotrade_parallel_stop'], feature: 'autotrade-parallel',
+        body: '`dexterm autotrade run --all --paper` runs every strategy listed in ~/.dexterm/autotrade/autotrade.json at the same time on one data feed, to forward-test several ideas side by side. Each entry has an `id`, a `preset` (a shipped preset or your own strategy) or an absolute `file`, a `bankroll` in USD or SOL, optional `caps` that can only tighten it, and `enabled`. Each strategy gets its own paper book, run file, loss limits and breaker, sessions and model spend budget; a breaker or a stop on one never stops another. The screener fetches once for all of them, and the `global` limits (sessions open at once, model spend and sessions per day, one check of how busy the computer is) count across all of them. `dexterm autotrade status --all` and the runner view on the AUTOTRADE screen (`Q`) compare them: P/L, win rate with the closed count, rug exits and exposure, missed runners, spend per entry. `dexterm autotrade stop|flatten|pause|resume` act on every strategy; add `--strategy ID` to act on one, and `dexterm autotrade start ID` starts a listed one that is not running. An MCP agent can list and compare them and start or stop one listed strategy, never add one or change a size or a cap. Paper only: live is refused. Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#several-strategies-at-once' },
+    { id: 'autotrade-telegram', title: 'Your own Telegram bot for the autotrade runner: notify, control, one-tap approvals (dexterm telegram)', screen: 'all', tags: ['telegram', 'bot', 'phone', 'mobile', 'notify', 'notifications', 'approve', 'approval', 'approvals', 'pair', 'pairing', 'kill', 'pause', 'remote', 'botfather'],
+        commands: ['telegram'], feature: 'autotrade-telegram',
+        body: 'Create a bot with @BotFather, then run `dexterm telegram setup`: paste the token at the hidden prompt (never as an argument), dexterm checks it and keeps it in your keychain (or the system keyring, or a 0600 file), then shows a 6-digit code; send `/pair <code>` to your bot from your own private chat and confirm the account it shows (@username and id) with `y` on your computer. Pairing is refused while a webhook or another program polls the bot. Only that account in that chat is answered. `dexterm autotrade run <id> --paper` then starts the bot by itself (`--no-telegram` keeps it off): entries, exits, PnL cards, halts and a daily summary reach your phone; `/status`, `/positions`, `/pause`, `/resume` (a pause only), `/kill`, `/flatten` and `/use` (each after a confirm button, `/use` only to an equal-or-tighter strategy; a change it cannot rank counts as looser) and `/approvals on` work from chat, which can make things safer and never less safe. With `entry.decide: "agent+approve"` or approvals on, every entry is a card with [Approve] [Half size] [Skip]: only a button approves, once, for that proposal, your account and your private chat; the price and your limits are checked again at the tap; no answer is a skip. Typed messages are never trades. `dexterm telegram status|test|audit --verify|revoke`. Nothing is hosted; paper only; never send keys or seed phrases in chat. Not financial advice. Full docs: https://dexterm.xyz/docs/telegram/' },
+    { id: 'autotrade-chat', title: 'Change an autotrade strategy by chat (paper)', screen: 'autotrade', tags: ['autotrade', 'strategy', 'chat', 'analyst', 'proposal', 'tune', 'change', 'diff', 'looser', 'less', 'safe'],
+        actions: [{ action: 'analyst.toggle' }, { action: 'autotrade.proposal', screen: 'autotrade' }],
+        tools: ['strategy_list', 'strategy_get', 'strategy_validate', 'strategy_propose_edit', 'strategy_propose_new', 'strategy_backtest', 'autotrade_status'], feature: 'autotrade-chat',
+        body: 'Ask the analyst to change one of your strategies ("make my swing exit faster"). It can only PROPOSE: the change arrives as a card on the AUTOTRADE screen (`Q`) with the field lines that change, the validation result and TIGHTER, NEUTRAL or LOOSER. `o` opens the card, `y` applies it as a new version (journaled with who proposed it), `n` dismisses it. When any risk number gets less safe (bigger size or exposure, more loss, a stop or safety gate removed) the edit is LOOSER and needs a second `y` on the less-safe popup. The mode, the book, the daily session budget and the exit-liquidity floor are yours only: the analyst cannot change them. It can backtest a proposal next to the current version on your recorded history (up to 14 days, read-only). Paper only.' },
+    { id: 'trade-ledger', title: 'See every trade in one ledger: win rate, profiles, exit reasons, strategy versions (dexterm ledger)', screen: 'all', tags: ['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'], feature: 'trade-ledger',
+        body: '`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' },
     { id: 'coin-images', title: 'Turn coin images on or off', screen: 'all', tags: ['images', 'image', 'pictures', 'icons', 'logos', 'off'],
         flags: ['--no-images'], feature: 'coin-images',
         body: 'Coin pictures render as real pixels in image-capable terminals (kitty/iTerm2/sixel) and as block art everywhere else. Turn them off with `--no-images` (or `DEXTERM_IMAGES=0`, or `enabled:false` in `~/.dexterm/images.json`). `dexterm doctor` has a Coin images line that says which path you get.' },
@@ -233,8 +269,8 @@ const TOPICS = [
         commands: ['agent'], feature: 'mcp',
         body: '`dexterm agent add|list|rotate|remove|tier|pause|resume|kick|audit|packs` manages your bring-your-own-agent registry and the loopback bus; `dexterm agent serve` runs a standalone bus on fixtures and `connect` attaches one. Every agent is untrusted and read-only: it can never sign, arm, raise a cap, touch keys or change network settings.' },
     { id: 'spectate-an-agent', title: 'Watch an agent drive dexterm (dexterm spectate)', screen: 'all', tags: ['spectate', 'spectator', 'watch', 'agent', 'cook', 'observe', 'replay', 'stream', 'record', 'mcp', 'follow'],
-        commands: ['spectate'], flags: ['--replay', '--spectate-mcp'], feature: 'spectator',
-        body: 'Watch an agent work. For an agent on the loopback bus, `dexterm agent serve --spectator-popup` opens the AGENT ACTIVITY window, `--spectate` starts the read-only, token-gated, loopback stream, and `--record FILE` saves a redacted session. For an agent connected over MCP (`dexterm mcp install`), run the app with `dexterm --spectate-mcp`: the running terminal then follows the agent — a navigation call moves the screen, a status line shows `agent <name>: opened <coin>`, ctrl+p pauses, ctrl+k stops and any key you press takes control. `dexterm spectate --replay FILE` replays a saved session step by step and `dexterm spectate --info` shows the live stream endpoint. Every shared copy is redacted — a tool name, refusal, agent line or navigation can never leak a wallet or key — and a spectator can only watch, never act. Full docs: https://dexterm.xyz/docs/spectator/' },
+        commands: ['spectate'], flags: ['--replay', '--spectate-mcp', '--spectate-thoughts'], feature: 'spectator',
+        body: 'Watch an agent work. For an agent on the loopback bus, `dexterm agent serve --spectator-popup` opens the AGENT ACTIVITY window, `--spectate` starts the read-only, token-gated, loopback stream, and `--record FILE` saves a redacted session. For an agent connected over MCP (`dexterm mcp install`), run the app with `dexterm --spectate-mcp`: the running terminal follows the agent and an agent dock appears under the screen — a phase rail (SCANNING > VETTING > SIZING > EXECUTING > HOLDING > EXITING) with a heartbeat, the call timeline with result chips, the rows it scans glow and a cursor marks the coin it opens, a vetting card fills its checks and LARP evidence, and a PAPER trade shows its ticket, the fill, a live position with the mark PnL and a result card. `--spectate-thoughts FILE` streams the agent\'s own words into a thought ribbon from a JSONL file it writes (for example `claude -p --output-format stream-json`); display only. PAPER is always on screen; ctrl+p pauses, ctrl+k kills (a hard stop) and any key you press takes control; calm mode drops the motion. While the agent is active, the token screen\'s analyst panel is its BRAIN VIEW: the reasoning stream with phase tags (or dexterm\'s narration when there is no thoughts feed), the vetting checklist with the app\'s numbers and pass/warn/fail/pending, a data strip, the PAPER plan and position, and the session\'s decision log with a simulated scoreboard. While it holds a PAPER position, a PnL chip shows coin, PnL, entry to mark, peak, drawdown, time held and the take-profit it said, on every terminal screen (in the dock, or on the band under the header on terminals under 24 rows) and on the chart popup; display only. `dexterm spectate --replay FILE` replays a saved session step by step and `dexterm spectate --info` shows the live stream endpoint. Every shared copy is redacted — a tool name, refusal, agent line or navigation can never leak a wallet or key — and a spectator can only watch, never act. Full docs: https://dexterm.xyz/docs/spectator/' },
     { id: 'recorder-history', title: 'Work with the history recorder (dexterm recorder)', screen: 'all', tags: ['recorder', 'record', 'history', 'stats', 'label', 'prune', 'outcomes', 'database', 'session', 'capture', 'data'],
         commands: ['recorder'], flags: ['--record', '--no-recorder'], feature: 'recorder',
         body: '`dexterm recorder stats|label|prune|export` works with the local history recorder\'s tables (the outcome-labelled data the rug model and backtests learn from). No network. Recording is on by default; `--no-recorder` disables it for a run and `--record FILE` captures a data session to a file for replay.' },
@@ -259,15 +295,15 @@ const TOPICS = [
     { id: 'share-packs', title: 'Share or install packs (dexterm pack)', screen: 'all', tags: ['pack', 'packs', 'share', 'install', 'export', 'sign', 'trust', 'lock', 'bundle'],
         commands: ['pack'], feature: 'packs',
         body: '`dexterm pack list|verify|add|remove|export|lock|sign|trust|signers|keymap|widget` shares themes, keymaps, rules and widgets as plain files with a sha256 lock and an optional ssh signature. A pack never runs code: widgets land disabled, unsigned rules load disabled, and a keymap merges only on the explicit command.' },
-    { id: 'link-a-wallet', title: 'Link a wallet for trading (dexterm wallet)', screen: 'all', tags: ['wallet', 'link', 'unlink', 'phantom', 'connect', 'pubkey', 'caps', 'trade'],
-        commands: ['wallet'], flags: ['--mainnet', '--max-usd', '--daily-usd', '--max-sol-out', '--max-slippage-bps', '--trade-rpc', '--no-live'], feature: 'trading',
-        body: '`dexterm wallet link|unlink|status` links a Phantom wallet through a loopback bridge — your keys NEVER enter dexterm, only the public key is stored — and shows the link and the signer-side trade caps. dexterm is non-custodial: it builds and simulates transactions, your own wallet signs. The signer-side caps (`--max-usd`, `--daily-usd`, `--max-sol-out`, `--max-slippage-bps`) and the RPC (`--trade-rpc`) bound every trade and live on the signer; `--mainnet` opts in to mainnet and `--no-live` keeps it paper-only. The analyst can never link, unlink, sign, arm or change a cap.' },
+    { id: 'link-a-wallet', title: 'Link a wallet to show its public key (dexterm wallet)', screen: 'all', tags: ['wallet', 'link', 'unlink', 'phantom', 'connect', 'pubkey', 'panic', 'resume'],
+        commands: ['wallet'], flags: ['--no-live'], feature: 'trading',
+        body: '`dexterm wallet link|unlink|status` links a Phantom wallet through a loopback bridge (Phantom signs a MESSAGE, never a transaction): your keys NEVER enter dexterm, only the public key is stored, for display. dexterm holds no key and never signs or sends a transaction; trading in dexterm is paper, and live trading happens in the Telegram trading bot of your choice. `dexterm wallet panic` halts autotrade runs and the paper agent desk at once; only `dexterm wallet resume`, a keypress on a real terminal, clears it. `--no-live` (0.1.6) is accepted and changes nothing. The analyst can never link, unlink or resume.' },
     { id: 'order-plans', title: 'Set conditional order plans (dexterm plan)', screen: 'all', tags: ['plan', 'plans', 'order', 'conditional', 'take-profit', 'stop', 'trigger', 'arm'],
         commands: ['plan'], feature: 'order-plans',
-        body: '`dexterm plan list|add|remove|arm|disarm` sets conditional order plans (e.g. take-profit / stop levels). Voice and agents can only PROPOSE a plan; ARMING one needs your physical keypress, and the caps and panic-stop stay signer-side. Nothing here lets a model sign or raise a cap.' },
+        body: '`dexterm plan list|add|remove|arm|disarm` sets conditional order plans (e.g. take-profit / stop levels). Voice and agents can only PROPOSE a plan; ARMING one needs your physical keypress, and plans fill on PAPER (dexterm places no live order). Nothing here lets a model sign or raise a cap.' },
     { id: 'standing-mandates', title: 'Set a standing mandate (dexterm mandate)', screen: 'all', tags: ['mandate', 'mandates', 'standing', 'rule', 'budget', 'auto', 'arm', 'cap'],
         commands: ['mandate'], feature: 'order-plans',
-        body: '`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.' },
+        body: '`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.' },
     { id: 'follow-a-wallet', title: 'Copy / follow a wallet (dexterm follow)', screen: 'all', tags: ['follow', 'copy', 'mirror', 'wallet', 'trader', 'track', 'unfollow', 'list'],
         commands: ['follow'], feature: 'copy-trading',
         body: '`dexterm follow list|add|remove` is the copy-trading follow list: local, self-directed and read-only. When a followed wallet trades, dexterm can surface a one-key MIRROR TICKET you confirm yourself — it never auto-trades, never signs, and the analyst can never add a follow or confirm a mirror.' },

package/dist/packages/cli/src/autotrade-cmd/audit.js

@@ -0,0 +1,57 @@
+// `dexterm autotrade audit [<run>|--last] [--verify]` (task-1509 AT-7, AUTOTRADE-SPEC §6.4). PAPER ONLY. Read-only.
+//
+// Lists the run ledgers under $DEXTERM_HOME/autotrade/runs/, and with --verify recomputes each hash chain (every line's
+// hash covers the previous hash and its own content) and checks it against the run's summary, so an edited, added,
+// dropped, reordered or cut-off line is named with its event number. Exit 1 when any checked run is broken.
+import { dextermHome } from '../../../custom/src/index.js';
+import { auditRun, listRunIds } from '../../../autotrade/src/index.js';
+import { parseArgs } from "./strategies.js";
+export const AUDIT_USAGE = 'dexterm autotrade audit [<run-id>|--last] [--verify] [--json]';
+function line(a, verify) {
+    const strat = a.strategy ? `${a.strategy.id} v${a.strategy.version}` : '?';
+    const state = a.running ? 'running' : a.ended ? 'ended' : 'no run_end (crashed or cut short)';
+    if (!verify)
+        return `  ${a.runId}  ${strat}  ${a.events} events  ${state}`;
+    if (a.ok)
+        return `✓ ${a.runId}  ${strat}  ${a.events} events  head ${a.head}  ${state}${a.summary ? '' : '  (no summary)'}`;
+    return `✗ ${a.runId}  ${strat}  broken at event ${a.brokenAt}: ${a.error}`;
+}
+export async function auditCmd(argv, io) {
+    const { pos, opts } = parseArgs(argv, ['verify', 'json', 'last']);
+    if (pos.length > 1) {
+        io.stderr.write(`usage: ${AUDIT_USAGE}\n`);
+        return 2;
+    }
+    const home = dextermHome(io.env);
+    const all = listRunIds(home);
+    let ids = all;
+    if (pos[0]) {
+        const want = pos[0].replace(/\.jsonl$/, '');
+        if (!all.includes(want)) {
+            io.stderr.write(`dexterm autotrade audit: no run ledger ${JSON.stringify(want)} under autotrade/runs/\n`);
+            return 1;
+        }
+        ids = [want];
+    }
+    else if (opts.last)
+        ids = all.slice(-1);
+    const verify = !!opts.verify;
+    const audits = ids.map((id) => auditRun(home, id));
+    const broken = verify ? audits.filter((a) => !a.ok) : [];
+    if (opts.json) {
+        io.stdout.write(`${JSON.stringify({ verified: verify, runs: audits, broken: broken.length }, null, 2)}\n`);
+        return broken.length ? 1 : 0;
+    }
+    if (!audits.length) {
+        io.stdout.write('no autotrade runs yet (ledgers live in autotrade/runs/ under your dexterm home)\n');
+        return 0;
+    }
+    io.stdout.write(`${verify ? 'verifying' : 'runs'} (${audits.length}) · ledgers in autotrade/runs/ · paper and live runs\n`);
+    for (const a of audits)
+        io.stdout.write(`${line(a, verify)}\n`);
+    if (verify)
+        io.stdout.write(broken.length ? `${broken.length} broken ledger${broken.length === 1 ? '' : 's'}: the lines from that event on cannot be trusted\n` : 'every chain verifies\n');
+    else
+        io.stdout.write('add --verify to recompute the hash chains\n');
+    return broken.length ? 1 : 0;
+}

package/dist/packages/cli/src/autotrade-cmd/backtest.js

@@ -0,0 +1,199 @@
+// `dexterm autotrade backtest|sweep|extract` (task-1503 AT-1, AUTOTRADE-SPEC §3/§3a). PAPER, recorded data only:
+// the recorder DB is opened read-only, fills are modelled, no network, no model, no keys. Mechanical entries
+// (`auto`): the agent's judgement is what the runner card measures, so a backtest never spawns a session.
+import { defaultDbPath } from '../../../data/src/index.js';
+import { openHistoryReadOnly } from '../../../recorder/src/index.js';
+import { backtest, everyCandidate, fmtIssue, loadTape, renderRecall, renderReport, renderSweep, renderYoloReplay, builtinTapePath, runnerRecall, saveTape, sweep, tapeFromDb, tapeFromDoc, yoloReplay, } from '../../../autotrade/src/index.js';
+import { parseArgs, resolveStrategyArg, storeFor } from "./strategies.js";
+const BOOL = ['json', 'every-candidate'];
+function strategyFrom(pos, opts, io, usage, anyMode = false) {
+    const arg = typeof opts.strategy === 'string' ? opts.strategy : pos[0];
+    const r = resolveStrategyArg(arg, io);
+    if (!r) {
+        io.stderr.write(`usage: ${usage}\n`);
+        return null;
+    }
+    for (const w of r.warnings)
+        io.stderr.write(`warning ${fmtIssue(w)}\n`);
+    if (!r.ok) {
+        for (const e of r.errors)
+            io.stderr.write(`error ${fmtIssue(e)}\n`);
+        return null;
+    }
+    if (r.strategy.mode !== 'paper' && !anyMode) {
+        io.stderr.write(`dexterm autotrade: ${r.strategy.id} is mode "${r.strategy.mode}": autotrade runs paper only\n`);
+        return null;
+    }
+    return r.strategy;
+}
+function numOpt(opts, k, dflt) {
+    const v = opts[k];
+    const n = typeof v === 'string' ? Number(v) : NaN;
+    return Number.isFinite(n) ? n : dflt;
+}
+/**
+ * `dexterm autotrade yolo-replay <id|file>` (task-1532): a full-port paper replay of a strategy (a live-mode copy too:
+ * the replay always runs a paper copy) over recorded history, with the rugs, the loss spread and how often a run of
+ * entries zeroed the wallet. Read-only: recorded data, modelled fills, no network, no model, no keys.
+ */
+export async function yoloReplayCmd(argv, io) {
+    const { pos, opts } = parseArgs(argv, ['json']);
+    const usage = 'dexterm autotrade yolo-replay <id|file> [--tape FILE | --db PATH [--days N | --since T] [--until T]] [--seed N] [--json]';
+    const s = strategyFrom(pos, opts, io, usage, true);
+    if (!s)
+        return 2;
+    const tape = tapeFrom(opts, io);
+    if (!tape)
+        return 2;
+    const r = await yoloReplay(s, tape, { seed: numOpt(opts, 'seed', 1) });
+    io.stdout.write(opts.json ? JSON.stringify(r, null, 2) + '\n' : renderYoloReplay(r) + '\n');
+    return 0;
+}
+/** `--since/--until`: epoch ms or an ISO time (pins a backtest to the exact tape window of an earlier run). */
+function timeOpt(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const n = /^\d+$/.test(v) ? Number(v) : Date.parse(v);
+    return Number.isFinite(n) ? n : undefined;
+}
+/** The recorder DB, read-only; null when it is missing, in memory, or not a recorder DB. */
+function openDb(path) {
+    if (path === ':memory:')
+        return null;
+    try {
+        return openHistoryReadOnly(path);
+    }
+    catch {
+        return null;
+    }
+}
+/** A tape from --tape FILE, else read-only from the recorder DB (--db, DEXTERM_DB_PATH, the default path). */
+export function tapeFrom(opts, io) {
+    if (typeof opts.tape === 'string') {
+        try {
+            return loadTape(builtinTapePath(opts.tape));
+        }
+        catch (e) {
+            io.stderr.write(`dexterm autotrade: ${e.message}\n`);
+            return null;
+        }
+    }
+    const path = typeof opts.db === 'string' ? opts.db : (io.env.DEXTERM_DB_PATH || defaultDbPath(io.env));
+    const db = openDb(path);
+    if (!db) {
+        io.stderr.write(`dexterm autotrade: no recorded history in ${path} (run the app with the recorder on first, or pass --tape FILE)\n`);
+        return null;
+    }
+    try {
+        const days = numOpt(opts, 'days', 0);
+        return tapeFromDoc(tapeFromDb(db, {
+            since: timeOpt(opts.since) ?? (days > 0 ? Date.now() - days * 86_400_000 : undefined),
+            until: timeOpt(opts.until),
+            minPeakLiqUsd: numOpt(opts, 'min-peak-liq', 20_000),
+            spanHours: numOpt(opts, 'span-hours', 80),
+        }));
+    }
+    finally {
+        db.close();
+    }
+}
+export async function backtestCmd(argv, io) {
+    const { pos, opts } = parseArgs(argv, BOOL);
+    const usage = 'dexterm autotrade backtest <id|file> [--tape FILE | --db PATH] [--days N | --since T] [--until T] [--every-candidate [--unit-usd 20]] [--recall 5,10] [--json]';
+    const s0 = strategyFrom(pos, opts, io, usage);
+    if (!s0)
+        return 2;
+    const tape = tapeFrom(opts, io);
+    if (!tape)
+        return 2;
+    const s = opts['every-candidate'] ? everyCandidate(s0, numOpt(opts, 'unit-usd', 20)) : s0;
+    const { report, run } = await backtest(s, tape);
+    const recallAt = typeof opts.recall === 'string' ? opts.recall.split(',').map(Number).filter((x) => Number.isFinite(x) && x > 1) : [];
+    const recall = recallAt.length ? runnerRecall(s, tape, run, recallAt) : null;
+    if (!opts['every-candidate']) {
+        try {
+            storeFor(io).recordBacktest({ hash: s.hash, t: Date.now(), trades: report.trades, netUsd: report.netUsd, netPct: report.netPct, maxDrawdownPct: report.maxDrawdownPct, tape: `${report.tape.mints} coins ${report.tape.from ?? ''}..${report.tape.to ?? ''}` });
+        }
+        catch { /* the line is a convenience for `list`; never fail a backtest on it */ }
+    }
+    if (opts.json) {
+        io.stdout.write(JSON.stringify(recall ? { ...report, recall } : report, null, 2) + '\n');
+        return 0;
+    }
+    io.stdout.write(renderReport(report) + '\n');
+    if (opts['every-candidate'])
+        io.stdout.write(`  every-candidate copy of ${s0.id}: each candidate entered at $${numOpt(opts, 'unit-usd', 20)} with the book caps lifted (an evaluation, not a strategy to run)\n`);
+    if (recall)
+        io.stdout.write(renderRecall(recall, s) + '\n');
+    io.stdout.write('  Paper only, recorded data, not financial advice. A backtest is not a forecast.\n');
+    return 0;
+}
+export async function sweepCmd(argv, io) {
+    const { pos, opts } = parseArgs(argv, BOOL);
+    const usage = 'dexterm autotrade sweep <id|file> [--tape FILE | --db PATH] [--grid JSON] [--mode grid|random] [--max N] [--seed N] [--test-frac 0.3] [--json]';
+    const s0 = strategyFrom(pos, opts, io, usage);
+    if (!s0)
+        return 2;
+    let grid;
+    try {
+        grid = typeof opts.grid === 'string' ? JSON.parse(opts.grid) : defaultGrid(s0);
+        if (!grid || typeof grid !== 'object' || !Object.values(grid).every((v) => Array.isArray(v) && v.every((x) => typeof x === 'number')))
+            throw new Error('the grid maps parameter paths to arrays of numbers');
+    }
+    catch (e) {
+        io.stderr.write(`dexterm autotrade: --grid: ${e.message}\n`);
+        return 2;
+    }
+    const tape = tapeFrom(opts, io);
+    if (!tape)
+        return 2;
+    const s = opts['every-candidate'] ? everyCandidate(s0, numOpt(opts, 'unit-usd', 20)) : s0;
+    let r;
+    try {
+        r = await sweep(s, tape, grid, { mode: opts.mode === 'random' ? 'random' : 'grid', max: numOpt(opts, 'max', 64), seed: numOpt(opts, 'seed', 1), testFrac: numOpt(opts, 'test-frac', 0.3) });
+    }
+    catch (e) {
+        io.stderr.write(`dexterm autotrade: ${e.message}\n`);
+        return 2;
+    }
+    io.stdout.write(opts.json ? JSON.stringify(r, null, 2) + '\n' : renderSweep(r) + '\n  Paper only, recorded data, not financial advice.\n');
+    return 0;
+}
+/** A small default grid on the default exit profile's own knobs (only the ones the profile has). */
+export function defaultGrid(s) {
+    const p = s.exits.profiles[s.exits.default];
+    const g = {};
+    if (p.trailingStop)
+        g['profile.trailingStop.trailPct'] = [15, 25, 35];
+    if (p.tpLadder.length)
+        g['profile.tpLadder.0.atPct'] = [30, 50, 80];
+    if (p.costRecovery)
+        g['profile.costRecovery.atPct'] = [60, 100, 150];
+    if (p.bagTrail)
+        g['profile.bagTrail.trailPct'] = [35, 55, 75];
+    if (s.sizing.mode === 'pct' && s.sizing.pct !== undefined)
+        g['sizing.pct'] = [s.sizing.pct / 2, s.sizing.pct].map((x) => Math.round(x * 10) / 10);
+    return g;
+}
+export function extractCmd(argv, io) {
+    const { opts } = parseArgs(argv);
+    if (typeof opts.out !== 'string') {
+        io.stderr.write('usage: dexterm autotrade extract --out FILE [--db PATH] [--max-mints N] [--min-peak-liq USD] [--span-hours H]\n');
+        return 2;
+    }
+    const path = typeof opts.db === 'string' ? opts.db : (io.env.DEXTERM_DB_PATH || defaultDbPath(io.env));
+    const db = openDb(path);
+    if (!db) {
+        io.stderr.write(`dexterm autotrade: no recorded history in ${path}\n`);
+        return 2;
+    }
+    try {
+        const doc = tapeFromDb(db, { maxMints: typeof opts['max-mints'] === 'string' ? Number(opts['max-mints']) : undefined, minPeakLiqUsd: numOpt(opts, 'min-peak-liq', 20_000), spanHours: numOpt(opts, 'span-hours', 80) });
+        saveTape(opts.out, doc);
+        io.stdout.write(`wrote ${opts.out}: ${doc.mints.length} coins, ${doc.mints.reduce((a, m) => a + m.rows.length, 0)} rows (recorded market data only)\n`);
+        return 0;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/packages/cli/src/autotrade-cmd/flatten.js

@@ -0,0 +1,64 @@
+// `dexterm autotrade flatten` (task-1509 AT-7, AUTOTRADE-SPEC §6.3). PAPER ONLY.
+//
+// A stop (no new entries, sessions closed, orders dropped), then every paper position sells at its next tick; one
+// that cannot sell (a pulled pool) stays stuck and is retried every tick. The runner ends once nothing is held. It
+// asks for a y keypress on a real terminal first, or takes `--yes` (selling only lowers risk; nothing here can buy,
+// arm a mandate or sign). Nothing here touches a wallet, a key or the signer.
+import { dextermHome } from '../../../custom/src/index.js';
+import { activeRunner } from '../../../autotrade/src/index.js';
+import { parseArgs } from "./strategies.js";
+import { sendControl, waitArg } from "./stop.js";
+export const FLATTEN_USAGE = 'dexterm autotrade flatten [--strategy ID] [--yes] [--wait SEC] [--json]';
+export async function flattenCmd(argv, io, over = {}) {
+    const { pos, opts } = parseArgs(argv, ['json', 'yes']);
+    if (pos.length) {
+        io.stderr.write(`usage: ${FLATTEN_USAGE}\n`);
+        return 2;
+    }
+    const home = dextermHome(io.env);
+    const member = typeof opts.strategy === 'string' ? opts.strategy : null;
+    const r = activeRunner(home);
+    if (!r) {
+        if (opts.json)
+            io.stdout.write(`${JSON.stringify({ requested: false, runId: null, why: 'no autotrade runner is running' })}\n`);
+        else
+            io.stdout.write('no autotrade runner is running; nothing to flatten.\n');
+        return 0;
+    }
+    if (!opts.yes) {
+        const stdin = io.stdin;
+        if (!stdin || stdin.isTTY !== true) {
+            io.stderr.write('dexterm autotrade flatten: confirm with y on a real terminal, or pass --yes\n');
+            return 2;
+        }
+        io.stdout.write(member ? `flatten strategy ${member} only: stop it, then sell its paper positions at their next tick (the other strategies keep running)? y to confirm, any other key cancels… `
+            : `flatten run ${r.runId}: stop, then sell every paper position at its next tick (${r.positions} open)? y to confirm, any other key cancels… `);
+        const { ttyKeypress } = await import("../wallet-cmd.js");
+        const key = await ttyKeypress(stdin, over.keypressTimeoutMs ?? 30_000);
+        io.stdout.write('\n');
+        if (key !== 'y' && key !== 'Y') {
+            io.stdout.write('flatten cancelled; nothing was sold\n');
+            return 1;
+        }
+    }
+    // task-1529: one strategy of a parallel run; the others keep running.
+    if (member)
+        return (await import("./strategy-control.js")).memberStopCmd(io, member, 'flatten', opts);
+    const res = await sendControl(io, 'flatten', waitArg(opts.wait), r);
+    if ('error' in res) {
+        io.stderr.write(`dexterm autotrade flatten: ${res.error}\n`);
+        return 1;
+    }
+    if (opts.json) {
+        io.stdout.write(`${JSON.stringify(res)}\n`);
+        return 0;
+    }
+    io.stdout.write(`flatten ${res.already ? 'was already requested' : 'requested'} for run ${r.runId} (pid ${r.pid})\n`);
+    if (!res.acknowledged)
+        io.stdout.write('the runner has not confirmed yet: it reads the request on its next tick. Watch the Q screen, or run this again.\n');
+    else if (res.ended)
+        io.stdout.write('✓ flat: the runner sold what it held and stopped\n');
+    else
+        io.stdout.write(`✓ flattening: no new entries, sessions closed; ${res.positions} paper position${res.positions === 1 ? '' : 's'} sell${res.positions === 1 ? 's' : ''} at the next tick (a stuck one is retried every tick)\n`);
+    return 0;
+}