@hybridaione/hybridclaw 0.2.2 → 0.2.6

package/src/health.ts

@@ -1,21 +1,25 @@
 import fs from 'fs';
 import http, { type IncomingMessage, type ServerResponse } from 'http';
 import path from 'path';
-
-import { GATEWAY_API_TOKEN, HEALTH_HOST, HEALTH_PORT, WEB_API_TOKEN } from './config.js';
+import { runDiscordToolAction } from './channels/discord/runtime.js';
+import type { DiscordToolActionRequest } from './channels/discord/tool-actions.js';
+import {
+  GATEWAY_API_TOKEN,
+  HEALTH_HOST,
+  HEALTH_PORT,
+  WEB_API_TOKEN,
+} from './config.js';
 import {
+  type GatewayChatRequest,
+  type GatewayCommandRequest,
   getGatewayHistory,
   getGatewayStatus,
   handleGatewayCommand,
   handleGatewayMessage,
-  type GatewayCommandRequest,
-  type GatewayChatRequest,
 } from './gateway-service.js';
-import { type GatewayChatRequestBody } from './gateway-types.js';
-import { type DiscordToolActionRequest } from './channels/discord/tool-actions.js';
-import { runDiscordToolAction } from './channels/discord/runtime.js';
-import { type ToolProgressEvent } from './types.js';
+import type { GatewayChatRequestBody } from './gateway-types.js';
 import { logger } from './logger.js';
+import type { ToolProgressEvent } from './types.js';
 
 const SITE_DIR = path.resolve(process.cwd(), 'docs');
 const MAX_REQUEST_BYTES = 1_000_000; // 1MB
@@ -40,7 +44,8 @@ function isLoopbackAddress(address: string | undefined): boolean {
 
 function hasApiAuth(req: IncomingMessage): boolean {
   const authHeader = req.headers.authorization || '';
-  const gatewayTokenMatch = Boolean(GATEWAY_API_TOKEN) && authHeader === `Bearer ${GATEWAY_API_TOKEN}`;
+  const gatewayTokenMatch =
+    Boolean(GATEWAY_API_TOKEN) && authHeader === `Bearer ${GATEWAY_API_TOKEN}`;
 
   if (!WEB_API_TOKEN) {
     return gatewayTokenMatch || isLoopbackAddress(req.socket.remoteAddress);
@@ -49,8 +54,14 @@ function hasApiAuth(req: IncomingMessage): boolean {
   return gatewayTokenMatch;
 }
 
-function sendJson(res: ServerResponse, statusCode: number, payload: unknown): void {
-  res.writeHead(statusCode, { 'Content-Type': 'application/json; charset=utf-8' });
+function sendJson(
+  res: ServerResponse,
+  statusCode: number,
+  payload: unknown,
+): void {
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json; charset=utf-8',
+  });
   res.end(JSON.stringify(payload, null, 2));
 }
 
@@ -81,12 +92,15 @@ function resolveSiteFile(pathname: string): string | null {
   const normalized = path.normalize(cleanPath).replace(/^(\.\.(\/|\\|$))+/, '');
   const candidate = path.resolve(SITE_DIR, `.${normalized}`);
   if (!candidate.startsWith(SITE_DIR)) return null;
-  if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile()) return null;
+  if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile())
+    return null;
   return candidate;
 }
 
 function serveStatic(pathname: string, res: ServerResponse): boolean {
-  const filePath = resolveSiteFile(pathname === '/chat' ? '/chat.html' : pathname);
+  const filePath = resolveSiteFile(
+    pathname === '/chat' ? '/chat.html' : pathname,
+  );
   if (!filePath) return false;
   const ext = path.extname(filePath).toLowerCase();
   const mimeType = MIME_TYPES[ext] || 'application/octet-stream';
@@ -95,8 +109,11 @@ function serveStatic(pathname: string, res: ServerResponse): boolean {
   return true;
 }
 
-async function handleApiChat(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const body = await readJsonBody(req) as Partial<ApiChatRequestBody>;
+async function handleApiChat(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<void> {
+  const body = (await readJsonBody(req)) as Partial<ApiChatRequestBody>;
   const wantsStream = body.stream === true;
 
   const content = body.content?.trim();
@@ -177,7 +194,10 @@ async function handleApiChatStream(
         error: errorMessage,
       },
     });
-    logger.error({ error, reqUrl: '/api/chat' }, 'Gateway streaming chat failed');
+    logger.error(
+      { error, reqUrl: '/api/chat' },
+      'Gateway streaming chat failed',
+    );
   } finally {
     if (!res.writableEnded) {
       res.end();
@@ -191,11 +211,18 @@ async function handleApiChatStream(
   });
 }
 
-async function handleApiCommand(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const body = await readJsonBody(req) as Partial<GatewayCommandRequest>;
-  const args = Array.isArray(body.args) ? body.args.map((value) => String(value)) : [];
+async function handleApiCommand(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<void> {
+  const body = (await readJsonBody(req)) as Partial<GatewayCommandRequest>;
+  const args = Array.isArray(body.args)
+    ? body.args.map((value) => String(value))
+    : [];
   if (args.length === 0) {
-    sendJson(res, 400, { error: 'Missing command. Provide non-empty `args` array.' });
+    sendJson(res, 400, {
+      error: 'Missing command. Provide non-empty `args` array.',
+    });
     return;
   }
 
@@ -209,12 +236,20 @@ async function handleApiCommand(req: IncomingMessage, res: ServerResponse): Prom
   sendJson(res, result.kind === 'error' ? 400 : 200, result);
 }
 
-async function handleApiDiscordAction(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const body = await readJsonBody(req) as ApiDiscordActionRequestBody;
+async function handleApiDiscordAction(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<void> {
+  const body = (await readJsonBody(req)) as ApiDiscordActionRequestBody;
   const action = typeof body.action === 'string' ? body.action.trim() : '';
-  if (action !== 'read' && action !== 'member-info' && action !== 'channel-info') {
+  if (
+    action !== 'read' &&
+    action !== 'member-info' &&
+    action !== 'channel-info'
+  ) {
     sendJson(res, 400, {
-      error: 'Invalid `action`. Allowed: "read", "member-info", "channel-info".',
+      error:
+        'Invalid `action`. Allowed: "read", "member-info", "channel-info".',
     });
     return;
   }
@@ -268,7 +303,9 @@ export function startHealthServer(): void {
 
     if (pathname.startsWith('/api/')) {
       if (!hasApiAuth(req)) {
-        sendJson(res, 401, { error: 'Unauthorized. Set `Authorization: Bearer <WEB_API_TOKEN>`.' });
+        sendJson(res, 401, {
+          error: 'Unauthorized. Set `Authorization: Bearer <WEB_API_TOKEN>`.',
+        });
         return;
       }
 
@@ -312,6 +349,9 @@ export function startHealthServer(): void {
   });
 
   server.listen(HEALTH_PORT, HEALTH_HOST, () => {
-    logger.info({ host: HEALTH_HOST, port: HEALTH_PORT }, 'Gateway HTTP server started');
+    logger.info(
+      { host: HEALTH_HOST, port: HEALTH_PORT },
+      'Gateway HTTP server started',
+    );
   });
 }

package/src/heartbeat.ts

@@ -2,17 +2,35 @@
  * Heartbeat — periodic poll so the agent can proactively check tasks,
  * maintain memory, and reach out when needed.
  */
-import { HEARTBEAT_CHANNEL, HEARTBEAT_ENABLED, HYBRIDAI_CHATBOT_ID, HYBRIDAI_ENABLE_RAG, HYBRIDAI_MODEL } from './config.js';
+
 import { runAgent } from './agent.js';
-import { getConversationHistory, getOrCreateSession, getTasksForSession, storeMessage } from './db.js';
+import {
+  emitToolExecutionAuditEvents,
+  makeAuditRunId,
+  recordAuditEvent,
+} from './audit-events.js';
+import {
+  HEARTBEAT_CHANNEL,
+  HEARTBEAT_ENABLED,
+  HYBRIDAI_CHATBOT_ID,
+  HYBRIDAI_ENABLE_RAG,
+  HYBRIDAI_MODEL,
+} from './config.js';
+import { buildConversationContext } from './conversation.js';
+import { getTasksForSession } from './db.js';
 import { logger } from './logger.js';
-import { processSideEffects } from './side-effects.js';
+import { memoryService } from './memory-service.js';
+import {
+  isWithinActiveHours,
+  proactiveWindowLabel,
+} from './proactive-policy.js';
 import { maybeCompactSession } from './session-maintenance.js';
 import { appendSessionTranscript } from './session-transcripts.js';
-import { buildConversationContext } from './conversation.js';
-import { isWithinActiveHours, proactiveWindowLabel } from './proactive-policy.js';
-import { emitToolExecutionAuditEvents, makeAuditRunId, recordAuditEvent } from './audit-events.js';
-import { estimateTokenCountFromMessages, estimateTokenCountFromText } from './token-efficiency.js';
+import { processSideEffects } from './side-effects.js';
+import {
+  estimateTokenCountFromMessages,
+  estimateTokenCountFromText,
+} from './token-efficiency.js';
 
 const HEARTBEAT_PROMPT =
   '[Heartbeat poll] Check HEARTBEAT.md for periodic tasks. If nothing needs attention, reply HEARTBEAT_OK.';
@@ -53,7 +71,10 @@ let timer: ReturnType<typeof setInterval> | null = null;
 let running = false;
 
 function isHeartbeatOk(text: string): boolean {
-  const normalized = text.trim().replace(/[^a-z_]/gi, '').toUpperCase();
+  const normalized = text
+    .trim()
+    .replace(/[^a-z_]/gi, '')
+    .toUpperCase();
   return normalized === 'HEARTBEATOK' || normalized.startsWith('HEARTBEATOK');
 }
 
@@ -75,7 +96,10 @@ export function startHeartbeat(
       return;
     }
     if (!isWithinActiveHours()) {
-      logger.debug({ activeHours: proactiveWindowLabel() }, 'Heartbeat skipped — outside active hours window');
+      logger.debug(
+        { activeHours: proactiveWindowLabel() },
+        'Heartbeat skipped — outside active hours window',
+      );
       return;
     }
     running = true;
@@ -87,13 +111,24 @@ export function startHeartbeat(
     let turnIndex = 1;
 
     try {
-      const session = getOrCreateSession(sessionId, null, channelId);
+      const session = memoryService.getOrCreateSession(
+        sessionId,
+        null,
+        channelId,
+      );
       turnIndex = session.message_count + 1;
 
-      const history = getConversationHistory(sessionId, MAX_HEARTBEAT_HISTORY);
+      const history = memoryService.getConversationHistory(
+        sessionId,
+        MAX_HEARTBEAT_HISTORY,
+      );
+      const memoryContext = memoryService.buildPromptMemoryContext({
+        session,
+        query: HEARTBEAT_PROMPT,
+      });
       const { messages } = buildConversationContext({
         agentId,
-        sessionSummary: session.session_summary,
+        sessionSummary: memoryContext.promptSummary,
         history,
       });
       messages.push({ role: 'user', content: HEARTBEAT_PROMPT });
@@ -141,13 +176,20 @@ export function startHeartbeat(
         toolExecutions: output.toolExecutions || [],
       });
       const tokenUsage = output.tokenUsage;
-      const estimatedPromptTokens = tokenUsage?.estimatedPromptTokens || estimateTokenCountFromMessages(messages);
-      const estimatedCompletionTokens = tokenUsage?.estimatedCompletionTokens || estimateTokenCountFromText(output.result || '');
-      const estimatedTotalTokens = tokenUsage?.estimatedTotalTokens || (estimatedPromptTokens + estimatedCompletionTokens);
+      const estimatedPromptTokens =
+        tokenUsage?.estimatedPromptTokens ||
+        estimateTokenCountFromMessages(messages);
+      const estimatedCompletionTokens =
+        tokenUsage?.estimatedCompletionTokens ||
+        estimateTokenCountFromText(output.result || '');
+      const estimatedTotalTokens =
+        tokenUsage?.estimatedTotalTokens ||
+        estimatedPromptTokens + estimatedCompletionTokens;
       const apiUsageAvailable = tokenUsage?.apiUsageAvailable === true;
       const apiPromptTokens = tokenUsage?.apiPromptTokens || 0;
       const apiCompletionTokens = tokenUsage?.apiCompletionTokens || 0;
-      const apiTotalTokens = tokenUsage?.apiTotalTokens || (apiPromptTokens + apiCompletionTokens);
+      const apiTotalTokens =
+        tokenUsage?.apiTotalTokens || apiPromptTokens + apiCompletionTokens;
       recordAuditEvent({
         sessionId,
         runId,
@@ -158,9 +200,15 @@ export function startHeartbeat(
           durationMs: Date.now() - startedAt,
           toolCallCount: (output.toolExecutions || []).length,
           modelCalls: tokenUsage ? Math.max(1, tokenUsage.modelCalls) : 0,
-          promptTokens: apiUsageAvailable ? apiPromptTokens : estimatedPromptTokens,
-          completionTokens: apiUsageAvailable ? apiCompletionTokens : estimatedCompletionTokens,
-          totalTokens: apiUsageAvailable ? apiTotalTokens : estimatedTotalTokens,
+          promptTokens: apiUsageAvailable
+            ? apiPromptTokens
+            : estimatedPromptTokens,
+          completionTokens: apiUsageAvailable
+            ? apiCompletionTokens
+            : estimatedCompletionTokens,
+          totalTokens: apiUsageAvailable
+            ? apiTotalTokens
+            : estimatedTotalTokens,
           estimatedPromptTokens,
           estimatedCompletionTokens,
           estimatedTotalTokens,
@@ -241,8 +289,19 @@ export function startHeartbeat(
       }
 
       // Real content — persist and deliver
-      storeMessage(sessionId, 'heartbeat', 'heartbeat', 'user', HEARTBEAT_PROMPT);
-      storeMessage(sessionId, 'assistant', null, 'assistant', result);
+      memoryService.storeTurn({
+        sessionId,
+        user: {
+          userId: 'heartbeat',
+          username: 'heartbeat',
+          content: HEARTBEAT_PROMPT,
+        },
+        assistant: {
+          userId: 'assistant',
+          username: null,
+          content: result,
+        },
+      });
       appendSessionTranscript(agentId, {
         sessionId,
         channelId: heartbeatChannelId,
@@ -267,7 +326,10 @@ export function startHeartbeat(
         model: HYBRIDAI_MODEL,
         channelId: heartbeatChannelId,
       });
-      logger.info({ length: result.length }, 'Heartbeat: agent has something to say');
+      logger.info(
+        { length: result.length },
+        'Heartbeat: agent has something to say',
+      );
       recordAuditEvent({
         sessionId,
         runId,

package/src/hybridai-bots.ts

@@ -1,4 +1,4 @@
-import { HYBRIDAI_BASE_URL, getHybridAIApiKey } from './config.js';
+import { getHybridAIApiKey, HYBRIDAI_BASE_URL } from './config.js';
 import type { HybridAIBot } from './types.js';
 
 interface BotCacheEntry {
@@ -10,18 +10,27 @@ let botCache: BotCacheEntry | null = null;
 
 function normalizeBots(payload: unknown): HybridAIBot[] {
   const data = payload as
-    | { data?: Record<string, unknown>[]; bots?: Record<string, unknown>[]; items?: Record<string, unknown>[] }
+    | {
+        data?: Record<string, unknown>[];
+        bots?: Record<string, unknown>[];
+        items?: Record<string, unknown>[];
+      }
     | Record<string, unknown>[];
-  const raw = Array.isArray(data) ? data : (data.data || data.bots || data.items || []);
+  const raw = Array.isArray(data)
+    ? data
+    : data.data || data.bots || data.items || [];
 
   return raw.map((item) => ({
     id: String(item.id ?? item._id ?? item.chatbot_id ?? item.bot_id ?? ''),
     name: String(item.bot_name ?? item.name ?? 'Unnamed'),
-    description: item.description != null ? String(item.description) : undefined,
+    description:
+      item.description != null ? String(item.description) : undefined,
   }));
 }
 
-export async function fetchHybridAIBots(options?: { cacheTtlMs?: number }): Promise<HybridAIBot[]> {
+export async function fetchHybridAIBots(options?: {
+  cacheTtlMs?: number;
+}): Promise<HybridAIBot[]> {
   const cacheTtlMs = Math.max(0, options?.cacheTtlMs ?? 0);
   const now = Date.now();
 

package/src/instruction-approval-audit.ts

@@ -22,7 +22,10 @@ function ensureAuditReady(): boolean {
     initDatabase({ quiet: true });
     auditReady = true;
   } catch (err) {
-    logger.warn({ err }, 'Failed to initialize DB for instruction approval audit');
+    logger.warn(
+      { err },
+      'Failed to initialize DB for instruction approval audit',
+    );
     auditReady = false;
   }
   return auditReady;

package/src/instruction-integrity.ts

@@ -2,9 +2,18 @@ import { createHash } from 'crypto';
 import fs from 'fs';
 import path from 'path';
 
-export const INSTRUCTION_FILES = ['AGENTS.md', 'SECURITY.md', 'TRUST_MODEL.md'] as const;
+export const INSTRUCTION_FILES = [
+  'AGENTS.md',
+  'SECURITY.md',
+  'TRUST_MODEL.md',
+] as const;
 export const INSTRUCTION_BASELINE_VERSION = 1;
-export const INSTRUCTION_BASELINE_PATH = path.join(process.cwd(), 'data', 'audit', 'instruction-hashes.json');
+export const INSTRUCTION_BASELINE_PATH = path.join(
+  process.cwd(),
+  'data',
+  'audit',
+  'instruction-hashes.json',
+);
 
 export interface InstructionHashBaseline {
   version: number;
@@ -29,7 +38,9 @@ export interface InstructionIntegrityResult {
   files: InstructionFileResult[];
 }
 
-export function summarizeInstructionIntegrity(result: InstructionIntegrityResult): string {
+export function summarizeInstructionIntegrity(
+  result: InstructionIntegrityResult,
+): string {
   if (result.baselineError) return `baseline.invalid (${result.baselineError})`;
   if (!result.baseline) return 'baseline.missing';
 
@@ -62,19 +73,24 @@ export function loadInstructionBaseline(): InstructionHashBaseline | null {
 
   const raw = fs.readFileSync(INSTRUCTION_BASELINE_PATH, 'utf-8');
   const parsed = JSON.parse(raw) as unknown;
-  if (!isRecord(parsed)) throw new Error('Instruction baseline is not a JSON object.');
+  if (!isRecord(parsed))
+    throw new Error('Instruction baseline is not a JSON object.');
 
   const version = parsed.version;
   const approvedAt = parsed.approvedAt;
   const files = parsed.files;
-  if (typeof version !== 'number') throw new Error('Instruction baseline is missing numeric `version`.');
+  if (typeof version !== 'number')
+    throw new Error('Instruction baseline is missing numeric `version`.');
   if (version !== INSTRUCTION_BASELINE_VERSION) {
-    throw new Error(`Instruction baseline version ${String(version)} is unsupported.`);
+    throw new Error(
+      `Instruction baseline version ${String(version)} is unsupported.`,
+    );
   }
   if (typeof approvedAt !== 'string' || !approvedAt.trim()) {
     throw new Error('Instruction baseline is missing `approvedAt`.');
   }
-  if (!isRecord(files)) throw new Error('Instruction baseline is missing `files` object.');
+  if (!isRecord(files))
+    throw new Error('Instruction baseline is missing `files` object.');
 
   const normalizedFiles: Record<string, string> = {};
   for (const relPath of INSTRUCTION_FILES) {
@@ -95,7 +111,9 @@ export function approveInstructionBaseline(): InstructionHashBaseline {
   const hashes = computeCurrentHashes();
   const missing = INSTRUCTION_FILES.filter((relPath) => !hashes[relPath]);
   if (missing.length > 0) {
-    throw new Error(`Approval failed: missing instruction files (${missing.join(', ')}).`);
+    throw new Error(
+      `Approval failed: missing instruction files (${missing.join(', ')}).`,
+    );
   }
 
   const baseline: InstructionHashBaseline = {
@@ -165,7 +183,10 @@ export function verifyInstructionBaseline(): InstructionIntegrityResult {
     };
   });
 
-  const ok = baselineError === null && baseline !== null && files.every((file) => file.status === 'ok');
+  const ok =
+    baselineError === null &&
+    baseline !== null &&
+    files.every((file) => file.status === 'ok');
   return {
     ok,
     baselinePath: INSTRUCTION_BASELINE_PATH,

package/src/ipc.ts

@@ -46,7 +46,11 @@ export function ensureAgentDirs(agentId: string): void {
  * When omitApiKey is set, the apiKey field is excluded from the file on disk
  * (the container already has the key in memory from the initial stdin payload).
  */
-export function writeInput(sessionId: string, input: ContainerInput, opts?: { omitApiKey?: boolean }): string {
+export function writeInput(
+  sessionId: string,
+  input: ContainerInput,
+  opts?: { omitApiKey?: boolean },
+): string {
   const dir = ipcDir(sessionId);
   const inputPath = path.join(dir, 'input.json');
   const toWrite = opts?.omitApiKey ? { ...input, apiKey: '' } : input;
@@ -67,7 +71,10 @@ function interruptedOutput(): ContainerOutput {
   };
 }
 
-async function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<boolean> {
+async function sleepWithAbort(
+  ms: number,
+  signal?: AbortSignal,
+): Promise<boolean> {
   if (!signal) {
     await new Promise((resolve) => setTimeout(resolve, ms));
     return false;
@@ -109,8 +116,16 @@ export async function readOutput(
       const stat = fs.statSync(outputPath);
       if (stat.size > CONTAINER_MAX_OUTPUT_SIZE) {
         fs.unlinkSync(outputPath);
-        logger.warn({ sessionId, size: stat.size, limit: CONTAINER_MAX_OUTPUT_SIZE }, 'Container output exceeded size limit');
-        return { status: 'error', result: null, toolsUsed: [], error: `Output too large (${stat.size} bytes, limit ${CONTAINER_MAX_OUTPUT_SIZE})` };
+        logger.warn(
+          { sessionId, size: stat.size, limit: CONTAINER_MAX_OUTPUT_SIZE },
+          'Container output exceeded size limit',
+        );
+        return {
+          status: 'error',
+          result: null,
+          toolsUsed: [],
+          error: `Output too large (${stat.size} bytes, limit ${CONTAINER_MAX_OUTPUT_SIZE})`,
+        };
       }
       try {
         const raw = fs.readFileSync(outputPath, 'utf-8');
@@ -152,7 +167,10 @@ export function cleanupIpc(sessionId: string): void {
 /**
  * Get host paths for container mounting.
  */
-export function getSessionPaths(sessionId: string, agentId: string): {
+export function getSessionPaths(
+  sessionId: string,
+  agentId: string,
+): {
   ipcPath: string;
   workspacePath: string;
 } {

package/src/logger.ts

@@ -12,7 +12,10 @@ export const logger = pino({
 onRuntimeConfigChange((next, prev) => {
   if (next.ops.logLevel !== prev.ops.logLevel) {
     logger.level = next.ops.logLevel;
-    logger.info({ level: next.ops.logLevel }, 'Logger level updated from config.json');
+    logger.info(
+      { level: next.ops.logLevel },
+      'Logger level updated from config.json',
+    );
   }
 });
 

package/src/memory-consolidation.ts

@@ -0,0 +1,41 @@
+import type { MemoryBackend } from './memory-service.js';
+
+export interface MemoryConsolidationConfig {
+  decayRate: number;
+  staleAfterDays: number;
+  minConfidence: number;
+}
+
+export interface MemoryConsolidationReport {
+  memoriesDecayed: number;
+  durationMs: number;
+}
+
+export class MemoryConsolidationEngine {
+  private readonly backend: MemoryBackend;
+  private readonly config: MemoryConsolidationConfig;
+
+  constructor(backend: MemoryBackend, config: MemoryConsolidationConfig) {
+    this.backend = backend;
+    this.config = config;
+  }
+
+  consolidate(
+    overrides?: Partial<MemoryConsolidationConfig>,
+  ): MemoryConsolidationReport {
+    const start = Date.now();
+    const config = {
+      ...this.config,
+      ...(overrides || {}),
+    };
+    const memoriesDecayed = this.backend.decaySemanticMemories({
+      decayRate: config.decayRate,
+      staleAfterDays: config.staleAfterDays,
+      minConfidence: config.minConfidence,
+    });
+    return {
+      memoriesDecayed,
+      durationMs: Math.max(0, Date.now() - start),
+    };
+  }
+}