@hybridaione/hybridclaw 0.2.3 → 0.2.7

package/dist/runtime-config.js

@@ -1,9 +1,17 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
 export const CONFIG_FILE_NAME = 'config.json';
-export const CONFIG_VERSION = 3;
+export const CONFIG_VERSION = 5;
 export const SECURITY_POLICY_VERSION = '2026-02-28';
-const KNOWN_LOG_LEVELS = new Set(['fatal', 'error', 'warn', 'info', 'debug', 'trace', 'silent']);
+const KNOWN_LOG_LEVELS = new Set([
+    'fatal',
+    'error',
+    'warn',
+    'info',
+    'debug',
+    'trace',
+    'silent',
+]);
 const DEFAULT_RUNTIME_CONFIG = {
     version: CONFIG_VERSION,
     security: {
@@ -21,12 +29,54 @@ const DEFAULT_RUNTIME_CONFIG = {
         presenceIntent: false,
         respondToAllMessages: false,
         commandsOnly: false,
+        commandMode: 'public',
+        commandAllowedUserIds: [],
         commandUserId: '',
+        groupPolicy: 'open',
+        freeResponseChannels: [],
+        textChunkLimit: 2_000,
+        maxLinesPerMessage: 17,
+        humanDelay: {
+            mode: 'natural',
+            minMs: 800,
+            maxMs: 2_500,
+        },
+        typingMode: 'thinking',
+        presence: {
+            enabled: true,
+            intervalMs: 30_000,
+            healthyText: 'Watching the channels',
+            degradedText: 'Thinking slowly...',
+            exhaustedText: 'Taking a break',
+            activityType: 'watching',
+        },
+        lifecycleReactions: {
+            enabled: true,
+            removeOnComplete: true,
+            phases: {
+                queued: '⏳',
+                thinking: '🤔',
+                toolUse: '⚙️',
+                streaming: '✍️',
+                done: '✅',
+                error: '❌',
+            },
+        },
+        ackReaction: '👀',
+        ackReactionScope: 'group-mentions',
+        removeAckAfterReply: true,
+        debounceMs: 2_500,
+        rateLimitPerUser: 0,
+        rateLimitExemptRoles: [],
+        suppressPatterns: ['/stop', '/pause', 'brb', 'afk'],
+        maxConcurrentPerChannel: 2,
+        guilds: {},
     },
     hybridai: {
         baseUrl: 'https://hybridai.one',
         defaultModel: 'gpt-5-nano',
         defaultChatbotId: '',
+        maxTokens: 4_096,
         enableRag: true,
         models: ['gpt-5-nano', 'gpt-5-mini', 'gpt-5'],
     },
@@ -44,6 +94,10 @@ const DEFAULT_RUNTIME_CONFIG = {
         intervalMs: 1_800_000,
         channel: '',
     },
+    memory: {
+        decayRate: 0.1,
+        consolidationIntervalHours: 24,
+    },
     ops: {
         healthHost: '127.0.0.1',
         healthPort: 9090,
@@ -67,7 +121,9 @@ const DEFAULT_RUNTIME_CONFIG = {
     },
     sessionCompaction: {
         enabled: true,
-        threshold: 120,
+        tokenBudget: 100_000,
+        budgetRatio: 0.7,
+        threshold: 200,
         keepRecent: 40,
         summaryMaxChars: 8_000,
         preCompactionMemoryFlush: {
@@ -106,6 +162,9 @@ const DEFAULT_RUNTIME_CONFIG = {
             maxIterations: 0,
         },
     },
+    scheduler: {
+        jobs: [],
+    },
 };
 const CONFIG_PATH = path.join(process.cwd(), CONFIG_FILE_NAME);
 let currentConfig = cloneConfig(DEFAULT_RUNTIME_CONFIG);
@@ -164,6 +223,25 @@ function normalizeInteger(value, fallback, opts) {
         parsed = opts.max;
     return parsed;
 }
+function normalizeNumber(value, fallback, opts) {
+    let parsed;
+    if (typeof value === 'number') {
+        parsed = value;
+    }
+    else if (typeof value === 'string' && value.trim()) {
+        parsed = Number.parseFloat(value);
+    }
+    else {
+        parsed = fallback;
+    }
+    if (!Number.isFinite(parsed))
+        parsed = fallback;
+    if (opts?.min != null && parsed < opts.min)
+        parsed = opts.min;
+    if (opts?.max != null && parsed > opts.max)
+        parsed = opts.max;
+    return parsed;
+}
 function normalizeStringArray(value, fallback) {
     if (Array.isArray(value)) {
         const normalized = value
@@ -182,8 +260,346 @@ function normalizeStringArray(value, fallback) {
     }
     return fallback;
 }
+function normalizeDiscordGroupPolicy(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'open' ||
+        normalized === 'allowlist' ||
+        normalized === 'disabled') {
+        return normalized;
+    }
+    return fallback;
+}
+function normalizeDiscordCommandMode(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'public' || normalized === 'restricted') {
+        return normalized;
+    }
+    return fallback;
+}
+function normalizeDiscordChannelMode(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'off' || normalized === 'mention' || normalized === 'free')
+        return normalized;
+    if (normalized === 'free-response' || normalized === 'free_response')
+        return 'free';
+    return fallback;
+}
+function normalizeDiscordTypingMode(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'instant' ||
+        normalized === 'thinking' ||
+        normalized === 'streaming' ||
+        normalized === 'never') {
+        return normalized;
+    }
+    return fallback;
+}
+function normalizeDiscordHumanDelayMode(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'off' ||
+        normalized === 'natural' ||
+        normalized === 'custom') {
+        return normalized;
+    }
+    return fallback;
+}
+function normalizeDiscordAckReactionScope(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'all' ||
+        normalized === 'group-mentions' ||
+        normalized === 'direct' ||
+        normalized === 'off') {
+        return normalized;
+    }
+    return fallback;
+}
+function normalizeDiscordPresenceActivityType(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'playing' ||
+        normalized === 'watching' ||
+        normalized === 'listening' ||
+        normalized === 'competing' ||
+        normalized === 'custom') {
+        return normalized;
+    }
+    return fallback;
+}
+function normalizeDiscordHumanDelayConfig(value, fallback) {
+    const raw = isRecord(value) ? value : {};
+    const mode = normalizeDiscordHumanDelayMode(raw.mode, fallback.mode);
+    const minMs = normalizeInteger(raw.minMs, fallback.minMs, {
+        min: 0,
+        max: 120_000,
+    });
+    const maxMsRaw = normalizeInteger(raw.maxMs, fallback.maxMs, {
+        min: 0,
+        max: 120_000,
+    });
+    const maxMs = Math.max(minMs, maxMsRaw);
+    return { mode, minMs, maxMs };
+}
+function normalizeDiscordPresenceConfig(value, fallback) {
+    const raw = isRecord(value) ? value : {};
+    return {
+        enabled: normalizeBoolean(raw.enabled, fallback.enabled),
+        intervalMs: normalizeInteger(raw.intervalMs, fallback.intervalMs, {
+            min: 5_000,
+            max: 300_000,
+        }),
+        healthyText: normalizeString(raw.healthyText, fallback.healthyText, {
+            allowEmpty: false,
+        }),
+        degradedText: normalizeString(raw.degradedText, fallback.degradedText, {
+            allowEmpty: false,
+        }),
+        exhaustedText: normalizeString(raw.exhaustedText, fallback.exhaustedText, {
+            allowEmpty: false,
+        }),
+        activityType: normalizeDiscordPresenceActivityType(raw.activityType, fallback.activityType),
+    };
+}
+function normalizeDiscordLifecycleReactionsConfig(value, fallback) {
+    const raw = isRecord(value) ? value : {};
+    const rawPhases = isRecord(raw.phases) ? raw.phases : {};
+    return {
+        enabled: normalizeBoolean(raw.enabled, fallback.enabled),
+        removeOnComplete: normalizeBoolean(raw.removeOnComplete, fallback.removeOnComplete),
+        phases: {
+            queued: normalizeString(rawPhases.queued, fallback.phases.queued, {
+                allowEmpty: false,
+            }),
+            thinking: normalizeString(rawPhases.thinking, fallback.phases.thinking, {
+                allowEmpty: false,
+            }),
+            toolUse: normalizeString(rawPhases.toolUse, fallback.phases.toolUse, {
+                allowEmpty: false,
+            }),
+            streaming: normalizeString(rawPhases.streaming, fallback.phases.streaming, { allowEmpty: false }),
+            done: normalizeString(rawPhases.done, fallback.phases.done, {
+                allowEmpty: false,
+            }),
+            error: normalizeString(rawPhases.error, fallback.phases.error, {
+                allowEmpty: false,
+            }),
+        },
+    };
+}
+function normalizeDiscordChannelConfig(value, fallback, defaultMode) {
+    const channelFallback = {
+        ...fallback,
+        mode: fallback.mode || defaultMode,
+    };
+    if (typeof value === 'string') {
+        return { mode: normalizeDiscordChannelMode(value, channelFallback.mode) };
+    }
+    if (!isRecord(value))
+        return null;
+    const channelConfig = {
+        mode: normalizeDiscordChannelMode(value.mode, channelFallback.mode),
+    };
+    if (value.typingMode !== undefined ||
+        channelFallback.typingMode !== undefined) {
+        channelConfig.typingMode = normalizeDiscordTypingMode(value.typingMode, channelFallback.typingMode ?? DEFAULT_RUNTIME_CONFIG.discord.typingMode);
+    }
+    if (value.debounceMs !== undefined ||
+        channelFallback.debounceMs !== undefined) {
+        channelConfig.debounceMs = normalizeInteger(value.debounceMs, channelFallback.debounceMs ?? DEFAULT_RUNTIME_CONFIG.discord.debounceMs, { min: 0, max: 120_000 });
+    }
+    if (value.ackReaction !== undefined ||
+        channelFallback.ackReaction !== undefined) {
+        channelConfig.ackReaction = normalizeString(value.ackReaction, channelFallback.ackReaction ?? DEFAULT_RUNTIME_CONFIG.discord.ackReaction, { allowEmpty: false });
+    }
+    if (value.ackReactionScope !== undefined ||
+        channelFallback.ackReactionScope !== undefined) {
+        channelConfig.ackReactionScope = normalizeDiscordAckReactionScope(value.ackReactionScope, channelFallback.ackReactionScope ??
+            DEFAULT_RUNTIME_CONFIG.discord.ackReactionScope);
+    }
+    if (value.removeAckAfterReply !== undefined ||
+        channelFallback.removeAckAfterReply !== undefined) {
+        channelConfig.removeAckAfterReply = normalizeBoolean(value.removeAckAfterReply, channelFallback.removeAckAfterReply ??
+            DEFAULT_RUNTIME_CONFIG.discord.removeAckAfterReply);
+    }
+    if (value.humanDelay !== undefined ||
+        channelFallback.humanDelay !== undefined) {
+        channelConfig.humanDelay = normalizeDiscordHumanDelayConfig(value.humanDelay, channelFallback.humanDelay ?? DEFAULT_RUNTIME_CONFIG.discord.humanDelay);
+    }
+    if (value.rateLimitPerUser !== undefined ||
+        channelFallback.rateLimitPerUser !== undefined) {
+        channelConfig.rateLimitPerUser = normalizeInteger(value.rateLimitPerUser, channelFallback.rateLimitPerUser ??
+            DEFAULT_RUNTIME_CONFIG.discord.rateLimitPerUser, { min: 0, max: 300 });
+    }
+    if (value.suppressPatterns !== undefined ||
+        channelFallback.suppressPatterns !== undefined) {
+        channelConfig.suppressPatterns = normalizeStringArray(value.suppressPatterns, channelFallback.suppressPatterns ??
+            DEFAULT_RUNTIME_CONFIG.discord.suppressPatterns);
+    }
+    if (value.maxConcurrentPerChannel !== undefined ||
+        channelFallback.maxConcurrentPerChannel !== undefined) {
+        channelConfig.maxConcurrentPerChannel = normalizeInteger(value.maxConcurrentPerChannel, channelFallback.maxConcurrentPerChannel ??
+            DEFAULT_RUNTIME_CONFIG.discord.maxConcurrentPerChannel, { min: 1, max: 16 });
+    }
+    return channelConfig;
+}
+function normalizeDiscordGuildConfig(value, fallback) {
+    if (!isRecord(value))
+        return fallback;
+    const defaultMode = normalizeDiscordChannelMode(value.defaultMode, fallback.defaultMode);
+    const rawChannels = isRecord(value.channels) ? value.channels : {};
+    const channels = {};
+    for (const [rawChannelId, rawChannelConfig] of Object.entries(rawChannels)) {
+        const channelId = rawChannelId.trim();
+        if (!channelId)
+            continue;
+        const fallbackChannel = fallback.channels[channelId] ?? {
+            mode: defaultMode,
+        };
+        const channelConfig = normalizeDiscordChannelConfig(rawChannelConfig, fallbackChannel, defaultMode);
+        if (!channelConfig)
+            continue;
+        channels[channelId] = channelConfig;
+    }
+    return { defaultMode, channels };
+}
+function normalizeDiscordGuildMap(value, fallback) {
+    if (!isRecord(value))
+        return fallback;
+    const guilds = {};
+    for (const [rawGuildId, rawGuildConfig] of Object.entries(value)) {
+        const guildId = rawGuildId.trim();
+        if (!guildId)
+            continue;
+        const fallbackGuild = fallback[guildId] ?? {
+            defaultMode: 'mention',
+            channels: {},
+        };
+        guilds[guildId] = normalizeDiscordGuildConfig(rawGuildConfig, fallbackGuild);
+    }
+    return guilds;
+}
+function normalizeSchedulerScheduleKind(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'at' || normalized === 'every' || normalized === 'cron')
+        return normalized;
+    return fallback;
+}
+function normalizeSchedulerActionKind(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'agent_turn' || normalized === 'system_event')
+        return normalized;
+    return fallback;
+}
+function normalizeSchedulerDeliveryKind(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'channel' ||
+        normalized === 'last-channel' ||
+        normalized === 'webhook')
+        return normalized;
+    return fallback;
+}
+function normalizeSchedulerJobList(value, fallback) {
+    if (!Array.isArray(value))
+        return fallback;
+    const jobs = [];
+    for (const item of value) {
+        if (!isRecord(item))
+            continue;
+        const jobId = normalizeString(item.id, '', { allowEmpty: false });
+        if (!jobId)
+            continue;
+        const rawSchedule = isRecord(item.schedule) ? item.schedule : {};
+        const rawAction = isRecord(item.action) ? item.action : {};
+        const rawDelivery = isRecord(item.delivery) ? item.delivery : {};
+        const scheduleKind = normalizeSchedulerScheduleKind(rawSchedule.kind, 'cron');
+        const everyMs = scheduleKind === 'every'
+            ? normalizeInteger(rawSchedule.everyMs, 60_000, {
+                min: 10_000,
+                max: 86_400_000,
+            })
+            : null;
+        const atRaw = scheduleKind === 'at'
+            ? normalizeString(rawSchedule.at, '', { allowEmpty: false })
+            : '';
+        const atIso = scheduleKind === 'at'
+            ? (() => {
+                const parsed = new Date(atRaw);
+                return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+            })()
+            : null;
+        const expr = scheduleKind === 'cron'
+            ? normalizeString(rawSchedule.expr, '', { allowEmpty: false })
+            : '';
+        if (scheduleKind === 'at' && !atIso)
+            continue;
+        if (scheduleKind === 'cron' && !expr)
+            continue;
+        const deliveryKind = normalizeSchedulerDeliveryKind(rawDelivery.kind, 'channel');
+        const to = normalizeString(rawDelivery.to, '', { allowEmpty: true });
+        const webhookUrl = normalizeString(rawDelivery.webhookUrl ?? rawDelivery.url, '', { allowEmpty: true });
+        if (deliveryKind === 'channel' && !to)
+            continue;
+        if (deliveryKind === 'webhook' && !webhookUrl)
+            continue;
+        const actionMessage = normalizeString(rawAction.message, '', {
+            allowEmpty: false,
+        });
+        if (!actionMessage)
+            continue;
+        const name = normalizeString(item.name, '', { allowEmpty: true });
+        const description = normalizeString(item.description, '', {
+            allowEmpty: true,
+        });
+        jobs.push({
+            id: jobId,
+            ...(name ? { name } : {}),
+            ...(description ? { description } : {}),
+            schedule: {
+                kind: scheduleKind,
+                at: atIso,
+                everyMs,
+                expr: scheduleKind === 'cron' ? expr : null,
+                tz: normalizeString(rawSchedule.tz, '', { allowEmpty: true }),
+            },
+            action: {
+                kind: normalizeSchedulerActionKind(rawAction.kind, 'agent_turn'),
+                message: actionMessage,
+            },
+            delivery: {
+                kind: deliveryKind,
+                channel: normalizeString(rawDelivery.channel, 'discord', {
+                    allowEmpty: true,
+                }),
+                to,
+                webhookUrl,
+            },
+            enabled: normalizeBoolean(item.enabled, true),
+        });
+    }
+    return jobs;
+}
 function normalizeLogLevel(value, fallback) {
-    const normalized = normalizeString(value, fallback, { allowEmpty: false }).toLowerCase();
+    const normalized = normalizeString(value, fallback, {
+        allowEmpty: false,
+    }).toLowerCase();
     if (KNOWN_LOG_LEVELS.has(normalized))
         return normalized;
     return fallback;
@@ -193,7 +609,10 @@ function normalizeBaseUrl(value, fallback) {
     return candidate.replace(/\/+$/, '') || fallback;
 }
 function normalizeApiPath(value, fallback) {
-    const normalized = normalizeString(value, fallback, { allowEmpty: false, trim: true });
+    const normalized = normalizeString(value, fallback, {
+        allowEmpty: false,
+        trim: true,
+    });
     if (/^https?:\/\//i.test(normalized)) {
         return normalized.replace(/\/+$/, '');
     }
@@ -214,27 +633,45 @@ function normalizeRuntimeConfig(patch) {
     const rawHybridAi = isRecord(raw.hybridai) ? raw.hybridai : {};
     const rawContainer = isRecord(raw.container) ? raw.container : {};
     const rawHeartbeat = isRecord(raw.heartbeat) ? raw.heartbeat : {};
+    const rawMemory = isRecord(raw.memory) ? raw.memory : {};
     const rawOps = isRecord(raw.ops) ? raw.ops : {};
     const rawObservability = isRecord(raw.observability) ? raw.observability : {};
-    const rawSessionCompaction = isRecord(raw.sessionCompaction) ? raw.sessionCompaction : {};
+    const rawSessionCompaction = isRecord(raw.sessionCompaction)
+        ? raw.sessionCompaction
+        : {};
     const rawPreFlush = isRecord(rawSessionCompaction.preCompactionMemoryFlush)
         ? rawSessionCompaction.preCompactionMemoryFlush
         : {};
     const rawPromptHooks = isRecord(raw.promptHooks) ? raw.promptHooks : {};
     const rawProactive = isRecord(raw.proactive) ? raw.proactive : {};
-    const rawActiveHours = isRecord(rawProactive.activeHours) ? rawProactive.activeHours : {};
-    const rawDelegation = isRecord(rawProactive.delegation) ? rawProactive.delegation : {};
-    const rawAutoRetry = isRecord(rawProactive.autoRetry) ? rawProactive.autoRetry : {};
+    const rawActiveHours = isRecord(rawProactive.activeHours)
+        ? rawProactive.activeHours
+        : {};
+    const rawDelegation = isRecord(rawProactive.delegation)
+        ? rawProactive.delegation
+        : {};
+    const rawAutoRetry = isRecord(rawProactive.autoRetry)
+        ? rawProactive.autoRetry
+        : {};
     const rawRalph = isRecord(rawProactive.ralph) ? rawProactive.ralph : {};
+    const rawScheduler = isRecord(raw.scheduler) ? raw.scheduler : {};
     const defaultOps = DEFAULT_RUNTIME_CONFIG.ops;
     const healthPort = normalizeInteger(rawOps.healthPort, defaultOps.healthPort, { min: 1, max: 65_535 });
     const webApiToken = normalizeString(rawOps.webApiToken, defaultOps.webApiToken, { allowEmpty: true });
     const hybridBaseUrl = normalizeBaseUrl(rawHybridAi.baseUrl, DEFAULT_RUNTIME_CONFIG.hybridai.baseUrl);
     const hybridDefaultChatbotId = normalizeString(rawHybridAi.defaultChatbotId, DEFAULT_RUNTIME_CONFIG.hybridai.defaultChatbotId, { allowEmpty: true });
     const threshold = normalizeInteger(rawSessionCompaction.threshold, DEFAULT_RUNTIME_CONFIG.sessionCompaction.threshold, { min: 20 });
+    const tokenBudget = normalizeInteger(rawSessionCompaction.tokenBudget, DEFAULT_RUNTIME_CONFIG.sessionCompaction.tokenBudget, { min: 1_000 });
+    const budgetRatio = normalizeNumber(rawSessionCompaction.budgetRatio, DEFAULT_RUNTIME_CONFIG.sessionCompaction.budgetRatio, { min: 0.05, max: 1 });
     const keepRecentRaw = normalizeInteger(rawSessionCompaction.keepRecent, DEFAULT_RUNTIME_CONFIG.sessionCompaction.keepRecent, { min: 1 });
     const keepRecent = Math.min(keepRecentRaw, Math.max(1, threshold - 1));
     const modelList = normalizeStringArray(rawHybridAi.models, DEFAULT_RUNTIME_CONFIG.hybridai.models);
+    const normalizedCommandUserId = normalizeString(rawDiscord.commandUserId, DEFAULT_RUNTIME_CONFIG.discord.commandUserId, { allowEmpty: true });
+    const normalizedCommandAllowedUserIds = normalizeStringArray(rawDiscord.commandAllowedUserIds, DEFAULT_RUNTIME_CONFIG.discord.commandAllowedUserIds);
+    const legacyCommandModeFallback = normalizedCommandUserId
+        ? 'restricted'
+        : DEFAULT_RUNTIME_CONFIG.discord.commandMode;
+    const normalizedCommandMode = normalizeDiscordCommandMode(rawDiscord.commandMode, legacyCommandModeFallback);
     return {
         version: CONFIG_VERSION,
         security: {
@@ -252,12 +689,32 @@ function normalizeRuntimeConfig(patch) {
             presenceIntent: normalizeBoolean(rawDiscord.presenceIntent, DEFAULT_RUNTIME_CONFIG.discord.presenceIntent),
             respondToAllMessages: normalizeBoolean(rawDiscord.respondToAllMessages, DEFAULT_RUNTIME_CONFIG.discord.respondToAllMessages),
             commandsOnly: normalizeBoolean(rawDiscord.commandsOnly, DEFAULT_RUNTIME_CONFIG.discord.commandsOnly),
-            commandUserId: normalizeString(rawDiscord.commandUserId, DEFAULT_RUNTIME_CONFIG.discord.commandUserId, { allowEmpty: true }),
+            commandMode: normalizedCommandMode,
+            commandAllowedUserIds: normalizedCommandAllowedUserIds,
+            commandUserId: normalizedCommandUserId,
+            groupPolicy: normalizeDiscordGroupPolicy(rawDiscord.groupPolicy, DEFAULT_RUNTIME_CONFIG.discord.groupPolicy),
+            freeResponseChannels: normalizeStringArray(rawDiscord.freeResponseChannels, DEFAULT_RUNTIME_CONFIG.discord.freeResponseChannels),
+            textChunkLimit: normalizeInteger(rawDiscord.textChunkLimit, DEFAULT_RUNTIME_CONFIG.discord.textChunkLimit, { min: 200, max: 2_000 }),
+            maxLinesPerMessage: normalizeInteger(rawDiscord.maxLinesPerMessage, DEFAULT_RUNTIME_CONFIG.discord.maxLinesPerMessage, { min: 4, max: 200 }),
+            humanDelay: normalizeDiscordHumanDelayConfig(rawDiscord.humanDelay, DEFAULT_RUNTIME_CONFIG.discord.humanDelay),
+            typingMode: normalizeDiscordTypingMode(rawDiscord.typingMode, DEFAULT_RUNTIME_CONFIG.discord.typingMode),
+            presence: normalizeDiscordPresenceConfig(rawDiscord.presence, DEFAULT_RUNTIME_CONFIG.discord.presence),
+            lifecycleReactions: normalizeDiscordLifecycleReactionsConfig(rawDiscord.lifecycleReactions, DEFAULT_RUNTIME_CONFIG.discord.lifecycleReactions),
+            ackReaction: normalizeString(rawDiscord.ackReaction, DEFAULT_RUNTIME_CONFIG.discord.ackReaction, { allowEmpty: false }),
+            ackReactionScope: normalizeDiscordAckReactionScope(rawDiscord.ackReactionScope, DEFAULT_RUNTIME_CONFIG.discord.ackReactionScope),
+            removeAckAfterReply: normalizeBoolean(rawDiscord.removeAckAfterReply, DEFAULT_RUNTIME_CONFIG.discord.removeAckAfterReply),
+            debounceMs: normalizeInteger(rawDiscord.debounceMs, DEFAULT_RUNTIME_CONFIG.discord.debounceMs, { min: 0, max: 120_000 }),
+            rateLimitPerUser: normalizeInteger(rawDiscord.rateLimitPerUser, DEFAULT_RUNTIME_CONFIG.discord.rateLimitPerUser, { min: 0, max: 300 }),
+            rateLimitExemptRoles: normalizeStringArray(rawDiscord.rateLimitExemptRoles, DEFAULT_RUNTIME_CONFIG.discord.rateLimitExemptRoles),
+            suppressPatterns: normalizeStringArray(rawDiscord.suppressPatterns, DEFAULT_RUNTIME_CONFIG.discord.suppressPatterns),
+            maxConcurrentPerChannel: normalizeInteger(rawDiscord.maxConcurrentPerChannel, DEFAULT_RUNTIME_CONFIG.discord.maxConcurrentPerChannel, { min: 1, max: 16 }),
+            guilds: normalizeDiscordGuildMap(rawDiscord.guilds, DEFAULT_RUNTIME_CONFIG.discord.guilds),
         },
         hybridai: {
             baseUrl: hybridBaseUrl,
             defaultModel: normalizeString(rawHybridAi.defaultModel, DEFAULT_RUNTIME_CONFIG.hybridai.defaultModel, { allowEmpty: false }),
             defaultChatbotId: hybridDefaultChatbotId,
+            maxTokens: normalizeInteger(rawHybridAi.maxTokens, DEFAULT_RUNTIME_CONFIG.hybridai.maxTokens, { min: 256, max: 32_768 }),
             enableRag: normalizeBoolean(rawHybridAi.enableRag, DEFAULT_RUNTIME_CONFIG.hybridai.enableRag),
             models: modelList,
         },
@@ -275,13 +732,23 @@ function normalizeRuntimeConfig(patch) {
             intervalMs: normalizeInteger(rawHeartbeat.intervalMs, DEFAULT_RUNTIME_CONFIG.heartbeat.intervalMs, { min: 10_000 }),
             channel: normalizeString(rawHeartbeat.channel, DEFAULT_RUNTIME_CONFIG.heartbeat.channel, { allowEmpty: true }),
         },
+        memory: {
+            decayRate: normalizeNumber(rawMemory.decayRate, DEFAULT_RUNTIME_CONFIG.memory.decayRate, { min: 0, max: 0.95 }),
+            consolidationIntervalHours: normalizeInteger(rawMemory.consolidationIntervalHours, DEFAULT_RUNTIME_CONFIG.memory.consolidationIntervalHours, { min: 0, max: 24 * 30 }),
+        },
         ops: {
-            healthHost: normalizeString(rawOps.healthHost, defaultOps.healthHost, { allowEmpty: false }),
+            healthHost: normalizeString(rawOps.healthHost, defaultOps.healthHost, {
+                allowEmpty: false,
+            }),
             healthPort,
             webApiToken,
             gatewayBaseUrl: normalizeBaseUrl(rawOps.gatewayBaseUrl, `http://127.0.0.1:${healthPort}`),
-            gatewayApiToken: normalizeString(rawOps.gatewayApiToken, webApiToken, { allowEmpty: true }),
-            dbPath: normalizeString(rawOps.dbPath, defaultOps.dbPath, { allowEmpty: false }),
+            gatewayApiToken: normalizeString(rawOps.gatewayApiToken, webApiToken, {
+                allowEmpty: true,
+            }),
+            dbPath: normalizeString(rawOps.dbPath, defaultOps.dbPath, {
+                allowEmpty: false,
+            }),
             logLevel: normalizeLogLevel(rawOps.logLevel, defaultOps.logLevel),
         },
         observability: {
@@ -289,7 +756,9 @@ function normalizeRuntimeConfig(patch) {
             baseUrl: normalizeBaseUrl(rawObservability.baseUrl, hybridBaseUrl),
             ingestPath: normalizeApiPath(rawObservability.ingestPath, DEFAULT_RUNTIME_CONFIG.observability.ingestPath),
             statusPath: normalizeApiPath(rawObservability.statusPath, DEFAULT_RUNTIME_CONFIG.observability.statusPath),
-            botId: normalizeString(rawObservability.botId, hybridDefaultChatbotId, { allowEmpty: true }),
+            botId: normalizeString(rawObservability.botId, hybridDefaultChatbotId, {
+                allowEmpty: true,
+            }),
             agentId: normalizeString(rawObservability.agentId, DEFAULT_RUNTIME_CONFIG.observability.agentId, { allowEmpty: false }),
             label: normalizeString(rawObservability.label, DEFAULT_RUNTIME_CONFIG.observability.label, { allowEmpty: true }),
             environment: normalizeString(rawObservability.environment, DEFAULT_RUNTIME_CONFIG.observability.environment, { allowEmpty: false }),
@@ -298,13 +767,18 @@ function normalizeRuntimeConfig(patch) {
         },
         sessionCompaction: {
             enabled: normalizeBoolean(rawSessionCompaction.enabled, DEFAULT_RUNTIME_CONFIG.sessionCompaction.enabled),
+            tokenBudget,
+            budgetRatio,
             threshold,
             keepRecent,
             summaryMaxChars: normalizeInteger(rawSessionCompaction.summaryMaxChars, DEFAULT_RUNTIME_CONFIG.sessionCompaction.summaryMaxChars, { min: 1_000 }),
             preCompactionMemoryFlush: {
-                enabled: normalizeBoolean(rawPreFlush.enabled, DEFAULT_RUNTIME_CONFIG.sessionCompaction.preCompactionMemoryFlush.enabled),
-                maxMessages: normalizeInteger(rawPreFlush.maxMessages, DEFAULT_RUNTIME_CONFIG.sessionCompaction.preCompactionMemoryFlush.maxMessages, { min: 8 }),
-                maxChars: normalizeInteger(rawPreFlush.maxChars, DEFAULT_RUNTIME_CONFIG.sessionCompaction.preCompactionMemoryFlush.maxChars, { min: 4_000 }),
+                enabled: normalizeBoolean(rawPreFlush.enabled, DEFAULT_RUNTIME_CONFIG.sessionCompaction.preCompactionMemoryFlush
+                    .enabled),
+                maxMessages: normalizeInteger(rawPreFlush.maxMessages, DEFAULT_RUNTIME_CONFIG.sessionCompaction.preCompactionMemoryFlush
+                    .maxMessages, { min: 8 }),
+                maxChars: normalizeInteger(rawPreFlush.maxChars, DEFAULT_RUNTIME_CONFIG.sessionCompaction.preCompactionMemoryFlush
+                    .maxChars, { min: 4_000 }),
             },
         },
         promptHooks: {
@@ -337,6 +811,9 @@ function normalizeRuntimeConfig(patch) {
                 maxIterations: normalizeInteger(rawRalph.maxIterations, DEFAULT_RUNTIME_CONFIG.proactive.ralph.maxIterations, { min: -1, max: 64 }),
             },
         },
+        scheduler: {
+            jobs: normalizeSchedulerJobList(rawScheduler.jobs, DEFAULT_RUNTIME_CONFIG.scheduler.jobs),
+        },
     };
 }
 function loadConfigPatchFromDisk() {
@@ -397,7 +874,7 @@ function scheduleWatcherRestart(reason) {
         return;
     }
     watcherRetryAttempt += 1;
-    const delay = Math.min(WATCHER_RETRY_BASE_DELAY_MS * (2 ** (watcherRetryAttempt - 1)), WATCHER_RETRY_MAX_DELAY_MS);
+    const delay = Math.min(WATCHER_RETRY_BASE_DELAY_MS * 2 ** (watcherRetryAttempt - 1), WATCHER_RETRY_MAX_DELAY_MS);
     console.warn(`[runtime-config] watcher restart in ${delay}ms (attempt ${watcherRetryAttempt}/${WATCHER_RETRY_MAX_ATTEMPTS})`);
     watcherRestartTimer = setTimeout(() => {
         watcherRestartTimer = null;
@@ -521,13 +998,15 @@ export function updateRuntimeConfig(mutator) {
     return saveRuntimeConfig(draft);
 }
 export function isSecurityTrustAccepted(config = currentConfig) {
-    return Boolean(config.security.trustModelAccepted
-        && config.security.trustModelAcceptedAt
-        && config.security.trustModelVersion === SECURITY_POLICY_VERSION);
+    return Boolean(config.security.trustModelAccepted &&
+        config.security.trustModelAcceptedAt &&
+        config.security.trustModelVersion === SECURITY_POLICY_VERSION);
 }
 export function acceptSecurityTrustModel(params) {
     const acceptedAt = normalizeString(params?.acceptedAt, new Date().toISOString(), { allowEmpty: false });
-    const acceptedBy = normalizeString(params?.acceptedBy ?? '', '', { allowEmpty: true });
+    const acceptedBy = normalizeString(params?.acceptedBy ?? '', '', {
+        allowEmpty: true,
+    });
     const policyVersion = normalizeString(params?.policyVersion, SECURITY_POLICY_VERSION, { allowEmpty: false });
     return updateRuntimeConfig((draft) => {
         draft.security.trustModelAccepted = true;