tradelab 1.1.0 → 1.2.1

package/dist/cjs/index.cjs

@@ -3194,6 +3194,7 @@ function forceExitAll(runners, time) {
 function backtestPortfolio({
   systems = [],
   equity = 1e4,
+  interval,
   allocation = "equal",
   collectEqSeries = true,
   collectReplay = false,
@@ -3327,17 +3328,20 @@ function backtestPortfolio({
   const replay = combineReplay(systemResults, eqSeries, collectReplay);
   const allCandles = systems.flatMap((system) => system.candles || []);
   const orderedCandles = [...allCandles].sort((left, right) => left.time - right.time);
+  const metricsInterval = interval ?? systems[0]?.interval;
+  const finalState = portfolioState(runners, equity);
   const metrics = buildMetrics({
     closed: trades,
     equityStart: equity,
-    equityFinal: eqSeries.length ? eqSeries[eqSeries.length - 1].equity : equity,
+    equityFinal: eqSeries.length ? eqSeries[eqSeries.length - 1].equity : finalState.markedEquity,
     candles: orderedCandles,
     estBarMs: estimateBarMs(orderedCandles),
-    eqSeries
+    eqSeries,
+    interval: metricsInterval
   });
   return {
     symbol: "PORTFOLIO",
-    interval: void 0,
+    interval: metricsInterval,
     range: void 0,
     trades,
     positions,
@@ -3632,7 +3636,9 @@ function walkForwardOptimize({
 // src/engine/optimize.js
 var import_node_worker_threads = require("node:worker_threads");
 var import_node_os = __toESM(require("node:os"), 1);
-var import_meta = {};
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
 function defaultConcurrency() {
   return Math.max(1, (import_node_os.default.cpus()?.length ?? 2) - 1);
 }
@@ -3640,6 +3646,23 @@ function scoreValue(metrics, scoreBy) {
   const v = metrics?.[scoreBy];
   return Number.isFinite(v) ? v : -Infinity;
 }
+function callerModuleDir() {
+  const stack = new Error().stack || "";
+  const lines = stack.split("\n").slice(1);
+  const match = lines.map((line) => line.match(/(?:\()?(file:\/\/\/[^\s)]+|\/[^\s)]+):\d+:\d+/)).find(Boolean);
+  if (!match) return process.cwd();
+  const filePath = match[1].startsWith("file://") ? (0, import_node_url.fileURLToPath)(match[1]) : match[1];
+  return import_node_path.default.dirname(filePath);
+}
+function workerUrl() {
+  const here = callerModuleDir();
+  const candidates = [
+    import_node_path.default.join(here, "optimizeWorker.js"),
+    import_node_path.default.join(here, "..", "..", "src", "engine", "optimizeWorker.js"),
+    import_node_path.default.join(process.cwd(), "src", "engine", "optimizeWorker.js")
+  ];
+  return (0, import_node_url.pathToFileURL)(candidates.find((candidate) => (0, import_node_fs.existsSync)(candidate)) || candidates[0]);
+}
 function optimize({
   candles,
   signalModulePath,
@@ -3682,7 +3705,7 @@ function optimize({
       worker.postMessage({ type: "run", index, params: parameterSets[index] });
     };
     for (let i = 0; i < poolSize; i += 1) {
-      const worker = new import_node_worker_threads.Worker(new URL("./optimizeWorker.js", import_meta.url), {
+      const worker = new import_node_worker_threads.Worker(workerUrl(), {
         workerData: { candles, signalModulePath, interval, backtestOptions }
       });
       workers.push(worker);
@@ -3945,29 +3968,33 @@ function monteCarlo({
   if (!Array.isArray(tradePnls) || tradePnls.length === 0) {
     throw new Error("monteCarlo() requires a non-empty tradePnls array");
   }
+  const runCount = Math.floor(Number(iterations));
+  if (!Number.isFinite(runCount) || runCount < 1) {
+    throw new Error("monteCarlo() requires positive iterations");
+  }
   const rng = makeRng(seed);
   const n = tradePnls.length;
   const block = Math.max(1, Math.floor(blockSize));
   const finals = [];
   const drawdowns = [];
   const pathSamples = Array.from({ length: n + 1 }, () => []);
-  for (let it = 0; it < iterations; it += 1) {
-    const path6 = [equityStart];
+  for (let it = 0; it < runCount; it += 1) {
+    const path7 = [equityStart];
     let equity = equityStart;
     let filled = 0;
     while (filled < n) {
       const start = randInt(rng, n);
       for (let k = 0; k < block && filled < n; k += 1) {
         equity += tradePnls[(start + k) % n];
-        path6.push(equity);
+        path7.push(equity);
         filled += 1;
       }
     }
-    for (let step = 0; step < path6.length; step += 1) {
-      pathSamples[step].push(path6[step]);
+    for (let step = 0; step < path7.length; step += 1) {
+      pathSamples[step].push(path7[step]);
     }
     finals.push(equity);
-    drawdowns.push(maxDrawdownOf(path6));
+    drawdowns.push(maxDrawdownOf(path7));
   }
   const sortedFinals = [...finals].sort((a, b) => a - b);
   const sortedDd = [...drawdowns].sort((a, b) => a - b);
@@ -3983,7 +4010,7 @@ function monteCarlo({
     p95: percentile2(sorted, 0.95)
   });
   return {
-    iterations,
+    iterations: runCount,
     blockSize: block,
     finalEquity: bands(sortedFinals),
     maxDrawdown: bands(sortedDd),

package/dist/cjs/live.cjs

@@ -48,8 +48,10 @@ __export(index_exports, {
   PaperEngine: () => PaperEngine,
   PollingFeed: () => PollingFeed,
   RiskManager: () => RiskManager,
+  SessionManager: () => SessionManager,
   StateManager: () => StateManager,
   StorageProvider: () => StorageProvider,
+  TradingSession: () => TradingSession,
   createAlpacaBroker: () => createAlpacaBroker,
   createBinanceBroker: () => createBinanceBroker,
   createBrokerFeed: () => createBrokerFeed,
@@ -66,6 +68,7 @@ __export(index_exports, {
   createPaperEngine: () => createPaperEngine,
   createPollingFeed: () => createPollingFeed,
   createRiskManager: () => createRiskManager,
+  createSessionManager: () => createSessionManager,
   createStateManager: () => createStateManager
 });
 module.exports = __toCommonJS(index_exports);
@@ -2298,15 +2301,20 @@ var PaperEngine = class extends BrokerAdapter {
   _recordOrder(order) {
     this.orderHistory.set(order.orderId, { ...order });
   }
+  _rejectOrder(order, reason) {
+    order.status = "rejected";
+    order.rejectReason = reason;
+    this._recordOrder(order);
+    this.openOrders.delete(order.orderId);
+    const receipt = cloneOrder(order);
+    this.emit("order:rejected", receipt);
+    return receipt;
+  }
   _fillOrder(order, fillPrice, kind = "market", fillTime = Date.now()) {
     const side = normalizeOrderSide(order.side);
     const qty = Math.max(0, asNumber(order.qty, 0));
     if (!(qty > 0)) {
-      order.status = "rejected";
-      order.rejectReason = "invalid quantity";
-      this._recordOrder(order);
-      this.emit("order:rejected", cloneOrder(order));
-      return cloneOrder(order);
+      return this._rejectOrder(order, "invalid quantity");
     }
     const sideForFill = side === "buy" ? "long" : "short";
     const filled = applyFill(fillPrice, sideForFill, {
@@ -2414,17 +2422,16 @@ var PaperEngine = class extends BrokerAdapter {
       rejectReason: void 0
     };
     if (!(normalized.qty > 0)) {
-      normalized.status = "rejected";
-      normalized.rejectReason = "invalid quantity";
-      this._recordOrder(normalized);
-      this.emit("order:rejected", cloneOrder(normalized));
-      return cloneOrder(normalized);
+      return this._rejectOrder(normalized, "invalid quantity");
     }
     this._recordOrder(normalized);
     this.emit("order:submitted", cloneOrder(normalized));
     if (normalized.type === "market") {
       const mark = this.lastPrices.get(normalized.symbol);
-      const fillPrice = mark ?? normalized.limitPrice ?? normalized.stopPrice ?? 0;
+      const fillPrice = mark ?? normalized.limitPrice ?? normalized.stopPrice;
+      if (!Number.isFinite(fillPrice)) {
+        return this._rejectOrder(normalized, "no price available for market order");
+      }
       return this._fillOrder(normalized, fillPrice, "market");
     }
     this.openOrders.set(normalized.orderId, normalized);
@@ -2483,6 +2490,7 @@ var PaperEngine = class extends BrokerAdapter {
     });
     const orders = [...this.openOrders.values()].filter((order) => order.symbol === symbol);
     for (const order of orders) {
+      if (!this.openOrders.has(order.orderId)) continue;
       if (order.type === "limit") {
         if (this._touchesLimit(order, normalizedBar)) {
           this._fillOrder(order, order.limitPrice, "limit", normalizedBar.time);
@@ -3317,7 +3325,6 @@ var import_node_http = __toESM(require("node:http"), 1);
 var import_node_fs2 = require("node:fs");
 var import_node_path2 = __toESM(require("node:path"), 1);
 var import_node_url4 = require("node:url");
-var import_meta = {};
 var FALLBACK_HTML = `<!doctype html>
 <html lang="en">
   <head>
@@ -3336,12 +3343,23 @@ var FALLBACK_HTML = `<!doctype html>
     </script>
   </body>
 </html>`;
+function callerModuleDir() {
+  const stack = new Error().stack || "";
+  const lines = stack.split("\n").slice(1);
+  const match = lines.map((line) => line.match(/(?:\()?(file:\/\/\/[^\s)]+|\/[^\s)]+):\d+:\d+/)).find(Boolean);
+  if (!match) return process.cwd();
+  const filePath = match[1].startsWith("file://") ? (0, import_node_url4.fileURLToPath)(match[1]) : match[1];
+  return import_node_path2.default.dirname(filePath);
+}
 function readDashboardHtml() {
-  if (import_meta.url) {
-    const here = import_node_path2.default.dirname((0, import_node_url4.fileURLToPath)(import_meta.url));
-    const htmlPath = import_node_path2.default.join(here, "..", "..", "..", "templates", "dashboard.html");
-    return (0, import_node_fs2.readFileSync)(htmlPath, "utf8");
-  }
+  const here = callerModuleDir();
+  const candidates = [
+    import_node_path2.default.join(here, "..", "..", "..", "templates", "dashboard.html"),
+    import_node_path2.default.join(here, "..", "..", "templates", "dashboard.html"),
+    import_node_path2.default.join(process.cwd(), "templates", "dashboard.html")
+  ];
+  const htmlPath = candidates.find((candidate) => (0, import_node_fs2.existsSync)(candidate));
+  if (htmlPath) return (0, import_node_fs2.readFileSync)(htmlPath, "utf8");
   try {
     return (0, import_node_fs2.readFileSync)(import_node_path2.default.join(process.cwd(), "templates", "dashboard.html"), "utf8");
   } catch {
@@ -3363,7 +3381,7 @@ function createDashboardServer({ source, port = 4317, maxBuffer = 200 }) {
 `;
     for (const res of clients) res.write(frame);
   });
-  const server = import_node_http.default.createServer((req, res) => {
+  const server = import_node_http.default.createServer(async (req, res) => {
     const url = (req.url || "/").split("?")[0];
     if (url === "/") {
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
@@ -3371,11 +3389,52 @@ function createDashboardServer({ source, port = 4317, maxBuffer = 200 }) {
       return;
     }
     if (url === "/state") {
+      if (typeof source.refresh === "function") await source.refresh().catch(() => {
+      });
       const status = typeof source.getStatus === "function" ? source.getStatus() : {};
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify(status));
       return;
     }
+    if (url === "/command" && req.method === "POST") {
+      const WHITELIST = {
+        flatten: "flatten",
+        stop: "stop",
+        closePosition: "closePosition",
+        cancelOrder: "cancelOrder"
+      };
+      let body = "";
+      req.on("data", (c) => body += c);
+      req.on("end", async () => {
+        let cmd;
+        try {
+          cmd = JSON.parse(body || "{}");
+        } catch {
+          cmd = {};
+        }
+        const method = WHITELIST[cmd.type];
+        if (!method || typeof source[method] !== "function") {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: `unsupported command "${cmd.type}"` }));
+          return;
+        }
+        try {
+          const arg = cmd.type === "closePosition" ? cmd.symbol : cmd.type === "cancelOrder" ? cmd.orderId : void 0;
+          await source[method](arg);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true }));
+        } catch (error) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              ok: false,
+              error: error instanceof Error ? error.message : String(error)
+            })
+          );
+        }
+      });
+      return;
+    }
     if (url === "/events") {
       res.writeHead(200, {
         "Content-Type": "text/event-stream",
@@ -3417,6 +3476,383 @@ function createDashboardServer({ source, port = 4317, maxBuffer = 200 }) {
     server
   };
 }
+
+// src/live/session.js
+function oppositeSide2(side) {
+  return side === "long" || side === "buy" ? "sell" : "buy";
+}
+function toBrokerSide(side) {
+  return side === "long" || side === "buy" ? "buy" : "sell";
+}
+function matchesOrderRef(reference, order) {
+  if (!reference || !order) return false;
+  if (reference.orderId && order.orderId && reference.orderId === order.orderId) return true;
+  if (reference.clientOrderId && order.clientOrderId && reference.clientOrderId === order.clientOrderId) {
+    return true;
+  }
+  return false;
+}
+var TradingSession = class _TradingSession {
+  constructor({
+    id,
+    symbol,
+    interval = "1m",
+    broker,
+    mode = "paper",
+    equity = 1e4,
+    riskPct = 1,
+    maxDailyLossPct = 0,
+    maxPositionPct = 1,
+    qtyStep = 1e-3,
+    minQty = 1e-3,
+    maxLeverage = 2,
+    confirmLive = false,
+    eventBus
+  } = {}) {
+    if (mode === "live" && (!_TradingSession.liveAllowed() || !confirmLive)) {
+      throw new Error(
+        "live trading is gated: set TRADELAB_ALLOW_LIVE=true and pass confirmLive:true with a credentialed broker"
+      );
+    }
+    if (!broker) throw new Error("TradingSession requires a broker (PaperEngine by default)");
+    if (!symbol) throw new Error("TradingSession requires a symbol");
+    this.id = id || `${symbol}-${interval}`;
+    this.symbol = symbol;
+    this.interval = interval;
+    this.broker = broker;
+    this.mode = mode;
+    this.equity = equity;
+    this._startEquity = equity;
+    this.riskPct = riskPct;
+    this.maxPositionPct = maxPositionPct;
+    this.qtyStep = qtyStep;
+    this.minQty = minQty;
+    this.maxLeverage = maxLeverage;
+    this.eventBus = eventBus || new EventBus();
+    this.riskManager = new RiskManager({ maxDailyLossPct, maxDrawdownPct: 0 });
+    this.lastPrice = null;
+    this.running = false;
+    this.events = [];
+    this.brackets = /* @__PURE__ */ new Map();
+    this._pendingBracket = null;
+    this._cachedPositions = [];
+    this._cachedOpenOrders = [];
+    this.candleBuffer = [];
+    this._strategy = null;
+    this._wireBrokerEvents();
+  }
+  static liveAllowed() {
+    return process.env.TRADELAB_ALLOW_LIVE === "true";
+  }
+  _record(event, payload) {
+    const msg = { event, payload, t: Date.now() };
+    this.events.push(msg);
+    if (this.events.length > 500) this.events.shift();
+    this.eventBus.emitEvent(event, { sessionId: this.id, symbol: this.symbol, ...payload });
+  }
+  _wireBrokerEvents() {
+    this.broker.on?.("order:filled", (order) => this._onBrokerFillSync(order));
+    this.broker.on?.("order:submitted", (order) => this._record("order:submitted", order));
+    this.broker.on?.(
+      "order:canceled",
+      (order) => this._onBrokerTerminalOrderSync("order:canceled", order)
+    );
+    this.broker.on?.(
+      "order:rejected",
+      (order) => this._onBrokerTerminalOrderSync("order:rejected", order)
+    );
+    this.broker.on?.("equity:update", (acct) => this._record("equity:update", acct));
+  }
+  _onBrokerTerminalOrderSync(event, order) {
+    this._record(event, order);
+    if (matchesOrderRef(this._pendingBracket, order)) {
+      this._pendingBracket = null;
+    }
+  }
+  // Sync event handler — fire-and-forget async OCO work via a stored promise
+  _onBrokerFillSync(order) {
+    this._record("order:filled", order);
+    if (matchesOrderRef(this._pendingBracket, order)) {
+      const staged = this._pendingBracket;
+      this._pendingBracket = null;
+      this._pendingCancelPromise = Promise.resolve(
+        this._attachBracket({ ...staged, receipt: order })
+      );
+      return;
+    }
+    const bracket = this.brackets.get(this.symbol);
+    if (bracket && (order.orderId === bracket.stopId || order.orderId === bracket.targetId)) {
+      const siblingId = order.orderId === bracket.stopId ? bracket.targetId : bracket.stopId;
+      this._pendingCancelPromise = (async () => {
+        if (siblingId) await this.broker.cancelOrder(siblingId).catch(() => {
+        });
+        this.brackets.delete(this.symbol);
+        this._record("position:closed", { reason: order.orderId === bracket.stopId ? "SL" : "TP" });
+      })();
+    }
+  }
+  async start() {
+    if (!this.broker.isConnected?.()) await this.broker.connect?.({});
+    const acct = await this.broker.getAccount?.().catch(() => null);
+    if (Number.isFinite(acct?.equity)) {
+      this.equity = acct.equity;
+      this._startEquity = acct.equity;
+    }
+    this.riskManager.initialize(this.equity, Date.now());
+    this.running = true;
+    this._record("connected", { mode: this.mode });
+  }
+  async stop({ flatten = false } = {}) {
+    if (flatten) await this.flatten();
+    this.running = false;
+    this._record("shutdown", {});
+  }
+  async pushBar(b) {
+    this.lastPrice = b.close;
+    if (typeof this.broker.simulateBar === "function") {
+      await this.broker.simulateBar(this.symbol, this.interval, b);
+    }
+    if (this._pendingCancelPromise) {
+      await this._pendingCancelPromise;
+      this._pendingCancelPromise = null;
+    }
+    this.candleBuffer.push(b);
+    if (this.candleBuffer.length > 200) this.candleBuffer.shift();
+    this._record("bar", { close: b.close, time: b.time });
+    await this._syncEquityAndRisk();
+    await this.refresh();
+  }
+  _riskHalted() {
+    const state = this.riskManager.getState?.() || {};
+    return Boolean(state.halted);
+  }
+  async placeOrder({ side, type = "market", qty, riskPct, stop, target, rr, limitPrice } = {}) {
+    if (!this.running) throw new Error("session not started");
+    if (this._riskHalted()) throw new Error("session is risk-halted for the day");
+    const entryRef = type === "limit" ? limitPrice : this.lastPrice;
+    if (!Number.isFinite(entryRef)) throw new Error("no price available; pushBar() a price first");
+    let size = qty;
+    if (!Number.isFinite(size)) {
+      const fraction = Number.isFinite(riskPct) ? riskPct / 100 : this.riskPct / 100;
+      if (!Number.isFinite(stop)) throw new Error("risk-based sizing requires a stop");
+      size = calculatePositionSize({
+        equity: this.equity,
+        entry: entryRef,
+        stop,
+        riskFraction: fraction,
+        qtyStep: this.qtyStep,
+        minQty: this.minQty,
+        maxLeverage: this.maxLeverage
+      });
+    }
+    size = roundStep(size, this.qtyStep);
+    if (!(size >= this.minQty)) throw new Error(`sized below minQty (${size})`);
+    const entryClientOrderId = `${this.id}-entry-${Date.now()}`;
+    const receipt = await this.broker.submitOrder({
+      symbol: this.symbol,
+      side: toBrokerSide(side),
+      type,
+      qty: size,
+      limitPrice: type === "limit" ? limitPrice : void 0,
+      clientOrderId: entryClientOrderId
+    });
+    if (Number.isFinite(stop) || Number.isFinite(target) || Number.isFinite(rr)) {
+      if (receipt.status === "filled") {
+        await this._attachBracket({ side, size, stop, target, rr, entryRef, receipt });
+      } else if (receipt.status !== "rejected") {
+        this._pendingBracket = {
+          side,
+          size,
+          stop,
+          target,
+          rr,
+          entryRef,
+          orderId: receipt.orderId,
+          clientOrderId: receipt.clientOrderId || entryClientOrderId
+        };
+      } else {
+        this._pendingBracket = null;
+      }
+    }
+    await this.refresh();
+    return receipt;
+  }
+  async _attachBracket({ side, size, stop, target, rr, entryRef, receipt }) {
+    const entryFill = receipt?.avgFillPrice ?? entryRef;
+    const risk = Number.isFinite(stop) ? Math.abs(entryFill - stop) : null;
+    const targetPrice = Number.isFinite(target) ? target : Number.isFinite(rr) && risk ? side === "long" || side === "buy" ? entryFill + rr * risk : entryFill - rr * risk : null;
+    const exitSide = oppositeSide2(side);
+    const bracket = {};
+    if (Number.isFinite(stop)) {
+      const stopOrder = await this.broker.submitOrder({
+        symbol: this.symbol,
+        side: exitSide,
+        type: "stop",
+        qty: size,
+        stopPrice: stop,
+        clientOrderId: `${this.id}-stop-${Date.now()}`
+      });
+      bracket.stopId = stopOrder.orderId;
+    }
+    if (Number.isFinite(targetPrice)) {
+      const tgtOrder = await this.broker.submitOrder({
+        symbol: this.symbol,
+        side: exitSide,
+        type: "limit",
+        qty: size,
+        limitPrice: targetPrice,
+        clientOrderId: `${this.id}-target-${Date.now()}`
+      });
+      bracket.targetId = tgtOrder.orderId;
+    }
+    this.brackets.set(this.symbol, bracket);
+  }
+  async _syncEquityAndRisk() {
+    const acct = await this.broker.getAccount?.().catch(() => null);
+    if (!Number.isFinite(acct?.equity)) return;
+    const prevEquity = this.equity;
+    this.equity = acct.equity;
+    const pnlDelta = this.equity - prevEquity;
+    if (pnlDelta !== 0) {
+      this.riskManager.recordTrade({ pnl: pnlDelta, timeMs: Date.now(), equity: this.equity });
+    } else {
+      this.riskManager.update({ timeMs: Date.now(), equity: this.equity });
+    }
+  }
+  async closePosition(symbol = this.symbol) {
+    const positions = await this.broker.getPositions();
+    const pos = positions.find((p) => p.symbol === symbol);
+    if (!pos) return null;
+    const bracket = this.brackets.get(symbol);
+    if (bracket) {
+      for (const id of [bracket.stopId, bracket.targetId]) {
+        if (id) await this.broker.cancelOrder(id).catch(() => {
+        });
+      }
+      this.brackets.delete(symbol);
+    }
+    const receipt = await this.broker.submitOrder({
+      symbol,
+      side: oppositeSide2(pos.side),
+      type: "market",
+      qty: pos.qty,
+      clientOrderId: `${this.id}-close-${Date.now()}`
+    });
+    await this._syncEquityAndRisk();
+    await this.refresh();
+    return receipt;
+  }
+  async flatten() {
+    const positions = await this.broker.getPositions();
+    for (const p of positions) await this.closePosition(p.symbol);
+    const open = await this.broker.getOpenOrders?.().catch(() => []) ?? [];
+    for (const o of open) await this.broker.cancelOrder(o.orderId).catch(() => {
+    });
+    await this.refresh();
+  }
+  async cancelOrder(orderId) {
+    await this.broker.cancelOrder(orderId);
+    await this.refresh();
+  }
+  async getAccount() {
+    return this.broker.getAccount();
+  }
+  async getPositions() {
+    return this.broker.getPositions();
+  }
+  recentEvents(limit = 50) {
+    return this.events.slice(-limit);
+  }
+  getStatus() {
+    const risk = this.riskManager.getState?.() || {};
+    return {
+      id: this.id,
+      symbol: this.symbol,
+      interval: this.interval,
+      mode: this.mode,
+      running: this.running,
+      equity: this.equity,
+      dayPnl: risk.dayPnl ?? 0,
+      lastPrice: this.lastPrice,
+      positions: this._cachedPositions ?? [],
+      openOrders: this._cachedOpenOrders ?? [],
+      risk: { halted: Boolean(risk.halted), ...risk }
+    };
+  }
+  /** Refresh sync caches used by getStatus() */
+  async refresh() {
+    if (this._pendingCancelPromise) {
+      await this._pendingCancelPromise;
+      this._pendingCancelPromise = null;
+    }
+    this._cachedPositions = await this.broker.getPositions().catch(() => []);
+    this._cachedOpenOrders = await this.broker.getOpenOrders?.().catch(() => []) ?? [];
+    const acct = await this.broker.getAccount?.().catch(() => null);
+    if (Number.isFinite(acct?.equity)) this.equity = acct.equity;
+    return this.getStatus();
+  }
+};
+var SessionManager = class {
+  constructor({ brokerFactory } = {}) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.brokerFactory = brokerFactory;
+  }
+  async create({
+    id,
+    mode = "paper",
+    symbol,
+    interval = "1m",
+    equity = 1e4,
+    confirmLive = false,
+    broker,
+    ...rest
+  } = {}) {
+    if (this.sessions.has(id)) throw new Error(`session "${id}" already exists`);
+    let resolvedBroker = broker;
+    if (mode === "live") {
+      if (!TradingSession.liveAllowed() || !confirmLive) {
+        throw new Error("live mode requires TRADELAB_ALLOW_LIVE=true and confirmLive:true");
+      }
+      if (!resolvedBroker && this.brokerFactory) {
+        resolvedBroker = this.brokerFactory({ symbol, ...rest });
+      }
+      if (!resolvedBroker) throw new Error("live mode requires a credentialed broker");
+    }
+    if (!resolvedBroker) resolvedBroker = new PaperEngine({ equity });
+    const session = new TradingSession({
+      id,
+      symbol,
+      interval,
+      broker: resolvedBroker,
+      mode,
+      equity,
+      confirmLive,
+      ...rest
+    });
+    await session.start();
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  get(id) {
+    return this.sessions.get(id) ?? null;
+  }
+  list() {
+    return [...this.sessions.values()];
+  }
+  async remove(id, { flatten = true } = {}) {
+    const s = this.sessions.get(id);
+    if (!s) return;
+    await s.stop({ flatten });
+    this.sessions.delete(id);
+  }
+  async haltAll() {
+    for (const s of this.sessions.values()) await s.stop({ flatten: true });
+    this.sessions.clear();
+  }
+};
+function createSessionManager(opts) {
+  return new SessionManager(opts);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AlpacaBroker,
@@ -3437,8 +3873,10 @@ function createDashboardServer({ source, port = 4317, maxBuffer = 200 }) {
   PaperEngine,
   PollingFeed,
   RiskManager,
+  SessionManager,
   StateManager,
   StorageProvider,
+  TradingSession,
   createAlpacaBroker,
   createBinanceBroker,
   createBrokerFeed,
@@ -3455,5 +3893,6 @@ function createDashboardServer({ source, port = 4317, maxBuffer = 200 }) {
   createPaperEngine,
   createPollingFeed,
   createRiskManager,
+  createSessionManager,
   createStateManager
 });