clodds 1.1.0

package/dist/gateway/index.js

@@ -0,0 +1,2321 @@
+"use strict";
+/**
+ * Gateway Module - Clawdbot-style WebSocket gateway protocol
+ *
+ * Features:
+ * - WebSocket server for remote connections
+ * - Binary and JSON message support
+ * - Connection authentication
+ * - Heartbeat/keepalive
+ * - Message routing
+ * - Session management
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayServer = exports.GatewayOpcodes = void 0;
+exports.createGatewayServer = createGatewayServer;
+exports.createGateway = createGateway;
+const ws_1 = require("ws");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+const logger_1 = require("../utils/logger");
+const security_1 = require("../security");
+const server_1 = require("./server");
+const x402_1 = require("../payments/x402");
+const db_1 = require("../db");
+const migrations_1 = require("../db/migrations");
+const acp_1 = require("../acp");
+const order_persistence_1 = require("../execution/order-persistence");
+const dca_persistence_1 = require("../execution/dca-persistence");
+const feeds_1 = require("../feeds");
+const sessions_1 = require("../sessions");
+const agents_1 = require("../agents");
+const channels_1 = require("../channels");
+const pairing_1 = require("../pairing");
+const memory_1 = require("../memory");
+const cron_1 = require("../cron");
+const credentials_1 = require("../credentials");
+const registry_1 = require("../commands/registry");
+const automation_1 = require("../automation");
+const webhooks_1 = require("../tools/webhooks");
+const providers_1 = require("../providers");
+const monitoring_1 = require("../monitoring");
+const embeddings_1 = require("../embeddings");
+const market_index_1 = require("../market-index");
+const opportunity_1 = require("../opportunity");
+const whale_tracker_1 = require("../feeds/polymarket/whale-tracker");
+const copy_trading_1 = require("../trading/copy-trading");
+const smart_router_1 = require("../execution/smart-router");
+const execution_1 = require("../execution");
+const alerts_1 = require("../alerts");
+const executor_1 = require("../opportunity/executor");
+const tick_recorder_1 = require("../services/tick-recorder");
+const tick_streamer_1 = require("../services/tick-streamer");
+const bittensor_1 = require("../bittensor");
+const server_2 = require("../bittensor/server");
+const bittensor_2 = require("../agents/handlers/bittensor");
+const feature_engineering_1 = require("../services/feature-engineering");
+const alt_data_1 = require("../services/alt-data");
+const signal_router_1 = require("../signal-router");
+const ml_pipeline_1 = require("../ml-pipeline");
+const jobs_1 = require("../queue/jobs");
+const chokidar_1 = __importDefault(require("chokidar"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../utils/config");
+const http_1 = require("../utils/http");
+const unified_1 = require("../messages/unified");
+const production_1 = require("../utils/production");
+const signal_bus_1 = require("./signal-bus");
+const orchestrator_1 = require("../trading/orchestrator");
+const safety_1 = require("../trading/safety");
+const circuit_breaker_1 = require("../execution/circuit-breaker");
+const api_routes_1 = require("./api-routes");
+const position_manager_1 = require("../execution/position-manager");
+const position_bridge_1 = require("../trading/position-bridge");
+const backtest_1 = require("../trading/backtest");
+const bots_1 = require("../trading/bots");
+const builder_1 = require("../trading/builder");
+const logger_2 = require("../trading/logger");
+const market_making_1 = require("../trading/market-making");
+exports.GatewayOpcodes = {
+    DISPATCH: 0,
+    HEARTBEAT: 1,
+    IDENTIFY: 2,
+    RESUME: 3,
+    RECONNECT: 7,
+    INVALID_SESSION: 9,
+    HELLO: 10,
+    HEARTBEAT_ACK: 11,
+};
+// =============================================================================
+// GATEWAY SERVER
+// =============================================================================
+class GatewayServer extends events_1.EventEmitter {
+    config;
+    server = null;
+    wss = null;
+    clients = new Map();
+    heartbeatChecker = null;
+    sequence = 0;
+    constructor(config = {}) {
+        super();
+        this.config = {
+            port: config.port ?? 8080,
+            host: config.host ?? '0.0.0.0',
+            path: config.path ?? '/gateway',
+            heartbeatInterval: config.heartbeatInterval ?? 45000,
+            maxClients: config.maxClients ?? 1000,
+            auth: config.auth ?? { type: 'none' },
+            ...config,
+        };
+    }
+    /** Start the gateway server */
+    async start() {
+        return new Promise((resolve) => {
+            // Create HTTP(S) server
+            if (this.config.ssl) {
+                const fs = require('fs');
+                this.server = https.createServer({
+                    cert: fs.readFileSync(this.config.ssl.cert),
+                    key: fs.readFileSync(this.config.ssl.key),
+                });
+            }
+            else {
+                this.server = http.createServer();
+            }
+            // Create WebSocket server
+            this.wss = new ws_1.WebSocketServer({
+                server: this.server,
+                path: this.config.path,
+            });
+            this.wss.on('connection', (socket, request) => {
+                this.handleConnection(socket, request);
+            });
+            // Start heartbeat checker
+            this.heartbeatChecker = setInterval(() => {
+                this.checkHeartbeats();
+            }, this.config.heartbeatInterval);
+            // Start listening
+            this.server.listen(this.config.port, this.config.host, () => {
+                const protocol = this.config.ssl ? 'wss' : 'ws';
+                logger_1.logger.info({
+                    url: `${protocol}://${this.config.host}:${this.config.port}${this.config.path}`,
+                }, 'Gateway server started');
+                resolve();
+            });
+        });
+    }
+    /** Stop the gateway server */
+    async stop() {
+        if (this.heartbeatChecker) {
+            clearInterval(this.heartbeatChecker);
+            this.heartbeatChecker = null;
+        }
+        for (const client of this.clients.values()) {
+            this.send(client, { op: exports.GatewayOpcodes.RECONNECT });
+            client.socket.close(1001, 'Server shutting down');
+        }
+        this.clients.clear();
+        return new Promise((resolve) => {
+            if (this.wss) {
+                this.wss.close(() => {
+                    if (this.server) {
+                        this.server.close(() => {
+                            logger_1.logger.info('Gateway server stopped');
+                            resolve();
+                        });
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /** Send message to a client */
+    send(client, message) {
+        if (client.socket.readyState === ws_1.WebSocket.OPEN) {
+            client.socket.send(JSON.stringify(message));
+        }
+    }
+    /** Broadcast to all authenticated clients */
+    broadcast(message, filter) {
+        for (const client of this.clients.values()) {
+            if (client.authenticated && (!filter || filter(client))) {
+                this.send(client, message);
+            }
+        }
+    }
+    /** Dispatch an event to all clients */
+    dispatch(event, data) {
+        this.sequence++;
+        this.broadcast({
+            op: exports.GatewayOpcodes.DISPATCH,
+            t: event,
+            d: data,
+            s: this.sequence,
+        });
+    }
+    /** Get connected clients */
+    getClients() {
+        return Array.from(this.clients.values());
+    }
+    /** Get client by ID */
+    getClient(id) {
+        return this.clients.get(id);
+    }
+    /** Disconnect a client */
+    disconnect(id, code = 1000, reason = '') {
+        const client = this.clients.get(id);
+        if (client) {
+            client.socket.close(code, reason);
+            this.clients.delete(id);
+        }
+    }
+    handleConnection(socket, request) {
+        if (this.clients.size >= this.config.maxClients) {
+            socket.close(1013, 'Server at capacity');
+            return;
+        }
+        const clientId = this.generateClientId();
+        const client = {
+            id: clientId,
+            socket,
+            authenticated: this.config.auth?.type === 'none',
+            metadata: {},
+            connectedAt: new Date(),
+            lastHeartbeat: new Date(),
+        };
+        this.clients.set(clientId, client);
+        logger_1.logger.debug({ clientId }, 'Gateway client connected');
+        this.send(client, {
+            op: exports.GatewayOpcodes.HELLO,
+            d: {
+                heartbeat_interval: this.config.heartbeatInterval,
+                session_id: clientId,
+            },
+        });
+        socket.on('message', (data) => {
+            this.handleMessage(client, data);
+        });
+        socket.on('close', (code, reason) => {
+            this.clients.delete(clientId);
+            this.emit('disconnect', { clientId, code, reason: reason.toString() });
+            logger_1.logger.debug({ clientId, code }, 'Gateway client disconnected');
+        });
+        socket.on('error', (error) => {
+            logger_1.logger.error({ clientId, error }, 'Gateway client error');
+        });
+        this.emit('connection', client);
+    }
+    handleMessage(client, data) {
+        try {
+            const message = JSON.parse(data.toString());
+            switch (message.op) {
+                case exports.GatewayOpcodes.HEARTBEAT:
+                    client.lastHeartbeat = new Date();
+                    this.send(client, { op: exports.GatewayOpcodes.HEARTBEAT_ACK });
+                    break;
+                case exports.GatewayOpcodes.IDENTIFY:
+                    this.handleIdentify(client, message.d);
+                    break;
+                case exports.GatewayOpcodes.RESUME:
+                    client.authenticated = true;
+                    this.emit('resume', { client, data: message.d });
+                    break;
+                case exports.GatewayOpcodes.DISPATCH:
+                    if (client.authenticated) {
+                        this.emit('message', {
+                            client,
+                            event: message.t,
+                            data: message.d,
+                        });
+                    }
+                    break;
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn({ clientId: client.id, error }, 'Invalid gateway message');
+        }
+    }
+    handleIdentify(client, data = {}) {
+        let authenticated = false;
+        switch (this.config.auth?.type) {
+            case 'none':
+                authenticated = true;
+                break;
+            case 'token':
+                authenticated = this.config.auth.tokens?.includes(data.token || '') ?? false;
+                break;
+            case 'basic':
+                if (data.username && data.password) {
+                    authenticated = this.config.auth.users?.[data.username] === data.password;
+                }
+                break;
+        }
+        if (authenticated) {
+            client.authenticated = true;
+            client.metadata = { ...data, password: undefined };
+            this.emit('identify', client);
+            this.dispatch('READY', { session_id: client.id });
+        }
+        else {
+            this.send(client, { op: exports.GatewayOpcodes.INVALID_SESSION, d: false });
+            client.socket.close(4001, 'Authentication failed');
+        }
+    }
+    checkHeartbeats() {
+        const timeout = this.config.heartbeatInterval * 2;
+        const now = Date.now();
+        for (const [id, client] of this.clients) {
+            if (now - client.lastHeartbeat.getTime() > timeout) {
+                logger_1.logger.debug({ clientId: id }, 'Client heartbeat timeout');
+                client.socket.close(4009, 'Heartbeat timeout');
+                this.clients.delete(id);
+            }
+        }
+    }
+    generateClientId() {
+        return (0, crypto_1.randomBytes)(16).toString('hex');
+    }
+}
+exports.GatewayServer = GatewayServer;
+// =============================================================================
+// FACTORY
+// =============================================================================
+function createGatewayServer(config) {
+    return new GatewayServer(config);
+}
+/**
+ * Create the full application gateway (HTTP + channels + agent).
+ *
+ * This wires together:
+ * - HTTP/WebSocket server (for webchat + health)
+ * - Channel manager (Telegram/Slack/etc)
+ * - Sessions, feeds, DB, memory
+ * - Command registry and command handling
+ * - Agent manager for non-command messages
+ */
+async function createGateway(config) {
+    let currentConfig = config;
+    (0, http_1.configureHttpClient)(currentConfig.http);
+    const configPath = process.env.CLODDS_CONFIG_PATH || config_1.CONFIG_FILE;
+    const db = await (0, db_1.initDatabase)();
+    try {
+        const runner = (0, migrations_1.createMigrationRunner)(db);
+        runner.migrate();
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Database migration failed');
+        throw error;
+    }
+    // Initialize ACP (Agent Commerce Protocol) with database
+    (0, acp_1.initACP)(db);
+    // Initialize order persistence for TWAP and bracket orders
+    (0, order_persistence_1.initOrderPersistence)(db);
+    (0, dca_persistence_1.initDCAPersistence)(db);
+    let feeds = await (0, feeds_1.createFeedManager)(config.feeds);
+    const sessions = (0, sessions_1.createSessionManager)(db, config.session);
+    const memory = (0, memory_1.createMemoryService)(db);
+    const pairing = (0, pairing_1.createPairingService)(db);
+    const webhookManager = (0, automation_1.createWebhookManager)();
+    const providerManager = (0, providers_1.createProviders)({
+        anthropicKey: process.env.ANTHROPIC_API_KEY,
+        openaiKey: process.env.OPENAI_API_KEY,
+        ollamaUrl: process.env.OLLAMA_URL,
+        groqKey: process.env.GROQ_API_KEY,
+        togetherKey: process.env.TOGETHER_API_KEY,
+        fireworksKey: process.env.FIREWORKS_API_KEY,
+        geminiKey: process.env.GEMINI_API_KEY,
+    });
+    const providerHealth = providerManager.list().length > 0
+        ? (0, providers_1.createProviderHealthMonitor)(providerManager)
+        : null;
+    let monitoring = null;
+    const commands = (0, registry_1.createCommandRegistry)();
+    commands.registerMany((0, registry_1.createDefaultCommands)());
+    const httpGateway = (0, server_1.createServer)({ ...config.gateway, x402: config.x402 }, webhookManager, db);
+    let channels = null;
+    const watchers = [];
+    let started = false;
+    let reloadInFlight = null;
+    let pendingReload = false;
+    let channelRateLimitCleanupInterval = null;
+    let positionPriceUpdateInterval = null;
+    let marketCacheCleanupInterval = null;
+    let marketIndexSyncInterval = null;
+    const channelRateLimiters = new Map();
+    const embeddings = (0, embeddings_1.createEmbeddingsService)(db);
+    const marketIndex = (0, market_index_1.createMarketIndexService)(db, embeddings, {
+        platformWeights: config.marketIndex?.platformWeights,
+    });
+    const cronCredentials = (0, credentials_1.createCredentialsManager)(db);
+    let cronService = null;
+    // Create opportunity finder for cross-platform arbitrage detection
+    const opportunityFinder = config.opportunityFinder?.enabled !== false
+        ? (0, opportunity_1.createOpportunityFinder)(db, feeds, embeddings, {
+            minEdge: config.opportunityFinder?.minEdge ?? 0.5,
+            minLiquidity: config.opportunityFinder?.minLiquidity ?? 100,
+            platforms: config.opportunityFinder?.platforms,
+            realtime: config.opportunityFinder?.realtime ?? false,
+            scanIntervalMs: config.opportunityFinder?.scanIntervalMs ?? 10000,
+            semanticMatching: config.opportunityFinder?.semanticMatching ?? true,
+            similarityThreshold: config.opportunityFinder?.similarityThreshold ?? 0.85,
+            includeInternal: config.opportunityFinder?.includeInternal ?? true,
+            includeCross: config.opportunityFinder?.includeCross ?? true,
+            includeEdge: config.opportunityFinder?.includeEdge ?? true,
+        })
+        : null;
+    // Create whale tracker for monitoring large trades
+    let whaleTracker = config.whaleTracking?.enabled
+        ? (0, whale_tracker_1.createWhaleTracker)({
+            minTradeSize: config.whaleTracking?.minTradeSize ?? 10000,
+            minPositionSize: config.whaleTracking?.minPositionSize ?? 50000,
+            enableRealtime: config.whaleTracking?.realtime ?? true,
+        })
+        : null;
+    // Create Bittensor mining service if enabled
+    let bittensorService = null;
+    if (config.bittensor?.enabled) {
+        const btConfig = {
+            enabled: true,
+            network: config.bittensor.network ?? 'mainnet',
+            subtensorUrl: config.bittensor.subtensorUrl,
+            coldkeyPath: config.bittensor.coldkeyPath,
+            coldkeyPassword: config.bittensor.coldkeyPassword,
+            pythonPath: config.bittensor.pythonPath,
+            subnets: config.bittensor.subnets,
+            earningsPollIntervalMs: config.bittensor.earningsPollIntervalMs,
+            taoPriceUsd: config.bittensor.taoPriceUsd,
+        };
+        bittensorService = (0, bittensor_1.createBittensorService)(btConfig, db);
+        (0, bittensor_2.setBittensorService)(bittensorService);
+        const bittensorRouter = (0, server_2.createBittensorRouter)(bittensorService);
+        httpGateway.setBittensorRouter(bittensorRouter);
+        logger_1.logger.info({ network: btConfig.network }, 'Bittensor service created');
+    }
+    // Create Percolator on-chain perps service if enabled
+    let percolatorService = null;
+    if (config.feeds?.percolator?.enabled) {
+        const { createPercolatorService } = await Promise.resolve().then(() => __importStar(require('../percolator/index.js')));
+        percolatorService = createPercolatorService(config.feeds.percolator);
+        // Wire Percolator HTTP API router
+        const { createPercolatorRouter } = await Promise.resolve().then(() => __importStar(require('./percolator-routes.js')));
+        httpGateway.setPercolatorRouter(createPercolatorRouter(percolatorService));
+        logger_1.logger.info({ slab: config.feeds.percolator.slabAddress }, 'Percolator service created');
+    }
+    // Wire Shield HTTP API router (always available — no credentials needed)
+    {
+        const { createShieldRouter } = await Promise.resolve().then(() => __importStar(require('./shield-routes.js')));
+        httpGateway.setShieldRouter(createShieldRouter());
+    }
+    // Wire Token Audit HTTP API router (always available — GoPlus is free)
+    {
+        const { createAuditRouter } = await Promise.resolve().then(() => __importStar(require('./audit-routes.js')));
+        httpGateway.setAuditRouter(createAuditRouter());
+    }
+    // Wire DCA HTTP API router (DCA persistence already initialized above)
+    {
+        const { createDCARouter } = await Promise.resolve().then(() => __importStar(require('./dca-routes.js')));
+        httpGateway.setDCARouter(createDCARouter());
+    }
+    // Create alt-data sentiment pipeline if enabled
+    let altDataService = null;
+    // Create execution service for real trading
+    let executionService = null;
+    if (config.trading?.enabled) {
+        const poly = config.trading.polymarket;
+        const kalshi = config.trading.kalshi;
+        const opinionCfg = config.trading.opinion;
+        const hasPolymarketCreds = poly?.address && poly?.apiKey && poly?.apiSecret && poly?.apiPassphrase;
+        const hasKalshiCreds = kalshi?.apiKeyId && kalshi?.privateKeyPem;
+        const hasOpinionCreds = opinionCfg?.apiKey && opinionCfg?.privateKey && opinionCfg?.vaultAddress;
+        const predictfunCfg = config.trading?.predictfun;
+        const hasPredictFunCreds = !!predictfunCfg?.privateKey;
+        if (hasPolymarketCreds || hasKalshiCreds || hasOpinionCreds || hasPredictFunCreds) {
+            executionService = (0, execution_1.createExecutionService)({
+                polymarket: hasPolymarketCreds ? {
+                    address: poly.address,
+                    apiKey: poly.apiKey,
+                    apiSecret: poly.apiSecret,
+                    apiPassphrase: poly.apiPassphrase,
+                    privateKey: poly.privateKey,
+                    funderAddress: poly?.funderAddress || poly.address,
+                    signatureType: poly?.signatureType,
+                } : undefined,
+                kalshi: hasKalshiCreds ? {
+                    apiKeyId: kalshi.apiKeyId,
+                    privateKeyPem: kalshi.privateKeyPem,
+                } : undefined,
+                opinion: hasOpinionCreds ? {
+                    apiKey: opinionCfg.apiKey,
+                    privateKey: opinionCfg.privateKey,
+                    multiSigAddress: opinionCfg.vaultAddress,
+                    rpcUrl: opinionCfg.rpcUrl,
+                } : undefined,
+                predictfun: hasPredictFunCreds ? {
+                    privateKey: predictfunCfg.privateKey,
+                    predictAccount: predictfunCfg.predictAccount,
+                    rpcUrl: predictfunCfg.rpcUrl,
+                    apiKey: predictfunCfg.apiKey,
+                } : undefined,
+                maxOrderSize: config.trading.maxOrderSize ?? 1000,
+                dryRun: config.trading.dryRun ?? false,
+            });
+            logger_1.logger.info({
+                dryRun: config.trading.dryRun ?? false,
+                polymarket: !!hasPolymarketCreds,
+                kalshi: !!hasKalshiCreds,
+                opinion: !!hasOpinionCreds,
+                predictfun: !!hasPredictFunCreds,
+            }, 'Execution service initialized');
+        }
+        else {
+            logger_1.logger.warn('Trading enabled but no platform credentials configured');
+        }
+    }
+    // Wire safety + circuit breaker + orchestrator around execution service.
+    // By reassigning executionService, all downstream consumers (signal router,
+    // copy trading, arbitrage executor) automatically get safety-checked execution.
+    let orchestrator = null;
+    let safetyManager = null;
+    if (executionService) {
+        // Circuit breaker: execution-level error rate + loss tracking
+        const circuitBreaker = (0, circuit_breaker_1.createCircuitBreaker)({
+            maxLossUsd: config.trading?.maxDailyLoss ?? 1000,
+            maxConsecutiveLosses: 5,
+            maxErrorRate: 0.5,
+            resetTimeoutMs: 3600_000,
+        });
+        executionService.setCircuitBreaker(circuitBreaker);
+        // Safety manager: daily loss limits, drawdown, concentration checks
+        safetyManager = (0, safety_1.createSafetyManager)(db, {
+            dailyLossLimit: config.trading?.maxDailyLoss ?? 500,
+            maxDrawdownPct: 20,
+            maxConcentrationPct: 25,
+            maxSameDirectionPositions: 5,
+        });
+        // Orchestrator wraps execution with pre-trade safety validation
+        orchestrator = (0, orchestrator_1.createTradingOrchestrator)({
+            execution: executionService,
+            safety: safetyManager,
+            db,
+        });
+        // Replace raw execution with guarded version for all downstream consumers
+        executionService = orchestrator.execution;
+        logger_1.logger.info('Trading orchestrator wired: safety manager + circuit breaker active');
+    }
+    // Position manager + bridge: automated TP/SL/trailing stop exits.
+    // executeClose callback is created first, then passed to the PM config,
+    // so triggers fire close orders through the (guarded) execution service.
+    let positionManager = null;
+    let positionBridge = null;
+    if (executionService) {
+        const executeClose = (0, position_bridge_1.createPositionCloseCallback)(executionService);
+        positionManager = (0, position_manager_1.createPositionManager)({ executeClose });
+        logger_1.logger.info('Position manager created with auto-close callback');
+    }
+    // Execution queue setup — reads from config.queue or env vars.
+    // Decouples gateway from execution: orders go through BullMQ.
+    // Only agent tool handlers use the queued wrapper; other services
+    // (copy trading, arbitrage executor) keep using the direct service
+    // since they need the full ExecutionService interface.
+    let executionProducer = null;
+    let queuedExecutionRef = null;
+    const queueRedisHost = config.queue?.redis?.host || process.env.REDIS_HOST;
+    const queueEnabled = config.queue?.enabled ?? !!queueRedisHost;
+    if (queueEnabled && queueRedisHost && executionService) {
+        try {
+            const queueRedisPort = config.queue?.redis?.port
+                ?? parseInt(process.env.REDIS_PORT || '6379', 10);
+            const queueRedisPassword = config.queue?.redis?.password
+                || process.env.REDIS_PASSWORD || undefined;
+            const queueTimeoutMs = config.queue?.timeoutMs
+                ?? parseInt(process.env.EXECUTION_QUEUE_TIMEOUT_MS || '30000', 10);
+            executionProducer = (0, jobs_1.createExecutionProducer)({
+                redis: {
+                    host: queueRedisHost,
+                    port: queueRedisPort,
+                    password: queueRedisPassword,
+                    maxRetriesPerRequest: null,
+                },
+                defaultTimeoutMs: queueTimeoutMs,
+            });
+            // Create queue-based wrapper for agent tool handlers only
+            queuedExecutionRef = (0, jobs_1.createQueuedExecutionService)(executionProducer);
+            logger_1.logger.info({ redisHost: queueRedisHost, redisPort: queueRedisPort }, 'Execution queue enabled - agent orders will be processed via BullMQ worker');
+        }
+        catch (error) {
+            logger_1.logger.warn({ error }, 'Failed to create execution queue producer - falling back to direct execution');
+        }
+    }
+    // Create copy trading service
+    let copyTrading = null;
+    if (config.copyTrading?.enabled && whaleTracker) {
+        copyTrading = (0, copy_trading_1.createCopyTradingService)(whaleTracker, executionService, {
+            followedAddresses: config.copyTrading?.followedAddresses ?? [],
+            sizingMode: config.copyTrading?.sizingMode ?? 'fixed',
+            fixedSize: config.copyTrading?.fixedSize ?? 100,
+            proportionMultiplier: config.copyTrading?.proportionalMultiplier ?? 0.1,
+            portfolioPercentage: config.copyTrading?.portfolioPercentage ?? 1,
+            maxPositionSize: config.copyTrading?.maxPositionSize ?? 500,
+            copyDelayMs: config.copyTrading?.copyDelayMs ?? 5000,
+            dryRun: executionService ? (config.copyTrading?.dryRun ?? false) : true,
+        });
+    }
+    // Create smart router for order routing
+    const smartRouter = config.smartRouting?.enabled !== false
+        ? (0, smart_router_1.createSmartRouter)(feeds, {
+            mode: config.smartRouting?.mode ?? 'balanced',
+            enabledPlatforms: config.smartRouting?.platforms ?? ['polymarket', 'kalshi'],
+            maxSlippage: config.smartRouting?.maxSlippage ?? 1,
+            preferMaker: config.smartRouting?.preferMaker ?? true,
+            allowSplitting: config.smartRouting?.allowSplitting ?? false,
+        })
+        : null;
+    // Wire TWAP + Bracket + Trigger order routers (require executionService)
+    if (executionService) {
+        const { createTwapRouter } = await Promise.resolve().then(() => __importStar(require('./twap-routes.js')));
+        httpGateway.setTwapRouter(createTwapRouter({ execution: executionService }));
+        const { createBracketRouter } = await Promise.resolve().then(() => __importStar(require('./bracket-routes.js')));
+        httpGateway.setBracketRouter(createBracketRouter({ execution: executionService }));
+        const { createTriggerOrderManager } = await Promise.resolve().then(() => __importStar(require('../execution/trigger-orders.js')));
+        const triggerManager = createTriggerOrderManager(executionService, feeds);
+        const { createTriggerRouter } = await Promise.resolve().then(() => __importStar(require('./trigger-routes.js')));
+        httpGateway.setTriggerRouter(createTriggerRouter({ manager: triggerManager }));
+        triggerManager.start();
+        logger_1.logger.info('TWAP, Bracket, Trigger order APIs wired');
+    }
+    // Wire Copy Trading router (requires copyTrading service)
+    if (copyTrading) {
+        const { createCopyTradingRouter } = await Promise.resolve().then(() => __importStar(require('./copy-trading-routes.js')));
+        httpGateway.setCopyTradingRouter(createCopyTradingRouter({ service: copyTrading }));
+        logger_1.logger.info('Copy Trading API wired');
+    }
+    // Wire Opportunity Finder router
+    if (opportunityFinder) {
+        const { createOpportunityRouter } = await Promise.resolve().then(() => __importStar(require('./opportunity-routes.js')));
+        httpGateway.setOpportunityRouter(createOpportunityRouter({ finder: opportunityFinder }));
+        logger_1.logger.info('Opportunity Finder API wired');
+    }
+    // Wire Whale Tracker router
+    if (whaleTracker) {
+        const { createWhaleRouter } = await Promise.resolve().then(() => __importStar(require('./whale-routes.js')));
+        httpGateway.setWhaleRouter(createWhaleRouter({ tracker: whaleTracker }));
+        logger_1.logger.info('Whale Tracker API wired');
+    }
+    // Wire Risk Engine router (requires safetyManager for risk context)
+    if (executionService && safetyManager) {
+        const { createRiskEngine } = await Promise.resolve().then(() => __importStar(require('../risk/engine.js')));
+        const riskContext = {
+            tradingContext: { maxOrderSize: config.trading?.maxOrderSize ?? 1000 },
+            db: {
+                getUser: (userId) => db.getUser(userId),
+                getPositions: (userId) => db.getPositions(userId),
+            },
+        };
+        const riskEngine = createRiskEngine({ initialBankroll: 10000 }, { riskContext, safetyManager });
+        const { createRiskRouter } = await Promise.resolve().then(() => __importStar(require('./risk-routes.js')));
+        httpGateway.setRiskRouter(createRiskRouter({ engine: riskEngine }));
+        logger_1.logger.info('Risk Engine API wired');
+    }
+    // Wire Smart Router API (requires smartRouter)
+    if (smartRouter) {
+        const { createRoutingRouter } = await Promise.resolve().then(() => __importStar(require('./routing-routes.js')));
+        httpGateway.setRoutingRouter(createRoutingRouter({ router: smartRouter }));
+        logger_1.logger.info('Smart Router API wired');
+    }
+    // Wire Feeds Manager API (always available)
+    {
+        const { createFeedsRouter } = await Promise.resolve().then(() => __importStar(require('./feeds-routes.js')));
+        httpGateway.setFeedsRouter(createFeedsRouter({ feeds: feeds }));
+        logger_1.logger.info('Feeds Manager API wired');
+    }
+    // Wire Monitoring API (providerHealth may be null)
+    {
+        const { createMonitoringRouter } = await Promise.resolve().then(() => __importStar(require('./monitoring-routes.js')));
+        httpGateway.setMonitoringRouter(createMonitoringRouter({ providerHealth }));
+        logger_1.logger.info('Monitoring API wired');
+    }
+    // Wire Alt Data API (lazy — altDataService created later in start())
+    {
+        const { createAltDataRouter } = await Promise.resolve().then(() => __importStar(require('./alt-data-routes.js')));
+        httpGateway.setAltDataRouter(createAltDataRouter({ getService: () => altDataService }));
+        logger_1.logger.info('Alt Data API wired');
+    }
+    // Wire Alerts API (lazy — alertService may not be instantiated)
+    {
+        const { createAlertsRouter } = await Promise.resolve().then(() => __importStar(require('./alerts-routes.js')));
+        httpGateway.setAlertsRouter(createAlertsRouter({ getService: () => null }));
+        logger_1.logger.info('Alerts API wired (service injected when available)');
+    }
+    // Wire Execution Queue API (requires Redis / executionProducer)
+    if (executionProducer) {
+        const { createQueueRouter } = await Promise.resolve().then(() => __importStar(require('./queue-routes.js')));
+        httpGateway.setQueueRouter(createQueueRouter({ producer: executionProducer }));
+        logger_1.logger.info('Execution Queue API wired');
+    }
+    // Wire Webhooks API
+    {
+        const { createWebhooksRouter } = await Promise.resolve().then(() => __importStar(require('./webhooks-routes.js')));
+        httpGateway.setWebhooksRouter(createWebhooksRouter({ manager: webhookManager }));
+        logger_1.logger.info('Webhooks API wired');
+    }
+    // Wire Payments/x402 API (lazy — x402Client created later)
+    {
+        const { createPaymentsRouter } = await Promise.resolve().then(() => __importStar(require('./payments-routes.js')));
+        httpGateway.setPaymentsRouter(createPaymentsRouter({ getClient: () => x402Client }));
+        logger_1.logger.info('Payments API wired');
+    }
+    // Wire Embeddings API (always available)
+    {
+        const { createEmbeddingsRouter } = await Promise.resolve().then(() => __importStar(require('./embeddings-routes.js')));
+        httpGateway.setEmbeddingsRouter(createEmbeddingsRouter({ embeddings }));
+        logger_1.logger.info('Embeddings API wired');
+    }
+    // Wire Cron Service API (lazy — cronService created in startCronService())
+    {
+        const { createCronRouter } = await Promise.resolve().then(() => __importStar(require('./cron-routes.js')));
+        httpGateway.setCronRouter(createCronRouter({ getService: () => cronService }));
+        logger_1.logger.info('Cron Service API wired');
+    }
+    // Realtime alerts service (created after sendMessage is defined)
+    let realtimeAlerts = null;
+    let whaleTrackerCleanup = null;
+    let opportunityFinderCleanup = null;
+    // Auto-arbitrage executor
+    let arbitrageExecutor = null;
+    // Signal router — routes signals to execution
+    let signalRouter = null;
+    // ML training pipeline — learn from signal outcomes
+    let mlPipeline = null;
+    // Tick recorder for historical data
+    let tickRecorder = null;
+    // Tick streamer for real-time WebSocket streaming
+    let tickStreamer = null;
+    // Feature engineering for computing trading indicators
+    let featureEngine = null;
+    // Bot manager — strategy lifecycle (start/stop/pause/resume)
+    let botManager = null;
+    // Trade logger — records fills and PnL
+    let tradeLogger = null;
+    // Strategy builder — template-based + NL strategy creation
+    let strategyBuilder = null;
+    const sendMessage = async (message) => {
+        if (!channels) {
+            logger_1.logger.warn({ platform: message.platform }, 'Channel manager not ready; dropping message');
+            return null;
+        }
+        return channels.send(message);
+    };
+    const editMessage = async (message) => {
+        if (!channels) {
+            logger_1.logger.warn({ platform: message.platform }, 'Channel manager not ready; dropping edit');
+            return;
+        }
+        await channels.edit(message);
+    };
+    const deleteMessage = async (message) => {
+        if (!channels) {
+            logger_1.logger.warn({ platform: message.platform }, 'Channel manager not ready; dropping delete');
+            return;
+        }
+        await channels.delete(message);
+    };
+    const reactMessage = async (message) => {
+        if (!channels) {
+            logger_1.logger.warn({ platform: message.platform }, 'Channel manager not ready; dropping reaction');
+            return;
+        }
+        await channels.react(message);
+    };
+    const createPoll = async (message) => {
+        if (!channels) {
+            logger_1.logger.warn({ platform: message.platform }, 'Channel manager not ready; dropping poll');
+            return null;
+        }
+        return channels.sendPoll(message);
+    };
+    // Initialize realtime alerts if enabled
+    if (config.realtimeAlerts?.enabled) {
+        realtimeAlerts = (0, alerts_1.createRealtimeAlertsService)(sendMessage, {
+            enabled: true,
+            targets: config.realtimeAlerts.targets?.map(t => ({
+                platform: t.platform,
+                chatId: t.chatId,
+                accountId: t.accountId,
+            })),
+            whaleTrades: config.realtimeAlerts.whaleTrades,
+            arbitrage: config.realtimeAlerts.arbitrage,
+            priceMovement: config.realtimeAlerts.priceMovement,
+            copyTrading: config.realtimeAlerts.copyTrading,
+        });
+        // Connect to whale tracker if available
+        if (whaleTracker) {
+            whaleTrackerCleanup = (0, alerts_1.connectWhaleTracker)(realtimeAlerts, whaleTracker);
+        }
+        // Connect to opportunity finder if available
+        if (opportunityFinder) {
+            opportunityFinderCleanup = (0, alerts_1.connectOpportunityFinder)(realtimeAlerts, opportunityFinder);
+        }
+        logger_1.logger.info({ targets: config.realtimeAlerts.targets?.length ?? 0 }, 'Realtime alerts service initialized');
+    }
+    // Initialize auto-arbitrage executor if enabled
+    if (config.arbitrageExecution?.enabled && opportunityFinder) {
+        const wantsDryRun = config.arbitrageExecution?.dryRun ?? false;
+        const effectiveDryRun = executionService ? wantsDryRun : true;
+        if (!executionService && !wantsDryRun) {
+            logger_1.logger.warn('arbitrageExecution.dryRun=false but no execution service available - forcing dry run');
+        }
+        arbitrageExecutor = (0, executor_1.createOpportunityExecutor)(opportunityFinder, executionService, {
+            dryRun: effectiveDryRun,
+            minEdge: config.arbitrageExecution?.minEdge ?? 1.0,
+            minLiquidity: config.arbitrageExecution?.minLiquidity ?? 500,
+            maxPositionSize: config.arbitrageExecution?.maxPositionSize ?? 100,
+            maxDailyLoss: config.arbitrageExecution?.maxDailyLoss ?? 500,
+            maxConcurrentPositions: config.arbitrageExecution?.maxConcurrentPositions ?? 3,
+            enabledPlatforms: config.arbitrageExecution?.platforms ?? ['polymarket', 'kalshi'],
+            preferMakerOrders: config.arbitrageExecution?.preferMakerOrders ?? true,
+            confirmationDelayMs: config.arbitrageExecution?.confirmationDelayMs ?? 0,
+        }, smartRouter);
+        logger_1.logger.info({ dryRun: effectiveDryRun, hasExecutionService: !!executionService }, 'Arbitrage executor initialized');
+    }
+    // Initialize ML pipeline if enabled (before signal router so model is available)
+    if (config.mlPipeline?.enabled) {
+        mlPipeline = (0, ml_pipeline_1.createMLPipeline)(db, config.mlPipeline);
+        logger_1.logger.info('ML training pipeline initialized');
+    }
+    // Initialize signal router if enabled
+    const signalRouterCfg = config.signalRouter;
+    if (signalRouterCfg?.enabled) {
+        const mlModel = (config.mlPipeline?.useMLConfidence !== false && mlPipeline)
+            ? mlPipeline.getModel()
+            : null;
+        signalRouter = (0, signal_router_1.createSignalRouter)(executionService, signalRouterCfg, smartRouter, mlModel);
+        logger_1.logger.info({ dryRun: signalRouterCfg.dryRun ?? true, mlEnabled: !!mlModel }, 'Signal router initialized');
+    }
+    // Initialize tick recorder if enabled
+    if (config.tickRecorder?.enabled && config.tickRecorder.connectionString) {
+        tickRecorder = (0, tick_recorder_1.createTickRecorder)({
+            enabled: true,
+            connectionString: config.tickRecorder.connectionString,
+            batchSize: config.tickRecorder.batchSize,
+            flushIntervalMs: config.tickRecorder.flushIntervalMs,
+            retentionDays: config.tickRecorder.retentionDays,
+            platforms: config.tickRecorder.platforms,
+        });
+        logger_1.logger.info({ platforms: config.tickRecorder.platforms ?? 'all' }, 'Tick recorder initialized (will start with gateway)');
+    }
+    // Initialize tick streamer for real-time WebSocket streaming
+    tickStreamer = (0, tick_streamer_1.createTickStreamer)({
+        maxSubscriptionsPerClient: 100,
+        pingIntervalMs: 30000,
+        connectionTimeoutMs: 60000,
+    });
+    // Initialize feature engineering for computing trading indicators
+    featureEngine = (0, feature_engineering_1.createFeatureEngineering)({
+        tickWindowSize: 100,
+        orderbookWindowSize: 50,
+        momentumLookback: 20,
+        volatilityLookback: 50,
+    });
+    // Make feature engine available globally for other services
+    (0, feature_engineering_1.setFeatureEngine)(featureEngine);
+    // ── Signal Bus: single subscription point for all feed consumers ──────────
+    const signalBus = (0, signal_bus_1.createSignalBus)();
+    // Tick consumers (error-isolated via signal bus)
+    signalBus.onTick((update) => tickRecorder?.recordTick(update));
+    signalBus.onTick((update) => {
+        if (tickStreamer && update.outcomeId) {
+            tickStreamer.broadcastTick({
+                platform: update.platform,
+                marketId: update.marketId,
+                outcomeId: update.outcomeId,
+                price: update.price,
+                prevPrice: update.prevPrice ?? null,
+                timestamp: update.timestamp,
+            });
+        }
+    });
+    signalBus.onTick((update) => {
+        if (featureEngine && update.outcomeId) {
+            featureEngine.processTick({
+                platform: update.platform,
+                marketId: update.marketId,
+                outcomeId: update.outcomeId,
+                price: update.price,
+                prevPrice: update.prevPrice ?? null,
+                timestamp: update.timestamp,
+            });
+        }
+    });
+    // Orderbook consumers
+    signalBus.onOrderbook((update) => tickRecorder?.recordOrderbook(update));
+    signalBus.onOrderbook((update) => {
+        if (tickStreamer) {
+            tickStreamer.broadcastOrderbook({
+                platform: update.platform,
+                marketId: update.marketId,
+                outcomeId: update.outcomeId,
+                bids: update.bids,
+                asks: update.asks,
+                spread: update.spread ?? null,
+                midPrice: update.midPrice ?? null,
+                timestamp: update.timestamp,
+            });
+        }
+    });
+    signalBus.onOrderbook((update) => {
+        if (featureEngine) {
+            featureEngine.processOrderbook({
+                platform: update.platform,
+                marketId: update.marketId,
+                outcomeId: update.outcomeId,
+                bids: update.bids,
+                asks: update.asks,
+                timestamp: update.timestamp,
+            });
+        }
+    });
+    // Log feature signals for observability (consumers can subscribe via signalBus.onSignal)
+    signalBus.onSignal((signal) => {
+        logger_1.logger.debug({ type: signal.type, platform: signal.platform, market: signal.marketId, strength: signal.strength, direction: signal.direction }, 'Trading signal emitted');
+    });
+    // Connect feature engine signal output → signal bus
+    featureEngine.setEmitter(signalBus);
+    // Connect feeds → signal bus (single subscription point)
+    signalBus.connectFeeds(feeds);
+    logger_1.logger.info('Signal bus wired: feeds → tick/orderbook/signal consumers');
+    // Create position bridge (wires signal bus ticks → PM price updates,
+    // signal router fills → PM position tracking, PM close events → cleanup)
+    if (positionManager) {
+        positionBridge = (0, position_bridge_1.createPositionBridge)({
+            positionManager,
+            signalBus,
+            signalRouter,
+        });
+        logger_1.logger.info('Position bridge created');
+    }
+    // Initialize x402 client for outbound payments (agent-to-agent)
+    let x402Client = null;
+    if (config.x402?.enabled && (config.x402.evmPrivateKey || config.x402.solanaPrivateKey)) {
+        x402Client = (0, x402_1.createX402Client)({
+            network: config.x402.network,
+            evmPrivateKey: config.x402.evmPrivateKey,
+            solanaPrivateKey: config.x402.solanaPrivateKey,
+            autoApproveLimit: config.x402.autoApproveLimit,
+            dryRun: config.x402.dryRun,
+        });
+        logger_1.logger.info('x402 client initialized for outbound payments');
+    }
+    const startMonitoring = () => {
+        monitoring?.stop();
+        monitoring = (0, monitoring_1.createMonitoringService)({
+            config: currentConfig.monitoring,
+            providerHealth,
+            sendMessage,
+            resolveAccountId: (target) => {
+                if (target.accountId)
+                    return target.accountId;
+                if (!target.platform || !target.chatId)
+                    return undefined;
+                const session = db.getLatestSessionForChat(target.platform, target.chatId);
+                return session?.accountId;
+            },
+        });
+        monitoring.start();
+    };
+    async function startCronService() {
+        const cronEnabled = currentConfig.cron?.enabled !== false;
+        if (!cronEnabled) {
+            cronService?.stop();
+            cronService = null;
+            logger_1.logger.info('Cron service disabled');
+            return;
+        }
+        cronService?.stop();
+        cronService = (0, cron_1.createCronService)({
+            db,
+            feeds,
+            sendMessage,
+            credentials: cronCredentials,
+            config: currentConfig,
+        });
+        await cronService.start();
+    }
+    async function updatePositionPrices() {
+        const positions = db.listPositionsForPricing();
+        if (positions.length === 0)
+            return;
+        const grouped = new Map();
+        for (const position of positions) {
+            const key = `${position.platform}:${position.marketId}`;
+            const list = grouped.get(key) || [];
+            list.push(position);
+            grouped.set(key, list);
+        }
+        for (const [key, entries] of grouped.entries()) {
+            const [platform, marketId] = key.split(':');
+            try {
+                const market = await feeds.getMarket(marketId, platform);
+                if (!market)
+                    continue;
+                for (const position of entries) {
+                    const outcome = market.outcomes.find((o) => o.id === position.outcomeId ||
+                        o.name.toLowerCase() === position.outcome.toLowerCase());
+                    if (!outcome)
+                        continue;
+                    if (Number.isFinite(outcome.price)) {
+                        db.updatePositionPrice(position.id, outcome.price);
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn({ error, platform, marketId }, 'Failed to update position prices for market');
+            }
+        }
+        const positionConfig = currentConfig.positions ?? {};
+        if (positionConfig.pnlSnapshotsEnabled !== false) {
+            const userIds = new Set(positions.map((pos) => pos.userId));
+            for (const userId of userIds) {
+                const userPositions = db.getPositions(userId);
+                if (userPositions.length === 0)
+                    continue;
+                let totalValue = 0;
+                let totalPnl = 0;
+                let totalCostBasis = 0;
+                const byPlatform = {};
+                for (const pos of userPositions) {
+                    const value = pos.shares * pos.currentPrice;
+                    const costBasis = pos.shares * pos.avgPrice;
+                    const pnl = value - costBasis;
+                    totalValue += value;
+                    totalPnl += pnl;
+                    totalCostBasis += costBasis;
+                    const agg = byPlatform[pos.platform] || { value: 0, pnl: 0 };
+                    agg.value += value;
+                    agg.pnl += pnl;
+                    byPlatform[pos.platform] = agg;
+                }
+                const totalPnlPct = totalCostBasis > 0 ? totalPnl / totalCostBasis : 0;
+                db.createPortfolioSnapshot({
+                    userId,
+                    totalValue,
+                    totalPnl,
+                    totalPnlPct,
+                    totalCostBasis,
+                    positionsCount: userPositions.length,
+                    byPlatform,
+                });
+            }
+            const historyDays = positionConfig.pnlHistoryDays ?? 90;
+            if (historyDays > 0) {
+                const cutoffMs = Date.now() - historyDays * 24 * 60 * 60 * 1000;
+                db.deletePortfolioSnapshotsBefore(cutoffMs);
+            }
+        }
+    }
+    function startMarketCacheCleanup() {
+        const cacheConfig = currentConfig.marketCache ?? {};
+        if (cacheConfig.enabled === false)
+            return;
+        const ttlMs = cacheConfig.ttlMs ?? 30 * 60 * 1000;
+        const intervalMs = cacheConfig.cleanupIntervalMs ?? 15 * 60 * 1000;
+        const runCleanup = () => {
+            const cutoff = Date.now() - ttlMs;
+            const removed = db.pruneMarketCache(cutoff);
+            if (removed > 0) {
+                logger_1.logger.info({ removed, cutoff }, 'Market cache cleanup completed');
+            }
+        };
+        runCleanup();
+        if (!marketCacheCleanupInterval) {
+            marketCacheCleanupInterval = setInterval(() => {
+                runCleanup();
+            }, intervalMs);
+            logger_1.logger.info({ ttlMs, intervalMs }, 'Market cache cleanup started');
+        }
+    }
+    function startMarketIndexSync() {
+        const indexConfig = currentConfig.marketIndex ?? {};
+        if (indexConfig.enabled === false)
+            return;
+        const intervalMs = indexConfig.syncIntervalMs ?? 6 * 60 * 60 * 1000;
+        const staleAfterMs = indexConfig.staleAfterMs ?? 7 * 24 * 60 * 60 * 1000;
+        const limitPerPlatform = indexConfig.limitPerPlatform ?? 300;
+        const status = indexConfig.status ?? 'open';
+        const excludeSports = indexConfig.excludeSports ?? true;
+        const platforms = indexConfig.platforms ?? ['polymarket', 'kalshi', 'manifold', 'metaculus'];
+        const minVolume24h = indexConfig.minVolume24h ?? 0;
+        const minLiquidity = indexConfig.minLiquidity ?? 0;
+        const minOpenInterest = indexConfig.minOpenInterest ?? 0;
+        const minPredictions = indexConfig.minPredictions ?? 0;
+        const excludeResolved = indexConfig.excludeResolved ?? false;
+        const runSync = async () => {
+            try {
+                const result = await marketIndex.sync({
+                    platforms,
+                    limitPerPlatform,
+                    status,
+                    excludeSports,
+                    minVolume24h,
+                    minLiquidity,
+                    minOpenInterest,
+                    minPredictions,
+                    excludeResolved,
+                    prune: true,
+                    staleAfterMs,
+                });
+                logger_1.logger.info({ result }, 'Market index sync completed');
+            }
+            catch (error) {
+                logger_1.logger.warn({ error }, 'Market index sync failed');
+            }
+        };
+        void runSync();
+        if (!marketIndexSyncInterval) {
+            marketIndexSyncInterval = setInterval(() => {
+                void runSync();
+            }, intervalMs);
+            logger_1.logger.info({
+                intervalMs,
+                platforms,
+                limitPerPlatform,
+                status,
+                minVolume24h,
+                minLiquidity,
+                minOpenInterest,
+                minPredictions,
+                staleAfterMs,
+            }, 'Market index sync scheduled');
+        }
+    }
+    const getConfig = () => currentConfig;
+    let webhookTool;
+    // Pass queued wrapper to agents when available; fall back to direct service
+    let agents = await (0, agents_1.createAgentManager)(currentConfig, feeds, db, sessions, sendMessage, editMessage, deleteMessage, reactMessage, createPoll, memory, getConfig, () => webhookTool, queuedExecutionRef ?? executionService);
+    // Wire command palette for webchat — merges registry commands + skill commands
+    httpGateway.setCommandListHandler(() => {
+        const registryCommands = commands.listAll();
+        const registryNames = new Set(registryCommands.map(c => c.name));
+        const skillEntries = [];
+        for (const s of agents.getSkillCommands()) {
+            const normalized = s.name.toLowerCase().replace(/\s+/g, '-');
+            if (registryNames.has(`/${normalized}`))
+                continue;
+            const cats = registry_1.COMMAND_CATEGORIES[s.name] || registry_1.COMMAND_CATEGORIES[normalized] || 'Other';
+            const catList = Array.isArray(cats) ? cats : [cats];
+            for (const category of catList) {
+                skillEntries.push({
+                    name: `/${normalized}`,
+                    description: s.description,
+                    category,
+                    subcommands: s.subcommands || [],
+                });
+            }
+        }
+        return [...registryCommands, ...skillEntries]
+            .sort((a, b) => a.category.localeCompare(b.category) || a.name.localeCompare(b.name));
+    });
+    webhookTool = (0, webhooks_1.createWebhookTool)({
+        manager: webhookManager,
+        gatewayPort: currentConfig.gateway.port,
+        sessions,
+        commands,
+        feeds,
+        db,
+        memory,
+        sendMessage,
+        handleAgentMessage: (message, session) => agents.handleMessage(message, session),
+    });
+    let skillWatcher = null;
+    let skillReloadTimer = null;
+    let configReloadTimer = null;
+    function getSkillWatchPaths(cfg) {
+        const bundledDir = path_1.default.join(__dirname, '..', 'skills', 'bundled');
+        const managedDir = path_1.default.join(process.cwd(), '.clodds', 'skills');
+        const workspaceDir = path_1.default.join(cfg.agents.defaults.workspace, 'skills');
+        return [bundledDir, managedDir, workspaceDir];
+    }
+    function scheduleSkillReload(trigger) {
+        if (skillReloadTimer) {
+            clearTimeout(skillReloadTimer);
+        }
+        skillReloadTimer = setTimeout(() => {
+            logger_1.logger.info({ trigger }, 'Reloading skills');
+            agents.reloadSkills();
+        }, 150);
+    }
+    function setupSkillWatcher() {
+        if (skillWatcher) {
+            skillWatcher.close().catch((err) => {
+                logger_1.logger.debug({ err }, 'Error closing skill watcher during reset');
+            });
+        }
+        const paths = getSkillWatchPaths(currentConfig);
+        skillWatcher = chokidar_1.default.watch(paths, {
+            ignoreInitial: true,
+            awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+        });
+        skillWatcher.on('add', () => scheduleSkillReload('add'));
+        skillWatcher.on('change', () => scheduleSkillReload('change'));
+        skillWatcher.on('unlink', () => scheduleSkillReload('unlink'));
+        watchers.push(skillWatcher);
+        logger_1.logger.info({ paths }, 'Skill hot-reload watcher started');
+    }
+    async function rebuildRuntime(reason, workspaceChanged) {
+        if (!started)
+            return;
+        if (reloadInFlight) {
+            pendingReload = true;
+            logger_1.logger.info({ reason }, 'Reload already in progress; queued follow-up reload');
+            await reloadInFlight;
+            return;
+        }
+        reloadInFlight = (async () => {
+            logger_1.logger.info({ reason }, 'Rebuilding feeds/channels/agent from updated config');
+            const oldChannels = channels;
+            const oldFeeds = feeds;
+            const oldAgents = agents;
+            monitoring?.stop();
+            monitoring = null;
+            try {
+                await oldChannels?.stop();
+            }
+            catch (error) {
+                logger_1.logger.warn({ error }, 'Failed to stop old channels during reload');
+            }
+            // Stop alt-data service before rebuilding feeds
+            if (altDataService) {
+                altDataService.stop();
+                altDataService = null;
+            }
+            // Stop percolator before rebuild (recreated after if still enabled)
+            if (percolatorService) {
+                if (percolatorService.keeper)
+                    percolatorService.keeper.stop();
+                percolatorService.feed.disconnect();
+                percolatorService = null;
+            }
+            try {
+                await oldFeeds.stop();
+            }
+            catch (error) {
+                logger_1.logger.warn({ error }, 'Failed to stop old feeds during reload');
+            }
+            try {
+                oldAgents.dispose();
+            }
+            catch (error) {
+                logger_1.logger.warn({ error }, 'Failed to dispose old agent during reload');
+            }
+            feeds = await (0, feeds_1.createFeedManager)(currentConfig.feeds);
+            // Reconnect signal bus to new feeds (consumers keep their state)
+            signalBus.disconnectFeeds();
+            signalBus.connectFeeds(feeds);
+            agents = await (0, agents_1.createAgentManager)(currentConfig, feeds, db, sessions, sendMessage, editMessage, deleteMessage, reactMessage, createPoll, memory, getConfig, () => webhookTool, queuedExecutionRef ?? executionService);
+            channels = await (0, channels_1.createChannelManager)(currentConfig.channels, {
+                onMessage: handleIncomingMessage,
+                pairing,
+                commands,
+            }, { offlineQueue: currentConfig.messages?.offlineQueue });
+            httpGateway.setChannelWebhookHandler(async (platform, event, req) => {
+                if (!channels) {
+                    logger_1.logger.warn({ platform }, 'Channel webhook received before channels initialized');
+                    return null;
+                }
+                const adapter = channels.getAdapters()[platform];
+                if (!adapter?.handleEvent) {
+                    logger_1.logger.warn({ platform }, 'Channel webhook handler not registered');
+                    return null;
+                }
+                return adapter.handleEvent(event, req);
+            });
+            const wss = httpGateway.getWebSocketServer();
+            if (wss) {
+                channels.attachWebSocket(wss);
+            }
+            await feeds.start();
+            await channels.start();
+            await startCronService();
+            startMonitoring();
+            // Recreate percolator service if still enabled
+            if (currentConfig.feeds?.percolator?.enabled) {
+                const { createPercolatorService } = await Promise.resolve().then(() => __importStar(require('../percolator/index.js')));
+                percolatorService = createPercolatorService(currentConfig.feeds.percolator);
+                await percolatorService.feed.connect();
+                if (percolatorService.keeper)
+                    percolatorService.keeper.start();
+            }
+            // Recreate alt-data service with fresh feeds
+            const rebuildAltDataCfg = currentConfig.altData;
+            if (rebuildAltDataCfg?.enabled !== false) {
+                altDataService = (0, alt_data_1.createAltDataService)({
+                    config: rebuildAltDataCfg ?? {},
+                    signalBus,
+                    feeds: feeds,
+                    embeddings: embeddings,
+                });
+                await altDataService.start();
+            }
+            // Recreate ML pipeline with current config
+            if (currentConfig.mlPipeline?.enabled) {
+                mlPipeline = (0, ml_pipeline_1.createMLPipeline)(db, currentConfig.mlPipeline);
+            }
+            // Recreate signal router with current config
+            const rebuildSignalRouterCfg = currentConfig.signalRouter;
+            if (rebuildSignalRouterCfg?.enabled) {
+                const mlModel = (currentConfig.mlPipeline?.useMLConfidence !== false && mlPipeline)
+                    ? mlPipeline.getModel()
+                    : null;
+                signalRouter = (0, signal_router_1.createSignalRouter)(executionService, rebuildSignalRouterCfg, smartRouter, mlModel);
+                signalRouter.start(signalBus);
+                // Start ML pipeline after signal router
+                if (mlPipeline) {
+                    mlPipeline.start(signalRouter, null);
+                }
+            }
+            // Reconnect position bridge to new signal router
+            if (positionBridge) {
+                positionBridge.stop();
+            }
+            if (positionManager) {
+                positionBridge = (0, position_bridge_1.createPositionBridge)({
+                    positionManager,
+                    signalBus,
+                    signalRouter,
+                });
+                positionBridge.start();
+            }
+            if (workspaceChanged) {
+                setupSkillWatcher();
+            }
+            else {
+                scheduleSkillReload('config');
+            }
+            logger_1.logger.info('Runtime rebuild complete');
+        })()
+            .catch((error) => {
+            logger_1.logger.error({ error }, 'Runtime rebuild failed');
+        })
+            .finally(async () => {
+            reloadInFlight = null;
+            if (pendingReload) {
+                pendingReload = false;
+                await rebuildRuntime('pending reload', true);
+            }
+        });
+        await reloadInFlight;
+    }
+    function setupConfigWatcher() {
+        const watcher = chokidar_1.default.watch(configPath, {
+            ignoreInitial: true,
+            awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+        });
+        const scheduleConfigReload = () => {
+            if (configReloadTimer) {
+                clearTimeout(configReloadTimer);
+            }
+            configReloadTimer = setTimeout(async () => {
+                try {
+                    const previousWorkspace = currentConfig.agents.defaults.workspace;
+                    const next = await (0, config_1.loadConfig)(configPath);
+                    currentConfig = next;
+                    (0, http_1.configureHttpClient)(currentConfig.http);
+                    const workspaceChanged = next.agents.defaults.workspace !== previousWorkspace;
+                    agents.reloadConfig(next);
+                    await rebuildRuntime('config change', workspaceChanged);
+                    logger_1.logger.info({ configPath }, 'Config hot-reloaded');
+                }
+                catch (error) {
+                    logger_1.logger.error({ error, configPath }, 'Failed to hot-reload config');
+                }
+            }, 250);
+        };
+        watcher.on('add', scheduleConfigReload);
+        watcher.on('change', scheduleConfigReload);
+        watcher.on('unlink', scheduleConfigReload);
+        watchers.push(watcher);
+        logger_1.logger.info({ configPath }, 'Config hot-reload watcher started');
+    }
+    function getChannelRateLimitConfig(platform) {
+        const channelConfig = currentConfig.channels?.[platform];
+        if (!channelConfig?.rateLimit)
+            return null;
+        return channelConfig.rateLimit;
+    }
+    function getChannelRateLimiter(platform, config) {
+        const existing = channelRateLimiters.get(platform);
+        if (existing &&
+            existing.config.maxRequests === config.maxRequests &&
+            existing.config.windowMs === config.windowMs &&
+            existing.config.perUser === config.perUser) {
+            return existing;
+        }
+        const limiter = new security_1.RateLimiter(config);
+        const entry = { config, limiter };
+        channelRateLimiters.set(platform, entry);
+        return entry;
+    }
+    const handleIncomingMessage = async (message) => {
+        const normalized = (0, unified_1.normalizeIncomingMessage)(message);
+        const channelRateLimit = getChannelRateLimitConfig(normalized.platform);
+        if (channelRateLimit) {
+            const limiterEntry = getChannelRateLimiter(normalized.platform, channelRateLimit);
+            const rateLimitKey = channelRateLimit.perUser
+                ? `${normalized.platform}:${normalized.userId}`
+                : `${normalized.platform}:global`;
+            const rateLimitResult = limiterEntry.limiter.check(rateLimitKey);
+            if (!rateLimitResult.allowed) {
+                const resetInSeconds = Math.ceil(rateLimitResult.resetIn / 1000);
+                logger_1.logger.warn({ platform: normalized.platform, userId: normalized.userId, resetInSeconds }, 'Channel rate limit exceeded');
+                await sendMessage({
+                    platform: normalized.platform,
+                    chatId: normalized.chatId,
+                    text: `Rate limit exceeded for ${normalized.platform}. Try again in ${resetInSeconds}s.`,
+                    parseMode: 'Markdown',
+                    thread: normalized.thread,
+                });
+                return;
+            }
+        }
+        const session = await sessions.getOrCreateSession(normalized);
+        const commandResponse = await commands.handle(normalized, {
+            session,
+            sessions,
+            feeds,
+            db,
+            memory,
+            opportunityFinder: opportunityFinder ?? undefined,
+            bittensorService: bittensorService ?? undefined,
+            send: sendMessage,
+        });
+        if (commandResponse) {
+            await sendMessage({
+                platform: normalized.platform,
+                chatId: normalized.chatId,
+                text: commandResponse,
+                parseMode: 'Markdown',
+                thread: normalized.thread,
+            });
+            return;
+        }
+        const responseText = await agents.handleMessage(normalized, session);
+        if (responseText !== null) {
+            await sendMessage({
+                platform: normalized.platform,
+                chatId: normalized.chatId,
+                text: responseText,
+                parseMode: 'Markdown',
+                thread: normalized.thread,
+            });
+        }
+    };
+    channels = await (0, channels_1.createChannelManager)(config.channels, {
+        onMessage: handleIncomingMessage,
+        pairing,
+        commands,
+    }, { offlineQueue: config.messages?.offlineQueue });
+    httpGateway.setChannelWebhookHandler(async (platform, event, req) => {
+        if (!channels) {
+            logger_1.logger.warn({ platform }, 'Channel webhook received before channels initialized');
+            return null;
+        }
+        const adapter = channels.getAdapters()[platform];
+        if (!adapter?.handleEvent) {
+            logger_1.logger.warn({ platform }, 'Channel webhook handler not registered');
+            return null;
+        }
+        return adapter.handleEvent(event, req);
+    });
+    httpGateway.setMarketIndexHandler(async (req) => {
+        if (!currentConfig.marketIndex || currentConfig.marketIndex.enabled === false) {
+            return { error: 'Market index disabled', status: 503 };
+        }
+        const query = typeof req.query.q === 'string' ? req.query.q.trim() : '';
+        if (!query) {
+            return { error: 'Missing query parameter: q', status: 400 };
+        }
+        const platform = typeof req.query.platform === 'string' ? req.query.platform : undefined;
+        const limit = req.query.limit ? Number.parseInt(String(req.query.limit), 10) : undefined;
+        const maxCandidates = req.query.maxCandidates
+            ? Number.parseInt(String(req.query.maxCandidates), 10)
+            : undefined;
+        const minScore = req.query.minScore ? Number.parseFloat(String(req.query.minScore)) : undefined;
+        let platformWeights;
+        if (typeof req.query.platformWeights === 'string') {
+            try {
+                platformWeights = JSON.parse(req.query.platformWeights);
+            }
+            catch {
+                return { error: 'Invalid platformWeights JSON', status: 400 };
+            }
+        }
+        const results = await marketIndex.search({
+            query,
+            platform: platform,
+            limit,
+            maxCandidates,
+            minScore,
+            platformWeights: platformWeights,
+        });
+        return {
+            results: results.map((r) => ({
+                score: Number(r.score.toFixed(4)),
+                market: {
+                    platform: r.item.platform,
+                    id: r.item.marketId,
+                    slug: r.item.slug,
+                    question: r.item.question,
+                    description: r.item.description,
+                    url: r.item.url,
+                    status: r.item.status,
+                    endDate: r.item.endDate,
+                    resolved: r.item.resolved,
+                    volume24h: r.item.volume24h,
+                    liquidity: r.item.liquidity,
+                    openInterest: r.item.openInterest,
+                    predictions: r.item.predictions,
+                },
+            })),
+        };
+    });
+    httpGateway.setMarketIndexStatsHandler(async (req) => {
+        if (!currentConfig.marketIndex || currentConfig.marketIndex.enabled === false) {
+            return { error: 'Market index disabled', status: 503 };
+        }
+        const platforms = typeof req.query.platforms === 'string'
+            ? req.query.platforms.split(',').map((p) => p.trim()).filter(Boolean)
+            : undefined;
+        const stats = marketIndex.stats(platforms);
+        return { stats };
+    });
+    httpGateway.setMarketIndexSyncHandler(async (req) => {
+        if (!currentConfig.marketIndex || currentConfig.marketIndex.enabled === false) {
+            return { error: 'Market index disabled', status: 503 };
+        }
+        const body = (req.body || {});
+        const platforms = Array.isArray(body.platforms)
+            ? body.platforms
+            : typeof body.platforms === 'string'
+                ? body.platforms.split(',').map((p) => p.trim()).filter(Boolean)
+                : undefined;
+        const limitPerPlatform = typeof body.limitPerPlatform === 'number' ? body.limitPerPlatform : undefined;
+        const status = typeof body.status === 'string' ? body.status : undefined;
+        const excludeSports = typeof body.excludeSports === 'boolean' ? body.excludeSports : undefined;
+        const minVolume24h = typeof body.minVolume24h === 'number' ? body.minVolume24h : undefined;
+        const minLiquidity = typeof body.minLiquidity === 'number' ? body.minLiquidity : undefined;
+        const minOpenInterest = typeof body.minOpenInterest === 'number' ? body.minOpenInterest : undefined;
+        const minPredictions = typeof body.minPredictions === 'number' ? body.minPredictions : undefined;
+        const excludeResolved = typeof body.excludeResolved === 'boolean' ? body.excludeResolved : undefined;
+        const prune = typeof body.prune === 'boolean' ? body.prune : undefined;
+        const staleAfterMs = typeof body.staleAfterMs === 'number' ? body.staleAfterMs : undefined;
+        const result = await marketIndex.sync({
+            platforms: platforms,
+            limitPerPlatform,
+            status: status,
+            excludeSports,
+            minVolume24h,
+            minLiquidity,
+            minOpenInterest,
+            minPredictions,
+            excludeResolved,
+            prune,
+            staleAfterMs,
+        });
+        return { result };
+    });
+    // Performance dashboard handler
+    httpGateway.setPerformanceDashboardHandler(async (_req) => {
+        // Get trade statistics from database
+        const trades = db.query(`
+      SELECT
+        id,
+        created_at as timestamp,
+        COALESCE(market_question, market_id) as market,
+        side,
+        size,
+        entry_price as entryPrice,
+        exit_price as exitPrice,
+        pnl,
+        pnl_pct as pnlPct,
+        status,
+        strategy
+      FROM trades
+      ORDER BY created_at DESC
+      LIMIT 100
+    `);
+        // Calculate stats
+        const closedTrades = trades.filter(t => t.status === 'closed' && t.pnl != null);
+        const winningTrades = closedTrades.filter(t => (t.pnl ?? 0) > 0);
+        const totalPnl = closedTrades.reduce((sum, t) => sum + (t.pnl ?? 0), 0);
+        const avgPnlPct = closedTrades.length > 0
+            ? closedTrades.reduce((sum, t) => sum + (t.pnlPct ?? 0), 0) / closedTrades.length
+            : 0;
+        // Calculate Sharpe ratio (simplified - daily returns)
+        const dailyPnl = {};
+        for (const t of closedTrades) {
+            const date = t.timestamp.split('T')[0];
+            dailyPnl[date] = (dailyPnl[date] ?? 0) + (t.pnl ?? 0);
+        }
+        const dailyReturns = Object.values(dailyPnl);
+        const avgReturn = dailyReturns.length > 0
+            ? dailyReturns.reduce((a, b) => a + b, 0) / dailyReturns.length
+            : 0;
+        const stdDev = dailyReturns.length > 1
+            ? Math.sqrt(dailyReturns.reduce((sum, r) => sum + Math.pow(r - avgReturn, 2), 0) / (dailyReturns.length - 1))
+            : 1;
+        const sharpeRatio = stdDev > 0 ? (avgReturn / stdDev) * Math.sqrt(252) : 0;
+        // Calculate max drawdown
+        let peak = 0;
+        let maxDrawdown = 0;
+        let cumulative = 0;
+        const dailyData = [];
+        const sortedDates = Object.keys(dailyPnl).sort();
+        for (const date of sortedDates) {
+            cumulative += dailyPnl[date];
+            peak = Math.max(peak, cumulative);
+            const drawdown = peak > 0 ? (peak - cumulative) / peak : 0;
+            maxDrawdown = Math.max(maxDrawdown, drawdown);
+            dailyData.push({ date, pnl: dailyPnl[date], cumulative });
+        }
+        // Group by strategy
+        const strategyMap = {};
+        for (const t of closedTrades) {
+            const strat = t.strategy ?? 'Unknown';
+            if (!strategyMap[strat]) {
+                strategyMap[strat] = { trades: 0, wins: 0, pnl: 0 };
+            }
+            strategyMap[strat].trades++;
+            if ((t.pnl ?? 0) > 0)
+                strategyMap[strat].wins++;
+            strategyMap[strat].pnl += t.pnl ?? 0;
+        }
+        const byStrategy = Object.entries(strategyMap).map(([strategy, data]) => ({
+            strategy,
+            trades: data.trades,
+            winRate: data.trades > 0 ? (data.wins / data.trades) * 100 : 0,
+            pnl: data.pnl,
+        }));
+        // Format recent trades
+        const recentTrades = trades.slice(0, 20).map(t => ({
+            id: t.id,
+            timestamp: t.timestamp,
+            market: t.market,
+            side: t.side,
+            size: t.size,
+            entryPrice: t.entryPrice,
+            exitPrice: t.exitPrice ?? undefined,
+            pnl: t.pnl ?? undefined,
+            pnlPct: t.pnlPct ?? undefined,
+            status: t.status === 'closed'
+                ? ((t.pnl ?? 0) > 0 ? 'win' : 'loss')
+                : t.status,
+        }));
+        return {
+            stats: {
+                totalTrades: trades.length,
+                winRate: closedTrades.length > 0 ? (winningTrades.length / closedTrades.length) * 100 : 0,
+                totalPnl,
+                avgPnlPct,
+                sharpeRatio,
+                maxDrawdown: maxDrawdown * 100,
+            },
+            recentTrades,
+            dailyPnl: dailyData,
+            byStrategy,
+        };
+    });
+    // Backtest handler - runs backtest on historical trade data
+    httpGateway.setBacktestHandler(async (req) => {
+        const body = req.body;
+        // Get historical trades for analysis
+        const startDate = body.startDate ? new Date(body.startDate) : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+        const endDate = body.endDate ? new Date(body.endDate) : new Date();
+        const initialCapital = body.initialCapital ?? 10000;
+        // Query historical trades
+        const trades = db.query(`
+      SELECT created_at, side, size, entry_price, exit_price, pnl, pnl_pct, status
+      FROM trades
+      WHERE created_at >= ? AND created_at <= ?
+      ${body.platform ? 'AND platform = ?' : ''}
+      ${body.marketId ? 'AND market_id = ?' : ''}
+      ORDER BY created_at
+    `, [
+            startDate.toISOString(),
+            endDate.toISOString(),
+            ...(body.platform ? [body.platform] : []),
+            ...(body.marketId ? [body.marketId] : []),
+        ]);
+        // Build equity curve from trades
+        let equity = initialCapital;
+        const equityCurve = [
+            { timestamp: startDate.toISOString(), equity: initialCapital }
+        ];
+        const dailyPnl = {};
+        const closedTrades = trades.filter(t => t.status === 'closed' && t.pnl != null);
+        for (const trade of closedTrades) {
+            equity += trade.pnl ?? 0;
+            equityCurve.push({ timestamp: trade.created_at, equity });
+            const date = trade.created_at.split('T')[0];
+            dailyPnl[date] = (dailyPnl[date] ?? 0) + (trade.pnl ?? 0);
+        }
+        // Calculate metrics
+        const wins = closedTrades.filter(t => (t.pnl ?? 0) > 0);
+        const losses = closedTrades.filter(t => (t.pnl ?? 0) < 0);
+        const totalPnl = closedTrades.reduce((sum, t) => sum + (t.pnl ?? 0), 0);
+        const totalReturnPct = (totalPnl / initialCapital) * 100;
+        const days = (endDate.getTime() - startDate.getTime()) / (24 * 60 * 60 * 1000);
+        const annualizedReturnPct = totalReturnPct * (365 / Math.max(1, days));
+        // Sharpe & Sortino
+        const dailyReturns = Object.values(dailyPnl).map(pnl => pnl / initialCapital);
+        const avgReturn = dailyReturns.length > 0 ? dailyReturns.reduce((a, b) => a + b, 0) / dailyReturns.length : 0;
+        const stdDev = dailyReturns.length > 1 ? Math.sqrt(dailyReturns.reduce((sum, r) => sum + Math.pow(r - avgReturn, 2), 0) / (dailyReturns.length - 1)) : 1;
+        const sharpeRatio = stdDev > 0 ? (avgReturn / stdDev) * Math.sqrt(252) : 0;
+        const negReturns = dailyReturns.filter(r => r < 0);
+        const downsideDev = negReturns.length > 0 ? Math.sqrt(negReturns.reduce((sum, r) => sum + r * r, 0) / negReturns.length) : 1;
+        const sortinoRatio = downsideDev > 0 ? (avgReturn / downsideDev) * Math.sqrt(252) : 0;
+        // Max drawdown
+        let peak = initialCapital;
+        let maxDrawdownPct = 0;
+        for (const point of equityCurve) {
+            if (point.equity > peak)
+                peak = point.equity;
+            const dd = ((peak - point.equity) / peak) * 100;
+            if (dd > maxDrawdownPct)
+                maxDrawdownPct = dd;
+        }
+        // Profit factor
+        const grossProfit = wins.reduce((sum, t) => sum + (t.pnl ?? 0), 0);
+        const grossLoss = Math.abs(losses.reduce((sum, t) => sum + (t.pnl ?? 0), 0));
+        const profitFactor = grossLoss > 0 ? grossProfit / grossLoss : grossProfit > 0 ? Infinity : 0;
+        return {
+            result: {
+                strategyId: body.strategyId || 'historical',
+                metrics: {
+                    totalReturnPct,
+                    annualizedReturnPct,
+                    totalTrades: trades.length,
+                    winRate: closedTrades.length > 0 ? (wins.length / closedTrades.length) * 100 : 0,
+                    sharpeRatio,
+                    sortinoRatio,
+                    maxDrawdownPct,
+                    profitFactor: profitFactor === Infinity ? 999 : profitFactor,
+                },
+                trades: trades.slice(0, 50).map(t => ({
+                    timestamp: t.created_at,
+                    side: t.side,
+                    size: t.size,
+                    entryPrice: t.entry_price,
+                    exitPrice: t.exit_price,
+                    pnl: t.pnl,
+                })),
+                equityCurve,
+                dailyReturns: Object.entries(dailyPnl).map(([date, pnl]) => ({ date, return: pnl / initialCapital })),
+            },
+        };
+    });
+    // Tick recorder handlers
+    httpGateway.setTicksHandler(async (req) => {
+        if (!tickRecorder) {
+            return { error: 'Tick recorder not enabled', status: 503 };
+        }
+        const platform = req.params.platform;
+        const marketId = req.params.marketId;
+        const outcomeId = typeof req.query.outcomeId === 'string' ? req.query.outcomeId : undefined;
+        const startTime = req.query.startTime ? Number(req.query.startTime) : Date.now() - 24 * 60 * 60 * 1000;
+        const endTime = req.query.endTime ? Number(req.query.endTime) : Date.now();
+        const limit = req.query.limit ? Number(req.query.limit) : 1000;
+        const ticks = await tickRecorder.getTicks({
+            platform,
+            marketId,
+            outcomeId,
+            startTime,
+            endTime,
+            limit,
+        });
+        return {
+            ticks: ticks.map((t) => ({
+                time: t.time.toISOString(),
+                platform: t.platform,
+                marketId: t.marketId,
+                outcomeId: t.outcomeId,
+                price: t.price,
+                prevPrice: t.prevPrice,
+            })),
+        };
+    });
+    httpGateway.setOHLCHandler(async (req) => {
+        if (!tickRecorder) {
+            return { error: 'Tick recorder not enabled', status: 503 };
+        }
+        const platform = req.params.platform;
+        const marketId = req.params.marketId;
+        const outcomeId = typeof req.query.outcomeId === 'string' ? req.query.outcomeId : undefined;
+        const interval = (typeof req.query.interval === 'string' ? req.query.interval : '1h');
+        const startTime = req.query.startTime ? Number(req.query.startTime) : Date.now() - 7 * 24 * 60 * 60 * 1000;
+        const endTime = req.query.endTime ? Number(req.query.endTime) : Date.now();
+        if (!outcomeId) {
+            return { error: 'Missing required query parameter: outcomeId', status: 400 };
+        }
+        const candles = await tickRecorder.getOHLC({
+            platform,
+            marketId,
+            outcomeId,
+            interval,
+            startTime,
+            endTime,
+        });
+        return { candles };
+    });
+    httpGateway.setOrderbookHistoryHandler(async (req) => {
+        if (!tickRecorder) {
+            return { error: 'Tick recorder not enabled', status: 503 };
+        }
+        const platform = req.params.platform;
+        const marketId = req.params.marketId;
+        const outcomeId = typeof req.query.outcomeId === 'string' ? req.query.outcomeId : undefined;
+        const startTime = req.query.startTime ? Number(req.query.startTime) : Date.now() - 60 * 60 * 1000;
+        const endTime = req.query.endTime ? Number(req.query.endTime) : Date.now();
+        const limit = req.query.limit ? Number(req.query.limit) : 100;
+        const snapshots = await tickRecorder.getOrderbookSnapshots({
+            platform,
+            marketId,
+            outcomeId,
+            startTime,
+            endTime,
+            limit,
+        });
+        return {
+            snapshots: snapshots.map((s) => ({
+                time: s.time.toISOString(),
+                platform: s.platform,
+                marketId: s.marketId,
+                outcomeId: s.outcomeId,
+                bids: s.bids,
+                asks: s.asks,
+                spread: s.spread,
+                midPrice: s.midPrice,
+            })),
+        };
+    });
+    httpGateway.setTickRecorderStatsHandler(async (_req) => {
+        if (!tickRecorder) {
+            return { error: 'Tick recorder not enabled', status: 503 };
+        }
+        const stats = tickRecorder.getStats();
+        return { stats };
+    });
+    // Set tick streamer for WebSocket streaming endpoint
+    httpGateway.setTickStreamer(tickStreamer);
+    // Set feature engineering for REST API
+    httpGateway.setFeatureEngineering(featureEngine);
+    // Create trade logger first (shared with bot manager)
+    tradeLogger = (0, logger_2.createTradeLogger)(db);
+    // Create bot manager with execution callbacks
+    botManager = (0, bots_1.createBotManager)(db, {
+        tradeLogger,
+        executeOrder: executionService
+            ? async (signal, strategyId) => {
+                const side = signal.type === 'buy' ? 'buy' : 'sell';
+                const orderReq = {
+                    platform: signal.platform,
+                    marketId: signal.marketId,
+                    outcome: signal.outcome,
+                    price: signal.price || 0.5,
+                    size: signal.size || 100,
+                };
+                const result = side === 'buy'
+                    ? await executionService.buyLimit(orderReq)
+                    : await executionService.sellLimit(orderReq);
+                if (!result.success)
+                    return null;
+                return tradeLogger.logTrade({
+                    platform: signal.platform,
+                    marketId: signal.marketId,
+                    outcome: signal.outcome,
+                    side,
+                    orderType: 'limit',
+                    price: result.avgFillPrice ?? signal.price ?? 0.5,
+                    size: result.filledSize ?? signal.size ?? 100,
+                    filled: result.filledSize ?? 0,
+                    cost: (result.avgFillPrice ?? signal.price ?? 0.5) * (result.filledSize ?? signal.size ?? 100),
+                    status: result.filledSize ? 'filled' : 'pending',
+                    strategyId,
+                    orderId: result.orderId,
+                });
+            }
+            : undefined,
+        getPrice: async (platform, marketId) => {
+            const market = await feeds.getMarket(marketId, platform);
+            if (!market)
+                return null;
+            const outcome = market.outcomes[0];
+            return outcome?.price ?? null;
+        },
+        getMarket: async (platform, marketId) => {
+            return feeds.getMarket(marketId, platform);
+        },
+        getPortfolio: async () => {
+            const positions = db.getPositions('default');
+            let totalValue = 0;
+            const mapped = positions.map((p) => {
+                const value = p.shares * (p.currentPrice || p.avgPrice);
+                totalValue += value;
+                return { platform: p.platform, marketId: p.marketId, outcome: p.outcome, shares: p.shares, avgPrice: p.avgPrice, currentPrice: p.currentPrice || p.avgPrice };
+            });
+            return { value: totalValue, balance: totalValue * 0.2, positions: mapped };
+        },
+    });
+    strategyBuilder = (0, builder_1.createStrategyBuilder)(db);
+    // Register built-in strategies
+    botManager.registerStrategy((0, bots_1.createMeanReversionStrategy)());
+    botManager.registerStrategy((0, bots_1.createMomentumStrategy)());
+    botManager.registerStrategy((0, bots_1.createArbitrageStrategy)());
+    // Register MM strategy if configured
+    if (config.trading?.marketMaking?.enabled && executionService) {
+        const mmConfig = config.trading.marketMaking;
+        const mmStrategy = (0, market_making_1.createMMStrategy)(mmConfig, {
+            execution: executionService,
+            feeds,
+        });
+        botManager.registerStrategy(mmStrategy);
+        logger_1.logger.info('Market making strategy registered');
+    }
+    // Register crypto HFT adapter if configured
+    if (config.trading?.cryptoHft?.enabled) {
+        try {
+            const { createCryptoFeed } = await Promise.resolve().then(() => __importStar(require('../feeds/crypto/index.js')));
+            const { createCryptoHftAdapter } = await Promise.resolve().then(() => __importStar(require('../trading/adapters/index.js')));
+            const cryptoFeed = createCryptoFeed();
+            const hftStrategy = createCryptoHftAdapter({
+                feed: cryptoFeed,
+                execution: executionService,
+                config: config.trading.cryptoHft,
+            });
+            botManager.registerStrategy(hftStrategy);
+            logger_1.logger.info('Crypto HFT adapter registered');
+        }
+        catch (err) {
+            logger_1.logger.warn({ err }, 'Failed to load crypto HFT adapter');
+        }
+    }
+    // Register HFT divergence adapter if configured
+    if (config.trading?.hftDivergence?.enabled) {
+        try {
+            const { createCryptoFeed } = await Promise.resolve().then(() => __importStar(require('../feeds/crypto/index.js')));
+            const { createDivergenceAdapter } = await Promise.resolve().then(() => __importStar(require('../trading/adapters/index.js')));
+            const cryptoFeed = createCryptoFeed();
+            const divStrategy = createDivergenceAdapter({
+                feed: cryptoFeed,
+                execution: executionService,
+                config: config.trading.hftDivergence,
+            });
+            botManager.registerStrategy(divStrategy);
+            logger_1.logger.info('HFT divergence adapter registered');
+        }
+        catch (err) {
+            logger_1.logger.warn({ err }, 'Failed to load HFT divergence adapter');
+        }
+    }
+    logger_1.logger.info({ strategies: botManager.getStrategies().length }, 'Bot manager initialized with built-in strategies');
+    // Wire trading API endpoints (positions, portfolio, orders, signals, orchestrator)
+    const backtestEngine = (0, backtest_1.createBacktestEngine)(db);
+    const tradingApiRouter = (0, api_routes_1.createTradingApiRouter)({
+        db,
+        execution: executionService,
+        orchestrator,
+        safety: safetyManager,
+        signalRouter,
+        botManager,
+        tradeLogger,
+        tickRecorder,
+        backtestEngine,
+        strategyBuilder,
+        signalBus,
+        featureEngine,
+        positionManager,
+        mlPipeline,
+    });
+    httpGateway.setTradingApiRouter(tradingApiRouter);
+    return {
+        async start() {
+            logger_1.logger.info('Starting gateway services');
+            // Setup graceful shutdown handlers
+            (0, production_1.setupShutdownHandlers)();
+            // Register shutdown cleanup
+            (0, production_1.onShutdown)(async () => {
+                logger_1.logger.info('Shutting down gateway services');
+                if (executionProducer)
+                    await executionProducer.close();
+                if (botManager) {
+                    for (const s of botManager.getAllBotStatuses()) {
+                        if (s.status === 'running' || s.status === 'paused') {
+                            await botManager.stopBot(s.id);
+                        }
+                    }
+                }
+                if (whaleTracker)
+                    whaleTracker.stop();
+                if (copyTrading)
+                    copyTrading.stop();
+                if (realtimeAlerts)
+                    realtimeAlerts.stop();
+                if (arbitrageExecutor)
+                    arbitrageExecutor.stop();
+                if (mlPipeline)
+                    mlPipeline.stop();
+                if (positionBridge)
+                    positionBridge.stop();
+                if (signalRouter)
+                    signalRouter.stop();
+                // Stop event flow first, then flush pending writes
+                signalBus.disconnectFeeds();
+                if (tickRecorder)
+                    await tickRecorder.stop();
+                if (tickStreamer)
+                    tickStreamer.stop();
+                if (cronService)
+                    await cronService.stop();
+                if (monitoring)
+                    monitoring.stop();
+                providerHealth?.stop();
+                await feeds.stop();
+                if (channels)
+                    await channels.stop();
+                await httpGateway.stop();
+                db.close();
+            });
+            await httpGateway.start();
+            const wss = httpGateway.getWebSocketServer();
+            if (wss) {
+                channels.attachWebSocket(wss);
+            }
+            await feeds.start();
+            await channels.start();
+            providerHealth?.start();
+            await startCronService();
+            startMonitoring();
+            // Start whale tracker if enabled
+            if (whaleTracker) {
+                await whaleTracker.start();
+                logger_1.logger.info('Whale tracker started');
+            }
+            // Start copy trading if enabled
+            if (copyTrading) {
+                copyTrading.start();
+                logger_1.logger.info('Copy trading service started');
+            }
+            // Start realtime alerts if enabled
+            if (realtimeAlerts) {
+                realtimeAlerts.start();
+                logger_1.logger.info('Realtime alerts service started');
+            }
+            // Start arbitrage executor if enabled
+            if (arbitrageExecutor) {
+                arbitrageExecutor.start();
+                logger_1.logger.info('Arbitrage executor started');
+            }
+            // Start signal router if enabled
+            if (signalRouter) {
+                signalRouter.start(signalBus);
+                logger_1.logger.info('Signal router started');
+            }
+            // Start ML pipeline if enabled (after signal router so it can subscribe)
+            if (mlPipeline && signalRouter) {
+                mlPipeline.start(signalRouter, null);
+                logger_1.logger.info('ML training pipeline started');
+            }
+            // Start position bridge (subscribes to ticks, fills, and close events)
+            if (positionBridge) {
+                positionBridge.start();
+                logger_1.logger.info('Position bridge started');
+            }
+            // Start tick recorder if enabled
+            if (tickRecorder) {
+                await tickRecorder.start();
+                logger_1.logger.info('Tick recorder started');
+            }
+            // Start Percolator feed + keeper if enabled
+            if (percolatorService) {
+                await percolatorService.feed.connect();
+                if (percolatorService.keeper) {
+                    percolatorService.keeper.start();
+                }
+                logger_1.logger.info('Percolator service started');
+            }
+            // Start Bittensor mining service if enabled
+            if (bittensorService) {
+                await bittensorService.start();
+                logger_1.logger.info('Bittensor mining service started');
+            }
+            // Start alt-data sentiment pipeline if enabled
+            const altDataCfg = currentConfig.altData;
+            if (altDataCfg?.enabled !== false) {
+                altDataService = (0, alt_data_1.createAltDataService)({
+                    config: altDataCfg ?? {},
+                    signalBus,
+                    feeds: feeds,
+                    embeddings: embeddings,
+                });
+                await altDataService.start();
+                logger_1.logger.info({ feeds: altDataService.getStats().activeFeeds }, 'Alt-data service started');
+            }
+            started = true;
+            if (!channelRateLimitCleanupInterval) {
+                channelRateLimitCleanupInterval = setInterval(() => {
+                    for (const entry of channelRateLimiters.values()) {
+                        entry.limiter.cleanup();
+                    }
+                }, 5 * 60 * 1000);
+            }
+            startMarketCacheCleanup();
+            startMarketIndexSync();
+            const positionConfig = currentConfig.positions ?? {};
+            const positionUpdatesEnabled = positionConfig.enabled !== false;
+            if (positionUpdatesEnabled) {
+                const intervalMs = positionConfig.priceUpdateIntervalMs ?? 5 * 60 * 1000;
+                if (!positionPriceUpdateInterval) {
+                    updatePositionPrices().catch((error) => {
+                        logger_1.logger.warn({ error }, 'Initial position price update failed');
+                    });
+                    positionPriceUpdateInterval = setInterval(() => {
+                        updatePositionPrices().catch((error) => {
+                            logger_1.logger.warn({ error }, 'Position price update failed');
+                        });
+                    }, intervalMs);
+                    logger_1.logger.info({ intervalMs }, 'Position price updater started');
+                }
+            }
+            setupSkillWatcher();
+            setupConfigWatcher();
+            logger_1.logger.info({ port: currentConfig.gateway.port }, 'Gateway started');
+        },
+        async stop() {
+            logger_1.logger.info('Stopping gateway services');
+            if (cronService) {
+                cronService.stop();
+                cronService = null;
+            }
+            for (const watcher of watchers) {
+                try {
+                    await watcher.close();
+                }
+                catch (error) {
+                    logger_1.logger.warn({ error }, 'Failed to close watcher cleanly');
+                }
+            }
+            if (skillReloadTimer) {
+                clearTimeout(skillReloadTimer);
+                skillReloadTimer = null;
+            }
+            if (configReloadTimer) {
+                clearTimeout(configReloadTimer);
+                configReloadTimer = null;
+            }
+            if (reloadInFlight) {
+                await reloadInFlight;
+            }
+            if (channelRateLimitCleanupInterval) {
+                clearInterval(channelRateLimitCleanupInterval);
+                channelRateLimitCleanupInterval = null;
+            }
+            if (positionPriceUpdateInterval) {
+                clearInterval(positionPriceUpdateInterval);
+                positionPriceUpdateInterval = null;
+            }
+            if (marketCacheCleanupInterval) {
+                clearInterval(marketCacheCleanupInterval);
+                marketCacheCleanupInterval = null;
+            }
+            if (marketIndexSyncInterval) {
+                clearInterval(marketIndexSyncInterval);
+                marketIndexSyncInterval = null;
+            }
+            agents.dispose();
+            providerHealth?.stop();
+            monitoring?.stop();
+            monitoring = null;
+            // Stop Percolator service
+            if (percolatorService) {
+                if (percolatorService.keeper)
+                    percolatorService.keeper.stop();
+                percolatorService.feed.disconnect();
+                percolatorService = null;
+            }
+            // Stop Bittensor mining service
+            if (bittensorService) {
+                await bittensorService.stop();
+                (0, bittensor_2.setBittensorService)(null);
+                bittensorService = null;
+            }
+            // Stop alt-data service
+            if (altDataService) {
+                altDataService.stop();
+                altDataService = null;
+            }
+            // Stop arbitrage executor
+            if (arbitrageExecutor) {
+                arbitrageExecutor.stop();
+                arbitrageExecutor = null;
+            }
+            // Stop bot manager (stops all running bots)
+            if (botManager) {
+                for (const s of botManager.getAllBotStatuses()) {
+                    if (s.status === 'running' || s.status === 'paused') {
+                        await botManager.stopBot(s.id);
+                    }
+                }
+                botManager = null;
+            }
+            tradeLogger = null;
+            strategyBuilder = null;
+            // Stop ML pipeline (before signal router, since it subscribes to router events)
+            if (mlPipeline) {
+                mlPipeline.stop();
+                mlPipeline = null;
+            }
+            // Stop position bridge (before signal router, since it subscribes to router events)
+            if (positionBridge) {
+                positionBridge.stop();
+                positionBridge = null;
+            }
+            // Stop signal router
+            if (signalRouter) {
+                signalRouter.stop();
+                signalRouter = null;
+            }
+            // Stop event flow first, then flush pending writes
+            signalBus.disconnectFeeds();
+            if (tickRecorder) {
+                await tickRecorder.stop();
+                tickRecorder = null;
+            }
+            if (tickStreamer) {
+                tickStreamer.stop();
+                tickStreamer = null;
+            }
+            // Stop realtime alerts and cleanup subscriptions
+            if (realtimeAlerts) {
+                if (whaleTrackerCleanup) {
+                    whaleTrackerCleanup();
+                    whaleTrackerCleanup = null;
+                }
+                if (opportunityFinderCleanup) {
+                    opportunityFinderCleanup();
+                    opportunityFinderCleanup = null;
+                }
+                realtimeAlerts.stop();
+                realtimeAlerts = null;
+            }
+            // Stop copy trading and whale tracker
+            if (copyTrading) {
+                copyTrading.stop();
+                copyTrading = null;
+            }
+            if (whaleTracker) {
+                whaleTracker.stop();
+                whaleTracker = null;
+            }
+            // Close execution queue producer
+            if (executionProducer) {
+                await executionProducer.close();
+                executionProducer = null;
+            }
+            await channels?.stop();
+            await feeds.stop();
+            await httpGateway.stop();
+            sessions.dispose();
+            started = false;
+            // Close DB if it exposes a close method
+            try {
+                await db.close();
+            }
+            catch (error) {
+                logger_1.logger.warn({ error }, 'Failed to close database cleanly');
+            }
+            logger_1.logger.info('Gateway stopped');
+        },
+    };
+}
+//# sourceMappingURL=index.js.map