dexterm-cli 0.1.6 → 0.2.0

package/dist/packages/autotrade/src/execution-port.js

@@ -0,0 +1,97 @@
+// dexterm autotrade — the execution port (task-1527, AUTOTRADE-SPEC §8.1, §8.5 step 7). PAPER today.
+//
+// Where an approved entry goes. The runner's Executor (sim book, paper desk) is the paper side; a live port (the
+// local signer with its caps, a later card) is the other side, behind the same three calls:
+//
+//   entryBlock()      why no entry can go through right now (null = ready). A live port says "live is off", "the
+//                     wallet is locked", "the kill switch is engaged", "no caps file" here.
+//   confirmRemote()   a chat button approved this exact order. The port cannot check the chat itself (it holds no
+//                     bot token), so it gets the connector's evidence {proposalHash, senderId, chatId, updateId} and
+//                     answers with a SINGLE-USE proof bound to the order's hash, or a refusal. A live port checks its
+//                     own caps here (per trade at the remote-button tier, its remote daily cap, the allowed
+//                     strategies, slippage and impact) and refuses anything outside them, whatever the broker said.
+//   buy() / sell()    the Executor calls; an approved buy carries its proof in ctx and a port that issued proofs
+//                     refuses a buy whose proof is missing, spent, expired or bound to another order (the proof is
+//                     bound to the order's hash and the proposal id, and needs a 64-hex proposal hash).
+//
+// The port has no `badge` field: the runner's Executor may carry its own optional order-line badge (DEVNET/LIVE, the
+// live signer's executor), and PAPER must never print there. Chat derives its badge from `network` (badgeOf).
+//
+// The paper port issues its proofs locally (there is nothing to sign). The live stub refuses everything: it exists
+// so the approval path, the runner and the docs can name the live side before it is installed, and so a
+// misconfiguration fails closed. Nothing in this file holds a key, signs, or touches the network.
+import { createHash, randomBytes } from 'node:crypto';
+import { canonical } from "./strategy.js";
+export const badgeOf = (n) => (n === 'paper' ? 'PAPER' : n === 'devnet' ? 'DEVNET' : 'LIVE');
+/** sha256 (hex, 32 chars) of the canonical order: the proof binds to it (the runner hands it back in OrderContext). */
+export const orderHash = (o) => createHash('sha256').update(canonical(o)).digest('hex').slice(0, 32);
+export const PROOF_TTL_MS = 30_000;
+const PROPOSAL_HASH = /^[0-9a-f]{64}$/;
+/**
+ * The paper side: the runner's Executor behind the port calls. confirmRemote issues a local single-use proof
+ * (PROOF_TTL_MS) for the order; a buy that carries a proofId must match it (order hash, proposal id, mint, size
+ * at most the approved one) and spends it. A buy
+ * without one is an ordinary runner entry (no approval was required) and goes straight to the executor.
+ */
+export class PaperPort {
+    network = 'paper';
+    name;
+    exec;
+    proofs = new Map();
+    now;
+    block;
+    constructor(exec, o = {}) {
+        this.exec = exec;
+        this.name = `paper-port(${exec.name})`;
+        this.now = o.now ?? Date.now;
+        this.block = o.entryBlock ?? (() => null);
+    }
+    entryBlock() { return this.block(); }
+    async confirmRemote(order, ev) {
+        if (order.network !== 'paper')
+            return { ok: false, refused: 'port-network-mismatch' };
+        if (ev.tier !== 'remote-button')
+            return { ok: false, refused: 'tier-unknown' };
+        if (!PROPOSAL_HASH.test(ev.proposalHash) || !ev.proposalId)
+            return { ok: false, refused: 'evidence-malformed' };
+        const b = this.entryBlock();
+        if (b)
+            return { ok: false, refused: b };
+        if (!(order.usd > 0))
+            return { ok: false, refused: 'size-not-positive' };
+        const proofId = randomBytes(12).toString('base64url');
+        const expiresAt = this.now() + PROOF_TTL_MS;
+        this.proofs.set(proofId, { orderHash: orderHash(order), proposalId: ev.proposalId, usd: order.usd, mint: order.mint, expiresAt });
+        return { ok: true, proofId, expiresAt };
+    }
+    async buy(k, usd, ctx) {
+        if (ctx?.proofId !== undefined) {
+            const p = this.proofs.get(ctx.proofId);
+            this.proofs.delete(ctx.proofId); // single use, whatever happens next
+            if (!p)
+                return { refused: 'proof-unknown-or-spent' };
+            if (this.now() > p.expiresAt)
+                return { refused: 'proof-expired' };
+            if (ctx.orderHash !== p.orderHash || ctx.proposalId !== p.proposalId || p.mint !== k.mint || usd > p.usd + 1e-9)
+                return { refused: 'proof-order-mismatch' };
+        }
+        return this.exec.buy(k, usd, ctx);
+    }
+    sell(k, tokens, reason) {
+        return this.exec.sell(k, tokens, reason);
+    }
+}
+/**
+ * The live side before it is installed: every call refuses. A runner or a broker that is handed this port takes no
+ * entry and says why; exits that would need it are refused too (a live position cannot exist without a live port).
+ */
+export class LivePortStub {
+    network;
+    name = 'live-port-stub';
+    static REASON = 'live-port-not-installed';
+    constructor(network = 'devnet') { this.network = network; }
+    entryBlock() { return LivePortStub.REASON; }
+    async confirmRemote() { return { ok: false, refused: LivePortStub.REASON }; }
+    buy() { return { refused: LivePortStub.REASON }; }
+    sell() { return { refused: LivePortStub.REASON }; }
+}

package/dist/packages/autotrade/src/executor-health.js

@@ -0,0 +1,217 @@
+// dexterm autotrade — executor health: heartbeats, the silence pause, the loopback listener (task-1654, 0.2.0 card E).
+//
+// Your executor (or the reference kit, examples/executor/) says it is alive by appending a
+// `dexterm-executor-heartbeat/1` line to $DEXTERM_HOME/autotrade/real/executor.jsonl, by running
+// `dexterm autotrade executor heartbeat`, or by POSTing it to the optional loopback listener a real run opens
+// (`dexterm autotrade signal channels --executor-port N`: 127.0.0.1 only, the same HMAC as the webhook when a secret
+// is set, /heartbeat and /receipt, 4 KB bodies). A receipt, and an ack on the webhook or command hook, count as
+// signs of life too (the JSONL stream and the MCP feed prove nothing: dexterm writes those itself).
+//
+// When nothing has been heard for longer than the user's `executorSilenceMin` (limits.json; placeholder 15 min) a real
+// run PAUSES new buy signals and says so (run log, Telegram). Exits still go out, and the kill switch and the TTL are
+// unchanged. When the executor is heard again, buys resume and that is said too. Heartbeats are data: they never make
+// dexterm do anything except pause or resume.
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readSync, renameSync, statSync, writeSync, fsyncSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { realDir } from "./outbox.js";
+import { appendReceipt, readReceipts, validateReceipt } from "./receipts.js";
+import { ACCOUNT_ID_RE, verifyBody } from "./signal.js";
+export const HEARTBEAT_SCHEMA = 'dexterm-executor-heartbeat/1';
+export const heartbeatPath = (home) => join(realDir(home), 'executor.jsonl');
+const ROTATE_ABOVE = 1 << 20;
+const TAIL_BYTES = 64 << 10;
+const text = (v, max) => { if (typeof v !== 'string')
+    return null; const t = v.replace(/[^\x20-\x7e]/g, '').trim().slice(0, max); return t || null; };
+export function validateHeartbeat(x) {
+    const h = x;
+    if (!h || typeof h !== 'object')
+        return { ok: false, error: 'not an object' };
+    if (h.schema !== HEARTBEAT_SCHEMA)
+        return { ok: false, error: 'schema' };
+    if (typeof h.at !== 'number' || !Number.isFinite(h.at) || h.at <= 0)
+        return { ok: false, error: 'at' };
+    const executor = text(h.executor, 32);
+    if (!executor)
+        return { ok: false, error: 'executor' };
+    if (h.accountId !== undefined && h.accountId !== null && (typeof h.accountId !== 'string' || !ACCOUNT_ID_RE.test(h.accountId)))
+        return { ok: false, error: 'accountId' };
+    if (h.lastNonce !== undefined && h.lastNonce !== null && (!Number.isSafeInteger(h.lastNonce) || h.lastNonce < 0))
+        return { ok: false, error: 'lastNonce' };
+    return { ok: true, heartbeat: { schema: HEARTBEAT_SCHEMA, at: h.at, executor, accountId: typeof h.accountId === 'string' ? h.accountId : null, dryRun: typeof h.dryRun === 'boolean' ? h.dryRun : null, lastNonce: typeof h.lastNonce === 'number' ? h.lastNonce : null, note: text(h.note, 120) } };
+}
+/** Append one heartbeat (fsync); the file is rotated to executor.1.jsonl past 1 MB. */
+export function appendHeartbeat(home, hb) {
+    const v = validateHeartbeat({ ...hb, schema: HEARTBEAT_SCHEMA });
+    if (!v.ok)
+        throw new Error(`heartbeat: ${v.error}`);
+    mkdirSync(realDir(home), { recursive: true, mode: 0o700 });
+    const p = heartbeatPath(home);
+    try {
+        if (statSync(p).size > ROTATE_ABOVE)
+            renameSync(p, join(realDir(home), 'executor.1.jsonl'));
+    }
+    catch { /* no file yet */ }
+    const fd = openSync(p, 'a', 0o600);
+    try {
+        writeSync(fd, `${JSON.stringify(v.heartbeat)}\n`);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    return v.heartbeat;
+}
+const hbCache = new Map();
+/** The newest valid heartbeat (reads only the last 64 KB, and only when the file changed since the last read). */
+export function lastHeartbeat(home) {
+    const p = heartbeatPath(home);
+    if (!existsSync(p))
+        return null;
+    const fd = openSync(p, 'r');
+    try {
+        const st = fstatSync(fd);
+        const size = st.size;
+        const c = hbCache.get(p);
+        if (c && c.size === size && c.mtimeMs === st.mtimeMs)
+            return c.hb;
+        const n = Math.min(size, TAIL_BYTES);
+        const buf = Buffer.alloc(n);
+        readSync(fd, buf, 0, n, size - n);
+        const lines = buf.toString('utf8').split('\n');
+        let best = null;
+        for (const l of lines) {
+            if (!l.trim())
+                continue;
+            try {
+                const v = validateHeartbeat(JSON.parse(l));
+                if (v.ok && (!best || v.heartbeat.at > best.at))
+                    best = v.heartbeat;
+            }
+            catch { /* torn or partial line */ }
+        }
+        hbCache.set(p, { size, mtimeMs: st.mtimeMs, hb: best });
+        return best;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * How the executor looks now. `ackAt` = the newest ack on the webhook or command hook (the outbox's channel health,
+ * this process); `since` = a floor for "last seen" (the run's start: a run is not paused in its first window).
+ */
+export function executorHealth(home, o) {
+    const hb = lastHeartbeat(home);
+    const receipts = o.receipts ?? readReceipts(home).receipts;
+    const last = receipts.reduce((a, r) => (!a || r.at > a.at ? r : a), null);
+    const cands = [];
+    if (hb)
+        cands.push([hb.at, 'heartbeat']);
+    if (last)
+        cands.push([last.at, 'receipt']);
+    if (o.ackAt)
+        cands.push([o.ackAt, 'ack']);
+    if (o.since)
+        cands.push([o.since, 'run-start']);
+    const best = cands.reduce((a, c) => (!a || c[0] > a[0] ? c : a), null);
+    const lags = [];
+    if (o.signal)
+        for (const r of receipts.slice(-20)) {
+            const s = o.signal(r.nonce);
+            if (s && s.id === r.signalId)
+                lags.push(Math.max(0, (r.at - s.issuedAt) / 1000));
+        }
+    lags.sort((a, b) => a - b);
+    const silentSec = best ? Math.max(0, Math.round((o.now - best[0]) / 1000)) : null;
+    const windowMin = o.windowMin ?? null;
+    return {
+        alive: windowMin === null ? null : silentSec !== null && silentSec <= windowMin * 60,
+        windowMin, lastSeenAt: best?.[0] ?? null, lastSeenBy: best?.[1] ?? null, silentSec,
+        heartbeat: hb ? { at: hb.at, executor: hb.executor, dryRun: hb.dryRun, lastNonce: hb.lastNonce } : null,
+        lastReceipt: last ? { at: last.at, nonce: last.nonce, status: last.status } : null,
+        receiptLagSec: lags.length ? Math.round(lags[Math.floor(lags.length / 2)] * 10) / 10 : null,
+    };
+}
+const ago = (sec) => (sec < 90 ? `${sec} s` : sec < 5400 ? `${Math.round(sec / 60)} min` : `${Math.round(sec / 3600)} h`);
+export function healthLine(h) {
+    const state = h.alive === null ? (h.lastSeenAt ? 'seen' : 'never seen') : h.alive ? 'ALIVE' : 'SILENT';
+    const parts = [state];
+    if (h.silentSec !== null && h.lastSeenBy && h.lastSeenBy !== 'run-start')
+        parts.push(`last ${h.lastSeenBy} ${ago(h.silentSec)} ago`);
+    else if (h.lastSeenBy === 'run-start')
+        parts.push('nothing heard since the run started');
+    if (h.heartbeat)
+        parts.push(`${h.heartbeat.executor}${h.heartbeat.dryRun ? ' (dry run)' : ''}`);
+    if (h.lastReceipt)
+        parts.push(`last receipt #${h.lastReceipt.nonce} ${h.lastReceipt.status}`);
+    if (h.receiptLagSec !== null)
+        parts.push(`receipt lag ${h.receiptLagSec} s`);
+    if (h.windowMin !== null)
+        parts.push(`pause after ${h.windowMin} min silent`);
+    return parts.join(' · ');
+}
+/**
+ * A loopback-only HTTP listener for executors that prefer to POST: /heartbeat (a heartbeat body) and /receipt (a
+ * receipt body). With a secret, the `x-dexterm-signature` header (the webhook's scheme) is required. Writes the same
+ * files the CLI and the kit append to. Never acts on anything.
+ */
+export function startExecutorListener(o) {
+    const host = o.host ?? '127.0.0.1';
+    if (!['127.0.0.1', '::1', 'localhost'].includes(host))
+        return Promise.reject(new Error('the executor listener binds to loopback only'));
+    const now = o.now ?? Date.now;
+    const server = createServer((req, res) => {
+        const reply = (code, body) => { res.writeHead(code, { 'content-type': 'text/plain' }); res.end(body); };
+        if (req.method !== 'POST' || (req.url !== '/heartbeat' && req.url !== '/receipt'))
+            return reply(404, 'POST /heartbeat or /receipt');
+        let body = '';
+        let tooBig = false;
+        req.setEncoding('utf8');
+        req.on('data', (c) => { body += c; if (body.length > 4096) {
+            tooBig = true;
+            req.destroy();
+        } });
+        req.on('end', () => {
+            if (tooBig)
+                return;
+            const secret = o.secret?.() ?? null;
+            if (secret) {
+                const v = verifyBody(secret, req.headers['x-dexterm-signature'], body, now());
+                if (!v.ok)
+                    return reply(401, v.why);
+            }
+            let raw;
+            try {
+                raw = JSON.parse(body);
+            }
+            catch {
+                return reply(400, 'not json');
+            }
+            try {
+                if (req.url === '/heartbeat') {
+                    const v = validateHeartbeat({ ...raw, schema: HEARTBEAT_SCHEMA });
+                    if (!v.ok)
+                        return reply(400, v.error);
+                    appendHeartbeat(o.home, v.heartbeat);
+                    return reply(204, '');
+                }
+                const v = validateReceipt(raw);
+                if (!v.ok)
+                    return reply(400, v.error);
+                appendReceipt(o.home, v.receipt);
+                return reply(204, '');
+            }
+            catch (e) {
+                return reply(500, e.message.slice(0, 80));
+            }
+        });
+    });
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(o.port, host, () => {
+            const a = server.address();
+            resolve({ port: typeof a === 'object' && a ? a.port : o.port, close: () => new Promise((r) => server.close(() => r())) });
+        });
+    });
+}

package/dist/packages/autotrade/src/fleet-config.js

@@ -0,0 +1,169 @@
+// dexterm autotrade — the multi-strategy config, `autotrade.json` (task-1529, parallel strategies). PAPER today.
+//
+// $DEXTERM_HOME/autotrade/autotrade.json, schema dexterm-autotrade/1, lists the strategies one runner process runs at
+// the same time on the same live data feed. Each one is a MEMBER with its own id, its own bankroll, its own run
+// ledger, caps, breaker, candidate sessions and spend budget; `global` holds the caps across all of them:
+//
+//   { "schema": "dexterm-autotrade/1",
+//     "strategies": [
+//       { "id": "moon-a", "preset": "moonbag", "bankroll": { "usd": 500 } },
+//       { "id": "yolo",   "preset": "my-yolo", "bankroll": { "sol": 1 }, "caps": { "modelUsdPerDay": 2, "maxSessions": 1 } },
+//       { "id": "dip",    "file": "/abs/path/dip.json", "bankroll": { "usd": 200 }, "enabled": false } ],
+//     "global": { "maxConcurrentSessions": 3, "modelUsdPerDay": 15, "candidateSessionsPerDay": 60 } }
+//
+// `preset` names a shipped preset or one of the user's own strategies (~/.dexterm/strategies); `file` is an absolute
+// path to a strategy file. Member caps can only TIGHTEN: the stricter of the strategy, the member caps, runner.json
+// and the global caps applies, so a shared config can never loosen a strategy. `mode` is "paper" (the default);
+// "live" is refused (task-1571: dexterm holds no key and places no live order).
+//
+// Paper ACCOUNTS (task-1538): `accounts` lists shared simulated wallets, and a strategy with `account` trades from
+// that wallet's cash instead of its own bankroll, next to every other strategy on it (paper-accounts.ts). One strategy
+// is not tied to one account: `"account": ["main", "yolo"]` runs it once per account, as members `<id>-main` and
+// `<id>-yolo` (each its own run, ledger, positions and caps):
+//
+//     "accounts": [ { "id": "main", "bankroll": { "usd": 1000 } }, { "id": "yolo", "bankroll": { "sol": 1 } } ],
+//     "strategies": [ { "id": "moon", "preset": "moonbag", "account": "main" },
+//                     { "id": "scalp", "preset": "scalp", "account": ["main", "yolo"] } ]
+//
+// A member on an account takes no `bankroll` of its own (the account holds the money). Accounts are paper only.
+//
+// The file is user data: no login, no key, no token, no wallet address (a paper account is a name and a starting
+// balance). Like runner.json, it is machine-local.
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { validate } from '../../custom/src/index.js';
+import { STRATEGY_ID } from "./store.js";
+import { MAX_PAPER_ACCOUNTS } from "./paper-accounts.js";
+import { strategyHash } from "./strategy.js";
+export const FLEET_CONFIG_SCHEMA = 'dexterm-autotrade/1';
+export const fleetConfigPath = (home) => join(home, 'autotrade', 'autotrade.json');
+/** How many strategies one process runs at most (each one is a book, a ledger and up to its own session cap). */
+export const MAX_MEMBERS = 8;
+export const DEFAULT_GLOBAL_CAPS = { maxConcurrentSessions: 3, modelUsdPerDay: 20, candidateSessionsPerDay: 96, positionSessionsPerDay: 96, turnsPerDay: 4000 };
+const num = (min, max, int = false) => ({ type: 'number', min, max, int });
+const CAPS = { type: 'object', additional: false, props: {
+        maxSessions: num(1, 8, true), modelUsdPerDay: num(0, 10_000), candidateSessionsPerDay: num(0, 10_000, true), positionSessionsPerDay: num(0, 10_000, true), turnsPerDay: num(0, 1_000_000, true),
+    } };
+const BANKROLL = { oneOf: [
+        { type: 'object', additional: false, required: ['usd'], props: { usd: num(1, 1e7) } },
+        { type: 'object', additional: false, required: ['sol'], props: { sol: num(0.001, 1e5) } },
+    ] };
+const ACCOUNT_REF = { oneOf: [
+        { type: 'string', pattern: STRATEGY_ID.source },
+        { type: 'array', max: MAX_PAPER_ACCOUNTS, items: { type: 'string', pattern: STRATEGY_ID.source } },
+    ] };
+const SCHEMA = {
+    type: 'object', additional: false, required: ['schema', 'strategies'],
+    props: {
+        schema: { type: 'string', enum: [FLEET_CONFIG_SCHEMA] },
+        strategies: { type: 'array', max: MAX_MEMBERS, items: {
+                type: 'object', additional: false, required: ['id'],
+                props: {
+                    id: { type: 'string', pattern: STRATEGY_ID.source },
+                    preset: { type: 'string', pattern: STRATEGY_ID.source },
+                    file: { type: 'string', max: 500 },
+                    bankroll: BANKROLL,
+                    account: ACCOUNT_REF,
+                    mode: { type: 'string', enum: ['paper', 'live'] },
+                    enabled: { type: 'boolean' },
+                    caps: CAPS,
+                },
+            } },
+        global: { type: 'object', additional: false, props: {
+                maxConcurrentSessions: num(1, 32, true), modelUsdPerDay: num(0, 10_000), candidateSessionsPerDay: num(0, 10_000, true), positionSessionsPerDay: num(0, 10_000, true), turnsPerDay: num(0, 1_000_000, true),
+            } },
+        solUsd: num(1, 100_000),
+        accounts: { type: 'array', max: MAX_PAPER_ACCOUNTS, items: {
+                type: 'object', additional: false, required: ['id', 'bankroll'],
+                props: { id: { type: 'string', pattern: STRATEGY_ID.source }, bankroll: BANKROLL },
+            } },
+    },
+};
+/** Validate a parsed autotrade.json and fill the defaults. */
+export function parseFleetConfig(doc, path = 'autotrade.json', o = {}) {
+    const errs = validate(SCHEMA, doc, '');
+    if (errs.length)
+        return { ok: false, errors: errs.map((e) => `${e.path || '/'} ${e.msg}`), path };
+    const d = doc;
+    const errors = [];
+    const accounts = d.accounts ?? [];
+    const accountIds = new Set();
+    accounts.forEach((a, i) => { if (accountIds.has(a.id))
+        errors.push(`/accounts/${i}/id ${a.id} is used twice (every paper account needs its own id)`); accountIds.add(a.id); });
+    const seen = new Set();
+    const strategies = [];
+    d.strategies.forEach((m, i) => {
+        const at = `/strategies/${i}`;
+        if (!!m.preset === !!m.file)
+            errors.push(`${at} needs exactly one of preset or file`);
+        if (m.file && !m.file.startsWith('/'))
+            errors.push(`${at}/file must be an absolute path`);
+        if (m.mode === 'live' && !o.liveAvailable)
+            errors.push(`${at}/mode live execution is not available for parallel strategies in this build; every strategy runs on paper`);
+        const refs = m.account === undefined ? [] : Array.isArray(m.account) ? m.account : [m.account];
+        if (m.account !== undefined) {
+            if (!refs.length)
+                errors.push(`${at}/account lists no paper account`);
+            if (new Set(refs).size !== refs.length)
+                errors.push(`${at}/account names an account twice`);
+            for (const a of refs)
+                if (!accountIds.has(a))
+                    errors.push(`${at}/account ${a} is not a paper account in /accounts`);
+            if (m.bankroll)
+                errors.push(`${at}/bankroll a strategy on a paper account trades from the account's balance; drop its own bankroll`);
+            if (m.mode === 'live')
+                errors.push(`${at}/account paper accounts hold simulated cash only; a live strategy cannot use one`);
+        }
+        const base = { ...(m.preset ? { preset: m.preset } : {}), ...(m.file ? { file: m.file } : {}), ...(m.bankroll ? { bankroll: m.bankroll } : {}), mode: m.mode ?? 'paper', enabled: m.enabled ?? true, caps: m.caps ?? {} };
+        // A list of accounts runs the same strategy once per account: one member each, `<id>-<account>`.
+        const ids = Array.isArray(m.account) ? m.account.map((a) => ({ id: `${m.id}-${a}`, account: a })) : [{ id: m.id, account: refs[0] }];
+        for (const x of ids) {
+            if (!STRATEGY_ID.test(x.id))
+                errors.push(`${at}/account ${x.id} (strategy id + "-" + account id) is not a valid member id (lowercase, at most 32 characters): shorten one of them`);
+            if (seen.has(x.id))
+                errors.push(`${at}/id ${x.id} is used twice (every strategy in the list needs its own id)`);
+            seen.add(x.id);
+            strategies.push({ id: x.id, ...base, ...(x.account ? { account: x.account } : {}), ...(Array.isArray(m.account) ? { entry: m.id } : {}) });
+        }
+    });
+    if (!strategies.length)
+        errors.push('/strategies lists no strategy');
+    if (strategies.length > MAX_MEMBERS)
+        errors.push(`/strategies ${strategies.length} strategy runs (after one per listed account); at most ${MAX_MEMBERS} run at once`);
+    if (errors.length)
+        return { ok: false, errors, path };
+    return { ok: true, config: { schema: FLEET_CONFIG_SCHEMA, strategies, global: { ...DEFAULT_GLOBAL_CAPS, ...d.global }, ...(accounts.length ? { accounts: accounts.map((a) => ({ id: a.id, bankroll: a.bankroll })) } : {}), ...(d.solUsd ? { solUsd: d.solUsd } : {}) }, path };
+}
+export function loadFleetConfig(home, file, o = {}) {
+    const path = file ?? fleetConfigPath(home);
+    if (!existsSync(path))
+        return { ok: false, missing: true, path, errors: [`no ${path}: list the strategies to run at once there (dexterm autotrade run --all --help)`] };
+    let doc;
+    try {
+        doc = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (e) {
+        return { ok: false, errors: [`not JSON: ${e.message}`], path };
+    }
+    return parseFleetConfig(doc, path, o);
+}
+/**
+ * A member's strategy: the resolved strategy under the member's id, with the member's bankroll, re-hashed so every
+ * ledger line names the exact rules it ran (two members on one preset with different bankrolls hash differently).
+ * The base strategy's id / version / hash stay in `basedOn` (the member's first ledger line).
+ */
+export function memberStrategy(base, m, startUsd) {
+    const { hash: _h, ...rest } = base;
+    const body = { ...rest, id: m.id, bankroll: { ...base.bankroll, ...(startUsd !== null ? { startUsd } : {}), source: 'fixed' } };
+    return { strategy: { ...body, hash: strategyHash(body) }, basedOn: { id: base.id, version: base.version, hash: base.hash } };
+}
+/** The bankroll in USD (a SOL bankroll at the given SOL price), or null when the strategy's own startUsd applies. */
+export function bankrollUsd(b, solUsd) {
+    if (!b)
+        return { usd: null };
+    if ('usd' in b)
+        return { usd: b.usd };
+    if (!solUsd || !(solUsd > 0))
+        return { usd: null, error: 'a SOL bankroll needs the SOL price (live: read at start; a replay: "solUsd" in autotrade.json or --sol-usd)' };
+    return { usd: Math.round(b.sol * solUsd * 100) / 100 };
+}