dexterm-cli 0.1.6 → 0.2.0

package/dist/packages/autotrade/src/forward.js

@@ -0,0 +1,355 @@
+// dexterm autotrade — FORWARD TESTS (0.2.0 card C). PAPER ONLY.
+//
+// A forward test runs one strategy, frozen at the version it started with, on the LIVE tape, on paper, for a chosen
+// window (hours, or N closed trades, whichever comes first), with its own bankroll (an isolated simulated book: no
+// paper account, no other strategy's cash) and its own run file. It is started and stopped from the chat
+// (strategy_forward_start / _stop), the Q screen's journey view and `dexterm autotrade forward start|status|stop|report`.
+//
+// It does not take the machine's run.lock: a forward test runs next to the always-on service or a foreground run, in
+// its own process (`dexterm autotrade forward run <fid>`, started detached), with its own status file and stop marker:
+//
+//   $DEXTERM_HOME/autotrade/forward/tests/<fid>.json   dexterm-forward-test/1: the frozen strategy, the window, state,
+//                                                     heartbeat, progress and, at the end, the metrics
+//   $DEXTERM_HOME/autotrade/forward/tests/<fid>.stop   the stop marker (CLI, chat, Q screen); the host flattens and ends
+//   $DEXTERM_HOME/autotrade/forward/tests/<fid>.log    the detached host's output
+//   $DEXTERM_HOME/autotrade/forward/<id>.json          the latest result line for real mode's arm panel (card A)
+//   $DEXTERM_HOME/autotrade/runs/<runId>.jsonl         the run ledger, hash-chained like every other run
+//
+// At the end of its window the host flattens (every position sold at its next tick, so the numbers are closed
+// numbers), then writes the metrics in the backtest's own shape (backtest.ts report()) and records the result in
+// the strategy's journey. Only a test that ran its whole window on live data is the "forward-tested" rung; one that
+// was stopped early, ran on a replay or died is shown, never counted. The panic file stops it like any run.
+//
+// Model spend: a forward test of an agent strategy opens sessions on the user's own engine inside the strategy's
+// budgets and runner.json's caps, like `run`. A strategy that needs a chat approval for every entry cannot be
+// forward-tested (no tap reaches a forward test). Nothing here holds a key, signs or touches a wallet.
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+import { report } from "./backtest.js";
+import { compareForward, renderComparison, latestBacktest, loadJourney, metricsLine, metricsOf, recordForwardResult, rulesHash, runFills, usd } from "./journey.js";
+import { fileLedger, writeJsonAtomic } from "./ledger.js";
+import { runAutotrade, simExecutor } from "./runner.js";
+import { STRATEGY_ID } from "./store.js";
+import { validateStrategy } from "./strategy.js";
+export const FORWARD_SCHEMA = 'dexterm-forward-test/1';
+export const FORWARD_LIMITS = { minHours: 0.25, maxHours: 72, maxTrades: 200, maxRunning: 3, minBankrollUsd: 10, maxBankrollUsd: 1_000_000 };
+/** A running host rewrites its status at least this often; older means the host is gone. */
+export const FORWARD_HEARTBEAT_MS = 10_000;
+export const FORWARD_STALE_MS = 90_000;
+/** After the window ends, how long (tape time) the flatten may keep trying before the stream is closed. */
+export const FLATTEN_GRACE_MS = 30 * 60_000;
+/** Live data: an ended test whose stream took no step for this long is closed (the report is written). */
+export const STALL_MS = 2 * 60_000;
+export const forwardRoot = (home) => join(home, 'autotrade', 'forward');
+export const forwardTestsDir = (home) => join(forwardRoot(home), 'tests');
+const FID = /^fw_[a-z0-9]{6,12}_[a-f0-9]{8}$/;
+export const isForwardId = (x) => typeof x === 'string' && FID.test(x);
+const fpath = (home, fid, ext) => {
+    if (!isForwardId(fid))
+        throw new Error(`bad forward test id ${JSON.stringify(fid)}`);
+    return join(forwardTestsDir(home), `${fid}.${ext}`);
+};
+export const forwardTestPath = (home, fid) => fpath(home, fid, 'json');
+export const forwardStopPath = (home, fid) => fpath(home, fid, 'stop');
+export const forwardLogPath = (home, fid) => fpath(home, fid, 'log');
+/** Card A's arm panel reads `autotrade/forward/<id>.json` (summary line). */
+export const forwardSummaryPath = (home, id) => {
+    if (!STRATEGY_ID.test(id))
+        throw new Error(`bad strategy id ${JSON.stringify(id)}`);
+    return join(forwardRoot(home), `${id}.json`);
+};
+export const newForwardId = (now = Date.now()) => `fw_${now.toString(36)}_${randomBytes(4).toString('hex')}`;
+const pidAlive = (pid) => { try {
+    process.kill(pid, 0);
+    return true;
+}
+catch (e) {
+    return e.code === 'EPERM';
+} };
+export function liveState(t, now = Date.now(), alive = pidAlive) {
+    if (t.state !== 'starting' && t.state !== 'running')
+        return t.state;
+    if (t.state === 'starting')
+        return now - t.createdAt > FORWARD_STALE_MS && (!t.pid || !alive(t.pid)) ? 'lost' : 'starting';
+    if (t.pid && !alive(t.pid))
+        return 'lost';
+    return t.heartbeatAt && now - t.heartbeatAt > FORWARD_STALE_MS ? 'lost' : 'running';
+}
+export function loadForwardTest(home, fid) {
+    if (!isForwardId(fid))
+        return null;
+    const p = forwardTestPath(home, fid);
+    if (!existsSync(p))
+        return null;
+    try {
+        const d = JSON.parse(readFileSync(p, 'utf8'));
+        return d.schema === FORWARD_SCHEMA && d.forwardId === fid ? d : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveForwardTest(home, t) {
+    mkdirSync(forwardTestsDir(home), { recursive: true, mode: 0o700 });
+    writeJsonAtomic(forwardTestPath(home, t.forwardId), t);
+}
+/** Newest first. */
+export function listForwardTests(home, filter = {}) {
+    const dir = forwardTestsDir(home);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir).filter((f) => f.endsWith('.json')).map((f) => loadForwardTest(home, f.slice(0, -5))).filter((t) => !!t && (!filter.strategyId || t.strategyId === filter.strategyId))
+        .sort((a, b) => b.createdAt - a.createdAt);
+}
+export const isActive = (t, now = Date.now()) => { const s = liveState(t, now); return s === 'starting' || s === 'running'; };
+/** A forward test id, or a strategy id (its running test, else its newest). */
+export function findForwardTest(home, ref, now = Date.now()) {
+    if (isForwardId(ref))
+        return loadForwardTest(home, ref);
+    if (!STRATEGY_ID.test(ref))
+        return null;
+    const all = listForwardTests(home, { strategyId: ref });
+    return all.find((t) => isActive(t, now)) ?? all[0] ?? null;
+}
+/**
+ * Freeze a strategy into a new forward test (state `starting`); the caller then starts its host. Refuses a window
+ * outside the limits, a second running test of the same strategy, more than FORWARD_LIMITS.maxRunning at once,
+ * mode live, and a strategy that needs a chat approval for every entry.
+ */
+export function createForwardTest(home, s, raw, o) {
+    const now = o.now ?? Date.now();
+    if (s.mode === 'live')
+        return { ok: false, why: `${s.id} is mode live, which does not run (dexterm holds no key and places no live order)` };
+    if (s.entry.decide === 'agent+approve')
+        return { ok: false, why: `${s.id} needs a chat approval for every entry (entry.decide "agent+approve"); no approval reaches a forward test, so it could never enter. Make a copy with decide "agent" or "auto" to forward-test it` };
+    const hours = o.hours ?? null;
+    const trades = o.trades ?? null;
+    if (hours === null && trades === null)
+        return { ok: false, why: 'a forward test needs a window: hours, a number of closed trades, or both (whichever comes first ends it)' };
+    if (hours !== null && !(Number.isFinite(hours) && hours >= FORWARD_LIMITS.minHours && hours <= FORWARD_LIMITS.maxHours))
+        return { ok: false, why: `hours must be from ${FORWARD_LIMITS.minHours} to ${FORWARD_LIMITS.maxHours}` };
+    if (trades !== null && !(Number.isInteger(trades) && trades >= 1 && trades <= FORWARD_LIMITS.maxTrades))
+        return { ok: false, why: `trades must be a whole number from 1 to ${FORWARD_LIMITS.maxTrades}` };
+    const bankrollUsd = o.bankrollUsd ?? s.bankroll.startUsd;
+    if (!(Number.isFinite(bankrollUsd) && bankrollUsd >= FORWARD_LIMITS.minBankrollUsd && bankrollUsd <= FORWARD_LIMITS.maxBankrollUsd))
+        return { ok: false, why: `the paper bankroll must be from $${FORWARD_LIMITS.minBankrollUsd} to $${FORWARD_LIMITS.maxBankrollUsd}` };
+    const running = listForwardTests(home).filter((t) => isActive(t, now));
+    const same = running.find((t) => t.strategyId === s.id);
+    if (same)
+        return { ok: false, why: `${s.id} already has a forward test running (${same.forwardId}); stop it first or read its report` };
+    if (running.length >= FORWARD_LIMITS.maxRunning)
+        return { ok: false, why: `${running.length} forward tests are already running (at most ${FORWARD_LIMITS.maxRunning} at once)` };
+    // The frozen document: always paper (a real strategy forward-tests as its paper twin), the test's own bankroll.
+    const doc = { ...structuredClone(raw), mode: 'paper', bankroll: { ...raw.bankroll, startUsd: bankrollUsd } };
+    const v = validateStrategy(doc);
+    if (!v.ok)
+        return { ok: false, why: `${s.id} does not validate as a paper forward test: ${v.errors.map((e) => `${e.path} ${e.msg}`).join('; ')}` };
+    const test = {
+        schema: FORWARD_SCHEMA, forwardId: newForwardId(now), strategyId: s.id, version: s.version, hash: s.hash, rulesHash: rulesHash(s), doc, bankrollUsd,
+        window: { hours, trades }, createdAt: now, by: o.by, source: o.source ?? 'live', stub: !!o.stub, msPerTick: o.msPerTick ?? null,
+        state: 'starting', pid: null, runId: null, startedAt: null, endsAt: null, heartbeatAt: null, endedAt: null, endReason: null, progress: null, metrics: null, problems: [],
+    };
+    saveForwardTest(home, test);
+    return { ok: true, test };
+}
+/** Ask a forward test to end (the host flattens and writes its report). Idempotent. */
+export function requestForwardStop(home, fid, by, now = Date.now()) {
+    const t = loadForwardTest(home, fid);
+    if (!t)
+        return { ok: false, why: `no forward test ${fid}` };
+    const st = liveState(t, now);
+    if (st !== 'starting' && st !== 'running')
+        return { ok: false, why: `${fid} is not running (${st})` };
+    const p = forwardStopPath(home, fid);
+    const already = existsSync(p);
+    if (!already)
+        writeFileSync(p, `${JSON.stringify({ at: now, by })}\n`, { mode: 0o600 });
+    return { ok: true, already, test: t };
+}
+export function forwardStopRequested(home, fid) {
+    const p = forwardStopPath(home, fid);
+    if (!existsSync(p))
+        return null;
+    try {
+        const d = JSON.parse(readFileSync(p, 'utf8'));
+        return { at: Number(d.at) || 0, by: typeof d.by === 'string' ? d.by.slice(0, 40) : 'unknown' };
+    }
+    catch {
+        return { at: 0, by: 'unknown' };
+    }
+}
+/** Mark a test whose host is gone as failed (a reader that finds it `lost` may call this). */
+export function markLost(home, t, now = Date.now()) {
+    const next = { ...t, state: 'failed', endedAt: now, endReason: 'the forward test host stopped without a report (crash, logout or kill)' };
+    saveForwardTest(home, next);
+    recordForwardResult(home, resultOf(next));
+    return next;
+}
+function resultOf(t) {
+    const state = t.state === 'done' || t.state === 'stopped' ? t.state : 'failed';
+    return {
+        kind: 'forward', forwardId: t.forwardId, id: t.strategyId, version: t.version, rulesHash: t.rulesHash, startedAt: t.startedAt ?? t.createdAt, endedAt: t.endedAt ?? Date.now(),
+        // Only a test on live data can be the forward-tested rung: a replay is a backtest in disguise.
+        state: state === 'done' && !t.source.startsWith('live') ? 'stopped' : state,
+        endReason: state === 'done' && !t.source.startsWith('live') ? `${t.endReason ?? 'window reached'} (on a replay, which does not count as a forward test)` : (t.endReason ?? ''),
+        window: t.window, source: t.source, metrics: t.metrics,
+    };
+}
+const dur = (ms) => { const m = Math.max(0, Math.round(ms / 60_000)); return m < 60 ? `${m} min` : `${Math.floor(m / 60)} h ${m % 60} min`; };
+export const windowText = (w) => [w.hours !== null ? `${w.hours} h` : '', w.trades !== null ? `${w.trades} closed trades` : ''].filter(Boolean).join(' or ') + (w.hours !== null && w.trades !== null ? ' (whichever first)' : '');
+/** The forward test next to the backtest (held-out split) of the same rules, from the journey file. */
+export function forwardReport(home, t, now = Date.now()) {
+    const state = liveState(t, now);
+    const bt = latestBacktest(loadJourney(home, t.strategyId), t.rulesHash);
+    const comparison = compareForward(bt, t.metrics);
+    const elapsed = t.startedAt ? dur((t.endedAt ?? now) - t.startedAt) : '0 min';
+    const lines = [
+        `FORWARD TEST ${t.forwardId} · ${t.strategyId} v${t.version} · PAPER · ${t.source} · own bankroll $${t.bankrollUsd}`,
+        `  state ${state.toUpperCase()}${t.endReason ? ` (${t.endReason})` : ''} · window ${windowText(t.window)} · ran ${elapsed}`,
+        t.progress && !t.metrics ? `  so far: ${t.progress.closed} closed · ${t.progress.open} open · equity $${t.progress.equityUsd.toFixed(2)} (${usd(t.progress.netUsd)}) · ${t.progress.candidates} candidates` : '',
+        t.metrics ? `  result: ${metricsLine(t.metrics)}` : '',
+        ...(t.metrics || bt ? ['  forward vs backtest of the same rules (paper, modelled fills; not a prediction, not financial advice):', ...renderComparison(comparison)] : []),
+        t.source.startsWith('live') ? '' : '  NOTE: this ran on a replay, so it is not a forward test of live data and does not count toward the journey',
+    ].filter(Boolean);
+    return { forwardId: t.forwardId, strategyId: t.strategyId, version: t.version, state, source: t.source, window: windowText(t.window), elapsed, endReason: t.endReason, progress: t.progress, metrics: t.metrics, comparison, lines };
+}
+/**
+ * Run a `starting` forward test to its end in this process: own ledger, own book (the frozen paper strategy and its
+ * bankroll), the window, the stop marker and the panic file; then the metrics, the journey record and the summary.
+ */
+export async function hostForward(o) {
+    const { home, forwardId } = o;
+    const clock = o.now ?? Date.now;
+    const say = o.onLine ?? (() => { });
+    let t = loadForwardTest(home, forwardId);
+    if (!t)
+        return { ok: false, why: `no forward test ${forwardId}` };
+    if (!o.source === !o.tape)
+        return { ok: false, why: 'a forward test runs on one live source or one replay tape' };
+    const srcName = o.source?.name ?? `replay ${o.tape.source}`;
+    if (t.state !== 'starting')
+        return { ok: false, why: `${forwardId} is ${t.state}; a forward test runs once` };
+    const v = validateStrategy(t.doc);
+    if (!v.ok || v.strategy.mode !== 'paper')
+        return { ok: false, why: `${forwardId}: the frozen strategy does not validate as paper` };
+    const strategy = v.strategy;
+    const runId = `${new Date(clock()).toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '')}-fwd-${strategy.id}-${forwardId.slice(-4)}`;
+    let closed = 0;
+    const { ledger, files } = fileLedger(home, runId, (e) => { if (e.kind === 'trade_closed')
+        closed++; });
+    const startedAt = clock();
+    t = { ...t, state: 'running', pid: o.pid ?? process.pid, runId, startedAt, heartbeatAt: startedAt };
+    saveForwardTest(home, t);
+    ledger.add(startedAt, 'forward_start', { forwardId, strategy: strategy.id, version: t.version, rulesHash: t.rulesHash, window: t.window, bankrollUsd: t.bankrollUsd, source: srcName, by: t.by });
+    say(`forward test ${forwardId} · ${strategy.id} v${t.version} · PAPER · ${srcName} · own bankroll $${t.bankrollUsd} · window ${windowText(t.window)} · run ${runId}`);
+    // The window clock: tape time on a tape or a lockstep feed; WALL time on live data, where a cached row keeps the
+    // last tick's time and the tape clock can stall (an hours window measured on it might never close).
+    const wall = !o.tape && (o.pacing?.mode ?? 'live') === 'live';
+    let tapeT = null;
+    let endsAt = wall && t.window.hours !== null ? startedAt + t.window.hours * 3_600_000 : null;
+    let ended = null;
+    let endedT = null;
+    let lastStepAt = startedAt;
+    let last = null;
+    let lastBeat = 0;
+    const windowNow = () => (wall ? clock() : tapeT);
+    /** Panic, the stop marker and the window; checked on every step and on every heartbeat (a stream can go quiet). */
+    const checkEnd = (panic) => {
+        if (panic && !ended)
+            ended = { state: 'stopped', reason: `the panic switch is engaged (${panic.reason})` };
+        const stop = forwardStopRequested(home, forwardId);
+        if (stop && !ended)
+            ended = { state: 'stopped', reason: `stopped early by ${stop.by}` };
+        const nowT = windowNow();
+        if (!ended && nowT !== null && endsAt !== null && nowT >= endsAt)
+            ended = { state: 'done', reason: `window reached (${t.window.hours} h)` };
+        if (!ended && t.window.trades !== null && closed >= t.window.trades)
+            ended = { state: 'done', reason: `window reached (${closed} closed trades)` };
+        if (ended && endedT === null)
+            endedT = nowT ?? clock();
+    };
+    const beat = (force = false) => {
+        const n = clock();
+        if (!force && n - lastBeat < FORWARD_HEARTBEAT_MS / 2)
+            return;
+        lastBeat = n;
+        const cur = loadForwardTest(home, forwardId) ?? t;
+        t = { ...cur, heartbeatAt: n, endsAt, progress: last ? { closed, open: last.positions.length, equityUsd: last.book.equityUsd, netUsd: last.book.equityUsd - last.book.startUsd, candidates: last.candidates.length } : cur.progress };
+        try {
+            saveForwardTest(home, t);
+        }
+        catch { /* the next beat retries */ }
+    };
+    const timer = setInterval(() => {
+        beat(true);
+        if (!wall)
+            return;
+        checkEnd(o.killSwitch?.engaged() ?? null);
+        // Ended, but no step for a while (a quiet stream): close the stream so the run ends and the report is written.
+        if (ended && clock() - lastStepAt > STALL_MS)
+            o.source?.stop?.();
+    }, FORWARD_HEARTBEAT_MS);
+    timer.unref?.();
+    const safety = () => {
+        const panic = o.killSwitch?.engaged() ?? null;
+        checkEnd(panic);
+        // The window end flattens at the next tick; a bag that cannot sell (no liquidity) ends the stream after a grace.
+        const nowT = windowNow();
+        if (ended && endedT !== null && nowT !== null && nowT - endedT > FLATTEN_GRACE_MS)
+            o.source?.stop?.();
+        if (ended) {
+            return { halt: ended.state === 'done' ? 'forward-window' : panic ? 'kill-switch' : 'forward-stopped', detail: ended.reason, flatten: true, pauseEntries: null, endWhenFlat: true };
+        }
+        return { halt: null, flatten: false, pauseEntries: null, endWhenFlat: false };
+    };
+    let res = null;
+    let error = null;
+    try {
+        res = await runAutotrade({
+            strategy, ...(o.source ? { source: o.source } : { tape: o.tape }), sessions: o.sessions, gate: o.gate, dossier: o.dossier, vet: o.vet, executor: simExecutor(strategy.execution),
+            pacing: o.pacing ?? { mode: 'live' }, ledger, runId, verbose: true, onLine: say, safety,
+            onState: (st) => {
+                if (!wall && tapeT === null && t.window.hours !== null)
+                    endsAt = st.t + t.window.hours * 3_600_000;
+                tapeT = st.t;
+                lastStepAt = clock();
+                last = st;
+                beat();
+            },
+        });
+    }
+    catch (e) {
+        error = e.message.slice(0, 300);
+    }
+    clearInterval(timer);
+    const endedAt = clock();
+    const cur = loadForwardTest(home, forwardId) ?? t;
+    let metrics = null;
+    if (res) {
+        const r = report(strategy, { source: srcName, ticks: [], mints: [] }, res);
+        metrics = metricsOf(r, runFills(res));
+    }
+    // A live stream that ends by itself (the data layer stopped) before the window is an early end, never "done".
+    const fin = error ? { state: 'failed', reason: `the run failed: ${error}` }
+        : ended ? ended : { state: 'stopped', reason: 'the tick stream ended before the window' };
+    t = { ...cur, state: fin.state, endReason: fin.reason, endedAt, endsAt, heartbeatAt: endedAt, metrics, progress: last ? { closed: metrics?.trades ?? closed, open: res?.openAtEnd.length ?? 0, equityUsd: last.book.equityUsd, netUsd: metrics?.netUsd ?? 0, candidates: res?.candidates ?? 0 } : cur.progress };
+    ledger.add(endedAt, 'forward_end', { forwardId, state: fin.state, reason: fin.reason, ...(metrics ? { trades: metrics.trades, netUsd: metrics.netUsd } : {}) });
+    saveForwardTest(home, t);
+    rmSync(forwardStopPath(home, forwardId), { force: true });
+    recordForwardResult(home, resultOf(t));
+    writeForwardSummary(home, t);
+    say(`forward test ${forwardId} ${fin.state}: ${fin.reason}${metrics ? ` · ${metricsLine(metrics)}` : ''} · ledger ${files.ledger}`);
+    return { ok: true, test: t };
+}
+/** The one-line result real mode's arm panel shows (card A reads `summary`). */
+export function writeForwardSummary(home, t) {
+    if (!t.metrics)
+        return;
+    const days = t.startedAt && t.endedAt ? Math.round(((t.endedAt - t.startedAt) / 86_400_000) * 100) / 100 : null;
+    const counted = t.state === 'done' && t.source.startsWith('live');
+    // ASCII only: real mode's arm panel prints this line through a printable-ASCII filter.
+    const summary = `${t.forwardId} ${t.state}${counted ? '' : ' (does not count)'}; v${t.version}; ${t.metrics.trades} trades; net ${usd(t.metrics.netUsd)} (${t.metrics.netPct}%); ${t.source.startsWith('live') ? 'paper, live data' : 'paper, replay'}${t.metrics.trades < 20 ? '; too few trades to claim anything' : ''}`;
+    mkdirSync(forwardRoot(home), { recursive: true, mode: 0o700 });
+    writeJsonAtomic(forwardSummaryPath(home, t.strategyId), { schema: 'dexterm-forward-summary/1', forwardId: t.forwardId, version: t.version, rulesHash: t.rulesHash, state: t.state, counted, summary, trades: t.metrics.trades, netPct: t.metrics.netPct, days });
+}

package/dist/packages/autotrade/src/index.js

@@ -0,0 +1,72 @@
+// @dexterm/autotrade — the autotrade engine (AUTOTRADE-SPEC, task-1503 AT-1). PAPER ONLY.
+//
+// strategy   the dexterm-strategy/1 document, exit profiles 1.0.0..1.2.0, the validator, presets
+// engine     entry rules on the screener grammar, sizing, the clamp, the constant-product fill model
+// monitor    mechanical exits + wake events (no LLM)
+// replay     the recorded tape (MarketTick) read from the recorder DB or a committed fixture
+// session    the decision protocol, dossier/delta text, the stub session (types for the runner card)
+// runner     the run loop (lockstep for backtests, paced for replays, live for `autotrade run`), lock + rendezvous
+// ledger     the hash-chained run ledger, runs/<runId>.jsonl, chain verification (task-1505)
+// sessions   the user's own `claude -p` sessions, day caps + allowance guard, the mcp dossier (task-1505)
+// live-source  Store-fed MarketTicks: the screener pool every 10 s, candidate/held coins every 5 s (task-1505)
+// runner-config / account  runner.json (dexterm-runner/1) and the four Claude account kinds (task-1505)
+// backtest   the report, every-candidate mode, runner recall, held-out split + sweeps
+// store      ~/.dexterm/strategies/<id>.json CRUD + the append-only .journal.jsonl
+// desk-executor   orders through the app's paper desk (armed paper-only mandate, exit plans, quote-sized cost recovery)
+// monitor-daemon  the position monitor process: §5 exits on the desk, one wake message per tick, restart recovery
+// safety     stop / flatten / pause (the control file), the kill switch + dead-man every step, the run audit, session isolation (task-1509)
+// fleet      parallel strategies: N strategies on one feed, each with its own book, ledger, caps and budget, under global caps (task-1529)
+// fleet-config / fleet-control  autotrade.json (dexterm-autotrade/1), per-strategy control files, the fleet status + comparison table
+// paper-accounts  shared paper accounts: many strategies trading from one simulated wallet, one strategy on many (task-1538)
+// trade-ledger  the run ledgers as unified trade ledger drafts (task-1530, read-only)
+// execution-port  where an approved entry goes: the paper port (local single-use proofs) and the live stub (task-1527)
+// chat       Telegram notify, control and approve-to-trade through the user's own bot; chat/ (task-1527)
+// yolo       task-1532: the full-port replay (rugs, loss spread, how often it zeroed the wallet); paper only
+// signal / outbox / signal-channels / receipts / real-mode  task-1645: mode real = the paper engine + a LIVE TRADE FIRE
+//            signal per fill to the user's own executor (webhook, command hook, JSONL, MCP feed, Telegram copy); no key
+// limits / executor-health / report  task-1654: every real-mode limit user-set per scope (stricter wins), executor
+//            heartbeats + the silence pause, the paper-vs-real divergence report and the digest
+//
+// The screener filter grammar is imported by path from the CLI's screener (one parser for the screen and
+// for strategies); nothing in this package touches a key or a wallet, and nothing places a live order (task-1571). The desk executor
+// trades only through the paper desk (a paper executor, by construction) on a keyless quote.
+export * from "./strategy.js";
+export * from "./engine.js";
+export * from "./monitor.js";
+export * from "./replay.js";
+export * from "./session.js";
+export * from "./runner.js";
+export * from "./ledger.js";
+export * from "./sessions.js";
+export * from "./live-source.js";
+export * from "./runner-config.js";
+export * from "./basis-text.js";
+export * from "./account.js";
+export * from "./backtest.js";
+export * from "./store.js";
+export * from "./desk-executor.js";
+export * from "./monitor-daemon.js";
+export * from "./safety.js";
+export * from "./fleet-config.js";
+export * from "./fleet-control.js";
+export * from "./fleet.js";
+export * from "./paper-accounts.js";
+export * from "./trade-ledger.js";
+export * from "./execution-port.js";
+export * from "./chat/index.js";
+export * from "./yolo.js";
+export * from "./signal.js";
+export * from "./outbox.js";
+export * from "./signal-channels.js";
+export * from "./receipts.js";
+export * from "./real-mode.js";
+export * from "./journey.js";
+export * from "./forward.js";
+export * from "./service.js";
+export * from "./service-guard.js";
+export * from "./service-recover.js";
+export * from "./service-install.js";
+export * from "./limits.js";
+export * from "./paper-limits.js";
+export * from "./executor-health.js";
+export * from "./report.js";