dexterm-cli 0.1.7 → 0.2.1

package/dist/packages/cli/src/analyst/backend.js

@@ -14,7 +14,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ACTION_FILE_ENV, ACTION_TOKEN_ENV, ANALYST_ACTION_TYPES, parseActionLine } from '../../../data/src/index.js';
 import { basisLanguage, DEFAULT_PRICE_BASIS, fmtCap, isPriceBasis, knownSupply, NO_SUPPLY_REASON, pickBasis } from '../../../data/src/basis.js';
-import { firewall, userSkillPreamble, PARALLEL_CONTROL_TOOLS, STRATEGY_PROPOSE_TOOLS } from '../../../mcp/src/index.js';
+import { firewall, userSkillPreamble, JOURNEY_CONTROL_TOOLS, JOURNEY_PROPOSE_TOOLS, PARALLEL_CONTROL_TOOLS, STRATEGY_PROPOSE_TOOLS } from '../../../mcp/src/index.js';
 import { skillStore } from "../kb-skill-cmd.js";
 import { applyCodexEvent, buildCodexArgv, codexAllowedTools, codexDeveloperInstructions, codexFailure, expandSkillPrompt, newCodexTurn, strictSchema } from "./codex.js";
 import { runOllamaTurn } from "./ollama.js";
@@ -37,7 +37,8 @@ export function deniedActionTools(actionTypes) {
         return [];
     // task-1507: an observe-only session (AI scan) cannot propose a strategy edit either
     // task-1529: nor start or stop a parallel strategy
-    const propose = actionTypes.length === 0 ? [...STRATEGY_PROPOSE_TOOLS, ...PARALLEL_CONTROL_TOOLS] : [];
+    // task-1647: nor start / stop a forward test or propose a promotion
+    const propose = actionTypes.length === 0 ? [...STRATEGY_PROPOSE_TOOLS, ...PARALLEL_CONTROL_TOOLS, ...JOURNEY_CONTROL_TOOLS, ...JOURNEY_PROPOSE_TOOLS] : [];
     return [...ANALYST_ACTION_TYPES.filter((t) => !actionTypes.includes(t)), ...propose].map((t) => `mcp__dexterm__${t}`);
 }
 /**

package/dist/packages/cli/src/analyst/codex.js

@@ -17,7 +17,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { ACTION_FILE_ENV, ACTION_TOKEN_ENV, ANALYST_ACTION_TYPES } from '../../../data/src/index.js';
-import { READ_ONLY_TOOLS, STRATEGY_PROPOSE_TOOLS } from '../../../mcp/src/index.js';
+import { JOURNEY_PROPOSE_TOOLS, READ_ONLY_TOOLS, STRATEGY_PROPOSE_TOOLS } from '../../../mcp/src/index.js';
 import { skillStore } from "../kb-skill-cmd.js";
 /** The analyst engines dexterm can drive: the user's own claude or codex CLI, or (task-1543) a local model on their Ollama. */
 export const ANALYST_ENGINES = ['claude', 'codex', 'ollama'];
@@ -75,7 +75,8 @@ export function codexAllowedTools(actionTypes) {
     const reads = READ_ONLY_TOOLS.filter((n) => !/^paper_/.test(n) && !ANALYST_ACTION_TYPES.includes(n));
     const actions = ANALYST_ACTION_TYPES.filter((t) => !actionTypes || actionTypes.includes(t));
     // task-1507: strategy PROPOSALS (never applied by a tool) for a chat turn; an observe-only scan gets none
-    const propose = actionTypes && actionTypes.length === 0 ? [] : STRATEGY_PROPOSE_TOOLS;
+    // task-1647: promotion PROPOSALS too (a file the user applies); forward-test control stays off codex, like parallel control
+    const propose = actionTypes && actionTypes.length === 0 ? [] : [...STRATEGY_PROPOSE_TOOLS, ...JOURNEY_PROPOSE_TOOLS];
     return [...reads, ...actions, ...propose];
 }
 const tomlString = (s) => JSON.stringify(s); // a JSON string is a valid TOML basic string

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

@@ -191,6 +191,9 @@ 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: 'classification-models', title: 'Pick a classification model (Kev, hosted Jev, or the built-in scores)', screen: 'all', tags: ['classifier', 'classification', 'kev', 'jev', 'model', 'probability', 'rug', 'drain', 'llama', 'calibrated', 'typesafe', 'experimental'],
+        commands: ['classifier'], tools: ['classify_coin', 'classify_batch', 'classifier_status'], feature: 'classifier',
+        body: 'EXPERIMENTAL. A classification model answers typed questions about one coin with a probability per answer: p(drain within 6 h) and RUG / WIN / DUD over 6 h, or a narrative category. `dexterm classifier list` shows the choices: `heuristic` (the built-in H1 rug score and LARP link score; the default, no download), `kev-local` (an open Kev decision model on your own machine through llama.cpp: `dexterm classifier pull kev-4b-q4` shows the size and source and asks first, verifies the sha256, then `dexterm classifier pick kev-local kev-4b-q4` and `dexterm classifier serve`), `jev-hosted` (TypeSafe\'s hosted Jev with your own API key: `dexterm classifier key set`; per-call cost and a daily call cap), `jev-open` (the open JEV students on a vLLM server), and `claude` / `ollama-llm` zero-shot baselines. `dexterm classifier doctor` reads RAM, CPU and GPU/VRAM and recommends a tier. If the picked model is unreachable the built-in scores answer and say so. Agents use the `classify_coin`, `classify_batch` (triage: flag / pass / escalate) and `classifier_status` MCP tools; a watch rule can use `rugp` (e.g. `when rugp > 0.8 then alert(warn, "...")`). How each model scored on dexterm\'s own labelled history is on the docs page. Every answer is a model estimate with the model id, never advice. Docs: https://dexterm.xyz/docs/classifier/' },
     { 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/' },
@@ -232,7 +235,7 @@ const TOPICS = [
         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/' },
+        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 does not place orders in a trading bot for you: in real mode (0.2.0, experimental) a strategy you armed on your own terminal sends a signal for each trade to an executor you run, and your executor places the order by its own rules (`dexterm autotrade signal`, https://dexterm.xyz/docs/real-mode/). Paper trading (the ticket, paper accounts, paper autotrade) is local. `dexterm wallet link` keeps a Phantom public key for display only. Not financial advice. Full docs: https://dexterm.xyz/docs/live-trading/' },
     { 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/' },
@@ -245,13 +248,28 @@ const TOPICS = [
     { 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-real-signal', title: 'Real mode: send a strategy\'s trades to your own executor as LIVE TRADE FIRE signals (dexterm autotrade signal)', screen: 'all', tags: ['real', 'mode', 'live', 'trade', 'fire', 'signal', 'signals', 'executor', 'webhook', 'hook', 'jsonl', 'receipt', 'receipts', 'arm', 'caps', 'kill', 'outbox', 'nonce'],
+        commands: ['autotrade'], tools: ['trade_fire_feed'], feature: 'autotrade-real-signal',
+        body: 'Real mode runs a strategy exactly like paper (the same clamp, exits, monitor and run file) and sends every buy and sell it fills, first, as a LIVE TRADE FIRE signal (`dexterm-trade-fire/1`: buy or sell, mint, symbol, size in SOL and % of book, the sell fraction and exit reason, strategy, run, account, an always-growing nonce, an idempotency id and an expiry) to YOUR executor: a Telegram trading bot of your choice or any script. dexterm holds no key and signs nothing. Set channels with `dexterm autotrade signal channels --webhook URL | --signal-cmd \'["/abs/path"]\' | --jsonl on | --mcp on | --telegram on` (they live in connectors.json next to the Telegram setup; a bot cannot read another bot, so the Telegram copy alone is not enough), a webhook HMAC secret with `signal secret generate --out FILE`, hard caps with `signal caps set` (raising needs a typed confirmation), then arm on your own terminal with `dexterm autotrade signal arm <id>` (evidence panel + a typed phrase with a one-time code; any later edit disarms; below the evidence floor, a completed forward test with your `minForwardTrades` closed paper trades and a backtest of these exact rules, or past a missing rung of the ladder, it refuses unless you first type a separate OVERRIDE phrase, which is journaled) and run `dexterm autotrade run <id> --real` (live data only, in the foreground: in 0.2.0 the always-on service runs paper strategies only). Delivery is at least once from a restart-safe outbox, in nonce order, retried until acked or expired; the executor dedupes by nonce, ignores expired signals and acts only on its own account. Every run ends with a `halted` signal that lists the positions still open; the run\'s last lines and the Telegram copy name them too. Open positions are carried to the next real run of the same strategy and account, whose exits keep firing; while no real run is running NO signal goes out, sells included, so manage them in your executor. Positions stay unconfirmed until `dexterm autotrade receipt <nonce> executed|rejected|failed` (data only). `signal kill` stops every signal; `signal status`, `signal tail`, `receipt list` and `autotrade audit` show the outbox, receipts and drift; agents can read the MCP feed with trade_fire_feed. No model, tool or chat tap can arm real mode, raise a cap or lift the kill switch. Experimental; not financial advice.' },
+    { id: 'autotrade-limits', title: 'Set your own real-mode limits: per trade, per day, open positions, loss stops, the breaker (dexterm autotrade limits)', screen: 'all', tags: ['limits', 'limit', 'caps', 'cap', 'size', 'sizing', 'per', 'trade', 'daily', 'loss', 'drawdown', 'breaker', 'streak', 'exposure', 'slippage', 'ttl', 'rate', 'raise', 'lower', 'scope'],
+        commands: ['autotrade'], tools: ['trading_limits', 'limits_propose'], feature: 'autotrade-limits',
+        body: 'Every limit real mode enforces is yours to set, in one file (`~/.dexterm/autotrade/real/limits.json`, schema `dexterm-limits/1`): per trade as SOL or as % of the book (the smaller wins), SOL and buys per day, open positions, exposure, min and max position, per coin per day, a daily loss stop, a drawdown breaker, a loss-streak pause, max hold time, the evidence floor for arming (`minForwardTrades`: closed paper trades in a completed forward test, placeholder 10), min liquidity and market cap, max slippage and price impact, the signal TTL, a buy rate limit, an optional sell rate (sells are never capped unless you set one) and how long a silent executor may stay silent. `dexterm autotrade limits show [--strategy ID] [--account ID]` lists what is in force and where each number comes from; `limits set perTradeSol=0.5 dailyLossSol=0.3` (or `--scope real|paper|strategy:ID|account:ID`) changes them: a global number replaces the placeholder default, every other scope can only tighten, and the stricter always wins. Paper runs ignore them unless you add a `paper` scope; then a single paper run (not `run --all`) obeys them on its own state (a replay then needs `--sol-usd N`). Daily counters cover the whole home (every strategy and account), so a strategy or account number can only stop buys sooner. Lowering is immediate, even for a running real run; raising shows the old -> new diff and needs the typed phrase on your own terminal, and applies from the next run. `limits diff`, `limits accept` (a hand-edited file), `limits reset`, `limits breaker reset` (typed) and `limits explain` do the rest. The defaults (0.25 SOL a trade, 1 SOL a day, 20 buys, 3 open, stop at -0.5 SOL a day) are placeholders: arming asks for your own numbers first. The analyst can read and explain them (`trading_limits`) and propose a change as a diff card (`limits_propose`); it can never apply one.' },
+    { id: 'autotrade-executor-kit', title: 'Wire up a test executor, check it is alive, and get the digest (dexterm autotrade executor, signal test, report)', screen: 'all', tags: ['executor', 'kit', 'example', 'heartbeat', 'alive', 'silent', 'health', 'test', 'webhook', 'receiver', 'dry', 'run', 'digest', 'report', 'daily', 'weekly', 'divergence', 'slippage', 'latency'],
+        commands: ['autotrade'], feature: 'autotrade-executor-kit',
+        body: '`dexterm autotrade executor kit --out ~/my-executor` copies the reference executors: a webhook receiver, a `--signal-cmd` hook and a JSONL tail. Each verifies the HMAC, dedupes by nonce, honours the TTL, writes a receipt and a heartbeat, and is DRY RUN: it only logs what it would do, with no wallet code in it. Start one, point a channel at it (`dexterm autotrade signal channels --webhook http://127.0.0.1:8787/signal`), then `dexterm autotrade signal test` sends a test signal (`test: true`, no coin, nothing to trade) and shows, per channel, whether it was delivered, how long it took and the executor\'s receipt. `dexterm autotrade executor status` shows the last heartbeat, the last receipt and the lag; a real run pauses new buy signals (exits still go out) when nothing is heard for longer than your `executorSilenceMin` limit, and tells you. With receipts that carry fills, `signal status`, `autotrade audit` and `dexterm autotrade report` show paper vs real: slippage against dexterm\'s own paper fill, latency, partial fills and rejections. `report [--period day|week] [--telegram]` is the digest per strategy and mode with the win rate\'s interval and a small-sample note; `report --schedule daily|weekly` makes a run with your bot on send it.' },
     { 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: 'autotrade-journey', title: 'Build a strategy by chat, back-test it, forward-test it, then promote it (paper, then real)', screen: 'all', tags: ['autotrade', 'strategy', 'build', 'chat', 'journey', 'ladder', 'backtest', 'held-out', 'forward', 'test', 'promote', 'promotion', 'always-on', 'real', 'evidence'],
+        commands: ['autotrade'], tools: ['strategy_journey', 'strategy_forward_start', 'strategy_forward_stop', 'strategy_forward_report', 'strategy_promote_propose'], feature: 'autotrade-journey',
+        body: 'A strategy climbs one ladder, one rung at a time: draft → backtested → forward-tested → always-on (paper) → real. Each rung needs evidence measured on that strategy\'s exact rules; any rule change starts it again (a rename or arming keeps it). Ask the analyst to build one ("build me a strategy that buys young pairs on a 5-minute push and takes profit at 2x"): it proposes a copy of a preset with changes (strategy_propose_new), you apply it on the Q screen. BACKTESTED: `dexterm autotrade backtest <id>` or strategy_backtest runs it on recorded history and on each half of the held-out split (the newest 30% of coins); verdict rule 6 allows gain wording only with at least 20 trades in both halves and a held-out net above 0. FORWARD-TESTED: `dexterm autotrade forward start <id> --hours 24` (or `--trades N`, or strategy_forward_start from the chat) runs the same version on the LIVE tape, on paper, with its own bankroll and run file, in the background next to the always-on service; `forward status`, `forward stop` and `forward report` (the forward numbers next to the backtest: trades, win rate with its interval, net, drawdown, rug rate, fill cost drift, and a plain line when a sample is too small). Only a test that ran its whole window on live data counts. ALWAYS-ON: the analyst can propose it (strategy_promote_propose), you apply it with `dexterm autotrade promote apply <pp-id>` (y on your own terminal) or on the Q screen journey view (`J`, then `y`); it joins autotrade.json and the always-on service runs it on paper. REAL: you set your own limits (`dexterm autotrade limits set`; `signal caps set` sets four of them), then `dexterm autotrade promote <id> --to real` hands over to `signal arm` (evidence panel, typed phrase with a one-time code). No tool or model can apply a promotion, skip a rung, set a cap, pick a bankroll or arm real mode. `dexterm autotrade journey <id>` shows where a strategy stands. Paper by default; not financial advice.' },
     { 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' },
+        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|real (real = a real-mode run: dexterm\'s model of the trades it signalled), --strategy id[@version], --profile, --exit, --mint, --run, --days, --status. Reads never write; `dexterm ledger sync` appends to ~/.dexterm/ledger/trades.jsonl (sha256-chained) and `dexterm ledger verify` names the first edited line. Agents read the same rows with the read-only ledger_* tools; `trading_status` and `telegram_status` show settings and state, never a key, address, exact balance, bot token or chat id. A backtest an agent asks for (backtest_request) only runs when you run it: `dexterm autotrade requests`. PAPER rows are simulated; filter by --mode before comparing. Not financial advice. Full docs: https://dexterm.xyz/docs/paper-trading/#the-trade-ledger' },
+    { id: 'strategy-dashboard', title: 'Track how your autotrade strategies perform in a browser, on this machine only (dexterm dash)', screen: 'all', tags: ['dash', 'dashboard', 'performance', 'strategies', 'track', 'equity', 'drawdown', 'compare', 'baseline', 'rugs', 'stuck', 'browser', 'web', 'phone'],
+        commands: ['dash'],
+        body: '`dexterm dash` reads your own autotrade run ledgers ($DEXTERM_HOME/autotrade/runs) and serves a dashboard on http://127.0.0.1:4317/ (loopback only; no account, no cloud, nothing leaves the machine; read-only). Views: Overview (every strategy side by side with an equity sparkline), Strategy (equity curve, drawdown, exit reasons, open positions with the engine mark and the realizable value from the last cached pool read, every trade), Rugs & stuck (closed at -80% or worse and stuck positions written off at what they actually sold), Compare (each strategy minus a --baseline with the 95% interval of the difference) and Live status; it refreshes every 30 s. Every number carries its sample size; under 20 closed trades a strategy is exploratory. Flags: --port, --home (repeat for several homes), --baseline ID, --books FILE (your own script\'s books), --allow-host NAME (a private proxy in front), --json, --export DIR [--redact-mints] (a static read-only snapshot). PAPER results are simulated. Not financial advice.' },
     { 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.' },
@@ -271,6 +289,9 @@ const TOPICS = [
     { 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', '--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: 'streamer-overlay', title: 'Streamer overlay for OBS (dexterm overlay)', screen: 'all', tags: ['overlay', 'obs', 'stream', 'streamer', 'browser source', 'scene', 'twitch', 'spectator', 'pnl', 'coin card', 'activity'],
+        commands: ['overlay'], feature: 'streamer-overlay',
+        body: 'Put the agent session on a live stream. `dexterm overlay` serves three transparent scenes for an OBS Browser source on 127.0.0.1: the agent activity feed, the coin card the agent is on (name, LARP evidence and the deterministic verdict, a top-10 holder bar, the live holder/rug signals) and the PnL card (the same renderer as the H key; stamped PAPER for the agent\'s simulated fills, or PAPER / LIVE by wallet mode with `--ledger <tradeId>`). `--scene all` puts all three in one source, `--theme cyberspace|ice|neon` picks a preset. It watches the read-only spectator stream a running `dexterm --spectate-mcp` (or `dexterm agent serve --spectate`) opens; `--replay FILE` plays a saved session and every scene then says SAMPLE DATA. Each printed URL works once (a single-use ticket, 10 minutes to paste it; press n for fresh ones). Addresses are always shortened, every scene shows the age of its data, and the overlay can only watch: it sends nothing back and cannot pause, trade, arm or sign. Full docs: https://dexterm.xyz/docs/overlay/' },
     { 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.' },
@@ -280,6 +301,9 @@ const TOPICS = [
     { id: 'narrative-board', title: 'See the narrative board (dexterm narrative)', screen: 'trending', tags: ['narrative', 'narratives', 'board', 'trending', 'movers', 'window', 'summary'],
         commands: ['narrative'], feature: 'trending-board',
         body: '`dexterm narrative [--window 1h|24h] [--summary]` prints the narrative board — what is trending across the recorded feed — with no network and no model. In-app it is the trending screen.' },
+    { id: 'narratives-tracker', title: 'Track memes and narratives (dexterm narratives, experimental)', screen: 'narrative', tags: ['narratives', 'narrative', 'memes', 'meme', 'copycat', 'lifecycle', 'ignition', 'heat', 'saturated', 'experimental'],
+        actions: [{ action: 'narrative.view', screen: 'narrative' }, { action: 'narrative.drill', screen: 'narrative' }], commands: ['narratives'], tools: ['narratives_top', 'narrative_detail', 'narrative_of'], feature: 'narratives',
+        body: 'EXPERIMENTAL. The narratives tracker groups coins by the theme their name and ticker carry (ticker puns, animals, celebrities, AI agents, seasonal events, copy-cats of a runner) and measures each theme per window: coins, new-coin rate, volume share, unique-trader growth, top runner and drawdown, a lifecycle state (spark / ignition / peak / fading / dead, with the rule that set it) and a copy-cat saturation flag. On the N screen, n flips the board into the NARRATIVES table (the first switch reads the last 26 h of recorded history and takes tens of seconds), enter to see a narrative\'s coins in spawn order, esc to go back. `dexterm narratives [top|detail ID|of MINT|export]` prints the same from the recorder; the analyst uses narratives_top, narrative_detail and narrative_of. Rules can use narrative_rank, narrative_score and the tags narrative:ignition / narrative:saturated. Keyless and local; measured heat, not advice.' },
     { id: 'kol-lists', title: 'Manage KOL wallet lists (dexterm kol)', screen: 'kol', tags: ['kol', 'kols', 'influencer', 'leader', 'list', 'lists', 'wallet', 'mute', 'import'],
         commands: ['kol'], feature: 'kol-lists',
         body: '`dexterm kol list|create|add|remove|mute|unmute|enable|disable|import` manages key-opinion-leader wallet lists on the shared DB (official / authorized sources only). In-app the KOL screen shows the lists and their activity.' },

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

@@ -4,7 +4,8 @@
 // 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 { existsSync } from 'node:fs';
+import { Outbox, allOutboxSignals, auditRun, divergenceLines, divergenceReport, driftReport, listRunIds, outboxPath, readReceipts } 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) {
@@ -38,8 +39,19 @@ export async function auditCmd(argv, io) {
     const verify = !!opts.verify;
     const audits = ids.map((id) => auditRun(home, id));
     const broken = verify ? audits.filter((a) => !a.ok) : [];
+    // task-1645: real mode: the drift between the trade-fire signals and the executor's receipts.
+    let real = null;
+    // task-1654: paper vs real: each receipted fill against dexterm's own paper fill (every outbox file, archives too).
+    let divergence = null;
+    if (existsSync(outboxPath(home))) {
+        const receipts = readReceipts(home).receipts;
+        const { rows: _rows, ...rest } = driftReport(Outbox.open(home, { channels: [], noLock: true }).signals(), receipts, Date.now());
+        real = rest;
+        const { rows: _r2, ...dv } = divergenceReport(allOutboxSignals(home), receipts);
+        divergence = dv;
+    }
     if (opts.json) {
-        io.stdout.write(`${JSON.stringify({ verified: verify, runs: audits, broken: broken.length }, null, 2)}\n`);
+        io.stdout.write(`${JSON.stringify({ verified: verify, runs: audits, broken: broken.length, ...(real ? { realSignals: real } : {}), ...(divergence ? { paperVsReal: divergence } : {}) }, null, 2)}\n`);
         return broken.length ? 1 : 0;
     }
     if (!audits.length) {
@@ -53,5 +65,10 @@ export async function auditCmd(argv, io) {
         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');
+    if (real)
+        io.stdout.write(`real-mode signals vs receipts · executed ${real.counts.executed} · rejected ${real.counts.rejected} · failed ${real.counts.failed} · unconfirmed ${real.unconfirmed}${real.sizeDrift ? ` · size drift on ${real.sizeDrift}` : ''}${real.orphanReceipts ? ` · ${real.orphanReceipts} orphan receipt(s)` : ''} (dexterm autotrade receipt list)\n`);
+    if (divergence?.receipted)
+        for (const l of divergenceLines(divergence))
+            io.stdout.write(`${l}\n`);
     return broken.length ? 1 : 0;
 }

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

@@ -1,11 +1,12 @@
 // `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 { dextermHome } from '../../../custom/src/index.js';
 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 { backtest, backtestEvidence, everyCandidate, recordBacktestEvidence, renderHeldOut, 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'];
+const BOOL = ['json', 'every-candidate', 'no-held-out'];
 function strategyFrom(pos, opts, io, usage, anyMode = false) {
     const arg = typeof opts.strategy === 'string' ? opts.strategy : pos[0];
     const r = resolveStrategyArg(arg, io);
@@ -99,7 +100,8 @@ export function tapeFrom(opts, io) {
 }
 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 usage = 'dexterm autotrade backtest <id|file> [--tape FILE | --db PATH] [--days N | --since T] [--until T] [--every-candidate [--unit-usd 20]] [--recall 5,10] [--no-held-out] [--json]';
+    const arg = typeof opts.strategy === 'string' ? opts.strategy : pos[0];
     const s0 = strategyFrom(pos, opts, io, usage);
     if (!s0)
         return 2;
@@ -116,11 +118,26 @@ export async function backtestCmd(argv, io) {
         }
         catch { /* the line is a convenience for `list`; never fail a backtest on it */ }
     }
+    // task-1647: a stored strategy's backtest is journey evidence: the same rules on each half of the held-out split.
+    let evidence = null;
+    const stored = !!arg && !opts['every-candidate'] && !opts['no-held-out'] && storeFor(io).get(arg)?.ok === true && arg === s.id;
+    if (stored) {
+        const days = numOpt(opts, 'days', 0);
+        evidence = (await backtestEvidence(s, tape, { by: 'user', days: days > 0 ? days : null, full: { report, run } })).evidence;
+        try {
+            recordBacktestEvidence(dextermHome(io.env), evidence);
+        }
+        catch (e) {
+            io.stderr.write(`warning: the journey record was not written (${e.message})\n`);
+        }
+    }
     if (opts.json) {
-        io.stdout.write(JSON.stringify(recall ? { ...report, recall } : report, null, 2) + '\n');
+        io.stdout.write(JSON.stringify({ ...report, ...(recall ? { recall } : {}), ...(evidence ? { heldOut: evidence.heldOut, evidence: { verdict: evidence.verdict, claim: evidence.claim, rulesHash: evidence.rulesHash } } : {}) }, null, 2) + '\n');
         return 0;
     }
     io.stdout.write(renderReport(report) + '\n');
+    if (evidence)
+        io.stdout.write(renderHeldOut(evidence).join('\n') + `\n  journey: recorded as the backtest of ${s.id} v${s.version} (dexterm autotrade journey ${s.id})\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)

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

@@ -0,0 +1,91 @@
+// `dexterm autotrade executor …` (task-1654, 0.2.0 card E): is YOUR executor alive?
+//
+//   status     the last heartbeat, the last receipt, the receipt lag, and whether a real run would pause new buys now
+//   heartbeat  append one heartbeat (for executors that prefer to shell out; the kit appends or POSTs its own)
+//   kit        copy the executor reference kit (webhook / signal-cmd / JSONL tail, all dry run) to a folder of yours
+//
+// A heartbeat is data: it can only keep new buy signals from pausing. It cannot raise a limit, lift the kill switch,
+// reset the breaker or confirm a position (receipts do that, and only as data).
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dextermHome } from '../../../custom/src/index.js';
+import { Outbox, appendHeartbeat, effectiveLimits, executorHealth, healthLine, heartbeatPath, loadLimits, readReceipts, ACCOUNT_ID_RE } from '../../../autotrade/src/index.js';
+import { parseArgs } from "./strategies.js";
+/** The kit inside the app (shipped in the npm package too: build-dist copies examples/). */
+export const KIT_DIR = fileURLToPath(new URL('../../../autotrade/examples/executor/', import.meta.url));
+const out = (io, s) => { io.stdout.write(`${s}\n`); };
+const err = (io, s) => { io.stderr.write(`dexterm autotrade executor: ${s}\n`); };
+export async function executorCmd(argv, io, deps = {}) {
+    const home = dextermHome(io.env);
+    const now = deps.now ?? Date.now;
+    const { pos, opts } = parseArgs(argv.slice(1), ['json', 'dry-run']);
+    switch (argv[0]) {
+        case undefined:
+        case 'help':
+            out(io, 'dexterm autotrade executor status [--json] | heartbeat [--name N] [--account ID] [--dry-run] [--nonce N] [--note TEXT] | kit --out DIR');
+            return 0;
+        case 'kit': {
+            if (typeof opts.out !== 'string') {
+                err(io, 'kit --out DIR (a new or empty folder)');
+                return 2;
+            }
+            const dir = resolve(opts.out);
+            if (existsSync(dir) && readdirSync(dir).length) {
+                err(io, `${dir} is not empty`);
+                return 1;
+            }
+            mkdirSync(dir, { recursive: true });
+            const files = readdirSync(KIT_DIR).filter((f) => /\.(mjs|md)$/.test(f));
+            for (const f of files)
+                copyFileSync(join(KIT_DIR, f), join(dir, f));
+            out(io, `executor reference kit (DRY RUN: it logs what it would do; no wallet code) copied to ${dir}: ${files.join(', ')}`);
+            out(io, `  start one:  node ${join(dir, 'webhook-executor.mjs')} --account main`);
+            out(io, '  wire it:    dexterm autotrade signal channels --webhook http://127.0.0.1:8787/signal');
+            out(io, '  prove it:   dexterm autotrade signal test   (then dexterm autotrade executor status)');
+            return 0;
+        }
+        case 'status': {
+            const l = loadLimits(home);
+            const e = effectiveLimits(l.ok ? l.doc : null, { strategyId: '-', accountId: '-', mode: 'real' });
+            const ob = Outbox.open(home, { channels: [], noLock: true });
+            const h = executorHealth(home, { now: now(), windowMin: e.values.executorSilenceMin ?? null, signal: (n) => ob.get(n), receipts: readReceipts(home).receipts });
+            if (opts.json) {
+                out(io, JSON.stringify(h, null, 2));
+                return 0;
+            }
+            out(io, `executor  ${healthLine(h)}`);
+            out(io, `  heartbeats: ${heartbeatPath(home)} (append, POST to the run's listener, or dexterm autotrade executor heartbeat)`);
+            if (h.alive === false)
+                out(io, '  a real run would PAUSE new buy signals now (exits still go out); start your executor, then dexterm autotrade signal test');
+            return 0;
+        }
+        case 'heartbeat': {
+            if (pos.length) {
+                err(io, `unexpected ${pos.join(' ')}`);
+                return 2;
+            }
+            const accountId = typeof opts.account === 'string' ? opts.account : null;
+            if (accountId && !ACCOUNT_ID_RE.test(accountId)) {
+                err(io, '--account: lowercase letters, digits, - and _');
+                return 2;
+            }
+            const nonce = opts.nonce === undefined ? null : Number(opts.nonce);
+            try {
+                const hb = appendHeartbeat(home, { at: now(), executor: typeof opts.name === 'string' ? opts.name : 'cli', accountId, dryRun: opts['dry-run'] === true ? true : null, lastNonce: nonce, note: typeof opts.note === 'string' ? opts.note : null });
+                if (opts.json)
+                    out(io, JSON.stringify(hb));
+                else
+                    out(io, `heartbeat from ${hb.executor} recorded`);
+                return 0;
+            }
+            catch (e) {
+                err(io, e.message);
+                return 2;
+            }
+        }
+        default:
+            err(io, `unknown subcommand ${JSON.stringify(argv[0])}`);
+            return 2;
+    }
+}

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

@@ -25,6 +25,7 @@ import { appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { dextermHome } from '../../../custom/src/index.js';
 import { KillSwitch, createDataLayer, defaultDbPath, resolveRpcUrl } from '../../../data/src/index.js';
+import { DrainPoller, RugProbe, chainVets, defaultFetchJson, rugproofVet } from '../../../autotrade/src/index.js';
 import { FleetGuard, HEARTBEAT_MS, accountTable, LiveSource, RUNNER_RENDEZVOUS_SCHEMA, RUN_SUMMARY_SCHEMA, RunnerSafety, acquireRunLock, bankrollUsd, claudeSessionFactory, clearControl, clearMemberControls, clearStaleControl, compareRows, compareTable, controlPath, fileLedger, fleetStatusPath, fleetTotals, loadFleetConfig, loadRunnerConfig, loadTape, memberStrategy, newRunId, prepareAccount, releaseRunLock, renderDossierRecord, runFleet, runFiles, runnerRendezvousPath, runnerSystemPrompt, sharedDossier, stubSession, writeJsonAtomic, writeRendezvous, } from '../../../autotrade/src/index.js';
 import { parseArgs, resolveStrategyArg } from "./strategies.js";
 import { larpVet } from "./run.js";
@@ -161,7 +162,7 @@ export async function fleetRunCmd(argv, io, over = {}) {
             continue;
         }
         if (r.strategy.mode !== 'paper') {
-            problems.push(`${m.id}: ${r.strategy.id} is mode "${r.strategy.mode}"; the runner refuses anything but paper`);
+            problems.push(`${m.id}: ${r.strategy.id} is mode "${r.strategy.mode}"; the runner refuses anything but paper${r.strategy.mode === 'real' ? ` in a parallel run (real mode runs one strategy on its own: dexterm autotrade run ${r.strategy.id} --real)` : ''}`);
             continue;
         }
         const acct = m.account ? accountOf.get(m.account) : undefined;
@@ -174,7 +175,8 @@ export async function fleetRunCmd(argv, io, over = {}) {
         }
         const { strategy, basedOn } = memberStrategy(r.strategy, m, b.usd);
         const sol = acct ? (acct.sol !== undefined ? { sol: acct.sol, solUsd: acct.solUsd } : {}) : m.bankroll && 'sol' in m.bankroll ? { sol: m.bankroll.sol, solUsd: solUsd } : {};
-        members.push({ config: m, strategy, basedOn, bankroll: { usd: strategy.bankroll.startUsd, ...sol } });
+        const adopt = over.adopt?.(m.id);
+        members.push({ config: m, strategy, basedOn, bankroll: { usd: strategy.bankroll.startUsd, ...sol }, ...(adopt?.length ? { adopt } : {}) });
     }
     if (problems.length) {
         io.stderr.write(`dexterm autotrade run --all: nothing started:\n${problems.map((p) => `  ${p}`).join('\n')}\n`);
@@ -199,6 +201,7 @@ export async function fleetRunCmd(argv, io, over = {}) {
     clearMemberControls(home, fleetId);
     const { ledger: fleetLedger, files: fleetFiles } = fileLedger(home, fleetId);
     const startedAt = Date.now();
+    over.onStarted?.(fleetId, fleetLedger);
     const guard = new FleetGuard(fleetCfg.global, runnerCfg, { loadavg: over.loadavg });
     const rawPath = opts.raw ? join(home, 'autotrade', 'runs', `${fleetId}.stream.jsonl`) : null;
     const sessions = over.sessions ?? (opts.stub
@@ -216,6 +219,7 @@ export async function fleetRunCmd(argv, io, over = {}) {
     let source;
     let dossier;
     let vet;
+    let drain;
     if (data) {
         live = new LiveSource({ store: data.store, dexscreener: data.dexscreener }, { onLog: (l) => fleetLedger.add(Date.now(), 'source_error', { error: l.slice(0, 300) }) });
         const ls = live;
@@ -233,7 +237,12 @@ export async function fleetRunCmd(argv, io, over = {}) {
         });
         dossier = () => async (k, h, matched, b) => renderDossierRecord(await shared.get(k.mint), { mint: k.mint, symbol: k.symbol, matched }, k, h, b);
         // A member's LARP gate (entry.safety.larp, the yolo preset's) on live data, as `autotrade run` has it.
-        vet = fleetLarpVet((mint) => mcp.call('larp_check', { mint }));
+        const larpVets = fleetLarpVet((mint) => mcp.call('larp_check', { mint }));
+        // task-1748: a member's rug-proof gates (entry.safety.rugproof) run first, then its LARP gate; one probe (and its
+        // caches) for the whole fleet. Read-only: DexScreener, the user's RPC (or the public one), Jupiter quotes.
+        const probe = new RugProbe({ fetchJson: defaultFetchJson(), rpcUrl: resolveRpcUrl({ env: io.env }).url });
+        vet = (mm) => chainVets(mm.strategy.entry.safety.rugproof ? rugproofVet(mm.strategy.entry.safety.rugproof, { probe }) : undefined, larpVets(mm));
+        drain = (mm) => { const g = mm.strategy.entry.safety.rugproof?.drainGuard; return g ? new DrainPoller(g, probe, (rec) => fleetLedger.add(Date.now(), 'drain_probe', { member: mm.strategy.id, ...rec })) : undefined; };
     }
     // Heartbeat: the aggregate rendezvous, the fleet status, every summary.
     const states = new Map();
@@ -300,11 +309,13 @@ export async function fleetRunCmd(argv, io, over = {}) {
         const res = await runFleet({
             fleetId, home, members, tape, source, runner: runnerCfg, guard, fleetLedger, fleetLedgerPath: fleetFiles.ledger, ...(accounts.length ? { accounts } : {}),
             pacing: replay ? { mode: 'paced', msPerTick: num(opts['ms-per-tick'], 2000) } : { mode: 'live' },
-            sessions, dossier, vet, newRunId: (id) => newRunId(id), verbose: true, onLine: say,
+            sessions, dossier, vet: over.vetWrap ? (m) => over.vetWrap(m, vet?.(m)) : vet, drain, newRunId: (id) => newRunId(id), verbose: true, onLine: say,
             globalSafety: () => {
                 if (Date.now() >= stopAt)
                     stop('max-minutes');
-                const v = safety.step();
+                const s0 = safety.step();
+                const extra = over.extraSafety?.().pauseEntries ?? null;
+                const v = extra && !s0.pauseEntries ? { ...s0, pauseEntries: extra } : s0;
                 return stopping && !v.halt ? { ...v, halt: 'runner-stopped', detail: 'a signal or --max-minutes', endWhenFlat: true } : v;
             },
             hooks: {