tradelab 1.0.1 → 1.2.0

package/dist/cjs/live.cjs

@@ -48,14 +48,17 @@ __export(index_exports, {
   PaperEngine: () => PaperEngine,
   PollingFeed: () => PollingFeed,
   RiskManager: () => RiskManager,
+  SessionManager: () => SessionManager,
   StateManager: () => StateManager,
   StorageProvider: () => StorageProvider,
+  TradingSession: () => TradingSession,
   createAlpacaBroker: () => createAlpacaBroker,
   createBinanceBroker: () => createBinanceBroker,
   createBrokerFeed: () => createBrokerFeed,
   createCandleAggregator: () => createCandleAggregator,
   createClock: () => createClock,
   createCoinbaseBroker: () => createCoinbaseBroker,
+  createDashboardServer: () => createDashboardServer,
   createEventBus: () => createEventBus,
   createInteractiveBrokersBroker: () => createInteractiveBrokersBroker,
   createJsonFileStorage: () => createJsonFileStorage,
@@ -65,6 +68,7 @@ __export(index_exports, {
   createPaperEngine: () => createPaperEngine,
   createPollingFeed: () => createPollingFeed,
   createRiskManager: () => createRiskManager,
+  createSessionManager: () => createSessionManager,
   createStateManager: () => createStateManager
 });
 module.exports = __toCommonJS(index_exports);
@@ -435,10 +439,10 @@ var AlpacaBroker = class extends BrokerAdapter {
       ...extra
     };
   }
-  async _request(method, path2, { query = null, body = null, dataApi = false } = {}) {
+  async _request(method, path3, { query = null, body = null, dataApi = false } = {}) {
     if (!this.fetch) throw new Error("global fetch is unavailable");
     const base = dataApi ? this.dataUrl : this.baseUrl;
-    const url = withQuery(`${base}${path2}`, query || {});
+    const url = withQuery(`${base}${path3}`, query || {});
     const response = await this.fetch(url, {
       method,
       headers: this._headers(),
@@ -648,11 +652,11 @@ var BinanceBroker = class extends BrokerAdapter {
     const signature = import_node_crypto.default.createHmac("sha256", this.config.apiSecret || "").update(payload).digest("hex");
     return { ...base, signature };
   }
-  async _request(method, path2, { signed = false, params = {}, body = null } = {}) {
+  async _request(method, path3, { signed = false, params = {}, body = null } = {}) {
     if (!this.fetch) throw new Error("global fetch is unavailable");
     const finalParams = signed ? this._signedParams(params) : params;
     const qs = queryString(finalParams);
-    const url = new import_node_url2.URL(`${this.baseUrl}${path2}${qs ? `?${qs}` : ""}`);
+    const url = new import_node_url2.URL(`${this.baseUrl}${path3}${qs ? `?${qs}` : ""}`);
     const headers = {
       "content-type": "application/json"
     };
@@ -671,8 +675,8 @@ var BinanceBroker = class extends BrokerAdapter {
     return payload;
   }
   async getServerTime() {
-    const path2 = this.config.futures ? "/fapi/v1/time" : "/api/v3/time";
-    const data = await this._request("GET", path2);
+    const path3 = this.config.futures ? "/fapi/v1/time" : "/api/v3/time";
+    const data = await this._request("GET", path3);
     return Number(data.serverTime || Date.now());
   }
   async getAccount() {
@@ -735,8 +739,8 @@ var BinanceBroker = class extends BrokerAdapter {
     return payload;
   }
   async submitOrder(order) {
-    const path2 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
-    const response = await this._request("POST", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
+    const response = await this._request("POST", path3, {
       signed: true,
       params: this._orderPayload(order)
     });
@@ -757,8 +761,8 @@ var BinanceBroker = class extends BrokerAdapter {
     return receipt;
   }
   async cancelOrder(orderId) {
-    const path2 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
-    await this._request("DELETE", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
+    await this._request("DELETE", path3, {
       signed: true,
       params: {
         orderId
@@ -767,8 +771,8 @@ var BinanceBroker = class extends BrokerAdapter {
     this.emit("order:canceled", { orderId: String(orderId) });
   }
   async modifyOrder(orderId, changes = {}) {
-    const path2 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
-    const response = await this._request("PUT", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
+    const response = await this._request("PUT", path3, {
       signed: true,
       params: {
         orderId,
@@ -793,8 +797,8 @@ var BinanceBroker = class extends BrokerAdapter {
     return receipt;
   }
   async getOpenOrders() {
-    const path2 = this.config.futures ? "/fapi/v1/openOrders" : "/api/v3/openOrders";
-    const rows = await this._request("GET", path2, { signed: true });
+    const path3 = this.config.futures ? "/fapi/v1/openOrders" : "/api/v3/openOrders";
+    const rows = await this._request("GET", path3, { signed: true });
     return rows.map((row) => ({
       orderId: String(row.orderId),
       clientOrderId: row.clientOrderId,
@@ -810,8 +814,8 @@ var BinanceBroker = class extends BrokerAdapter {
     }));
   }
   async getOrderStatus(orderId) {
-    const path2 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
-    const row = await this._request("GET", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
+    const row = await this._request("GET", path3, {
       signed: true,
       params: { orderId }
     });
@@ -873,8 +877,8 @@ var BinanceBroker = class extends BrokerAdapter {
     };
   }
   async getHistoricalBars(symbol, interval, limit = 200) {
-    const path2 = this.config.futures ? "/fapi/v1/klines" : "/api/v3/klines";
-    const rows = await this._request("GET", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/klines" : "/api/v3/klines";
+    const rows = await this._request("GET", path3, {
       params: { symbol, interval, limit }
     });
     const bars = rows.map((row) => ({
@@ -898,7 +902,7 @@ var import_node_url3 = require("node:url");
 function base64url(input) {
   return Buffer.from(input).toString("base64url");
 }
-function buildJwt({ key, secret, method, host, path: path2 }) {
+function buildJwt({ key, secret, method, host, path: path3 }) {
   const now = Math.floor(Date.now() / 1e3);
   const header = { alg: "HS256", typ: "JWT", kid: key };
   const payload = {
@@ -906,7 +910,7 @@ function buildJwt({ key, secret, method, host, path: path2 }) {
     sub: key,
     nbf: now - 5,
     exp: now + 120,
-    uri: `${method.toUpperCase()} ${host}${path2}`
+    uri: `${method.toUpperCase()} ${host}${path3}`
   };
   const encodedHeader = base64url(JSON.stringify(header));
   const encodedPayload = base64url(JSON.stringify(payload));
@@ -965,9 +969,9 @@ var CoinbaseBroker = class extends BrokerAdapter {
       path: target.pathname
     });
   }
-  async _request(method, path2, { query = {}, body = null } = {}) {
+  async _request(method, path3, { query = {}, body = null } = {}) {
     if (!this.fetch) throw new Error("global fetch is unavailable");
-    const url = new import_node_url3.URL(`${this.baseUrl}${path2}`);
+    const url = new import_node_url3.URL(`${this.baseUrl}${path3}`);
     for (const [key, value] of Object.entries(query || {})) {
       if (value === void 0 || value === null) continue;
       url.searchParams.set(key, String(value));
@@ -1726,6 +1730,7 @@ function dayKeyET(timeMs) {
   const pseudoEtTime = anchor.getTime() + hoursET * 60 * 60 * 1e3 + minutesETDay * 60 * 1e3;
   return dayKeyUTC(pseudoEtTime);
 }
+var MS_PER_YEAR = 365 * 24 * 60 * 60 * 1e3;
 
 // src/live/engine/candleAggregator.js
 function intervalToMs(interval) {
@@ -2481,6 +2486,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);
@@ -2549,9 +2555,9 @@ function asNumber2(value) {
 function formatIsoTime(time) {
   return Number.isFinite(time) ? new Date(time).toISOString() : "invalid-time";
 }
-function callSignalWithContext({ signal, context, index, bar, symbol }) {
+async function callSignalWithContextAsync({ signal, context, index, bar, symbol }) {
   try {
-    return signal(context);
+    return await signal(context);
   } catch (error) {
     const cause = error instanceof Error ? error.message : String(error);
     throw new Error(
@@ -3038,7 +3044,7 @@ var LiveEngine = class {
     }
     if (!this.openPosition && !this.pendingOrder) {
       const context = this._signalContext(bar);
-      const rawSignal = callSignalWithContext({
+      const rawSignal = await callSignalWithContextAsync({
         signal: this.options.signal,
         context,
         index: context.index,
@@ -3309,6 +3315,507 @@ var LiveOrchestrator = class {
 function createLiveOrchestrator(options) {
   return new LiveOrchestrator(options);
 }
+
+// src/live/dashboard/server.js
+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 FALLBACK_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>tradelab live</title>
+  </head>
+  <body>
+    <h1>tradelab live</h1>
+    <pre id="state"></pre>
+    <script>
+      fetch("/state")
+        .then((res) => res.json())
+        .then((state) => {
+          document.getElementById("state").textContent = JSON.stringify(state, null, 2);
+        });
+    </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() {
+  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 {
+    return FALLBACK_HTML;
+  }
+}
+function createDashboardServer({ source, port = 4317, maxBuffer = 200 }) {
+  if (!source?.eventBus || typeof source.eventBus.onAny !== "function") {
+    throw new Error("dashboard source must expose an eventBus with onAny()");
+  }
+  const recent = [];
+  const clients = /* @__PURE__ */ new Set();
+  const unsubscribe = source.eventBus.onAny(({ event, payload }) => {
+    const msg = { event, payload, t: Date.now() };
+    recent.push(msg);
+    if (recent.length > maxBuffer) recent.shift();
+    const frame = `data: ${JSON.stringify(msg)}
+
+`;
+    for (const res of clients) res.write(frame);
+  });
+  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" });
+      res.end(readDashboardHtml());
+      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",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      res.flushHeaders();
+      for (const msg of recent) res.write(`data: ${JSON.stringify(msg)}
+
+`);
+      clients.add(res);
+      req.on("close", () => clients.delete(res));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("not found");
+  });
+  return {
+    start() {
+      return new Promise((resolve) => {
+        server.listen(port, () => {
+          const address = server.address();
+          const actualPort = typeof address === "object" && address ? address.port : port;
+          resolve(`http://localhost:${actualPort}`);
+        });
+      });
+    },
+    close() {
+      unsubscribe();
+      for (const res of clients) res.end();
+      clients.clear();
+      return new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error) reject(error);
+          else resolve();
+        });
+      });
+    },
+    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";
+}
+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._record("order:canceled", order));
+    this.broker.on?.("equity:update", (acct) => this._record("equity:update", acct));
+  }
+  // Sync event handler — fire-and-forget async OCO work via a stored promise
+  _onBrokerFillSync(order) {
+    this._record("order:filled", order);
+    if (this._pendingBracket && String(order.clientOrderId || "").includes("-entry-")) {
+      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 receipt = await this.broker.submitOrder({
+      symbol: this.symbol,
+      side: toBrokerSide(side),
+      type,
+      qty: size,
+      limitPrice: type === "limit" ? limitPrice : void 0,
+      clientOrderId: `${this.id}-entry-${Date.now()}`
+    });
+    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 {
+        this._pendingBracket = { side, size, stop, target, rr, entryRef };
+      }
+    }
+    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,
@@ -3329,14 +3836,17 @@ function createLiveOrchestrator(options) {
   PaperEngine,
   PollingFeed,
   RiskManager,
+  SessionManager,
   StateManager,
   StorageProvider,
+  TradingSession,
   createAlpacaBroker,
   createBinanceBroker,
   createBrokerFeed,
   createCandleAggregator,
   createClock,
   createCoinbaseBroker,
+  createDashboardServer,
   createEventBus,
   createInteractiveBrokersBroker,
   createJsonFileStorage,
@@ -3346,5 +3856,6 @@ function createLiveOrchestrator(options) {
   createPaperEngine,
   createPollingFeed,
   createRiskManager,
+  createSessionManager,
   createStateManager
 });