tradelab 1.1.0 → 1.2.1

package/docs/superpowers/plans/2026-05-mcp-server.md

@@ -1,758 +0,0 @@
-# `tradelab/mcp` Server Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Ship an MCP server that exposes tradelab's research loop (fetch data → choose/parameterize a strategy → backtest → read metrics → walk-forward) as tools any agent (Claude Desktop, Cursor, Claude Code) can call autonomously.
-
-**Architecture:** Agents cannot pass JS closures over MCP, so strategies are **named and parameterized** through a registry (`src/strategies/`). The MCP tools are pure async functions in `src/mcp/tools.js` (unit-testable without a transport); `src/mcp/server.js` wires them to `@modelcontextprotocol/sdk`'s `McpServer` over stdio. Tool outputs are LLM-sized summaries (metrics + trade counts), never full replay frames. A `bin/tradelab-mcp.js` launches the server.
-
-**Tech Stack:** Node ESM, `@modelcontextprotocol/sdk`, `zod` for tool input schemas, `node:test`. Builds on Plan 1 (clean metrics) and Plan 4 (`backtestAsync`, optional).
-
----
-
-### Task 1: Named strategy registry
-
-**Files:**
-
-- Create: `src/strategies/index.js`
-- Create: `src/strategies/builtins.js`
-- Modify: `src/index.js`
-- Test: `test/strategies/registry.test.js`
-
-- [ ] **Step 1: Write the failing test**
-
-```js
-// test/strategies/registry.test.js
-import test from "node:test";
-import assert from "node:assert/strict";
-import { listStrategies, getStrategy } from "../../src/strategies/index.js";
-
-test("listStrategies returns built-ins with name, description, params", () => {
-  const all = listStrategies();
-  const names = all.map((s) => s.name);
-  assert.ok(names.includes("ema-cross"));
-  assert.ok(names.includes("rsi-reversion"));
-  assert.ok(names.includes("donchian-breakout"));
-  assert.ok(names.includes("buy-hold"));
-  const ema = all.find((s) => s.name === "ema-cross");
-  assert.equal(typeof ema.description, "string");
-  assert.equal(typeof ema.params.fast.default, "number");
-});
-
-test("getStrategy returns a signalFactory producing a working signal", () => {
-  const factory = getStrategy("ema-cross");
-  const signal = factory({ fast: 3, slow: 5, rr: 2 });
-  assert.equal(typeof signal, "function");
-  const candles = Array.from({ length: 20 }, (_, i) => ({
-    time: i * 60000,
-    high: 101 + i,
-    low: 99 + i,
-    close: 100 + i,
-  }));
-  const out = signal({ candles, index: 19, bar: candles[19], equity: 10_000 });
-  assert.ok(out === null || typeof out === "object");
-});
-
-test("getStrategy throws on unknown name with the available list", () => {
-  assert.throws(() => getStrategy("nope"), /Unknown strategy "nope"/);
-});
-```
-
-- [ ] **Step 2: Run to verify it fails**
-
-Run: `node --test test/strategies/registry.test.js`
-Expected: FAIL — cannot find module.
-
-- [ ] **Step 3: Implement src/strategies/builtins.js**
-
-```js
-// src/strategies/builtins.js
-import { ema } from "../utils/indicators.js";
-import { rsi } from "../ta/oscillators.js";
-import { donchian } from "../ta/channels.js";
-
-// Each entry: { description, params: { name: {type, default, description} }, factory }
-// factory(params) => signal(context) compatible with backtest().
-
-export const BUILTINS = {
-  "ema-cross": {
-    description: "Long when fast EMA crosses above slow EMA; stop at recent swing low.",
-    params: {
-      fast: { type: "number", default: 10, description: "fast EMA period" },
-      slow: { type: "number", default: 30, description: "slow EMA period" },
-      rr: { type: "number", default: 2, description: "reward:risk target" },
-      lookback: { type: "number", default: 15, description: "swing-low lookback for stop" },
-    },
-    factory({ fast = 10, slow = 30, rr = 2, lookback = 15 } = {}) {
-      return ({ candles, bar }) => {
-        if (candles.length < slow + 2) return null;
-        const closes = candles.map((c) => c.close);
-        const f = ema(closes, fast);
-        const s = ema(closes, slow);
-        const last = closes.length - 1;
-        if (f[last - 1] <= s[last - 1] && f[last] > s[last]) {
-          const stop = Math.min(...candles.slice(-lookback).map((c) => c.low));
-          if (stop >= bar.close) return null;
-          return { side: "long", entry: bar.close, stop, rr };
-        }
-        return null;
-      };
-    },
-  },
-
-  "rsi-reversion": {
-    description: "Long when RSI dips below `oversold`; stop a fixed pct below entry.",
-    params: {
-      period: { type: "number", default: 14, description: "RSI period" },
-      oversold: { type: "number", default: 30, description: "RSI entry threshold" },
-      stopPct: { type: "number", default: 2, description: "stop distance in percent" },
-      rr: { type: "number", default: 1.5, description: "reward:risk target" },
-    },
-    factory({ period = 14, oversold = 30, stopPct = 2, rr = 1.5 } = {}) {
-      return ({ candles, bar }) => {
-        if (candles.length < period + 2) return null;
-        const values = rsi(
-          candles.map((c) => c.close),
-          period
-        );
-        const r = values[values.length - 1];
-        if (r === undefined || r > oversold) return null;
-        return { side: "long", entry: bar.close, stop: bar.close * (1 - stopPct / 100), rr };
-      };
-    },
-  },
-
-  "donchian-breakout": {
-    description: "Long on a close above the prior Donchian upper channel.",
-    params: {
-      period: { type: "number", default: 20, description: "channel lookback" },
-      rr: { type: "number", default: 2, description: "reward:risk target" },
-    },
-    factory({ period = 20, rr = 2 } = {}) {
-      return ({ candles, bar }) => {
-        if (candles.length < period + 2) return null;
-        const ch = donchian(candles, period);
-        const i = candles.length - 1;
-        const priorUpper = ch.upper[i - 1];
-        const priorLower = ch.lower[i - 1];
-        if (priorUpper === undefined) return null;
-        if (bar.close > priorUpper) {
-          return { side: "long", entry: bar.close, stop: priorLower, rr };
-        }
-        return null;
-      };
-    },
-  },
-
-  "buy-hold": {
-    description: "Enter once at the first eligible bar and hold for `holdBars`.",
-    params: {
-      holdBars: { type: "number", default: 5, description: "bars to hold before exit" },
-      stopPct: { type: "number", default: 10, description: "protective stop distance in percent" },
-    },
-    factory({ holdBars = 5, stopPct = 10 } = {}) {
-      let entered = false;
-      return ({ bar }) => {
-        if (entered) return null;
-        entered = true;
-        return {
-          side: "long",
-          entry: bar.close,
-          stop: bar.close * (1 - stopPct / 100),
-          rr: 5,
-          _maxBarsInTrade: holdBars,
-        };
-      };
-    },
-  },
-};
-```
-
-- [ ] **Step 4: Implement src/strategies/index.js**
-
-```js
-// src/strategies/index.js
-import { BUILTINS } from "./builtins.js";
-
-const registry = new Map(Object.entries(BUILTINS));
-
-/** Register a custom strategy at runtime. `def` is a BUILTINS-shaped object. */
-export function registerStrategy(name, def) {
-  if (typeof def?.factory !== "function") {
-    throw new Error(`registerStrategy("${name}") requires a factory function`);
-  }
-  registry.set(name, def);
-}
-
-/** List all strategies as { name, description, params }. */
-export function listStrategies() {
-  return [...registry.entries()].map(([name, def]) => ({
-    name,
-    description: def.description,
-    params: def.params,
-  }));
-}
-
-/** Get a strategy's signalFactory(params) => signal. Throws on unknown name. */
-export function getStrategy(name) {
-  const def = registry.get(name);
-  if (!def) {
-    const available = [...registry.keys()].join(", ");
-    throw new Error(`Unknown strategy "${name}". Available: ${available}`);
-  }
-  return def.factory;
-}
-```
-
-- [ ] **Step 5: Export from src/index.js**
-
-```js
-export { listStrategies, getStrategy, registerStrategy } from "./strategies/index.js";
-```
-
-- [ ] **Step 6: Run test + suite**
-
-Run: `node --test test/strategies/registry.test.js`
-Expected: PASS (3 tests).
-
-Run: `node --test`
-Expected: PASS.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add src/strategies/index.js src/strategies/builtins.js src/index.js test/strategies/registry.test.js
-git commit -m "feat: add named strategy registry with built-ins
-
-Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
-```
-
----
-
-### Task 2: MCP tool functions (transport-free, testable)
-
-**Files:**
-
-- Create: `src/mcp/tools.js`
-- Test: `test/mcp/tools.test.js`
-
-- [ ] **Step 1: Write the failing test**
-
-```js
-// test/mcp/tools.test.js
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mcpTools } from "../../src/mcp/tools.js";
-
-function buildCandles(n = 60) {
-  const start = Date.UTC(2025, 0, 2, 14, 30, 0);
-  return Array.from({ length: n }, (_, i) => ({
-    time: start + i * 86_400_000,
-    open: 100 + i,
-    high: 101 + i,
-    low: 99 + i,
-    close: 100 + i + (i % 3 === 0 ? -0.5 : 0.5),
-    volume: 1000 + i,
-  }));
-}
-
-test("list_strategies returns the registry", async () => {
-  const out = await mcpTools.list_strategies.handler({});
-  assert.ok(Array.isArray(out.strategies));
-  assert.ok(out.strategies.some((s) => s.name === "ema-cross"));
-});
-
-test("run_backtest with inline candles returns an LLM-sized metrics summary", async () => {
-  const candles = buildCandles();
-  const out = await mcpTools.run_backtest.handler({
-    candles,
-    symbol: "TEST",
-    interval: "1d",
-    strategy: "ema-cross",
-    params: { fast: 3, slow: 5, rr: 2 },
-  });
-  assert.equal(typeof out.metrics.trades, "number");
-  assert.equal(typeof out.metrics.profitFactor, "number");
-  assert.equal("sharpeAnnualized" in out.metrics, true);
-  assert.equal("replay" in out, false); // never ship replay to an agent
-  assert.ok(out.tradesPreview.length <= 10);
-});
-
-test("run_backtest rejects an unknown strategy", async () => {
-  await assert.rejects(() =>
-    mcpTools.run_backtest.handler({ candles: buildCandles(), strategy: "ghost" })
-  );
-});
-
-test("walk_forward runs a parameter grid and returns window stability", async () => {
-  const candles = buildCandles(200);
-  const out = await mcpTools.walk_forward.handler({
-    candles,
-    interval: "1d",
-    strategy: "ema-cross",
-    trainBars: 60,
-    testBars: 20,
-    mode: "anchored",
-    grid: { fast: [3, 5], slow: [8, 13] },
-  });
-  assert.ok(out.windows >= 1);
-  assert.equal(typeof out.metrics.totalPnL, "number");
-  assert.equal(typeof out.stability.uniqueWinnerCount, "number");
-});
-```
-
-- [ ] **Step 2: Run to verify it fails**
-
-Run: `node --test test/mcp/tools.test.js`
-Expected: FAIL — cannot find module.
-
-- [ ] **Step 3: Implement src/mcp/tools.js**
-
-```js
-// src/mcp/tools.js
-import { backtest } from "../engine/backtest.js";
-import { walkForwardOptimize } from "../engine/walkForward.js";
-import { getHistoricalCandles } from "../data/index.js";
-import { getStrategy, listStrategies } from "../strategies/index.js";
-
-// Strip heavy fields so tool output stays within an agent's context budget.
-function summarizeMetrics(metrics) {
-  const {
-    trades,
-    winRate,
-    profitFactor,
-    expectancy,
-    totalR,
-    avgR,
-    sharpe,
-    sharpeAnnualized,
-    sortinoAnnualized,
-    maxDrawdown,
-    calmar,
-    returnPct,
-    totalPnL,
-    finalEquity,
-    exposurePct,
-    sideBreakdown,
-  } = metrics;
-  return {
-    trades,
-    winRate,
-    profitFactor,
-    expectancy,
-    totalR,
-    avgR,
-    sharpe,
-    sharpeAnnualized,
-    sortinoAnnualized,
-    maxDrawdown,
-    calmar,
-    returnPct,
-    totalPnL,
-    finalEquity,
-    exposurePct,
-    sideBreakdown,
-  };
-}
-
-async function resolveCandles(args) {
-  if (Array.isArray(args.candles) && args.candles.length) return args.candles;
-  if (args.data) return getHistoricalCandles(args.data);
-  throw new Error("Provide either `candles` (array) or `data` (getHistoricalCandles spec).");
-}
-
-// Cartesian product of a { key: value[] } grid into parameter set objects.
-function expandGrid(grid) {
-  const keys = Object.keys(grid || {});
-  if (!keys.length) return [{}];
-  return keys.reduce(
-    (acc, key) => acc.flatMap((base) => grid[key].map((v) => ({ ...base, [key]: v }))),
-    [{}]
-  );
-}
-
-export const mcpTools = {
-  list_strategies: {
-    description: "List built-in trading strategies with their tunable parameters.",
-    handler: async () => ({ strategies: listStrategies() }),
-  },
-
-  fetch_candles: {
-    description: "Download/caches OHLCV candles from Yahoo or CSV. Returns a compact summary.",
-    handler: async (args) => {
-      const candles = await getHistoricalCandles(args);
-      return {
-        count: candles.length,
-        first: candles[0] ?? null,
-        last: candles[candles.length - 1] ?? null,
-      };
-    },
-  },
-
-  run_backtest: {
-    description:
-      "Run a single backtest using a named strategy + params. Returns a metrics summary and a small trade preview (no replay).",
-    handler: async (args) => {
-      const candles = await resolveCandles(args);
-      const factory = getStrategy(args.strategy);
-      const signal = factory(args.params || {});
-      const result = backtest({
-        candles,
-        symbol: args.symbol ?? "UNKNOWN",
-        interval: args.interval,
-        signal,
-        collectReplay: false,
-        ...(args.backtestOptions || {}),
-      });
-      return {
-        symbol: result.symbol,
-        interval: result.interval,
-        metrics: summarizeMetrics(result.metrics),
-        tradesPreview: result.positions.slice(0, 10).map((p) => ({
-          side: p.side,
-          entry: p.entryFill ?? p.entry,
-          exit: p.exit.price,
-          pnl: p.exit.pnl,
-          reason: p.exit.reason,
-        })),
-      };
-    },
-  },
-
-  walk_forward: {
-    description:
-      "Walk-forward optimize a named strategy over a parameter grid. Returns out-of-sample metrics and winner stability.",
-    handler: async (args) => {
-      const candles = await resolveCandles(args);
-      const factory = getStrategy(args.strategy);
-      const wf = walkForwardOptimize({
-        candles,
-        mode: args.mode ?? "rolling",
-        trainBars: args.trainBars,
-        testBars: args.testBars,
-        stepBars: args.stepBars ?? args.testBars,
-        scoreBy: args.scoreBy ?? "profitFactor",
-        parameterSets: expandGrid(args.grid),
-        signalFactory: (params) => factory(params),
-        backtestOptions: {
-          interval: args.interval,
-          collectReplay: false,
-          ...(args.backtestOptions || {}),
-        },
-      });
-      return {
-        windows: wf.windows.length,
-        metrics: summarizeMetrics(wf.metrics),
-        stability: wf.bestParamsSummary,
-        windowSummaries: wf.windows.map((w) => ({
-          bestParams: w.bestParams,
-          oosTrades: w.oosTrades,
-          profitable: w.profitable,
-          stabilityScore: w.stabilityScore,
-        })),
-      };
-    },
-  },
-};
-```
-
-- [ ] **Step 4: Run test + suite**
-
-Run: `node --test test/mcp/tools.test.js`
-Expected: PASS (4 tests).
-
-Run: `node --test`
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add src/mcp/tools.js test/mcp/tools.test.js
-git commit -m "feat: add transport-free MCP tool functions
-
-Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
-```
-
----
-
-### Task 3: Add MCP SDK dependencies + subpath
-
-**Files:**
-
-- Modify: `package.json`
-
-- [ ] **Step 1: Install the SDK and zod**
-
-Run:
-
-```bash
-npm install @modelcontextprotocol/sdk zod
-```
-
-Expected: both added to `dependencies` in `package.json`, lockfile updated.
-
-- [ ] **Step 2: Add the `./mcp` export and `tradelab-mcp` bin**
-
-In `package.json`, in the `exports` map add:
-
-```json
-    "./mcp": {
-      "import": "./src/mcp/server.js"
-    },
-```
-
-In the `bin` map add:
-
-```json
-    "tradelab-mcp": "bin/tradelab-mcp.js"
-```
-
-Add `"bin"` is already listed in `files`. Confirm `bin` stays in the `files` array.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add package.json package-lock.json
-git commit -m "build: add MCP SDK + zod deps and tradelab-mcp bin
-
-Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
-```
-
----
-
-### Task 4: Wire tools into an McpServer over stdio
-
-**Files:**
-
-- Create: `src/mcp/schemas.js` (zod input shapes)
-- Create: `src/mcp/server.js`
-- Create: `bin/tradelab-mcp.js`
-- Test: `test/mcp/server.test.js`
-
-- [ ] **Step 1: Write the failing test**
-
-```js
-// test/mcp/server.test.js
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createServer } from "../../src/mcp/server.js";
-
-test("createServer registers all tradelab tools", () => {
-  const server = createServer();
-  // McpServer exposes registered tool names via its internal registry; we assert
-  // the factory returns an object with a connect method (the SDK server handle).
-  assert.equal(typeof server.connect, "function");
-});
-```
-
-- [ ] **Step 2: Run to verify it fails**
-
-Run: `node --test test/mcp/server.test.js`
-Expected: FAIL — cannot find module.
-
-- [ ] **Step 3: Implement src/mcp/schemas.js**
-
-```js
-// src/mcp/schemas.js
-import { z } from "zod";
-
-const candle = z.object({
-  time: z.number(),
-  open: z.number().optional(),
-  high: z.number(),
-  low: z.number(),
-  close: z.number(),
-  volume: z.number().optional(),
-});
-
-const dataSpec = z
-  .object({
-    source: z.enum(["yahoo", "csv", "auto"]).optional(),
-    symbol: z.string().optional(),
-    interval: z.string().optional(),
-    period: z.string().optional(),
-    csvPath: z.string().optional(),
-    cache: z.boolean().optional(),
-  })
-  .passthrough();
-
-export const schemas = {
-  list_strategies: {},
-  fetch_candles: dataSpec.shape,
-  run_backtest: {
-    candles: z.array(candle).optional(),
-    data: dataSpec.optional(),
-    symbol: z.string().optional(),
-    interval: z.string().optional(),
-    strategy: z.string(),
-    params: z.record(z.any()).optional(),
-    backtestOptions: z.record(z.any()).optional(),
-  },
-  walk_forward: {
-    candles: z.array(candle).optional(),
-    data: dataSpec.optional(),
-    interval: z.string().optional(),
-    strategy: z.string(),
-    trainBars: z.number(),
-    testBars: z.number(),
-    stepBars: z.number().optional(),
-    mode: z.enum(["rolling", "anchored"]).optional(),
-    scoreBy: z.string().optional(),
-    grid: z.record(z.array(z.any())).optional(),
-    backtestOptions: z.record(z.any()).optional(),
-  },
-};
-```
-
-- [ ] **Step 4: Implement src/mcp/server.js**
-
-```js
-// src/mcp/server.js
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { mcpTools } from "./tools.js";
-import { schemas } from "./schemas.js";
-
-/** Build (but do not start) an McpServer with all tradelab tools registered. */
-export function createServer() {
-  const server = new McpServer({ name: "tradelab", version: "1.1.0" });
-
-  for (const [name, def] of Object.entries(mcpTools)) {
-    server.tool(name, def.description, schemas[name] ?? {}, async (args) => {
-      try {
-        const result = await def.handler(args ?? {});
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { isError: true, content: [{ type: "text", text: `Error: ${message}` }] };
-      }
-    });
-  }
-
-  return server;
-}
-
-/** Start the server on stdio. Called by bin/tradelab-mcp.js. */
-export async function startStdioServer() {
-  const server = createServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  return server;
-}
-```
-
-- [ ] **Step 5: Implement bin/tradelab-mcp.js**
-
-```js
-#!/usr/bin/env node
-// bin/tradelab-mcp.js
-import { startStdioServer } from "../src/mcp/server.js";
-
-startStdioServer().catch((error) => {
-  console.error("tradelab-mcp failed to start:", error);
-  process.exit(1);
-});
-```
-
-- [ ] **Step 6: Make the bin executable**
-
-Run:
-
-```bash
-chmod +x bin/tradelab-mcp.js
-```
-
-- [ ] **Step 7: Run test + suite**
-
-Run: `node --test test/mcp/server.test.js`
-Expected: PASS.
-
-Run: `node --test`
-Expected: PASS.
-
-- [ ] **Step 8: Smoke-test the server starts and lists tools**
-
-Run (sends an MCP `initialize` + `tools/list` and exits):
-
-```bash
-node bin/tradelab-mcp.js < /dev/null & sleep 1; kill %1 2>/dev/null; echo "started ok"
-```
-
-Expected: process starts without throwing (it waits on stdio). For a real
-handshake test, configure it in Claude Desktop (Task 5) — automated stdio
-handshake testing is out of scope for unit tests.
-
-- [ ] **Step 9: Commit**
-
-```bash
-git add src/mcp/schemas.js src/mcp/server.js bin/tradelab-mcp.js test/mcp/server.test.js
-git commit -m "feat: MCP stdio server wiring tradelab tools
-
-Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
-```
-
----
-
-### Task 5: Docs — agent setup guide
-
-**Files:**
-
-- Create: `docs/mcp.md`
-- Modify: `README.md`
-
-- [ ] **Step 1: Write docs/mcp.md**
-
-Document:
-
-- What the server exposes (`list_strategies`, `fetch_candles`, `run_backtest`, `walk_forward`).
-- The "agent research loop": list strategies → fetch candles → run_backtest → read metrics → walk_forward to validate.
-- Claude Desktop config snippet:
-
-````markdown
-```json
-{
-  "mcpServers": {
-    "tradelab": {
-      "command": "npx",
-      "args": ["-y", "tradelab", "tradelab-mcp"]
-    }
-  }
-}
-```
-````
-
-(After `npm install -g tradelab` you can instead use `"command": "tradelab-mcp"`.)
-
-- A note that strategies are name-addressable (agents can't pass code), and how to
-  add custom strategies via `registerStrategy`.
-
-- [ ] **Step 2: Link from README**
-
-Add a documentation-table row:
-
-```markdown
-| [MCP server](docs/mcp.md) | Run the research loop from any MCP-capable agent (Claude, Cursor) |
-```
-
-And add a short "## AI agents / MCP" section near the top pointing to `docs/mcp.md`.
-
-- [ ] **Step 3: Build, lint, test, commit**
-
-```bash
-npm run build && npm run lint && npm run format:check && npm test
-git add docs/mcp.md README.md
-git commit -m "docs: MCP server setup and agent research loop
-
-Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>"
-```
-
----
-
-## Self-review checklist
-
-- [ ] Agents never need to pass code — every tool is name + JSON params. ✔ (Task 1, 2)
-- [ ] Tool outputs are summaries; `replay` is explicitly excluded (asserted in test). ✔ (Task 2)
-- [ ] `mcpTools` handlers are pure async functions tested without a transport; `server.js` is a thin SDK adapter. ✔
-- [ ] Strategy names are consistent across registry, tools, tests, and docs (`ema-cross`, `rsi-reversion`, `donchian-breakout`, `buy-hold`). ✔
-- [ ] `run_backtest` surfaces `sharpeAnnualized` (depends on Plan 1 being merged; if Plan 1 is not yet done, the field is simply absent — the summary still works). ✔
-- [ ] New deps (`@modelcontextprotocol/sdk`, `zod`) are runtime `dependencies`, not `devDependencies`. ✔ (Task 3)