dexterm-cli 0.1.7 → 0.2.0

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

@@ -1,4 +1,5 @@
-// `dexterm autotrade <sub>` (task-1503 AT-1, AUTOTRADE-SPEC). PAPER ONLY: no keys, no wallet, no signer.
+// `dexterm autotrade <sub>` (task-1503 AT-1, AUTOTRADE-SPEC). No keys, no wallet, no signer: paper, or real mode
+// (task-1645: trade-fire signals to the user's own executor, `signal` / `receipt` rows).
 //
 // A dispatcher table: each subcommand is one row that lazy-loads its own module under ./autotrade-cmd/, so
 // later cards add a row (run, service, stop, flatten, audit) without editing anyone else's lines.
@@ -55,8 +56,8 @@ export const SUBCOMMANDS = {
         load: () => import("./autotrade-cmd/requests.js").then((m) => m.requestsCmd),
     },
     run: {
-        usage: 'dexterm autotrade run <id|file> --paper [--replay TAPE [--ms-per-tick 2000]] [--model M] [--max-minutes N] [--stub] [--raw] [--quiet] [--no-telegram]',
-        summary: 'the paper runner: the screener hands each candidate to your own Claude (runner.json picks the account), every size clamped; ledger in autotrade/runs/; your paired Telegram bot starts with it (dexterm telegram setup)',
+        usage: 'dexterm autotrade run <id|file> --paper|--real [--replay TAPE [--ms-per-tick 2000]] [--model M] [--max-minutes N] [--sol-usd N] [--stub] [--raw] [--quiet] [--no-telegram]',
+        summary: 'the runner: the screener hands each candidate to your own Claude (runner.json picks the account), every size clamped; ledger in autotrade/runs/; your paired Telegram bot starts with it (dexterm telegram setup). --real (a strategy you armed with signal arm) runs in the FOREGROUND only, on live data: the always-on service runs paper strategies, and while no real run is running NO signal goes out, sells included',
         load: () => import("./autotrade-cmd/run.js").then((m) => m.runCmd),
     },
     'run --all': {
@@ -99,6 +100,51 @@ export const SUBCOMMANDS = {
         summary: 'list the run ledgers; --verify recomputes each hash chain and names the first edited, missing or reordered event',
         load: () => import("./autotrade-cmd/audit.js").then((m) => m.auditCmd),
     },
+    signal: {
+        usage: 'dexterm autotrade signal status|channels|secret|arm|disarm|caps|kill|unkill|held|release|test|flush|tail|reconcile …',
+        summary: 'real mode: a LIVE TRADE FIRE signal per trade to YOUR executor (webhook, --signal-cmd, JSONL, MCP, Telegram copy); arm on your own terminal; hard caps, kill switch; dexterm holds no key',
+        load: () => import("./autotrade-cmd/signal.js").then((m) => m.signalCmd),
+    },
+    receipt: {
+        usage: 'dexterm autotrade receipt <nonce|id> executed|rejected|failed [--price USD] [--size-sol N] [--tokens N] [--tx SIG] [--reason TEXT] | receipt list [--json]',
+        summary: 'what your executor did with a trade-fire signal, as data only (positions stay unconfirmed until a receipt); the drift between signals and fills',
+        load: () => import("./autotrade-cmd/receipt.js").then((m) => m.receiptCmd),
+    },
+    service: {
+        usage: 'dexterm autotrade service install|uninstall|ensure|run|start|stop|status|logs [--home PATH]',
+        summary: 'the always-on service: your PAPER strategies (autotrade.json) start at login, restart after a crash, stop on any kill switch and tell you when they cannot run; real mode does not run under it (run --real, in the foreground)',
+        load: () => import("./autotrade-cmd/service.js").then((m) => m.serviceCmd),
+    },
+    forward: {
+        usage: 'dexterm autotrade forward start <id> [--hours H] [--trades N] [--bankroll-usd N] | status [<id>] | stop <id> | report <id> [--json]',
+        summary: 'forward test: the strategy on the LIVE tape, on paper, own bankroll and run file, for hours or N trades; the report sets it next to its backtest',
+        load: () => import("./autotrade-cmd/forward.js").then((m) => m.forwardCmd),
+    },
+    journey: {
+        usage: 'dexterm autotrade journey [<id>] [--json]',
+        summary: 'where a strategy stands on the ladder draft → backtested → forward-tested → always-on → real, and what the next rung needs',
+        load: () => import("./autotrade-cmd/journey.js").then((m) => m.journeyCmd),
+    },
+    promote: {
+        usage: 'dexterm autotrade promote <id> --to always-on|real | list | show <pp-id> | apply <pp-id> | dismiss <pp-id>',
+        summary: 'a promotion with its evidence card: always-on needs your y on a real terminal; real needs the evidence floor (a completed forward test with minForwardTrades closed paper trades + a backtest) and hands over to signal arm (your caps, a typed phrase); no rung is skipped',
+        load: () => import("./autotrade-cmd/journey.js").then((m) => m.promoteCmd),
+    },
+    limits: {
+        usage: 'dexterm autotrade limits show|set|diff|reset|accept|breaker reset|explain|schema …',
+        summary: 'real mode: every limit is yours (per trade SOL or % of book, per day, open positions, exposure, loss limits, breaker, rate, slippage, TTL, executor silence), global / per mode / per strategy / per account, the stricter wins; raising is typed on your own terminal',
+        load: () => import("./autotrade-cmd/limits.js").then((m) => m.limitsCmd),
+    },
+    executor: {
+        usage: 'dexterm autotrade executor status [--json] | heartbeat [--name N] [--account ID] [--dry-run] [--nonce N] | kit --out DIR',
+        summary: 'real mode: is YOUR executor alive (heartbeat, last receipt, lag)? A silent executor pauses new buy signals; `kit --out DIR` copies the dry-run reference executors (webhook, signal-cmd, JSONL tail)',
+        load: () => import("./autotrade-cmd/executor.js").then((m) => m.executorCmd),
+    },
+    report: {
+        usage: 'dexterm autotrade report [--period day|week] [--strategy ID] [--json] [--telegram]',
+        summary: 'the digest per strategy and mode: trades, win rate with its interval, net, drawdown, refusals, limits hit, executor health, paper vs real fills, an honest small-sample note',
+        load: () => import("./autotrade-cmd/report.js").then((m) => m.reportCmd),
+    },
     extract: {
         usage: 'dexterm autotrade extract --out FILE [--db PATH] [--max-mints N] [--min-peak-liq USD] [--span-hours H]',
         summary: 'save a replay tape from your recorder history (read-only) to a file you can backtest offline',
@@ -107,7 +153,7 @@ export const SUBCOMMANDS = {
 };
 export function autotradeHelp() {
     return [
-        'dexterm autotrade: strategies, backtests and the paper runner. PAPER ONLY, not financial advice.',
+        'dexterm autotrade: strategies, backtests and the runner. PAPER by default; mode real sends a LIVE TRADE FIRE signal per trade to YOUR executor (`signal arm`, on your own terminal; dexterm holds no key). Not financial advice.',
         '',
         ...Object.values(SUBCOMMANDS).map((s) => `  ${s.usage}\n      ${s.summary}`),
         '',

package/dist/packages/cli/src/ledger-cmd.js

@@ -20,7 +20,7 @@ export const LEDGER_HELP = `dexterm ledger: the unified trade ledger (paper, age
   dexterm ledger sync [--json]                                append what the sources hold to the ledger file
   dexterm ledger verify [--json]                              recompute the ledger file's sha256 chain
 
-  filters: --source paper|desk|autotrade|live  --mode paper|devnet|live  --strategy ID[@VERSION|@HASH]  --profile P
+  filters: --source paper|desk|autotrade|live  --mode paper|devnet|live|real  --strategy ID[@VERSION|@HASH]  --profile P
            --exit REASON  --mint MINT  --run RUN_ID  --account ID  --days N  --status open|closed  --wallet-db PATH
 
   The file is $DEXTERM_HOME/ledger/trades.jsonl (default ~/.dexterm). PAPER rows are simulated; filter by --mode
@@ -95,9 +95,11 @@ function banner(v, rows) {
             out.push(`  ! ${s.problem}`);
     const modes = [...new Set(rows.map((t) => t.walletMode))];
     if (modes.length > 1)
-        out.push('  PAPER, DEVNET and LIVE trades are mixed here: use --mode before comparing results.');
+        out.push('  PAPER, REAL, DEVNET and LIVE trades are mixed here: use --mode before comparing results.');
     else if (modes[0] === 'paper')
         out.push('  PAPER (simulated) trades.');
+    else if (modes[0] === 'real')
+        out.push('  REAL-mode trades: dexterm modelled the trades it signalled to your executor; your executor\'s receipts are the real fills.');
     return out;
 }
 function tradesTable(rows) {

package/dist/packages/cli/src/pnl-card.js

@@ -138,6 +138,10 @@ export function autotradeCardInput(events, o) {
  * needs `solUsd`; a fill with no token amount refuses the card rather than guess.
  */
 export function ledgerCardInput(row, o = {}) {
+    // task-1655: a real-mode row is dexterm's model of a trade it signalled; the real fill is the executor's receipt.
+    // A card would stamp it PAPER or LIVE, and both are wrong, so there is none.
+    if (row.walletMode === 'real')
+        throw new CardError('a real-mode trade: dexterm only modelled this fill (the signal it sent your executor); your executor\'s receipt is the record, so dexterm makes no card for it');
     const decimals = row.decimals ?? 6;
     const usdDesk = row.fills.some((f) => f.sol === null);
     if (usdDesk && !(o.solUsd && o.solUsd.usd > 0))

package/dist/packages/cli/src/screens/autotrade-journey.js

@@ -0,0 +1,134 @@
+// dexterm — the AUTOTRADE screen's JOURNEY view (`Q`, then `J` on a strategy; 0.2.0 card C). One strategy's ladder:
+// draft → backtested → forward-tested → always-on (paper) → real, with the last backtest (held-out split), the forward
+// test (running or its result next to the backtest), the always-on service membership and the mode.
+//
+// Keys on the view: `b` backtests (recorded as evidence), `F` starts a 24 h forward test (paper, live data, the
+// strategy's own bankroll, in the background), `X` stops it, `A` opens the pending ALWAYS-ON promotion's card (y
+// applies it: autotrade.json gets the paper member). A promotion to REAL is never applied here: it needs the user's own
+// caps and the typed phrase on a terminal (`dexterm autotrade promote apply <pp-id>`). Nothing here reaches a wallet,
+// a key, a mandate or the signer.
+import { dirname } from 'node:path';
+import { PromotionFiles, applyAlwaysOn, createForwardTest, findForwardTest, forwardReport, journeyView, liveState, loadArmings, requestForwardStop, saveForwardTest, windowText, } from '../../../autotrade/src/index.js';
+import { spawnForwardHost } from "../autotrade-cmd/forward.js";
+export const defaultForwardSpawn = (home, t) => spawnForwardHost(home, t, process.env);
+const homeOf = (ui) => dirname(ui.deps.store.dir);
+export function openJourney(ui, id) {
+    if (!id)
+        return 'no strategy selected';
+    ui.journey = { id, view: null, error: null, forward: null, report: null, pending: [], readAt: 0 };
+    ui.view = 'journey';
+    refreshJourney(ui, true);
+    return ui.journey.error;
+}
+/** Re-read the journey (at most every 2 s unless forced): evidence, forward test, pending promotions. */
+export function refreshJourney(ui, force = false) {
+    const j = ui.journey;
+    if (!j)
+        return;
+    const now = ui.deps.now();
+    if (!force && now - j.readAt < 2000)
+        return;
+    j.readAt = now;
+    const home = homeOf(ui);
+    const got = ui.deps.store.get(j.id);
+    if (!got || !got.ok) {
+        j.view = null;
+        j.error = got ? `${j.id} does not validate` : `no strategy ${j.id}`;
+        return;
+    }
+    try {
+        j.view = journeyView(home, got.strategy, { armedHash: loadArmings(home)[j.id]?.strategyHash ?? null });
+        j.forward = findForwardTest(home, j.id, now);
+        j.report = j.forward ? forwardReport(home, j.forward, now) : null;
+        j.pending = new PromotionFiles(home).list({ status: 'pending', id: j.id });
+        j.error = null;
+    }
+    catch (e) {
+        j.error = `journey unreadable: ${e.message}`;
+    }
+}
+/** `F`: a 24 h forward test of this version, on paper, live data, its own bankroll, started in the background. */
+export function journeyForward(ui) {
+    const j = ui.journey;
+    if (!j)
+        return 'F starts a forward test from the journey view (J)';
+    const got = ui.deps.store.get(j.id);
+    if (!got || !got.ok)
+        return `no valid strategy ${j.id}`;
+    if (got.source !== 'user')
+        return `${j.id} is a preset: copy it first (d)`;
+    const home = homeOf(ui);
+    const c = createForwardTest(home, got.strategy, ui.deps.store.raw(j.id), { hours: 24, by: 'user:tui', now: ui.deps.now() });
+    if (!c.ok)
+        return c.why;
+    const pid = (ui.deps.forwardSpawn ?? defaultForwardSpawn)(home, c.test);
+    if (!pid) {
+        saveForwardTest(home, { ...c.test, state: 'failed', endedAt: ui.deps.now(), endReason: 'could not start the host' });
+        return `could not start it; in a terminal: dexterm autotrade forward start ${j.id}`;
+    }
+    refreshJourney(ui, true);
+    return `forward test ${c.test.forwardId} started · ${windowText(c.test.window)} · paper, live data, own bankroll $${c.test.bankrollUsd} · X stops it`;
+}
+/** `X`: stop the running forward test (it flattens and writes its report; an early stop does not count). */
+export function journeyStopForward(ui) {
+    const j = ui.journey;
+    if (!j)
+        return 'X stops a forward test from the journey view (J)';
+    const t = findForwardTest(homeOf(ui), j.id, ui.deps.now());
+    if (!t)
+        return 'no forward test';
+    const r = requestForwardStop(homeOf(ui), t.forwardId, 'tui', ui.deps.now());
+    refreshJourney(ui, true);
+    return r.ok ? `${r.already ? 'already stopping' : 'stop requested'}: ${t.forwardId} flattens and writes its report (an early stop does not count)` : r.why;
+}
+/** `A`: open the pending always-on promotion's confirm card (y applies). Real is a terminal-only step. */
+export function journeyPromote(ui) {
+    const j = ui.journey;
+    if (!j)
+        return 'A applies a promotion from the journey view (J)';
+    refreshJourney(ui, true);
+    const p = j.pending.find((x) => x.to === 'always-on');
+    if (p) {
+        ui.confirm = { kind: 'promote', proposalId: p.proposalId };
+        return `promotion ${p.proposalId} → always-on (proposed by ${p.actor}): y applies, any key cancels`;
+    }
+    const real = j.pending.find((x) => x.to === 'real');
+    if (real)
+        return `real mode is armed only on your own terminal with your caps and a typed phrase: dexterm autotrade promote apply ${real.proposalId}`;
+    return j.view?.next?.stage === 'always-on' ? `nothing pending: ask the analyst to propose it, or in a terminal: dexterm autotrade promote ${j.id} --to always-on` : 'no promotion pending';
+}
+/** The y / any-key answer on the promotion card. */
+export function confirmPromote(ui, proposalId, yes) {
+    if (!yes)
+        return 'promotion not applied (it stays pending)';
+    const j = ui.journey;
+    const got = j ? ui.deps.store.get(j.id) : null;
+    if (!got || !got.ok)
+        return 'the strategy is not valid any more';
+    const a = applyAlwaysOn(homeOf(ui), proposalId, got.strategy, { by: 'user:tui', now: ui.deps.now() });
+    refreshJourney(ui, true);
+    return a.ok ? `applied: ${got.strategy.id} is an always-on paper member (${a.memberId}); the service runs it from its next start` : `not applied: ${a.why}`;
+}
+export function journeyLines(j, now) {
+    if (j.error || !j.view)
+        return [{ text: j.error ?? 'loading…', tone: 'warn' }];
+    const v = j.view;
+    const out = [
+        { text: `${v.id} v${v.version} · rules ${v.rulesHash.slice(0, 8)} · mode ${v.mode} · stage ${v.stage.toUpperCase()}`, tone: 'text' },
+        { text: '', tone: 'dim' },
+        ...v.rungs.map((r) => ({ text: `${r.ok ? '[x]' : '[ ]'} ${r.stage.padEnd(15)} ${r.detail}`, tone: (r.ok ? 'ok' : 'dim') })),
+        ...v.notes.map((n) => ({ text: `!  ${n}`, tone: 'warn' })),
+        { text: v.next ? `next: ${v.next.stage} — ${v.next.how}` : 'top of the ladder: real (caps, kill switch, receipts: dexterm autotrade signal status)', tone: 'text' },
+        { text: '', tone: 'dim' },
+    ];
+    if (j.forward && j.report) {
+        const st = liveState(j.forward, now);
+        out.push({ text: `forward test ${j.forward.forwardId} · ${st.toUpperCase()} · ${windowText(j.forward.window)}`, tone: st === 'running' || st === 'starting' ? 'warn' : 'text' });
+        for (const l of j.report.lines.slice(1))
+            out.push({ text: l.replace(/^  /, ''), tone: 'text' });
+        out.push({ text: '', tone: 'dim' });
+    }
+    for (const p of j.pending)
+        out.push({ text: `pending promotion ${p.proposalId} → ${p.to} (proposed by ${p.actor})${p.to === 'always-on' ? ' · A to review' : ' · terminal only: dexterm autotrade promote apply'}`, tone: 'warn' });
+    return out;
+}

package/dist/packages/cli/src/screens/autotrade-keys.js

@@ -4,6 +4,7 @@
 // strategy files; nothing here reaches a wallet, a key, a mandate or the signer.
 import { INPUT_MAX, backtestSubject, beginFieldEdit, beginImport, beginNew, commitInput, commitTyping, confirmKey, exportSelected, nextView, openEditor, reloadList, refreshRunner, revalidateTyping, runnerVerb, saveEditor, selectedEntry, startBacktest, startCompareBacktest, startSweep, toggleMark, undoEditor, } from "./autotrade-ui.js";
 import { openReview, reviewKey } from "./autotrade-proposals.js";
+import { journeyForward, journeyPromote, journeyStopForward, openJourney, refreshJourney } from "./autotrade-journey.js";
 const PRINTABLE = (k) => (k.name === 'space' ? ' ' : k.name === 'char' && k.ch && !k.ctrl && !k.alt && !/[\u0000-\u001f\u007f]/.test(k.ch) ? k.ch : null);
 /** A captured key (input line, field value or confirm). Returns true when the key was consumed. */
 export function autotradeKey(ui, key) {
@@ -135,6 +136,8 @@ export function autotradeAction(ui, action) {
         case 'autotrade.save': return say(ui.view === 'editor' ? saveEditor(ui) : 's saves in the editor');
         case 'autotrade.undo': return say(ui.view === 'editor' ? undoEditor(ui) : 'u undoes in the editor');
         case 'autotrade.backtest': {
+            if (ui.view === 'journey' && ui.journey)
+                return say(startBacktest(ui, ui.journey.id));
             if (ui.view === 'compare')
                 return say(startCompareBacktest(ui));
             if (ui.view === 'editor' && ui.editor)
@@ -150,6 +153,16 @@ export function autotradeAction(ui, action) {
             return say(id ? startSweep(ui, id) : 'no strategy selected');
         }
         case 'autotrade.proposal': return say(ui.view === 'list' ? openReview(ui) || null : 'o reviews chat proposals on the strategies list (esc)');
+        // task-1647: the journey view
+        case 'autotrade.journey':
+            if (ui.view === 'journey') {
+                refreshJourney(ui, true);
+                return say(null);
+            }
+            return say(openJourney(ui, ui.view === 'editor' ? ui.editor?.id : ui.view === 'backtest' ? backtestSubject(ui)?.id : e?.id));
+        case 'autotrade.forward': return say(ui.view === 'journey' ? journeyForward(ui) : 'F starts a forward test on the journey view (J)');
+        case 'autotrade.forwardstop': return say(ui.view === 'journey' ? journeyStopForward(ui) : 'X stops a forward test on the journey view (J)');
+        case 'autotrade.promote': return say(ui.view === 'journey' ? journeyPromote(ui) : 'A reviews a promotion on the journey view (J)');
         case 'autotrade.run':
             ui.view = 'runner';
             refreshRunner(ui);

package/dist/packages/cli/src/screens/autotrade-screen.js

@@ -5,6 +5,7 @@ import { Canvas, header, footer, breakpoint, fmtAgeSec, sparkline, wrap } from '
 import { compareRows as fleetCompareRows, compareTable as fleetCompareTable, fleetTotals } from '../../../autotrade/src/index.js';
 import { tokenize } from "../screener/filter.js";
 import { headerModel } from "../state.js";
+import { journeyLines, refreshJourney } from "./autotrade-journey.js";
 import { AUTOTRADE_VIEWS, VIEW_TITLE, READ_ONLY_PATHS, backtestSubject, compareRows, getAt, heartbeatStale, issuesByField, screenHighlight, } from "./autotrade-ui.js";
 /** Per-screen memo of file reads + validation, keyed by what the list says about a strategy (id, hash, version,
  *  last backtest): a frame never re-reads a strategy file; a save, import or backtest reloads the list and so the key. */
@@ -46,10 +47,14 @@ export function renderAutotrade(c, state) {
         renderCompare(c, ui, area);
     else if (ui.view === 'backtest')
         renderBacktest(c, ui, area, now);
+    else if (ui.view === 'journey')
+        renderJourneyView(c, ui, area, now);
     else
         renderRunner(c, ui, area, now);
-    if (ui.confirm)
+    if (ui.confirm?.kind === 'flatten')
         confirmCard(c);
+    else if (ui.confirm?.kind === 'promote')
+        promoteCard(c, ui, ui.confirm.proposalId);
     if (ui.review)
         reviewCard(c, ui);
     footer(c, hintsFor(ui), t.name);
@@ -68,6 +73,8 @@ function tabs(c, ui) {
         const off = (v === 'compare' && !ui.compare) || (v === 'editor' && !ui.editor);
         x = c.text(x, y, ` ${VIEW_TITLE[v]} `, { fg: on ? t.text : off ? t.dim : t.muted, bg: on ? t.tabActiveBg : t.bg, b: on }) + 1;
     }
+    if (ui.view === 'journey')
+        x = c.text(x, y, ` ${VIEW_TITLE.journey} `, { fg: t.text, bg: t.tabActiveBg, b: true }) + 1;
     const line = ui.input
         ? `${ui.input.kind === 'import' ? 'import file: ' : ui.input.kind === 'dup' ? `duplicate ${ui.input.from} as: ` : `new from ${ui.input.from} as: `}${ui.input.text}█  ⏎ ok · esc cancel`
         : ui.notice;
@@ -77,7 +84,7 @@ function tabs(c, ui) {
 function hintsFor(ui) {
     const common = [['esc', 'back'], ['q', 'quit']];
     if (ui.confirm)
-        return [['y', 'flatten'], ['any key', 'cancel']];
+        return [['y', ui.confirm.kind === 'promote' ? 'apply promotion' : 'flatten'], ['any key', 'cancel']];
     if (ui.review)
         return ui.review.stage === 'less-safe' ? [['y', 'apply (less safe)'], ['any key', 'cancel']] : [['y', ui.review.check.ok && ui.review.check.riskDelta === 'looser' ? 'apply… (less safe)' : 'apply'], ['n', 'dismiss'], ['any key', 'close']];
     if (ui.input)
@@ -89,6 +96,7 @@ function hintsFor(ui) {
             : [['tab', 'view'], ['↑↓', 'field'], ['⏎', 'change'], ['s', 'save'], ['u', 'undo'], ['b', 'backtest'], ['w', 'sweep'], ...common];
         case 'compare': return [['tab', 'view'], ['↑↓', 'scroll'], ['b', 'backtest both, one tape'], ...common];
         case 'backtest': return [['tab', 'view'], ['b', 'run again'], ['w', 'sweep (held-out)'], ...common];
+        case 'journey': return [['b', 'backtest'], ['F', 'forward test'], ['X', 'stop it'], ['A', 'promotion'], ['J', 'refresh'], ...common];
         default: return [['tab', 'view'], ['!', 'kill'], ['p', 'pause entries'], ['f', 'flatten (confirm)'], ...common];
     }
 }
@@ -206,7 +214,7 @@ function renderList(c, ui, a, now) {
 }
 const running = (ui) => ui.runner.kind === 'ok';
 /** task-1528: the running runner's mode from its rendezvous ('live' = mainnet through the live signer). */
-const runMode = (ui) => { const m = ui.runner.kind === 'ok' ? ui.runner.snap.mode : 'paper'; return m === 'live' || m === 'devnet' ? m : 'paper'; };
+const runMode = (ui) => { const m = ui.runner.kind === 'ok' ? ui.runner.snap.mode : 'paper'; return m === 'live' || m === 'devnet' || m === 'real' ? m : 'paper'; };
 /** One chat proposal card (§2a): id, hashes, the diff lines, validation, LOOSER in the warn colour. */
 export function proposalCard(c, p, x, y, w, maxY) {
     const t = c.theme;
@@ -639,9 +647,9 @@ function sweepRow(x, pw) {
 function renderRunner(c, ui, a, now) {
     const t = c.theme;
     const rr = ui.runner;
-    const sh = 5;
     const mode = runMode(ui);
-    const sbox = c.box(a.x, a.y, a.w, sh, { title: `RUNNER · ${mode === 'live' ? 'LIVE · MAINNET' : mode === 'devnet' ? 'DEVNET (live signer rehearsal)' : 'PAPER'}`, caption: `status file: ${rr.path || '~/.dexterm/autotrade/runner.json'}`, focus: true });
+    const sh = mode === 'real' ? (ui.runner.kind === 'ok' && ui.runner.snap.real?.limits ? 8 : 6) : 5;
+    const sbox = c.box(a.x, a.y, a.w, sh, { title: `RUNNER · ${mode === 'live' ? 'LIVE · MAINNET' : mode === 'devnet' ? 'DEVNET (live signer rehearsal)' : mode === 'real' ? 'REAL · LIVE TRADE FIRE signals to your executor (no key here)' : 'PAPER'}`, caption: `status file: ${rr.path || '~/.dexterm/autotrade/runner.json'}`, focus: true });
     let y = sbox.y;
     const sl = (s, fg = t.text, b = false) => { if (y < sbox.y + sbox.h) {
         c.text(sbox.x + 1, y, fit(s, sbox.w - 2), { fg, bg: sbox.bg, b });
@@ -665,6 +673,23 @@ function renderRunner(c, ui, a, now) {
     sl(`${stale ? 'STALE' : s.state.toUpperCase()} · ${s.strategy.id} v${s.strategy.version} (${s.strategy.hash}) · pid ${s.pid} · heartbeat ${age} ago${stale ? ' (no heartbeat for over 30 s: treat it as down)' : ''}`, stateFg, true);
     sl(`book $${s.book.equityUsd.toFixed(2)} of $${s.book.startUsd.toFixed(2)} · cash $${s.book.cashUsd.toFixed(2)} · realized today ${usd(s.book.realizedTodayUsd)} · model spend $${s.spend.todayUsd.toFixed(2)} of $${s.spend.dayCapUsd.toFixed(2)} today`);
     sl(s.haltReason ? `halted: ${s.haltReason}` : 'no halt', s.haltReason ? t.down : t.dim, !!s.haltReason);
+    // task-1645: real mode: the account, the kill switch, the outbox, each channel's health, unconfirmed positions.
+    const rm = s.real;
+    if (rm) {
+        const chans = rm.channels.map((h) => `${h.name} ${h.failing ? `FAILING ×${h.failing}` : 'ok'}${h.pending ? ` (${h.pending} pending)` : ''}`).join(', ') || 'none';
+        const unconf = rm.positions.filter((p) => p.state === 'unconfirmed').length;
+        sl(`real · account ${rm.accountId} · ${rm.killed ? `KILL ON (${rm.killed})` : 'kill off'} · outbox ${rm.outboxDepth} pending · ${chans} · ${unconf} unconfirmed · today ${rm.day.buySol} of ${rm.caps.dailySol ?? 'off'} SOL`, rm.killed || rm.channels.some((h) => h.failing) || unconf ? t.warn : t.text, true);
+        // task-1654: the limits panel (status only: limits change on your own terminal, `dexterm autotrade limits`).
+        if (rm.limits) {
+            const L = rm.limits;
+            const v = (k, unit) => (typeof L[k] === 'number' ? `${L[k]}${unit}` : 'off');
+            const pause = rm.risk?.buyPause;
+            sl(`limits · ${v('perTradeSol', ' SOL')}/trade${typeof L.perTradePct === 'number' ? ` (${L.perTradePct}% of book)` : ''} · ${v('dailySol', ' SOL')}/day · ${v('buysPerDay', '')} buys · ${v('maxOpenPositions', '')} open · loss stop ${v('dailyLossSol', ' SOL')} · streak ${rm.risk?.lossStreak ?? 0}/${v('lossStreak', '')}${rm.risk?.breaker ? ' · BREAKER TRIPPED' : ''}${pause ? ` · BUYS PAUSED: ${pause}` : ''} · dexterm autotrade limits show`, pause || rm.risk?.breaker ? t.warn : t.muted, !!pause);
+            const ex = rm.executor;
+            if (ex)
+                sl(`executor · ${ex.alive === false ? 'SILENT' : ex.alive ? 'alive' : 'not judged'}${ex.silentSec !== null && ex.lastSeenBy !== 'run-start' ? ` · last ${ex.lastSeenBy} ${fmtAgeSec(ex.silentSec)} ago` : ''}${ex.heartbeat ? ` · ${ex.heartbeat.executor}${ex.heartbeat.dryRun ? ' (dry run)' : ''}` : ' · no heartbeat yet'}${ex.lastReceipt ? ` · receipt #${ex.lastReceipt.nonce} ${ex.lastReceipt.status}` : ''}${ex.receiptLagSec !== null ? ` · lag ${ex.receiptLagSec} s` : ''}${ex.windowMin !== null ? ` · pauses buys after ${ex.windowMin} min silent` : ''}`, ex.alive === false ? t.down : t.muted, ex.alive === false);
+        }
+    }
     // task-1529: a `run --all` shows its strategies side by side above the shared panels (rows tagged [strategy]).
     const fleet = ui.fleet;
     let fh = 0;
@@ -703,7 +728,7 @@ function renderRunner(c, ui, a, now) {
         [`  last: ${k.lastDecision ?? '—'}`, t.muted],
     ]));
     panel(a.x + 2 * third, a.w - 2 * third, `POSITIONS · ${s.positions.length}`, s.positions.flatMap((p) => [
-        [`${tag(p)}${p.symbol.padEnd(8)}${pct(p.pnlPct).padStart(8)}${usd(p.pnlUsd).padStart(9)}${p.freeBag ? ' free bag' : ''}`, p.pnlUsd >= 0 ? t.up : t.down],
+        [`${tag(p)}${p.symbol.padEnd(8)}${pct(p.pnlPct).padStart(8)}${usd(p.pnlUsd).padStart(9)}${p.freeBag ? ' free bag' : ''}${p.confirm ? ` · ${p.confirm}` : ''}`, p.pnlUsd >= 0 ? t.up : t.down],
         [`  ${p.profile} · next: ${p.next ?? '—'}`, t.muted],
     ]));
     const lb = c.box(a.x, a.y + sh + fh + upper, a.w, ledgerH, { title: 'RUN LEDGER · newest last', caption: 'hash-chained; every step with its exact inputs' });
@@ -723,3 +748,29 @@ function confirmCard(c) {
     c.text(b.x + 1, b.y + 1, fit('New entries stop first; mechanical exits keep running.', b.w - 2), { fg: t.muted, bg: b.bg });
     c.text(b.x + 1, b.y + 3, 'y flatten · any other key cancels', { fg: t.warn, bg: b.bg, b: true });
 }
+// ───────────────────────────── journey (task-1647) ─────────────────────────────
+function renderJourneyView(c, ui, a, now) {
+    const t = c.theme;
+    refreshJourney(ui);
+    const j = ui.journey;
+    const box = c.box(a.x, a.y, a.w, a.h, { title: `JOURNEY · ${j?.id ?? '—'}`, caption: 'draft → backtested → forward-tested → always-on (paper) → real · one rung at a time, on these exact rules', focus: true });
+    const bg = box.bg;
+    if (!j) {
+        c.text(box.x + 1, box.y, 'J on a strategy opens its journey', { fg: t.dim, bg });
+        return;
+    }
+    const tone = { text: t.text, ok: t.up, warn: t.warn, dim: t.dim };
+    // tables keep their columns: only a line wider than the box wraps
+    const lines = journeyLines(j, now).flatMap((l) => (l.text.length <= box.w - 2 ? [l] : wrap(l.text, box.w - 2).map((x) => ({ text: x, tone: l.tone }))));
+    lines.slice(0, box.h).forEach((l, i) => c.text(box.x + 1, box.y + i, fit(l.text, box.w - 2), { fg: tone[l.tone], bg }));
+}
+function promoteCard(c, ui, proposalId) {
+    const t = c.theme;
+    const p = ui.journey?.pending.find((x) => x.proposalId === proposalId);
+    const body = p ? p.card : [`promotion ${proposalId}`];
+    const w = Math.min(c.w - 4, 104), h = Math.min(c.h - 4, body.length + 5);
+    const x = Math.floor((c.w - w) / 2), y = Math.floor((c.h - h) / 2);
+    const box = c.box(x, y, w, h, { title: 'APPLY PROMOTION? (paper: the always-on service)', focus: true });
+    body.slice(0, h - 4).forEach((l, i) => c.text(box.x + 1, box.y + i, fit(l, box.w - 2), { fg: t.text, bg: box.bg }));
+    c.text(box.x + 1, box.y + h - 3, fit(`proposed by ${p?.actor ?? '?'} · y applies (autotrade.json gets the paper member) · any other key cancels`, box.w - 2), { fg: t.warn, bg: box.bg, b: true });
+}

package/dist/packages/cli/src/screens/autotrade-ui.js

@@ -15,13 +15,14 @@
 // cards; applying them is the chat card's keypress flow). Kill / pause / flatten go through RunnerControl: the
 // runner's control file (task-1509 fileControl), the same request `dexterm autotrade stop|flatten` writes.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { applyOps, dextermHome } from '../../../custom/src/index.js';
-import { StrategyStore, MAX_OPS, STRATEGY_ID, activeRunner, bumpPatch, fmtIssue, readControl, readFleetStatus, requestControl, runnerRendezvousPath, validateStrategy, } from '../../../autotrade/src/index.js';
+import { StrategyStore, MAX_OPS, recordBacktestEvidence, STRATEGY_ID, activeRunner, bumpPatch, fmtIssue, readControl, readFleetStatus, requestControl, runnerRendezvousPath, validateStrategy, } from '../../../autotrade/src/index.js';
 import { parseFilter } from "../screener/filter.js";
 import { proposalFilesFor, proposalSource } from "./autotrade-proposals.js";
+import { confirmPromote } from "./autotrade-journey.js";
 export const AUTOTRADE_VIEWS = ['list', 'editor', 'compare', 'backtest', 'runner'];
-export const VIEW_TITLE = { list: 'STRATEGIES', editor: 'EDITOR', compare: 'COMPARE', backtest: 'BACKTEST', runner: 'RUNNER' };
+export const VIEW_TITLE = { list: 'STRATEGIES', editor: 'EDITOR', compare: 'COMPARE', backtest: 'BACKTEST', runner: 'RUNNER', journey: 'JOURNEY' };
 export const SECTIONS = ['entry', 'exits', 'risk', 'sizing', 'agent', 'execution'];
 /** Who the journal names for an edit made on this screen (the same actor the CLI uses for the user's own edits). */
 export const TUI_ACTOR = 'user';
@@ -94,9 +95,9 @@ function runnerShapeError(d) {
     const o = d;
     if (o.schema !== RUNNER_SCHEMA)
         return `unknown rendezvous shape ${JSON.stringify(o.schema)} (expected ${RUNNER_SCHEMA})`;
-    // Paper only: a rendezvous that claims anything else is shown as an error, never as a running live runner.
-    if (o.mode !== 'paper')
-        return `mode ${JSON.stringify(o.mode)}: this screen shows paper runners only`;
+    // Paper, or real (task-1645: signals to the user's executor). Anything else is an error, never a running live runner.
+    if (o.mode !== 'paper' && o.mode !== 'real')
+        return `mode ${JSON.stringify(o.mode)}: this screen shows paper runners only (and real-mode signal runners)`;
     for (const k of ['pid', 'startedAt', 'heartbeatAt'])
         if (typeof o[k] !== 'number')
             return `${k} is not a number`;
@@ -133,7 +134,7 @@ export function defaultDeps(env = process.env, jobs = null) {
 export function newAutotradeUi(deps) {
     const ui = {
         view: 'list', deps, entries: [], selected: 0, marked: [], notice: null, input: null, editor: null, compare: null,
-        focusId: null, backtests: new Map(), compareRun: null, sweep: null, runner: { kind: 'none', path: '' }, fleet: null, runnerReadAt: 0, confirm: null, review: null,
+        focusId: null, backtests: new Map(), compareRun: null, sweep: null, runner: { kind: 'none', path: '' }, fleet: null, runnerReadAt: 0, confirm: null, review: null, journey: null,
     };
     reloadList(ui);
     refreshRunner(ui);
@@ -525,6 +526,13 @@ export function startBacktest(ui, id) {
         job.result = out;
         job.doneAt = ui.deps.now();
         recordLine(ui, s, out.report);
+        // task-1647: the held-out split of a stored strategy is its journey evidence
+        if (out.evidence && ui.deps.store.get(s.id)?.ok) {
+            try {
+                recordBacktestEvidence(dirname(ui.deps.store.dir), out.evidence);
+            }
+            catch { /* evidence is best effort here */ }
+        }
     }, (e) => { job.status = 'error'; job.error = errText(e); job.doneAt = ui.deps.now(); });
     return `backtesting ${s.id} v${s.version} on the last ${BACKTEST_DAYS} days of recorded history…`;
 }
@@ -631,6 +639,8 @@ export function confirmKey(ui, yes) {
     ui.confirm = null;
     if (!c)
         return '';
+    if (c.kind === 'promote')
+        return confirmPromote(ui, c.proposalId, yes);
     return yes ? ui.deps.control.flatten() : 'flatten cancelled';
 }
 /** The views tab cycles through (compare only once two strategies were marked). */

package/dist/packages/cli/src/screens/autotrade-worker.js

@@ -7,7 +7,7 @@ import { existsSync } from 'node:fs';
 import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
 import { defaultDbPath } from '../../../data/src/index.js';
 import { openHistoryReadOnly } from '../../../recorder/src/index.js';
-import { backtest, sweep, tapeFromDb, tapeFromDoc } from '../../../autotrade/src/index.js';
+import { backtest, backtestEvidence, sweep, tapeFromDb, tapeFromDoc } from '../../../autotrade/src/index.js';
 const DAY_MS = 86_400_000;
 /** The equity curve is resampled to this many points before it crosses the thread boundary (it feeds a sparkline). */
 const CURVE_POINTS = 240;
@@ -42,7 +42,9 @@ export async function backtestOn(tape, ss) {
     const out = [];
     for (const s of ss) {
         const { report, run } = await backtest(s, tape);
-        out.push({ report, curve: resample(run.equityCurve.map((p) => p.equity), CURVE_POINTS) });
+        // task-1647: one strategy alone (not a compare) also runs on each half of the held-out split: journey evidence
+        const evidence = ss.length === 1 && s.mode === 'paper' ? (await backtestEvidence(s, tape, { by: 'user:tui', full: { report, run } })).evidence : undefined;
+        out.push({ report, curve: resample(run.equityCurve.map((p) => p.equity), CURVE_POINTS), ...(evidence ? { evidence } : {}) });
     }
     return out;
 }

package/dist/packages/cli/src/telegram-cmd.js

@@ -15,7 +15,7 @@
 // The runner starts the bot by itself when it is set up and paired (`dexterm autotrade run … --paper`; --no-telegram
 // keeps it off). Nothing here is hosted: the bot long-polls from this machine.
 import { dextermHome } from '../../custom/src/index.js';
-import { ChatAudit, PairingWindow, TelegramConnector, TIERS_ALL, chooseSecretStore, connectorsPath, defaultTelegram, loadConnectors, looksLikeBotToken, redact, saveConnectors, secretStore, verifyChatAudit, ChatHub, } from '../../autotrade/src/index.js';
+import { ChatAudit, PairingWindow, TelegramConnector, TIERS_ALL, chooseSecretStore, connectorsPath, defaultTelegram, loadConnectors, looksLikeBotToken, redact, saveConnectors, secretStore, verifyChatAudit, ChatHub, enabledChannels, parseSignalsConfig, } from '../../autotrade/src/index.js';
 export const TELEGRAM_USAGE = `dexterm telegram: your own Telegram bot for the autotrade runner (paper first). Nothing is hosted.
 
   dexterm telegram setup [--tiers notify,control,approve] [--no-pair]
@@ -321,6 +321,8 @@ export async function telegramCommand(argv, io, deps = {}) {
                     paired: t.allow.map((a) => ({ senderId: a.senderId, chatId: a.chatId, tiers: a.tiers, pairedAt: a.pairedAt ? new Date(a.pairedAt).toISOString() : null })),
                     approvals: t.approvals, approvalExpirySec: t.approvalExpirySec, repriceTolPct: t.repriceTolPct, notify: t.notify, dailySummaryAt: t.dailySummaryAt, quietHours: t.quietHours,
                     audit: { days: chain.length, broken: chain.filter((c) => !c.check.ok).map((c) => c.day) },
+                    // task-1645: the real-mode trade-fire channels live in the same file (dexterm autotrade signal channels).
+                    signals: (() => { const sc = parseSignalsConfig(cfg.signals); return { channels: enabledChannels(sc.config), telegramCopy: sc.config.telegram.enabled, ttlSec: sc.config.ttlSec, problems: sc.problems }; })(),
                 };
                 if (argv.includes('--json')) {
                     io.stdout.write(`${JSON.stringify(view, null, 2)}\n`);
@@ -332,6 +334,7 @@ export async function telegramCommand(argv, io, deps = {}) {
                 io.stdout.write(`  approvals ${t.approvals} · expiry ${t.approvalExpirySec} s · re-quote tolerance ${t.repriceTolPct}%\n`);
                 io.stdout.write(`  notify candidates ${t.notify.candidates} · entries ${t.notify.entries ? 'on' : 'off'} · closes ${t.notify.closes ? 'on' : 'off'} · halts ${t.notify.halts ? 'on' : 'off'} · spend ${t.notify.spend ? 'on' : 'off'} · daily ${t.notify.daily ? `at ${t.dailySummaryAt ?? 'off'}` : 'off'}${t.quietHours ? ` · quiet ${t.quietHours}` : ''}\n`);
                 io.stdout.write(`  audit ${chain.length} day file${chain.length === 1 ? '' : 's'}${view.audit.broken.length ? ` · BROKEN: ${view.audit.broken.join(', ')}` : ''}\n`);
+                io.stdout.write(`  trade-fire signals (real mode) · channels ${view.signals.channels.filter((c) => c !== 'telegram').join(', ') || 'none'} · Telegram copy ${view.signals.telegramCopy ? 'on' : 'off'} · ttl ${view.signals.ttlSec} s · set with dexterm autotrade signal channels${view.signals.problems.length ? ` · OFF: ${view.signals.problems.join('; ')}` : ''}\n`);
                 return 0;
             }
             case 'approvals': {

package/dist/packages/cli/src/version.js

@@ -1,3 +1,3 @@
 // The one place the app's version lives (task-1397). --version, the help banner and `dexterm update` read it;
 // cli.test.ts keeps it equal to packages/cli/package.json (release.yml refuses a tag that differs).
-export const VERSION = '0.1.7';
+export const VERSION = '0.2.0';

package/dist/packages/data/src/trade/ledger/schema.js

@@ -23,7 +23,7 @@ export const LEDGER_SCHEMA = 'dexterm-ledger/1';
 export const LEDGER_VERSION = 1;
 export const GENESIS = 'genesis';
 export const LEDGER_SOURCES = ['paper', 'desk', 'autotrade', 'live'];
-export const WALLET_MODES = ['paper', 'devnet', 'live'];
+export const WALLET_MODES = ['paper', 'devnet', 'live', 'real'];
 // ───────────────────────────── hygiene ─────────────────────────────
 /** A base58 secret key (64 bytes ≈ 87-88 chars) or a 64-number byte array: never stored, whatever field it is in. */
 const KEY_SHAPED = /(?:[1-9A-HJ-NP-Za-km-z]{85,90})|(?:\[(?:\s*\d{1,3}\s*,){63}\s*\d{1,3}\s*\])/g;

package/dist/packages/mcp/assets/kb/app-help/autotrade-executor-kit.md

@@ -0,0 +1,44 @@
+---
+id: autotrade-executor-kit
+title: Wire up a test executor, check it is alive, and get the digest (dexterm autotrade executor, signal test, report)
+kind: app-help
+screen: all
+feature: autotrade-executor-kit
+tags:
+  - app-help
+  - executor
+  - kit
+  - example
+  - heartbeat
+  - alive
+  - silent
+  - health
+  - test
+  - webhook
+  - receiver
+  - dry
+  - run
+  - digest
+  - report
+  - daily
+  - weekly
+  - divergence
+  - slippage
+  - latency
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm 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.
+
+CLI: `dexterm autotrade`.