dexterm-cli 0.1.5 → 0.1.7

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

@@ -0,0 +1,639 @@
+// dexterm autotrade — parallel strategies: N strategies on ONE data feed (task-1529). PAPER today.
+//
+//                    ┌──────────── one source (the live keyless data layer, or one tape) ────────────┐
+//                    │   focus = the union of every strategy's candidate + held coins (one fast lane) │
+//                    └──────────────────────────────┬─────────────────────────────────────────────────┘
+//                                       TickHub.publish(k)  (a tape: a barrier, so a replay is deterministic)
+//              ┌────────────────────────────────────┼────────────────────────────────────┐
+//        member A: runAutotrade             member B: runAutotrade               member C …
+//        own book (bankroll), breaker,      own book, breaker, ledger,
+//        ledger + run id, entry rules,      entry rules, sessions, spend
+//        sessions, spend budget             budget
+//              │  MemberGate ─────────────── FleetGuard (global: model sessions open at once, $/day, sessions/day,
+//              │                                         turns/day, the shared Claude allowance, ONE load check)
+//              └── safety: the fleet's RunnerSafety (panic file, global stop/flatten/pause, dead-man) ⊕ the
+//                  strategy's own MemberSafety (fleet-control.ts)
+//
+// Each member is an ordinary runAutotrade run (runner.ts, unchanged): its own SimBook, so a breaker (daily loss,
+// drawdown) or a stop of one strategy never stops another; only the global switches reach all of them. The shared
+// parts never multiply work: one source fetches for everyone (each strategy screens the same ticks with its own entry
+// rules), one dossier per coin per 30 s whoever asks (sharedDossier), one load sample per 5 s.
+//
+// Paper accounts (task-1538, paper-accounts.ts): members that name an account share that account's cash instead of
+// owning a bankroll; each keeps its own book of positions, breaker and ledger. One strategy can run on several accounts
+// (one member per account). The accounts live for the run: a member started again joins the same account.
+//
+// Execution: every member binds its own executor (bindExecutors). Paper members each get their own simulated book.
+// Live members (refused in this build: fleet-config.ts) would share ONE port per trading wallet, so their orders meet
+// the same signer and its caps together: two live strategies can never exceed the wallet's caps between them.
+//
+// Nothing here holds a key, touches a wallet or the signer.
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, rmSync } from 'node:fs';
+import { loadavg } from 'node:os';
+import { Ledger, runFiles, runsDir } from "./ledger.js";
+import { SessionGate } from "./sessions.js";
+import { effectiveCaps } from "./runner-config.js";
+import { runAutotrade, simExecutor } from "./runner.js";
+import { PaperAccount } from "./paper-accounts.js";
+import { FLEET_STATUS_SCHEMA, MISSED_RUNNER_X, MemberSafety, isRugExit, mergeVerdicts, readMemberControl, memberControlPath, } from "./fleet-control.js";
+/**
+ * Fan-out of one tick stream. `barrier` (tapes): a tick goes out only once every subscriber has taken the previous
+ * one and asked for more, so N strategies over one tape run in a fixed order. Live: no barrier (a slow strategy never
+ * holds the others back); a subscriber more than `maxQueue` ticks behind loses its oldest ones (counted).
+ */
+export class TickHub {
+    subs = new Map();
+    ended = false;
+    notify = null;
+    barrier;
+    maxQueue;
+    constructor(o) { this.barrier = o.barrier; this.maxQueue = o.maxQueue ?? 5000; }
+    changed() { const n = this.notify; this.notify = null; n?.(); }
+    /** `id` must be unique per subscription (a run id): a re-started strategy gets a new one. */
+    subscribe(id) {
+        if (this.subs.has(id))
+            throw new Error(`tick hub: ${id} is already subscribed`);
+        const sub = { id, queue: [], waiter: null, closed: false, dropped: 0 };
+        this.subs.set(id, sub);
+        const close = () => { if (!sub.closed) {
+            sub.closed = true;
+            this.subs.delete(id);
+            this.changed();
+        } };
+        const it = {
+            next: () => {
+                if (sub.queue.length)
+                    return Promise.resolve({ value: sub.queue.shift(), done: false });
+                if (this.ended || sub.closed) {
+                    close();
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => { sub.waiter = resolve; this.changed(); });
+            },
+            return: () => { close(); return Promise.resolve({ value: undefined, done: true }); },
+        };
+        return { [Symbol.asyncIterator]: () => it };
+    }
+    /** True when every subscriber has drained its queue and waits for more (or has gone). */
+    caughtUp() {
+        for (const s of this.subs.values())
+            if (!s.closed && (s.queue.length || !s.waiter))
+                return false;
+        return true;
+    }
+    async publish(k) {
+        if (this.barrier)
+            while (!this.caughtUp())
+                await new Promise((r) => { this.notify = r; });
+        for (const s of this.subs.values()) {
+            // Each strategy gets its own copy: nothing one run does to a tick can leak into another's.
+            const mine = { ...k };
+            if (s.waiter) {
+                const w = s.waiter;
+                s.waiter = null;
+                w({ value: mine, done: false });
+                continue;
+            }
+            s.queue.push(mine);
+            if (s.queue.length > this.maxQueue) {
+                s.queue.shift();
+                s.dropped++;
+            }
+        }
+    }
+    /** Wait until every subscriber took everything (the end of a tape). */
+    async drain() { while (!this.caughtUp())
+        await new Promise((r) => { this.notify = r; }); }
+    end() {
+        this.ended = true;
+        for (const s of [...this.subs.values()])
+            if (s.waiter && !s.queue.length) {
+                const w = s.waiter;
+                s.waiter = null;
+                s.closed = true;
+                this.subs.delete(s.id);
+                w({ value: undefined, done: true });
+            }
+    }
+    /** Drop a subscriber that will never ask again (a run that failed before its first tick), so a barrier never waits on it. */
+    unsubscribe(id) {
+        const s = this.subs.get(id);
+        if (!s)
+            return;
+        s.closed = true;
+        this.subs.delete(id);
+        if (s.waiter) {
+            const w = s.waiter;
+            s.waiter = null;
+            w({ value: undefined, done: true });
+        }
+        this.changed();
+    }
+    get size() { return this.subs.size; }
+    droppedBy(id) { return this.subs.get(id)?.dropped ?? 0; }
+}
+export const DEFAULT_FLEET_LOAD = { pauseAboveLoad1m: 25, resumeBelowLoad1m: 20, sustainSec: 60 };
+/** ONE machine-load check for every strategy: sampled at most every 5 s, with hysteresis. */
+export class LoadGuard {
+    cfg;
+    read;
+    clock;
+    lastAt = -Infinity;
+    aboveSince = null;
+    load1m = null;
+    paused = false;
+    constructor(cfg, o = {}) { this.cfg = cfg; this.read = o.loadavg ?? (() => loadavg()[0]); this.clock = o.clock ?? Date.now; }
+    sample() {
+        const now = this.clock();
+        if (now - this.lastAt < 5000)
+            return;
+        this.lastAt = now;
+        const l = this.read();
+        this.load1m = Math.round(l * 100) / 100;
+        if (l > this.cfg.pauseAboveLoad1m) {
+            this.aboveSince ??= now;
+            if (now - this.aboveSince >= this.cfg.sustainSec * 1000)
+                this.paused = true;
+        }
+        else {
+            this.aboveSince = null;
+            if (l < this.cfg.resumeBelowLoad1m)
+                this.paused = false;
+        }
+    }
+    get config() { return this.cfg; }
+}
+/**
+ * The caps across every strategy: model sessions open at once (candidate and position sessions of all of them),
+ * model $ / turns / sessions per day, the shared Claude allowance (one account: a reading from any session applies to
+ * all), a misconfigured account (blocks every strategy), and the load check. The day counters run on the WALL clock.
+ */
+export class FleetGuard {
+    caps;
+    gate;
+    load;
+    members = new Set();
+    live = 0;
+    liveBy = new Map();
+    constructor(caps, runner, o = {}) {
+        // The runner config (machine-local, one per process) caps the whole fleet too: the stricter number wins.
+        this.caps = {
+            maxConcurrentSessions: caps.maxConcurrentSessions,
+            modelUsdPerDay: Math.min(caps.modelUsdPerDay, runner.caps.modelUsdPerDay),
+            candidateSessionsPerDay: Math.min(caps.candidateSessionsPerDay, runner.caps.candidateSessionsPerDay),
+            positionSessionsPerDay: Math.min(caps.positionSessionsPerDay, runner.caps.positionSessionsPerDay),
+            turnsPerDay: Math.min(caps.turnsPerDay, runner.caps.turnsPerDay),
+        };
+        const eff = { maxSessions: Infinity, budgetUsdPerSession: Infinity, maxTurnsPerSession: Infinity, modelUsdPerDay: this.caps.modelUsdPerDay, candidateSessionsPerDay: this.caps.candidateSessionsPerDay, positionSessionsPerDay: this.caps.positionSessionsPerDay, turnsPerDay: this.caps.turnsPerDay };
+        this.gate = new SessionGate(eff, runner.allowanceGuard, { clock: o.clock });
+        const lc = o.load ?? (runner.load ? { pauseAboveLoad1m: runner.load.pauseAboveLoad1m, resumeBelowLoad1m: runner.load.resumeBelowLoad1m, sustainSec: runner.load.sustainSec } : DEFAULT_FLEET_LOAD);
+        this.load = new LoadGuard(lc, { loadavg: o.loadavg, clock: o.clock });
+    }
+    register(g) { this.members.add(g); }
+    canOpen(kind) {
+        this.load.sample();
+        if (this.load.paused)
+            return { ok: false, reason: 'fleet-load-high' };
+        if (this.live >= this.caps.maxConcurrentSessions)
+            return { ok: false, reason: 'fleet-max-sessions' };
+        const g = this.gate.canOpen(kind, 0);
+        return g.ok ? g : { ok: false, reason: `fleet-${g.reason}` };
+    }
+    /** A session factory that counts its sessions in the fleet-wide open total (closed by the runner, always). */
+    track(member, f) {
+        return (id, s, ctx) => {
+            const x = f(id, s, ctx);
+            this.live++;
+            this.liveBy.set(member, (this.liveBy.get(member) ?? 0) + 1);
+            let closed = false;
+            const close = x.close.bind(x);
+            x.close = async (reason) => {
+                if (!closed) {
+                    closed = true;
+                    this.live--;
+                    this.liveBy.set(member, Math.max(0, (this.liveBy.get(member) ?? 1) - 1));
+                }
+                return close(reason);
+            };
+            return x;
+        };
+    }
+    rateLimit(r, from) {
+        this.gate.rateLimit(r);
+        for (const m of this.members)
+            if (m !== from)
+                m.shareRateLimit(r);
+    }
+    block(reason, from) {
+        this.gate.block(reason);
+        for (const m of this.members)
+            if (m !== from)
+                m.shareBlock(reason);
+    }
+    paused() { return this.gate.paused() || this.load.paused; }
+}
+/** The caps one strategy runs under: the stricter of the strategy, its autotrade.json caps and runner.json. */
+export function memberCaps(s, runner, m) {
+    const e = effectiveCaps(s, runner);
+    const min = (a, b) => (b === undefined ? a : Math.min(a, b));
+    return {
+        ...e,
+        maxSessions: min(e.maxSessions, m.maxSessions),
+        modelUsdPerDay: min(e.modelUsdPerDay, m.modelUsdPerDay),
+        candidateSessionsPerDay: min(e.candidateSessionsPerDay, m.candidateSessionsPerDay),
+        positionSessionsPerDay: min(e.positionSessionsPerDay, m.positionSessionsPerDay),
+        turnsPerDay: min(e.turnsPerDay, m.turnsPerDay),
+    };
+}
+/**
+ * One strategy's session gate: its own caps first (SessionGate), then the fleet's. Every turn and every dollar counts
+ * against both, so the global $/day holds across all strategies and each strategy's own budget holds on its own.
+ */
+export class MemberGate extends SessionGate {
+    member;
+    fleet;
+    constructor(member, caps, runner, fleet, o = {}) {
+        super(caps, runner.allowanceGuard, o);
+        this.member = member;
+        this.fleet = fleet;
+        fleet.register(this);
+    }
+    canOpen(kind, live) {
+        const own = super.canOpen(kind, live);
+        return own.ok ? this.fleet.canOpen(kind) : own;
+    }
+    opened(kind) { super.opened(kind); this.fleet.gate.opened(kind); }
+    turn(costDeltaUsd) { super.turn(costDeltaUsd); this.fleet.gate.turn(costDeltaUsd); }
+    spend(usd) { super.spend(usd); this.fleet.gate.spend(usd); }
+    overDay() { const o = super.overDay(); if (o)
+        return o; const g = this.fleet.gate.overDay(); return g ? `fleet-${g}` : null; }
+    rateLimit(r) { super.rateLimit(r); this.fleet.rateLimit(r, this); }
+    block(reason) { super.block(reason); this.fleet.block(reason, this); }
+    paused() { return super.paused() || this.fleet.paused(); }
+    /** A reading another strategy's session made (the same Claude account). */
+    shareRateLimit(r) { super.rateLimit(r); }
+    shareBlock(reason) { super.block(reason); }
+}
+// ───────────────────────────── shared dossier, executors ─────────────────────────────
+/**
+ * One dossier record per coin per `ttlMs`, whoever asks: two strategies that pick the same coin at the same time cost
+ * one fetch. The record is shared; each strategy renders its own text (its own bounds and bankroll).
+ */
+export function sharedDossier(fetch, ttlMs = 30_000, clock = Date.now) {
+    const cache = new Map();
+    let n = 0;
+    return {
+        get(mint) {
+            const now = clock();
+            const hit = cache.get(mint);
+            if (hit && now - hit.at < ttlMs)
+                return hit.rec;
+            n++;
+            const rec = fetch(mint);
+            cache.set(mint, { at: now, rec });
+            rec.catch(() => cache.delete(mint));
+            if (cache.size > 500)
+                for (const [k, v] of cache)
+                    if (now - v.at >= ttlMs)
+                        cache.delete(k);
+            return rec;
+        },
+        fetches: () => n,
+    };
+}
+/** Executors by member id. Live members share one port per wallet, so the wallet's signer caps hold across them. */
+export function bindExecutors(members, b) {
+    const out = new Map();
+    const ports = new Map();
+    for (const m of members) {
+        if (m.mode === 'paper') {
+            out.set(m.id, b.paper(m));
+            continue;
+        }
+        if (!b.live)
+            return { ok: false, why: `${m.id}: live execution is not available for parallel strategies in this build` };
+        const w = m.wallet ?? 'trading-wallet';
+        if (!ports.has(w))
+            ports.set(w, b.live(w));
+        out.set(m.id, ports.get(w));
+    }
+    return { ok: true, executors: out, livePorts: ports.size };
+}
+// ───────────────────────────── per-strategy stats (for the comparison table) ─────────────────────────────
+/**
+ * Folds one strategy's ledger events into its stats, and watches the shared feed for coins it saw as candidates but
+ * did not enter: one that later trades at >= MISSED_RUNNER_X its candidate price is a missed runner.
+ */
+export class MemberStatsTracker {
+    stats = { candidates: 0, entries: 0, closed: 0, wins: 0, losses: 0, realizedUsd: 0, rugExits: 0, rugCostUsd: 0, enteredUsd: 0, missedRunners: 0, missedSample: [], spendUsd: 0 };
+    endedSpend = 0;
+    watch = new Map();
+    positions = new Map();
+    onEvent(e) {
+        switch (e.kind) {
+            case 'candidate': {
+                this.stats.candidates++;
+                const price = e.tick?.price ?? null;
+                const mint = String(e.mint);
+                const w = this.watch.get(mint);
+                if (price && price > 0 && !w)
+                    this.watch.set(mint, { symbol: String(e.symbol ?? ''), price, entered: false, missed: false });
+                break;
+            }
+            case 'fill': {
+                const usd = Number(e.usd) || 0;
+                if (e.side === 'buy') {
+                    this.stats.enteredUsd += usd;
+                    if (e.profile !== undefined)
+                        this.stats.entries++;
+                    const w = this.watch.get(String(e.mint));
+                    if (w)
+                        w.entered = true;
+                    this.positions.set(String(e.positionId), (this.positions.get(String(e.positionId)) ?? 0) + usd);
+                }
+                break;
+            }
+            case 'trade_closed': {
+                const t = e.trade;
+                if (!t)
+                    break;
+                this.stats.closed++;
+                if (t.pnlUsd > 0)
+                    this.stats.wins++;
+                else
+                    this.stats.losses++;
+                this.stats.realizedUsd = Math.round((this.stats.realizedUsd + t.pnlUsd) * 1e6) / 1e6;
+                if (isRugExit(t.exitReason, t.stuck)) {
+                    this.stats.rugExits++;
+                    this.stats.rugCostUsd += t.costUsd;
+                }
+                break;
+            }
+            case 'session_end':
+                this.endedSpend += Number(e.costUsd) || 0;
+                break;
+        }
+    }
+    /** A tick from the shared feed (every strategy sees the same ones). */
+    onTick(k) {
+        const w = this.watch.get(k.mint);
+        if (!w || w.entered || w.missed || !k.price)
+            return;
+        const x = k.price / w.price;
+        if (x >= MISSED_RUNNER_X) {
+            w.missed = true;
+            this.stats.missedRunners++;
+            if (this.stats.missedSample.length < 5)
+                this.stats.missedSample.push({ symbol: w.symbol, x: Math.round(x * 10) / 10 });
+        }
+    }
+    /** Spend = ended sessions + what the live ones show now; stuck bags still held count as rug exposure. */
+    view(st) {
+        const liveSpend = st ? st.sessions.reduce((a, s) => a + s.costUsd, 0) : 0;
+        const stuck = st ? st.positions.filter((p) => p.next?.startsWith('stuck')) : [];
+        return {
+            ...this.stats,
+            rugExits: this.stats.rugExits + stuck.length,
+            rugCostUsd: Math.round((this.stats.rugCostUsd + stuck.reduce((a, p) => a + p.costUsd, 0)) * 100) / 100,
+            enteredUsd: Math.round(this.stats.enteredUsd * 100) / 100,
+            spendUsd: Math.round((this.endedSpend + liveSpend) * 1e4) / 1e4,
+            missedSample: [...this.stats.missedSample],
+        };
+    }
+}
+export function strategyTaggedHooks(sink, also = {}) {
+    return {
+        ...also,
+        onMemberEvent: (member, runId, e) => { also.onMemberEvent?.(member, runId, e); sink.onEvent({ ...e, strategyId: member, runId }); },
+    };
+}
+/** A member ledger appended to runs/<runId>.jsonl as it happens (0600), with a tap after each write. */
+export function memberFileLedger(home, runId, tap) {
+    const files = runFiles(home, runId);
+    mkdirSync(runsDir(home), { recursive: true, mode: 0o700 });
+    if (existsSync(files.ledger))
+        throw new Error(`run ledger ${files.ledger} already exists`);
+    closeSync(openSync(files.ledger, 'a', 0o600));
+    const ledger = new Ledger((e, line) => { appendFileSync(files.ledger, `${line}\n`); try {
+        tap(e);
+    }
+    catch { /* a hook never stops the ledger */ } });
+    return { ledger, files };
+}
+export async function runFleet(o) {
+    if (!o.tape && !o.source)
+        throw new Error('runFleet needs a tape or a live source');
+    for (const m of o.members)
+        if (m.config.mode !== 'paper' && !o.executors?.live)
+            throw new Error(`${m.config.id}: live execution is not available for parallel strategies in this build`);
+    const accounts = new Map();
+    for (const a of o.accounts ?? []) {
+        if (accounts.has(a.id))
+            throw new Error(`paper account ${a.id} is listed twice`);
+        accounts.set(a.id, new PaperAccount(a.id, a.startUsd, { ...(a.sol !== undefined ? { sol: a.sol, solUsd: a.solUsd } : {}) }));
+    }
+    for (const m of o.members) {
+        if (!m.config.account)
+            continue;
+        if (!accounts.has(m.config.account))
+            throw new Error(`${m.config.id}: paper account ${m.config.account} is not defined`);
+        if (m.config.mode !== 'paper')
+            throw new Error(`${m.config.id}: a paper account never backs a live strategy`);
+    }
+    const clock = o.clock ?? Date.now;
+    const say = o.onLine ?? (() => { });
+    const pacing = o.pacing ?? { mode: 'lockstep' };
+    const hub = new TickHub({ barrier: !!o.tape || pacing.mode !== 'live' });
+    const fl = o.fleetLedger;
+    const startedAt = clock();
+    let now = o.tape ? (o.tape.ticks[0]?.t ?? 0) : (o.source.startT ?? startedAt);
+    const lives = new Map();
+    for (const spec of o.members)
+        lives.set(spec.config.id, { spec, state: 'idle', runId: null, gate: null, stats: new MemberStatsTracker(), last: null, ledgerPath: null, done: null, result: null, focus: [], startedAt: null, endedAt: null });
+    const execs = bindExecutors(o.members.map((m) => ({ id: m.config.id, mode: m.config.mode, strategy: m.strategy })), o.executors ?? { paper: (m) => simExecutor(m.strategy.execution) });
+    if (!execs.ok)
+        throw new Error(execs.why);
+    fl.add(now, 'fleet_start', {
+        fleetId: o.fleetId, mode: 'paper', source: o.tape?.source ?? o.source.name, pacing: pacing.mode,
+        members: o.members.map((m) => ({ id: m.config.id, enabled: m.config.enabled, basedOn: m.basedOn, strategyHash: m.strategy.hash, bankroll: m.bankroll, mode: m.config.mode, caps: m.config.caps, ...(m.config.account ? { account: m.config.account } : {}) })),
+        global: o.guard.caps, livePorts: execs.livePorts,
+        ...(accounts.size ? { accounts: [...accounts.values()].map((a) => ({ id: a.id, startUsd: a.startUsd, ...(a.sol !== undefined ? { sol: a.sol, solUsd: a.solUsd } : {}) })) } : {}),
+    });
+    const publishFocus = () => {
+        if (!o.source?.setFocus)
+            return;
+        const seen = new Map();
+        for (const l of lives.values())
+            for (const f of l.focus) {
+                const cur = seen.get(f.mint);
+                if (!cur || f.role === 'held')
+                    seen.set(f.mint, f);
+            }
+        o.source.setFocus([...seen.values()]);
+    };
+    const status = (state, haltReason) => {
+        const g = o.guard;
+        const day = g.gate.todayNow();
+        return {
+            schema: FLEET_STATUS_SCHEMA, fleetId: o.fleetId, pid: process.pid, mode: 'paper', state, haltReason, startedAt, heartbeatAt: clock(),
+            source: o.tape ? `replay ${o.tape.source}` : 'live',
+            global: {
+                caps: g.caps, today: { modelUsd: Math.round(day.modelUsd * 1e4) / 1e4, turns: day.turns, candidateSessions: day.candidateSessions, positionSessions: day.positionSessions },
+                liveSessions: g.live, load: { load1m: g.load.load1m, paused: g.load.paused, pauseAbove: g.load.config.pauseAboveLoad1m, resumeBelow: g.load.config.resumeBelowLoad1m },
+                allowance: g.gate.allowance ? { fiveHour: g.gate.allowance.fiveHour, sevenDay: g.gate.allowance.sevenDay } : null, blocked: g.gate.blocked,
+            },
+            members: [...lives.values()].map((l) => ({
+                id: l.spec.config.id, runId: l.runId, state: l.state, ...(l.error ? { error: l.error } : {}), haltReason: l.last?.haltReason ?? null, mode: 'paper',
+                basedOn: l.spec.basedOn, strategyHash: l.spec.strategy.hash, bankroll: l.spec.bankroll,
+                book: l.last ? l.last.book : null, spend: l.last ? { todayUsd: l.last.spend.todayUsd, dayCapUsd: l.last.spend.dayCapUsd } : null,
+                open: (l.last?.positions ?? []).map((p) => ({ mint: p.mint, symbol: p.symbol, profile: p.profile, costUsd: p.costUsd, pnlUsd: p.pnlUsd, pnlPct: p.pnlPct, ...(p.freeBag ? { freeBag: true } : {}), ...(p.next?.startsWith('stuck') ? { stuck: true } : {}) })),
+                candidates: l.last?.candidates.length ?? 0, sessions: l.last?.sessions.length ?? 0,
+                stats: l.stats.view(l.last), ledgerPath: l.ledgerPath, startedAt: l.startedAt, endedAt: l.endedAt,
+                ...(l.spec.config.account ? { account: l.spec.config.account, pnlUsd: l.last?.account?.pnlUsd ?? null } : {}),
+            })),
+            ...(accounts.size ? { accounts: [...accounts.values()].map((a) => a.view()) } : {}),
+            ledgerPath: o.fleetLedgerPath ?? '',
+        };
+    };
+    let globalHalt = null;
+    const emitStatus = (state = globalHalt ? 'halted' : 'running') => {
+        const st = status(state, globalHalt);
+        o.onStatus?.(st);
+        o.hooks?.onFleetState?.(st);
+    };
+    const startMember = (l, why) => {
+        const spec = l.spec;
+        const id = spec.config.id;
+        const runId = o.newRunId(id);
+        l.runId = runId;
+        l.state = 'running';
+        l.error = undefined;
+        l.last = null;
+        l.result = null;
+        l.stats = new MemberStatsTracker();
+        l.startedAt = clock();
+        l.endedAt = null;
+        l.focus = [];
+        let memberNow = now;
+        const tap = (e) => { l.stats.onEvent(e); o.hooks?.onMemberEvent?.(id, runId, e); };
+        let ledger;
+        try {
+            const lf = o.ledgerFor ? o.ledgerFor(id, runId, tap) : memberFileLedger(o.home, runId, tap);
+            ledger = lf.ledger;
+            l.ledgerPath = lf.files?.ledger ?? null;
+        }
+        catch (e) {
+            l.state = 'error';
+            l.error = e.message.slice(0, 200);
+            fl.add(now, 'member_error', { member: id, error: l.error });
+            return;
+        }
+        const account = spec.config.account ? accounts.get(spec.config.account) : undefined;
+        ledger.add(now, 'fleet_member', { fleetId: o.fleetId, member: id, basedOn: spec.basedOn, strategyHash: spec.strategy.hash, bankroll: spec.bankroll, mode: spec.config.mode, caps: spec.config.caps, why, ...(account ? { account: account.id, accountCashUsd: Math.round(account.cashUsd * 100) / 100 } : {}) });
+        const gate = new MemberGate(id, memberCaps(spec.strategy, o.runner, spec.config.caps), o.runner, o.guard, { clock });
+        l.gate = gate;
+        const log = (kind, data) => { ledger.add(memberNow, kind, data); };
+        const sessions = o.sessions ? o.guard.track(id, o.sessions(spec, gate, log, () => memberNow)) : null;
+        const msafety = o.memberControl === false ? null : new MemberSafety({ home: o.home, fleetId: o.fleetId, member: id, runId });
+        fl.add(now, 'member_start', { member: id, runId, why, strategyHash: spec.strategy.hash, bankroll: spec.bankroll, ...(account ? { account: account.id } : {}) });
+        say(`[${id}] started (run ${runId}, ${spec.basedOn.id} v${spec.basedOn.version}, ${account ? `paper account ${account.id} ($${account.cashUsd.toFixed(2)} cash of $${account.startUsd})` : `bankroll $${spec.bankroll.usd}${spec.bankroll.sol !== undefined ? ` = ${spec.bankroll.sol} SOL` : ''}`})`);
+        const ticks = hub.subscribe(runId);
+        l.done = runAutotrade({
+            strategy: spec.strategy, source: { name: o.tape?.source ?? o.source.name, ticks, startT: now }, sessions, gate, ledger, runId,
+            dossier: o.dossier?.(spec), vet: o.vet?.(spec), executor: execs.executors.get(id), verbose: o.verbose ?? true, onLine: (s) => say(`[${id}] ${s}`),
+            pacing, ...(account ? { account, member: id } : {}),
+            safety: () => {
+                const g = o.globalSafety();
+                return msafety ? mergeVerdicts(g, msafety.step()) : g;
+            },
+            onState: (st) => {
+                memberNow = st.t;
+                l.last = st;
+                l.state = st.state === 'stopped' ? 'stopped' : st.state;
+                o.hooks?.onMemberState?.(id, runId, st);
+            },
+            onFocus: (marks) => { l.focus = marks; publishFocus(); },
+        }).then((res) => {
+            hub.unsubscribe(runId);
+            l.result = res;
+            l.state = 'stopped';
+            l.endedAt = clock();
+            l.focus = [];
+            publishFocus();
+            const v = l.stats.view(l.last);
+            const own = Math.round(res.book.ownPnlUsd() * 100) / 100;
+            fl.add(now, 'member_end', { member: id, runId, trades: res.trades.length, openAtEnd: res.openAtEnd.length, equityUsd: Math.round(res.book.markedEquity() * 100) / 100, startUsd: spec.bankroll.usd, spendUsd: v.spendUsd, head: res.ledger.head(), ...(account ? { account: account.id, pnlUsd: own } : {}) });
+            say(account
+                ? `[${id}] ended · ${res.trades.length} closed, ${res.openAtEnd.length} open · its P/L ${own >= 0 ? '+' : '-'}$${Math.abs(own).toFixed(2)} on paper account ${account.id} (account equity $${res.book.markedEquity().toFixed(2)} of $${account.startUsd})`
+                : `[${id}] ended · ${res.trades.length} closed, ${res.openAtEnd.length} open · equity $${res.book.markedEquity().toFixed(2)} of $${spec.bankroll.usd}`);
+            return res;
+        }, (e) => {
+            hub.unsubscribe(runId);
+            l.state = 'error';
+            l.error = e.message?.slice(0, 200) ?? String(e);
+            l.endedAt = clock();
+            l.focus = [];
+            publishFocus();
+            fl.add(now, 'member_error', { member: id, runId, error: l.error });
+            say(`[${id}] failed: ${l.error}`);
+            return null;
+        });
+    };
+    // Start requests: a strategy of the config that is not running starts at the next tick.
+    const memberControlOn = o.memberControl !== false;
+    const checkStarts = () => {
+        if (!memberControlOn || globalHalt)
+            return;
+        for (const l of lives.values()) {
+            if (l.state === 'running' || l.state === 'paused' || l.state === 'halted')
+                continue;
+            const id = l.spec.config.id;
+            const c = readMemberControl(o.home, id);
+            if (!c || c === 'unreadable' || c.fleetId !== o.fleetId || c.action !== 'start')
+                continue;
+            try {
+                rmSync(memberControlPath(o.home, id), { force: true });
+            }
+            catch { /* re-read next tick */ }
+            fl.add(now, 'member_control', { member: id, action: 'start', by: c.by });
+            startMember(l, `start requested (${c.by})`);
+        }
+    };
+    for (const l of lives.values())
+        if (l.spec.config.enabled)
+            startMember(l, 'enabled in autotrade.json');
+    emitStatus();
+    const anyRunning = () => [...lives.values()].some((l) => l.done && l.state !== 'stopped' && l.state !== 'error');
+    const loop = o.tape ? (async function* () { for (const k of o.tape.ticks)
+        yield k; })() : o.source.ticks;
+    let lastStatus = 0;
+    for await (const k of loop) {
+        now = k.t;
+        const g = o.globalSafety();
+        if (g.halt && !globalHalt) {
+            globalHalt = g.halt;
+            fl.add(now, 'fleet_halt', { reason: g.halt, ...(g.detail ? { detail: g.detail } : {}), flatten: g.flatten });
+            say(`FLEET ${g.halt.toUpperCase()}: every strategy takes no new entries; mechanical exits keep running`);
+        }
+        checkStarts();
+        for (const l of lives.values())
+            l.stats.onTick(k);
+        if (!anyRunning() && hub.size === 0)
+            break;
+        await hub.publish(k);
+        if (clock() - lastStatus >= 1000) {
+            lastStatus = clock();
+            emitStatus();
+        }
+    }
+    if (o.tape)
+        await hub.drain();
+    hub.end();
+    const results = await Promise.all([...lives.values()].map((l) => l.done ?? Promise.resolve(null)));
+    void results;
+    const final = status('stopped', globalHalt);
+    fl.add(now, 'fleet_end', { members: final.members.map((m) => ({ id: m.id, runId: m.runId, state: m.state, equityUsd: m.book?.equityUsd ?? null, startUsd: m.bankroll.usd, closed: m.stats.closed, spendUsd: m.stats.spendUsd, ...(m.account ? { account: m.account, pnlUsd: m.pnlUsd ?? null } : {}) })), ...(final.accounts ? { accounts: final.accounts } : {}), head: fl.head() });
+    o.onStatus?.(final);
+    o.hooks?.onFleetState?.(final);
+    return { fleetId: o.fleetId, members: [...lives.values()].map((l) => ({ id: l.spec.config.id, runId: l.runId, result: l.result, ...(l.error ? { error: l.error } : {}) })), status: final };
+}