tradelab 0.5.0 → 1.0.0

package/README.md

@@ -3,19 +3,19 @@
 
   <p><strong>A Node.js backtesting toolkit for serious trading strategy research.</strong></p>
 
-  [![npm version](https://img.shields.io/npm/v/tradelab?color=0f172a&label=npm&logo=npm)](https://www.npmjs.com/package/tradelab)
-  [![GitHub](https://img.shields.io/badge/github-ishsharm0/tradelab-0f172a?logo=github)](https://github.com/ishsharm0/tradelab)
-  [![License: MIT](https://img.shields.io/badge/license-MIT-0f172a)](https://github.com/ishsharm0/tradelab/blob/main/LICENSE)
-  [![Node.js](https://img.shields.io/badge/node-%3E%3D18-0f172a?logo=node.js)](https://nodejs.org)
-  [![TypeScript](https://img.shields.io/badge/TypeScript-ready-0f172a?logo=typescript)](https://github.com/ishsharm0/tradelab/blob/main/types/index.d.ts)
+[![npm version](https://img.shields.io/npm/v/tradelab?color=0f172a&label=npm&logo=npm)](https://www.npmjs.com/package/tradelab)
+[![GitHub](https://img.shields.io/badge/github-ishsharm0/tradelab-0f172a?logo=github)](https://github.com/ishsharm0/tradelab)
+[![License: MIT](https://img.shields.io/badge/license-MIT-0f172a)](https://github.com/ishsharm0/tradelab/blob/main/LICENSE)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-0f172a?logo=node.js)](https://nodejs.org)
+[![TypeScript](https://img.shields.io/badge/TypeScript-ready-0f172a?logo=typescript)](https://github.com/ishsharm0/tradelab/blob/main/types/index.d.ts)
 
 </div>
 
 ---
 
-**tradelab** handles the simulation, sizing, exits, costs, and result exports; you bring the data and signal logic.
+**tradelab** handles strategy research and execution workflows in one package.
 
-It works cleanly for a single-strategy backtest and scales up to portfolio runs, walk-forward testing, and detailed execution modeling. It is not a broker connector or a live trading tool.
+Use it for backtests, portfolio and walk-forward validation, and live or paper execution through broker adapters while keeping the same `signal()` contract.
 
 ```bash
 npm install tradelab
@@ -32,6 +32,7 @@ npm install tradelab
 - [Portfolio mode](#portfolio-mode)
 - [Walk-forward optimization](#walk-forward-optimization)
 - [Tick backtests](#tick-backtests)
+- [Live trading](#live-trading)
 - [Execution and cost modeling](#execution-and-cost-modeling)
 - [Exports and reporting](#exports-and-reporting)
 - [CLI](#cli)
@@ -42,15 +43,16 @@ npm install tradelab
 
 ## What it includes
 
-| Area | What you get |
-|---|---|
-| **Engine** | Candle and tick backtests with position sizing, exits, replay capture, and cost models |
-| **Portfolio** | Multi-system shared-capital simulation with live capital locking and daily loss halts |
-| **Walk-forward** | Rolling and anchored train/test validation with parameter search and stability summaries |
-| **Data** | Yahoo Finance downloads, CSV import, and local cache helpers |
-| **Costs** | Slippage, spread, and commission modeling |
-| **Exports** | HTML reports, metrics JSON, and trade CSV |
-| **Dev experience** | TypeScript definitions, ESM/CJS support, CLI for quick runs |
+| Area               | What you get                                                                             |
+| ------------------ | ---------------------------------------------------------------------------------------- |
+| **Engine**         | Candle and tick backtests with position sizing, exits, replay capture, and cost models   |
+| **Portfolio**      | Multi-system shared-capital simulation with live capital locking and daily loss halts    |
+| **Walk-forward**   | Rolling and anchored train/test validation with parameter search and stability summaries |
+| **Live execution** | Live and paper engines with broker adapters, state persistence, and orchestration        |
+| **Data**           | Yahoo Finance downloads, CSV import, and local cache helpers                             |
+| **Costs**          | Slippage, spread, and commission modeling                                                |
+| **Exports**        | HTML reports, metrics JSON, and trade CSV                                                |
+| **Dev experience** | TypeScript definitions, ESM/CJS support, CLI for quick runs                              |
 
 ---
 
@@ -108,7 +110,7 @@ const candles = await getHistoricalCandles({
   symbol: "SPY",
   interval: "1d",
   period: "2y",
-  cache: true,       // reuses local copy on repeated runs
+  cache: true, // reuses local copy on repeated runs
 });
 
 const result = backtest({ candles, symbol: "SPY", interval: "1d", range: "2y", signal });
@@ -161,16 +163,16 @@ The minimum viable signal is just `side`, `stop`, and `rr`. Start there and add
 
 ### Key backtest options
 
-| Option | Purpose |
-|---|---|
-| `equity` | Starting equity (default `10000`) |
-| `riskPct` | Percent of equity risked per trade |
-| `warmupBars` | Bars skipped before signal evaluation starts |
-| `flattenAtClose` | Forces end-of-day exit when enabled |
-| `costs` | Slippage, spread, and commission model |
-| `strict` | Throws on lookahead access |
-| `collectEqSeries` | Enables equity curve output |
-| `collectReplay` | Enables visualization payload |
+| Option            | Purpose                                      |
+| ----------------- | -------------------------------------------- |
+| `equity`          | Starting equity (default `10000`)            |
+| `riskPct`         | Percent of equity risked per trade           |
+| `warmupBars`      | Bars skipped before signal evaluation starts |
+| `flattenAtClose`  | Forces end-of-day exit when enabled          |
+| `costs`           | Slippage, spread, and commission model       |
+| `strict`          | Throws on lookahead access                   |
+| `collectEqSeries` | Enables equity curve output                  |
+| `collectReplay`   | Enables visualization payload                |
 
 ### Result shape
 
@@ -229,7 +231,7 @@ const wf = walkForwardOptimize({
   stepBars: 60,
   scoreBy: "profitFactor",
   parameterSets: [
-    { fast: 8,  slow: 21, rr: 2 },
+    { fast: 8, slow: 21, rr: 2 },
     { fast: 10, slow: 30, rr: 2 },
   ],
   signalFactory(params) {
@@ -260,6 +262,40 @@ Market entries fill on the next tick, limit orders can fill at the touch with co
 
 ---
 
+## Live trading
+
+`tradelab/live` provides the live stack:
+
+- `LiveEngine` for single-system live/paper execution
+- `LiveOrchestrator` for multi-system execution with shared broker state
+- `PaperEngine` implementing the broker interface for deterministic simulation
+- broker adapters for Alpaca, Binance, Coinbase, and Interactive Brokers
+- JSON state/trade/equity persistence via `JsonFileStorage`
+
+Use the same signal contract from backtesting in live mode:
+
+```js
+import { LiveEngine, PaperEngine, JsonFileStorage } from "tradelab/live";
+
+const engine = new LiveEngine({
+  id: "aapl-1m",
+  symbol: "AAPL",
+  interval: "1m",
+  broker: new PaperEngine({ equity: 25_000 }),
+  storage: new JsonFileStorage({ baseDir: "./output/live-state" }),
+  signal({ bar, openPosition }) {
+    if (openPosition) return null;
+    return { side: "long", stop: bar.close - 1, rr: 2 };
+  },
+});
+
+await engine.start();
+```
+
+See [docs/live-trading.md](docs/live-trading.md) for API and CLI workflows.
+
+---
+
 ## Execution and cost modeling
 
 ```js
@@ -302,12 +338,12 @@ exportBacktestArtifacts({ result, outDir: "./output" });
 
 Or use the narrower helpers:
 
-| Helper | Output |
-|---|---|
-| `exportHtmlReport(options)` | Interactive HTML report written to disk |
-| `renderHtmlReport(options)` | HTML report returned as a string |
-| `exportTradesCsv(trades, options)` | Flat trade ledger for spreadsheets or pandas |
-| `exportMetricsJSON(options)` | Machine-readable metrics for dashboards or automation |
+| Helper                             | Output                                                |
+| ---------------------------------- | ----------------------------------------------------- |
+| `exportHtmlReport(options)`        | Interactive HTML report written to disk               |
+| `renderHtmlReport(options)`        | HTML report returned as a string                      |
+| `exportTradesCsv(trades, options)` | Flat trade ledger for spreadsheets or pandas          |
+| `exportMetricsJSON(options)`       | Machine-readable metrics for dashboards or automation |
 
 For programmatic pipelines, `exportMetricsJSON` is usually the most useful format to build on.
 
@@ -335,6 +371,15 @@ npx tradelab walk-forward \
   --source yahoo --symbol QQQ --interval 1d --period 2y \
   --trainBars 180 --testBars 60 --mode anchored
 
+# Live paper engine (single system)
+npx tradelab paper --symbol AAPL --interval 1m --mode polling --once true
+
+# Live orchestrator from config
+npx tradelab live --config ./live-portfolio.json --paper --mode polling --once true
+
+# Inspect persisted live state
+npx tradelab status --dir ./output/live-state
+
 # Prefetch and cache data
 npx tradelab prefetch --symbol SPY --interval 1d --period 1y
 npx tradelab import-csv --csvPath ./data/spy.csv --symbol SPY --interval 1d
@@ -364,6 +409,7 @@ The examples are a good place to start if you want something runnable before wir
 ```js
 import { backtest, getHistoricalCandles, ema } from "tradelab";
 import { fetchHistorical } from "tradelab/data";
+import { LiveEngine, PaperEngine } from "tradelab/live";
 ```
 
 ### CommonJS
@@ -371,18 +417,20 @@ import { fetchHistorical } from "tradelab/data";
 ```js
 const { backtest, getHistoricalCandles, ema } = require("tradelab");
 const { fetchHistorical } = require("tradelab/data");
+const { LiveEngine, PaperEngine } = require("tradelab/live");
 ```
 
 ---
 
 ## Documentation
 
-| Guide | What it covers |
-|---|---|
-| [Backtest engine](docs/backtest-engine.md) | Signal contract, all options, result shape, portfolio mode, walk-forward |
-| [Data, reporting, and CLI](docs/data-reporting-cli.md) | Data loading, cache behavior, exports, CLI reference |
-| [Strategy examples](docs/examples.md) | Mean reversion, breakout, sentiment, LLM, and portfolio strategy patterns |
-| [API reference](docs/api-reference.md) | Compact index of every public export |
+| Guide                                                  | What it covers                                                                 |
+| ------------------------------------------------------ | ------------------------------------------------------------------------------ |
+| [Backtest engine](docs/backtest-engine.md)             | Signal contract, all options, result shape, portfolio mode, walk-forward       |
+| [Data, reporting, and CLI](docs/data-reporting-cli.md) | Data loading, cache behavior, exports, CLI reference                           |
+| [Live trading](docs/live-trading.md)                   | Live engine, broker adapters, paper mode, orchestration, and state persistence |
+| [Strategy examples](docs/examples.md)                  | Mean reversion, breakout, sentiment, LLM, and portfolio strategy patterns      |
+| [API reference](docs/api-reference.md)                 | Compact index of every public export                                           |
 
 ---
 
@@ -401,4 +449,4 @@ const { fetchHistorical } = require("tradelab/data");
 - Node `18+` is required
 - Yahoo downloads are cached under `output/data` by default
 - CommonJS and ESM are both supported
-- The engine is built for historical research - not brokerage execution or full exchange microstructure simulation
+- Live adapters support broker execution workflows, but this is still not an exchange microstructure simulator

package/bin/tradelab.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import fs from "node:fs";
 import path from "path";
 import { pathToFileURL } from "url";
 
@@ -13,6 +14,16 @@ import {
   saveCandlesToCache,
   walkForwardOptimize,
 } from "../src/index.js";
+import {
+  AlpacaBroker,
+  BinanceBroker,
+  CoinbaseBroker,
+  InteractiveBrokersBroker,
+  JsonFileStorage,
+  LiveEngine,
+  LiveOrchestrator,
+  PaperEngine,
+} from "../src/live/index.js";
 
 function parseArgs(argv) {
   const args = { _: [] };
@@ -24,12 +35,15 @@ function parseArgs(argv) {
     }
 
     const key = token.slice(2);
+    const camelKey = key.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
     const next = argv[index + 1];
+    const value = next && !next.startsWith("--") ? next : true;
+    args[key] = value;
+    if (camelKey !== key && args[camelKey] === undefined) {
+      args[camelKey] = value;
+    }
     if (next && !next.startsWith("--")) {
-      args[key] = next;
       index += 1;
-    } else {
-      args[key] = true;
     }
   }
   return args;
@@ -50,15 +64,71 @@ function toList(value, fallback) {
 
 function parseJsonValue(value, fallback = null) {
   if (!value) return fallback;
-  return JSON.parse(String(value));
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    throw new Error(`Invalid JSON value: ${String(value).slice(0, 120)}`);
+  }
 }
 
-function createEmaCrossSignal({
-  fast = 10,
-  slow = 30,
-  rr = 2,
-  stopLookback = 15,
-} = {}) {
+function toBoolean(value, fallback = false) {
+  if (value === undefined || value === null) return fallback;
+  if (value === true || value === false) return value;
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "n", "off"].includes(normalized)) return false;
+  return fallback;
+}
+
+function loadJsonFile(filePath) {
+  const resolved = path.resolve(process.cwd(), filePath);
+  const raw = fs.readFileSync(resolved, "utf8");
+  return JSON.parse(raw);
+}
+
+function resolveBrokerName(name, paperMode = false) {
+  if (paperMode) return "paper";
+  return String(name || "paper").toLowerCase();
+}
+
+function createBrokerAdapter(args, overrides = {}) {
+  const brokerName = resolveBrokerName(
+    overrides.broker || args.broker,
+    toBoolean(overrides.paper ?? args.paper, false)
+  );
+
+  if (brokerName === "paper") {
+    return new PaperEngine({
+      equity: toNumber(overrides.equity ?? args.equity, 10_000),
+      slippageBps: toNumber(overrides.slippageBps ?? args.slippageBps, 0),
+      feeBps: toNumber(overrides.feeBps ?? args.feeBps, 0),
+      costs: parseJsonValue(overrides.costs ?? args.costs, null),
+    });
+  }
+
+  if (brokerName === "alpaca") return new AlpacaBroker();
+  if (brokerName === "binance") return new BinanceBroker();
+  if (brokerName === "coinbase") return new CoinbaseBroker();
+  if (brokerName === "ib" || brokerName === "interactivebrokers") {
+    return new InteractiveBrokersBroker();
+  }
+
+  throw new Error(`Unsupported broker "${brokerName}"`);
+}
+
+function brokerConfigFromArgs(args, overrides = {}) {
+  return {
+    apiKey: overrides.apiKey ?? args.apiKey,
+    apiSecret: overrides.apiSecret ?? args.apiSecret,
+    passphrase: overrides.passphrase ?? args.passphrase,
+    paper: toBoolean(overrides.paper ?? args.paper, false),
+    baseUrl: overrides.baseUrl ?? args.baseUrl,
+    wsUrl: overrides.wsUrl ?? args.wsUrl,
+    futures: toBoolean(overrides.futures ?? args.futures, false),
+  };
+}
+
+function createEmaCrossSignal({ fast = 10, slow = 30, rr = 2, stopLookback = 15 } = {}) {
   return ({ candles }) => {
     if (candles.length < Math.max(fast, slow) + 2) return null;
 
@@ -67,27 +137,17 @@ function createEmaCrossSignal({
     const slowLine = ema(closes, slow);
     const last = closes.length - 1;
 
-    if (
-      fastLine[last - 1] <= slowLine[last - 1] &&
-      fastLine[last] > slowLine[last]
-    ) {
+    if (fastLine[last - 1] <= slowLine[last - 1] && fastLine[last] > slowLine[last]) {
       const entry = candles[last].close;
-      const stop = Math.min(
-        ...candles.slice(-stopLookback).map((bar) => bar.low)
-      );
+      const stop = Math.min(...candles.slice(-stopLookback).map((bar) => bar.low));
       if (entry > stop) {
         return { side: "long", entry, stop, rr };
       }
     }
 
-    if (
-      fastLine[last - 1] >= slowLine[last - 1] &&
-      fastLine[last] < slowLine[last]
-    ) {
+    if (fastLine[last - 1] >= slowLine[last - 1] && fastLine[last] < slowLine[last]) {
       const entry = candles[last].close;
-      const stop = Math.max(
-        ...candles.slice(-stopLookback).map((bar) => bar.high)
-      );
+      const stop = Math.max(...candles.slice(-stopLookback).map((bar) => bar.high));
       if (entry < stop) {
         return { side: "short", entry, stop, rr };
       }
@@ -170,9 +230,7 @@ async function loadWalkForwardStrategy(strategyArg, args) {
   const resolved = path.resolve(process.cwd(), strategyArg);
   const module = await import(pathToFileURL(resolved).href);
   if (typeof module.signalFactory !== "function") {
-    throw new Error(
-      `Walk-forward strategy module "${strategyArg}" must export signalFactory`
-    );
+    throw new Error(`Walk-forward strategy module "${strategyArg}" must export signalFactory`);
   }
 
   const parameterSets =
@@ -196,12 +254,17 @@ async function loadWalkForwardStrategy(strategyArg, args) {
 }
 
 function printHelp() {
-  console.log(`tradelab
+  console.log(`tradelab — backtesting toolkit for Node.js
+
+Usage: tradelab <command> [options]
 
 Commands:
   backtest      Run a one-off backtest from Yahoo or CSV data
   portfolio     Run multiple CSV datasets as an equal-weight portfolio
   walk-forward  Run rolling or anchored train/test optimization
+  live          Run live trading engine (streaming or polling)
+  paper         Run live engine in paper broker mode
+  status        Read persisted live state
   prefetch      Download Yahoo candles into the local cache
   import-csv    Normalize a CSV and save it into the local cache
 
@@ -209,12 +272,21 @@ Examples:
   tradelab backtest --source yahoo --symbol SPY --interval 1d --period 1y
   tradelab backtest --source csv --csvPath ./data/btc.csv --strategy buy-hold --holdBars 3
   tradelab walk-forward --source csv --csvPath ./data/spy.csv --trainBars 120 --testBars 40
+  tradelab live --strategy ./mySignal.js --symbol AAPL --interval 5m --broker alpaca --paper
+
+Options:
+  --help       Show this help message
+  --version    Print version number
 `);
 }
 
 async function commandBacktest(args) {
+  const source = args.source || (args.csvPath ? "csv" : "yahoo");
+  if (source === "yahoo" && !args.symbol) {
+    throw new Error("backtest with Yahoo source requires --symbol (e.g. --symbol SPY)");
+  }
   const candles = await getHistoricalCandles({
-    source: args.source || (args.csvPath ? "csv" : "yahoo"),
+    source,
     symbol: args.symbol,
     interval: args.interval || "1d",
     period: args.period || "1y",
@@ -311,8 +383,12 @@ async function commandPortfolio(args) {
 }
 
 async function commandWalkForward(args) {
+  const wfSource = args.source || (args.csvPath ? "csv" : "yahoo");
+  if (wfSource === "yahoo" && !args.symbol) {
+    throw new Error("walk-forward with Yahoo source requires --symbol (e.g. --symbol QQQ)");
+  }
   const candles = await getHistoricalCandles({
-    source: args.source || (args.csvPath ? "csv" : "yahoo"),
+    source: wfSource,
     symbol: args.symbol,
     interval: args.interval || "1d",
     period: args.period || "1y",
@@ -398,10 +474,174 @@ async function commandImportCsv(args) {
   console.log(`Saved ${candles.length} candles to ${outputPath}`);
 }
 
+async function createLiveSystemFromConfig(system, args) {
+  const signal = await loadStrategy(system.strategy || args.strategy, {
+    ...args,
+    ...system,
+  });
+  return {
+    ...system,
+    signal,
+    interval: system.interval || args.interval || "1m",
+    symbol: system.symbol || args.symbol,
+  };
+}
+
+async function commandLive(args, overrides = {}) {
+  const configPath = overrides.config || args.config;
+  const mode = overrides.mode || args.mode || "streaming";
+  const stateDir = overrides.stateDir || args.stateDir || "output/live-state";
+  const once = toBoolean(overrides.once ?? args.once, mode === "polling");
+  const watch = toBoolean(overrides.watch ?? args.watch, false);
+  const storage = new JsonFileStorage({ baseDir: stateDir });
+
+  if (configPath) {
+    const fileConfig = loadJsonFile(configPath);
+    const broker = createBrokerAdapter(args, {
+      ...overrides,
+      equity: fileConfig.equity ?? overrides.equity,
+    });
+    const brokerConfig = brokerConfigFromArgs(args, overrides);
+    const systems = await Promise.all(
+      (fileConfig.systems || []).map((system) => createLiveSystemFromConfig(system, args))
+    );
+    const orchestrator = new LiveOrchestrator({
+      systems,
+      broker,
+      storage,
+      brokerConfig,
+      allocation: fileConfig.allocation || args.allocation || "equal",
+      maxDailyLossPct: toNumber(fileConfig.maxDailyLossPct ?? args.maxDailyLossPct, 0),
+      equity: toNumber(fileConfig.equity ?? args.equity, 10_000),
+    });
+    await broker.connect(brokerConfig);
+    await orchestrator.start();
+
+    if (once && orchestrator.engines?.length) {
+      await Promise.all(orchestrator.engines.map((engine) => engine.pollOnce()));
+    }
+
+    const status = orchestrator.getStatus();
+    console.log(JSON.stringify(status, null, 2));
+
+    if (!watch) {
+      await orchestrator.stop();
+    }
+    return;
+  }
+
+  const broker = createBrokerAdapter(args, overrides);
+  const brokerConfig = brokerConfigFromArgs(args, overrides);
+  const signal = await loadStrategy(overrides.strategy || args.strategy, args);
+  const engine = new LiveEngine({
+    id: overrides.id || args.id,
+    signal,
+    symbol: overrides.symbol || args.symbol,
+    interval: overrides.interval || args.interval || "1m",
+    mode,
+    pollIntervalMs: toNumber(overrides.pollIntervalMs ?? args.pollIntervalMs, 60_000),
+    warmupBars: toNumber(overrides.warmupBars ?? args.warmupBars, 200),
+    equity: toNumber(overrides.equity ?? args.equity, 10_000),
+    riskPct: toNumber(overrides.riskPct ?? args.riskPct, 1),
+    costs: parseJsonValue(overrides.costs ?? args.costs, null),
+    flattenAtClose: toBoolean(overrides.flattenAtClose ?? args.flattenAtClose, false),
+    maxDailyLossPct: toNumber(overrides.maxDailyLossPct ?? args.maxDailyLossPct, 0),
+    dailyMaxTrades: toNumber(overrides.dailyMaxTrades ?? args.dailyMaxTrades, 0),
+    broker,
+    storage,
+    brokerConfig,
+  });
+
+  await engine.start();
+
+  if (once) {
+    await engine.pollOnce();
+  }
+
+  const status = engine.getStatus();
+  console.log(JSON.stringify(status, null, 2));
+
+  if (!watch) {
+    await engine.stop();
+    return;
+  }
+
+  const shutdown = async () => {
+    await engine.stop();
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}
+
+async function commandPaper(args) {
+  return commandLive(args, { paper: true, broker: "paper" });
+}
+
+async function commandStatus(args) {
+  const stateDir = args.dir || args.stateDir || "output/live-state";
+  const storage = new JsonFileStorage({ baseDir: stateDir });
+  const namespace = args.namespace || args.id;
+
+  if (namespace) {
+    const state = await storage.load(namespace);
+    const trades = await storage.loadTrades(namespace);
+    const equity = await storage.loadEquityCurve(namespace);
+    console.log(
+      JSON.stringify(
+        {
+          namespace,
+          state,
+          trades: trades.length,
+          equityPoints: equity.length,
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  if (!fs.existsSync(stateDir)) {
+    console.log(JSON.stringify({ dir: stateDir, namespaces: [] }, null, 2));
+    return;
+  }
+
+  const namespaces = fs
+    .readdirSync(stateDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+  const summaries = [];
+  for (const name of namespaces) {
+    const state = await storage.load(name);
+    const trades = await storage.loadTrades(name);
+    summaries.push({
+      namespace: name,
+      savedAt: state?.savedAt ?? null,
+      equity: state?.equity ?? null,
+      openPosition: Boolean(state?.openPosition),
+      trades: trades.length,
+    });
+  }
+  console.log(
+    JSON.stringify(
+      {
+        dir: stateDir,
+        namespaces: summaries,
+      },
+      null,
+      2
+    )
+  );
+}
+
 const commands = {
   backtest: commandBacktest,
   portfolio: commandPortfolio,
   "walk-forward": commandWalkForward,
+  live: commandLive,
+  paper: commandPaper,
+  status: commandStatus,
   prefetch: commandPrefetch,
   "import-csv": commandImportCsv,
 };
@@ -410,6 +650,12 @@ async function main() {
   const args = parseArgs(process.argv.slice(2));
   const command = args._[0];
 
+  if (args.version || args.v) {
+    const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    console.log(pkg.version);
+    return;
+  }
+
   if (!command || command === "help" || args.help) {
     printHelp();
     return;