dexterm-cli 0.1.7 → 0.2.0

package/dist/packages/mcp/src/ledger-tools.js

@@ -11,9 +11,17 @@
 //                               every candidate of a run (what the skips turned into)
 //   telegram_status    observe  the Telegram connector's settings: enabled, paired chats (a count), approvals, notify
 //   trading_status     observe  where live trading happens (task-1571: not in dexterm; it holds no key and places no
-//                               live order) and whether the panic switch is engaged
+//                               live order), whether the panic switch is engaged, and real mode's state (task-1645)
+//   trade_fire_feed      observe  task-1645: the MCP channel of real mode: the LIVE TRADE FIRE signals of the feed
+//                               (autotrade/real/mcp-feed.jsonl) after a nonce, and real mode's status. Reading is all it
+//                               does: no tool arms real mode, changes a cap, lifts the kill switch or records a receipt
+//   trading_limits     observe  task-1654: real mode's limits in force (for a strategy / account / mode), where each
+//                               number comes from, what each limit does, today's counters and the executor's health
 //   backtest_requests  observe  the backtests this agent asked for, and their results once the user ran them
 //   backtest_request   propose  ask the user to run a longer backtest (a request file; the user runs or dismisses it)
+//   limits_propose     propose  task-1654: a limits change as a DIFF CARD (old -> new, which numbers it raises, the
+//                               exact command the user would type). It writes nothing at all: only the user applies a
+//                               change, on their own terminal (`dexterm autotrade limits set`; a raise is typed)
 //
 // Nothing here can trade, sign, change a cap, enable live or touch a key: the ledger is read through
 // `@dexterm/autotrade`'s loader (pure file reads, loaded lazily: @dexterm/autotrade imports this package). Text that
@@ -26,10 +34,10 @@ import { dextermHome } from "./user-content.js";
 import { BacktestRequests, MAX_PENDING_REQUESTS, REQUEST_MAX_DAYS, REQUEST_RATE_PER_HOUR } from "./backtest-requests.js";
 export const LEDGER_READ_TOOLS = [
     'ledger_trades', 'ledger_positions', 'ledger_equity', 'ledger_summary', 'ledger_compare',
-    'candidate_dossier', 'outcomes_lookup', 'telegram_status', 'trading_status', 'backtest_requests',
+    'candidate_dossier', 'outcomes_lookup', 'telegram_status', 'trading_status', 'trade_fire_feed', 'trading_limits', 'backtest_requests',
 ];
 /** Write-shaped (a request file), so not on the read-only surface a skill may name. */
-export const LEDGER_PROPOSE_TOOLS = ['backtest_request'];
+export const LEDGER_PROPOSE_TOOLS = ['backtest_request', 'limits_propose'];
 export const LEDGER_TOOLS = [...LEDGER_READ_TOOLS, ...LEDGER_PROPOSE_TOOLS];
 const MINT = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
 const RUN_ID = /^[0-9TZ]+-[a-z][a-z0-9-]{1,31}-[0-9a-f]{4}$/;
@@ -64,10 +72,10 @@ export function filterFromArgs(a, now) {
         return allowed.includes(a[k]) ? a[k] : false;
     };
     const source = pick('source', ['paper', 'desk', 'autotrade', 'live']);
-    const mode = pick('mode', ['paper', 'devnet', 'live']);
+    const mode = pick('mode', ['paper', 'devnet', 'live', 'real']);
     const status = pick('status', ['open', 'closed']);
     if (source === false || mode === false || status === false)
-        return { ok: false, error: 'source is paper|desk|autotrade|live, mode is paper|devnet|live, status is open|closed' };
+        return { ok: false, error: 'source is paper|desk|autotrade|live, mode is paper|devnet|live|real, status is open|closed' };
     if (source)
         f.source = source;
     if (mode)
@@ -135,6 +143,9 @@ export class LedgerTools {
                 case 'outcomes_lookup': return await this.outcomes(args);
                 case 'telegram_status': return this.telegram();
                 case 'trading_status': return this.trading();
+                case 'trade_fire_feed': return this.signals(args);
+                case 'trading_limits': return await this.limits(args);
+                case 'limits_propose': return await this.limitsPropose(args);
                 case 'backtest_requests': return this.requests();
                 case 'backtest_request': return await this.request(args);
                 default: return { error: `unknown ledger tool ${name}` };
@@ -154,7 +165,7 @@ export class LedgerTools {
         const rows = filterTrades(v.trades, filter);
         const integrity = { ledger: v.file.check.ok ? `verified, ${v.file.events.length} events` : `FAILS its check at line ${v.file.check.at}: ${v.file.check.error}`, pendingFromSources: v.pending.length, problems: v.sources.filter((s) => s.problem).map((s) => s.problem) };
         const modes = [...new Set(rows.map((t) => t.walletMode))];
-        const base = { readOnly: true, modes, integrity, note: modes.length > 1 ? 'PAPER, DEVNET and LIVE trades are in this set: filter by mode before comparing results.' : modes.includes('paper') ? 'PAPER (simulated) trades: never present them as results.' : undefined };
+        const base = { readOnly: true, modes, integrity, note: modes.length > 1 ? 'PAPER, REAL, DEVNET and LIVE trades are in this set: filter by mode before comparing results.' : modes.includes('paper') ? 'PAPER (simulated) trades: never present them as results.' : modes.includes('real') ? 'REAL-mode trades: dexterm\'s model of the trades it signalled to the user\'s executor; the executor\'s receipts are the real fills.' : undefined };
         if (name === 'ledger_trades' || name === 'ledger_positions') {
             const limit = Math.min(200, Math.max(1, Number.isInteger(args.limit) ? Number(args.limit) : 50));
             const newest = [...rows].sort((a, b) => b.openedAt - a.openedAt).slice(0, limit);
@@ -292,13 +303,150 @@ export class LedgerTools {
     // ───────────────────────────── live trading (task-1571: not in dexterm) ───────────────
     trading() {
         const panic = existsSync(join(this.home(), 'trading.panic'));
+        const real = this.realState();
         return {
             readOnly: true,
-            liveTrading: 'not in dexterm: dexterm holds no key, signs nothing and places no live order. Live trading happens in the Telegram trading bot the user chose, which holds its own wallet; dexterm only sends alerts and run control to the user\'s own bot (telegram_status).',
+            liveTrading: 'not in dexterm: dexterm holds no key, signs nothing and places no live order. Live trading happens in the Telegram trading bot (or script) the user chose, which holds its own wallet; dexterm only sends alerts, run control and, in real mode, LIVE TRADE FIRE signals to the user\'s own executor (telegram_status, trade_fire_feed).',
             paperTrading: 'local: the paper ticket, paper accounts and paper autotrade runs (ledger_* tools)',
+            realMode: `${real.armed.length} strategy(ies) armed for real mode by the user on their own terminal${real.kill ? `; the real-mode kill switch is ON (${real.kill})` : ''}. Only the user arms, disarms, sets caps or lifts the kill switch, on their own terminal; no tool can.`,
             panicSwitch: panic ? 'engaged (autotrade runs and the paper agent desk are halted; only `dexterm wallet resume` in a terminal clears it)' : 'off',
         };
     }
+    // ───────────────────────────── real mode (task-1645) ─────────────────────────────
+    readJson(path) {
+        try {
+            return JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Real mode's state from its files (pure reads; ids and numbers only). */
+    realState() {
+        const dir = join(this.home(), 'autotrade', 'real');
+        const arming = this.readJson(join(dir, 'arming.json'));
+        const armed = Object.values((arming?.armed ?? {}))
+            .filter((a) => typeof a.strategyId === 'string' && /^[a-z][a-z0-9-]{1,31}$/.test(a.strategyId))
+            .map((a) => ({ id: String(a.strategyId), version: String(a.version ?? '').slice(0, 16), accountId: String(a.accountId ?? '').replace(/[^a-z0-9_-]/g, '').slice(0, 32) }));
+        const killFile = join(dir, 'kill.json');
+        const k = existsSync(killFile) ? this.readJson(killFile) : null;
+        // task-1654: the caps are four of the limits (limits.json global, else card A's caps.json).
+        const lim = this.readJson(join(dir, 'limits.json'))?.global;
+        const caps = (lim ? Object.fromEntries(['perTradeSol', 'dailySol', 'buysPerDay', 'maxOpenPositions'].filter((k) => typeof lim[k] === 'number').map((k) => [k, lim[k]])) : undefined) ?? this.readJson(join(dir, 'caps.json'))?.caps;
+        const capsNum = caps ? Object.fromEntries(Object.entries(caps).filter(([, v]) => typeof v === 'number')) : null;
+        const n = Number(this.readJson(join(dir, 'nonce.json'))?.last);
+        return { armed, kill: existsSync(killFile) ? cleanLedgerText(k?.reason ?? 'engaged', 80) || 'engaged' : null, caps: capsNum, lastNonce: Number.isSafeInteger(n) ? n : null };
+    }
+    signals(args) {
+        const after = Number(args.after_nonce ?? 0);
+        const limit = Number(args.limit ?? 50);
+        if (!Number.isSafeInteger(after) || after < 0)
+            return { error: 'after_nonce is a whole number >= 0' };
+        if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+            return { error: 'limit is a whole number from 1 to 100' };
+        const feed = join(this.home(), 'autotrade', 'real', 'mcp-feed.jsonl');
+        const out = [];
+        let feedOn = false;
+        if (existsSync(feed)) {
+            feedOn = true;
+            for (const l of readFileSync(feed, 'utf8').split('\n')) {
+                if (!l.trim())
+                    continue;
+                let x;
+                try {
+                    x = JSON.parse(l);
+                }
+                catch {
+                    continue;
+                }
+                if (x.schema !== 'dexterm-trade-fire/1' || typeof x.nonce !== 'number' || x.nonce <= after)
+                    continue;
+                // The signal as dexterm wrote it; the only token text in it is the symbol, already reduced to [A-Za-z0-9._$-].
+                out.push({ ...x, symbol: typeof x.symbol === 'string' ? x.symbol.replace(/[^A-Za-z0-9._$-]/g, '').slice(0, 16) : undefined });
+                if (out.length >= limit)
+                    break;
+            }
+        }
+        const st = this.realState();
+        return {
+            readOnly: true, schema: 'dexterm-trade-fire/1', signals: out, nextAfterNonce: out.length ? out[out.length - 1].nonce : after,
+            realMode: { armed: st.armed, kill: st.kill, caps: st.caps, lastNonce: st.lastNonce, mcpFeed: feedOn ? 'on' : 'off (the user enables it: dexterm autotrade signal channels --mcp on)' },
+            rules: 'An executor acts only on its own accountId, ignores a signal after expiresAt, and dedupes by nonce (delivery is at-least-once). type "halted" ends a run; type "test" is never traded. The user records what was done with `dexterm autotrade receipt`; this tool changes nothing.',
+        };
+    }
+    // ───────────────────────────── limits (task-1654) ─────────────────────────────
+    limitsContext(args) {
+        const id = (v, name) => (v === undefined ? '-' : typeof v === 'string' && /^[a-z0-9][a-z0-9._-]{0,63}$/.test(v) ? v : { error: `${name} is an id ([a-z0-9._-], 64 max)` });
+        const strategyId = id(args.strategy, 'strategy');
+        if (typeof strategyId !== 'string')
+            return strategyId;
+        const accountId = id(args.account, 'account');
+        if (typeof accountId !== 'string')
+            return accountId;
+        if (args.mode !== undefined && args.mode !== 'real' && args.mode !== 'paper')
+            return { error: 'mode is real or paper' };
+        return { strategyId, accountId, mode: args.mode === 'paper' ? 'paper' : 'real' };
+    }
+    async limits(args) {
+        const c = this.limitsContext(args);
+        if ('error' in c)
+            return c;
+        const at = await import('../../autotrade/src/index.js');
+        const home = this.home();
+        const l = at.loadLimits(home);
+        const doc = l.ok ? l.doc : null;
+        const e = at.effectiveLimits(doc, c);
+        const risk = at.loadRiskState(home, this.now());
+        const ex = at.executorHealth(home, { now: this.now(), windowMin: e.values.executorSilenceMin ?? null });
+        return {
+            readOnly: true, context: c, applies: e.applies,
+            state: l.ok ? (l.source === 'migrated' ? 'migrated from caps.json' : l.unjournaled ? 'changed outside dexterm (a real run refuses it if it raises anything)' : 'saved by the user') : l.missing ? 'not set yet: placeholder defaults (real mode does not arm on them silently)' : 'unreadable: real buys are refused',
+            limits: at.LIMIT_FIELDS.map((f) => ({ key: f.key, group: f.group, unit: f.unit, kind: f.dir === 'max' ? 'cap (smaller is stricter)' : 'floor (larger is stricter)', value: e.values[f.key] ?? null, from: e.from[f.key] ?? null, placeholder: at.DEFAULT_LIMITS[f.key] ?? null, what: f.help })),
+            today: { day: risk.day, buys: risk.buys, buySol: risk.buySol, realizedSol: risk.dayPnlSol, lossStreak: risk.lossStreak, pausedUntil: iso(risk.pausedUntil), breaker: risk.breaker ? { at: iso(risk.breaker.at), drawdownSol: risk.breaker.drawdownSol } : null },
+            executor: at.healthLine(ex),
+            rules: 'Limits live outside the model. The effective number is the placeholder default replaced by the user\'s global value, then the STRICTER of every scope that sets it (mode, strategy, account). No tool changes them: limits_propose returns a diff card for the user to apply on their own terminal (raising needs their typed confirmation). The defaults are placeholders, not advice.',
+        };
+    }
+    async limitsPropose(args) {
+        const at = await import('../../autotrade/src/index.js');
+        const scope = typeof args.scope === 'string' ? args.scope : 'global';
+        const changes = args.changes;
+        if (!changes || typeof changes !== 'object' || Array.isArray(changes) || !Object.keys(changes).length || Object.keys(changes).length > 24)
+            return { error: 'changes is an object of 1 to 24 limits: { "perTradeSol": 0.1, "dailyLossSol": null }' };
+        // The agent's own reason is returned apart from the card, firewalled: the card is engine-made lines only.
+        const why = typeof args.why === 'string' ? fw(args.why.slice(0, 200), 'limits-why') : null;
+        const home = this.home();
+        const l = at.loadLimits(home);
+        const cur = l.ok ? l.doc : at.emptyLimits();
+        const next = structuredClone(cur);
+        delete next.migratedFrom;
+        const ref = at.scopeRef(next, scope, true);
+        if ('error' in ref)
+            return { error: ref.error };
+        for (const [k, v] of Object.entries(changes)) {
+            if (!at.limitField(k))
+                return { error: `unknown limit "${String(k).slice(0, 40)}"` };
+            if (v !== null && (typeof v !== 'number' || !Number.isFinite(v)))
+                return { error: `${k}: a number, or null to remove it` };
+            if (v === null && !ref.isGlobal)
+                delete ref.set[k];
+            else
+                ref.set[k] = v;
+        }
+        const issues = at.validateLimits(next);
+        if (issues.length)
+            return { error: issues.map((i) => `${i.path}: ${i.msg}`).join('; ').slice(0, 400) };
+        const diff = at.diffLimits(l.ok ? cur : null, next);
+        const up = at.raises(diff);
+        const assign = Object.entries(changes).map(([k, v]) => `${k}=${v === null ? 'off' : v}`).join(' ');
+        return {
+            applied: false, proposal: true,
+            card: [`PROPOSED LIMITS CHANGE · ${scope}`, ...diff.map((d) => `  ${at.changeLine(d)}`), up.length ? `  raises ${up.length} limit(s): you would type the confirmation on your own terminal` : '  lowers only: applies at once when you run it', `  to apply it yourself: dexterm autotrade limits set --scope ${scope} ${assign}`],
+            changes: diff, raises: up.length, why,
+            command: `dexterm autotrade limits set --scope ${scope} ${assign}`,
+            note: 'Nothing was changed: no tool can change a limit. Only the user applies this, on their own terminal.',
+        };
+    }
     // ───────────────────────────── backtest requests ─────────────────────────────
     requests() {
         const rs = new BacktestRequests(this.home()).list().slice(0, 20);

package/dist/packages/mcp/src/server.js

@@ -24,7 +24,7 @@ import { firewall } from "./firewall.js";
 import { OverlayStore, dextermHome, KB_RULE } from "./user-content.js";
 import { resolveSpectatorSink, readFollowScreen, FOLLOW_NAV_ACTIONS } from "./spectator-sink.js";
 import { resolvePaperAgentDesk } from "./paper-agent.js";
-import { AutotradeTools, AUTOTRADE_TOOLS, PARALLEL_CONTROL_TOOLS, PARALLEL_TOOLS, STRATEGY_PROPOSE_TOOLS } from "./autotrade-tools.js";
+import { AutotradeTools, AUTOTRADE_TOOLS, JOURNEY_CONTROL_TOOLS, JOURNEY_PROPOSE_TOOLS, JOURNEY_TOOLS, PARALLEL_CONTROL_TOOLS, PARALLEL_TOOLS, STRATEGY_PROPOSE_TOOLS } from "./autotrade-tools.js";
 import { LedgerTools, LEDGER_TOOLS, LEDGER_PROPOSE_TOOLS } from "./ledger-tools.js";
 import { loadAppHelp, getAppHelp, loadDocsKb, getDocs, searchHelp } from "./app-help.js";
 import { assembleTokenDossier, computeBoard, recentNarrativeRows, loadDefaultLexicon, summaryText, buildDigest, tokenRugScorer, h1Model, runBacktest } from '../../packs/src/index.js';
@@ -309,8 +309,16 @@ const TOOLS_RAW = [
     { name: 'strategy_validate', description: 'AUTOTRADE (paper): validate a whole dexterm-strategy/1 document: {ok, errors[{path,msg}], warnings[]}. Saves nothing.', inputSchema: { type: 'object', properties: { doc: { type: 'object' } }, required: ['doc'], additionalProperties: false } },
     { name: 'strategy_propose_edit', description: 'AUTOTRADE (paper): PROPOSE a change to one of the user\'s strategies as JSON-patch ops (add/replace/remove, at most 20) with a one-line why. Returns a proposal (diff lines, validation, riskDelta tighter/looser/neutral with the reasons). It is NEVER applied by this tool: the user applies it with a key on the Q screen, and a looser one needs a second key. /mode, /bankroll, /agent/budgetUsdPerDay and /execution/minExitLiquidityUsd are user-only and refused. Paper only.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, ops: { type: 'array', minItems: 1, maxItems: 20, items: { type: 'object', properties: { op: { type: 'string', enum: ['add', 'replace', 'remove'] }, path: { type: 'string', maxLength: 200 }, value: {} }, required: ['op', 'path'], additionalProperties: false } }, why: { type: 'string', maxLength: 200 } }, required: ['id', 'ops', 'why'], additionalProperties: false } },
     { name: 'strategy_propose_new', description: 'AUTOTRADE (paper): PROPOSE a new strategy copied from a preset (scalp, swing, runner, moonbag or another strategy id) under a new id and name, with optional JSON-patch ops (at most 20). Always paper. Same proposal shape as strategy_propose_edit; never applied by this tool (the user confirms it with a key).', inputSchema: { type: 'object', properties: { fromPreset: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, name: { type: 'string', maxLength: 80 }, ops: { type: 'array', maxItems: 20, items: { type: 'object', properties: { op: { type: 'string', enum: ['add', 'replace', 'remove'] }, path: { type: 'string', maxLength: 200 }, value: {} }, required: ['op', 'path'], additionalProperties: false } }, why: { type: 'string', maxLength: 200 } }, required: ['fromPreset', 'id', 'name'], additionalProperties: false } },
-    { name: 'strategy_backtest', description: 'AUTOTRADE (paper): backtest a strategy (`id`) or a pending proposal next to its current version (`proposalId`) on the RECORDED history, days <= 14 (default 7): P/L, win rate with its Wilson interval, max drawdown, exits, clamps and the data limits. Modelled fills, not a prediction; quote the trade count. Read-only (nothing is saved), one at a time and rate-limited.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, proposalId: { type: 'string', maxLength: 40 }, tape: { type: 'string', enum: ['recorded'] }, days: { type: 'integer', minimum: 1, maximum: 14 } }, additionalProperties: false } },
+    { name: 'strategy_backtest', description: 'AUTOTRADE (paper): backtest a strategy (`id`) or a pending proposal next to its current version (`proposalId`) on the RECORDED history, days <= 14 (default 7): P/L, win rate with its Wilson interval, max drawdown, exits, clamps and the data limits. With `id` it also runs the strategy on each half of the held-out split (the newest 30% of coins) and records that as the strategy\'s backtest evidence for its journey (`heldOut`: train, test, verdict; gain wording only when `claim` is true). Modelled fills, not a prediction; quote the trade count. Never changes a strategy; one at a time and rate-limited.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, proposalId: { type: 'string', maxLength: 40 }, tape: { type: 'string', enum: ['recorded'] }, days: { type: 'integer', minimum: 1, maximum: 14 } }, additionalProperties: false } },
     { name: 'autotrade_status', description: 'AUTOTRADE (paper): the paper runner\'s state from its status file (heartbeat, halt reason, candidates, sessions and spend, open positions), the number of strategies and the proposals waiting for the user. Read-only.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    // ---- THE JOURNEY (task-1647, 0.2.0 card C): draft -> backtested -> forward-tested -> always-on -> real. Paper forward
+    // tests with the strategy's own bankroll, and promotion PROPOSALS the user applies (always-on: y; real: their own caps
+    // and a typed phrase on their terminal). No tool applies a promotion, sets a cap, arms real mode or skips a rung.
+    { name: 'strategy_journey', description: 'AUTOTRADE: where one of the user\'s strategies stands on the ladder draft → backtested → forward-tested → always-on (paper service) → real: each rung, the evidence on these exact rules (a rule change starts the ladder again), what the next rung needs, any forward test running and the promotions waiting for the user. Read-only.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' } }, required: ['id'], additionalProperties: false } },
+    { name: 'strategy_forward_start', description: 'AUTOTRADE (paper): start a FORWARD TEST of one of the user\'s strategies: its current version on LIVE data, on paper, with the strategy\'s own bankroll and its own run file, in the background, for `hours` (0.25-72) and/or `trades` closed trades (1-200), whichever comes first (default 24 h). Needs a backtest with the held-out split first. One per strategy, three at once. Cannot set a bankroll, a cap or a mode, and never runs real.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, hours: { type: 'number', minimum: 0.25, maximum: 72 }, trades: { type: 'integer', minimum: 1, maximum: 200 } }, required: ['id'], additionalProperties: false } },
+    { name: 'strategy_forward_stop', description: 'AUTOTRADE (paper): stop a running forward test (by strategy `id` or `forwardId`). It flattens at its next tick and writes its report; a test stopped early is shown but does not count as the forward-tested rung.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, forwardId: { type: 'string', maxLength: 40 } }, additionalProperties: false } },
+    { name: 'strategy_forward_report', description: 'AUTOTRADE (paper): a forward test (by strategy `id` or `forwardId`): state, window, progress and, once it ends, its numbers next to the backtest of the same rules (trades, win rate with its interval, net, drawdown, rug rate, fill cost drift) with plain verdict lines; it says when a sample is too small to claim anything. Read-only.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, forwardId: { type: 'string', maxLength: 40 } }, additionalProperties: false } },
+    { name: 'strategy_promote_propose', description: 'AUTOTRADE: PROPOSE promoting one of the user\'s strategies one rung up the ladder: `to` "always-on" (the always-on paper service; needs a finished forward test) or "real" (LIVE TRADE FIRE signals to the user\'s own executor; needs always-on first AND the user\'s evidence floor: a completed forward test of these exact rules with their minimum of closed paper trades, plus a backtest; below it nothing is proposed). Returns a proposal with an evidence card. It is NEVER applied by this tool and no rung can be skipped: the user applies always-on with a key, and real only with their own caps and a typed phrase on their own terminal. Cannot set caps, a bankroll or a mode.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, to: { type: 'string', enum: ['always-on', 'real'] }, why: { type: 'string', maxLength: 200 } }, required: ['id', 'to', 'why'], additionalProperties: false } },
     // ---- PARALLEL STRATEGIES (task-1529). Paper only. Two reads, and start / stop / pause of ONE strategy the user listed in
     // autotrade.json (a per-strategy control file). A tool can never add a strategy, change a bankroll or a cap, or go live.
     { name: 'autotrade_parallel_list', description: 'AUTOTRADE (paper): the strategies the user listed for parallel runs (autotrade.json: id, the preset it is based on, bankroll or shared paper account, enabled; the paper accounts several strategies trade from) and, while `dexterm autotrade run --all --paper` runs, each one\'s state (running / paused / halted / stopped), open positions, candidates and sessions. Read-only.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
@@ -320,16 +328,19 @@ const TOOLS_RAW = [
     // ---- TRADE LEDGER + neighbours (task-1530). Reads of the unified trade ledger (paper, desk, autotrade, live), a run's
     // record of a candidate, the recorder's outcome labels, the Telegram and live-signer STATE (never a key, an address or
     // an exact balance), and one PROPOSE tool: a backtest request the user runs or dismisses. None can trade or change a cap.
-    { name: 'ledger_trades', description: 'TRADE LEDGER: trades from the unified ledger (one row per round trip, every source: paper, the agent paper desk, autotrade runs, the live signer), newest first: strategy id+version+hash, profile and entry reason (with where each came from: structured, rule, tag-line, late, default, missing), exit reason, size SOL/USD and % of book, entry/exit price AND market cap, fees, impact, slippage, hold time, MFE/MAE, rug flag, wallet mode, tx signatures (live), model session ids and cost. `fills: true` adds each fill. Read-only. PAPER rows are simulated: never present them as results.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' }, status: { type: 'string', enum: ['open', 'closed'] }, limit: { type: 'integer', minimum: 1, maximum: 200 }, fills: { type: 'boolean' } }, additionalProperties: false } },
-    { name: 'ledger_positions', description: 'TRADE LEDGER: the open trades (cost, % of book, held time, profile, entry reason) from the unified ledger. No price fetch and no wallet balance: call get_token for a price. Read-only.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' }, limit: { type: 'integer', minimum: 1, maximum: 200 } }, additionalProperties: false } },
-    { name: 'ledger_equity', description: 'TRADE LEDGER: the realized equity curve (cumulative P/L by close, in SOL when every trade has a SOL figure, else USD) with its max drawdown, at most 200 points. Read-only.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' } }, additionalProperties: false } },
-    { name: 'ledger_summary', description: 'TRADE LEDGER: win rate with its 95% interval, P/L, profit factor, max drawdown, rug rate, average hold, MFE/MAE, fees, model cost, how many trades declared their profile / exit, and breakdowns by profile, exit reason, strategy, source and wallet mode. Read-only; small n means little.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' } }, additionalProperties: false } },
-    { name: 'ledger_compare', description: 'TRADE LEDGER: one row per strategy version (id@version) side by side: trades, win rate with interval, P/L, drawdown, rug rate, hold, MFE/MAE, model cost. The forward-test table for strategies run in parallel. Read-only.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' } }, additionalProperties: false } },
+    { name: 'ledger_trades', description: 'TRADE LEDGER: trades from the unified ledger (one row per round trip, every source: paper, the agent paper desk, autotrade runs, the live signer), newest first: strategy id+version+hash, profile and entry reason (with where each came from: structured, rule, tag-line, late, default, missing), exit reason, size SOL/USD and % of book, entry/exit price AND market cap, fees, impact, slippage, hold time, MFE/MAE, rug flag, wallet mode, tx signatures (live), model session ids and cost. `fills: true` adds each fill. Read-only. PAPER rows are simulated: never present them as results.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' }, status: { type: 'string', enum: ['open', 'closed'] }, limit: { type: 'integer', minimum: 1, maximum: 200 }, fills: { type: 'boolean' } }, additionalProperties: false } },
+    { name: 'ledger_positions', description: 'TRADE LEDGER: the open trades (cost, % of book, held time, profile, entry reason) from the unified ledger. No price fetch and no wallet balance: call get_token for a price. Read-only.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' }, limit: { type: 'integer', minimum: 1, maximum: 200 } }, additionalProperties: false } },
+    { name: 'ledger_equity', description: 'TRADE LEDGER: the realized equity curve (cumulative P/L by close, in SOL when every trade has a SOL figure, else USD) with its max drawdown, at most 200 points. Read-only.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' } }, additionalProperties: false } },
+    { name: 'ledger_summary', description: 'TRADE LEDGER: win rate with its 95% interval, P/L, profit factor, max drawdown, rug rate, average hold, MFE/MAE, fees, model cost, how many trades declared their profile / exit, and breakdowns by profile, exit reason, strategy, source and wallet mode. Read-only; small n means little.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' } }, additionalProperties: false } },
+    { name: 'ledger_compare', description: 'TRADE LEDGER: one row per strategy version (id@version) side by side: trades, win rate with interval, P/L, drawdown, rug rate, hold, MFE/MAE, model cost. The forward-test table for strategies run in parallel. Read-only.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'], description: 'Where the trade was booked: paper (the TUI ticket), desk (the agent paper desk), autotrade (a run), live (the signer).' }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, description: 'A strategy id, id@version or id@hash-prefix; manual for trades with no strategy.' }, profile: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, exit_reason: { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$' }, mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, account: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', description: 'A shared paper account id (autotrade.json accounts): the trades of the strategies on it.' }, days: { type: 'number', minimum: 0, maximum: 3650, description: 'Only trades opened in the last N days.' } }, additionalProperties: false } },
     { name: 'candidate_dossier', description: 'AUTOTRADE: what a run recorded about one candidate coin: the entry rules it matched, the tick at the time, the session\'s decisions (action, profile, reason), the size clamp, the fills and how the trade closed. The newest run that saw the coin, or `run_id`. Read-only; for the coin as it is now call get_dossier.', inputSchema: { type: 'object', properties: { mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 } }, required: ['mint'], additionalProperties: false } },
     { name: 'outcomes_lookup', description: 'The recorder\'s outcome labels (rug, dead, fade, flat, runner, unobserved, by horizon, with the market-cap / liquidity / price ratios) for a coin (`mint`), or for every candidate of an autotrade run (`run_id`: what the entries and the skips turned into). Code-only labels from recorded numbers, not predictions. Read-only.', inputSchema: { type: 'object', properties: { mint: { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$' }, run_id: { type: 'string', maxLength: 64 }, limit: { type: 'integer', minimum: 1, maximum: 100 } }, additionalProperties: false } },
     { name: 'telegram_status', description: 'The Telegram connector\'s settings: set up or not, enabled, how many chats are paired, the tiers (notify / control / approve), whether entries need a one-tap approval, the notify choices and quiet hours. Never the bot token or any chat or sender id. Read-only: only local commands change it.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
-    { name: 'trading_status', description: 'Where trading happens: dexterm trades on PAPER only and holds no key, signs nothing and places no live order (live trading happens in the Telegram trading bot the user chose), and whether the panic switch is engaged. Read-only.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'trading_status', description: 'Where trading happens: dexterm trades on PAPER and holds no key, signs nothing and places no live order (live trading happens in the Telegram trading bot or script the user chose; in real mode dexterm sends it LIVE TRADE FIRE signals), whether the panic switch is engaged, and how many strategies the user armed for real mode. Read-only.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'trade_fire_feed', description: 'Real mode\'s MCP channel: the LIVE TRADE FIRE signals (schema dexterm-trade-fire/1: buy/sell, mint, sanitized symbol, size in SOL and % of book, price context, exit reason, strategy, run, account, nonce, expiry) after `after_nonce`, plus real mode\'s status (armed strategies, kill switch, caps). For the user\'s own executor: act only on your accountId, ignore expired signals, dedupe by nonce. Read-only: no tool arms real mode, changes a cap or lifts the kill switch.', inputSchema: { type: 'object', properties: { after_nonce: { type: 'integer', minimum: 0 }, limit: { type: 'integer', minimum: 1, maximum: 100 } }, additionalProperties: false } },
     { name: 'backtest_requests', description: 'The backtest requests filed with backtest_request, their status (pending, done, failed, dismissed) and the result line once the user ran one. Read-only.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'trading_limits', description: 'Real mode\'s limits in force (task-1654) for a strategy / account / mode: every limit (sizing, risk, the optional sell rate, executor silence), its number, which scope set it (placeholder default, global, mode, strategy, account; the stricter wins), what it does, today\'s counters, the breaker and the executor\'s health. Read-only: explain them; to suggest a change use limits_propose. No tool changes a limit.', inputSchema: { type: 'object', properties: { strategy: { type: 'string', pattern: '^[a-z0-9][a-z0-9._-]{0,63}$' }, account: { type: 'string', pattern: '^[a-z0-9][a-z0-9._-]{0,63}$' }, mode: { type: 'string', enum: ['real', 'paper'] } }, additionalProperties: false } },
+    { name: 'limits_propose', description: 'PROPOSE a change to real mode\'s limits as a diff card: old -> new per limit, which ones it raises, and the exact `dexterm autotrade limits set` command for the user. It writes NOTHING and applies nothing: only the user can change a limit, on their own terminal, and raising one needs their typed confirmation. scope: global, real, paper, strategy:<id> or account:<id>; changes: { limitName: number, or null to remove/turn off }.', inputSchema: { type: 'object', properties: { scope: { type: 'string', maxLength: 80 }, changes: { type: 'object', additionalProperties: { type: ['number', 'null'] } }, why: { type: 'string', maxLength: 200 } }, required: ['changes'], additionalProperties: false } },
     { name: 'backtest_request', description: 'PROPOSE a longer backtest than strategy_backtest allows: a stored strategy `id` over the last `days` (1 to 60) of recorded history, optionally every candidate, with a one-line why. Writes a request the user runs (`dexterm autotrade requests run <id>`) or dismisses; nothing runs here. Read the result with backtest_requests. Cannot change a strategy, a cap or a mode.', inputSchema: { type: 'object', properties: { id: { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$' }, days: { type: 'integer', minimum: 1, maximum: 60 }, every_candidate: { type: 'boolean' }, why: { type: 'string', maxLength: 200 } }, required: ['id', 'why'], additionalProperties: false } },
 ];
 /**
@@ -351,7 +362,7 @@ const PAPER_TOOLS = new Set([...PAPER_WRITE_TOOLS, ...PAPER_READ_TOOLS, ...PAPER
  * request (task-1530, they write a journal line / a request file). The only tools a skill may name
  * (task-1377); the paper read tools and the strategy read tools stay here (they cannot trade or change anything).
  */
-export const READ_ONLY_TOOLS = TOOLS.map((t) => String(t.name)).filter((n) => !ANALYST_ACTION_TYPES.includes(n) && !PAPER_WRITE_TOOLS.includes(n) && !STRATEGY_PROPOSE_TOOLS.includes(n) && !PARALLEL_CONTROL_TOOLS.includes(n) && !PAPER_NOTE_TOOLS.includes(n) && !LEDGER_PROPOSE_TOOLS.includes(n));
+export const READ_ONLY_TOOLS = TOOLS.map((t) => String(t.name)).filter((n) => !ANALYST_ACTION_TYPES.includes(n) && !PAPER_WRITE_TOOLS.includes(n) && !STRATEGY_PROPOSE_TOOLS.includes(n) && !PARALLEL_CONTROL_TOOLS.includes(n) && !JOURNEY_CONTROL_TOOLS.includes(n) && !JOURNEY_PROPOSE_TOOLS.includes(n) && !PAPER_NOTE_TOOLS.includes(n) && !LEDGER_PROPOSE_TOOLS.includes(n));
 const SKILL_STORE = new OverlayStore({ kind: 'skill', bundled: [{ dir: SKILLS_DIR, layout: 'flat' }], readTools: READ_ONLY_TOOLS, home: () => dextermHome(process.env), onSkip: logSkip('skill') });
 /** Read the action allow-list the CLI put in screen_state.actions (defensive: any shape → empty lists). */
 function allowFrom(screenState) {
@@ -737,7 +748,7 @@ export class McpTools {
         if (PAPER_TOOLS.has(name))
             return this.paperTool(name, args);
         // task-1507: the AUTOTRADE strategy tools (reads + proposals; the user's keypress applies a proposal, never a tool)
-        if (AUTOTRADE_TOOLS.includes(name) || PARALLEL_TOOLS.includes(name))
+        if (AUTOTRADE_TOOLS.includes(name) || PARALLEL_TOOLS.includes(name) || JOURNEY_TOOLS.includes(name))
             return (this.autotrade ??= new AutotradeTools({ actor: this.channel ? 'analyst' : 'mcp-agent', historyDb: () => this.historyDb() })).call(name, args);
         // task-1530: the trade ledger reads, a run's candidate record, outcomes, Telegram / trading STATE, backtest requests
         if (LEDGER_TOOLS.includes(name)) {

package/dist/packages/tui/src/keymap.js

@@ -388,4 +388,11 @@ export const DEFAULT_KEYMAP = new Keymap([
     { keys: ['p'], action: 'autotrade.pause', label: 'pause new entries', screen: 'autotrade' },
     { keys: ['f'], action: 'autotrade.flatten', label: 'flatten (confirm)', screen: 'autotrade' },
     { keys: ['o'], action: 'autotrade.proposal', label: 'review chat proposal', screen: 'autotrade' },
+    // task-1647: a strategy's JOURNEY (draft → backtested → forward-tested → always-on → real). F starts a 24 h paper forward
+    // test (live data, the strategy's own bankroll), X stops it, A opens a pending always-on promotion (y applies). Real is
+    // never applied from a key: it needs the user's caps and a typed phrase on a terminal.
+    { keys: ['J'], action: 'autotrade.journey', label: 'journey (ladder)', screen: 'autotrade' },
+    { keys: ['F'], action: 'autotrade.forward', label: 'forward test (paper)', screen: 'autotrade' },
+    { keys: ['X'], action: 'autotrade.forwardstop', label: 'stop forward test', screen: 'autotrade' },
+    { keys: ['A'], action: 'autotrade.promote', label: 'review promotion', screen: 'autotrade' },
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dexterm-cli",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "mcpName": "io.github.dexterm-xyz/dexterm",
   "description": "dexterm: terminal DEX screener with a local Claude CLI analyst",
   "author": "The dexterm authors",