@timmeck/trading-brain 1.0.0

package/src/learning/calibrator.ts

@@ -0,0 +1,57 @@
+import type { CalibrationConfig } from '../types/config.types.js';
+
+/**
+ * Adaptive Calibration — dynamically adjust learning parameters based on data volume.
+ * Ported from tradingBrain.js calibrate() function.
+ */
+export function calibrate(current: CalibrationConfig, outcomeCount: number, synapseCount: number): CalibrationConfig {
+  const cal = { ...current };
+
+  if (outcomeCount < 20) {
+    // Very early: conservative, wide thresholds
+    cal.learningRate = 0.08;
+    cal.weakenPenalty = 0.8;
+    cal.patternMinSamples = 5;
+    cal.patternWilsonThreshold = 0.3;
+    cal.wilsonZ = 1.64; // 90% CI
+    cal.minActivationsForWeight = 2;
+    cal.minOutcomesForWeights = 3;
+  } else if (outcomeCount < 100) {
+    // Growing: moderate
+    cal.learningRate = 0.12;
+    cal.weakenPenalty = 0.75;
+    cal.patternMinSamples = 8;
+    cal.patternWilsonThreshold = 0.4;
+    cal.wilsonZ = 1.80;
+    cal.minActivationsForWeight = 3;
+    cal.minOutcomesForWeights = 5;
+  } else if (outcomeCount < 500) {
+    // Mature: standard
+    cal.learningRate = 0.15;
+    cal.weakenPenalty = 0.7;
+    cal.patternMinSamples = 10;
+    cal.patternWilsonThreshold = 0.5;
+    cal.wilsonZ = 1.96; // 95% CI
+    cal.minActivationsForWeight = 3;
+    cal.minOutcomesForWeights = 5;
+  } else {
+    // Large dataset: high confidence, fine-grained
+    cal.learningRate = 0.10;
+    cal.weakenPenalty = 0.75;
+    cal.patternMinSamples = 15;
+    cal.patternWilsonThreshold = 0.55;
+    cal.wilsonZ = 2.33; // 99% CI
+    cal.minActivationsForWeight = 5;
+    cal.minOutcomesForWeights = 8;
+    cal.patternExtractionInterval = 30;
+  }
+
+  // Adjust decay based on synapse density
+  if (synapseCount > 100) {
+    cal.decayHalfLifeDays = 10; // faster cleanup
+  } else if (synapseCount < 10) {
+    cal.decayHalfLifeDays = 21; // preserve early knowledge
+  }
+
+  return cal;
+}

package/src/learning/chain-detector.ts

@@ -0,0 +1,43 @@
+import type { TradeRecord } from '../db/repositories/trade.repository.js';
+
+export interface DetectedChain {
+  pair: string;
+  type: 'winning_streak' | 'losing_streak';
+  length: number;
+  fingerprints: string[];
+  total_profit: number;
+}
+
+/**
+ * Detect winning/losing streaks from recent trade outcomes.
+ * Ported from tradingBrain.js _detectChain().
+ *
+ * @param recentTrades - Last N trades (should be ~10)
+ * @param latestTrade - The most recent trade
+ * @param minLength - Minimum consecutive trades for a chain (default: 3)
+ */
+export function detectChain(
+  recentTrades: TradeRecord[],
+  latestTrade: TradeRecord,
+  minLength: number = 3,
+): DetectedChain | null {
+  if (recentTrades.length < minLength) return null;
+
+  const recent = recentTrades.slice(-5);
+  const samePair = recent.filter(o => o.pair === latestTrade.pair);
+  if (samePair.length < minLength) return null;
+
+  const lastThree = samePair.slice(-minLength);
+  const allLosses = lastThree.every(o => o.win === 0);
+  const allWins = lastThree.every(o => o.win === 1);
+
+  if (!allLosses && !allWins) return null;
+
+  return {
+    pair: latestTrade.pair,
+    type: allLosses ? 'losing_streak' : 'winning_streak',
+    length: lastThree.length,
+    fingerprints: lastThree.map(o => o.fingerprint),
+    total_profit: lastThree.reduce((s, o) => s + o.profit_pct, 0),
+  };
+}

package/src/learning/learning-engine.ts

@@ -0,0 +1,94 @@
+import type { TradeRepository } from '../db/repositories/trade.repository.js';
+import type { RuleRepository } from '../db/repositories/rule.repository.js';
+import type { ChainRepository } from '../db/repositories/chain.repository.js';
+import type { CalibrationRepository } from '../db/repositories/calibration.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { WeightedGraph } from '../graph/weighted-graph.js';
+import type { CalibrationConfig, LearningConfig } from '../types/config.types.js';
+import { extractPatterns } from './pattern-extractor.js';
+import { calibrate } from './calibrator.js';
+import { getLogger } from '../utils/logger.js';
+import { getEventBus } from '../utils/events.js';
+
+export class LearningEngine {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private lastPatternExtraction = 0;
+  private lastDecay = 0;
+  private logger = getLogger();
+
+  constructor(
+    private learningConfig: LearningConfig,
+    private cal: CalibrationConfig,
+    private tradeRepo: TradeRepository,
+    private ruleRepo: RuleRepository,
+    private chainRepo: ChainRepository,
+    private calRepo: CalibrationRepository,
+    private synapseManager: SynapseManager,
+    private graph: WeightedGraph,
+  ) {}
+
+  start(): void {
+    this.timer = setInterval(() => this.runCycle(), this.learningConfig.intervalMs);
+    this.logger.info(`Learning engine started (interval: ${this.learningConfig.intervalMs}ms)`);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  getCalibration(): CalibrationConfig {
+    return { ...this.cal };
+  }
+
+  runCycle(): void {
+    const bus = getEventBus();
+    const outcomeCount = this.tradeRepo.count();
+
+    // Pattern extraction
+    if (outcomeCount - this.lastPatternExtraction >= this.cal.patternExtractionInterval) {
+      const trades = this.tradeRepo.getAll();
+      const rules = extractPatterns(trades, this.cal);
+      if (rules.length > 0) {
+        this.ruleRepo.replaceAll(rules);
+        this.lastPatternExtraction = outcomeCount;
+        this.logger.info(`Extracted ${rules.length} rules from ${trades.length} trades`);
+        bus.emit('patterns:extracted', { ruleCount: rules.length });
+      }
+    }
+
+    // Recalibrate every 25 trades
+    if (outcomeCount > 0 && outcomeCount % 25 === 0) {
+      const newCal = calibrate(this.cal, outcomeCount, this.synapseManager.count());
+      this.cal = newCal;
+      this.synapseManager.updateCalibration(newCal);
+      this.calRepo.save(newCal);
+      this.logger.info(`Recalibrated — lr: ${newCal.learningRate}, z: ${newCal.wilsonZ}, halfLife: ${newCal.decayHalfLifeDays}d`);
+      bus.emit('calibration:updated', { outcomeCount, learningRate: newCal.learningRate });
+    }
+
+    // Daily decay
+    const now = Date.now();
+    const dayMs = 86400000;
+    if (now - this.lastDecay > dayMs) {
+      const halfLifeMs = this.cal.decayHalfLifeDays * dayMs;
+      const synDecayed = this.synapseManager.runDecay();
+      this.graph.decayEdges(halfLifeMs);
+      this.lastDecay = now;
+      this.logger.info(`Decay applied — ${synDecayed} synapses, ${this.graph.getEdgeCount()} edges`);
+      bus.emit('decay:applied', { synapseCount: synDecayed, edgeCount: this.graph.getEdgeCount() });
+    }
+
+    // Prune old chains
+    this.chainRepo.pruneOldest(this.learningConfig.maxChains);
+  }
+
+  /** Manual trigger for a full learning cycle */
+  runManual(): { rules: number; calibration: CalibrationConfig } {
+    this.runCycle();
+    const rules = this.ruleRepo.getAll();
+    return { rules: rules.length, calibration: this.getCalibration() };
+  }
+}

package/src/learning/pattern-extractor.ts

@@ -0,0 +1,53 @@
+import type { TradeRecord } from '../db/repositories/trade.repository.js';
+import { fingerprintSimilarity } from '../signals/fingerprint.js';
+import { wilsonScore } from '../signals/wilson-score.js';
+import type { CalibrationConfig } from '../types/config.types.js';
+
+export interface ExtractedRule {
+  pattern: string;
+  confidence: number;
+  sample_count: number;
+  win_rate: number;
+  avg_profit: number;
+}
+
+/**
+ * Extract trading rules from outcome data using fingerprint grouping + Wilson Score.
+ * Ported from tradingBrain.js _extractPatterns().
+ */
+export function extractPatterns(trades: TradeRecord[], cal: CalibrationConfig): ExtractedRule[] {
+  if (trades.length < cal.patternMinSamples) return [];
+
+  // Group by similar fingerprints (threshold: 0.7)
+  const groups: Record<string, TradeRecord[]> = {};
+  for (const trade of trades) {
+    let assigned = false;
+    for (const key of Object.keys(groups)) {
+      if (fingerprintSimilarity(trade.fingerprint, key) >= 0.7) {
+        groups[key]!.push(trade);
+        assigned = true;
+        break;
+      }
+    }
+    if (!assigned) {
+      groups[trade.fingerprint] = [trade];
+    }
+  }
+
+  const rules: ExtractedRule[] = [];
+  for (const [pattern, group] of Object.entries(groups)) {
+    if (group.length < cal.patternMinSamples) continue;
+
+    const wins = group.filter(o => o.win === 1).length;
+    const total = group.length;
+    const winRate = wins / total;
+    const confidence = wilsonScore(wins, total, cal.wilsonZ);
+
+    if (confidence > cal.patternWilsonThreshold) {
+      const avgProfit = group.reduce((s, o) => s + o.profit_pct, 0) / total;
+      rules.push({ pattern, confidence, sample_count: total, win_rate: winRate, avg_profit: avgProfit });
+    }
+  }
+
+  return rules.sort((a, b) => b.confidence - a.confidence);
+}

package/src/mcp/http-server.ts

@@ -0,0 +1,118 @@
+import http from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { getLogger } from '../utils/logger.js';
+import type { IpcRouter } from '../ipc/router.js';
+import { registerToolsDirect } from './tools.js';
+
+export class McpHttpServer {
+  private server: http.Server | null = null;
+  private transports = new Map<string, SSEServerTransport>();
+  private logger = getLogger();
+
+  constructor(
+    private port: number,
+    private router: IpcRouter,
+  ) {}
+
+  start(): void {
+    this.server = http.createServer((req, res) => {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+      if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+
+      const url = new URL(req.url ?? '/', `http://localhost:${this.port}`);
+
+      if (url.pathname === '/sse' && req.method === 'GET') { this.handleSSE(res); return; }
+      if (url.pathname === '/messages' && req.method === 'POST') { this.handleMessage(req, res, url); return; }
+
+      if (url.pathname === '/' && req.method === 'GET') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          name: 'trading-brain',
+          version: '1.0.0',
+          protocol: 'MCP',
+          transport: 'sse',
+          endpoints: { sse: '/sse', messages: '/messages' },
+          clients: this.transports.size,
+        }));
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not Found');
+    });
+
+    this.server.listen(this.port, () => {
+      this.logger.info(`MCP HTTP server (SSE) started on http://localhost:${this.port}`);
+    });
+  }
+
+  stop(): void {
+    for (const transport of this.transports.values()) {
+      try { transport.close?.(); } catch { /* ignore */ }
+    }
+    this.transports.clear();
+    this.server?.close();
+    this.server = null;
+    this.logger.info('MCP HTTP server stopped');
+  }
+
+  getClientCount(): number {
+    return this.transports.size;
+  }
+
+  private async handleSSE(res: http.ServerResponse): Promise<void> {
+    try {
+      const transport = new SSEServerTransport('/messages', res);
+      const sessionId = transport.sessionId ?? randomUUID();
+      this.transports.set(sessionId, transport);
+
+      const server = new McpServer({ name: 'trading-brain', version: '1.0.0' });
+      registerToolsDirect(server, this.router);
+
+      res.on('close', () => {
+        this.transports.delete(sessionId);
+        this.logger.debug(`MCP SSE client disconnected: ${sessionId}`);
+      });
+
+      await server.connect(transport);
+      this.logger.info(`MCP SSE client connected: ${sessionId}`);
+    } catch (err) {
+      this.logger.error('MCP SSE connection error:', err);
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Internal Server Error');
+      }
+    }
+  }
+
+  private async handleMessage(req: http.IncomingMessage, res: http.ServerResponse, url: URL): Promise<void> {
+    try {
+      const sessionId = url.searchParams.get('sessionId');
+      if (!sessionId) {
+        res.writeHead(400, { 'Content-Type': 'text/plain' });
+        res.end('Missing sessionId parameter');
+        return;
+      }
+
+      const transport = this.transports.get(sessionId);
+      if (!transport) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Session not found. Connect to /sse first.');
+        return;
+      }
+
+      await transport.handlePostMessage(req, res);
+    } catch (err) {
+      this.logger.error('MCP message error:', err);
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Internal Server Error');
+      }
+    }
+  }
+}

package/src/mcp/server.ts

@@ -0,0 +1,72 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { IpcClient } from '../ipc/client.js';
+import { getPipeName } from '../utils/paths.js';
+import { registerTools } from './tools.js';
+
+function spawnDaemon(): void {
+  const entryPoint = path.resolve(import.meta.dirname, '../index.js');
+  const child = spawn(process.execPath, [
+    '--import', 'tsx',
+    entryPoint, 'daemon',
+  ], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: path.resolve(import.meta.dirname, '../..'),
+  });
+  child.unref();
+  process.stderr.write(`Trading Brain: Auto-started daemon (PID: ${child.pid})\n`);
+}
+
+async function connectWithRetry(ipc: IpcClient, retries: number, delayMs: number): Promise<void> {
+  for (let i = 0; i < retries; i++) {
+    try {
+      await ipc.connect();
+      return;
+    } catch {
+      if (i < retries - 1) {
+        await new Promise(r => setTimeout(r, delayMs));
+      }
+    }
+  }
+  throw new Error('Could not connect to daemon after retries');
+}
+
+export async function startMcpServer(): Promise<void> {
+  const server = new McpServer({
+    name: 'trading-brain',
+    version: '1.0.0',
+  });
+
+  const ipc = new IpcClient(getPipeName());
+
+  try {
+    await ipc.connect();
+  } catch {
+    process.stderr.write('Trading Brain: Daemon not running, starting automatically...\n');
+    spawnDaemon();
+    try {
+      await connectWithRetry(ipc, 10, 500);
+    } catch {
+      process.stderr.write('Trading Brain: Could not connect to daemon after auto-start. Check logs.\n');
+      process.exit(1);
+    }
+  }
+
+  registerTools(server, ipc);
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  process.on('SIGINT', () => {
+    ipc.disconnect();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', () => {
+    ipc.disconnect();
+    process.exit(0);
+  });
+}

package/src/mcp/tools.ts

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { IpcClient } from '../ipc/client.js';
+import type { IpcRouter } from '../ipc/router.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyResult = any;
+type BrainCall = (method: string, params?: unknown) => Promise<unknown> | unknown;
+
+function textResult(data: unknown): { content: Array<{ type: 'text'; text: string }> } {
+  const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+  return { content: [{ type: 'text' as const, text }] };
+}
+
+/** Register tools using IPC client (for stdio MCP transport) */
+export function registerTools(server: McpServer, ipc: IpcClient): void {
+  registerToolsWithCaller(server, (method, params) => ipc.request(method, params));
+}
+
+/** Register tools using router directly (for HTTP MCP transport inside daemon) */
+export function registerToolsDirect(server: McpServer, router: IpcRouter): void {
+  registerToolsWithCaller(server, (method, params) => router.handle(method, params));
+}
+
+function registerToolsWithCaller(server: McpServer, call: BrainCall): void {
+
+  // 1. trading_record_outcome
+  server.tool(
+    'trading_record_outcome',
+    'Record a trade outcome. Main entry point for the learning loop — updates synapses, graph, chains, and triggers pattern extraction.',
+    {
+      pair: z.string().describe('Trading pair (e.g. BTC/USDT)'),
+      bot_type: z.string().describe('Bot type (e.g. DCA, Grid, SmartTrader)'),
+      profit_pct: z.number().describe('Profit percentage of the trade'),
+      win: z.boolean().describe('Whether the trade was profitable'),
+      rsi14: z.number().optional().describe('RSI-14 value at entry'),
+      macd: z.number().optional().describe('MACD value at entry'),
+      trend_score: z.number().optional().describe('Trend score at entry'),
+      volatility: z.number().optional().describe('Volatility at entry'),
+      regime: z.string().optional().describe('Market regime (e.g. bullish_trend, ranging)'),
+    },
+    async (params) => {
+      const result: AnyResult = await call('trade.recordOutcome', {
+        signals: { rsi14: params.rsi14, macd: params.macd, trendScore: params.trend_score, volatility: params.volatility },
+        regime: params.regime,
+        profitPct: params.profit_pct,
+        win: params.win,
+        botType: params.bot_type,
+        pair: params.pair,
+      });
+      return textResult(`Trade #${result.tradeId} recorded (${params.win ? 'WIN' : 'LOSS'}, ${params.profit_pct.toFixed(2)}%). Fingerprint: ${result.fingerprint}. Synapse weight: ${result.synapseWeight.toFixed(3)}`);
+    },
+  );
+
+  // 2. trading_signal_weights
+  server.tool(
+    'trading_signal_weights',
+    'Get brain-weighted signal strengths based on learned experience. Returns adjusted weights for each signal type.',
+    {
+      rsi14: z.number().optional().describe('RSI-14 value'),
+      macd: z.number().optional().describe('MACD value'),
+      trend_score: z.number().optional().describe('Trend score'),
+      volatility: z.number().optional().describe('Volatility'),
+      regime: z.string().optional().describe('Market regime'),
+    },
+    async (params) => {
+      const result = await call('signal.weights', {
+        signals: { rsi14: params.rsi14, macd: params.macd, trendScore: params.trend_score, volatility: params.volatility },
+        regime: params.regime,
+      });
+      return textResult(result);
+    },
+  );
+
+  // 3. trading_signal_confidence
+  server.tool(
+    'trading_signal_confidence',
+    'Get Wilson Score confidence for a signal pattern. Returns 0-1 confidence based on historical win rate.',
+    {
+      rsi14: z.number().optional().describe('RSI-14 value'),
+      macd: z.number().optional().describe('MACD value'),
+      trend_score: z.number().optional().describe('Trend score'),
+      volatility: z.number().optional().describe('Volatility'),
+      regime: z.string().optional().describe('Market regime'),
+    },
+    async (params) => {
+      const confidence = await call('signal.confidence', {
+        signals: { rsi14: params.rsi14, macd: params.macd, trendScore: params.trend_score, volatility: params.volatility },
+        regime: params.regime,
+      });
+      return textResult(`Confidence: ${((confidence as number) * 100).toFixed(1)}%`);
+    },
+  );
+
+  // 4. trading_dca_multiplier
+  server.tool(
+    'trading_dca_multiplier',
+    'Get brain-recommended DCA position size multiplier based on regime success history.',
+    {
+      regime: z.string().describe('Market regime'),
+      rsi: z.number().describe('Current RSI value'),
+      volatility: z.number().describe('Current volatility'),
+    },
+    async (params) => {
+      const result = await call('strategy.dcaMultiplier', params);
+      return textResult(result);
+    },
+  );
+
+  // 5. trading_grid_params
+  server.tool(
+    'trading_grid_params',
+    'Get brain-recommended grid spacing parameters based on volatility history.',
+    {
+      regime: z.string().describe('Market regime'),
+      volatility: z.number().describe('Current volatility'),
+      pair: z.string().describe('Trading pair'),
+    },
+    async (params) => {
+      const result = await call('strategy.gridParams', params);
+      return textResult(result);
+    },
+  );
+
+  // 6. trading_explore
+  server.tool(
+    'trading_explore',
+    'Explore the brain network using spreading activation. Find related nodes from a starting concept.',
+    {
+      query: z.string().describe('Node ID, label, or partial match to start exploration from'),
+    },
+    async (params) => {
+      const result = await call('synapse.explore', params);
+      return textResult(result);
+    },
+  );
+
+  // 7. trading_connections
+  server.tool(
+    'trading_connections',
+    'Find the shortest path between two nodes in the brain network.',
+    {
+      from: z.string().describe('Source node ID'),
+      to: z.string().describe('Target node ID'),
+    },
+    async (params) => {
+      const path = await call('synapse.findPath', params);
+      if (!path) return textResult('No path found between these nodes.');
+      return textResult(`Path: ${(path as string[]).join(' → ')}`);
+    },
+  );
+
+  // 8. trading_rules
+  server.tool(
+    'trading_rules',
+    'Get all learned trading rules with confidence scores and win rates.',
+    {},
+    async () => {
+      const rules = await call('rule.list', {});
+      return textResult(rules);
+    },
+  );
+
+  // 9. trading_insights
+  server.tool(
+    'trading_insights',
+    'Get research insights (trends, gaps, synergies, performance, regime shifts).',
+    {
+      type: z.string().optional().describe('Filter by type: trend, gap, synergy, performance, regime_shift'),
+      limit: z.number().optional().describe('Max results (default 20)'),
+    },
+    async (params) => {
+      const result = params.type
+        ? await call('insight.byType', params)
+        : await call('insight.list', params);
+      return textResult(result);
+    },
+  );
+
+  // 10. trading_chains
+  server.tool(
+    'trading_chains',
+    'Get detected trade chains (winning/losing streaks).',
+    {
+      pair: z.string().optional().describe('Filter by trading pair'),
+      limit: z.number().optional().describe('Max results (default 20)'),
+    },
+    async (params) => {
+      const result = params.pair
+        ? await call('chain.byPair', params)
+        : await call('chain.list', params);
+      return textResult(result);
+    },
+  );
+
+  // 11. trading_query
+  server.tool(
+    'trading_query',
+    'Search trades and signals by fingerprint, pair, or bot type.',
+    {
+      search: z.string().describe('Search query'),
+      limit: z.number().optional().describe('Max results (default 50)'),
+    },
+    async (params) => {
+      const result = await call('trade.query', params);
+      return textResult(result);
+    },
+  );
+
+  // 12. trading_status
+  server.tool(
+    'trading_status',
+    'Get brain stats: trades, synapses, graph size, rules, insights, calibration.',
+    {},
+    async () => {
+      const result = await call('analytics.summary', {});
+      return textResult(result);
+    },
+  );
+
+  // 13. trading_calibration
+  server.tool(
+    'trading_calibration',
+    'Get current adaptive calibration parameters (learning rate, Wilson Z, decay half-life, etc.).',
+    {},
+    async () => {
+      const result = await call('calibration.get', {});
+      return textResult(result);
+    },
+  );
+
+  // 14. trading_learn
+  server.tool(
+    'trading_learn',
+    'Manually trigger a learning cycle (pattern extraction, calibration, decay).',
+    {},
+    async () => {
+      const result = await call('learning.run', {});
+      return textResult(result);
+    },
+  );
+
+  // 15. trading_reset
+  server.tool(
+    'trading_reset',
+    'Reset all trading brain data (trades, synapses, graph, rules, insights, chains, calibration).',
+    {
+      confirm: z.boolean().describe('Must be true to confirm reset'),
+    },
+    async (params) => {
+      if (!params.confirm) return textResult('Reset cancelled. Pass confirm: true to proceed.');
+      const result = await call('reset', {});
+      return textResult(result);
+    },
+  );
+}