@massa-ai/mcp-client 1.37.0 → 1.38.0

package/dist/config-cli.js

@@ -108231,6 +108231,7 @@ var init_registry = __esm(() => {
     search_analytics: { storeId: "search_analytics", identityColumn: "project_id", mutable: true },
     search_events: { storeId: "search_events", identityColumn: "project_id", mutable: true },
     synapse_sessions: { storeId: "synapse_sessions", identityColumn: "workspace_id", mutable: true },
+    managed_runs: { storeId: "managed_runs", identityColumn: "project_id", mutable: true },
     operation_log: { storeId: "operation_log", identityColumn: "project_id", mutable: false },
     project_identity_operations: {
       storeId: "project_identity_operations",
@@ -127386,1409 +127387,1427 @@ var init_observation_consolidation_job = __esm(() => {
   observationConsolidationJob = new ObservationConsolidationJob;
 });
 
-// ../../packages/core/dist/services/scheduler/scheduler-defaults.js
-function envBool2(key, fallback) {
-  const raw2 = process.env[key];
-  if (raw2 === undefined)
-    return fallback;
-  return raw2 === "true" || raw2 === "1";
-}
-function envNum2(key, fallback) {
-  const raw2 = process.env[key];
-  if (raw2 === undefined || raw2 === "")
-    return fallback;
-  const n = Number(raw2);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
+// ../../packages/core/dist/services/checkpoint/checkpoint-store-pg.js
+function toNum4(v) {
+  if (v == null)
+    return null;
+  return typeof v === "bigint" ? Number(v) : v;
 }
-function applySafeDefaults(job) {
-  if (!envBool2("MASSA_AI_SCHEDULER_SAFE_DEFAULTS", false)) {
-    return job;
-  }
-  if (job.jobKind === "memory-consolidation") {
-    const currentInterval = job.schedule.intervalMs ?? THIRTY_MIN;
-    const safeInterval = Math.max(currentInterval, THIRTY_MIN);
-    return {
-      ...job,
-      defaultEnabled: true,
-      schedule: { type: "interval", intervalMs: safeInterval }
-    };
-  }
-  if (job.jobKind === "decay-sweep") {
-    const currentInterval = job.schedule.intervalMs ?? ONE_HOUR;
-    const safeInterval = Math.max(currentInterval, ONE_HOUR);
-    return {
-      ...job,
-      defaultEnabled: true,
-      schedule: { type: "interval", intervalMs: safeInterval }
-    };
-  }
-  return job;
+function compressState(state) {
+  const json3 = JSON.stringify(state);
+  return Buffer.from(Bun.deflateSync(Buffer.from(json3, "utf-8")));
 }
-function registerDefaultJobs(scheduler) {
-  scheduler.registerHandler("memory-consolidation", async () => {
-    const { memoryConsolidationJob: memoryConsolidationJob2 } = await Promise.resolve().then(() => (init_memory_consolidation_job(), exports_memory_consolidation_job));
-    await memoryConsolidationJob2.consolidate();
-  });
-  scheduler.registerHandler("decay-sweep", async () => {
-    const { memoryConsolidationJob: memoryConsolidationJob2 } = await Promise.resolve().then(() => (init_memory_consolidation_job(), exports_memory_consolidation_job));
-    await memoryConsolidationJob2.consolidate();
-  });
-  scheduler.registerHandler("auto-improve", async (job) => {
-    const { autoImproveJob: autoImproveJob2 } = await Promise.resolve().then(() => (init_auto_improve_job(), exports_auto_improve_job));
-    const projectId = job.payload?.projectId ?? "default";
-    await autoImproveJob2.runOnce(projectId);
-  });
-  scheduler.registerHandler("observation-bridge", async (job) => {
-    const { observationConsolidationJob: observationConsolidationJob2 } = await Promise.resolve().then(() => (init_observation_consolidation_job(), exports_observation_consolidation_job));
-    const projectId = job.payload?.projectId ?? "default";
-    await observationConsolidationJob2.runOnce(projectId);
-  });
-  for (const rawDef of DEFAULT_SCHEDULED_JOBS) {
-    const def = applySafeDefaults(rawDef);
-    const enabled = envBool2(def.enableEnvVar, def.defaultEnabled);
-    const intervalMs = envNum2(def.intervalEnvVar, def.schedule.intervalMs ?? THIRTY_MIN);
-    const schedule = { type: "interval", intervalMs };
-    scheduler.registerOrResumeJob({
-      id: def.id,
-      name: def.name,
-      jobKind: def.jobKind,
-      schedule,
-      nextRunAt: 0,
-      enabled
-    });
-  }
-  logger.info("Scheduler default jobs registered", {
-    handlers: scheduler.registeredKinds(),
-    jobs: DEFAULT_SCHEDULED_JOBS.length
-  });
+function decompressState(data) {
+  const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  const inflated = Bun.inflateSync(new Uint8Array(buf));
+  return JSON.parse(Buffer.from(inflated).toString("utf-8"));
 }
-var MIN, THIRTY_MIN, ONE_HOUR, DEFAULT_SCHEDULED_JOBS;
-var init_scheduler_defaults = __esm(() => {
-  init_dist();
-  MIN = 60 * 1000;
-  THIRTY_MIN = 30 * MIN;
-  ONE_HOUR = 60 * MIN;
-  DEFAULT_SCHEDULED_JOBS = [
-    {
-      id: "scheduled-memory-consolidation",
-      name: "Memory Consolidation (clock)",
-      jobKind: "memory-consolidation",
-      schedule: { type: "interval", intervalMs: THIRTY_MIN },
-      defaultEnabled: false,
-      enableEnvVar: "MASSA_AI_SCHEDULER_CONSOLIDATION_ENABLED",
-      intervalEnvVar: "MASSA_AI_SCHEDULER_CONSOLIDATION_INTERVAL_MS"
-    },
-    {
-      id: "scheduled-decay-sweep",
-      name: "Decay Sweep (clock)",
-      jobKind: "decay-sweep",
-      schedule: { type: "interval", intervalMs: ONE_HOUR },
-      defaultEnabled: false,
-      enableEnvVar: "MASSA_AI_SCHEDULER_DECAY_ENABLED",
-      intervalEnvVar: "MASSA_AI_SCHEDULER_DECAY_INTERVAL_MS"
-    },
-    {
-      id: "scheduled-auto-improve",
-      name: "Auto-Improve (clock)",
-      jobKind: "auto-improve",
-      schedule: { type: "interval", intervalMs: THIRTY_MIN },
-      defaultEnabled: false,
-      enableEnvVar: "MASSA_AI_SCHEDULER_AUTO_IMPROVE_ENABLED",
-      intervalEnvVar: "MASSA_AI_SCHEDULER_AUTO_IMPROVE_INTERVAL_MS"
-    },
-    {
-      id: "scheduled-observation-bridge",
-      name: "Observation Bridge (clock)",
-      jobKind: "observation-bridge",
-      schedule: { type: "interval", intervalMs: THIRTY_MIN },
-      defaultEnabled: false,
-      enableEnvVar: "MASSA_AI_SCHEDULER_OBSERVATION_BRIDGE_ENABLED",
-      intervalEnvVar: "MASSA_AI_SCHEDULER_OBSERVATION_BRIDGE_INTERVAL_MS"
-    }
-  ];
-});
-
-// ../../packages/core/dist/services/scheduler/index.js
-var init_scheduler2 = __esm(() => {
-  init_scheduler();
-  init_scheduler_store_pg();
-  init_scheduler_store_factory();
-  init_scheduler_cron();
-  init_scheduler_defaults();
-});
 
-// ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs11 from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path16 from "path";
-function getModelsDevClient() {
-  if (!clientInstance) {
-    clientInstance = new ModelsDevClient;
+class PgCheckpointStore {
+  prisma;
+  mirror = new Map;
+  hydrated = false;
+  hydrating = null;
+  hydrateFailedAt = 0;
+  static HYDRATE_RETRY_MS = 30000;
+  inflight = new Map;
+  getClient() {
+    if (!this.prisma)
+      this.prisma = getPrismaClient2();
+    return this.prisma;
   }
-  return clientInstance;
-}
-var ModelsDevClient, clientInstance = null;
-var init_models_dev_client = __esm(() => {
-  init_dist();
-  init_dist();
-  ModelsDevClient = class ModelsDevClient {
-    static API_URL = "https://models.dev/api.json";
-    static MEMORY_CACHE_TTL = 3600 * 1000;
-    static LOCAL_CACHE_TTL = 24 * 3600 * 1000;
-    static LOCAL_CACHE_FILE = "pricing-cache.json";
-    memoryCache = null;
-    memoryCacheTimestamp = 0;
-    getLocalCachePath() {
-      const dataDir = config.get("dataDir");
-      return path16.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+  ensureHydrated() {
+    if (this.hydrated)
+      return Promise.resolve();
+    if (this.hydrating)
+      return this.hydrating;
+    if (this.hydrateFailedAt > 0 && Date.now() - this.hydrateFailedAt < PgCheckpointStore.HYDRATE_RETRY_MS) {
+      return Promise.resolve();
     }
-    async loadLocalCache() {
-      const cachePath = this.getLocalCachePath();
+    this.hydrating = (async () => {
       try {
-        if (!existsSync4(cachePath)) {
-          return null;
-        }
-        const content = await fs11.readFile(cachePath, "utf-8");
-        const data = JSON.parse(content);
-        const age = Date.now() - data.timestamp;
-        if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
-          logger.debug("Local pricing cache expired", {
-            ageHours: Math.round(age / 3600000)
-          });
+        const prisma2 = this.getClient();
+        const rows = await prisma2.$queryRaw`
+          SELECT * FROM task_checkpoints
+        `;
+        const next = new Map;
+        const dbIds = new Set;
+        for (const row of rows) {
+          dbIds.add(row.id);
+          next.set(row.id, this.rowToCheckpoint(row));
         }
-        const models = new Map;
-        for (const [key, value] of Object.entries(data.models)) {
-          models.set(key, value);
+        for (const [id, existing] of this.mirror) {
+          if (!dbIds.has(id))
+            next.set(id, existing);
         }
-        logger.debug("Loaded pricing from local cache", {
-          models: models.size,
-          ageHours: Math.round(age / 3600000)
+        this.mirror = next;
+        this.hydrated = true;
+        this.hydrateFailedAt = 0;
+        logger.info("PgCheckpointStore hydrated", {
+          rows: this.mirror.size
         });
-        return models;
-      } catch (error51) {
-        logger.debug("Failed to load local pricing cache", {
-          error: error51.message
+      } catch (e) {
+        this.hydrateFailedAt = Date.now();
+        logger.warn("PgCheckpointStore hydrate failed (best-effort)", {
+          error: e.message
         });
-        return null;
+      } finally {
+        this.hydrating = null;
       }
+    })();
+    return this.hydrating;
+  }
+  rowToCheckpoint(row) {
+    const state = decompressState(row.state);
+    const storedSchemaVersion = toNum4(row.state_schema_version);
+    if (storedSchemaVersion != null) {
+      const storedVersionString = String(storedSchemaVersion);
+      const normalized = /^\d+$/u.test(storedVersionString) ? `${storedVersionString}.0.0` : storedVersionString;
+      assertSchemaSupported("checkpoint", normalized, SUPPORTED_CHECKPOINT_STATE_SCHEMA_VERSION);
     }
-    async saveLocalCache(models) {
-      const cachePath = this.getLocalCachePath();
-      try {
-        const dir = path16.dirname(cachePath);
-        await fs11.mkdir(dir, { recursive: true });
-        const data = {
-          timestamp: Date.now(),
-          version: "1.0.0",
-          models: Object.fromEntries(models)
-        };
-        await fs11.writeFile(cachePath, JSON.stringify(data), "utf-8");
-        logger.debug("Saved pricing to local cache", {
-          models: models.size,
-          path: cachePath
-        });
-      } catch (error51) {
-        logger.warn("Failed to save local pricing cache", {
-          error: error51.message
-        });
-      }
-    }
-    getBundledDefaults() {
-      const models = new Map;
-      const defaults3 = [
-        {
-          id: "ollama/nomic-embed-text",
-          name: "Nomic Embed Text",
-          provider: "Ollama",
-          family: "nomic",
-          inputCostPerMillion: 0,
-          outputCostPerMillion: 0,
-          contextWindow: 8192
-        },
-        {
-          id: "ollama/all-minilm",
-          name: "All MiniLM",
-          provider: "Ollama",
-          family: "minilm",
-          inputCostPerMillion: 0,
-          outputCostPerMillion: 0,
-          contextWindow: 512
-        },
-        {
-          id: "ollama/mxbai-embed-large",
-          name: "MxBai Embed Large",
-          provider: "Ollama",
-          family: "mxbai",
-          inputCostPerMillion: 0,
-          outputCostPerMillion: 0,
-          contextWindow: 512
-        },
-        {
-          id: "mistral-embed",
-          name: "Mistral Embed",
-          provider: "Mistral",
-          family: "mistral",
-          inputCostPerMillion: 0.1,
-          outputCostPerMillion: 0,
-          contextWindow: 8192
-        },
-        {
-          id: "codestral-embed",
-          name: "Codestral Embed",
-          provider: "Mistral",
-          family: "codestral",
-          inputCostPerMillion: 0.1,
-          outputCostPerMillion: 0,
-          contextWindow: 32768
-        },
-        {
-          id: "mistral-small-latest",
-          name: "Mistral Small",
-          provider: "Mistral",
-          family: "mistral",
-          inputCostPerMillion: 0.2,
-          outputCostPerMillion: 0.6,
-          contextWindow: 32768,
-          maxOutputTokens: 8192
-        },
-        {
-          id: "text-embedding-3-small",
-          name: "Text Embedding 3 Small",
-          provider: "OpenAI",
-          family: "embedding",
-          inputCostPerMillion: 0.02,
-          outputCostPerMillion: 0,
-          contextWindow: 8191
-        },
-        {
-          id: "gpt-4o-mini",
-          name: "GPT-4o Mini",
-          provider: "OpenAI",
-          family: "gpt-4",
-          inputCostPerMillion: 0.15,
-          outputCostPerMillion: 0.6,
-          contextWindow: 128000,
-          maxOutputTokens: 16384
-        },
-        {
-          id: "claude-3-haiku-20240307",
-          name: "Claude 3 Haiku",
-          provider: "Anthropic",
-          family: "claude-3",
-          inputCostPerMillion: 0.25,
-          outputCostPerMillion: 1.25,
-          contextWindow: 200000,
-          maxOutputTokens: 4096
-        },
-        {
-          id: "claude-3-5-sonnet-20241022",
-          name: "Claude 3.5 Sonnet",
-          provider: "Anthropic",
-          family: "claude-3.5",
-          inputCostPerMillion: 3,
-          outputCostPerMillion: 15,
-          contextWindow: 200000,
-          maxOutputTokens: 8192
-        },
-        {
-          id: "gemini-1.5-flash",
-          name: "Gemini 1.5 Flash",
-          provider: "Google",
-          family: "gemini",
-          inputCostPerMillion: 0.075,
-          outputCostPerMillion: 0.3,
-          contextWindow: 1e6,
-          maxOutputTokens: 8192
-        },
-        {
-          id: "embed-english-v3.0",
-          name: "Embed English v3",
-          provider: "Cohere",
-          family: "embed",
-          inputCostPerMillion: 0.1,
-          outputCostPerMillion: 0,
-          contextWindow: 512
-        }
-      ];
-      for (const pricing of defaults3) {
-        models.set(pricing.id, pricing);
-      }
-      logger.info("Using bundled pricing defaults (offline mode)", {
-        models: models.size
-      });
-      return models;
-    }
-    async fetchAllModels() {
-      if (this.memoryCache && Date.now() - this.memoryCacheTimestamp < ModelsDevClient.MEMORY_CACHE_TTL) {
-        logger.debug("Using in-memory pricing cache");
-        return this.memoryCache;
-      }
-      const localCache = await this.loadLocalCache();
-      let remoteModels = null;
-      try {
-        remoteModels = await this.fetchRemote();
-        await this.saveLocalCache(remoteModels);
-      } catch (error51) {
-        logger.debug("Remote pricing fetch failed (offline?)", {
-          error: error51.message
-        });
-      }
-      let result;
-      if (remoteModels) {
-        result = remoteModels;
-        logger.debug("Using remote pricing data");
-      } else if (localCache) {
-        result = localCache;
-        logger.info("Using local pricing cache (offline mode)");
-      } else {
-        result = this.getBundledDefaults();
-      }
-      this.memoryCache = result;
-      this.memoryCacheTimestamp = Date.now();
-      return result;
-    }
-    async fetchRemote() {
-      const controller = new AbortController;
-      const timeout = setTimeout(() => controller.abort(), 1e4);
-      try {
-        logger.info("Fetching pricing data from models.dev API");
-        const response = await fetch(ModelsDevClient.API_URL, {
-          signal: controller.signal
-        });
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        const models = new Map;
-        let totalModels = 0;
-        let modelsWithPricing = 0;
-        for (const [providerId, provider] of Object.entries(data)) {
-          for (const [modelId, model] of Object.entries(provider.models || {})) {
-            totalModels++;
-            const cost = model.cost || { input: 0, output: 0 };
-            if (cost.input === 0 && cost.output === 0) {
-              continue;
-            }
-            modelsWithPricing++;
-            const normalizedId = this.normalizeModelId(modelId);
-            const pricing = {
-              id: normalizedId,
-              name: model.name || modelId,
-              provider: provider.name || providerId,
-              family: model.family,
-              inputCostPerMillion: cost.input,
-              outputCostPerMillion: cost.output,
-              cacheReadCostPerMillion: cost.cache_read,
-              contextWindow: model.limit?.context,
-              maxOutputTokens: model.limit?.output,
-              lastUpdated: model.last_updated
-            };
-            models.set(modelId, pricing);
-            if (normalizedId !== modelId) {
-              models.set(normalizedId, pricing);
-            }
-            this.addCommonAliases(models, modelId, pricing);
-          }
-        }
-        logger.info(`Loaded ${modelsWithPricing} models with pricing (out of ${totalModels} total)`);
-        return models;
-      } finally {
-        clearTimeout(timeout);
-      }
-    }
-    async getModelPricing(modelId) {
-      const models = await this.fetchAllModels();
-      let pricing = models.get(modelId);
-      if (pricing)
-        return pricing;
-      const normalized = this.normalizeModelId(modelId);
-      pricing = models.get(normalized);
-      if (pricing)
-        return pricing;
-      const lowerModelId = modelId.toLowerCase();
-      for (const [key, value] of models.entries()) {
-        if (key.toLowerCase() === lowerModelId) {
-          return value;
-        }
-      }
-      logger.warn(`Model pricing not found: ${modelId}`);
-      return null;
-    }
-    async searchModels(query) {
-      const models = await this.fetchAllModels();
-      const lowerQuery = query.toLowerCase();
-      const results = [];
-      const seen = new Set;
-      for (const pricing of models.values()) {
-        const key = `${pricing.provider}:${pricing.name}`;
-        if (seen.has(key))
-          continue;
-        seen.add(key);
-        if (pricing.id.toLowerCase().includes(lowerQuery) || pricing.name.toLowerCase().includes(lowerQuery) || pricing.provider.toLowerCase().includes(lowerQuery) || pricing.family && pricing.family.toLowerCase().includes(lowerQuery)) {
-          results.push(pricing);
-        }
-      }
-      results.sort((a, b) => b.inputCostPerMillion - a.inputCostPerMillion);
-      return results;
-    }
-    async getTopExpensiveModels(limit = 10) {
-      const models = await this.fetchAllModels();
-      const unique = new Map;
-      for (const pricing of models.values()) {
-        const key = `${pricing.provider}:${pricing.name}`;
-        if (!unique.has(key)) {
-          unique.set(key, pricing);
-        }
-      }
-      return Array.from(unique.values()).sort((a, b) => b.inputCostPerMillion - a.inputCostPerMillion).slice(0, limit);
-    }
-    async getStatistics() {
-      const models = await this.fetchAllModels();
-      const unique = new Map;
-      const providers = new Set;
-      let totalInputCost = 0;
-      let totalOutputCost = 0;
-      for (const pricing of models.values()) {
-        const key = `${pricing.provider}:${pricing.name}`;
-        if (!unique.has(key)) {
-          unique.set(key, pricing);
-          providers.add(pricing.provider);
-          totalInputCost += pricing.inputCostPerMillion;
-          totalOutputCost += pricing.outputCostPerMillion;
+    return {
+      id: row.id,
+      taskId: row.task_id,
+      taskDescription: row.task_description ?? undefined,
+      agentId: row.agent_id ?? undefined,
+      projectId: row.project_id ?? undefined,
+      state,
+      memoryIds: row.memory_ids ? JSON.parse(row.memory_ids) : [],
+      fileChanges: row.file_changes ? JSON.parse(row.file_changes) : [],
+      checkpointType: row.checkpoint_type,
+      parentCheckpointId: row.parent_checkpoint_id ?? undefined,
+      createdAt: toNum4(row.created_at) ?? Date.now(),
+      expiresAt: toNum4(row.expires_at) ?? undefined
+    };
+  }
+  createCheckpoint(state, options = {}) {
+    const {
+      agentId,
+      projectId,
+      checkpointType = CheckpointType.MANUAL,
+      memoryIds = [],
+      fileChanges = [],
+      parentCheckpointId,
+      ttlMs = 7 * 24 * 60 * 60 * 1000
+    } = options;
+    const id = `ckpt_${checkpointType}_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+    const now2 = Date.now();
+    const expiresAt = now2 + ttlMs;
+    const checkpoint = {
+      id,
+      taskId: state.taskId,
+      taskDescription: state.description,
+      agentId,
+      projectId,
+      state,
+      memoryIds,
+      fileChanges,
+      checkpointType,
+      parentCheckpointId,
+      createdAt: now2,
+      expiresAt
+    };
+    this.mirror.set(id, checkpoint);
+    this.ensureHydrated();
+    this.chainWrite(id, async () => {
+      const prisma2 = this.getClient();
+      const canonicalProjectId = projectId ? await getProjectIdentityAliasResolver().resolve(projectId) : projectId;
+      const compressed = compressState(state);
+      await prisma2.$executeRaw`
+        INSERT INTO task_checkpoints (
+          id, task_id, task_description, agent_id, project_id,
+          state, state_schema_version,
+          memory_ids, file_changes,
+          checkpoint_type, parent_checkpoint_id,
+          created_at, expires_at
+        ) VALUES (
+          ${id},
+          ${state.taskId},
+          ${state.description ?? null},
+          ${agentId ?? null},
+          ${canonicalProjectId ?? null},
+          ${compressed},
+          1,
+          ${JSON.stringify(memoryIds)},
+          ${JSON.stringify(fileChanges)},
+          ${checkpointType},
+          ${parentCheckpointId ?? null},
+          ${now2}::bigint,
+          ${expiresAt}::bigint
+        )
+        ON CONFLICT (id) DO UPDATE SET
+          task_id = EXCLUDED.task_id,
+          task_description = EXCLUDED.task_description,
+          agent_id = EXCLUDED.agent_id,
+          project_id = EXCLUDED.project_id,
+          state = EXCLUDED.state,
+          state_schema_version = EXCLUDED.state_schema_version,
+          memory_ids = EXCLUDED.memory_ids,
+          file_changes = EXCLUDED.file_changes,
+          checkpoint_type = EXCLUDED.checkpoint_type,
+          parent_checkpoint_id = EXCLUDED.parent_checkpoint_id,
+          created_at = EXCLUDED.created_at,
+          expires_at = EXCLUDED.expires_at
+      `;
+    });
+    logger.info("Checkpoint created (PG)", {
+      id,
+      taskId: state.taskId,
+      type: checkpointType,
+      compressedBytes: compressState(state).byteLength
+    });
+    return checkpoint;
+  }
+  getCheckpoint(checkpointId) {
+    this.ensureHydrated();
+    return this.mirror.get(checkpointId) ?? null;
+  }
+  listCheckpoints(options = {}) {
+    this.ensureHydrated();
+    return this.applyFilters(this.mirror.values(), options);
+  }
+  listCheckpointsMetadata(options = {}) {
+    this.ensureHydrated();
+    const filtered = this.applyFilters(this.mirror.values(), options);
+    return filtered.map((c) => this.checkpointToMetadata(c));
+  }
+  getCheckpointState(checkpointId) {
+    this.ensureHydrated();
+    const ckpt = this.mirror.get(checkpointId);
+    return ckpt ? ckpt.state : null;
+  }
+  getLatestCheckpoint(taskId) {
+    this.ensureHydrated();
+    const now2 = Date.now();
+    let latest = null;
+    for (const ckpt of this.mirror.values()) {
+      if (ckpt.taskId === taskId && (ckpt.expiresAt == null || ckpt.expiresAt > now2)) {
+        if (!latest || ckpt.createdAt > latest.createdAt) {
+          latest = ckpt;
         }
       }
-      const modelList = Array.from(unique.values());
-      modelList.sort((a, b) => a.inputCostPerMillion - b.inputCostPerMillion);
-      return {
-        totalModels: modelList.length,
-        totalProviders: providers.size,
-        avgInputCost: modelList.length > 0 ? totalInputCost / modelList.length : 0,
-        avgOutputCost: modelList.length > 0 ? totalOutputCost / modelList.length : 0,
-        cheapestModel: modelList[0] || null,
-        mostExpensiveModel: modelList[modelList.length - 1] || null
-      };
-    }
-    normalizeModelId(modelId) {
-      let normalized = modelId.replace(/^(openai|anthropic|google|meta|mistral|cohere)\//i, "").replace(/^(claude-|gpt-|gemini-|llama-)/i, (match2) => match2.toLowerCase());
-      return normalized;
     }
-    addCommonAliases(models, modelId, pricing) {
-      if (modelId.includes("gpt-4") && !modelId.includes("turbo")) {
-        models.set("gpt-4", pricing);
-      }
-      if (modelId.includes("gpt-4-turbo")) {
-        models.set("gpt-4-turbo", pricing);
-      }
-      if (modelId.includes("gpt-3.5-turbo")) {
-        models.set("gpt-3.5-turbo", pricing);
-      }
-      if (modelId.includes("claude-3-opus")) {
-        models.set("claude-3-opus", pricing);
-      }
-      if (modelId.includes("claude-3-sonnet")) {
-        models.set("claude-3-sonnet", pricing);
-      }
-      if (modelId.includes("claude-3-haiku")) {
-        models.set("claude-3-haiku", pricing);
-      }
-      if (modelId.includes("gemini-pro")) {
-        models.set("gemini-pro", pricing);
-      }
-      if (modelId.includes("gemini-1.5-pro")) {
-        models.set("gemini-1.5-pro", pricing);
-      }
-      if (modelId.includes("gemini-1.5-flash")) {
-        models.set("gemini-1.5-flash", pricing);
+    return latest;
+  }
+  deleteCheckpoint(checkpointId) {
+    const existed = this.mirror.has(checkpointId);
+    this.mirror.delete(checkpointId);
+    this.ensureHydrated();
+    this.chainWrite(checkpointId, async () => {
+      const prisma2 = this.getClient();
+      await prisma2.$executeRaw`
+        DELETE FROM task_checkpoints WHERE id = ${checkpointId}
+      `;
+    });
+    return existed;
+  }
+  purgeExpired() {
+    const now2 = Date.now();
+    let count = 0;
+    const toRemove = [];
+    for (const ckpt of this.mirror.values()) {
+      if (ckpt.expiresAt != null && ckpt.expiresAt < now2) {
+        toRemove.push(ckpt.id);
+        count++;
       }
     }
-    clearCache() {
-      this.memoryCache = null;
-      this.memoryCacheTimestamp = 0;
-      logger.debug("Models.dev pricing memory cache cleared");
+    for (const id of toRemove)
+      this.mirror.delete(id);
+    if (count > 0) {
+      this.chainWrite("__purge__", async () => {
+        const prisma2 = this.getClient();
+        await prisma2.$executeRaw`
+          DELETE FROM task_checkpoints
+          WHERE expires_at IS NOT NULL AND expires_at < ${now2}::bigint
+        `;
+      });
+      logger.info("Expired checkpoints purged (PG)", { count });
     }
-    async clearAllCaches() {
-      this.clearCache();
-      const cachePath = this.getLocalCachePath();
-      try {
-        if (existsSync4(cachePath)) {
-          await fs11.unlink(cachePath);
-          logger.debug("Local pricing cache file deleted");
-        }
-      } catch (error51) {
-        logger.warn("Failed to delete local pricing cache", {
-          error: error51.message
-        });
+    return count;
+  }
+  async countExistingMemoryIds(memoryIds) {
+    if (memoryIds.length === 0)
+      return [];
+    this.ensureHydrated();
+    const BATCH_SIZE = 1000;
+    const existing = [];
+    try {
+      const prisma2 = this.getClient();
+      for (let i = 0;i < memoryIds.length; i += BATCH_SIZE) {
+        const batch = memoryIds.slice(i, i + BATCH_SIZE);
+        const rows = await prisma2.$queryRaw`
+          SELECT id FROM memories WHERE id IN (${import_prisma4.Prisma.join(batch)})
+        `;
+        for (const row of rows)
+          existing.push(row.id);
       }
+      return existing;
+    } catch (e) {
+      logger.warn("countExistingMemoryIds failed (best-effort: assuming all exist)", {
+        error: e.message
+      });
+      return memoryIds;
     }
-    async hasLocalCache() {
-      const cachePath = this.getLocalCachePath();
-      return existsSync4(cachePath);
+  }
+  getStats() {
+    this.ensureHydrated();
+    const checkpoints = Array.from(this.mirror.values());
+    const byType = {};
+    let totalSizeBytes = 0;
+    let oldest;
+    for (const c of checkpoints) {
+      byType[c.checkpointType] = (byType[c.checkpointType] ?? 0) + 1;
+      totalSizeBytes += compressState(c.state).byteLength;
+      if (oldest == null || c.createdAt < oldest)
+        oldest = c.createdAt;
     }
-  };
-});
-
-// ../../packages/core/dist/services/memory/redundancy-filter.js
-class RedundancyFilter {
-  static instance = null;
-  static getInstance() {
-    return this.instance ??= new RedundancyFilter;
+    return {
+      totalCheckpoints: checkpoints.length,
+      byType,
+      totalSizeBytes,
+      oldestCheckpointAge: oldest != null ? Date.now() - oldest : undefined
+    };
   }
-  async findDuplicates(threshold = 0.95, scanLimit = 300) {
-    const rows = await getPrismaClient2().$queryRaw`
-      SELECT id, content, type, level, importance, array_to_json(tags)::text AS tags, embedding,
-        created_at, updated_at, access_count, user_id, session_id, project_id, agent_id
-      FROM memories WHERE embedding IS NOT NULL AND deleted_at IS NULL
-      ORDER BY created_at DESC LIMIT ${scanLimit}`;
-    const groups = new Map;
-    for (const row of rows) {
-      if (!row.embedding)
+  ensureReady() {
+    return this.ensureHydrated();
+  }
+  close() {}
+  applyFilters(iter, options) {
+    const { taskId, projectId, checkpointType, includeExpired = false, limit = 20, offset = 0 } = options;
+    const now2 = Date.now();
+    const out = [];
+    for (const c of iter) {
+      if (taskId && c.taskId !== taskId)
         continue;
-      const bytes = Buffer.from(row.embedding);
-      const vector = new Float32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 4));
-      let norm = 0;
-      for (const value of vector)
-        norm += value * value;
-      norm = Math.sqrt(norm);
-      if (!norm)
+      if (projectId && c.projectId !== projectId)
         continue;
-      const group = groups.get(row.type) ?? [];
-      group.push({ row, vector, norm });
-      groups.set(row.type, group);
+      if (checkpointType && c.checkpointType !== checkpointType)
+        continue;
+      if (!includeExpired && c.expiresAt != null && c.expiresAt <= now2)
+        continue;
+      out.push(c);
     }
-    const pairs = [];
-    const removed = new Set;
-    for (const group of groups.values())
-      for (let left = 0;left < group.length; left++)
-        for (let right = left + 1;right < group.length; right++) {
-          const a = group[left];
-          const b = group[right];
-          if (removed.has(a.row.id) || removed.has(b.row.id) || a.vector.length !== b.vector.length)
-            continue;
-          let dot = 0;
-          for (let index = 0;index < a.vector.length; index++)
-            dot += a.vector[index] * b.vector[index];
-          const similarity = dot / (a.norm * b.norm);
-          if (similarity < threshold)
-            continue;
-          const keep = a.row.importance !== b.row.importance ? a.row.importance > b.row.importance ? a : b : a.row.access_count >= b.row.access_count ? a : b;
-          const drop = keep === a ? b : a;
-          removed.add(drop.row.id);
-          pairs.push({ keepId: keep.row.id, removeId: drop.row.id, similarity, reason: keep.row.importance !== drop.row.importance ? "Higher importance" : "Higher access count" });
-        }
-    return pairs;
+    out.sort((a, b) => b.createdAt - a.createdAt);
+    return out.slice(offset, offset + limit);
+  }
+  checkpointToMetadata(c) {
+    return {
+      id: c.id,
+      taskId: c.taskId,
+      taskDescription: c.taskDescription,
+      agentId: c.agentId,
+      projectId: c.projectId,
+      checkpointType: c.checkpointType,
+      parentCheckpointId: c.parentCheckpointId,
+      createdAt: c.createdAt,
+      expiresAt: c.expiresAt,
+      compressedSizeBytes: compressState(c.state).byteLength,
+      memoryCount: c.memoryIds.length,
+      fileChangeCount: c.fileChanges.length
+    };
   }
-  async mergeDuplicates(pairs) {
-    if (!pairs.length)
-      return { merged: 0, edgesTransferred: 0, accessCountsBoosted: 0 };
-    const prisma2 = getPrismaClient2();
-    let merged = 0;
-    let edgesTransferred = 0;
-    let accessCountsBoosted = 0;
-    await prisma2.$transaction(async (tx) => {
-      for (const pair of pairs) {
-        const rows = await tx.$queryRaw`SELECT content, access_count FROM memories WHERE id = ${pair.removeId} FOR UPDATE`;
-        if (!rows[0])
-          continue;
-        const moved = await tx.$executeRaw`
-          INSERT INTO memory_edges (from_id, to_id, edge_type, weight, metadata, created_at, updated_at)
-          SELECT CASE WHEN from_id = ${pair.removeId} THEN ${pair.keepId} ELSE from_id END,
-                 CASE WHEN to_id = ${pair.removeId} THEN ${pair.keepId} ELSE to_id END,
-                 edge_type, weight, metadata, NOW(), NOW()
-          FROM memory_edges WHERE (from_id = ${pair.removeId} OR to_id = ${pair.removeId})
-            AND from_id <> ${pair.keepId} AND to_id <> ${pair.keepId}
-          ON CONFLICT (from_id, to_id, edge_type) DO UPDATE SET weight = GREATEST(memory_edges.weight, EXCLUDED.weight), updated_at = NOW()`;
-        await tx.$executeRaw`DELETE FROM memory_edges WHERE from_id = ${pair.removeId} OR to_id = ${pair.removeId}`;
-        await tx.$executeRaw`UPDATE memories SET access_count = access_count + ${rows[0].access_count}, updated_at = NOW() WHERE id = ${pair.keepId}`;
-        await tx.$executeRaw`DELETE FROM memories WHERE id = ${pair.removeId}`;
-        TokenMetrics.getInstance().recordRedundancyFilterSavings(rows[0].content);
-        merged++;
-        edgesTransferred += Number(moved);
-        if (rows[0].access_count > 0)
-          accessCountsBoosted++;
-      }
+  chainWrite(key, fn) {
+    const prev = this.inflight.get(key) ?? Promise.resolve();
+    const next = prev.then(fn).catch((e) => {
+      logger.warn("PgCheckpointStore write failed (best-effort)", {
+        key,
+        error: e.message
+      });
+    });
+    this.inflight.set(key, next);
+    next.then(() => {
+      if (this.inflight.get(key) === next)
+        this.inflight.delete(key);
     });
-    logger.info("RedundancyFilter: merge complete", { merged, edgesTransferred, accessCountsBoosted });
-    return { merged, edgesTransferred, accessCountsBoosted };
   }
-  async runCleanup(threshold = 0.95) {
-    const start = Date.now();
-    const pairs = await this.findDuplicates(threshold);
-    const result = await this.mergeDuplicates(pairs);
-    return { duplicatesFound: pairs.length, merged: result.merged, edgesTransferred: result.edgesTransferred, durationMs: Date.now() - start };
+  async __drain() {
+    const pending = Array.from(this.inflight.values());
+    if (pending.length > 0)
+      await Promise.allSettled(pending);
+    await new Promise((r) => setTimeout(r, 10));
   }
-  close() {
-    RedundancyFilter.instance = null;
+  async __hydrate() {
+    await this.ensureHydrated();
   }
 }
-var init_redundancy_filter = __esm(() => {
+var import_prisma4, SUPPORTED_CHECKPOINT_STATE_SCHEMA_VERSION = "1.0.0";
+var init_checkpoint_store_pg = __esm(() => {
   init_dist();
   init_prisma_client();
-  init_token_metrics();
+  init_alias_resolver();
+  init_schema_version();
+  import_prisma4 = __toESM(require_prisma(), 1);
 });
 
-// ../../packages/core/dist/services/memory/memory-clustering.js
-class MemoryClustering {
-  static instance = null;
-  static getInstance() {
-    if (!MemoryClustering.instance) {
-      MemoryClustering.instance = new MemoryClustering;
+// ../../packages/core/dist/services/checkpoint/checkpoint-manager.js
+var exports_checkpoint_manager = {};
+__export(exports_checkpoint_manager, {
+  CheckpointManager: () => CheckpointManager
+});
+var CheckpointManager;
+var init_checkpoint_manager = __esm(() => {
+  init_config();
+  init_checkpoint_store_pg();
+  CheckpointManager = class CheckpointManager extends PgCheckpointStore {
+    static instance = null;
+    static getInstance() {
+      requirePostgresDatabaseUrl();
+      return this.instance ??= new CheckpointManager;
     }
-    return MemoryClustering.instance;
+    async restoreCheckpoint(checkpointId) {
+      const checkpoint = this.getCheckpoint(checkpointId);
+      if (!checkpoint)
+        return null;
+      const existing = new Set(await this.countExistingMemoryIds(checkpoint.memoryIds));
+      const validMemoryIds = checkpoint.memoryIds.filter((id) => existing.has(id));
+      const missingMemoryIds = checkpoint.memoryIds.filter((id) => !existing.has(id));
+      const fileConflicts = [];
+      const restoreInstructions = [
+        `Restore checkpoint ${checkpoint.id} for task ${checkpoint.taskId}.`,
+        missingMemoryIds.length ? `Missing memories: ${missingMemoryIds.join(", ")}.` : "All referenced memories are available."
+      ].join(`
+`);
+      return { checkpoint, validMemoryIds, missingMemoryIds, fileConflicts, restoreInstructions };
+    }
+  };
+});
+
+// ../../packages/core/dist/services/scheduler/scheduler-defaults.js
+function envBool2(key, fallback) {
+  const raw2 = process.env[key];
+  if (raw2 === undefined)
+    return fallback;
+  return raw2 === "true" || raw2 === "1";
+}
+function envNum2(key, fallback) {
+  const raw2 = process.env[key];
+  if (raw2 === undefined || raw2 === "")
+    return fallback;
+  const n = Number(raw2);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function applySafeDefaults(job) {
+  if (!envBool2("MASSA_AI_SCHEDULER_SAFE_DEFAULTS", false)) {
+    return job;
   }
-  constructor() {}
-  async clusterMemories(k, maxIter = 20, maxMemories = 500) {
-    const start = Date.now();
-    const rows = await getPrismaClient2().$queryRaw`
-      SELECT id, content, type, level, importance, array_to_json(tags)::text AS tags,
-        embedding, created_at, updated_at, access_count, user_id, session_id, project_id, agent_id
-      FROM memories WHERE embedding IS NOT NULL ORDER BY created_at DESC LIMIT ${maxMemories}`;
-    const items = [];
-    for (const row of rows) {
-      if (!row.embedding)
-        continue;
-      const buf = row.embedding instanceof Buffer ? row.embedding : Buffer.from(row.embedding);
-      const vec = Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4));
-      if (vec.every((v) => v === 0))
-        continue;
-      items.push({ row, vec });
+  if (job.jobKind === "memory-consolidation") {
+    const currentInterval = job.schedule.intervalMs ?? THIRTY_MIN;
+    const safeInterval = Math.max(currentInterval, THIRTY_MIN);
+    return {
+      ...job,
+      defaultEnabled: true,
+      schedule: { type: "interval", intervalMs: safeInterval }
+    };
+  }
+  if (job.jobKind === "decay-sweep") {
+    const currentInterval = job.schedule.intervalMs ?? ONE_HOUR;
+    const safeInterval = Math.max(currentInterval, ONE_HOUR);
+    return {
+      ...job,
+      defaultEnabled: true,
+      schedule: { type: "interval", intervalMs: safeInterval }
+    };
+  }
+  return job;
+}
+function registerDefaultJobs(scheduler) {
+  scheduler.registerHandler("memory-consolidation", async () => {
+    const { memoryConsolidationJob: memoryConsolidationJob2 } = await Promise.resolve().then(() => (init_memory_consolidation_job(), exports_memory_consolidation_job));
+    await memoryConsolidationJob2.consolidate();
+  });
+  scheduler.registerHandler("decay-sweep", async () => {
+    const { memoryConsolidationJob: memoryConsolidationJob2 } = await Promise.resolve().then(() => (init_memory_consolidation_job(), exports_memory_consolidation_job));
+    await memoryConsolidationJob2.consolidate();
+  });
+  scheduler.registerHandler("auto-improve", async (job) => {
+    const { autoImproveJob: autoImproveJob2 } = await Promise.resolve().then(() => (init_auto_improve_job(), exports_auto_improve_job));
+    const projectId = job.payload?.projectId ?? "default";
+    await autoImproveJob2.runOnce(projectId);
+  });
+  scheduler.registerHandler("observation-bridge", async (job) => {
+    const { observationConsolidationJob: observationConsolidationJob2 } = await Promise.resolve().then(() => (init_observation_consolidation_job(), exports_observation_consolidation_job));
+    const projectId = job.payload?.projectId ?? "default";
+    await observationConsolidationJob2.runOnce(projectId);
+  });
+  scheduler.registerHandler("checkpoint-purge", async () => {
+    const { CheckpointManager: CheckpointManager2 } = await Promise.resolve().then(() => (init_checkpoint_manager(), exports_checkpoint_manager));
+    const count = CheckpointManager2.getInstance().purgeExpired();
+    logger.info("Scheduled checkpoint purge completed", { count });
+  });
+  for (const rawDef of DEFAULT_SCHEDULED_JOBS) {
+    const def = applySafeDefaults(rawDef);
+    const enabled = envBool2(def.enableEnvVar, def.defaultEnabled);
+    const intervalMs = envNum2(def.intervalEnvVar, def.schedule.intervalMs ?? THIRTY_MIN);
+    const schedule = { type: "interval", intervalMs };
+    scheduler.registerOrResumeJob({
+      id: def.id,
+      name: def.name,
+      jobKind: def.jobKind,
+      schedule,
+      nextRunAt: 0,
+      enabled
+    });
+  }
+  logger.info("Scheduler default jobs registered", {
+    handlers: scheduler.registeredKinds(),
+    jobs: DEFAULT_SCHEDULED_JOBS.length
+  });
+}
+var MIN, THIRTY_MIN, ONE_HOUR, DEFAULT_SCHEDULED_JOBS;
+var init_scheduler_defaults = __esm(() => {
+  init_dist();
+  MIN = 60 * 1000;
+  THIRTY_MIN = 30 * MIN;
+  ONE_HOUR = 60 * MIN;
+  DEFAULT_SCHEDULED_JOBS = [
+    {
+      id: "scheduled-memory-consolidation",
+      name: "Memory Consolidation (clock)",
+      jobKind: "memory-consolidation",
+      schedule: { type: "interval", intervalMs: THIRTY_MIN },
+      defaultEnabled: false,
+      enableEnvVar: "MASSA_AI_SCHEDULER_CONSOLIDATION_ENABLED",
+      intervalEnvVar: "MASSA_AI_SCHEDULER_CONSOLIDATION_INTERVAL_MS"
+    },
+    {
+      id: "scheduled-decay-sweep",
+      name: "Decay Sweep (clock)",
+      jobKind: "decay-sweep",
+      schedule: { type: "interval", intervalMs: ONE_HOUR },
+      defaultEnabled: false,
+      enableEnvVar: "MASSA_AI_SCHEDULER_DECAY_ENABLED",
+      intervalEnvVar: "MASSA_AI_SCHEDULER_DECAY_INTERVAL_MS"
+    },
+    {
+      id: "scheduled-auto-improve",
+      name: "Auto-Improve (clock)",
+      jobKind: "auto-improve",
+      schedule: { type: "interval", intervalMs: THIRTY_MIN },
+      defaultEnabled: false,
+      enableEnvVar: "MASSA_AI_SCHEDULER_AUTO_IMPROVE_ENABLED",
+      intervalEnvVar: "MASSA_AI_SCHEDULER_AUTO_IMPROVE_INTERVAL_MS"
+    },
+    {
+      id: "scheduled-observation-bridge",
+      name: "Observation Bridge (clock)",
+      jobKind: "observation-bridge",
+      schedule: { type: "interval", intervalMs: THIRTY_MIN },
+      defaultEnabled: false,
+      enableEnvVar: "MASSA_AI_SCHEDULER_OBSERVATION_BRIDGE_ENABLED",
+      intervalEnvVar: "MASSA_AI_SCHEDULER_OBSERVATION_BRIDGE_INTERVAL_MS"
+    },
+    {
+      id: "scheduled-checkpoint-purge",
+      name: "Checkpoint Purge (clock)",
+      jobKind: "checkpoint-purge",
+      schedule: { type: "interval", intervalMs: ONE_HOUR },
+      defaultEnabled: false,
+      enableEnvVar: "MASSA_AI_SCHEDULER_CHECKPOINT_PURGE_ENABLED",
+      intervalEnvVar: "MASSA_AI_SCHEDULER_CHECKPOINT_PURGE_INTERVAL_MS"
     }
-    if (items.length < 3) {
-      return { clusters: [], unclustered: items.length, durationMs: Date.now() - start };
+  ];
+});
+
+// ../../packages/core/dist/services/scheduler/index.js
+var init_scheduler2 = __esm(() => {
+  init_scheduler();
+  init_scheduler_store_pg();
+  init_scheduler_store_factory();
+  init_scheduler_cron();
+  init_scheduler_defaults();
+});
+
+// ../../packages/core/dist/services/pricing/models-dev-client.js
+import fs11 from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import path16 from "path";
+function getModelsDevClient() {
+  if (!clientInstance) {
+    clientInstance = new ModelsDevClient;
+  }
+  return clientInstance;
+}
+var ModelsDevClient, clientInstance = null;
+var init_models_dev_client = __esm(() => {
+  init_dist();
+  init_dist();
+  ModelsDevClient = class ModelsDevClient {
+    static API_URL = "https://models.dev/api.json";
+    static MEMORY_CACHE_TTL = 3600 * 1000;
+    static LOCAL_CACHE_TTL = 24 * 3600 * 1000;
+    static LOCAL_CACHE_FILE = "pricing-cache.json";
+    memoryCache = null;
+    memoryCacheTimestamp = 0;
+    getLocalCachePath() {
+      const dataDir = config.get("dataDir");
+      return path16.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
-    const effectiveK = k ?? Math.max(2, Math.min(20, Math.round(Math.sqrt(items.length / 2))));
-    const dim = items[0].vec.length;
-    let centroids = this.kMeansPlusPlusInit(items.map((i) => i.vec), effectiveK);
-    let assignments = new Int32Array(items.length);
-    for (let iter = 0;iter < maxIter; iter++) {
-      const newAssignments = new Int32Array(items.length);
-      for (let i = 0;i < items.length; i++) {
-        let bestDist = Infinity;
-        let bestCluster = 0;
-        for (let c = 0;c < centroids.length; c++) {
-          const dist = this.euclideanDistanceSq(items[i].vec, centroids[c]);
-          if (dist < bestDist) {
-            bestDist = dist;
-            bestCluster = c;
-          }
-        }
-        newAssignments[i] = bestCluster;
-      }
-      let changed = false;
-      for (let i = 0;i < items.length; i++) {
-        if (newAssignments[i] !== assignments[i]) {
-          changed = true;
-          break;
+    async loadLocalCache() {
+      const cachePath = this.getLocalCachePath();
+      try {
+        if (!existsSync4(cachePath)) {
+          return null;
         }
-      }
-      assignments = newAssignments;
-      if (!changed)
-        break;
-      const newCentroids = [];
-      const counts = [];
-      for (let c = 0;c < centroids.length; c++) {
-        newCentroids.push(Array.from({ length: dim }, () => 0));
-        counts.push(0);
-      }
-      for (let i = 0;i < items.length; i++) {
-        const c = assignments[i];
-        counts[c]++;
-        for (let d = 0;d < dim; d++) {
-          newCentroids[c][d] += items[i].vec[d];
+        const content = await fs11.readFile(cachePath, "utf-8");
+        const data = JSON.parse(content);
+        const age = Date.now() - data.timestamp;
+        if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
+          logger.debug("Local pricing cache expired", {
+            ageHours: Math.round(age / 3600000)
+          });
         }
-      }
-      for (let c = 0;c < centroids.length; c++) {
-        if (counts[c] === 0)
-          continue;
-        for (let d = 0;d < dim; d++) {
-          newCentroids[c][d] /= counts[c];
+        const models = new Map;
+        for (const [key, value] of Object.entries(data.models)) {
+          models.set(key, value);
         }
+        logger.debug("Loaded pricing from local cache", {
+          models: models.size,
+          ageHours: Math.round(age / 3600000)
+        });
+        return models;
+      } catch (error51) {
+        logger.debug("Failed to load local pricing cache", {
+          error: error51.message
+        });
+        return null;
       }
-      centroids = newCentroids;
-    }
-    const clusterMap = new Map;
-    for (let i = 0;i < items.length; i++) {
-      const c = assignments[i];
-      if (!clusterMap.has(c))
-        clusterMap.set(c, []);
-      clusterMap.get(c).push(items[i].row);
-    }
-    const clusters = [];
-    let unclustered = 0;
-    for (const [cIdx, members] of clusterMap) {
-      if (members.length < 2) {
-        unclustered += members.length;
-        continue;
-      }
-      const label = this.generateLabel(members);
-      const avgImportance = members.reduce((sum, m) => sum + m.importance, 0) / members.length;
-      const totalAccess = members.reduce((sum, m) => sum + m.access_count, 0);
-      const dominantType = this.getDominantType(members);
-      clusters.push({
-        id: `cluster_${Date.now()}_${cIdx}`,
-        centroid: centroids[cIdx],
-        memberIds: members.map((m) => m.id),
-        label,
-        importance: Math.round(avgImportance * 100) / 100,
-        totalAccess,
-        dominantType
-      });
     }
-    clusters.sort((a, b) => b.importance - a.importance);
-    logger.info("MemoryClustering: complete", {
-      inputMemories: items.length,
-      clusters: clusters.length,
-      unclustered,
-      k: effectiveK
-    });
-    return { clusters, unclustered, durationMs: Date.now() - start };
-  }
-  async findCluster(memoryId, cached2) {
-    const result = cached2 ?? await this.clusterMemories();
-    for (const cluster of result.clusters) {
-      if (cluster.memberIds.includes(memoryId)) {
-        return cluster;
+    async saveLocalCache(models) {
+      const cachePath = this.getLocalCachePath();
+      try {
+        const dir = path16.dirname(cachePath);
+        await fs11.mkdir(dir, { recursive: true });
+        const data = {
+          timestamp: Date.now(),
+          version: "1.0.0",
+          models: Object.fromEntries(models)
+        };
+        await fs11.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        logger.debug("Saved pricing to local cache", {
+          models: models.size,
+          path: cachePath
+        });
+      } catch (error51) {
+        logger.warn("Failed to save local pricing cache", {
+          error: error51.message
+        });
       }
     }
-    return null;
-  }
-  async summarizeCluster(cluster) {
-    const members = await getPrismaClient2().$queryRaw`SELECT content, type, importance FROM memories WHERE id = ANY(${cluster.memberIds}::text[]) ORDER BY importance DESC LIMIT 5`;
-    if (members.length === 0)
-      return cluster.label;
-    const lead = members[0].content.split(/[.!?\n]/)[0].trim();
-    const typeCount = members.length;
-    const types6 = [...new Set(members.map((m) => m.type))].join(", ");
-    return `[${cluster.label}] ${lead} (${typeCount} memories, types: ${types6})`;
-  }
-  kMeansPlusPlusInit(vectors, k) {
-    const centroids = [];
-    const firstIdx = Math.floor(Math.random() * vectors.length);
-    centroids.push([...vectors[firstIdx]]);
-    for (let c = 1;c < k; c++) {
-      const distances = [];
-      let totalDist = 0;
-      for (const vec of vectors) {
-        let minDist = Infinity;
-        for (const centroid of centroids) {
-          const d = this.euclideanDistanceSq(vec, centroid);
-          if (d < minDist)
-            minDist = d;
-        }
-        distances.push(minDist);
-        totalDist += minDist;
-      }
-      if (totalDist === 0) {
-        centroids.push([...vectors[Math.floor(Math.random() * vectors.length)]]);
-        continue;
-      }
-      let r = Math.random() * totalDist;
-      for (let i = 0;i < distances.length; i++) {
-        r -= distances[i];
-        if (r <= 0) {
-          centroids.push([...vectors[i]]);
-          break;
+    getBundledDefaults() {
+      const models = new Map;
+      const defaults3 = [
+        {
+          id: "ollama/nomic-embed-text",
+          name: "Nomic Embed Text",
+          provider: "Ollama",
+          family: "nomic",
+          inputCostPerMillion: 0,
+          outputCostPerMillion: 0,
+          contextWindow: 8192
+        },
+        {
+          id: "ollama/all-minilm",
+          name: "All MiniLM",
+          provider: "Ollama",
+          family: "minilm",
+          inputCostPerMillion: 0,
+          outputCostPerMillion: 0,
+          contextWindow: 512
+        },
+        {
+          id: "ollama/mxbai-embed-large",
+          name: "MxBai Embed Large",
+          provider: "Ollama",
+          family: "mxbai",
+          inputCostPerMillion: 0,
+          outputCostPerMillion: 0,
+          contextWindow: 512
+        },
+        {
+          id: "mistral-embed",
+          name: "Mistral Embed",
+          provider: "Mistral",
+          family: "mistral",
+          inputCostPerMillion: 0.1,
+          outputCostPerMillion: 0,
+          contextWindow: 8192
+        },
+        {
+          id: "codestral-embed",
+          name: "Codestral Embed",
+          provider: "Mistral",
+          family: "codestral",
+          inputCostPerMillion: 0.1,
+          outputCostPerMillion: 0,
+          contextWindow: 32768
+        },
+        {
+          id: "mistral-small-latest",
+          name: "Mistral Small",
+          provider: "Mistral",
+          family: "mistral",
+          inputCostPerMillion: 0.2,
+          outputCostPerMillion: 0.6,
+          contextWindow: 32768,
+          maxOutputTokens: 8192
+        },
+        {
+          id: "text-embedding-3-small",
+          name: "Text Embedding 3 Small",
+          provider: "OpenAI",
+          family: "embedding",
+          inputCostPerMillion: 0.02,
+          outputCostPerMillion: 0,
+          contextWindow: 8191
+        },
+        {
+          id: "gpt-4o-mini",
+          name: "GPT-4o Mini",
+          provider: "OpenAI",
+          family: "gpt-4",
+          inputCostPerMillion: 0.15,
+          outputCostPerMillion: 0.6,
+          contextWindow: 128000,
+          maxOutputTokens: 16384
+        },
+        {
+          id: "claude-3-haiku-20240307",
+          name: "Claude 3 Haiku",
+          provider: "Anthropic",
+          family: "claude-3",
+          inputCostPerMillion: 0.25,
+          outputCostPerMillion: 1.25,
+          contextWindow: 200000,
+          maxOutputTokens: 4096
+        },
+        {
+          id: "claude-3-5-sonnet-20241022",
+          name: "Claude 3.5 Sonnet",
+          provider: "Anthropic",
+          family: "claude-3.5",
+          inputCostPerMillion: 3,
+          outputCostPerMillion: 15,
+          contextWindow: 200000,
+          maxOutputTokens: 8192
+        },
+        {
+          id: "gemini-1.5-flash",
+          name: "Gemini 1.5 Flash",
+          provider: "Google",
+          family: "gemini",
+          inputCostPerMillion: 0.075,
+          outputCostPerMillion: 0.3,
+          contextWindow: 1e6,
+          maxOutputTokens: 8192
+        },
+        {
+          id: "embed-english-v3.0",
+          name: "Embed English v3",
+          provider: "Cohere",
+          family: "embed",
+          inputCostPerMillion: 0.1,
+          outputCostPerMillion: 0,
+          contextWindow: 512
         }
+      ];
+      for (const pricing of defaults3) {
+        models.set(pricing.id, pricing);
       }
-      if (centroids.length <= c) {
-        centroids.push([...vectors[vectors.length - 1]]);
-      }
+      logger.info("Using bundled pricing defaults (offline mode)", {
+        models: models.size
+      });
+      return models;
     }
-    return centroids;
-  }
-  generateLabel(members) {
-    const stopWords = new Set([
-      "the",
-      "a",
-      "an",
-      "is",
-      "are",
-      "was",
-      "were",
-      "be",
-      "been",
-      "being",
-      "have",
-      "has",
-      "had",
-      "do",
-      "does",
-      "did",
-      "will",
-      "would",
-      "could",
-      "should",
-      "may",
-      "might",
-      "shall",
-      "can",
-      "need",
-      "dare",
-      "ought",
-      "used",
-      "to",
-      "of",
-      "in",
-      "for",
-      "on",
-      "with",
-      "at",
-      "by",
-      "from",
-      "as",
-      "into",
-      "through",
-      "during",
-      "before",
-      "after",
-      "above",
-      "below",
-      "between",
-      "out",
-      "off",
-      "over",
-      "under",
-      "again",
-      "further",
-      "then",
-      "once",
-      "here",
-      "there",
-      "when",
-      "where",
-      "why",
-      "how",
-      "all",
-      "both",
-      "each",
-      "few",
-      "more",
-      "most",
-      "other",
-      "some",
-      "such",
-      "no",
-      "nor",
-      "not",
-      "only",
-      "own",
-      "same",
-      "so",
-      "than",
-      "too",
-      "very",
-      "just",
-      "don",
-      "should",
-      "now",
-      "and",
-      "but",
-      "or",
-      "if",
-      "while",
-      "that",
-      "this",
-      "it",
-      "its",
-      "what",
-      "which",
-      "who",
-      "whom",
-      "these",
-      "those",
-      "i",
-      "me",
-      "my",
-      "myself",
-      "we",
-      "our",
-      "ours",
-      "you",
-      "your",
-      "he",
-      "him",
-      "his",
-      "she",
-      "her",
-      "they",
-      "them",
-      "their",
-      "de",
-      "da",
-      "do",
-      "das",
-      "dos",
-      "em",
-      "no",
-      "na",
-      "nos",
-      "nas",
-      "um",
-      "uma",
-      "uns",
-      "umas",
-      "para",
-      "com",
-      "por",
-      "que",
-      "se",
-      "como",
-      "mas",
-      "ou",
-      "quando",
-      "mais",
-      "tamb\xE9m",
-      "j\xE1",
-      "ainda",
-      "sobre",
-      "entre",
-      "at\xE9",
-      "sem",
-      "sob",
-      "esse",
-      "essa",
-      "este",
-      "esta",
-      "aquele",
-      "aquela",
-      "ele",
-      "ela",
-      "eles",
-      "elas",
-      "n\xF3s",
-      "eu",
-      "tu",
-      "voc\xEA",
-      "voc\xEAs",
-      "meu",
-      "minha",
-      "seu",
-      "sua"
-    ]);
-    const wordFreq = new Map;
-    for (const member of members) {
-      const words = member.content.toLowerCase().replace(/[^a-z\u00E1\u00E0\u00E2\u00E3\u00E9\u00E8\u00EA\u00ED\u00EF\u00F3\u00F4\u00F5\u00FA\u00FC\u00E7\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+    async fetchAllModels() {
+      if (this.memoryCache && Date.now() - this.memoryCacheTimestamp < ModelsDevClient.MEMORY_CACHE_TTL) {
+        logger.debug("Using in-memory pricing cache");
+        return this.memoryCache;
+      }
+      const localCache = await this.loadLocalCache();
+      let remoteModels = null;
+      try {
+        remoteModels = await this.fetchRemote();
+        await this.saveLocalCache(remoteModels);
+      } catch (error51) {
+        logger.debug("Remote pricing fetch failed (offline?)", {
+          error: error51.message
+        });
+      }
+      let result;
+      if (remoteModels) {
+        result = remoteModels;
+        logger.debug("Using remote pricing data");
+      } else if (localCache) {
+        result = localCache;
+        logger.info("Using local pricing cache (offline mode)");
+      } else {
+        result = this.getBundledDefaults();
+      }
+      this.memoryCache = result;
+      this.memoryCacheTimestamp = Date.now();
+      return result;
+    }
+    async fetchRemote() {
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), 1e4);
+      try {
+        logger.info("Fetching pricing data from models.dev API");
+        const response = await fetch(ModelsDevClient.API_URL, {
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        const models = new Map;
+        let totalModels = 0;
+        let modelsWithPricing = 0;
+        for (const [providerId, provider] of Object.entries(data)) {
+          for (const [modelId, model] of Object.entries(provider.models || {})) {
+            totalModels++;
+            const cost = model.cost || { input: 0, output: 0 };
+            if (cost.input === 0 && cost.output === 0) {
+              continue;
+            }
+            modelsWithPricing++;
+            const normalizedId = this.normalizeModelId(modelId);
+            const pricing = {
+              id: normalizedId,
+              name: model.name || modelId,
+              provider: provider.name || providerId,
+              family: model.family,
+              inputCostPerMillion: cost.input,
+              outputCostPerMillion: cost.output,
+              cacheReadCostPerMillion: cost.cache_read,
+              contextWindow: model.limit?.context,
+              maxOutputTokens: model.limit?.output,
+              lastUpdated: model.last_updated
+            };
+            models.set(modelId, pricing);
+            if (normalizedId !== modelId) {
+              models.set(normalizedId, pricing);
+            }
+            this.addCommonAliases(models, modelId, pricing);
+          }
+        }
+        logger.info(`Loaded ${modelsWithPricing} models with pricing (out of ${totalModels} total)`);
+        return models;
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    async getModelPricing(modelId) {
+      const models = await this.fetchAllModels();
+      let pricing = models.get(modelId);
+      if (pricing)
+        return pricing;
+      const normalized = this.normalizeModelId(modelId);
+      pricing = models.get(normalized);
+      if (pricing)
+        return pricing;
+      const lowerModelId = modelId.toLowerCase();
+      for (const [key, value] of models.entries()) {
+        if (key.toLowerCase() === lowerModelId) {
+          return value;
+        }
+      }
+      logger.warn(`Model pricing not found: ${modelId}`);
+      return null;
+    }
+    async searchModels(query) {
+      const models = await this.fetchAllModels();
+      const lowerQuery = query.toLowerCase();
+      const results = [];
       const seen = new Set;
-      for (const word of words) {
-        if (seen.has(word))
+      for (const pricing of models.values()) {
+        const key = `${pricing.provider}:${pricing.name}`;
+        if (seen.has(key))
           continue;
-        seen.add(word);
-        wordFreq.set(word, (wordFreq.get(word) ?? 0) + 1);
+        seen.add(key);
+        if (pricing.id.toLowerCase().includes(lowerQuery) || pricing.name.toLowerCase().includes(lowerQuery) || pricing.provider.toLowerCase().includes(lowerQuery) || pricing.family && pricing.family.toLowerCase().includes(lowerQuery)) {
+          results.push(pricing);
+        }
       }
+      results.sort((a, b) => b.inputCostPerMillion - a.inputCostPerMillion);
+      return results;
     }
-    const sorted = [...wordFreq.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([word]) => word);
-    return sorted.length > 0 ? sorted.join(", ") : "misc";
+    async getTopExpensiveModels(limit = 10) {
+      const models = await this.fetchAllModels();
+      const unique = new Map;
+      for (const pricing of models.values()) {
+        const key = `${pricing.provider}:${pricing.name}`;
+        if (!unique.has(key)) {
+          unique.set(key, pricing);
+        }
+      }
+      return Array.from(unique.values()).sort((a, b) => b.inputCostPerMillion - a.inputCostPerMillion).slice(0, limit);
+    }
+    async getStatistics() {
+      const models = await this.fetchAllModels();
+      const unique = new Map;
+      const providers = new Set;
+      let totalInputCost = 0;
+      let totalOutputCost = 0;
+      for (const pricing of models.values()) {
+        const key = `${pricing.provider}:${pricing.name}`;
+        if (!unique.has(key)) {
+          unique.set(key, pricing);
+          providers.add(pricing.provider);
+          totalInputCost += pricing.inputCostPerMillion;
+          totalOutputCost += pricing.outputCostPerMillion;
+        }
+      }
+      const modelList = Array.from(unique.values());
+      modelList.sort((a, b) => a.inputCostPerMillion - b.inputCostPerMillion);
+      return {
+        totalModels: modelList.length,
+        totalProviders: providers.size,
+        avgInputCost: modelList.length > 0 ? totalInputCost / modelList.length : 0,
+        avgOutputCost: modelList.length > 0 ? totalOutputCost / modelList.length : 0,
+        cheapestModel: modelList[0] || null,
+        mostExpensiveModel: modelList[modelList.length - 1] || null
+      };
+    }
+    normalizeModelId(modelId) {
+      let normalized = modelId.replace(/^(openai|anthropic|google|meta|mistral|cohere)\//i, "").replace(/^(claude-|gpt-|gemini-|llama-)/i, (match2) => match2.toLowerCase());
+      return normalized;
+    }
+    addCommonAliases(models, modelId, pricing) {
+      if (modelId.includes("gpt-4") && !modelId.includes("turbo")) {
+        models.set("gpt-4", pricing);
+      }
+      if (modelId.includes("gpt-4-turbo")) {
+        models.set("gpt-4-turbo", pricing);
+      }
+      if (modelId.includes("gpt-3.5-turbo")) {
+        models.set("gpt-3.5-turbo", pricing);
+      }
+      if (modelId.includes("claude-3-opus")) {
+        models.set("claude-3-opus", pricing);
+      }
+      if (modelId.includes("claude-3-sonnet")) {
+        models.set("claude-3-sonnet", pricing);
+      }
+      if (modelId.includes("claude-3-haiku")) {
+        models.set("claude-3-haiku", pricing);
+      }
+      if (modelId.includes("gemini-pro")) {
+        models.set("gemini-pro", pricing);
+      }
+      if (modelId.includes("gemini-1.5-pro")) {
+        models.set("gemini-1.5-pro", pricing);
+      }
+      if (modelId.includes("gemini-1.5-flash")) {
+        models.set("gemini-1.5-flash", pricing);
+      }
+    }
+    clearCache() {
+      this.memoryCache = null;
+      this.memoryCacheTimestamp = 0;
+      logger.debug("Models.dev pricing memory cache cleared");
+    }
+    async clearAllCaches() {
+      this.clearCache();
+      const cachePath = this.getLocalCachePath();
+      try {
+        if (existsSync4(cachePath)) {
+          await fs11.unlink(cachePath);
+          logger.debug("Local pricing cache file deleted");
+        }
+      } catch (error51) {
+        logger.warn("Failed to delete local pricing cache", {
+          error: error51.message
+        });
+      }
+    }
+    async hasLocalCache() {
+      const cachePath = this.getLocalCachePath();
+      return existsSync4(cachePath);
+    }
+  };
+});
+
+// ../../packages/core/dist/services/memory/redundancy-filter.js
+class RedundancyFilter {
+  static instance = null;
+  static getInstance() {
+    return this.instance ??= new RedundancyFilter;
   }
-  getDominantType(members) {
-    const typeCounts = new Map;
-    for (const m of members) {
-      typeCounts.set(m.type, (typeCounts.get(m.type) ?? 0) + 1);
+  async findDuplicates(threshold = 0.95, scanLimit = 300) {
+    const rows = await getPrismaClient2().$queryRaw`
+      SELECT id, content, type, level, importance, array_to_json(tags)::text AS tags, embedding,
+        created_at, updated_at, access_count, user_id, session_id, project_id, agent_id
+      FROM memories WHERE embedding IS NOT NULL AND deleted_at IS NULL
+      ORDER BY created_at DESC LIMIT ${scanLimit}`;
+    const groups = new Map;
+    for (const row of rows) {
+      if (!row.embedding)
+        continue;
+      const bytes = Buffer.from(row.embedding);
+      const vector = new Float32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 4));
+      let norm = 0;
+      for (const value of vector)
+        norm += value * value;
+      norm = Math.sqrt(norm);
+      if (!norm)
+        continue;
+      const group = groups.get(row.type) ?? [];
+      group.push({ row, vector, norm });
+      groups.set(row.type, group);
     }
-    let dominant = "unknown";
-    let maxCount = 0;
-    for (const [type, count] of typeCounts) {
-      if (count > maxCount) {
-        maxCount = count;
-        dominant = type;
+    const pairs = [];
+    const removed = new Set;
+    for (const group of groups.values())
+      for (let left = 0;left < group.length; left++)
+        for (let right = left + 1;right < group.length; right++) {
+          const a = group[left];
+          const b = group[right];
+          if (removed.has(a.row.id) || removed.has(b.row.id) || a.vector.length !== b.vector.length)
+            continue;
+          let dot = 0;
+          for (let index = 0;index < a.vector.length; index++)
+            dot += a.vector[index] * b.vector[index];
+          const similarity = dot / (a.norm * b.norm);
+          if (similarity < threshold)
+            continue;
+          const keep = a.row.importance !== b.row.importance ? a.row.importance > b.row.importance ? a : b : a.row.access_count >= b.row.access_count ? a : b;
+          const drop = keep === a ? b : a;
+          removed.add(drop.row.id);
+          pairs.push({ keepId: keep.row.id, removeId: drop.row.id, similarity, reason: keep.row.importance !== drop.row.importance ? "Higher importance" : "Higher access count" });
+        }
+    return pairs;
+  }
+  async mergeDuplicates(pairs) {
+    if (!pairs.length)
+      return { merged: 0, edgesTransferred: 0, accessCountsBoosted: 0 };
+    const prisma2 = getPrismaClient2();
+    let merged = 0;
+    let edgesTransferred = 0;
+    let accessCountsBoosted = 0;
+    await prisma2.$transaction(async (tx) => {
+      for (const pair of pairs) {
+        const rows = await tx.$queryRaw`SELECT content, access_count FROM memories WHERE id = ${pair.removeId} FOR UPDATE`;
+        if (!rows[0])
+          continue;
+        const moved = await tx.$executeRaw`
+          INSERT INTO memory_edges (from_id, to_id, edge_type, weight, metadata, created_at, updated_at)
+          SELECT CASE WHEN from_id = ${pair.removeId} THEN ${pair.keepId} ELSE from_id END,
+                 CASE WHEN to_id = ${pair.removeId} THEN ${pair.keepId} ELSE to_id END,
+                 edge_type, weight, metadata, NOW(), NOW()
+          FROM memory_edges WHERE (from_id = ${pair.removeId} OR to_id = ${pair.removeId})
+            AND from_id <> ${pair.keepId} AND to_id <> ${pair.keepId}
+          ON CONFLICT (from_id, to_id, edge_type) DO UPDATE SET weight = GREATEST(memory_edges.weight, EXCLUDED.weight), updated_at = NOW()`;
+        await tx.$executeRaw`DELETE FROM memory_edges WHERE from_id = ${pair.removeId} OR to_id = ${pair.removeId}`;
+        await tx.$executeRaw`UPDATE memories SET access_count = access_count + ${rows[0].access_count}, updated_at = NOW() WHERE id = ${pair.keepId}`;
+        await tx.$executeRaw`DELETE FROM memories WHERE id = ${pair.removeId}`;
+        TokenMetrics.getInstance().recordRedundancyFilterSavings(rows[0].content);
+        merged++;
+        edgesTransferred += Number(moved);
+        if (rows[0].access_count > 0)
+          accessCountsBoosted++;
       }
-    }
-    return dominant;
+    });
+    logger.info("RedundancyFilter: merge complete", { merged, edgesTransferred, accessCountsBoosted });
+    return { merged, edgesTransferred, accessCountsBoosted };
   }
-  euclideanDistanceSq(a, b) {
-    let sum = 0;
-    for (let i = 0;i < a.length; i++) {
-      const diff = a[i] - b[i];
-      sum += diff * diff;
-    }
-    return sum;
+  async runCleanup(threshold = 0.95) {
+    const start = Date.now();
+    const pairs = await this.findDuplicates(threshold);
+    const result = await this.mergeDuplicates(pairs);
+    return { duplicatesFound: pairs.length, merged: result.merged, edgesTransferred: result.edgesTransferred, durationMs: Date.now() - start };
   }
   close() {
-    MemoryClustering.instance = null;
+    RedundancyFilter.instance = null;
   }
 }
-var init_memory_clustering = __esm(() => {
+var init_redundancy_filter = __esm(() => {
   init_dist();
   init_prisma_client();
+  init_token_metrics();
 });
 
-// ../../packages/core/dist/services/checkpoint/checkpoint-store-pg.js
-function toNum4(v) {
-  if (v == null)
-    return null;
-  return typeof v === "bigint" ? Number(v) : v;
-}
-function compressState(state) {
-  const json3 = JSON.stringify(state);
-  return Buffer.from(Bun.deflateSync(Buffer.from(json3, "utf-8")));
-}
-function decompressState(data) {
-  const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-  const inflated = Bun.inflateSync(new Uint8Array(buf));
-  return JSON.parse(Buffer.from(inflated).toString("utf-8"));
-}
-
-class PgCheckpointStore {
-  prisma;
-  mirror = new Map;
-  hydrated = false;
-  hydrating = null;
-  hydrateFailedAt = 0;
-  static HYDRATE_RETRY_MS = 30000;
-  inflight = new Map;
-  getClient() {
-    if (!this.prisma)
-      this.prisma = getPrismaClient2();
-    return this.prisma;
-  }
-  ensureHydrated() {
-    if (this.hydrated)
-      return Promise.resolve();
-    if (this.hydrating)
-      return this.hydrating;
-    if (this.hydrateFailedAt > 0 && Date.now() - this.hydrateFailedAt < PgCheckpointStore.HYDRATE_RETRY_MS) {
-      return Promise.resolve();
+// ../../packages/core/dist/services/memory/memory-clustering.js
+class MemoryClustering {
+  static instance = null;
+  static getInstance() {
+    if (!MemoryClustering.instance) {
+      MemoryClustering.instance = new MemoryClustering;
     }
-    this.hydrating = (async () => {
-      try {
-        const prisma2 = this.getClient();
-        const rows = await prisma2.$queryRaw`
-          SELECT * FROM task_checkpoints
-        `;
-        const next = new Map;
-        const dbIds = new Set;
-        for (const row of rows) {
-          dbIds.add(row.id);
-          next.set(row.id, this.rowToCheckpoint(row));
-        }
-        for (const [id, existing] of this.mirror) {
-          if (!dbIds.has(id))
-            next.set(id, existing);
-        }
-        this.mirror = next;
-        this.hydrated = true;
-        this.hydrateFailedAt = 0;
-        logger.info("PgCheckpointStore hydrated", {
-          rows: this.mirror.size
-        });
-      } catch (e) {
-        this.hydrateFailedAt = Date.now();
-        logger.warn("PgCheckpointStore hydrate failed (best-effort)", {
-          error: e.message
-        });
-      } finally {
-        this.hydrating = null;
-      }
-    })();
-    return this.hydrating;
+    return MemoryClustering.instance;
   }
-  rowToCheckpoint(row) {
-    const state = decompressState(row.state);
-    const storedSchemaVersion = toNum4(row.state_schema_version);
-    if (storedSchemaVersion != null) {
-      const storedVersionString = String(storedSchemaVersion);
-      const normalized = /^\d+$/u.test(storedVersionString) ? `${storedVersionString}.0.0` : storedVersionString;
-      assertSchemaSupported("checkpoint", normalized, SUPPORTED_CHECKPOINT_STATE_SCHEMA_VERSION);
+  constructor() {}
+  async clusterMemories(k, maxIter = 20, maxMemories = 500) {
+    const start = Date.now();
+    const rows = await getPrismaClient2().$queryRaw`
+      SELECT id, content, type, level, importance, array_to_json(tags)::text AS tags,
+        embedding, created_at, updated_at, access_count, user_id, session_id, project_id, agent_id
+      FROM memories WHERE embedding IS NOT NULL ORDER BY created_at DESC LIMIT ${maxMemories}`;
+    const items = [];
+    for (const row of rows) {
+      if (!row.embedding)
+        continue;
+      const buf = row.embedding instanceof Buffer ? row.embedding : Buffer.from(row.embedding);
+      const vec = Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4));
+      if (vec.every((v) => v === 0))
+        continue;
+      items.push({ row, vec });
     }
-    return {
-      id: row.id,
-      taskId: row.task_id,
-      taskDescription: row.task_description ?? undefined,
-      agentId: row.agent_id ?? undefined,
-      projectId: row.project_id ?? undefined,
-      state,
-      memoryIds: row.memory_ids ? JSON.parse(row.memory_ids) : [],
-      fileChanges: row.file_changes ? JSON.parse(row.file_changes) : [],
-      checkpointType: row.checkpoint_type,
-      parentCheckpointId: row.parent_checkpoint_id ?? undefined,
-      createdAt: toNum4(row.created_at) ?? Date.now(),
-      expiresAt: toNum4(row.expires_at) ?? undefined
-    };
-  }
-  createCheckpoint(state, options = {}) {
-    const {
-      agentId,
-      projectId,
-      checkpointType = CheckpointType.MANUAL,
-      memoryIds = [],
-      fileChanges = [],
-      parentCheckpointId,
-      ttlMs = 7 * 24 * 60 * 60 * 1000
-    } = options;
-    const id = `ckpt_${checkpointType}_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
-    const now2 = Date.now();
-    const expiresAt = now2 + ttlMs;
-    const checkpoint = {
-      id,
-      taskId: state.taskId,
-      taskDescription: state.description,
-      agentId,
-      projectId,
-      state,
-      memoryIds,
-      fileChanges,
-      checkpointType,
-      parentCheckpointId,
-      createdAt: now2,
-      expiresAt
-    };
-    this.mirror.set(id, checkpoint);
-    this.ensureHydrated();
-    this.chainWrite(id, async () => {
-      const prisma2 = this.getClient();
-      const canonicalProjectId = projectId ? await getProjectIdentityAliasResolver().resolve(projectId) : projectId;
-      const compressed = compressState(state);
-      await prisma2.$executeRaw`
-        INSERT INTO task_checkpoints (
-          id, task_id, task_description, agent_id, project_id,
-          state, state_schema_version,
-          memory_ids, file_changes,
-          checkpoint_type, parent_checkpoint_id,
-          created_at, expires_at
-        ) VALUES (
-          ${id},
-          ${state.taskId},
-          ${state.description ?? null},
-          ${agentId ?? null},
-          ${canonicalProjectId ?? null},
-          ${compressed},
-          1,
-          ${JSON.stringify(memoryIds)},
-          ${JSON.stringify(fileChanges)},
-          ${checkpointType},
-          ${parentCheckpointId ?? null},
-          ${now2}::bigint,
-          ${expiresAt}::bigint
-        )
-        ON CONFLICT (id) DO UPDATE SET
-          task_id = EXCLUDED.task_id,
-          task_description = EXCLUDED.task_description,
-          agent_id = EXCLUDED.agent_id,
-          project_id = EXCLUDED.project_id,
-          state = EXCLUDED.state,
-          state_schema_version = EXCLUDED.state_schema_version,
-          memory_ids = EXCLUDED.memory_ids,
-          file_changes = EXCLUDED.file_changes,
-          checkpoint_type = EXCLUDED.checkpoint_type,
-          parent_checkpoint_id = EXCLUDED.parent_checkpoint_id,
-          created_at = EXCLUDED.created_at,
-          expires_at = EXCLUDED.expires_at
-      `;
-    });
-    logger.info("Checkpoint created (PG)", {
-      id,
-      taskId: state.taskId,
-      type: checkpointType,
-      compressedBytes: compressState(state).byteLength
+    if (items.length < 3) {
+      return { clusters: [], unclustered: items.length, durationMs: Date.now() - start };
+    }
+    const effectiveK = k ?? Math.max(2, Math.min(20, Math.round(Math.sqrt(items.length / 2))));
+    const dim = items[0].vec.length;
+    let centroids = this.kMeansPlusPlusInit(items.map((i) => i.vec), effectiveK);
+    let assignments = new Int32Array(items.length);
+    for (let iter = 0;iter < maxIter; iter++) {
+      const newAssignments = new Int32Array(items.length);
+      for (let i = 0;i < items.length; i++) {
+        let bestDist = Infinity;
+        let bestCluster = 0;
+        for (let c = 0;c < centroids.length; c++) {
+          const dist = this.euclideanDistanceSq(items[i].vec, centroids[c]);
+          if (dist < bestDist) {
+            bestDist = dist;
+            bestCluster = c;
+          }
+        }
+        newAssignments[i] = bestCluster;
+      }
+      let changed = false;
+      for (let i = 0;i < items.length; i++) {
+        if (newAssignments[i] !== assignments[i]) {
+          changed = true;
+          break;
+        }
+      }
+      assignments = newAssignments;
+      if (!changed)
+        break;
+      const newCentroids = [];
+      const counts = [];
+      for (let c = 0;c < centroids.length; c++) {
+        newCentroids.push(Array.from({ length: dim }, () => 0));
+        counts.push(0);
+      }
+      for (let i = 0;i < items.length; i++) {
+        const c = assignments[i];
+        counts[c]++;
+        for (let d = 0;d < dim; d++) {
+          newCentroids[c][d] += items[i].vec[d];
+        }
+      }
+      for (let c = 0;c < centroids.length; c++) {
+        if (counts[c] === 0)
+          continue;
+        for (let d = 0;d < dim; d++) {
+          newCentroids[c][d] /= counts[c];
+        }
+      }
+      centroids = newCentroids;
+    }
+    const clusterMap = new Map;
+    for (let i = 0;i < items.length; i++) {
+      const c = assignments[i];
+      if (!clusterMap.has(c))
+        clusterMap.set(c, []);
+      clusterMap.get(c).push(items[i].row);
+    }
+    const clusters = [];
+    let unclustered = 0;
+    for (const [cIdx, members] of clusterMap) {
+      if (members.length < 2) {
+        unclustered += members.length;
+        continue;
+      }
+      const label = this.generateLabel(members);
+      const avgImportance = members.reduce((sum, m) => sum + m.importance, 0) / members.length;
+      const totalAccess = members.reduce((sum, m) => sum + m.access_count, 0);
+      const dominantType = this.getDominantType(members);
+      clusters.push({
+        id: `cluster_${Date.now()}_${cIdx}`,
+        centroid: centroids[cIdx],
+        memberIds: members.map((m) => m.id),
+        label,
+        importance: Math.round(avgImportance * 100) / 100,
+        totalAccess,
+        dominantType
+      });
+    }
+    clusters.sort((a, b) => b.importance - a.importance);
+    logger.info("MemoryClustering: complete", {
+      inputMemories: items.length,
+      clusters: clusters.length,
+      unclustered,
+      k: effectiveK
     });
-    return checkpoint;
-  }
-  getCheckpoint(checkpointId) {
-    this.ensureHydrated();
-    return this.mirror.get(checkpointId) ?? null;
-  }
-  listCheckpoints(options = {}) {
-    this.ensureHydrated();
-    return this.applyFilters(this.mirror.values(), options);
+    return { clusters, unclustered, durationMs: Date.now() - start };
   }
-  listCheckpointsMetadata(options = {}) {
-    this.ensureHydrated();
-    const filtered = this.applyFilters(this.mirror.values(), options);
-    return filtered.map((c) => this.checkpointToMetadata(c));
+  async findCluster(memoryId, cached2) {
+    const result = cached2 ?? await this.clusterMemories();
+    for (const cluster of result.clusters) {
+      if (cluster.memberIds.includes(memoryId)) {
+        return cluster;
+      }
+    }
+    return null;
   }
-  getCheckpointState(checkpointId) {
-    this.ensureHydrated();
-    const ckpt = this.mirror.get(checkpointId);
-    return ckpt ? ckpt.state : null;
+  async summarizeCluster(cluster) {
+    const members = await getPrismaClient2().$queryRaw`SELECT content, type, importance FROM memories WHERE id = ANY(${cluster.memberIds}::text[]) ORDER BY importance DESC LIMIT 5`;
+    if (members.length === 0)
+      return cluster.label;
+    const lead = members[0].content.split(/[.!?\n]/)[0].trim();
+    const typeCount = members.length;
+    const types6 = [...new Set(members.map((m) => m.type))].join(", ");
+    return `[${cluster.label}] ${lead} (${typeCount} memories, types: ${types6})`;
   }
-  getLatestCheckpoint(taskId) {
-    this.ensureHydrated();
-    const now2 = Date.now();
-    let latest = null;
-    for (const ckpt of this.mirror.values()) {
-      if (ckpt.taskId === taskId && (ckpt.expiresAt == null || ckpt.expiresAt > now2)) {
-        if (!latest || ckpt.createdAt > latest.createdAt) {
-          latest = ckpt;
+  kMeansPlusPlusInit(vectors, k) {
+    const centroids = [];
+    const firstIdx = Math.floor(Math.random() * vectors.length);
+    centroids.push([...vectors[firstIdx]]);
+    for (let c = 1;c < k; c++) {
+      const distances = [];
+      let totalDist = 0;
+      for (const vec of vectors) {
+        let minDist = Infinity;
+        for (const centroid of centroids) {
+          const d = this.euclideanDistanceSq(vec, centroid);
+          if (d < minDist)
+            minDist = d;
+        }
+        distances.push(minDist);
+        totalDist += minDist;
+      }
+      if (totalDist === 0) {
+        centroids.push([...vectors[Math.floor(Math.random() * vectors.length)]]);
+        continue;
+      }
+      let r = Math.random() * totalDist;
+      for (let i = 0;i < distances.length; i++) {
+        r -= distances[i];
+        if (r <= 0) {
+          centroids.push([...vectors[i]]);
+          break;
         }
       }
+      if (centroids.length <= c) {
+        centroids.push([...vectors[vectors.length - 1]]);
+      }
+    }
+    return centroids;
+  }
+  generateLabel(members) {
+    const stopWords = new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "shall",
+      "can",
+      "need",
+      "dare",
+      "ought",
+      "used",
+      "to",
+      "of",
+      "in",
+      "for",
+      "on",
+      "with",
+      "at",
+      "by",
+      "from",
+      "as",
+      "into",
+      "through",
+      "during",
+      "before",
+      "after",
+      "above",
+      "below",
+      "between",
+      "out",
+      "off",
+      "over",
+      "under",
+      "again",
+      "further",
+      "then",
+      "once",
+      "here",
+      "there",
+      "when",
+      "where",
+      "why",
+      "how",
+      "all",
+      "both",
+      "each",
+      "few",
+      "more",
+      "most",
+      "other",
+      "some",
+      "such",
+      "no",
+      "nor",
+      "not",
+      "only",
+      "own",
+      "same",
+      "so",
+      "than",
+      "too",
+      "very",
+      "just",
+      "don",
+      "should",
+      "now",
+      "and",
+      "but",
+      "or",
+      "if",
+      "while",
+      "that",
+      "this",
+      "it",
+      "its",
+      "what",
+      "which",
+      "who",
+      "whom",
+      "these",
+      "those",
+      "i",
+      "me",
+      "my",
+      "myself",
+      "we",
+      "our",
+      "ours",
+      "you",
+      "your",
+      "he",
+      "him",
+      "his",
+      "she",
+      "her",
+      "they",
+      "them",
+      "their",
+      "de",
+      "da",
+      "do",
+      "das",
+      "dos",
+      "em",
+      "no",
+      "na",
+      "nos",
+      "nas",
+      "um",
+      "uma",
+      "uns",
+      "umas",
+      "para",
+      "com",
+      "por",
+      "que",
+      "se",
+      "como",
+      "mas",
+      "ou",
+      "quando",
+      "mais",
+      "tamb\xE9m",
+      "j\xE1",
+      "ainda",
+      "sobre",
+      "entre",
+      "at\xE9",
+      "sem",
+      "sob",
+      "esse",
+      "essa",
+      "este",
+      "esta",
+      "aquele",
+      "aquela",
+      "ele",
+      "ela",
+      "eles",
+      "elas",
+      "n\xF3s",
+      "eu",
+      "tu",
+      "voc\xEA",
+      "voc\xEAs",
+      "meu",
+      "minha",
+      "seu",
+      "sua"
+    ]);
+    const wordFreq = new Map;
+    for (const member of members) {
+      const words = member.content.toLowerCase().replace(/[^a-z\u00E1\u00E0\u00E2\u00E3\u00E9\u00E8\u00EA\u00ED\u00EF\u00F3\u00F4\u00F5\u00FA\u00FC\u00E7\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+      const seen = new Set;
+      for (const word of words) {
+        if (seen.has(word))
+          continue;
+        seen.add(word);
+        wordFreq.set(word, (wordFreq.get(word) ?? 0) + 1);
+      }
     }
-    return latest;
-  }
-  deleteCheckpoint(checkpointId) {
-    const existed = this.mirror.has(checkpointId);
-    this.mirror.delete(checkpointId);
-    this.ensureHydrated();
-    this.chainWrite(checkpointId, async () => {
-      const prisma2 = this.getClient();
-      await prisma2.$executeRaw`
-        DELETE FROM task_checkpoints WHERE id = ${checkpointId}
-      `;
-    });
-    return existed;
+    const sorted = [...wordFreq.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([word]) => word);
+    return sorted.length > 0 ? sorted.join(", ") : "misc";
   }
-  purgeExpired() {
-    const now2 = Date.now();
-    let count = 0;
-    const toRemove = [];
-    for (const ckpt of this.mirror.values()) {
-      if (ckpt.expiresAt != null && ckpt.expiresAt < now2) {
-        toRemove.push(ckpt.id);
-        count++;
-      }
-    }
-    for (const id of toRemove)
-      this.mirror.delete(id);
-    if (count > 0) {
-      this.chainWrite("__purge__", async () => {
-        const prisma2 = this.getClient();
-        await prisma2.$executeRaw`
-          DELETE FROM task_checkpoints
-          WHERE expires_at IS NOT NULL AND expires_at < ${now2}::bigint
-        `;
-      });
-      logger.info("Expired checkpoints purged (PG)", { count });
+  getDominantType(members) {
+    const typeCounts = new Map;
+    for (const m of members) {
+      typeCounts.set(m.type, (typeCounts.get(m.type) ?? 0) + 1);
     }
-    return count;
-  }
-  async countExistingMemoryIds(memoryIds) {
-    if (memoryIds.length === 0)
-      return [];
-    this.ensureHydrated();
-    const BATCH_SIZE = 1000;
-    const existing = [];
-    try {
-      const prisma2 = this.getClient();
-      for (let i = 0;i < memoryIds.length; i += BATCH_SIZE) {
-        const batch = memoryIds.slice(i, i + BATCH_SIZE);
-        const rows = await prisma2.$queryRaw`
-          SELECT id FROM memories WHERE id IN (${import_prisma4.Prisma.join(batch)})
-        `;
-        for (const row of rows)
-          existing.push(row.id);
+    let dominant = "unknown";
+    let maxCount = 0;
+    for (const [type, count] of typeCounts) {
+      if (count > maxCount) {
+        maxCount = count;
+        dominant = type;
       }
-      return existing;
-    } catch (e) {
-      logger.warn("countExistingMemoryIds failed (best-effort: assuming all exist)", {
-        error: e.message
-      });
-      return memoryIds;
-    }
-  }
-  getStats() {
-    this.ensureHydrated();
-    const checkpoints = Array.from(this.mirror.values());
-    const byType = {};
-    let totalSizeBytes = 0;
-    let oldest;
-    for (const c of checkpoints) {
-      byType[c.checkpointType] = (byType[c.checkpointType] ?? 0) + 1;
-      totalSizeBytes += compressState(c.state).byteLength;
-      if (oldest == null || c.createdAt < oldest)
-        oldest = c.createdAt;
     }
-    return {
-      totalCheckpoints: checkpoints.length,
-      byType,
-      totalSizeBytes,
-      oldestCheckpointAge: oldest != null ? Date.now() - oldest : undefined
-    };
-  }
-  ensureReady() {
-    return this.ensureHydrated();
+    return dominant;
   }
-  close() {}
-  applyFilters(iter, options) {
-    const { taskId, projectId, checkpointType, includeExpired = false, limit = 20, offset = 0 } = options;
-    const now2 = Date.now();
-    const out = [];
-    for (const c of iter) {
-      if (taskId && c.taskId !== taskId)
-        continue;
-      if (projectId && c.projectId !== projectId)
-        continue;
-      if (checkpointType && c.checkpointType !== checkpointType)
-        continue;
-      if (!includeExpired && c.expiresAt != null && c.expiresAt <= now2)
-        continue;
-      out.push(c);
+  euclideanDistanceSq(a, b) {
+    let sum = 0;
+    for (let i = 0;i < a.length; i++) {
+      const diff = a[i] - b[i];
+      sum += diff * diff;
     }
-    out.sort((a, b) => b.createdAt - a.createdAt);
-    return out.slice(offset, offset + limit);
-  }
-  checkpointToMetadata(c) {
-    return {
-      id: c.id,
-      taskId: c.taskId,
-      taskDescription: c.taskDescription,
-      agentId: c.agentId,
-      projectId: c.projectId,
-      checkpointType: c.checkpointType,
-      parentCheckpointId: c.parentCheckpointId,
-      createdAt: c.createdAt,
-      expiresAt: c.expiresAt,
-      compressedSizeBytes: compressState(c.state).byteLength,
-      memoryCount: c.memoryIds.length,
-      fileChangeCount: c.fileChanges.length
-    };
-  }
-  chainWrite(key, fn) {
-    const prev = this.inflight.get(key) ?? Promise.resolve();
-    const next = prev.then(fn).catch((e) => {
-      logger.warn("PgCheckpointStore write failed (best-effort)", {
-        key,
-        error: e.message
-      });
-    });
-    this.inflight.set(key, next);
-    next.then(() => {
-      if (this.inflight.get(key) === next)
-        this.inflight.delete(key);
-    });
-  }
-  async __drain() {
-    const pending = Array.from(this.inflight.values());
-    if (pending.length > 0)
-      await Promise.allSettled(pending);
-    await new Promise((r) => setTimeout(r, 10));
+    return sum;
   }
-  async __hydrate() {
-    await this.ensureHydrated();
+  close() {
+    MemoryClustering.instance = null;
   }
 }
-var import_prisma4, SUPPORTED_CHECKPOINT_STATE_SCHEMA_VERSION = "1.0.0";
-var init_checkpoint_store_pg = __esm(() => {
+var init_memory_clustering = __esm(() => {
   init_dist();
   init_prisma_client();
-  init_alias_resolver();
-  init_schema_version();
-  import_prisma4 = __toESM(require_prisma(), 1);
-});
-
-// ../../packages/core/dist/services/checkpoint/checkpoint-manager.js
-var CheckpointManager;
-var init_checkpoint_manager = __esm(() => {
-  init_config();
-  init_checkpoint_store_pg();
-  CheckpointManager = class CheckpointManager extends PgCheckpointStore {
-    static instance = null;
-    static getInstance() {
-      requirePostgresDatabaseUrl();
-      return this.instance ??= new CheckpointManager;
-    }
-    async restoreCheckpoint(checkpointId) {
-      const checkpoint = this.getCheckpoint(checkpointId);
-      if (!checkpoint)
-        return null;
-      const existing = new Set(await this.countExistingMemoryIds(checkpoint.memoryIds));
-      const validMemoryIds = checkpoint.memoryIds.filter((id) => existing.has(id));
-      const missingMemoryIds = checkpoint.memoryIds.filter((id) => !existing.has(id));
-      const fileConflicts = [];
-      const restoreInstructions = [
-        `Restore checkpoint ${checkpoint.id} for task ${checkpoint.taskId}.`,
-        missingMemoryIds.length ? `Missing memories: ${missingMemoryIds.join(", ")}.` : "All referenced memories are available."
-      ].join(`
-`);
-      return { checkpoint, validMemoryIds, missingMemoryIds, fileConflicts, restoreInstructions };
-    }
-  };
 });
 
 // ../../packages/core/dist/services/checkpoint/auto-checkpointer.js