@hybridaione/hybridclaw 0.2.3 → 0.2.7

package/src/gateway.ts

@@ -1,19 +1,31 @@
-import fs from 'fs';
-
 import { AttachmentBuilder } from 'discord.js';
-
+import fs from 'fs';
+import {
+  buildResponseText,
+  formatError,
+  formatInfo,
+} from './channels/discord/delivery.js';
+import { rewriteUserMentionsForMessage } from './channels/discord/mentions.js';
+import {
+  initDiscord,
+  type ReplyFn,
+  sendToChannel,
+  setDiscordMaintenancePresence,
+} from './channels/discord/runtime.js';
 import {
   DISCORD_TOKEN,
+  getConfigSnapshot,
   HEARTBEAT_CHANNEL,
   HEARTBEAT_INTERVAL,
   HYBRIDAI_CHATBOT_ID,
-  PROACTIVE_QUEUE_OUTSIDE_HOURS,
   onConfigChange,
+  PROACTIVE_QUEUE_OUTSIDE_HOURS,
 } from './config.js';
 import { stopAllContainers } from './container-runner.js';
 import {
   deleteQueuedProactiveMessage,
   enqueueProactiveMessage,
+  getMostRecentSessionChannelId,
   getQueuedProactiveMessageCount,
   initDatabase,
   listQueuedProactiveMessages,
@@ -25,25 +37,41 @@ import {
   renderGatewayCommand,
   runGatewayScheduledTask,
 } from './gateway-service.js';
-import { buildResponseText, formatError, formatInfo } from './channels/discord/delivery.js';
-import { rewriteUserMentionsForMessage } from './channels/discord/mentions.js';
 import { startHealthServer } from './health.js';
 import { startHeartbeat, stopHeartbeat } from './heartbeat.js';
 import { logger } from './logger.js';
-import { startObservabilityIngest, stopObservabilityIngest } from './observability-ingest.js';
-import { startScheduler, stopScheduler } from './scheduler.js';
+import { memoryService } from './memory-service.js';
 import {
-  initDiscord,
-  sendToChannel,
-  type ReplyFn,
-} from './channels/discord/runtime.js';
-import { isWithinActiveHours, proactiveWindowLabel } from './proactive-policy.js';
+  startObservabilityIngest,
+  stopObservabilityIngest,
+} from './observability-ingest.js';
+import {
+  isWithinActiveHours,
+  proactiveWindowLabel,
+} from './proactive-policy.js';
+import {
+  rearmScheduler,
+  type SchedulerDispatchRequest,
+  startScheduler,
+  stopScheduler,
+} from './scheduler.js';
 import type { ArtifactMetadata } from './types.js';
 
 let detachConfigListener: (() => void) | null = null;
 let proactiveFlushTimer: ReturnType<typeof setInterval> | null = null;
+let memoryConsolidationTimer: ReturnType<typeof setInterval> | null = null;
 
 const MAX_QUEUED_PROACTIVE_MESSAGES = 100;
+const APPROVAL_PROMPT_DEFAULT_TTL_MS = 120_000;
+
+interface PendingApprovalPrompt {
+  prompt: string;
+  createdAt: number;
+  expiresAt: number;
+  userId: string;
+}
+
+const pendingApprovalBySession = new Map<string, PendingApprovalPrompt>();
 
 function isDiscordChannelId(channelId: string): boolean {
   return /^\d{16,22}$/.test(channelId);
@@ -57,9 +85,14 @@ function buildArtifactAttachments(
   for (const artifact of artifacts) {
     try {
       const content = fs.readFileSync(artifact.path);
-      attachments.push(new AttachmentBuilder(content, { name: artifact.filename }));
+      attachments.push(
+        new AttachmentBuilder(content, { name: artifact.filename }),
+      );
     } catch (error) {
-      logger.warn({ artifactPath: artifact.path, error }, 'Failed to read artifact for Discord attachment');
+      logger.warn(
+        { artifactPath: artifact.path, error },
+        'Failed to read artifact for Discord attachment',
+      );
     }
   }
   return attachments;
@@ -75,7 +108,9 @@ function simplifyImageAttachmentNarration(
 ): string {
   if (!text.trim() || !artifacts || artifacts.length === 0) return text;
 
-  const imageArtifacts = artifacts.filter((artifact) => artifact.mimeType.startsWith('image/'));
+  const imageArtifacts = artifacts.filter((artifact) =>
+    artifact.mimeType.startsWith('image/'),
+  );
   if (imageArtifacts.length === 0) return text;
 
   const pathHints = new Set<string>();
@@ -88,14 +123,18 @@ function simplifyImageAttachmentNarration(
     if (filename) pathHints.add(`.browser-artifacts/${filename}`);
   }
 
-  const pathishLine = /(^`?\s*(\.\/|\/|~\/|[a-zA-Z]:\\|\.browser-artifacts\/))|([\\/][^\\/\s]+\.[a-zA-Z0-9]{1,8})/;
-  const locationNarration = /(workspace|saved to|find it at|located at|liegt unter|pfad|path)/i;
+  const pathishLine =
+    /(^`?\s*(\.\/|\/|~\/|[a-zA-Z]:\\|\.browser-artifacts\/))|([\\/][^\\/\s]+\.[a-zA-Z0-9]{1,8})/;
+  const locationNarration =
+    /(workspace|saved to|find it at|located at|liegt unter|pfad|path)/i;
 
   let removedPathNarration = false;
   const keptLines: string[] = [];
   for (const line of text.split('\n')) {
     const normalizedLine = normalizePathForMatch(line);
-    const mentionsArtifact = Array.from(pathHints).some((hint) => normalizedLine.includes(hint));
+    const mentionsArtifact = Array.from(pathHints).some((hint) =>
+      normalizedLine.includes(hint),
+    );
     const isPathLine = pathishLine.test(line.trim());
     const isLocationNarration = locationNarration.test(line);
     if (mentionsArtifact && (isPathLine || isLocationNarration)) {
@@ -107,11 +146,140 @@ function simplifyImageAttachmentNarration(
 
   if (!removedPathNarration) return text;
 
-  const cleaned = keptLines.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+  const cleaned = keptLines
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
   if (cleaned) return cleaned;
   return imageArtifacts.length === 1 ? 'Here it is.' : 'Here they are.';
 }
 
+function isApprovalPromptForPrivateDelivery(text: string): boolean {
+  const normalized = text.toLowerCase();
+  return (
+    normalized.includes('i need your approval before i') &&
+    normalized.includes('approval id:') &&
+    normalized.includes('reply `yes`')
+  );
+}
+
+function parseApprovalExpiryMs(prompt: string): number {
+  const match = prompt.match(/Approval expires in\s+(\d+)s\./i);
+  const seconds = match ? Number.parseInt(match[1], 10) : NaN;
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    return APPROVAL_PROMPT_DEFAULT_TTL_MS;
+  }
+  return Math.max(15_000, seconds * 1_000);
+}
+
+function extractApprovalId(prompt: string): string {
+  const match = prompt.match(/Approval ID:\s*([a-f0-9-]{6,64})/i);
+  return match?.[1]?.trim() || '';
+}
+
+function cleanupExpiredPendingApprovals(): void {
+  const now = Date.now();
+  for (const [sessionId, pending] of pendingApprovalBySession.entries()) {
+    if (pending.expiresAt <= now) {
+      pendingApprovalBySession.delete(sessionId);
+    }
+  }
+}
+
+async function handleApprovalCommand(params: {
+  sessionId: string;
+  guildId: string | null;
+  channelId: string;
+  userId: string;
+  username: string;
+  args: string[];
+  reply: ReplyFn;
+}): Promise<boolean> {
+  const { sessionId, guildId, channelId, userId, username, args, reply } =
+    params;
+  if ((args[0] || '').toLowerCase() !== 'approve') return false;
+
+  cleanupExpiredPendingApprovals();
+  const pending = pendingApprovalBySession.get(sessionId) || null;
+  const action = (args[1] || 'view').trim().toLowerCase();
+  const providedApprovalId = (args[2] || '').trim();
+  const currentApprovalId = pending ? extractApprovalId(pending.prompt) : '';
+  const approvalId = providedApprovalId || currentApprovalId;
+
+  if (action === 'view' || action === 'status' || action === 'show') {
+    if (!pending || pending.userId !== userId) {
+      await reply('No pending approval request for you in this session.');
+      return true;
+    }
+    await reply(formatInfo('Pending Approval', pending.prompt));
+    return true;
+  }
+
+  const directive = (() => {
+    if (action === 'yes' || action === '1') return 'yes';
+    if (action === 'session' || action === '2') return 'yes for session';
+    if (action === 'agent' || action === '3') return 'yes for agent';
+    if (
+      action === 'no' ||
+      action === 'deny' ||
+      action === 'skip' ||
+      action === '4'
+    ) {
+      return 'no';
+    }
+    return null;
+  })();
+
+  if (!directive) {
+    await reply(
+      'Usage: `/approve action:view|yes|session|agent|no [approval_id]`',
+    );
+    return true;
+  }
+
+  if (!approvalId && !pending) {
+    await reply('No pending approval request for this session.');
+    return true;
+  }
+
+  const approvalContent = approvalId ? `${directive} ${approvalId}` : directive;
+  const approvalResult = await handleGatewayMessage({
+    sessionId,
+    guildId,
+    channelId,
+    userId,
+    username,
+    content: approvalContent,
+    media: [],
+  });
+  if (approvalResult.status === 'error') {
+    await reply(
+      formatError('Approval Error', approvalResult.error || 'Unknown error'),
+    );
+    return true;
+  }
+
+  const resultText = buildResponseText(
+    approvalResult.result || 'No response from agent.',
+    approvalResult.toolsUsed,
+  );
+  if (isApprovalPromptForPrivateDelivery(resultText)) {
+    pendingApprovalBySession.set(sessionId, {
+      prompt: resultText,
+      createdAt: Date.now(),
+      expiresAt: Date.now() + parseApprovalExpiryMs(resultText),
+      userId,
+    });
+    await reply(formatInfo('Pending Approval', resultText));
+    return true;
+  }
+
+  pendingApprovalBySession.delete(sessionId);
+  const attachments = buildArtifactAttachments(approvalResult.artifacts);
+  await reply(resultText, attachments);
+  return true;
+}
+
 async function deliverProactiveMessage(
   channelId: string,
   text: string,
@@ -120,7 +288,12 @@ async function deliverProactiveMessage(
 ): Promise<void> {
   if (!isWithinActiveHours()) {
     if (PROACTIVE_QUEUE_OUTSIDE_HOURS) {
-      const { queued, dropped } = enqueueProactiveMessage(channelId, text, source, MAX_QUEUED_PROACTIVE_MESSAGES);
+      const { queued, dropped } = enqueueProactiveMessage(
+        channelId,
+        text,
+        source,
+        MAX_QUEUED_PROACTIVE_MESSAGES,
+      );
       logger.info(
         {
           source,
@@ -140,7 +313,10 @@ async function deliverProactiveMessage(
       }
       return;
     }
-    logger.info({ source, channelId, activeHours: proactiveWindowLabel() }, 'Proactive message suppressed (outside active hours)');
+    logger.info(
+      { source, channelId, activeHours: proactiveWindowLabel() },
+      'Proactive message suppressed (outside active hours)',
+    );
     return;
   }
 
@@ -155,18 +331,59 @@ async function sendProactiveMessageNow(
 ): Promise<void> {
   const attachments = buildArtifactAttachments(artifacts);
   if (!DISCORD_TOKEN || !isDiscordChannelId(channelId)) {
-    logger.info({ source, channelId, text, artifactCount: attachments.length }, 'Proactive message (no Discord delivery)');
+    logger.info(
+      { source, channelId, text, artifactCount: attachments.length },
+      'Proactive message (no Discord delivery)',
+    );
     return;
   }
 
   try {
     await sendToChannel(channelId, text, attachments);
   } catch (error) {
-    logger.warn({ source, channelId, error, artifactCount: attachments.length }, 'Failed to send proactive message to Discord channel');
+    logger.warn(
+      { source, channelId, error, artifactCount: attachments.length },
+      'Failed to send proactive message to Discord channel',
+    );
     logger.info({ source, channelId, text }, 'Proactive message fallback');
   }
 }
 
+async function deliverWebhookMessage(
+  webhookUrl: string,
+  text: string,
+  source: string,
+  artifacts?: ArtifactMetadata[],
+): Promise<void> {
+  const response = await fetch(webhookUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json; charset=utf-8',
+    },
+    body: JSON.stringify({
+      text,
+      source,
+      artifactCount: artifacts?.length || 0,
+      artifacts: (artifacts || []).map((artifact) => ({
+        filename: artifact.filename,
+        mimeType: artifact.mimeType,
+      })),
+    }),
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => '');
+    throw new Error(
+      `Webhook delivery failed (${response.status}): ${body.slice(0, 300)}`,
+    );
+  }
+}
+
+function resolveLastUsedDiscordChannelId(): string | null {
+  const channelId = getMostRecentSessionChannelId();
+  if (!channelId) return null;
+  return isDiscordChannelId(channelId) ? channelId : null;
+}
+
 async function flushQueuedProactiveMessages(): Promise<void> {
   if (!isWithinActiveHours()) return;
   const pending = listQueuedProactiveMessages(MAX_QUEUED_PROACTIVE_MESSAGES);
@@ -178,7 +395,11 @@ async function flushQueuedProactiveMessages(): Promise<void> {
 
   for (const item of pending) {
     if (!isWithinActiveHours()) break;
-    await sendProactiveMessageNow(item.channel_id, item.text, `${item.source}:queued`);
+    await sendProactiveMessageNow(
+      item.channel_id,
+      item.text,
+      `${item.source}:queued`,
+    );
     deleteQueuedProactiveMessage(item.id);
   }
 }
@@ -202,6 +423,7 @@ async function startDiscordIntegration(): Promise<void> {
       context,
     ) => {
       try {
+        let sawTextDelta = false;
         const result = await handleGatewayMessage({
           sessionId,
           guildId,
@@ -211,15 +433,35 @@ async function startDiscordIntegration(): Promise<void> {
           content,
           media,
           onTextDelta: (delta) => {
+            if (!sawTextDelta) {
+              sawTextDelta = true;
+              context.emitLifecyclePhase('streaming');
+            }
             void context.stream.append(delta);
           },
+          onToolProgress: (event) => {
+            if (sawTextDelta) return;
+            if (event.phase === 'start') {
+              context.emitLifecyclePhase('toolUse');
+            } else {
+              context.emitLifecyclePhase('thinking');
+            }
+          },
           onProactiveMessage: async (message) => {
-            await deliverProactiveMessage(channelId, message.text, 'delegate', message.artifacts);
+            await deliverProactiveMessage(
+              channelId,
+              message.text,
+              'delegate',
+              message.artifacts,
+            );
           },
           abortSignal: context.abortSignal,
         });
         if (result.status === 'error') {
-          const errorText = formatError('Agent Error', result.error || 'Unknown error');
+          const errorText = formatError(
+            'Agent Error',
+            result.error || 'Unknown error',
+          );
           await context.stream.fail(errorText);
           return;
         }
@@ -233,13 +475,27 @@ async function startDiscordIntegration(): Promise<void> {
           context.sourceMessage,
           context.mentionLookup,
         );
-        await context.stream.finalize(
-          buildResponseText(renderedText, result.toolsUsed),
-          attachments,
-        );
+        const responseText = buildResponseText(renderedText, result.toolsUsed);
+        if (isApprovalPromptForPrivateDelivery(responseText)) {
+          pendingApprovalBySession.set(sessionId, {
+            prompt: responseText,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + parseApprovalExpiryMs(responseText),
+            userId,
+          });
+          await context.stream.finalize(
+            `<@${userId}> approval required. Use \`/approve\` to view and respond privately.`,
+          );
+          return;
+        }
+        pendingApprovalBySession.delete(sessionId);
+        await context.stream.finalize(responseText, attachments);
       } catch (error) {
         const text = error instanceof Error ? error.message : String(error);
-        logger.error({ error, sessionId, channelId }, 'Discord message handling failed');
+        logger.error(
+          { error, sessionId, channelId },
+          'Discord message handling failed',
+        );
         const errorText = formatError('Gateway Error', text);
         await context.stream.fail(errorText);
       }
@@ -248,10 +504,25 @@ async function startDiscordIntegration(): Promise<void> {
       sessionId: string,
       guildId: string | null,
       channelId: string,
+      userId: string,
+      username: string,
       args: string[],
       reply: ReplyFn,
     ) => {
       try {
+        if (
+          await handleApprovalCommand({
+            sessionId,
+            guildId,
+            channelId,
+            userId,
+            username,
+            args,
+            reply,
+          })
+        ) {
+          return;
+        }
         const result = await handleGatewayCommand({
           sessionId,
           guildId,
@@ -269,7 +540,10 @@ async function startDiscordIntegration(): Promise<void> {
         await reply(renderGatewayCommand(result));
       } catch (error) {
         const text = error instanceof Error ? error.message : String(error);
-        logger.error({ error, sessionId, channelId, args }, 'Discord command handling failed');
+        logger.error(
+          { error, sessionId, channelId, args },
+          'Discord command handling failed',
+        );
         await reply(formatError('Gateway Error', text));
       }
     },
@@ -278,47 +552,141 @@ async function startDiscordIntegration(): Promise<void> {
 }
 
 function setupShutdown(): void {
-  const shutdown = () => {
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
     logger.info('Shutting down gateway...');
     if (detachConfigListener) {
       detachConfigListener();
       detachConfigListener = null;
     }
+    await setDiscordMaintenancePresence().catch((error) => {
+      logger.debug(
+        { error },
+        'Failed to set Discord maintenance presence during shutdown',
+      );
+    });
     stopHeartbeat();
     stopObservabilityIngest();
     stopAllContainers();
     stopScheduler();
+    stopMemoryConsolidationScheduler();
     if (proactiveFlushTimer) {
       clearInterval(proactiveFlushTimer);
       proactiveFlushTimer = null;
     }
     process.exit(0);
   };
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', () => {
+    void shutdown();
+  });
+  process.on('SIGTERM', () => {
+    void shutdown();
+  });
 }
 
 async function runScheduledTask(
-  sessionId: string,
-  channelId: string,
-  prompt: string,
-  taskId: number,
+  request: SchedulerDispatchRequest,
 ): Promise<void> {
+  const sourceLabel =
+    request.source === 'db-task'
+      ? `schedule:${request.taskId ?? 'unknown'}`
+      : `schedule-job:${request.jobId ?? 'unknown'}`;
+  const resolvedDeliveryChannelId =
+    request.delivery.kind === 'channel'
+      ? request.delivery.channelId
+      : request.delivery.kind === 'last-channel'
+        ? resolveLastUsedDiscordChannelId()
+        : null;
+
+  if (request.actionKind === 'system_event') {
+    if (request.delivery.kind === 'webhook') {
+      await deliverWebhookMessage(
+        request.delivery.webhookUrl,
+        request.prompt,
+        `${sourceLabel}:system`,
+      );
+      return;
+    }
+    if (!resolvedDeliveryChannelId) {
+      throw new Error(
+        'No Discord channel available for scheduled system event delivery.',
+      );
+    }
+    await deliverProactiveMessage(
+      resolvedDeliveryChannelId,
+      request.prompt,
+      `${sourceLabel}:system`,
+    );
+    return;
+  }
+
+  const runChannelId =
+    request.channelId || resolvedDeliveryChannelId || 'scheduler';
+  const taskId = request.taskId ?? -1;
+
   await runGatewayScheduledTask(
-    sessionId,
-    channelId,
-    prompt,
+    request.sessionId,
+    runChannelId,
+    request.prompt,
     taskId,
     async (result) => {
-      await deliverProactiveMessage(channelId, result.text, `schedule:${taskId}`, result.artifacts);
+      if (request.delivery.kind === 'webhook') {
+        await deliverWebhookMessage(
+          request.delivery.webhookUrl,
+          result.text,
+          sourceLabel,
+          result.artifacts,
+        );
+        logger.info(
+          {
+            jobId: request.jobId,
+            taskId: request.taskId,
+            source: request.source,
+            delivery: 'webhook',
+            result: result.text,
+            artifactCount: result.artifacts?.length || 0,
+          },
+          'Scheduled task completed',
+        );
+        return;
+      }
+
+      if (!resolvedDeliveryChannelId) {
+        throw new Error('No Discord channel available for scheduled delivery.');
+      }
+      await deliverProactiveMessage(
+        resolvedDeliveryChannelId,
+        result.text,
+        sourceLabel,
+        result.artifacts,
+      );
       logger.info(
-        { taskId, channelId, result: result.text, artifactCount: result.artifacts?.length || 0 },
+        {
+          jobId: request.jobId,
+          taskId: request.taskId,
+          source: request.source,
+          channelId: resolvedDeliveryChannelId,
+          result: result.text,
+          artifactCount: result.artifacts?.length || 0,
+        },
         'Scheduled task completed',
       );
     },
     (error) => {
-      logger.error({ taskId, channelId, error }, 'Scheduled task failed');
+      logger.error(
+        {
+          jobId: request.jobId,
+          taskId: request.taskId,
+          source: request.source,
+          delivery: request.delivery.kind,
+          error,
+        },
+        'Scheduled task failed',
+      );
     },
+    request.sessionId,
   );
 }
 
@@ -332,6 +700,46 @@ function startOrRestartHeartbeat(): void {
   });
 }
 
+function stopMemoryConsolidationScheduler(): void {
+  if (!memoryConsolidationTimer) return;
+  clearInterval(memoryConsolidationTimer);
+  memoryConsolidationTimer = null;
+}
+
+function startOrRestartMemoryConsolidationScheduler(): void {
+  stopMemoryConsolidationScheduler();
+  const intervalHours = Math.max(
+    0,
+    Math.trunc(getConfigSnapshot().memory.consolidationIntervalHours),
+  );
+  if (intervalHours <= 0) {
+    logger.info('Memory consolidation scheduler disabled');
+    return;
+  }
+
+  const intervalMs = intervalHours * 3_600_000;
+  memoryConsolidationTimer = setInterval(() => {
+    const { decayRate } = getConfigSnapshot().memory;
+    try {
+      const report = memoryService.consolidateMemories({ decayRate });
+      if (report.memoriesDecayed > 0) {
+        logger.info(
+          {
+            decayed: report.memoriesDecayed,
+            durationMs: report.durationMs,
+            decayRate,
+          },
+          'Memory consolidation completed',
+        );
+      }
+    } catch (error) {
+      logger.warn({ error, decayRate }, 'Memory consolidation failed');
+    }
+  }, intervalMs);
+
+  logger.info({ intervalHours }, 'Memory consolidation scheduled');
+}
+
 async function main(): Promise<void> {
   logger.info('Starting HybridClaw gateway');
   initDatabase();
@@ -343,9 +751,9 @@ async function main(): Promise<void> {
   startObservabilityIngest();
   detachConfigListener = onConfigChange((next, prev) => {
     const shouldRestart =
-      next.hybridai.defaultChatbotId !== prev.hybridai.defaultChatbotId
-      || next.heartbeat.intervalMs !== prev.heartbeat.intervalMs
-      || next.heartbeat.enabled !== prev.heartbeat.enabled;
+      next.hybridai.defaultChatbotId !== prev.hybridai.defaultChatbotId ||
+      next.heartbeat.intervalMs !== prev.heartbeat.intervalMs ||
+      next.heartbeat.enabled !== prev.heartbeat.enabled;
     if (shouldRestart) {
       logger.info(
         {
@@ -358,9 +766,32 @@ async function main(): Promise<void> {
       startOrRestartHeartbeat();
     }
 
+    const schedulerChanged =
+      JSON.stringify(next.scheduler) !== JSON.stringify(prev.scheduler);
+    if (schedulerChanged) {
+      logger.info(
+        'Config changed, re-arming scheduler for updated scheduler.jobs',
+      );
+      rearmScheduler();
+    }
+
+    const memoryChanged =
+      JSON.stringify(next.memory) !== JSON.stringify(prev.memory);
+    if (memoryChanged) {
+      logger.info(
+        {
+          consolidationIntervalHours: next.memory.consolidationIntervalHours,
+          decayRate: next.memory.decayRate,
+        },
+        'Config changed, restarting memory consolidation scheduler',
+      );
+      startOrRestartMemoryConsolidationScheduler();
+    }
+
     const shouldRestartObservability =
-      JSON.stringify(next.observability) !== JSON.stringify(prev.observability)
-      || next.hybridai.defaultChatbotId !== prev.hybridai.defaultChatbotId;
+      JSON.stringify(next.observability) !==
+        JSON.stringify(prev.observability) ||
+      next.hybridai.defaultChatbotId !== prev.hybridai.defaultChatbotId;
     if (!shouldRestartObservability) return;
 
     logger.info(
@@ -374,6 +805,7 @@ async function main(): Promise<void> {
     startObservabilityIngest();
   });
   startScheduler(runScheduledTask);
+  startOrRestartMemoryConsolidationScheduler();
   proactiveFlushTimer = setInterval(() => {
     void flushQueuedProactiveMessages().catch((err) => {
       logger.warn({ err }, 'Failed to flush queued proactive messages');
@@ -383,7 +815,10 @@ async function main(): Promise<void> {
     logger.warn({ err }, 'Initial proactive queue flush failed');
   });
 
-  logger.info({ ...getGatewayStatus(), discord: !!DISCORD_TOKEN }, 'HybridClaw gateway started');
+  logger.info(
+    { ...getGatewayStatus(), discord: !!DISCORD_TOKEN },
+    'HybridClaw gateway started',
+  );
 }
 
 main().catch((err) => {