dexterm-cli 0.1.7 → 0.2.1

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/screens/narrative.js

@@ -3,8 +3,13 @@
 // new launches / runners / pace / "what is working" score. No model in the hot path; the board carries
 // its own limits (name-based, X/TG-only narratives missed, honest unclassified share). w flips 1h/24h,
 // M opens the HUD popup. The board is computed in state.ts (computeNarrativeView) on entry and the tick.
+// task-1818: `n` flips to the EXPERIMENTAL heat table (@dexterm/narratives: clustered by what the name says,
+// lifecycle + traction score per narrative); ⏎ drills into one narrative's member coins, esc returns to the table.
 import { Canvas, header, footer, badge, breakpoint } from '../../../tui/src/index.js';
 import { headerModel } from "../state.js";
+import { clean } from '../../../packs/src/index.js';
+import { HEAT_NOTE } from '../../../narratives/src/index.js';
+import { heatRows, drillDetail, currentTracker, narrativesSource, UNTRUSTED_NOTE } from "../narratives.js";
 const fmtUsd = (v) => { if (v == null)
     return '—'; const a = Math.abs(v); if (a >= 1e9)
     return (v / 1e9).toFixed(2) + 'B'; if (a >= 1e6)
@@ -12,6 +17,13 @@ const fmtUsd = (v) => { if (v == null)
     return (v / 1e3).toFixed(1) + 'K'; return v.toFixed(0); };
 const fmtPct = (v) => (v == null ? '—' : (v > 0 ? '+' : '') + v.toFixed(1) + '%');
 export function renderNarrative(c, state) {
+    if (state.narrativesUi?.mode === 'heat') {
+        if (state.narrativesUi.drill)
+            renderDrill(c, state);
+        else
+            renderHeat(c, state);
+        return;
+    }
     const t = c.theme;
     const bp = breakpoint(c.w);
     header(c, headerModel(state));
@@ -27,7 +39,7 @@ export function renderNarrative(c, state) {
     if (!board || board.narratives.every((n) => n.tokens === 0)) {
         c.textC(box.x, box.y + 1, box.w, 'collecting narratives — run the app with the recorder on, or open the screener first', { fg: t.muted, bg, i: true });
         c.textC(box.x, box.y + 3, box.w, view?.error ? `(${view.error})` : 'clusters come from token names against a lexicon (owner: maintainers); X/Telegram-only narratives are missed', { fg: t.dim, bg });
-        footer(c, [['w', '1h/24h'], ['esc', 'back'], ['q', 'quit']], t.name);
+        footer(c, [['w', '1h/24h'], ['n', 'narratives (exp)'], ['esc', 'back'], ['q', 'quit']], t.name);
         return;
     }
     const shown = board.narratives.filter((n) => n.tokens > 0);
@@ -86,5 +98,145 @@ export function renderNarrative(c, state) {
     const ly = box.y + box.h - 1;
     if (wide)
         c.textC(box.x, ly, box.w, `model output: none (deterministic lexicon v${board.meta.lexicon_version}) · ${board.meta.copycat_tokens} copycat symbols · name-based · pace '*' = all tokens · compute ${board.meta.compute_ms}ms`, { fg: t.dim, bg });
-    footer(c, [['↑↓', 'move'], ['w', win === '1h' ? '→24h' : '→1h'], ['M', 'popup'], ['esc', 'back'], ['q', 'quit']], t.name);
+    footer(c, [['↑↓', 'move'], ['w', win === '1h' ? '→24h' : '→1h'], ['n', 'narratives (exp)'], ['M', 'popup'], ['esc', 'back'], ['q', 'quit']], t.name);
+}
+// ---- task-1818 EXPERIMENTAL heat table + drill-down ------------------------------------------------------------
+const heatUsd = (v) => (v == null ? '—' : '$' + fmtUsd(v));
+const fmtShare = (v) => (v == null ? '—' : (v * 100).toFixed(1) + '%');
+const fmtX = (v) => (v == null || !Number.isFinite(v) ? '—' : v.toFixed(2) + 'x');
+function lcColor(t, lc) {
+    // states are measured heat, so none is painted as a market up/down colour (no green "go")
+    return lc === 'ignition' ? t.accent : lc === 'peak' ? t.text : lc === 'fading' ? t.warn : lc === 'dead' ? t.dim : t.muted;
+}
+/** The limits line: the full HEAT_NOTE when it fits, else the short form (the note must never be the part that is cut). */
+function limitsLine(w, extra) {
+    const full = `${HEAT_NOTE} · ${UNTRUSTED_NOTE} · ${extra}`;
+    return full.length <= w ? full : `measured heat, not advice · ${UNTRUSTED_NOTE} · ${extra}`;
+}
+/** The status line under an empty heat table: building (with the one-time stall warning), failed, or nothing yet. */
+function heatPlaceholder(state) {
+    const ui = state.narrativesUi;
+    const rec = narrativesSource(state) === 'recorded';
+    if (ui?.error)
+        return [`narratives failed: ${clean(ui.error, 120)}`, 'the theme board (v) still works'];
+    if (!currentTracker(state))
+        return [rec ? 'building narratives from recorded history…' : 'building narratives from the visible rows…',
+            rec ? 'first build reads the last 26 h of the recorder: tens of seconds, the screen stays live (once per run)' : 'no recorder DB here (fixtures / replay): no history, so every narrative starts as a spark'];
+    return ['no narrative with 2+ coins yet', 'a narrative needs at least two coins whose names share a theme · measured heat, not advice'];
+}
+function renderHeat(c, state) {
+    const t = c.theme;
+    const bp = breakpoint(c.w);
+    header(c, headerModel(state));
+    const ui = state.narrativesUi;
+    const rows = heatRows(state);
+    const tr = currentTracker(state);
+    const src = narrativesSource(state) === 'recorded' ? 'recorded history' : 'visible rows';
+    const top = 2, bottom = c.h - 1;
+    const title = `NARRATIVES · EXPERIMENTAL · ${tr ? `${rows.length} narratives · ${tr.coins.size} coins` : 'building'} · ${src}${ui.busy && tr ? ' · refreshing' : ''}`;
+    const caption = bp === 'compact' ? undefined : 'measured heat, not advice';
+    const box = c.box(0, top, c.w, bottom - top, { title, caption, focus: true });
+    const bg = box.bg;
+    const keys = [['↑↓', 'move'], ['⏎', 'drill'], ['n', 'theme board'], ['esc', 'back'], ['q', 'quit']];
+    if (!rows.length) {
+        const [a, b] = heatPlaceholder(state);
+        c.textC(box.x, box.y + 1, box.w, a, { fg: t.muted, bg, i: true });
+        c.textC(box.x, box.y + 3, box.w, b, { fg: t.dim, bg });
+        c.textC(box.x, box.y + 5, box.w, HEAT_NOTE, { fg: t.dim, bg });
+        footer(c, keys, t.name);
+        return;
+    }
+    const sel = Math.max(0, Math.min(rows.length - 1, ui.selected));
+    // columns: [x, header]; a column that does not fit the box is dropped (the runner first)
+    const cols = [[1, '#', 3], [5, 'NARRATIVE', 18], [24, 'THEME', 12], [37, 'STATE', 10], [48, 'COINS', 5], [54, 'NEW/h', 5], [60, 'VOL 1h', 9], [70, 'SHARE', 6], [77, 'TRADERS', 7], [85, 'SCORE', 5], [91, 'TOP RUNNER (x · drawdown)', 28]];
+    const fits = (i) => cols[i][0] + Math.min(cols[i][2], 12) <= box.w - 1;
+    let cy = box.y;
+    cols.forEach(([x, h], i) => { if (fits(i))
+        c.text(box.x + x, cy, h, { fg: t.dim, bg }, box.w - x - 1); });
+    cy += 1;
+    c.hline(box.x, cy, box.w, { fg: t.border, bg });
+    cy += 1;
+    const scroll = Math.max(0, sel - (box.h - 6));
+    for (let i = scroll; i < rows.length; i++) {
+        if (cy >= box.y + box.h - 2)
+            break;
+        const s = rows[i];
+        const w1 = s.windows['1h'];
+        const selected = i === sel;
+        const rb = selected ? t.selBg : bg;
+        c.fill(box.x, cy, box.w, 1, ' ', { bg: rb });
+        if (selected)
+            c.put(box.x, cy, '▎', { fg: t.accent, bg: rb, soft: true });
+        const cell = (k, v, st) => { if (fits(k))
+            c.text(box.x + cols[k][0], cy, v, { ...st, bg: rb }, Math.min(cols[k][2], box.w - cols[k][0] - 1)); };
+        cell(0, s.rank == null ? '·' : String(s.rank), { fg: s.rank == null ? t.dim : t.accent, b: true });
+        cell(1, clean(s.label, 18), { fg: selected ? t.borderFocus : t.text, b: s.rank != null });
+        cell(2, s.theme ? clean(s.theme, 12) : '—', { fg: t.muted });
+        cell(3, s.lifecycle + (s.saturated ? '*' : ''), { fg: lcColor(t, s.lifecycle), b: s.lifecycle === 'ignition' });
+        cell(4, String(s.members), { fg: t.text });
+        cell(5, w1.newPerHour.toFixed(0), { fg: t.muted });
+        cell(6, heatUsd(w1.volume), { fg: t.text });
+        cell(7, fmtShare(w1.volumeShare), { fg: t.muted });
+        cell(8, String(w1.traders), { fg: t.muted });
+        cell(9, String(s.score), { fg: t.accent, b: true });
+        const r = s.topRunner;
+        cell(10, r ? `${clean(r.symbol, 10)} ${fmtX(r.x)} · ${r.drawdownPct.toFixed(0)}%` : '—', { fg: r ? t.text : t.dim });
+        cy += 1;
+    }
+    c.textC(box.x, box.y + box.h - 1, box.w, limitsLine(box.w, '* = copy-cat saturated'), { fg: t.dim, bg });
+    footer(c, keys, t.name);
+}
+function renderDrill(c, state) {
+    const t = c.theme;
+    header(c, headerModel(state));
+    const ui = state.narrativesUi;
+    const d = drillDetail(state);
+    const top = 2, bottom = c.h - 1;
+    const keys = [['↑↓', 'move'], ['⏎', 'open coin'], ['esc', 'table'], ['q', 'quit']];
+    if (!d) {
+        const box = c.box(0, top, c.w, bottom - top, { title: 'NARRATIVE · EXPERIMENTAL', focus: true });
+        c.textC(box.x, box.y + 1, box.w, 'this narrative is no longer tracked (esc returns to the table)', { fg: t.muted, bg: box.bg, i: true });
+        footer(c, keys, t.name);
+        return;
+    }
+    const w1 = d.windows['1h'];
+    const title = `NARRATIVE · ${clean(d.label, 24)} · ${d.lifecycle}${d.saturated ? ' · copy-cat saturated' : ''} · ${d.memberList.length} coin${d.memberList.length === 1 ? '' : 's'} · EXPERIMENTAL`;
+    const box = c.box(0, top, c.w, bottom - top, { title, caption: 'measured heat, not advice · members in spawn order', focus: true });
+    const bg = box.bg;
+    let cy = box.y;
+    c.text(box.x + 1, cy, `lifecycle rule (${d.lifecycle}): ${d.lifecycleRule}`, { fg: lcColor(t, d.lifecycle), bg }, box.w - 2);
+    cy += 1;
+    c.text(box.x + 1, cy, `1h: vol ${heatUsd(w1.volume)} · share ${fmtShare(w1.volumeShare)} · new/h ${w1.newPerHour.toFixed(0)} · traders ${w1.traders} · score ${d.score}${d.rank ? ` · rank ${d.rank}` : ''}${d.theme ? ` · theme ${clean(d.theme, 16)}` : ''}`, { fg: t.muted, bg }, box.w - 2);
+    cy += 1;
+    const cols = [[1, '#', 4], [6, 'SYMBOL', 12], [19, 'NAME', 26], [46, 'X SINCE 1ST', 11], [58, 'LIQ', 9], [68, 'VOL 1h', 9]];
+    const fits = (i) => cols[i][0] + Math.min(cols[i][2], 8) <= box.w - 1;
+    cols.forEach(([x, h], i) => { if (fits(i))
+        c.text(box.x + x, cy, h, { fg: t.dim, bg }); });
+    cy += 1;
+    c.hline(box.x, cy, box.w, { fg: t.border, bg });
+    cy += 1;
+    const n = d.memberList.length;
+    const sel = Math.max(0, Math.min(n - 1, ui.drill.selected));
+    const scroll = Math.max(0, sel - (box.h - 8));
+    for (let i = scroll; i < n; i++) {
+        if (cy >= box.y + box.h - 1)
+            break;
+        const m = d.memberList[i];
+        const selected = i === sel;
+        const rb = selected ? t.selBg : bg;
+        c.fill(box.x, cy, box.w, 1, ' ', { bg: rb });
+        if (selected)
+            c.put(box.x, cy, '▎', { fg: t.accent, bg: rb, soft: true });
+        const cell = (k, v, fg) => { if (fits(k))
+            c.text(box.x + cols[k][0], cy, v, { fg, bg: rb }, Math.min(cols[k][2], box.w - cols[k][0] - 1)); };
+        cell(0, `#${m.spawn}`, t.dim);
+        cell(1, clean(m.symbol, 12), selected ? t.borderFocus : t.text);
+        cell(2, clean(m.name, 26), t.muted);
+        cell(3, fmtX(m.x), m.x == null ? t.dim : m.x >= 1 ? t.up : t.down);
+        cell(4, heatUsd(m.liq), t.text);
+        cell(5, heatUsd(m.vol1h), t.text);
+        cy += 1;
+    }
+    c.textC(box.x, box.y + box.h - 1, box.w, limitsLine(box.w, 'x = now vs first $10K+ pool price'), { fg: t.dim, bg });
+    footer(c, keys, t.name);
 }

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

@@ -301,6 +301,7 @@ export function makeFixtureState(opts = {}) {
         ai: null,
         analystByMint: new Map(),
         larpByMint: new Map(),
+        classifierByMint: new Map(),
         colorDepth: opts.colorDepth ?? 'truecolor',
     };
     if (opts.priceMode)

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.1';