clodds 1.1.0

package/dist/config/index.js

@@ -0,0 +1,1451 @@
+"use strict";
+/**
+ * Configuration System - Clawdbot-style config management
+ *
+ * Features:
+ * - JSON5 config file loading
+ * - Environment variable substitution
+ * - Config validation with Zod
+ * - Default values
+ * - Config paths resolution
+ * - Backup rotation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = exports.DEFAULT_GATEWAY_PORT = exports.WORKSPACE_DIR = exports.LOGS_DIR = exports.CREDENTIALS_DIR = exports.CONFIG_PATH = exports.STATE_DIR = void 0;
+exports.resolveStateDir = resolveStateDir;
+exports.resolveConfigPath = resolveConfigPath;
+exports.resolveCredentialsDir = resolveCredentialsDir;
+exports.resolveLogsDir = resolveLogsDir;
+exports.resolveWorkspaceDir = resolveWorkspaceDir;
+exports.loadConfig = loadConfig;
+exports.loadConfigSnapshot = loadConfigSnapshot;
+exports.saveConfig = saveConfig;
+exports.validateConfig = validateConfig;
+exports.createConfigService = createConfigService;
+exports.deepMerge = deepMerge;
+exports.parseJson5 = parseJson5;
+exports.substituteEnvVars = substituteEnvVars;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const logger_1 = require("../utils/logger");
+// =============================================================================
+// PATHS
+// =============================================================================
+/** Resolve ~ to home directory */
+function resolveUserPath(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return trimmed;
+    if (trimmed.startsWith('~')) {
+        return (0, path_1.resolve)(trimmed.replace(/^~(?=$|[\\/])/, (0, os_1.homedir)()));
+    }
+    return (0, path_1.resolve)(trimmed);
+}
+function readPackageVersion() {
+    if (process.env.npm_package_version) {
+        return process.env.npm_package_version;
+    }
+    try {
+        const pkgPath = (0, path_1.resolve)(__dirname, '..', '..', 'package.json');
+        const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf-8'));
+        if (pkg.version)
+            return pkg.version;
+    }
+    catch { }
+    return 'unknown';
+}
+/** State directory for mutable data */
+function resolveStateDir(env = process.env) {
+    const override = env.CLODDS_STATE_DIR?.trim();
+    if (override)
+        return resolveUserPath(override);
+    return (0, path_1.join)((0, os_1.homedir)(), '.clodds');
+}
+/** Config file path */
+function resolveConfigPath(env = process.env) {
+    const override = env.CLODDS_CONFIG_PATH?.trim();
+    if (override)
+        return resolveUserPath(override);
+    return (0, path_1.join)(resolveStateDir(env), 'clodds.json');
+}
+/** Credentials directory */
+function resolveCredentialsDir(env = process.env) {
+    return (0, path_1.join)(resolveStateDir(env), 'credentials');
+}
+/** Logs directory */
+function resolveLogsDir(env = process.env) {
+    return (0, path_1.join)(resolveStateDir(env), 'logs');
+}
+/** Workspace directory */
+function resolveWorkspaceDir(env = process.env) {
+    const override = env.CLODDS_WORKSPACE?.trim();
+    if (override)
+        return resolveUserPath(override);
+    return (0, path_1.join)((0, os_1.homedir)(), 'clodds');
+}
+exports.STATE_DIR = resolveStateDir();
+exports.CONFIG_PATH = resolveConfigPath();
+exports.CREDENTIALS_DIR = resolveCredentialsDir();
+exports.LOGS_DIR = resolveLogsDir();
+exports.WORKSPACE_DIR = resolveWorkspaceDir();
+exports.DEFAULT_GATEWAY_PORT = 18789;
+// =============================================================================
+// DEFAULTS
+// =============================================================================
+exports.DEFAULT_CONFIG = {
+    agent: {
+        model: 'claude-opus-4-6',
+        maxTokens: 4096,
+        temperature: 0.7,
+        thinkingLevel: 'medium',
+        sandbox: { mode: 'off' },
+    },
+    gateway: {
+        port: exports.DEFAULT_GATEWAY_PORT,
+        bind: 'loopback',
+        cors: false,
+        auth: { mode: 'off' },
+        tailscale: { mode: 'off' },
+    },
+    memory: {
+        auto: {
+            enabled: true,
+            scope: 'user',
+            minIntervalMs: 2 * 60 * 1000,
+            maxItemsPerType: 5,
+            profileUpdateEvery: 6,
+            semanticSearchTopK: 5,
+            includeMemoryContext: true,
+            excludeSensitive: true,
+        },
+    },
+    channels: {},
+    messages: {
+        offlineQueue: {
+            enabled: true,
+            maxSize: 200,
+            maxAgeMs: 15 * 60 * 1000,
+            retryIntervalMs: 5000,
+            maxRetries: 10,
+        },
+    },
+    feeds: {
+        polymarket: { enabled: true, rtds: { enabled: false } },
+        kalshi: { enabled: true },
+        manifold: { enabled: true },
+        metaculus: { enabled: true },
+        drift: { enabled: false },
+        news: { enabled: false },
+    },
+    solana: {},
+    browser: {
+        enabled: true,
+        headless: true,
+    },
+    tts: {
+        enabled: false,
+        provider: 'elevenlabs',
+    },
+    cron: {
+        enabled: true,
+        jobs: [],
+    },
+    plugins: {
+        enabled: true,
+        autoEnable: [],
+        disabled: [],
+    },
+    logging: {
+        level: 'info',
+        file: true,
+        json: false,
+    },
+    http: {
+        enabled: true,
+        defaultRateLimit: { maxRequests: 60, windowMs: 60_000 },
+        perHost: {},
+        retry: {
+            enabled: true,
+            maxAttempts: 3,
+            minDelay: 500,
+            maxDelay: 30_000,
+            jitter: 0.1,
+            backoffMultiplier: 2,
+            methods: ['GET', 'HEAD', 'OPTIONS'],
+        },
+    },
+    positions: {
+        enabled: true,
+        priceUpdateIntervalMs: 5 * 60 * 1000,
+        pnlSnapshotsEnabled: true,
+        pnlHistoryDays: 90,
+    },
+    monitoring: {
+        enabled: true,
+        cooldownMs: 5 * 60 * 1000,
+        alertTargets: [],
+        email: {
+            enabled: false,
+            subjectPrefix: 'Clodds',
+        },
+        providerHealth: {
+            enabled: true,
+            alertAfterFailures: 3,
+            alertOnRecovery: true,
+            cooldownMs: 10 * 60 * 1000,
+        },
+        errors: {
+            enabled: true,
+            cooldownMs: 5 * 60 * 1000,
+            includeStack: true,
+        },
+        systemHealth: {
+            enabled: false,
+            intervalMs: 60 * 1000,
+            memoryWarnPct: 85,
+            diskWarnPct: 90,
+            cooldownMs: 30 * 60 * 1000,
+        },
+    },
+    altData: {
+        enabled: true,
+        fearGreedEnabled: true,
+        fundingRatesEnabled: true,
+        redditEnabled: false,
+    },
+    signalRouter: {
+        enabled: false,
+        dryRun: true,
+    },
+    mlPipeline: {
+        enabled: false,
+    },
+    bittensor: {
+        enabled: false,
+        network: 'mainnet',
+    },
+};
+// =============================================================================
+// ENV SUBSTITUTION
+// =============================================================================
+/** Environment variables that can be used in config */
+const ENV_MAPPINGS = {
+    ANTHROPIC_API_KEY: () => { }, // Used directly by agent
+    OPENAI_API_KEY: () => { },
+    ELEVENLABS_API_KEY: (cfg) => {
+        if (cfg.tts)
+            cfg.tts.apiKey = process.env.ELEVENLABS_API_KEY;
+    },
+    TELEGRAM_BOT_TOKEN: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.telegram)
+            cfg.channels.telegram = {};
+        cfg.channels.telegram.botToken = process.env.TELEGRAM_BOT_TOKEN;
+    },
+    DISCORD_BOT_TOKEN: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.discord)
+            cfg.channels.discord = {};
+        cfg.channels.discord.token = process.env.DISCORD_BOT_TOKEN;
+    },
+    DISCORD_APP_ID: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.discord)
+            cfg.channels.discord = {};
+        cfg.channels.discord.appId = process.env.DISCORD_APP_ID;
+    },
+    WEBCHAT_TOKEN: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.webchat)
+            cfg.channels.webchat = {};
+        cfg.channels.webchat.authToken = process.env.WEBCHAT_TOKEN;
+    },
+    POSITIONS_PRICE_UPDATE_INTERVAL_MS: (cfg) => {
+        if (!cfg.positions)
+            cfg.positions = {};
+        const raw = process.env.POSITIONS_PRICE_UPDATE_INTERVAL_MS;
+        if (raw)
+            cfg.positions.priceUpdateIntervalMs = Number.parseInt(raw, 10);
+    },
+    POSITIONS_PRICE_UPDATE_ENABLED: (cfg) => {
+        if (!cfg.positions)
+            cfg.positions = {};
+        const raw = process.env.POSITIONS_PRICE_UPDATE_ENABLED;
+        if (raw)
+            cfg.positions.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    POSITIONS_PNL_SNAPSHOTS_ENABLED: (cfg) => {
+        if (!cfg.positions)
+            cfg.positions = {};
+        const raw = process.env.POSITIONS_PNL_SNAPSHOTS_ENABLED;
+        if (raw)
+            cfg.positions.pnlSnapshotsEnabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    POSITIONS_PNL_HISTORY_DAYS: (cfg) => {
+        if (!cfg.positions)
+            cfg.positions = {};
+        const raw = process.env.POSITIONS_PNL_HISTORY_DAYS;
+        if (raw)
+            cfg.positions.pnlHistoryDays = Number.parseInt(raw, 10);
+    },
+    SESSION_CLEANUP_ENABLED: (cfg) => {
+        if (!cfg.session)
+            cfg.session = {};
+        if (!cfg.session.cleanup)
+            cfg.session.cleanup = {};
+        const raw = process.env.SESSION_CLEANUP_ENABLED;
+        if (raw)
+            cfg.session.cleanup.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    SESSION_CLEANUP_MAX_AGE_DAYS: (cfg) => {
+        if (!cfg.session)
+            cfg.session = {};
+        if (!cfg.session.cleanup)
+            cfg.session.cleanup = {};
+        const raw = process.env.SESSION_CLEANUP_MAX_AGE_DAYS;
+        if (raw)
+            cfg.session.cleanup.maxAgeDays = Number.parseInt(raw, 10);
+    },
+    SESSION_CLEANUP_IDLE_DAYS: (cfg) => {
+        if (!cfg.session)
+            cfg.session = {};
+        if (!cfg.session.cleanup)
+            cfg.session.cleanup = {};
+        const raw = process.env.SESSION_CLEANUP_IDLE_DAYS;
+        if (raw)
+            cfg.session.cleanup.idleDays = Number.parseInt(raw, 10);
+    },
+    MARKET_CACHE_ENABLED: (cfg) => {
+        if (!cfg.marketCache)
+            cfg.marketCache = {};
+        const raw = process.env.MARKET_CACHE_ENABLED;
+        if (raw)
+            cfg.marketCache.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    MARKET_CACHE_TTL_MS: (cfg) => {
+        if (!cfg.marketCache)
+            cfg.marketCache = {};
+        const raw = process.env.MARKET_CACHE_TTL_MS;
+        if (raw)
+            cfg.marketCache.ttlMs = Number.parseInt(raw, 10);
+    },
+    MARKET_CACHE_CLEANUP_INTERVAL_MS: (cfg) => {
+        if (!cfg.marketCache)
+            cfg.marketCache = {};
+        const raw = process.env.MARKET_CACHE_CLEANUP_INTERVAL_MS;
+        if (raw)
+            cfg.marketCache.cleanupIntervalMs = Number.parseInt(raw, 10);
+    },
+    MARKET_INDEX_ENABLED: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_ENABLED;
+        if (raw)
+            cfg.marketIndex.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    MARKET_INDEX_SYNC_INTERVAL_MS: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_SYNC_INTERVAL_MS;
+        if (raw)
+            cfg.marketIndex.syncIntervalMs = Number.parseInt(raw, 10);
+    },
+    MARKET_INDEX_STALE_AFTER_MS: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_STALE_AFTER_MS;
+        if (raw)
+            cfg.marketIndex.staleAfterMs = Number.parseInt(raw, 10);
+    },
+    MARKET_INDEX_LIMIT_PER_PLATFORM: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_LIMIT_PER_PLATFORM;
+        if (raw)
+            cfg.marketIndex.limitPerPlatform = Number.parseInt(raw, 10);
+    },
+    MARKET_INDEX_STATUS: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_STATUS;
+        if (raw)
+            cfg.marketIndex.status = raw;
+    },
+    MARKET_INDEX_EXCLUDE_SPORTS: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_EXCLUDE_SPORTS;
+        if (raw)
+            cfg.marketIndex.excludeSports = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    MARKET_INDEX_PLATFORMS: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_PLATFORMS;
+        if (raw) {
+            cfg.marketIndex.platforms = raw
+                .split(',')
+                .map((p) => p.trim())
+                .filter(Boolean);
+        }
+    },
+    MARKET_INDEX_MIN_VOLUME_24H: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_MIN_VOLUME_24H;
+        if (raw)
+            cfg.marketIndex.minVolume24h = Number.parseFloat(raw);
+    },
+    MARKET_INDEX_MIN_LIQUIDITY: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_MIN_LIQUIDITY;
+        if (raw)
+            cfg.marketIndex.minLiquidity = Number.parseFloat(raw);
+    },
+    MARKET_INDEX_MIN_OPEN_INTEREST: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_MIN_OPEN_INTEREST;
+        if (raw)
+            cfg.marketIndex.minOpenInterest = Number.parseFloat(raw);
+    },
+    MARKET_INDEX_MIN_PREDICTIONS: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_MIN_PREDICTIONS;
+        if (raw)
+            cfg.marketIndex.minPredictions = Number.parseInt(raw, 10);
+    },
+    MARKET_INDEX_EXCLUDE_RESOLVED: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_EXCLUDE_RESOLVED;
+        if (raw)
+            cfg.marketIndex.excludeResolved = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    MARKET_INDEX_PLATFORM_WEIGHTS: (cfg) => {
+        if (!cfg.marketIndex)
+            cfg.marketIndex = {};
+        const raw = process.env.MARKET_INDEX_PLATFORM_WEIGHTS;
+        if (!raw)
+            return;
+        try {
+            const parsed = JSON.parse(raw);
+            cfg.marketIndex.platformWeights = parsed;
+        }
+        catch (error) {
+            logger_1.logger.warn({ error }, 'Failed to parse MARKET_INDEX_PLATFORM_WEIGHTS');
+        }
+    },
+    MEMORY_AUTO_ENABLED: (cfg) => {
+        if (!cfg.memory)
+            cfg.memory = {};
+        if (!cfg.memory.auto)
+            cfg.memory.auto = {};
+        const raw = process.env.MEMORY_AUTO_ENABLED;
+        if (raw)
+            cfg.memory.auto.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    MEMORY_AUTO_SCOPE: (cfg) => {
+        if (!cfg.memory)
+            cfg.memory = {};
+        if (!cfg.memory.auto)
+            cfg.memory.auto = {};
+        const raw = process.env.MEMORY_AUTO_SCOPE;
+        if (raw === 'user' || raw === 'channel')
+            cfg.memory.auto.scope = raw;
+    },
+    MEMORY_AUTO_MIN_INTERVAL_MS: (cfg) => {
+        if (!cfg.memory)
+            cfg.memory = {};
+        if (!cfg.memory.auto)
+            cfg.memory.auto = {};
+        const raw = process.env.MEMORY_AUTO_MIN_INTERVAL_MS;
+        if (raw)
+            cfg.memory.auto.minIntervalMs = Number.parseInt(raw, 10);
+    },
+    MEMORY_AUTO_MAX_ITEMS_PER_TYPE: (cfg) => {
+        if (!cfg.memory)
+            cfg.memory = {};
+        if (!cfg.memory.auto)
+            cfg.memory.auto = {};
+        const raw = process.env.MEMORY_AUTO_MAX_ITEMS_PER_TYPE;
+        if (raw)
+            cfg.memory.auto.maxItemsPerType = Number.parseInt(raw, 10);
+    },
+    MEMORY_AUTO_PROFILE_UPDATE_EVERY: (cfg) => {
+        if (!cfg.memory)
+            cfg.memory = {};
+        if (!cfg.memory.auto)
+            cfg.memory.auto = {};
+        const raw = process.env.MEMORY_AUTO_PROFILE_UPDATE_EVERY;
+        if (raw)
+            cfg.memory.auto.profileUpdateEvery = Number.parseInt(raw, 10);
+    },
+    MEMORY_AUTO_SEMANTIC_TOPK: (cfg) => {
+        if (!cfg.memory)
+            cfg.memory = {};
+        if (!cfg.memory.auto)
+            cfg.memory.auto = {};
+        const raw = process.env.MEMORY_AUTO_SEMANTIC_TOPK;
+        if (raw)
+            cfg.memory.auto.semanticSearchTopK = Number.parseInt(raw, 10);
+    },
+    MEMORY_AUTO_INCLUDE_CONTEXT: (cfg) => {
+        if (!cfg.memory)
+            cfg.memory = {};
+        if (!cfg.memory.auto)
+            cfg.memory.auto = {};
+        const raw = process.env.MEMORY_AUTO_INCLUDE_CONTEXT;
+        if (raw)
+            cfg.memory.auto.includeMemoryContext = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    MEMORY_AUTO_EXCLUDE_SENSITIVE: (cfg) => {
+        if (!cfg.memory)
+            cfg.memory = {};
+        if (!cfg.memory.auto)
+            cfg.memory.auto = {};
+        const raw = process.env.MEMORY_AUTO_EXCLUDE_SENSITIVE;
+        if (raw)
+            cfg.memory.auto.excludeSensitive = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    SLACK_BOT_TOKEN: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.slack)
+            cfg.channels.slack = {};
+        cfg.channels.slack.botToken = process.env.SLACK_BOT_TOKEN;
+    },
+    SLACK_APP_TOKEN: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.slack)
+            cfg.channels.slack = {};
+        cfg.channels.slack.appToken = process.env.SLACK_APP_TOKEN;
+    },
+    X_BEARER_TOKEN: (cfg) => {
+        if (!cfg.feeds)
+            cfg.feeds = {};
+        if (!cfg.feeds.news)
+            cfg.feeds.news = { enabled: true };
+        if (!cfg.feeds.news.twitter)
+            cfg.feeds.news.twitter = { accounts: [] };
+        cfg.feeds.news.twitter.bearerToken = process.env.X_BEARER_TOKEN;
+    },
+    TWITTER_BEARER_TOKEN: (cfg) => {
+        if (!cfg.feeds)
+            cfg.feeds = {};
+        if (!cfg.feeds.news)
+            cfg.feeds.news = { enabled: true };
+        if (!cfg.feeds.news.twitter)
+            cfg.feeds.news.twitter = { accounts: [] };
+        cfg.feeds.news.twitter.bearerToken = process.env.TWITTER_BEARER_TOKEN;
+    },
+    SOLANA_RPC_URL: (cfg) => {
+        if (!cfg.solana)
+            cfg.solana = {};
+        cfg.solana.rpcUrl = process.env.SOLANA_RPC_URL;
+    },
+    SOLANA_PRIVATE_KEY: (cfg) => {
+        if (!cfg.solana)
+            cfg.solana = {};
+        cfg.solana.privateKey = process.env.SOLANA_PRIVATE_KEY;
+    },
+    SOLANA_KEYPAIR_PATH: (cfg) => {
+        if (!cfg.solana)
+            cfg.solana = {};
+        cfg.solana.keypairPath = process.env.SOLANA_KEYPAIR_PATH;
+    },
+    TEAMS_APP_ID: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.teams)
+            cfg.channels.teams = {};
+        cfg.channels.teams.appId = process.env.TEAMS_APP_ID;
+    },
+    TEAMS_APP_PASSWORD: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.teams)
+            cfg.channels.teams = {};
+        cfg.channels.teams.appPassword = process.env.TEAMS_APP_PASSWORD;
+    },
+    MATRIX_HOMESERVER_URL: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.matrix)
+            cfg.channels.matrix = {};
+        cfg.channels.matrix.homeserverUrl = process.env.MATRIX_HOMESERVER_URL;
+    },
+    MATRIX_ACCESS_TOKEN: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.matrix)
+            cfg.channels.matrix = {};
+        cfg.channels.matrix.accessToken = process.env.MATRIX_ACCESS_TOKEN;
+    },
+    MATRIX_USER_ID: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.matrix)
+            cfg.channels.matrix = {};
+        cfg.channels.matrix.userId = process.env.MATRIX_USER_ID;
+    },
+    SIGNAL_PHONE_NUMBER: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.signal)
+            cfg.channels.signal = {};
+        cfg.channels.signal.phoneNumber = process.env.SIGNAL_PHONE_NUMBER;
+    },
+    SIGNAL_CLI_PATH: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.signal)
+            cfg.channels.signal = {};
+        cfg.channels.signal.signalCliPath = process.env.SIGNAL_CLI_PATH;
+    },
+    SIGNAL_CONFIG_DIR: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.signal)
+            cfg.channels.signal = {};
+        cfg.channels.signal.configDir = process.env.SIGNAL_CONFIG_DIR;
+    },
+    IMESSAGE_ENABLED: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.imessage)
+            cfg.channels.imessage = {};
+        cfg.channels.imessage.enabled = process.env.IMESSAGE_ENABLED === '1';
+    },
+    IMESSAGE_POLL_INTERVAL: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.imessage)
+            cfg.channels.imessage = {};
+        const value = process.env.IMESSAGE_POLL_INTERVAL;
+        if (value)
+            cfg.channels.imessage.pollInterval = Number.parseInt(value, 10);
+    },
+    LINE_CHANNEL_ACCESS_TOKEN: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.line)
+            cfg.channels.line = {};
+        cfg.channels.line.channelAccessToken = process.env.LINE_CHANNEL_ACCESS_TOKEN;
+    },
+    LINE_CHANNEL_SECRET: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.line)
+            cfg.channels.line = {};
+        cfg.channels.line.channelSecret = process.env.LINE_CHANNEL_SECRET;
+    },
+    LINE_WEBHOOK_PORT: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.line)
+            cfg.channels.line = {};
+        const value = process.env.LINE_WEBHOOK_PORT;
+        if (value)
+            cfg.channels.line.webhookPort = Number.parseInt(value, 10);
+    },
+    LINE_WEBHOOK_PATH: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.line)
+            cfg.channels.line = {};
+        cfg.channels.line.webhookPath = process.env.LINE_WEBHOOK_PATH;
+    },
+    GOOGLECHAT_CREDENTIALS_PATH: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.googlechat)
+            cfg.channels.googlechat = {};
+        cfg.channels.googlechat.credentialsPath = process.env.GOOGLECHAT_CREDENTIALS_PATH;
+    },
+    GOOGLECHAT_CLIENT_EMAIL: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.googlechat)
+            cfg.channels.googlechat = {};
+        if (!cfg.channels.googlechat.credentials)
+            cfg.channels.googlechat.credentials = {
+                client_email: '',
+                private_key: '',
+                project_id: '',
+            };
+        cfg.channels.googlechat.credentials.client_email = process.env.GOOGLECHAT_CLIENT_EMAIL || '';
+    },
+    GOOGLECHAT_PRIVATE_KEY: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.googlechat)
+            cfg.channels.googlechat = {};
+        if (!cfg.channels.googlechat.credentials)
+            cfg.channels.googlechat.credentials = {
+                client_email: '',
+                private_key: '',
+                project_id: '',
+            };
+        cfg.channels.googlechat.credentials.private_key = process.env.GOOGLECHAT_PRIVATE_KEY || '';
+    },
+    GOOGLECHAT_PROJECT_ID: (cfg) => {
+        if (!cfg.channels)
+            cfg.channels = {};
+        if (!cfg.channels.googlechat)
+            cfg.channels.googlechat = {};
+        if (!cfg.channels.googlechat.credentials)
+            cfg.channels.googlechat.credentials = {
+                client_email: '',
+                private_key: '',
+                project_id: '',
+            };
+        cfg.channels.googlechat.credentials.project_id = process.env.GOOGLECHAT_PROJECT_ID || '';
+    },
+    CLODDS_GATEWAY_TOKEN: (cfg) => {
+        if (!cfg.gateway)
+            cfg.gateway = {};
+        if (!cfg.gateway.auth)
+            cfg.gateway.auth = {};
+        cfg.gateway.auth.token = process.env.CLODDS_GATEWAY_TOKEN;
+        cfg.gateway.auth.mode = 'token';
+    },
+    CLODDS_GATEWAY_PASSWORD: (cfg) => {
+        if (!cfg.gateway)
+            cfg.gateway = {};
+        if (!cfg.gateway.auth)
+            cfg.gateway.auth = {};
+        cfg.gateway.auth.password = process.env.CLODDS_GATEWAY_PASSWORD;
+        cfg.gateway.auth.mode = 'password';
+    },
+    BITTENSOR_ENABLED: (cfg) => {
+        if (!cfg.bittensor)
+            cfg.bittensor = {};
+        const raw = process.env.BITTENSOR_ENABLED;
+        if (raw)
+            cfg.bittensor.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    BITTENSOR_NETWORK: (cfg) => {
+        if (!cfg.bittensor)
+            cfg.bittensor = {};
+        const raw = process.env.BITTENSOR_NETWORK;
+        if (raw === 'mainnet' || raw === 'testnet' || raw === 'local')
+            cfg.bittensor.network = raw;
+    },
+    BITTENSOR_SUBTENSOR_URL: (cfg) => {
+        if (!cfg.bittensor)
+            cfg.bittensor = {};
+        const raw = process.env.BITTENSOR_SUBTENSOR_URL;
+        if (raw)
+            cfg.bittensor.subtensorUrl = raw;
+    },
+    BITTENSOR_COLDKEY_PATH: (cfg) => {
+        if (!cfg.bittensor)
+            cfg.bittensor = {};
+        const raw = process.env.BITTENSOR_COLDKEY_PATH;
+        if (raw)
+            cfg.bittensor.coldkeyPath = raw;
+    },
+    BITTENSOR_COLDKEY_PASSWORD: (cfg) => {
+        if (!cfg.bittensor)
+            cfg.bittensor = {};
+        const raw = process.env.BITTENSOR_COLDKEY_PASSWORD;
+        if (raw)
+            cfg.bittensor.coldkeyPassword = raw;
+    },
+    BITTENSOR_PYTHON_PATH: (cfg) => {
+        if (!cfg.bittensor)
+            cfg.bittensor = {};
+        const raw = process.env.BITTENSOR_PYTHON_PATH;
+        if (raw)
+            cfg.bittensor.pythonPath = raw;
+    },
+    BITTENSOR_EARNINGS_POLL_INTERVAL_MS: (cfg) => {
+        if (!cfg.bittensor)
+            cfg.bittensor = {};
+        const raw = process.env.BITTENSOR_EARNINGS_POLL_INTERVAL_MS;
+        if (raw)
+            cfg.bittensor.earningsPollIntervalMs = Number.parseInt(raw, 10);
+    },
+    BITTENSOR_TAO_PRICE_USD: (cfg) => {
+        if (!cfg.bittensor)
+            cfg.bittensor = {};
+        const raw = process.env.BITTENSOR_TAO_PRICE_USD;
+        if (raw)
+            cfg.bittensor.taoPriceUsd = Number.parseFloat(raw);
+    },
+    ALT_DATA_ENABLED: (cfg) => {
+        if (!cfg.altData)
+            cfg.altData = {};
+        const raw = process.env.ALT_DATA_ENABLED;
+        if (raw)
+            cfg.altData.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    ALT_DATA_MIN_SENTIMENT_CONFIDENCE: (cfg) => {
+        if (!cfg.altData)
+            cfg.altData = {};
+        const raw = process.env.ALT_DATA_MIN_SENTIMENT_CONFIDENCE;
+        if (raw)
+            cfg.altData.minSentimentConfidence = Number.parseFloat(raw);
+    },
+    ALT_DATA_MIN_MARKET_RELEVANCE: (cfg) => {
+        if (!cfg.altData)
+            cfg.altData = {};
+        const raw = process.env.ALT_DATA_MIN_MARKET_RELEVANCE;
+        if (raw)
+            cfg.altData.minMarketRelevance = Number.parseFloat(raw);
+    },
+    ALT_DATA_FEAR_GREED_ENABLED: (cfg) => {
+        if (!cfg.altData)
+            cfg.altData = {};
+        const raw = process.env.ALT_DATA_FEAR_GREED_ENABLED;
+        if (raw)
+            cfg.altData.fearGreedEnabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    ALT_DATA_FUNDING_RATES_ENABLED: (cfg) => {
+        if (!cfg.altData)
+            cfg.altData = {};
+        const raw = process.env.ALT_DATA_FUNDING_RATES_ENABLED;
+        if (raw)
+            cfg.altData.fundingRatesEnabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    ALT_DATA_REDDIT_ENABLED: (cfg) => {
+        if (!cfg.altData)
+            cfg.altData = {};
+        const raw = process.env.ALT_DATA_REDDIT_ENABLED;
+        if (raw)
+            cfg.altData.redditEnabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    ALT_DATA_REDDIT_SUBREDDITS: (cfg) => {
+        if (!cfg.altData)
+            cfg.altData = {};
+        const raw = process.env.ALT_DATA_REDDIT_SUBREDDITS;
+        if (raw)
+            cfg.altData.redditSubreddits = raw.split(',').map((s) => s.trim()).filter(Boolean);
+    },
+    SIGNAL_ROUTER_ENABLED: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_ENABLED;
+        if (raw)
+            cfg.signalRouter.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    SIGNAL_ROUTER_DRY_RUN: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_DRY_RUN;
+        if (raw)
+            cfg.signalRouter.dryRun = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    SIGNAL_ROUTER_MIN_STRENGTH: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_MIN_STRENGTH;
+        if (raw)
+            cfg.signalRouter.minStrength = parseFloat(raw);
+    },
+    SIGNAL_ROUTER_DEFAULT_SIZE_USD: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_DEFAULT_SIZE_USD;
+        if (raw)
+            cfg.signalRouter.defaultSizeUsd = parseInt(raw, 10);
+    },
+    SIGNAL_ROUTER_MAX_SIZE_USD: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_MAX_SIZE_USD;
+        if (raw)
+            cfg.signalRouter.maxSizeUsd = parseInt(raw, 10);
+    },
+    SIGNAL_ROUTER_MAX_DAILY_LOSS: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_MAX_DAILY_LOSS;
+        if (raw)
+            cfg.signalRouter.maxDailyLoss = parseInt(raw, 10);
+    },
+    SIGNAL_ROUTER_MAX_CONCURRENT_POSITIONS: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_MAX_CONCURRENT_POSITIONS;
+        if (raw)
+            cfg.signalRouter.maxConcurrentPositions = parseInt(raw, 10);
+    },
+    SIGNAL_ROUTER_COOLDOWN_MS: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_COOLDOWN_MS;
+        if (raw)
+            cfg.signalRouter.cooldownMs = parseInt(raw, 10);
+    },
+    SIGNAL_ROUTER_ORDER_MODE: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_ORDER_MODE;
+        if (raw && ['maker', 'limit', 'market'].includes(raw)) {
+            cfg.signalRouter.orderMode = raw;
+        }
+    },
+    SIGNAL_ROUTER_SIGNAL_TYPES: (cfg) => {
+        if (!cfg.signalRouter)
+            cfg.signalRouter = {};
+        const raw = process.env.SIGNAL_ROUTER_SIGNAL_TYPES;
+        if (raw)
+            cfg.signalRouter.signalTypes = raw.split(',').map((s) => s.trim()).filter(Boolean);
+    },
+    ML_PIPELINE_ENABLED: (cfg) => {
+        if (!cfg.mlPipeline)
+            cfg.mlPipeline = {};
+        const raw = process.env.ML_PIPELINE_ENABLED;
+        if (raw)
+            cfg.mlPipeline.enabled = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    ML_PIPELINE_OUTCOME_HORIZON: (cfg) => {
+        if (!cfg.mlPipeline)
+            cfg.mlPipeline = {};
+        const raw = process.env.ML_PIPELINE_OUTCOME_HORIZON;
+        if (raw && ['1h', '4h', '24h'].includes(raw)) {
+            cfg.mlPipeline.outcomeHorizon = raw;
+        }
+    },
+    ML_PIPELINE_TRAIN_INTERVAL_MS: (cfg) => {
+        if (!cfg.mlPipeline)
+            cfg.mlPipeline = {};
+        const raw = process.env.ML_PIPELINE_TRAIN_INTERVAL_MS;
+        if (raw)
+            cfg.mlPipeline.trainIntervalMs = parseInt(raw, 10);
+    },
+    ML_PIPELINE_MIN_SAMPLES: (cfg) => {
+        if (!cfg.mlPipeline)
+            cfg.mlPipeline = {};
+        const raw = process.env.ML_PIPELINE_MIN_SAMPLES;
+        if (raw)
+            cfg.mlPipeline.minTrainingSamples = parseInt(raw, 10);
+    },
+    ML_PIPELINE_MODEL_TYPE: (cfg) => {
+        if (!cfg.mlPipeline)
+            cfg.mlPipeline = {};
+        const raw = process.env.ML_PIPELINE_MODEL_TYPE;
+        if (raw && ['simple', 'xgboost_python'].includes(raw)) {
+            cfg.mlPipeline.modelType = raw;
+        }
+    },
+    ML_PIPELINE_USE_ML_CONFIDENCE: (cfg) => {
+        if (!cfg.mlPipeline)
+            cfg.mlPipeline = {};
+        const raw = process.env.ML_PIPELINE_USE_ML_CONFIDENCE;
+        if (raw)
+            cfg.mlPipeline.useMLConfidence = raw === '1' || raw.toLowerCase() === 'true';
+    },
+    ML_PIPELINE_CLEANUP_DAYS: (cfg) => {
+        if (!cfg.mlPipeline)
+            cfg.mlPipeline = {};
+        const raw = process.env.ML_PIPELINE_CLEANUP_DAYS;
+        if (raw)
+            cfg.mlPipeline.cleanupDays = parseInt(raw, 10);
+    },
+    CLODDS_GROUP_POLICIES: (cfg) => {
+        if (!process.env.CLODDS_GROUP_POLICIES)
+            return;
+        try {
+            const parsed = JSON.parse(process.env.CLODDS_GROUP_POLICIES);
+            if (!cfg.channels)
+                cfg.channels = {};
+            for (const [channel, value] of Object.entries(parsed)) {
+                if (!value || typeof value !== 'object')
+                    continue;
+                const channelConfig = cfg.channels[channel] || {};
+                channelConfig.groups = value;
+                cfg.channels[channel] = channelConfig;
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn({ error }, 'Failed to parse CLODDS_GROUP_POLICIES');
+        }
+    },
+};
+/** Apply environment variable overrides */
+function applyEnvOverrides(cfg) {
+    for (const [envKey, applier] of Object.entries(ENV_MAPPINGS)) {
+        if (process.env[envKey]) {
+            applier(cfg);
+        }
+    }
+    return cfg;
+}
+/** Substitute ${VAR} patterns in config values */
+function substituteEnvVars(obj) {
+    if (typeof obj === 'string') {
+        return obj.replace(/\$\{(\w+)\}/g, (_, varName) => {
+            const value = process.env[varName];
+            if (value === undefined) {
+                logger_1.logger.warn({ varName }, 'Missing environment variable in config');
+                return '';
+            }
+            return value;
+        });
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(substituteEnvVars);
+    }
+    if (obj && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = substituteEnvVars(value);
+        }
+        return result;
+    }
+    return obj;
+}
+// =============================================================================
+// LOADING
+// =============================================================================
+/** Parse JSON5 (with comments, trailing commas) */
+function parseJson5(text) {
+    // Simple JSON5 parser - handle comments and trailing commas
+    let cleaned = text
+        .replace(/\/\*[\s\S]*?\*\//g, '') // Block comments
+        .replace(/\/\/.*$/gm, '') // Line comments
+        .replace(/,(\s*[}\]])/g, '$1'); // Trailing commas
+    // Handle unquoted keys
+    cleaned = cleaned.replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:');
+    try {
+        return JSON.parse(cleaned);
+    }
+    catch {
+        // Fall back to strict JSON
+        return JSON.parse(text);
+    }
+}
+/** Deep merge configs */
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const sourceVal = source[key];
+        const targetVal = target[key];
+        if (sourceVal && typeof sourceVal === 'object' && !Array.isArray(sourceVal)) {
+            if (targetVal && typeof targetVal === 'object' && !Array.isArray(targetVal)) {
+                result[key] = { ...targetVal, ...sourceVal };
+            }
+            else {
+                result[key] = sourceVal;
+            }
+        }
+        else if (sourceVal !== undefined) {
+            result[key] = sourceVal;
+        }
+    }
+    return result;
+}
+/** Load config from file */
+function loadConfig(configPath = exports.CONFIG_PATH) {
+    let userConfig = {};
+    // Ensure state dir exists
+    const stateDir = resolveStateDir();
+    if (!(0, fs_1.existsSync)(stateDir)) {
+        (0, fs_1.mkdirSync)(stateDir, { recursive: true });
+    }
+    // Load config file if exists
+    if ((0, fs_1.existsSync)(configPath)) {
+        try {
+            const raw = (0, fs_1.readFileSync)(configPath, 'utf-8');
+            const parsed = parseJson5(raw);
+            userConfig = (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                ? parsed
+                : {};
+            logger_1.logger.debug({ configPath }, 'Config loaded');
+        }
+        catch (error) {
+            logger_1.logger.error({ configPath, error }, 'Failed to load config');
+        }
+    }
+    // Substitute env vars in config values
+    userConfig = substituteEnvVars(userConfig);
+    // Merge with defaults
+    let config = deepMerge(exports.DEFAULT_CONFIG, userConfig);
+    // Apply environment overrides
+    config = applyEnvOverrides(config);
+    return config;
+}
+/** Load config and return raw snapshot */
+function loadConfigSnapshot(configPath = exports.CONFIG_PATH) {
+    let raw = null;
+    if ((0, fs_1.existsSync)(configPath)) {
+        raw = (0, fs_1.readFileSync)(configPath, 'utf-8');
+    }
+    const config = loadConfig(configPath);
+    const hash = (0, crypto_1.createHash)('sha256').update(raw || '').digest('hex');
+    return { config, raw, hash };
+}
+// =============================================================================
+// SAVING
+// =============================================================================
+const CONFIG_BACKUP_COUNT = 5;
+/** Rotate config backups */
+function rotateBackups(configPath) {
+    const backupBase = `${configPath}.bak`;
+    // Delete oldest
+    try {
+        (0, fs_1.unlinkSync)(`${backupBase}.${CONFIG_BACKUP_COUNT - 1}`);
+    }
+    catch { }
+    // Shift backups
+    for (let i = CONFIG_BACKUP_COUNT - 2; i >= 1; i--) {
+        try {
+            (0, fs_1.renameSync)(`${backupBase}.${i}`, `${backupBase}.${i + 1}`);
+        }
+        catch { }
+    }
+    // Move current backup
+    try {
+        (0, fs_1.renameSync)(backupBase, `${backupBase}.1`);
+    }
+    catch { }
+}
+/** Save config to file */
+function saveConfig(config, configPath = exports.CONFIG_PATH) {
+    // Ensure directory exists
+    const dir = (0, path_1.resolve)(configPath, '..');
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    // Backup existing config
+    if ((0, fs_1.existsSync)(configPath)) {
+        try {
+            const existing = (0, fs_1.readFileSync)(configPath, 'utf-8');
+            (0, fs_1.writeFileSync)(`${configPath}.bak`, existing);
+            rotateBackups(configPath);
+        }
+        catch { }
+    }
+    // Stamp version
+    const stamped = {
+        ...config,
+        meta: {
+            ...config.meta,
+            lastTouchedVersion: readPackageVersion(),
+            lastTouchedAt: new Date().toISOString(),
+        },
+    };
+    // Write config
+    const content = JSON.stringify(stamped, null, 2);
+    (0, fs_1.writeFileSync)(configPath, content, 'utf-8');
+    logger_1.logger.info({ configPath }, 'Config saved');
+}
+/** Validate config structure */
+function validateConfig(config) {
+    const errors = [];
+    const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+    const whatsappPolicies = ['open', 'allowlist', 'pairing', 'disabled'];
+    const validateAllowFrom = (path, allowFrom) => {
+        if (!Array.isArray(allowFrom)) {
+            errors.push({ path, message: 'allowFrom must be an array of strings' });
+            return;
+        }
+        allowFrom.forEach((entry, idx) => {
+            if (typeof entry !== 'string') {
+                errors.push({ path: `${path}[${idx}]`, message: 'allowFrom entries must be strings' });
+            }
+        });
+    };
+    const validateGroups = (path, groups) => {
+        if (!isRecord(groups)) {
+            errors.push({ path, message: 'groups must be an object' });
+            return;
+        }
+        for (const [groupId, groupConfig] of Object.entries(groups)) {
+            const groupPath = `${path}.${groupId}`;
+            if (!isRecord(groupConfig)) {
+                errors.push({ path: groupPath, message: 'group config must be an object' });
+                continue;
+            }
+            if (groupConfig.requireMention !== undefined &&
+                typeof groupConfig.requireMention !== 'boolean') {
+                errors.push({
+                    path: `${groupPath}.requireMention`,
+                    message: 'requireMention must be a boolean',
+                });
+            }
+        }
+    };
+    // Validate gateway
+    if (config.gateway?.port !== undefined) {
+        if (typeof config.gateway.port !== 'number' || config.gateway.port < 1 || config.gateway.port > 65535) {
+            errors.push({ path: 'gateway.port', message: 'Port must be a number between 1 and 65535' });
+        }
+    }
+    if (config.gateway?.bind && !['loopback', 'all'].includes(config.gateway.bind)) {
+        errors.push({ path: 'gateway.bind', message: 'Bind must be "loopback" or "all"' });
+    }
+    // Validate agent
+    if (config.agent?.thinkingLevel && !['off', 'minimal', 'low', 'medium', 'high'].includes(config.agent.thinkingLevel)) {
+        errors.push({ path: 'agent.thinkingLevel', message: 'Invalid thinking level' });
+    }
+    // Validate logging
+    if (config.logging?.level && !['debug', 'info', 'warn', 'error'].includes(config.logging.level)) {
+        errors.push({ path: 'logging.level', message: 'Invalid log level' });
+    }
+    // Validate WhatsApp channel config
+    const whatsapp = config.channels?.whatsapp;
+    if (whatsapp) {
+        if (whatsapp.dmPolicy && !whatsappPolicies.includes(whatsapp.dmPolicy)) {
+            errors.push({ path: 'channels.whatsapp.dmPolicy', message: 'Invalid dmPolicy value' });
+        }
+        if (whatsapp.allowFrom !== undefined) {
+            validateAllowFrom('channels.whatsapp.allowFrom', whatsapp.allowFrom);
+        }
+        if (whatsapp.requireMentionInGroups !== undefined &&
+            typeof whatsapp.requireMentionInGroups !== 'boolean') {
+            errors.push({
+                path: 'channels.whatsapp.requireMentionInGroups',
+                message: 'requireMentionInGroups must be a boolean',
+            });
+        }
+        if (whatsapp.groups !== undefined) {
+            validateGroups('channels.whatsapp.groups', whatsapp.groups);
+        }
+        if (whatsapp.accounts !== undefined) {
+            if (!isRecord(whatsapp.accounts)) {
+                errors.push({ path: 'channels.whatsapp.accounts', message: 'accounts must be an object' });
+            }
+            else {
+                for (const [accountId, accountConfig] of Object.entries(whatsapp.accounts)) {
+                    const accountPath = `channels.whatsapp.accounts.${accountId}`;
+                    if (!isRecord(accountConfig)) {
+                        errors.push({ path: accountPath, message: 'account config must be an object' });
+                        continue;
+                    }
+                    if (accountConfig.dmPolicy && !whatsappPolicies.includes(accountConfig.dmPolicy)) {
+                        errors.push({ path: `${accountPath}.dmPolicy`, message: 'Invalid dmPolicy value' });
+                    }
+                    if (accountConfig.allowFrom !== undefined) {
+                        validateAllowFrom(`${accountPath}.allowFrom`, accountConfig.allowFrom);
+                    }
+                    if (accountConfig.requireMentionInGroups !== undefined &&
+                        typeof accountConfig.requireMentionInGroups !== 'boolean') {
+                        errors.push({
+                            path: `${accountPath}.requireMentionInGroups`,
+                            message: 'requireMentionInGroups must be a boolean',
+                        });
+                    }
+                    if (accountConfig.groups !== undefined) {
+                        validateGroups(`${accountPath}.groups`, accountConfig.groups);
+                    }
+                }
+            }
+        }
+        if (whatsapp.defaultAccountId !== undefined) {
+            const accounts = whatsapp.accounts;
+            if (!accounts || !isRecord(accounts) || !accounts[whatsapp.defaultAccountId]) {
+                errors.push({
+                    path: 'channels.whatsapp.defaultAccountId',
+                    message: 'defaultAccountId must reference an account in channels.whatsapp.accounts',
+                });
+            }
+            else if (isRecord(accounts[whatsapp.defaultAccountId]) &&
+                accounts[whatsapp.defaultAccountId].enabled === false) {
+                errors.push({
+                    path: 'channels.whatsapp.defaultAccountId',
+                    message: 'defaultAccountId references a disabled account',
+                });
+            }
+        }
+    }
+    // Validate feeds (RTDS)
+    const rtds = config.feeds?.polymarket?.rtds;
+    if (rtds) {
+        if (rtds.enabled && config.feeds?.polymarket?.enabled === false) {
+            errors.push({
+                path: 'feeds.polymarket.rtds.enabled',
+                message: 'RTDS requires feeds.polymarket.enabled to be true',
+            });
+        }
+        if (rtds.url !== undefined && typeof rtds.url !== 'string') {
+            errors.push({ path: 'feeds.polymarket.rtds.url', message: 'RTDS url must be a string' });
+        }
+        if (rtds.pingIntervalMs !== undefined) {
+            if (typeof rtds.pingIntervalMs !== 'number' || rtds.pingIntervalMs <= 0) {
+                errors.push({
+                    path: 'feeds.polymarket.rtds.pingIntervalMs',
+                    message: 'RTDS pingIntervalMs must be a positive number',
+                });
+            }
+        }
+        if (rtds.reconnectDelayMs !== undefined) {
+            if (typeof rtds.reconnectDelayMs !== 'number' || rtds.reconnectDelayMs <= 0) {
+                errors.push({
+                    path: 'feeds.polymarket.rtds.reconnectDelayMs',
+                    message: 'RTDS reconnectDelayMs must be a positive number',
+                });
+            }
+        }
+        if (rtds.subscriptions !== undefined) {
+            if (!Array.isArray(rtds.subscriptions)) {
+                errors.push({
+                    path: 'feeds.polymarket.rtds.subscriptions',
+                    message: 'RTDS subscriptions must be an array',
+                });
+            }
+            else {
+                const allowedTopics = ['crypto_prices', 'crypto_prices_chainlink', 'comments'];
+                rtds.subscriptions.forEach((sub, idx) => {
+                    if (!sub || typeof sub !== 'object') {
+                        errors.push({
+                            path: `feeds.polymarket.rtds.subscriptions[${idx}]`,
+                            message: 'Subscription must be an object',
+                        });
+                        return;
+                    }
+                    if (!allowedTopics.includes(sub.topic)) {
+                        errors.push({
+                            path: `feeds.polymarket.rtds.subscriptions[${idx}].topic`,
+                            message: 'Invalid RTDS topic',
+                        });
+                    }
+                    if (typeof sub.type !== 'string' || sub.type.length === 0) {
+                        errors.push({
+                            path: `feeds.polymarket.rtds.subscriptions[${idx}].type`,
+                            message: 'Subscription type must be a non-empty string',
+                        });
+                    }
+                    if (sub.filters !== undefined && typeof sub.filters !== 'string') {
+                        errors.push({
+                            path: `feeds.polymarket.rtds.subscriptions[${idx}].filters`,
+                            message: 'Subscription filters must be a string',
+                        });
+                    }
+                    if (sub.gammaAuthAddress !== undefined && typeof sub.gammaAuthAddress !== 'string') {
+                        errors.push({
+                            path: `feeds.polymarket.rtds.subscriptions[${idx}].gammaAuthAddress`,
+                            message: 'gammaAuthAddress must be a string',
+                        });
+                    }
+                    if (sub.clobAuth !== undefined) {
+                        if (typeof sub.clobAuth !== 'object' || sub.clobAuth === null) {
+                            errors.push({
+                                path: `feeds.polymarket.rtds.subscriptions[${idx}].clobAuth`,
+                                message: 'clobAuth must be an object',
+                            });
+                        }
+                        else {
+                            if (typeof sub.clobAuth.key !== 'string' || sub.clobAuth.key.length === 0) {
+                                errors.push({
+                                    path: `feeds.polymarket.rtds.subscriptions[${idx}].clobAuth.key`,
+                                    message: 'clobAuth.key must be a non-empty string',
+                                });
+                            }
+                            if (typeof sub.clobAuth.secret !== 'string' || sub.clobAuth.secret.length === 0) {
+                                errors.push({
+                                    path: `feeds.polymarket.rtds.subscriptions[${idx}].clobAuth.secret`,
+                                    message: 'clobAuth.secret must be a non-empty string',
+                                });
+                            }
+                            if (typeof sub.clobAuth.passphrase !== 'string' || sub.clobAuth.passphrase.length === 0) {
+                                errors.push({
+                                    path: `feeds.polymarket.rtds.subscriptions[${idx}].clobAuth.passphrase`,
+                                    message: 'clobAuth.passphrase must be a non-empty string',
+                                });
+                            }
+                        }
+                    }
+                });
+            }
+        }
+    }
+    // Validate Kalshi feed auth config
+    const kalshi = config.feeds?.kalshi;
+    if (kalshi?.enabled) {
+        const hasApiKey = Boolean(kalshi.apiKeyId);
+        const hasPrivateKey = Boolean(kalshi.privateKeyPem || kalshi.privateKeyPath);
+        const hasLegacy = Boolean(kalshi.email || kalshi.password);
+        if (hasApiKey && !hasPrivateKey) {
+            errors.push({
+                path: 'feeds.kalshi.privateKeyPem',
+                message: 'Kalshi API key auth requires privateKeyPem or privateKeyPath',
+            });
+        }
+        if ((kalshi.privateKeyPem || kalshi.privateKeyPath) && !hasApiKey) {
+            errors.push({
+                path: 'feeds.kalshi.apiKeyId',
+                message: 'Kalshi private key requires apiKeyId',
+            });
+        }
+        if (hasLegacy && !(kalshi.email && kalshi.password)) {
+            errors.push({
+                path: 'feeds.kalshi.email',
+                message: 'Legacy Kalshi auth requires both email and password',
+            });
+        }
+    }
+    return errors;
+}
+function createConfigService(configPath = exports.CONFIG_PATH) {
+    let { config, hash } = loadConfigSnapshot(configPath);
+    const watchers = [];
+    return {
+        get() {
+            return config;
+        },
+        getValue(path) {
+            const parts = path.split('.');
+            let current = config;
+            for (const part of parts) {
+                if (current && typeof current === 'object') {
+                    current = current[part];
+                }
+                else {
+                    return undefined;
+                }
+            }
+            return current;
+        },
+        setValue(path, value) {
+            const parts = path.split('.');
+            let current = config;
+            for (let i = 0; i < parts.length - 1; i++) {
+                const part = parts[i];
+                const obj = current;
+                if (!obj[part] || typeof obj[part] !== 'object') {
+                    obj[part] = {};
+                }
+                current = obj[part];
+            }
+            current[parts[parts.length - 1]] = value;
+        },
+        reload() {
+            const snapshot = loadConfigSnapshot(configPath);
+            config = snapshot.config;
+            hash = snapshot.hash;
+            for (const watcher of watchers) {
+                watcher(config);
+            }
+            return config;
+        },
+        save() {
+            saveConfig(config, configPath);
+            hash = (0, crypto_1.createHash)('sha256').update(JSON.stringify(config)).digest('hex');
+        },
+        getHash() {
+            return hash;
+        },
+        watch(callback) {
+            watchers.push(callback);
+            return () => {
+                const idx = watchers.indexOf(callback);
+                if (idx >= 0)
+                    watchers.splice(idx, 1);
+            };
+        },
+    };
+}
+//# sourceMappingURL=index.js.map