@timmeck/trading-brain 1.0.0

package/src/services/trade.service.ts

@@ -0,0 +1,139 @@
+import type { TradeRepository, TradeRecord } from '../db/repositories/trade.repository.js';
+import type { SignalRepository } from '../db/repositories/signal.repository.js';
+import type { ChainRepository } from '../db/repositories/chain.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 { fingerprint, decomposeFingerprint, type SignalInput } from '../signals/fingerprint.js';
+import { NODE_TYPES } from '../graph/weighted-graph.js';
+import { detectChain } from '../learning/chain-detector.js';
+import { getLogger } from '../utils/logger.js';
+import { getEventBus } from '../utils/events.js';
+
+export interface RecordOutcomeInput {
+  signals: SignalInput;
+  regime?: string;
+  profitPct: number;
+  win: boolean;
+  botType: string;
+  pair: string;
+}
+
+export class TradeService {
+  private recentTrades: TradeRecord[] = [];
+  private logger = getLogger();
+
+  constructor(
+    private tradeRepo: TradeRepository,
+    private signalRepo: SignalRepository,
+    private chainRepo: ChainRepository,
+    private synapseManager: SynapseManager,
+    private graph: WeightedGraph,
+    private cal: CalibrationConfig,
+    private learningConfig: LearningConfig,
+  ) {
+    // Seed recent trades for chain detection
+    this.recentTrades = this.tradeRepo.getRecent(10);
+  }
+
+  updateCalibration(cal: CalibrationConfig): void {
+    this.cal = cal;
+  }
+
+  recordOutcome(input: RecordOutcomeInput): { tradeId: number; fingerprint: string; synapseWeight: number } {
+    const bus = getEventBus();
+    const fp = fingerprint({ ...input.signals, regime: input.regime });
+
+    // 1. Store signal combo
+    this.signalRepo.create(fp, JSON.stringify(input.signals), input.regime);
+
+    // 2. Store trade
+    const tradeId = this.tradeRepo.create({
+      fingerprint: fp,
+      pair: input.pair,
+      bot_type: input.botType,
+      regime: input.regime,
+      profit_pct: input.profitPct,
+      win: input.win,
+      signals_json: JSON.stringify(input.signals),
+    });
+
+    // 3. Hebbian synapse update
+    const synapse = input.win
+      ? this.synapseManager.recordWin(fp, input.profitPct)
+      : this.synapseManager.recordLoss(fp, input.profitPct);
+
+    // 4. Update weighted graph
+    const graphNodes = decomposeFingerprint(fp, input.regime, input.pair, input.botType);
+    const outcomeNodeId = input.win ? 'outcome_win' : 'outcome_loss';
+
+    for (const gn of graphNodes) {
+      this.graph.addNode(gn.id, gn.type, gn.label);
+    }
+    this.graph.addNode(outcomeNodeId, NODE_TYPES.OUTCOME, input.win ? 'win' : 'loss');
+
+    const comboNodeId = `combo_${fp}`;
+    for (const gn of graphNodes) {
+      if (gn.id !== comboNodeId) {
+        this.graph.addEdge(gn.id, comboNodeId, 0.5);
+        if (input.win) {
+          this.graph.strengthenEdge(gn.id, comboNodeId, this.cal.learningRate);
+        } else {
+          this.graph.weakenEdge(gn.id, comboNodeId, this.cal.weakenPenalty);
+        }
+      }
+    }
+
+    this.graph.addEdge(comboNodeId, outcomeNodeId, 0.5);
+    if (input.win) {
+      this.graph.strengthenEdge(comboNodeId, outcomeNodeId, this.cal.learningRate);
+    } else {
+      this.graph.weakenEdge(comboNodeId, outcomeNodeId, this.cal.weakenPenalty);
+    }
+
+    // Cross-connect co-occurring signals (Hebbian)
+    for (let i = 0; i < graphNodes.length; i++) {
+      for (let j = i + 1; j < graphNodes.length; j++) {
+        if (graphNodes[i]!.id !== comboNodeId && graphNodes[j]!.id !== comboNodeId) {
+          this.graph.addEdge(graphNodes[i]!.id, graphNodes[j]!.id, 0.3);
+          if (input.win) {
+            this.graph.strengthenEdge(graphNodes[i]!.id, graphNodes[j]!.id, this.cal.learningRate * 0.5);
+          }
+        }
+      }
+    }
+
+    // 5. Chain detection
+    const trade = this.tradeRepo.getById(tradeId)!;
+    this.recentTrades.push(trade);
+    if (this.recentTrades.length > 10) this.recentTrades.shift();
+
+    const chain = detectChain(this.recentTrades, trade, this.learningConfig.chainMinLength);
+    if (chain) {
+      this.chainRepo.create(chain);
+      bus.emit('chain:detected', { pair: chain.pair, type: chain.type, length: chain.length });
+      this.logger.info(`Chain detected: ${chain.type} (${chain.length}x) on ${chain.pair}`);
+    }
+
+    bus.emit('trade:recorded', { tradeId, fingerprint: fp, win: input.win });
+    this.logger.info(`Recorded: ${fp} → ${input.win ? 'WIN' : 'LOSS'} (${input.profitPct.toFixed(2)}%) | weight: ${synapse.weight.toFixed(3)} | graph: ${this.graph.getNodeCount()}N/${this.graph.getEdgeCount()}E`);
+
+    return { tradeId, fingerprint: fp, synapseWeight: synapse.weight };
+  }
+
+  query(search: string, limit: number = 50): TradeRecord[] {
+    return this.tradeRepo.search(search, limit);
+  }
+
+  getRecent(limit: number = 10): TradeRecord[] {
+    return this.tradeRepo.getRecent(limit);
+  }
+
+  getByPair(pair: string): TradeRecord[] {
+    return this.tradeRepo.getByPair(pair);
+  }
+
+  count(): number {
+    return this.tradeRepo.count();
+  }
+}

package/src/signals/fingerprint.ts

@@ -0,0 +1,93 @@
+import { NODE_TYPES } from '../graph/weighted-graph.js';
+
+export interface SignalInput {
+  rsi14?: number;
+  macd?: number;
+  trendScore?: number;
+  volatility?: number;
+  regime?: string;
+}
+
+export interface DecomposedNode {
+  id: string;
+  type: string;
+  label: string;
+}
+
+export function classifyRSI(rsi: number): string {
+  if (rsi < 25) return 'extreme_oversold';
+  if (rsi < 30) return 'oversold';
+  if (rsi < 40) return 'low';
+  if (rsi > 75) return 'extreme_overbought';
+  if (rsi > 70) return 'overbought';
+  if (rsi > 60) return 'high';
+  return 'neutral';
+}
+
+export function classifyMACD(macd: number, trendScore: number): string {
+  if (macd > 0 && trendScore > 0) return 'bullish';
+  if (macd < 0 && trendScore < 0) return 'bearish';
+  return 'neutral';
+}
+
+export function classifyTrend(trendScore: number): string {
+  if (trendScore > 3) return 'strong_up';
+  if (trendScore > 1) return 'up';
+  if (trendScore < -3) return 'strong_down';
+  if (trendScore < -1) return 'down';
+  return 'flat';
+}
+
+export function classifyVolatility(volatility: number): string {
+  if (volatility > 80) return 'extreme';
+  if (volatility > 50) return 'high';
+  if (volatility > 30) return 'medium';
+  return 'low';
+}
+
+/**
+ * Create a signal fingerprint string from input signals.
+ * Format: rsi_class|macd_class|trend_class|vol_class[|regime]
+ */
+export function fingerprint(signals: SignalInput): string {
+  const parts = [
+    classifyRSI(signals.rsi14 ?? 50),
+    classifyMACD(signals.macd ?? 0, signals.trendScore ?? 0),
+    classifyTrend(signals.trendScore ?? 0),
+    classifyVolatility(signals.volatility ?? 30),
+  ];
+  if (signals.regime) parts.push(signals.regime);
+  return parts.join('|');
+}
+
+/**
+ * Compare two fingerprints for similarity (0-1).
+ */
+export function fingerprintSimilarity(fp1: string, fp2: string): number {
+  const parts1 = fp1.split('|');
+  const parts2 = fp2.split('|');
+  const maxLen = Math.max(parts1.length, parts2.length);
+  if (maxLen === 0) return 1;
+  let matches = 0;
+  for (let i = 0; i < maxLen; i++) {
+    if (parts1[i] === parts2[i]) matches++;
+  }
+  return matches / maxLen;
+}
+
+/**
+ * Decompose a fingerprint into individual graph node IDs for the weighted graph.
+ */
+export function decomposeFingerprint(fp: string, regime?: string, pair?: string, botType?: string): DecomposedNode[] {
+  const parts = fp.split('|');
+  const nodes: DecomposedNode[] = [];
+  if (parts[0]) nodes.push({ id: `sig_rsi_${parts[0]}`, type: NODE_TYPES.SIGNAL, label: parts[0] });
+  if (parts[1]) nodes.push({ id: `sig_macd_${parts[1]}`, type: NODE_TYPES.SIGNAL, label: parts[1] });
+  if (parts[2]) nodes.push({ id: `sig_trend_${parts[2]}`, type: NODE_TYPES.SIGNAL, label: parts[2] });
+  if (parts[3]) nodes.push({ id: `sig_vol_${parts[3]}`, type: NODE_TYPES.SIGNAL, label: parts[3] });
+  if (regime) nodes.push({ id: `regime_${regime}`, type: NODE_TYPES.REGIME, label: regime });
+  if (pair) nodes.push({ id: `pair_${pair}`, type: NODE_TYPES.PAIR, label: pair });
+  if (botType) nodes.push({ id: `bot_${botType}`, type: NODE_TYPES.BOT_TYPE, label: botType });
+  nodes.push({ id: `combo_${fp}`, type: NODE_TYPES.COMBO, label: fp });
+  return nodes;
+}

package/src/signals/wilson-score.ts

@@ -0,0 +1,17 @@
+/**
+ * Wilson Score lower bound — statistically sound confidence interval for win rates.
+ * Penalizes small sample sizes (wide confidence intervals).
+ *
+ * @param wins - Number of wins
+ * @param total - Total number of trades
+ * @param z - Z-score (1.64=90%, 1.80, 1.96=95%, 2.33=99%)
+ * @returns Lower bound of confidence interval (0-1)
+ */
+export function wilsonScore(wins: number, total: number, z: number = 1.96): number {
+  if (total === 0) return 0;
+  const p = wins / total;
+  const denominator = 1 + (z * z) / total;
+  const centre = p + (z * z) / (2 * total);
+  const spread = z * Math.sqrt((p * (1 - p) + (z * z) / (4 * total)) / total);
+  return Math.max(0, (centre - spread) / denominator);
+}

package/src/synapses/decay.ts

@@ -0,0 +1,19 @@
+import type { SynapseRecord } from '../db/repositories/synapse.repository.js';
+
+/**
+ * Apply temporal decay to a synapse.
+ * Formula: new_weight = max(0.01, weight * 0.5^(age/halfLifeMs))
+ */
+export function decaySynapse(synapse: Omit<SynapseRecord, 'created_at'>, halfLifeMs: number): boolean {
+  const now = Date.now();
+  const lastActivated = new Date(synapse.last_activated).getTime();
+  const age = now - lastActivated;
+
+  if (age > halfLifeMs) {
+    const periods = age / halfLifeMs;
+    const oldWeight = synapse.weight;
+    synapse.weight = Math.max(0.01, synapse.weight * Math.pow(0.5, periods));
+    return synapse.weight !== oldWeight;
+  }
+  return false;
+}

package/src/synapses/hebbian.ts

@@ -0,0 +1,23 @@
+import type { SynapseRecord } from '../db/repositories/synapse.repository.js';
+
+/**
+ * Hebbian strengthen — "neurons that fire together wire together"
+ * Asymptotic approach to 1.0: weight += (1 - weight) * learningRate
+ */
+export function strengthen(synapse: Omit<SynapseRecord, 'created_at'>, learningRate: number): void {
+  synapse.wins++;
+  synapse.activations++;
+  synapse.weight += (1.0 - synapse.weight) * learningRate;
+  synapse.last_activated = new Date().toISOString();
+}
+
+/**
+ * Hebbian weaken — multiplicative decay on loss
+ * weight *= weakenPenalty (e.g. 0.7)
+ */
+export function weaken(synapse: Omit<SynapseRecord, 'created_at'>, weakenPenalty: number): void {
+  synapse.losses++;
+  synapse.activations++;
+  synapse.weight *= weakenPenalty;
+  synapse.last_activated = new Date().toISOString();
+}

package/src/synapses/synapse-manager.ts

@@ -0,0 +1,112 @@
+import type { SynapseRepository, SynapseRecord } from '../db/repositories/synapse.repository.js';
+import type { CalibrationConfig } from '../types/config.types.js';
+import { strengthen, weaken } from './hebbian.js';
+import { decaySynapse } from './decay.js';
+import { getLogger } from '../utils/logger.js';
+
+export class SynapseManager {
+  private cache: Map<string, Omit<SynapseRecord, 'created_at'>> = new Map();
+  private logger = getLogger();
+
+  constructor(
+    private repo: SynapseRepository,
+    private cal: CalibrationConfig,
+  ) {
+    this.loadCache();
+  }
+
+  private loadCache(): void {
+    const all = this.repo.getAll();
+    for (const syn of all) {
+      this.cache.set(syn.id, syn);
+    }
+    this.logger.info(`Synapse cache loaded: ${this.cache.size} synapses`);
+  }
+
+  updateCalibration(cal: CalibrationConfig): void {
+    this.cal = cal;
+  }
+
+  getOrCreate(fingerprint: string): Omit<SynapseRecord, 'created_at'> {
+    const id = `syn_${fingerprint}`;
+    let synapse = this.cache.get(id);
+    if (!synapse) {
+      synapse = {
+        id,
+        fingerprint,
+        weight: 0.5,
+        wins: 0,
+        losses: 0,
+        activations: 0,
+        total_profit: 0,
+        last_activated: new Date().toISOString(),
+      };
+      this.cache.set(id, synapse);
+    }
+    return synapse;
+  }
+
+  get(id: string): Omit<SynapseRecord, 'created_at'> | undefined {
+    return this.cache.get(id);
+  }
+
+  getByFingerprint(fingerprint: string): Omit<SynapseRecord, 'created_at'> | undefined {
+    return this.cache.get(`syn_${fingerprint}`);
+  }
+
+  recordWin(fingerprint: string, profitPct: number): Omit<SynapseRecord, 'created_at'> {
+    const synapse = this.getOrCreate(fingerprint);
+    synapse.total_profit += profitPct;
+    strengthen(synapse, this.cal.learningRate);
+    this.repo.upsert(synapse);
+    return synapse;
+  }
+
+  recordLoss(fingerprint: string, profitPct: number): Omit<SynapseRecord, 'created_at'> {
+    const synapse = this.getOrCreate(fingerprint);
+    synapse.total_profit += profitPct;
+    weaken(synapse, this.cal.weakenPenalty);
+    this.repo.upsert(synapse);
+    return synapse;
+  }
+
+  runDecay(): number {
+    const halfLifeMs = this.cal.decayHalfLifeDays * 86400000;
+    let decayed = 0;
+    for (const synapse of this.cache.values()) {
+      if (decaySynapse(synapse, halfLifeMs)) {
+        this.repo.upsert(synapse);
+        decayed++;
+      }
+    }
+    if (decayed > 0) {
+      this.logger.info(`Decayed ${decayed} synapses`);
+    }
+    return decayed;
+  }
+
+  getAll(): Omit<SynapseRecord, 'created_at'>[] {
+    return Array.from(this.cache.values());
+  }
+
+  count(): number {
+    return this.cache.size;
+  }
+
+  getStrongest(limit: number = 20): Omit<SynapseRecord, 'created_at'>[] {
+    return Array.from(this.cache.values())
+      .sort((a, b) => b.weight - a.weight)
+      .slice(0, limit);
+  }
+
+  getAvgWeight(): number {
+    if (this.cache.size === 0) return 0;
+    let sum = 0;
+    for (const syn of this.cache.values()) sum += syn.weight;
+    return sum / this.cache.size;
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+}

package/src/trading-core.ts

@@ -0,0 +1,285 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import type Database from 'better-sqlite3';
+import { loadConfig } from './config.js';
+import type { TradingBrainConfig } from './types/config.types.js';
+import { createLogger, getLogger } from './utils/logger.js';
+import { getEventBus } from './utils/events.js';
+import { createConnection } from './db/connection.js';
+import { runMigrations } from './db/migrations/index.js';
+
+// Repositories
+import { TradeRepository } from './db/repositories/trade.repository.js';
+import { SignalRepository } from './db/repositories/signal.repository.js';
+import { SynapseRepository } from './db/repositories/synapse.repository.js';
+import { GraphRepository } from './db/repositories/graph.repository.js';
+import { RuleRepository } from './db/repositories/rule.repository.js';
+import { ChainRepository } from './db/repositories/chain.repository.js';
+import { InsightRepository } from './db/repositories/insight.repository.js';
+import { CalibrationRepository } from './db/repositories/calibration.repository.js';
+
+// Graph
+import { WeightedGraph } from './graph/weighted-graph.js';
+
+// Synapses
+import { SynapseManager } from './synapses/synapse-manager.js';
+
+// Services
+import { TradeService } from './services/trade.service.js';
+import { SignalService } from './services/signal.service.js';
+import { StrategyService } from './services/strategy.service.js';
+import { SynapseService } from './services/synapse.service.js';
+import { AnalyticsService } from './services/analytics.service.js';
+import { InsightService } from './services/insight.service.js';
+
+// Engines
+import { LearningEngine } from './learning/learning-engine.js';
+import { ResearchEngine } from './research/research-engine.js';
+
+// IPC
+import { IpcRouter, type Services } from './ipc/router.js';
+import { IpcServer } from './ipc/server.js';
+
+// API & MCP HTTP
+import { ApiServer } from './api/server.js';
+import { McpHttpServer } from './mcp/http-server.js';
+
+export class TradingCore {
+  private db: Database.Database | null = null;
+  private ipcServer: IpcServer | null = null;
+  private apiServer: ApiServer | null = null;
+  private mcpHttpServer: McpHttpServer | null = null;
+  private learningEngine: LearningEngine | null = null;
+  private researchEngine: ResearchEngine | null = null;
+  private config: TradingBrainConfig | null = null;
+  private configPath?: string;
+  private restarting = false;
+
+  start(configPath?: string): void {
+    this.configPath = configPath;
+
+    // 1. Config
+    this.config = loadConfig(configPath);
+    const config = this.config;
+
+    // 2. Ensure data dir
+    fs.mkdirSync(path.dirname(config.dbPath), { recursive: true });
+
+    // 3. Logger
+    createLogger({
+      level: config.log.level,
+      file: config.log.file,
+      maxSize: config.log.maxSize,
+      maxFiles: config.log.maxFiles,
+    });
+    const logger = getLogger();
+
+    // 4. Database
+    this.db = createConnection(config.dbPath);
+    runMigrations(this.db);
+    logger.info(`Database initialized: ${config.dbPath}`);
+
+    // 5. Repositories
+    const tradeRepo = new TradeRepository(this.db);
+    const signalRepo = new SignalRepository(this.db);
+    const synapseRepo = new SynapseRepository(this.db);
+    const graphRepo = new GraphRepository(this.db);
+    const ruleRepo = new RuleRepository(this.db);
+    const chainRepo = new ChainRepository(this.db);
+    const insightRepo = new InsightRepository(this.db);
+    const calibrationRepo = new CalibrationRepository(this.db);
+
+    // 6. Synapse Manager
+    const synapseManager = new SynapseManager(synapseRepo, config.calibration);
+
+    // 7. Weighted Graph (load from DB)
+    const graph = new WeightedGraph();
+    const graphNodes = graphRepo.getAllNodes();
+    for (const node of graphNodes) {
+      graph.addNode(node.id, node.type, node.label);
+    }
+    const graphEdges = graphRepo.getAllEdges();
+    for (const edge of graphEdges) {
+      graph.addEdge(edge.source, edge.target, edge.weight);
+    }
+    logger.info(`Graph loaded: ${graphNodes.length} nodes, ${graphEdges.length} edges`);
+
+    // 8. Calibration (load current or use defaults)
+    const cal = calibrationRepo.get() ?? config.calibration;
+    const tradeCount = () => tradeRepo.count();
+
+    // 9. Services
+    const services: Services = {
+      trade: new TradeService(tradeRepo, signalRepo, chainRepo, synapseManager, graph, cal, config.learning),
+      signal: new SignalService(synapseManager, graph, cal, tradeCount),
+      strategy: new StrategyService(synapseManager, graph, cal, tradeCount),
+      synapse: new SynapseService(synapseManager, graph),
+      analytics: new AnalyticsService(tradeRepo, ruleRepo, chainRepo, insightRepo, synapseManager, graph),
+      insight: new InsightService(insightRepo),
+      ruleRepo,
+      chainRepo,
+      calRepo: calibrationRepo,
+    };
+
+    // 10. Learning Engine
+    this.learningEngine = new LearningEngine(
+      config.learning,
+      cal,
+      tradeRepo,
+      ruleRepo,
+      chainRepo,
+      calibrationRepo,
+      synapseManager,
+      graph,
+    );
+    this.learningEngine.start();
+    logger.info(`Learning engine started (interval: ${config.learning.intervalMs}ms)`);
+
+    // 11. Research Engine
+    this.researchEngine = new ResearchEngine(
+      config.research,
+      tradeRepo,
+      insightRepo,
+    );
+    this.researchEngine.start();
+    logger.info(`Research engine started (interval: ${config.research.intervalMs}ms)`);
+
+    // Expose engines to IPC
+    services.learning = this.learningEngine;
+    services.research = this.researchEngine;
+
+    // 12. IPC Server
+    const router = new IpcRouter(services);
+    this.ipcServer = new IpcServer(router, config.ipc.pipeName);
+    this.ipcServer.start();
+
+    // 13. REST API Server
+    if (config.api.enabled) {
+      this.apiServer = new ApiServer({
+        port: config.api.port,
+        router,
+        apiKey: config.api.apiKey,
+      });
+      this.apiServer.start();
+      logger.info(`REST API enabled on port ${config.api.port}`);
+    }
+
+    // 14. MCP HTTP Server (SSE transport for Cursor, Windsurf, Cline, Continue)
+    if (config.mcpHttp.enabled) {
+      this.mcpHttpServer = new McpHttpServer(config.mcpHttp.port, router);
+      this.mcpHttpServer.start();
+      logger.info(`MCP HTTP (SSE) enabled on port ${config.mcpHttp.port}`);
+    }
+
+    // 15. Event listeners (synapse wiring)
+    this.setupEventListeners(synapseManager);
+
+    // 16. PID file
+    const pidPath = path.join(path.dirname(config.dbPath), 'trading-brain.pid');
+    fs.writeFileSync(pidPath, String(process.pid));
+
+    // 17. Graceful shutdown
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+
+    // 18. Crash recovery
+    process.on('uncaughtException', (err) => {
+      logger.error('Uncaught exception — restarting', { error: err.message, stack: err.stack });
+      this.logCrash('uncaughtException', err);
+      this.restart();
+    });
+    process.on('unhandledRejection', (reason) => {
+      logger.error('Unhandled rejection — restarting', { reason: String(reason) });
+      this.logCrash('unhandledRejection', reason instanceof Error ? reason : new Error(String(reason)));
+      this.restart();
+    });
+
+    logger.info(`Trading Brain daemon started (PID: ${process.pid})`);
+  }
+
+  private logCrash(type: string, err: Error): void {
+    if (!this.config) return;
+    const crashLog = path.join(path.dirname(this.config.dbPath), 'crashes.log');
+    const entry = `[${new Date().toISOString()}] ${type}: ${err.message}\n${err.stack ?? ''}\n\n`;
+    try { fs.appendFileSync(crashLog, entry); } catch { /* best effort */ }
+  }
+
+  private cleanup(): void {
+    this.researchEngine?.stop();
+    this.learningEngine?.stop();
+    this.mcpHttpServer?.stop();
+    this.apiServer?.stop();
+    this.ipcServer?.stop();
+    this.db?.close();
+
+    this.db = null;
+    this.ipcServer = null;
+    this.apiServer = null;
+    this.mcpHttpServer = null;
+    this.learningEngine = null;
+    this.researchEngine = null;
+  }
+
+  restart(): void {
+    if (this.restarting) return;
+    this.restarting = true;
+
+    const logger = getLogger();
+    logger.info('Restarting Trading Brain daemon...');
+
+    try { this.cleanup(); } catch { /* best effort cleanup */ }
+
+    this.restarting = false;
+    this.start(this.configPath);
+  }
+
+  stop(): void {
+    const logger = getLogger();
+    logger.info('Shutting down...');
+
+    this.cleanup();
+
+    // Remove PID file
+    if (this.config) {
+      const pidPath = path.join(path.dirname(this.config.dbPath), 'trading-brain.pid');
+      try { fs.unlinkSync(pidPath); } catch { /* ignore */ }
+    }
+
+    logger.info('Trading Brain daemon stopped');
+    process.exit(0);
+  }
+
+  private setupEventListeners(_synapseManager: SynapseManager): void {
+    const bus = getEventBus();
+
+    // Trade recorded → log
+    bus.on('trade:recorded', ({ tradeId, fingerprint, win }) => {
+      getLogger().info(`Trade #${tradeId} recorded: ${fingerprint} (${win ? 'WIN' : 'LOSS'})`);
+    });
+
+    // Synapse updated → log at debug level
+    bus.on('synapse:updated', ({ synapseId }) => {
+      getLogger().debug(`Synapse updated: ${synapseId}`);
+    });
+
+    // Rule learned → log
+    bus.on('rule:learned', ({ ruleId, pattern }) => {
+      getLogger().info(`New rule #${ruleId} learned: ${pattern}`);
+    });
+
+    // Chain detected → log
+    bus.on('chain:detected', ({ pair, type, length }) => {
+      getLogger().info(`Chain: ${pair} ${type} streak (${length})`);
+    });
+
+    // Insight created → log
+    bus.on('insight:created', ({ insightId, type }) => {
+      getLogger().info(`New insight #${insightId} (${type})`);
+    });
+
+    // Calibration updated → log
+    bus.on('calibration:updated', ({ outcomeCount }) => {
+      getLogger().info(`Calibration updated (${outcomeCount} outcomes)`);
+    });
+  }
+}