@usewhisper/mcp-server 0.2.3 → 0.3.0

package/dist/server.js

@@ -1,801 +1,629 @@
 #!/usr/bin/env node
-import {
-  ingestDocument
-} from "./chunk-X7HNNNJJ.js";
-import {
-  embedSingle,
-  prisma
-} from "./chunk-3WGYBAYR.js";
-import "./chunk-QGM4M3NI.js";
 
 // ../src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 
-// ../src/engine/compressor.ts
-import OpenAI from "openai";
-import { createHash } from "crypto";
-var openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-var deltaCache = /* @__PURE__ */ new Map();
-var DELTA_CACHE_TTL = 6e5;
-function hashContext(text) {
-  return createHash("sha256").update(text).digest("hex").slice(0, 16);
-}
-async function compressContext(rawContext, opts = {}) {
-  const {
-    maxTokens = 4e3,
-    strategy = "adaptive",
-    previousContextHash,
-    previousContext,
-    targetReduction = 0.5
-  } = opts;
-  const originalTokens = estimateTokens(rawContext);
-  if (originalTokens <= maxTokens) {
-    return {
-      context: rawContext,
-      originalTokens,
-      compressedTokens: originalTokens,
-      reductionPercent: 0,
-      strategy: "none"
-    };
-  }
-  switch (strategy) {
-    case "delta":
-      return deltaCompress(rawContext, originalTokens, maxTokens, previousContextHash, previousContext);
-    case "summarize":
-      return summarizeCompress(rawContext, originalTokens, maxTokens);
-    case "extract":
-      return extractCompress(rawContext, originalTokens, maxTokens);
-    case "adaptive":
-    default:
-      return adaptiveCompress(rawContext, originalTokens, maxTokens, previousContextHash, previousContext);
+// ../src/sdk/index.ts
+var WhisperError = class extends Error {
+  code;
+  status;
+  retryable;
+  details;
+  constructor(args) {
+    super(args.message);
+    this.name = "WhisperError";
+    this.code = args.code;
+    this.status = args.status;
+    this.retryable = args.retryable ?? false;
+    this.details = args.details;
   }
+};
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_BASE_DELAY_MS = 250;
+var DEFAULT_MAX_DELAY_MS = 2e3;
+var DEFAULT_TIMEOUT_MS = 15e3;
+var PROJECT_CACHE_TTL_MS = 3e4;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function adaptiveCompress(rawContext, originalTokens, maxTokens, previousHash, previousCtx) {
-  const ratio = originalTokens / maxTokens;
-  if (previousHash || previousCtx) {
-    const delta = await deltaCompress(rawContext, originalTokens, maxTokens, previousHash, previousCtx);
-    if (delta.compressedTokens <= maxTokens) return delta;
-  }
-  if (ratio < 2) {
-    return extractCompress(rawContext, originalTokens, maxTokens);
-  }
-  return summarizeCompress(rawContext, originalTokens, maxTokens);
+function getBackoffDelay(attempt, base, max) {
+  const jitter = 0.8 + Math.random() * 0.4;
+  return Math.min(max, Math.floor(base * Math.pow(2, attempt) * jitter));
 }
-async function deltaCompress(rawContext, originalTokens, maxTokens, previousHash, previousCtx) {
-  const currentHash = hashContext(rawContext);
-  if (previousHash && previousHash === currentHash) {
-    return {
-      context: "[No changes since last context]",
-      originalTokens,
-      compressedTokens: 8,
-      reductionPercent: 99,
-      strategy: "delta-identical"
+function isLikelyProjectId(projectRef) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(projectRef);
+}
+var WhisperContext = class _WhisperContext {
+  apiKey;
+  baseUrl;
+  defaultProject;
+  orgId;
+  timeoutMs;
+  retryConfig;
+  projectRefToId = /* @__PURE__ */ new Map();
+  projectCache = [];
+  projectCacheExpiresAt = 0;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new WhisperError({
+        code: "INVALID_API_KEY",
+        message: "API key is required"
+      });
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || "https://context.usewhisper.dev";
+    this.defaultProject = config.project;
+    this.orgId = config.orgId;
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.retryConfig = {
+      maxAttempts: config.retry?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+      baseDelayMs: config.retry?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS,
+      maxDelayMs: config.retry?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS
     };
   }
-  let prevCtx = previousCtx;
-  if (!prevCtx && previousHash) {
-    const cached = deltaCache.get(previousHash);
-    if (cached && Date.now() - cached.timestamp < DELTA_CACHE_TTL) {
-      prevCtx = cached.context;
-    }
+  withProject(project) {
+    return new _WhisperContext({
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      project,
+      orgId: this.orgId,
+      timeoutMs: this.timeoutMs,
+      retry: this.retryConfig
+    });
   }
-  if (!prevCtx) {
-    return extractCompress(rawContext, originalTokens, maxTokens);
+  getRequiredProject(project) {
+    const resolved = project || this.defaultProject;
+    if (!resolved) {
+      throw new WhisperError({
+        code: "MISSING_PROJECT",
+        message: "Project is required. Pass project in params or set a default project in WhisperContext config."
+      });
+    }
+    return resolved;
   }
-  const prevBlocks = new Set(prevCtx.split("\n---\n").map((b) => b.trim()));
-  const currentBlocks = rawContext.split("\n---\n").map((b) => b.trim());
-  const newBlocks = [];
-  const unchangedCount = { count: 0 };
-  for (const block of currentBlocks) {
-    if (prevBlocks.has(block)) {
-      unchangedCount.count++;
-    } else {
-      newBlocks.push(block);
+  async refreshProjectCache(force = false) {
+    if (!force && Date.now() < this.projectCacheExpiresAt && this.projectCache.length > 0) {
+      return this.projectCache;
     }
+    const response = await this.request("/v1/projects", { method: "GET" });
+    this.projectRefToId.clear();
+    this.projectCache = response.projects || [];
+    for (const p of this.projectCache) {
+      this.projectRefToId.set(p.id, p.id);
+      this.projectRefToId.set(p.slug, p.id);
+      this.projectRefToId.set(p.name, p.id);
+    }
+    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+    return this.projectCache;
   }
-  let deltaContext;
-  if (newBlocks.length === 0) {
-    deltaContext = "[No new information since last query]";
-  } else {
-    const header = `[${unchangedCount.count} unchanged results omitted, ${newBlocks.length} new/updated]
-
-`;
-    deltaContext = header + newBlocks.join("\n---\n");
+  async resolveProjectId(projectRef) {
+    if (this.projectRefToId.has(projectRef)) {
+      return this.projectRefToId.get(projectRef);
+    }
+    const projects = await this.refreshProjectCache(true);
+    const byDirect = projects.find((p) => p.id === projectRef);
+    if (byDirect) return byDirect.id;
+    const matches = projects.filter((p) => p.slug === projectRef || p.name === projectRef);
+    if (matches.length === 1) {
+      return matches[0].id;
+    }
+    if (matches.length > 1) {
+      throw new WhisperError({
+        code: "PROJECT_AMBIGUOUS",
+        message: `Project reference '${projectRef}' matched multiple projects. Use project id instead.`
+      });
+    }
+    if (isLikelyProjectId(projectRef)) {
+      return projectRef;
+    }
+    throw new WhisperError({
+      code: "PROJECT_NOT_FOUND",
+      message: `Project '${projectRef}' not found`
+    });
   }
-  const deltaTokens = estimateTokens(deltaContext);
-  if (deltaTokens > maxTokens) {
-    const truncated = truncateToTokens(deltaContext, maxTokens);
-    deltaCache.set(currentHash, { context: rawContext, hash: currentHash, timestamp: Date.now() });
-    return {
-      context: truncated,
-      originalTokens,
-      compressedTokens: estimateTokens(truncated),
-      reductionPercent: Math.round((1 - estimateTokens(truncated) / originalTokens) * 100),
-      strategy: "delta-truncated"
-    };
+  async getProjectRefCandidates(projectRef) {
+    const candidates = /* @__PURE__ */ new Set([projectRef]);
+    try {
+      const projects = await this.refreshProjectCache(false);
+      const match = projects.find((p) => p.id === projectRef || p.slug === projectRef || p.name === projectRef);
+      if (match) {
+        candidates.add(match.id);
+        candidates.add(match.slug);
+        candidates.add(match.name);
+      } else if (isLikelyProjectId(projectRef)) {
+        const byId = projects.find((p) => p.id === projectRef);
+        if (byId) {
+          candidates.add(byId.slug);
+          candidates.add(byId.name);
+        }
+      }
+    } catch {
+    }
+    return Array.from(candidates).filter(Boolean);
   }
-  deltaCache.set(currentHash, { context: rawContext, hash: currentHash, timestamp: Date.now() });
-  return {
-    context: deltaContext,
-    originalTokens,
-    compressedTokens: estimateTokens(deltaContext),
-    reductionPercent: Math.round((1 - estimateTokens(deltaContext) / originalTokens) * 100),
-    strategy: "delta"
-  };
-}
-async function extractCompress(rawContext, originalTokens, maxTokens) {
-  try {
-    const res = await openai.chat.completions.create({
-      model: "gpt-4o-mini",
-      // Fixed: was "gpt-4.1-nano" which doesn't exist
-      messages: [
-        {
-          role: "system",
-          content: `You are a context compressor. Extract and preserve ONLY the most important information from the provided context. Remove redundancy, boilerplate, and low-value content. Keep code snippets, key facts, API signatures, and important relationships. Output should be ${maxTokens} tokens or less. Do NOT add commentary \u2014 just output the compressed context.`
-        },
-        { role: "user", content: rawContext }
-      ],
-      max_tokens: maxTokens,
-      temperature: 0
+  async withProjectRefFallback(projectRef, execute) {
+    const refs = await this.getProjectRefCandidates(projectRef);
+    let lastError;
+    for (const ref of refs) {
+      try {
+        return await execute(ref);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof WhisperError && error.code === "PROJECT_NOT_FOUND") {
+          continue;
+        }
+        throw error;
+      }
+    }
+    if (lastError instanceof Error) {
+      throw lastError;
+    }
+    throw new WhisperError({
+      code: "PROJECT_NOT_FOUND",
+      message: `Project '${projectRef}' not found`
     });
-    const compressed = res.choices[0]?.message?.content?.trim() || rawContext;
-    const compressedTokens = estimateTokens(compressed);
-    return {
-      context: compressed,
-      originalTokens,
-      compressedTokens,
-      reductionPercent: Math.round((1 - compressedTokens / originalTokens) * 100),
-      strategy: "extract"
-    };
-  } catch {
-    const truncated = truncateToTokens(rawContext, maxTokens);
-    return {
-      context: truncated,
-      originalTokens,
-      compressedTokens: estimateTokens(truncated),
-      reductionPercent: Math.round((1 - estimateTokens(truncated) / originalTokens) * 100),
-      strategy: "truncate-fallback"
-    };
   }
-}
-async function summarizeCompress(rawContext, originalTokens, maxTokens) {
-  const blocks = rawContext.split("\n---\n").filter((b) => b.trim());
-  if (blocks.length <= 3) {
-    return extractCompress(rawContext, originalTokens, maxTokens);
+  classifyError(status, message) {
+    if (status === 401 || /api key|unauthorized|forbidden/i.test(message)) {
+      return { code: "INVALID_API_KEY", retryable: false };
+    }
+    if (status === 404 || /project not found/i.test(message)) {
+      return { code: "PROJECT_NOT_FOUND", retryable: false };
+    }
+    if (status === 408) {
+      return { code: "TIMEOUT", retryable: true };
+    }
+    if (status === 429) {
+      return { code: "RATE_LIMITED", retryable: true };
+    }
+    if (status !== void 0 && status >= 500) {
+      return { code: "TEMPORARY_UNAVAILABLE", retryable: true };
+    }
+    return { code: "REQUEST_FAILED", retryable: false };
   }
-  const budgetPerBlock = Math.floor(maxTokens / blocks.length);
-  try {
-    const summaries = await Promise.all(
-      blocks.map(async (block) => {
-        if (estimateTokens(block) <= budgetPerBlock) return block;
-        const res = await openai.chat.completions.create({
-          model: "gpt-4o-mini",
-          // Fixed: was "gpt-4.1-nano" which doesn't exist
-          messages: [
-            {
-              role: "system",
-              content: `Summarize this context block in ${budgetPerBlock} tokens or less. Preserve code signatures, key facts, and important details. Output only the summary.`
-            },
-            { role: "user", content: block }
-          ],
-          max_tokens: budgetPerBlock,
-          temperature: 0
+  async request(endpoint, options = {}) {
+    const maxAttempts = Math.max(1, this.retryConfig.maxAttempts);
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const response = await fetch(`${this.baseUrl}${endpoint}`, {
+          ...options,
+          signal: controller.signal,
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            ...this.orgId ? { "X-Whisper-Org-Id": this.orgId } : {},
+            ...options.headers
+          }
         });
-        return res.choices[0]?.message?.content?.trim() || block.slice(0, budgetPerBlock * 4);
-      })
-    );
-    const compressed = summaries.join("\n\n---\n\n");
-    let compressedTokens = estimateTokens(compressed);
-    let finalContext = compressed;
-    if (compressedTokens > maxTokens) {
-      finalContext = truncateToTokens(compressed, maxTokens);
-      compressedTokens = estimateTokens(finalContext);
+        clearTimeout(timeout);
+        if (!response.ok) {
+          let payload = null;
+          try {
+            payload = await response.json();
+          } catch {
+            payload = await response.text().catch(() => "");
+          }
+          const message = typeof payload === "string" ? payload : payload?.error || payload?.message || `HTTP ${response.status}: ${response.statusText}`;
+          const { code, retryable } = this.classifyError(response.status, message);
+          const err = new WhisperError({
+            code,
+            message,
+            status: response.status,
+            retryable,
+            details: payload
+          });
+          if (!retryable || attempt === maxAttempts - 1) {
+            throw err;
+          }
+          await sleep(getBackoffDelay(attempt, this.retryConfig.baseDelayMs, this.retryConfig.maxDelayMs));
+          continue;
+        }
+        return response.json();
+      } catch (error) {
+        clearTimeout(timeout);
+        const isAbort = error?.name === "AbortError";
+        const mapped = error instanceof WhisperError ? error : new WhisperError({
+          code: isAbort ? "TIMEOUT" : "NETWORK_ERROR",
+          message: isAbort ? "Request timed out" : error?.message || "Network request failed",
+          retryable: true,
+          details: error
+        });
+        lastError = mapped;
+        if (!mapped.retryable || attempt === maxAttempts - 1) {
+          throw mapped;
+        }
+        await sleep(getBackoffDelay(attempt, this.retryConfig.baseDelayMs, this.retryConfig.maxDelayMs));
+      }
     }
-    return {
-      context: finalContext,
-      originalTokens,
-      compressedTokens,
-      reductionPercent: Math.round((1 - compressedTokens / originalTokens) * 100),
-      strategy: "summarize"
-    };
-  } catch {
-    const truncated = truncateToTokens(rawContext, maxTokens);
-    return {
-      context: truncated,
-      originalTokens,
-      compressedTokens: estimateTokens(truncated),
-      reductionPercent: Math.round((1 - estimateTokens(truncated) / originalTokens) * 100),
-      strategy: "truncate-fallback"
-    };
+    throw lastError instanceof Error ? lastError : new WhisperError({ code: "REQUEST_FAILED", message: "Request failed" });
   }
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function truncateToTokens(text, maxTokens) {
-  const maxChars = maxTokens * 4;
-  if (text.length <= maxChars) return text;
-  return text.slice(0, maxChars) + "\n\n[...truncated]";
-}
-var cacheCleanupInterval = null;
-function startCacheCleanup() {
-  if (cacheCleanupInterval) return;
-  cacheCleanupInterval = setInterval(() => {
-    const now = Date.now();
-    for (const [key, val] of deltaCache) {
-      if (now - val.timestamp > DELTA_CACHE_TTL) deltaCache.delete(key);
+  async query(params) {
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/context/query", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
+    }));
+  }
+  async createProject(params) {
+    const project = await this.request("/v1/projects", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+    this.projectRefToId.set(project.id, project.id);
+    this.projectRefToId.set(project.slug, project.id);
+    this.projectRefToId.set(project.name, project.id);
+    this.projectCache = [
+      ...this.projectCache.filter((p) => p.id !== project.id),
+      project
+    ];
+    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+    return project;
+  }
+  async listProjects() {
+    const projects = await this.request("/v1/projects", { method: "GET" });
+    this.projectCache = projects.projects || [];
+    for (const p of projects.projects || []) {
+      this.projectRefToId.set(p.id, p.id);
+      this.projectRefToId.set(p.slug, p.id);
+      this.projectRefToId.set(p.name, p.id);
     }
-  }, 6e4);
-}
-function stopCacheCleanup() {
-  if (cacheCleanupInterval) {
-    clearInterval(cacheCleanupInterval);
-    cacheCleanupInterval = null;
+    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+    return projects;
   }
-}
-startCacheCleanup();
-process.on("SIGTERM", stopCacheCleanup);
-process.on("SIGINT", stopCacheCleanup);
-process.on("beforeExit", stopCacheCleanup);
-
-// ../src/engine/retriever.ts
-import { createHash as createHash2 } from "crypto";
-import OpenAI2 from "openai";
-var openai2 = new OpenAI2({ apiKey: process.env.OPENAI_API_KEY });
-async function retrieve(opts) {
-  const {
-    projectId,
-    query,
-    topK = 10,
-    threshold = 0.3,
-    chunkTypes,
-    hybridSearch = true,
-    vectorWeight = 0.7,
-    bm25Weight = 0.3,
-    rerank = true,
-    rerankTopK,
-    includeMemories = false,
-    userId,
-    sessionId,
-    agentId,
-    includeGraph = false,
-    graphDepth = 1,
-    maxTokens,
-    compress = false,
-    compressionStrategy = "adaptive",
-    previousContextHash,
-    useCache = true,
-    cacheTtlSeconds = 300
-  } = opts;
-  const startTime = Date.now();
-  if (useCache) {
-    const cached = await checkCache(projectId, query);
-    if (cached) {
-      const cachedResults = cached;
-      return {
-        results: cachedResults,
-        context: packContext(cachedResults, maxTokens),
-        meta: {
-          totalResults: cachedResults.length,
-          latencyMs: Date.now() - startTime,
-          cacheHit: true,
-          tokensUsed: 0
+  async getProject(id) {
+    const projectId = await this.resolveProjectId(id);
+    return this.request(`/v1/projects/${projectId}`);
+  }
+  async deleteProject(id) {
+    const projectId = await this.resolveProjectId(id);
+    return this.request(`/v1/projects/${projectId}`, { method: "DELETE" });
+  }
+  async addSource(projectId, params) {
+    const resolvedProjectId = await this.resolveProjectId(projectId);
+    return this.request(`/v1/projects/${resolvedProjectId}/sources`, {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async syncSource(sourceId) {
+    return this.request(`/v1/sources/${sourceId}/sync`, { method: "POST" });
+  }
+  async ingest(projectId, documents) {
+    const resolvedProjectId = await this.resolveProjectId(projectId);
+    return this.request(`/v1/projects/${resolvedProjectId}/ingest`, {
+      method: "POST",
+      body: JSON.stringify({ documents })
+    });
+  }
+  async addContext(params) {
+    const projectId = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.ingest(projectId, [
+      {
+        title: params.title || "Context",
+        content: params.content,
+        metadata: params.metadata || { source: "addContext" }
+      }
+    ]);
+  }
+  async addMemory(params) {
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, async (project) => {
+      const toSotaType = (memoryType) => {
+        switch (memoryType) {
+          case "episodic":
+            return "event";
+          case "semantic":
+            return "factual";
+          case "procedural":
+            return "instruction";
+          default:
+            return memoryType;
         }
       };
-    }
+      const toLegacyType = (memoryType) => {
+        switch (memoryType) {
+          case "event":
+            return "episodic";
+          case "instruction":
+            return "procedural";
+          case "preference":
+          case "relationship":
+          case "opinion":
+          case "goal":
+            return "semantic";
+          default:
+            return memoryType;
+        }
+      };
+      try {
+        const direct = await this.request("/v1/memory", {
+          method: "POST",
+          body: JSON.stringify({
+            project,
+            content: params.content,
+            memory_type: toSotaType(params.memory_type),
+            user_id: params.user_id,
+            session_id: params.session_id,
+            agent_id: params.agent_id,
+            importance: params.importance,
+            metadata: params.metadata
+          })
+        });
+        const id2 = direct?.memory?.id || direct?.id || direct?.memory_id;
+        if (id2) {
+          return { id: id2, success: true, path: "sota", fallback_used: false };
+        }
+      } catch (error) {
+        if (params.allow_legacy_fallback === false) {
+          throw error;
+        }
+      }
+      const legacy = await this.request("/v1/memories", {
+        method: "POST",
+        body: JSON.stringify({
+          project,
+          content: params.content,
+          memory_type: toLegacyType(params.memory_type),
+          user_id: params.user_id,
+          session_id: params.session_id,
+          agent_id: params.agent_id,
+          importance: params.importance,
+          metadata: params.metadata,
+          expires_in_seconds: params.expires_in_seconds
+        })
+      });
+      const id = legacy?.memory?.id || legacy?.id || legacy?.memory_id;
+      if (!id) {
+        throw new WhisperError({
+          code: "REQUEST_FAILED",
+          message: "Memory create succeeded but no memory id was returned by the API"
+        });
+      }
+      return { id, success: true, path: "legacy", fallback_used: true };
+    });
+  }
+  async searchMemories(params) {
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/search", {
+      method: "POST",
+      body: JSON.stringify({
+        query: params.query,
+        project,
+        user_id: params.user_id,
+        session_id: params.session_id,
+        memory_types: params.memory_type ? [params.memory_type] : void 0,
+        top_k: params.top_k || 10
+      })
+    }));
+  }
+  async createApiKey(params) {
+    return this.request("/v1/keys", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async listApiKeys() {
+    return this.request("/v1/keys");
+  }
+  async getUsage(days = 30) {
+    return this.request(`/v1/usage?days=${days}`);
   }
-  const queryEmbedding = await embedSingle(query);
-  let allResults = [];
-  const maxResultsPerSearch = Math.min(topK * 2, 50);
-  const vectorResults = await vectorSearch(projectId, queryEmbedding, maxResultsPerSearch, chunkTypes);
-  allResults.push(...vectorResults);
-  if (hybridSearch) {
-    const bm25Results = await fullTextSearch(projectId, query, maxResultsPerSearch, chunkTypes);
-    allResults.push(...bm25Results);
+  async searchMemoriesSOTA(params) {
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/search", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
+    }));
   }
-  if (includeMemories) {
-    const memoryResults = await memorySearch(projectId, queryEmbedding, {
-      userId,
-      sessionId,
-      agentId,
-      topK: Math.min(Math.ceil(topK / 3), 10)
+  async ingestSession(params) {
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/ingest/session", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
+    }));
+  }
+  async getSessionMemories(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    const query = new URLSearchParams({
+      project,
+      ...params.limit && { limit: params.limit.toString() },
+      ...params.since_date && { since_date: params.since_date }
     });
-    allResults.push(...memoryResults);
+    return this.request(`/v1/memory/session/${params.session_id}?${query}`);
   }
-  if (includeGraph) {
-    const graphResults = await graphSearch(projectId, queryEmbedding, {
-      depth: Math.min(graphDepth, 2),
-      topK: Math.min(Math.ceil(topK / 3), 10)
+  async getUserProfile(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    const query = new URLSearchParams({
+      project,
+      ...params.memory_types && { memory_types: params.memory_types }
     });
-    allResults.push(...graphResults);
+    return this.request(`/v1/memory/profile/${params.user_id}?${query}`);
+  }
+  async getMemoryVersions(memoryId) {
+    return this.request(`/v1/memory/${memoryId}/versions`);
   }
-  if (allResults.length > topK * 4) {
-    allResults = allResults.sort((a, b) => b.score - a.score).slice(0, topK * 4);
+  async updateMemory(memoryId, params) {
+    return this.request(`/v1/memory/${memoryId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
   }
-  allResults = deduplicateResults(allResults);
-  if (hybridSearch) {
-    allResults = reciprocalRankFusion(allResults, vectorWeight, bm25Weight);
+  async deleteMemory(memoryId) {
+    return this.request(`/v1/memory/${memoryId}`, { method: "DELETE" });
   }
-  allResults = allResults.filter((r) => r.score >= threshold);
-  if (rerank && allResults.length > 0) {
-    const reranked = await rerankResults(query, allResults, rerankTopK || topK);
-    allResults = reranked;
+  async getMemoryRelations(memoryId) {
+    return this.request(`/v1/memory/${memoryId}/relations`);
   }
-  allResults = allResults.slice(0, topK);
-  allResults = await enrichResults(allResults);
-  let context = packContext(allResults, maxTokens);
-  const contextHash = createHash2("sha256").update(context).digest("hex").slice(0, 16);
-  let compressionMeta;
-  if (compress && context.length > 0) {
-    const compressed = await compressContext(context, {
-      maxTokens: maxTokens || 4e3,
-      strategy: compressionStrategy,
-      previousContextHash
+  async oracleSearch(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.request("/v1/oracle/search", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
     });
-    context = compressed.context;
-    compressionMeta = {
-      originalTokens: compressed.originalTokens,
-      compressedTokens: compressed.compressedTokens,
-      reductionPercent: compressed.reductionPercent,
-      strategy: compressed.strategy
-    };
   }
-  if (useCache && allResults.length > 0) {
-    await setCache(projectId, query, allResults, cacheTtlSeconds);
+  async autosubscribe(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.request("/v1/autosubscribe", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
+    });
   }
-  const latencyMs = Date.now() - startTime;
-  return {
-    results: allResults,
-    context,
-    meta: {
-      totalResults: allResults.length,
-      latencyMs,
-      cacheHit: false,
-      tokensUsed: estimateTokens2(context),
-      contextHash,
-      compression: compressionMeta
-    }
-  };
-}
-async function vectorSearch(projectId, queryEmbedding, limit, chunkTypes) {
-  const embeddingStr = `[${queryEmbedding.join(",")}]`;
-  const results = chunkTypes && chunkTypes.length > 0 ? await prisma.$queryRaw`
-        SELECT
-          id, content, "chunkType", metadata,
-          1 - (embedding <=> ${embeddingStr}::vector) as similarity
-        FROM chunks
-        WHERE "projectId" = ${projectId}
-          AND "chunkType" = ANY(${chunkTypes})
-        ORDER BY embedding <=> ${embeddingStr}::vector
-        LIMIT ${limit}
-      ` : await prisma.$queryRaw`
-        SELECT
-          id, content, "chunkType", metadata,
-          1 - (embedding <=> ${embeddingStr}::vector) as similarity
-        FROM chunks
-        WHERE "projectId" = ${projectId}
-        ORDER BY embedding <=> ${embeddingStr}::vector
-        LIMIT ${limit}
-      `;
-  return results.map((r) => ({
-    id: r.id,
-    content: r.content,
-    score: r.similarity,
-    metadata: r.metadata || {},
-    chunkType: r.chunkType,
-    source: "vector"
-  }));
-}
-async function fullTextSearch(projectId, query, limit, chunkTypes) {
-  const tsQuery = query.replace(/[^\w\s]/g, " ").trim().split(/\s+/).filter((w) => w.length > 1).join(" & ");
-  if (!tsQuery) return [];
-  const results = chunkTypes && chunkTypes.length > 0 ? await prisma.$queryRaw`
-        SELECT
-          id, content, "chunkType", metadata,
-          ts_rank(to_tsvector('english', coalesce("searchContent", content)), to_tsquery('english', ${tsQuery})) as rank
-        FROM chunks
-        WHERE "projectId" = ${projectId}
-          AND "chunkType" = ANY(${chunkTypes})
-          AND to_tsvector('english', coalesce("searchContent", content)) @@ to_tsquery('english', ${tsQuery})
-        ORDER BY rank DESC
-        LIMIT ${limit}
-      ` : await prisma.$queryRaw`
-        SELECT
-          id, content, "chunkType", metadata,
-          ts_rank(to_tsvector('english', coalesce("searchContent", content)), to_tsquery('english', ${tsQuery})) as rank
-        FROM chunks
-        WHERE "projectId" = ${projectId}
-          AND to_tsvector('english', coalesce("searchContent", content)) @@ to_tsquery('english', ${tsQuery})
-        ORDER BY rank DESC
-        LIMIT ${limit}
-      `;
-  const maxRank = results.length > 0 ? Math.max(...results.map((r) => r.rank)) : 1;
-  return results.map((r) => ({
-    id: r.id,
-    content: r.content,
-    score: maxRank > 0 ? r.rank / maxRank : 0,
-    metadata: r.metadata || {},
-    chunkType: r.chunkType,
-    source: "bm25"
-  }));
-}
-async function memorySearch(projectId, queryEmbedding, opts) {
-  const embeddingStr = `[${queryEmbedding.join(",")}]`;
-  let query;
-  if (opts.userId && opts.sessionId && opts.agentId) {
-    query = prisma.$queryRaw`
-      SELECT
-        id, content, memory_type as "memoryType", metadata, importance,
-        1 - (embedding <=> ${embeddingStr}::vector) as similarity
-      FROM memories
-      WHERE project_id = ${projectId}
-        AND is_active = true
-        AND (expires_at IS NULL OR expires_at > NOW())
-        AND user_id = ${opts.userId}
-        AND session_id = ${opts.sessionId}
-        AND agent_id = ${opts.agentId}
-      ORDER BY embedding <=> ${embeddingStr}::vector
-      LIMIT ${opts.topK}
-    `;
-  } else if (opts.userId && opts.sessionId) {
-    query = prisma.$queryRaw`
-      SELECT
-        id, content, memory_type as "memoryType", metadata, importance,
-        1 - (embedding <=> ${embeddingStr}::vector) as similarity
-      FROM memories
-      WHERE project_id = ${projectId}
-        AND is_active = true
-        AND (expires_at IS NULL OR expires_at > NOW())
-        AND user_id = ${opts.userId}
-        AND session_id = ${opts.sessionId}
-      ORDER BY embedding <=> ${embeddingStr}::vector
-      LIMIT ${opts.topK}
-    `;
-  } else if (opts.userId) {
-    query = prisma.$queryRaw`
-      SELECT
-        id, content, memory_type as "memoryType", metadata, importance,
-        1 - (embedding <=> ${embeddingStr}::vector) as similarity
-      FROM memories
-      WHERE project_id = ${projectId}
-        AND is_active = true
-        AND (expires_at IS NULL OR expires_at > NOW())
-        AND user_id = ${opts.userId}
-      ORDER BY embedding <=> ${embeddingStr}::vector
-      LIMIT ${opts.topK}
-    `;
-  } else {
-    query = prisma.$queryRaw`
-      SELECT
-        id, content, memory_type as "memoryType", metadata, importance,
-        1 - (embedding <=> ${embeddingStr}::vector) as similarity
-      FROM memories
-      WHERE project_id = ${projectId}
-        AND is_active = true
-        AND (expires_at IS NULL OR expires_at > NOW())
-      ORDER BY embedding <=> ${embeddingStr}::vector
-      LIMIT ${opts.topK}
-    `;
+  async createSharedContext(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.request("/v1/context/share", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
+    });
   }
-  const results = await query;
-  const ids = results.map((r) => r.id);
-  if (ids.length > 0) {
-    await prisma.memory.updateMany({
-      where: { id: { in: ids } },
-      data: {
-        accessCount: { increment: 1 },
-        lastAccessedAt: /* @__PURE__ */ new Date()
-      }
+  async loadSharedContext(shareId) {
+    return this.request(`/v1/context/shared/${shareId}`);
+  }
+  async resumeFromSharedContext(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.request("/v1/context/resume", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
     });
   }
-  return results.map((r) => ({
-    id: r.id,
-    content: r.content,
-    score: r.similarity * (r.importance || 0.5),
-    metadata: { ...r.metadata || {}, memoryType: r.memoryType },
-    chunkType: "memory",
-    source: "memory"
-  }));
-}
-async function graphSearch(projectId, queryEmbedding, opts) {
-  const embeddingStr = `[${queryEmbedding.join(",")}]`;
-  const relevantEntities = await prisma.$queryRaw`
-    SELECT
-      id, name, entity_type as "entityType", description, metadata, source_chunk_id as "sourceChunkId",
-      1 - (embedding <=> ${embeddingStr}::vector) as similarity
-    FROM entities
-    WHERE project_id = ${projectId}
-    ORDER BY embedding <=> ${embeddingStr}::vector
-    LIMIT 5
-  `;
-  if (relevantEntities.length === 0) return [];
-  const entityIds = relevantEntities.map((e) => e.id);
-  const relatedEntities = await prisma.$queryRaw`
-    SELECT
-      e.id, e.name, e.entity_type as "entityType", e.description, e.metadata, e.source_chunk_id as "sourceChunkId",
-      er.relation_type as "relationType", er.weight
-    FROM entity_relations er
-    INNER JOIN entities e ON er.to_entity_id = e.id
-    WHERE er.project_id = ${projectId}
-      AND er.from_entity_id = ANY(${entityIds})
-    LIMIT ${opts.topK}
-  `;
-  const chunkIds = [
-    ...relevantEntities.map((e) => e.sourceChunkId).filter(Boolean),
-    ...relatedEntities.map((e) => e.sourceChunkId).filter(Boolean)
-  ];
-  if (chunkIds.length === 0) return [];
-  const relatedChunks = await prisma.chunk.findMany({
-    where: { id: { in: chunkIds } },
-    take: opts.topK
-  });
-  return relatedChunks.map((c) => {
-    const entity = relevantEntities.find((e) => e.sourceChunkId === c.id);
-    return {
-      id: c.id,
-      content: c.content,
-      score: entity ? entity.similarity * 0.8 : 0.5,
-      metadata: {
-        ...c.metadata,
-        entityName: entity?.name,
-        entityType: entity?.entityType
-      },
-      chunkType: c.chunkType || "text",
-      source: "graph"
-    };
-  });
-}
-function reciprocalRankFusion(results, vectorWeight, bm25Weight, k = 60) {
-  const scoreMap = /* @__PURE__ */ new Map();
-  const vectorResults = results.filter((r) => r.source === "vector");
-  const bm25Results = results.filter((r) => r.source === "bm25");
-  const otherResults = results.filter((r) => r.source !== "vector" && r.source !== "bm25");
-  vectorResults.forEach((r, rank) => {
-    const existing = scoreMap.get(r.id);
-    const rrfScore = vectorWeight / (k + rank + 1);
-    if (existing) {
-      existing.score += rrfScore;
-    } else {
-      scoreMap.set(r.id, { result: r, score: rrfScore });
-    }
-  });
-  bm25Results.forEach((r, rank) => {
-    const existing = scoreMap.get(r.id);
-    const rrfScore = bm25Weight / (k + rank + 1);
-    if (existing) {
-      existing.score += rrfScore;
-      existing.result.source = "hybrid";
-    } else {
-      scoreMap.set(r.id, { result: { ...r, source: "hybrid" }, score: rrfScore });
-    }
-  });
-  otherResults.forEach((r) => {
-    if (!scoreMap.has(r.id)) {
-      scoreMap.set(r.id, { result: r, score: r.score * 0.5 });
-    }
-  });
-  return Array.from(scoreMap.values()).sort((a, b) => b.score - a.score).map((entry) => ({ ...entry.result, score: entry.score }));
-}
-async function rerankResults(query, results, topK) {
-  if (results.length <= 3) return results;
-  const candidates = results.slice(0, Math.min(results.length, topK * 3));
-  const prompt = `Given the query: "${query}"
-
-Rank these ${candidates.length} text passages by relevance (most relevant first). Return ONLY a JSON array of indices (0-based), e.g. [2, 0, 4, 1, 3].
-
-${candidates.map((r, i) => `[${i}] ${r.content.slice(0, 300)}`).join("\n\n")}`;
-  try {
-    const res = await openai2.chat.completions.create({
-      model: "gpt-4o-mini",
-      // Fixed: was "gpt-4.1-nano" which doesn't exist
-      messages: [{ role: "user", content: prompt }],
-      temperature: 0,
-      max_tokens: 200
+  async consolidateMemories(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.request("/v1/memory/consolidate", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
     });
-    const text = res.choices[0]?.message?.content?.trim() || "";
-    const match = text.match(/\[[\d,\s]+\]/);
-    if (!match) return results;
-    const indices = JSON.parse(match[0]);
-    const reranked = [];
-    for (const idx of indices) {
-      if (idx >= 0 && idx < candidates.length) {
-        reranked.push({
-          ...candidates[idx],
-          score: 1 - reranked.length * (1 / indices.length)
-          // normalize
-        });
-      }
-    }
-    for (const r of results) {
-      if (!reranked.find((rr) => rr.id === r.id)) {
-        reranked.push(r);
-      }
-    }
-    return reranked.slice(0, topK);
-  } catch {
-    return results.slice(0, topK);
   }
-}
-function deduplicateResults(results) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const r of results) {
-    const existing = seen.get(r.id);
-    if (!existing || r.score > existing.score) {
-      seen.set(r.id, r);
-    }
+  async updateImportanceDecay(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.request("/v1/memory/decay/update", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
+    });
   }
-  return Array.from(seen.values());
-}
-function packContext(results, maxTokens) {
-  if (results.length === 0) return "";
-  const limit = maxTokens || 8e3;
-  let totalTokens = 0;
-  const packed = [];
-  for (const r of results) {
-    const header = buildChunkHeader(r);
-    const block = `${header}
-${r.content}
-`;
-    const tokens = estimateTokens2(block);
-    if (totalTokens + tokens > limit) break;
-    packed.push(block);
-    totalTokens += tokens;
+  async getImportanceStats(project) {
+    const resolvedProject = await this.resolveProjectId(this.getRequiredProject(project));
+    return this.request(`/v1/memory/decay/stats?project=${resolvedProject}`);
   }
-  return packed.join("\n---\n\n");
-}
-function buildChunkHeader(r) {
-  const parts = [];
-  if (r.sourceName) parts.push(`Source: ${r.sourceName}`);
-  if (r.documentTitle) parts.push(`Document: ${r.documentTitle}`);
-  if (r.metadata?.filePath) parts.push(`File: ${r.metadata.filePath}`);
-  if (r.metadata?.startLine) parts.push(`Lines: ${r.metadata.startLine}-${r.metadata.endLine || "?"}`);
-  if (r.chunkType && r.chunkType !== "text") parts.push(`Type: ${r.chunkType}`);
-  return parts.length > 0 ? `[${parts.join(" | ")}]` : "";
-}
-function estimateTokens2(text) {
-  return Math.ceil(text.length / 4);
-}
-async function enrichResults(results) {
-  const chunkResults = results.filter((r) => r.source !== "memory");
-  if (chunkResults.length === 0) return results;
-  const chunkIds = chunkResults.map((r) => r.id);
-  if (chunkIds.length === 0) return results;
-  const chunkDocs = await prisma.$queryRaw`
-    SELECT
-      c.id as "chunkId", d.title as "docTitle", s.name as "sourceName"
-    FROM chunks c
-    INNER JOIN documents d ON c."documentId" = d.id
-    INNER JOIN sources s ON d."sourceId" = s.id
-    WHERE c.id = ANY(${chunkIds})
-  `;
-  const enrichMap = new Map(chunkDocs.map((d) => [d.chunkId, d]));
-  return results.map((r) => {
-    const enrichment = enrichMap.get(r.id);
-    if (enrichment) {
-      return {
-        ...r,
-        documentTitle: enrichment.docTitle || void 0,
-        sourceName: enrichment.sourceName || void 0
-      };
-    }
-    return r;
-  });
-}
-var MAX_CACHE_PER_PROJECT = 500;
-var lastCacheCleanup = 0;
-var CACHE_CLEANUP_INTERVAL = 6e4;
-function hashQuery(query) {
-  return createHash2("sha256").update(query.toLowerCase().trim()).digest("hex");
-}
-async function cleanupQueryCache(projectId) {
-  const now = Date.now();
-  if (now - lastCacheCleanup < CACHE_CLEANUP_INTERVAL) return;
-  lastCacheCleanup = now;
-  try {
-    const count = await prisma.queryCache.count({ where: { projectId } });
-    if (count > MAX_CACHE_PER_PROJECT * 1.5) {
-      await prisma.queryCache.deleteMany({
-        where: {
-          projectId,
-          expiresAt: { lt: /* @__PURE__ */ new Date() }
-        }
-      });
-      const remaining = await prisma.queryCache.count({ where: { projectId } });
-      if (remaining > MAX_CACHE_PER_PROJECT) {
-        const oldest = await prisma.queryCache.findFirst({
-          where: { projectId },
-          orderBy: { createdAt: "asc" },
-          skip: MAX_CACHE_PER_PROJECT - 1
-        });
-        if (oldest) {
-          await prisma.queryCache.deleteMany({
-            where: {
-              projectId,
-              createdAt: { lte: oldest.createdAt },
-              id: { notIn: (await prisma.queryCache.findMany({
-                where: { projectId },
-                take: MAX_CACHE_PER_PROJECT,
-                orderBy: { createdAt: "desc" },
-                select: { id: true }
-              })).map((x) => x.id) }
-            }
-          });
-        }
-      }
-    }
-  } catch (error) {
-    console.error("Cache cleanup error:", error);
+  async getCacheStats() {
+    return this.request("/v1/cache/stats");
   }
-}
-async function checkCache(projectId, query) {
-  const hash = hashQuery(query);
-  const cached = await prisma.queryCache.findFirst({
-    where: {
-      projectId,
-      queryHash: hash,
-      expiresAt: { gt: /* @__PURE__ */ new Date() }
-    }
-  });
-  if (cached) {
-    await prisma.queryCache.update({
-      where: { id: cached.id },
-      data: { hitCount: { increment: 1 } }
+  async warmCache(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.request("/v1/cache/warm", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
     });
-    return cached.results;
   }
-  return null;
-}
-async function setCache(projectId, query, results, ttlSeconds) {
-  const hash = hashQuery(query);
-  const expiresAt = new Date(Date.now() + ttlSeconds * 1e3);
-  await prisma.queryCache.upsert({
-    where: {
-      projectId_queryHash: {
-        projectId,
-        queryHash: hash
-      }
-    },
-    update: {
-      results,
-      expiresAt,
-      hitCount: 0
-    },
-    create: {
-      projectId,
-      queryHash: hash,
-      query,
-      results,
-      expiresAt
-    }
-  });
-  await cleanupQueryCache(projectId);
-}
+  async clearCache(params) {
+    return this.request("/v1/cache/clear", {
+      method: "DELETE",
+      body: JSON.stringify(params)
+    });
+  }
+  async getCostSummary(params = {}) {
+    const resolvedProject = params.project ? await this.resolveProjectId(params.project) : void 0;
+    const query = new URLSearchParams({
+      ...resolvedProject && { project: resolvedProject },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/summary?${query}`);
+  }
+  async getCostBreakdown(params = {}) {
+    const resolvedProject = params.project ? await this.resolveProjectId(params.project) : void 0;
+    const query = new URLSearchParams({
+      ...resolvedProject && { project: resolvedProject },
+      ...params.group_by && { group_by: params.group_by },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/breakdown?${query}`);
+  }
+  async getCostSavings(params = {}) {
+    const resolvedProject = params.project ? await this.resolveProjectId(params.project) : void 0;
+    const query = new URLSearchParams({
+      ...resolvedProject && { project: resolvedProject },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/savings?${query}`);
+  }
+  // Backward-compatible grouped namespaces.
+  projects = {
+    create: (params) => this.createProject(params),
+    list: () => this.listProjects(),
+    get: (id) => this.getProject(id),
+    delete: (id) => this.deleteProject(id)
+  };
+  sources = {
+    add: (projectId, params) => this.addSource(projectId, params),
+    sync: (sourceId) => this.syncSource(sourceId),
+    syncSource: (sourceId) => this.syncSource(sourceId)
+  };
+  memory = {
+    add: (params) => this.addMemory(params),
+    search: (params) => this.searchMemories(params),
+    searchSOTA: (params) => this.searchMemoriesSOTA(params),
+    ingestSession: (params) => this.ingestSession(params),
+    getSessionMemories: (params) => this.getSessionMemories(params),
+    getUserProfile: (params) => this.getUserProfile(params),
+    getVersions: (memoryId) => this.getMemoryVersions(memoryId),
+    update: (memoryId, params) => this.updateMemory(memoryId, params),
+    delete: (memoryId) => this.deleteMemory(memoryId),
+    getRelations: (memoryId) => this.getMemoryRelations(memoryId),
+    consolidate: (params) => this.consolidateMemories(params),
+    updateDecay: (params) => this.updateImportanceDecay(params),
+    getImportanceStats: (project) => this.getImportanceStats(project)
+  };
+  keys = {
+    create: (params) => this.createApiKey(params),
+    list: () => this.listApiKeys(),
+    getUsage: (days) => this.getUsage(days)
+  };
+  oracle = {
+    search: (params) => this.oracleSearch(params)
+  };
+  context = {
+    createShare: (params) => this.createSharedContext(params),
+    loadShare: (shareId) => this.loadSharedContext(shareId),
+    resumeShare: (params) => this.resumeFromSharedContext(params)
+  };
+  optimization = {
+    getCacheStats: () => this.getCacheStats(),
+    warmCache: (params) => this.warmCache(params),
+    clearCache: (params) => this.clearCache(params),
+    getCostSummary: (params) => this.getCostSummary(params),
+    getCostBreakdown: (params) => this.getCostBreakdown(params),
+    getCostSavings: (params) => this.getCostSavings(params)
+  };
+};
 
 // ../src/mcp/server.ts
-var ORG_ID = process.env.WHISPER_ORG_ID || "";
+var API_KEY = process.env.WHISPER_API_KEY || "";
+var DEFAULT_PROJECT = process.env.WHISPER_PROJECT || "";
+var BASE_URL = process.env.WHISPER_BASE_URL;
+if (!API_KEY) {
+  console.error("Error: WHISPER_API_KEY environment variable is required");
+  process.exit(1);
+}
+var whisper = new WhisperContext({
+  apiKey: API_KEY,
+  project: DEFAULT_PROJECT,
+  ...BASE_URL && { baseUrl: BASE_URL }
+});
 var server = new McpServer({
   name: "whisper-context",
-  version: "0.1.0"
+  version: "0.2.8"
 });
-async function resolveProject(name) {
-  const proj = await prisma.project.findFirst({
-    where: {
-      orgId: ORG_ID,
-      OR: [
-        { name },
-        { slug: name }
-      ]
-    }
-  });
-  return proj;
-}
 server.tool(
   "query_context",
   "Search your knowledge base for relevant context. Returns packed context ready for LLM consumption. Supports hybrid vector+keyword search, memory inclusion, and knowledge graph traversal.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug (optional if WHISPER_PROJECT is set)"),
     query: z.string().describe("What are you looking for?"),
     top_k: z.number().optional().default(10).describe("Number of results"),
     chunk_types: z.array(z.string()).optional().describe("Filter: code, function, class, documentation, api_spec, schema, config, text"),
@@ -806,93 +634,89 @@ server.tool(
     max_tokens: z.number().optional().describe("Max tokens for packed context")
   },
   async ({ project, query, top_k, chunk_types, include_memories, include_graph, user_id, session_id, max_tokens }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const response = await retrieve({
-      projectId: proj.id,
-      query,
-      topK: top_k,
-      chunkTypes: chunk_types,
-      includeMemories: include_memories,
-      includeGraph: include_graph,
-      userId: user_id,
-      sessionId: session_id,
-      maxTokens: max_tokens
-    });
-    if (response.results.length === 0) {
-      return { content: [{ type: "text", text: "No relevant context found." }] };
-    }
-    const header = `Found ${response.meta.totalResults} results (${response.meta.latencyMs}ms${response.meta.cacheHit ? ", cached" : ""}):
+    try {
+      const response = await whisper.query({
+        project,
+        query,
+        top_k,
+        chunk_types,
+        include_memories,
+        include_graph,
+        user_id,
+        session_id,
+        max_tokens
+      });
+      if (response.results.length === 0) {
+        return { content: [{ type: "text", text: "No relevant context found." }] };
+      }
+      const header = `Found ${response.meta.total} results (${response.meta.latency_ms}ms${response.meta.cache_hit ? ", cached" : ""}):
 
 `;
-    return { content: [{ type: "text", text: header + response.context }] };
+      return { content: [{ type: "text", text: header + response.context }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
   "add_memory",
   "Store a memory (fact, preference, decision) that persists across conversations. Memories can be scoped to a user, session, or agent.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     content: z.string().describe("The memory content to store"),
-    memory_type: z.enum(["factual", "episodic", "semantic", "procedural"]).optional().default("factual"),
+    memory_type: z.enum(["factual", "preference", "event", "relationship", "opinion", "goal", "instruction"]).optional().default("factual"),
     user_id: z.string().optional().describe("User this memory belongs to"),
     session_id: z.string().optional().describe("Session scope"),
     agent_id: z.string().optional().describe("Agent scope"),
     importance: z.number().optional().default(0.5).describe("Importance 0-1")
   },
   async ({ project, content, memory_type, user_id, session_id, agent_id, importance }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const embedding = await embedSingle(content);
-    const memory = await prisma.memory.create({
-      data: {
-        projectId: proj.id,
+    try {
+      const result = await whisper.addMemory({
+        project,
         content,
-        memoryType: memory_type,
-        userId: user_id,
-        sessionId: session_id,
-        agentId: agent_id,
-        importance,
-        embedding
-      }
-    });
-    return { content: [{ type: "text", text: `Memory stored (id: ${memory.id}, type: ${memory_type}).` }] };
+        memory_type,
+        user_id,
+        session_id,
+        agent_id,
+        importance
+      });
+      return { content: [{ type: "text", text: `Memory stored (id: ${result.id}, type: ${memory_type}).` }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
   "search_memories",
   "Search stored memories by semantic similarity. Recall facts, preferences, past decisions from previous interactions.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     query: z.string().describe("What to search for"),
     user_id: z.string().optional().describe("Filter by user"),
     session_id: z.string().optional().describe("Filter by session"),
-    top_k: z.number().optional().default(10).describe("Number of results")
+    top_k: z.number().optional().default(10).describe("Number of results"),
+    memory_types: z.array(z.enum(["factual", "preference", "event", "relationship", "opinion", "goal", "instruction"])).optional()
   },
-  async ({ project, query, user_id, session_id, top_k }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const queryEmbedding = await embedSingle(query);
-    let whereClause = `
-      project_id = '${proj.id}' 
-      AND is_active = true 
-      AND (expires_at IS NULL OR expires_at > NOW())
-    `;
-    if (user_id) whereClause += ` AND user_id = '${user_id}'`;
-    if (session_id) whereClause += ` AND session_id = '${session_id}'`;
-    const results = await prisma.$queryRawUnsafe(`
-      SELECT 
-        id, content, memory_type as "memoryType", importance,
-        1 - (embedding <=> '${JSON.stringify(queryEmbedding)}'::vector) as similarity
-      FROM memories
-      WHERE ${whereClause}
-      ORDER BY embedding <=> '${JSON.stringify(queryEmbedding)}'::vector
-      LIMIT ${top_k}
-    `);
-    if (results.length === 0) return { content: [{ type: "text", text: "No memories found." }] };
-    const text = results.map((r, i) => `${i + 1}. [${r.memoryType}, importance: ${r.importance}, score: ${r.similarity.toFixed(3)}]
+  async ({ project, query, user_id, session_id, top_k, memory_types }) => {
+    try {
+      const results = await whisper.searchMemoriesSOTA({
+        project,
+        query,
+        user_id,
+        session_id,
+        top_k,
+        memory_types
+      });
+      if (!results.memories || results.memories.length === 0) {
+        return { content: [{ type: "text", text: "No memories found." }] };
+      }
+      const text = results.memories.map((r, i) => `${i + 1}. [${r.memory_type}, score: ${r.similarity?.toFixed(3) || "N/A"}]
 ${r.content}`).join("\n\n");
-    return { content: [{ type: "text", text }] };
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
@@ -900,139 +724,56 @@ server.tool(
   "List all available context projects.",
   {},
   async () => {
-    const projs = await prisma.project.findMany({
-      where: { orgId: ORG_ID }
-    });
-    const text = projs.length === 0 ? "No projects found." : projs.map((p) => `- ${p.name} (${p.slug})${p.description ? `: ${p.description}` : ""}`).join("\n");
-    return { content: [{ type: "text", text }] };
+    try {
+      const { projects } = await whisper.listProjects();
+      const text = projects.length === 0 ? "No projects found." : projects.map((p) => `- ${p.name} (${p.slug})${p.description ? `: ${p.description}` : ""}`).join("\n");
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
   "list_sources",
   "List all data sources connected to a project.",
-  { project: z.string().describe("Project name or slug") },
+  { project: z.string().optional().describe("Project name or slug") },
   async ({ project }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const srcs = await prisma.source.findMany({
-      where: { projectId: proj.id }
-    });
-    const text = srcs.length === 0 ? "No sources connected." : srcs.map((s) => `- ${s.name} (${s.connectorType}) \u2014 ${s.status} | ${s.documentCount} docs, ${s.chunkCount} chunks`).join("\n");
-    return { content: [{ type: "text", text }] };
+    try {
+      const projectData = await whisper.getProject(project || DEFAULT_PROJECT);
+      const srcs = projectData.sources || [];
+      const text = srcs.length === 0 ? "No sources connected." : srcs.map((s) => `- ${s.name} (${s.connectorType}) \u2014 ${s.status}`).join("\n");
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
   "add_context",
   "Add text content to a project's knowledge base.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     title: z.string().describe("Title for this content"),
     content: z.string().describe("The text content to index")
   },
   async ({ project, title, content }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    let directSource = await prisma.source.findFirst({
-      where: {
-        projectId: proj.id,
-        connectorType: "custom",
-        name: "mcp-ingest"
-      }
-    });
-    if (!directSource) {
-      directSource = await prisma.source.create({
-        data: {
-          orgId: ORG_ID,
-          projectId: proj.id,
-          name: "mcp-ingest",
-          type: "custom",
-          connectorType: "custom",
-          config: {},
-          status: "READY"
-        }
-      });
-    }
-    await ingestDocument({ sourceId: directSource.id, projectId: proj.id, externalId: `mcp-${title}`, title, content });
-    return { content: [{ type: "text", text: `Indexed "${title}" (${content.length} chars) into '${project}'.` }] };
-  }
-);
-server.tool(
-  "track_conversation",
-  "Add a message to a conversation. Creates the conversation if it doesn't exist.",
-  {
-    project: z.string().describe("Project name or slug"),
-    session_id: z.string().describe("Unique session identifier"),
-    role: z.enum(["user", "assistant", "system", "tool"]),
-    content: z.string().describe("Message content"),
-    user_id: z.string().optional().describe("User identifier")
-  },
-  async ({ project, session_id, role, content, user_id }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    let conv = await prisma.session.findFirst({
-      where: {
-        projectId: proj.id,
-        sessionId: session_id
-      }
-    });
-    if (!conv) {
-      conv = await prisma.session.create({
-        data: {
-          projectId: proj.id,
-          sessionId: session_id,
-          userId: user_id
-        }
+    try {
+      await whisper.addContext({
+        project,
+        title,
+        content
       });
+      return { content: [{ type: "text", text: `Indexed "${title}" (${content.length} chars).` }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
     }
-    await prisma.message.create({
-      data: {
-        conversationId: conv.id,
-        role,
-        content
-      }
-    });
-    await prisma.session.update({
-      where: { id: conv.id },
-      data: {
-        messageCount: { increment: 1 },
-        updatedAt: /* @__PURE__ */ new Date()
-      }
-    });
-    return { content: [{ type: "text", text: `Message added (session: ${session_id}).` }] };
-  }
-);
-server.tool(
-  "get_conversation",
-  "Retrieve conversation history for a session.",
-  {
-    project: z.string().describe("Project name or slug"),
-    session_id: z.string().describe("Session identifier"),
-    limit: z.number().optional().default(50)
-  },
-  async ({ project, session_id, limit }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const conv = await prisma.session.findFirst({
-      where: {
-        projectId: proj.id,
-        sessionId: session_id
-      }
-    });
-    if (!conv) return { content: [{ type: "text", text: "No conversation found for this session." }] };
-    const msgs = await prisma.message.findMany({
-      where: { conversationId: conv.id },
-      orderBy: { createdAt: "asc" },
-      take: limit
-    });
-    const text = msgs.map((m) => `[${m.role}]: ${m.content}`).join("\n\n");
-    return { content: [{ type: "text", text: text || "No messages yet." }] };
   }
 );
 server.tool(
   "memory_search_sota",
   "SOTA memory search with temporal reasoning and relation graphs. Searches memories with support for temporal queries ('what did I say yesterday?'), type filtering, and knowledge graph traversal.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     query: z.string().describe("Search query (supports temporal: 'yesterday', 'last week')"),
     user_id: z.string().optional().describe("Filter by user"),
     session_id: z.string().optional().describe("Filter by session"),
@@ -1042,43 +783,42 @@ server.tool(
     include_relations: z.boolean().optional().default(true).describe("Include related memories via knowledge graph")
   },
   async ({ project, query, user_id, session_id, question_date, memory_types, top_k, include_relations }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const { searchMemories } = await import("./search-BLVHWLWC.js");
-    const results = await searchMemories({
-      query,
-      questionDate: question_date ? new Date(question_date) : /* @__PURE__ */ new Date(),
-      projectId: proj.id,
-      orgId: ORG_ID,
-      userId: user_id,
-      sessionId: session_id,
-      topK: top_k,
-      memoryTypes: memory_types
-    });
-    if (results.length === 0) return { content: [{ type: "text", text: "No memories found." }] };
-    const text = results.map((r, i) => {
-      let line = `${i + 1}. [${r.memory.memoryType}, confidence: ${r.memory.confidence.toFixed(2)}, score: ${r.similarity.toFixed(3)}]
-`;
-      line += `   ${r.memory.content}
+    try {
+      const results = await whisper.searchMemoriesSOTA({
+        project,
+        query,
+        user_id,
+        session_id,
+        question_date,
+        memory_types,
+        top_k,
+        include_relations
+      });
+      if (!results.memories || results.memories.length === 0) {
+        return { content: [{ type: "text", text: "No memories found." }] };
+      }
+      const text = results.memories.map((r, i) => {
+        let line = `${i + 1}. [${r.memory_type}, score: ${r.similarity?.toFixed(3) || "N/A"}]
 `;
-      if (r.memory.temporal.eventDate) {
-        line += `   Event: ${r.memory.temporal.eventDate.toISOString().split("T")[0]}
+        line += `   ${r.content}
 `;
-      }
-      if (include_relations && r.relations && r.relations.length > 0) {
-        line += `   Relations: ${r.relations.map((rel) => rel.relationType).join(", ")}
+        if (r.event_date) {
+          line += `   Event: ${new Date(r.event_date).toISOString().split("T")[0]}
 `;
-      }
-      return line;
-    }).join("\n");
-    return { content: [{ type: "text", text }] };
+        }
+        return line;
+      }).join("\n");
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
   "ingest_conversation",
   "Extract memories from a conversation session. Automatically handles disambiguation, temporal grounding, and relation detection.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     session_id: z.string().describe("Session identifier"),
     user_id: z.string().optional().describe("User identifier"),
     messages: z.array(z.object({
@@ -1088,75 +828,73 @@ server.tool(
     })).describe("Array of conversation messages with timestamps")
   },
   async ({ project, session_id, user_id, messages }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const { ingestSession } = await import("./ingest-2LPTWUUM.js");
-    const result = await ingestSession({
-      sessionId: session_id,
-      projectId: proj.id,
-      orgId: ORG_ID,
-      userId: user_id,
-      messages: messages.map((m) => ({
-        role: m.role,
-        content: m.content,
-        timestamp: new Date(m.timestamp)
-      }))
-    });
-    return {
-      content: [{
-        type: "text",
-        text: `Processed ${messages.length} messages:
-- Created ${result.memoriesCreated} memories
-- Detected ${result.relationsCreated} relations
-- Updated ${result.memoriesInvalidated} outdated memories` + (result.errors && result.errors.length > 0 ? `
+    try {
+      const result = await whisper.ingestSession({
+        project,
+        session_id,
+        user_id,
+        messages
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Processed ${messages.length} messages:
+- Created ${result.memories_created} memories
+- Detected ${result.relations_created} relations
+- Updated ${result.memories_invalidated} outdated memories` + (result.errors && result.errors.length > 0 ? `
 - Errors: ${result.errors.join(", ")}` : "")
-      }]
-    };
+        }]
+      };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
   "oracle_search",
   "Oracle Research Mode - Tree-guided document navigation with multi-step reasoning. More precise than standard search, especially for bleeding-edge features.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     query: z.string().describe("Research question"),
     mode: z.enum(["search", "research"]).optional().default("search").describe("'search' for tree-guided, 'research' for multi-step reasoning"),
     max_results: z.number().optional().default(5),
     max_steps: z.number().optional().default(5).describe("For research mode: max reasoning steps")
   },
   async ({ project, query, mode, max_results, max_steps }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const { oracleSearch, oracleResearch } = await import("./oracle-J47QCSEW.js");
-    if (mode === "research") {
-      const result = await oracleResearch({
-        question: query,
-        projectId: proj.id,
-        maxSteps: max_steps
+    try {
+      const results = await whisper.oracleSearch({
+        project,
+        query,
+        mode,
+        max_results,
+        max_steps
       });
-      let text = `Answer: ${result.answer}
+      if (mode === "research" && results.answer) {
+        let text = `Answer: ${results.answer}
 
 Reasoning Steps:
 `;
-      result.steps.forEach((step, i) => {
-        text += `${i + 1}. Query: ${step.query}
+        if (results.steps) {
+          results.steps.forEach((step, i) => {
+            text += `${i + 1}. Query: ${step.query}
    Reasoning: ${step.reasoning}
-   Results: ${step.results.length} items
+   Results: ${step.results?.length || 0} items
 `;
-      });
-      return { content: [{ type: "text", text }] };
-    } else {
-      const results = await oracleSearch({
-        query,
-        projectId: proj.id,
-        topK: max_results
-      });
-      if (results.length === 0) return { content: [{ type: "text", text: "No results found." }] };
-      const text = results.map(
-        (r, i) => `${i + 1}. [${r.path}] (relevance: ${r.relevance.toFixed(3)})
+          });
+        }
+        return { content: [{ type: "text", text }] };
+      } else {
+        if (!results.results || results.results.length === 0) {
+          return { content: [{ type: "text", text: "No results found." }] };
+        }
+        const text = results.results.map(
+          (r, i) => `${i + 1}. [${r.path || r.source}] (relevance: ${r.relevance?.toFixed(3) || r.score?.toFixed(3) || "N/A"})
 ${r.content.slice(0, 200)}...`
-      ).join("\n\n");
-      return { content: [{ type: "text", text }] };
+        ).join("\n\n");
+        return { content: [{ type: "text", text }] };
+      }
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
     }
   }
 );
@@ -1164,7 +902,7 @@ server.tool(
   "autosubscribe_dependencies",
   "Automatically index a project's dependencies (package.json, requirements.txt, etc.). Resolves docs URLs and indexes documentation.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     source_type: z.enum(["github", "local"]).describe("Source location"),
     github_owner: z.string().optional().describe("For GitHub: owner/org name"),
     github_repo: z.string().optional().describe("For GitHub: repository name"),
@@ -1173,104 +911,100 @@ server.tool(
     index_limit: z.number().optional().default(20).describe("Max dependencies to index")
   },
   async ({ project, source_type, github_owner, github_repo, local_path, dependency_file, index_limit }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const { autosubscribe } = await import("./autosubscribe-6EDKPBE2.js");
-    const result = await autosubscribe({
-      projectId: proj.id,
-      orgId: ORG_ID,
-      source: source_type === "github" ? { type: "github", owner: github_owner, repo: github_repo } : { type: "local", filePath: local_path },
-      indexLimit: index_limit
-    });
-    return {
-      content: [{
-        type: "text",
-        text: `Autosubscribe completed:
+    try {
+      const result = await whisper.autosubscribe({
+        project,
+        source: source_type === "github" ? { type: "github", owner: github_owner, repo: github_repo } : { type: "local", path: local_path },
+        index_limit
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Autosubscribe completed:
 - Discovered: ${result.discovered} dependencies
 - Indexed: ${result.indexed} successfully
-- Skipped: ${result.skipped} (already indexed)
-- Errors: ${result.errors.length}`
-      }]
-    };
+- Errors: ${result.errors?.length || 0}`
+        }]
+      };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
   "share_context",
   "Create a shareable snapshot of a conversation with memories. Returns a URL that can be shared or resumed later.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     session_id: z.string().describe("Session to share"),
     title: z.string().optional().describe("Title for the shared context"),
     expiry_days: z.number().optional().default(30).describe("Days until expiry")
   },
   async ({ project, session_id, title, expiry_days }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const { createSharedContext } = await import("./context-sharing-PH64JTXS.js");
-    const result = await createSharedContext({
-      sessionId: session_id,
-      projectId: proj.id,
-      orgId: ORG_ID,
-      includeMemories: true,
-      expiryDays: expiry_days
-    });
-    return {
-      content: [{
-        type: "text",
-        text: `Shared context created:
-- Share ID: ${result.id}
-- Memories: ${result.memories?.length || 0}
-- Messages: ${result.messages?.length || 0}
-- Expires: ${result.expiresAt?.toISOString() || "Never"}
+    try {
+      const result = await whisper.createSharedContext({
+        project,
+        session_id,
+        title,
+        expiry_days
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Shared context created:
+- Share ID: ${result.share_id}
+- Memories: ${result.memories_count || 0}
+- Messages: ${result.messages_count || 0}
+- Expires: ${result.expires_at || "Never"}
 
-Share URL: ${result.shareUrl}`
-      }]
-    };
+Share URL: ${result.share_url}`
+        }]
+      };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
   "consolidate_memories",
   "Find and merge duplicate memories to reduce bloat. Uses vector similarity + LLM merging.",
   {
-    project: z.string().describe("Project name or slug"),
+    project: z.string().optional().describe("Project name or slug"),
     similarity_threshold: z.number().optional().default(0.95).describe("Similarity threshold (0-1)"),
     dry_run: z.boolean().optional().default(false).describe("Preview without merging")
   },
   async ({ project, similarity_threshold, dry_run }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const { findDuplicateMemories, consolidateMemories } = await import("./consolidation-FOVQTWNQ.js");
-    if (dry_run) {
-      const clusters = await findDuplicateMemories({
-        projectId: proj.id,
-        similarityThreshold: similarity_threshold
+    try {
+      const result = await whisper.consolidateMemories({
+        project,
+        similarity_threshold,
+        dry_run
       });
-      const totalDuplicates = clusters.reduce((sum, c) => sum + c.duplicates.length, 0);
-      return {
-        content: [{
-          type: "text",
-          text: `Found ${clusters.length} duplicate clusters:
+      if (dry_run && result.clusters) {
+        const totalDuplicates = result.clusters.reduce((sum, c) => sum + (c.duplicates?.length || 0), 0);
+        return {
+          content: [{
+            type: "text",
+            text: `Found ${result.clusters.length} duplicate clusters:
 - Total duplicates: ${totalDuplicates}
 - Estimated savings: ${totalDuplicates} memories
 
 Run without dry_run to merge.`
-        }]
-      };
-    } else {
-      const result = await consolidateMemories({
-        projectId: proj.id,
-        similarityThreshold: similarity_threshold,
-        dryRun: false
-      });
-      return {
-        content: [{
-          type: "text",
-          text: `Consolidation complete:
-- Clusters found: ${result.clustersFound}
-- Memories merged: ${result.memoriesMerged}
-- Memories deactivated: ${result.memoriesDeactivated}`
-        }]
-      };
+          }]
+        };
+      } else {
+        return {
+          content: [{
+            type: "text",
+            text: `Consolidation complete:
+- Clusters found: ${result.clusters_found || 0}
+- Memories merged: ${result.memories_merged || 0}
+- Memories deactivated: ${result.memories_deactivated || 0}`
+          }]
+        };
+      }
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
     }
   }
 );
@@ -1282,48 +1016,39 @@ server.tool(
     days: z.number().optional().default(30).describe("Time period in days")
   },
   async ({ project, days }) => {
-    let projectId;
-    if (project) {
-      const proj = await resolveProject(project);
-      if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-      projectId = proj.id;
-    }
-    const { getCostSummary, calculateSavings } = await import("./cost-optimization-F3L5BS5F.js");
-    const endDate = /* @__PURE__ */ new Date();
-    const startDate = new Date(endDate.getTime() - days * 24 * 60 * 60 * 1e3);
-    const summary = getCostSummary({
-      since: startDate,
-      groupBy: "model"
-    });
-    const savings = calculateSavings({
-      since: startDate
-    });
-    let text = `Cost Summary (last ${days} days):
+    try {
+      const endDate = /* @__PURE__ */ new Date();
+      const startDate = new Date(endDate.getTime() - days * 24 * 60 * 60 * 1e3);
+      const summary = await whisper.getCostSummary({
+        project,
+        start_date: startDate.toISOString(),
+        end_date: endDate.toISOString()
+      });
+      const savings = await whisper.getCostSavings({
+        project,
+        start_date: startDate.toISOString(),
+        end_date: endDate.toISOString()
+      });
+      let text = `Cost Summary (last ${days} days):
 
 `;
-    text += `Total Cost: $${savings.actualCost.toFixed(2)}
+      text += `Total Cost: $${savings.actual_cost?.toFixed(2) || "0.00"}
 `;
-    text += `Total Requests: ${Object.values(summary).reduce((sum, s) => sum + s.calls, 0)}
-`;
-    text += `Avg Cost/Request: $${(savings.actualCost / (Object.values(summary).reduce((sum, s) => sum + s.calls, 0) || 1)).toFixed(4)}
+      text += `Total Requests: ${summary.total_requests || 0}
 
 `;
-    text += `By Model:
-`;
-    Object.entries(summary).forEach(([model, stats]) => {
-      text += `- ${model}: $${stats.totalCost.toFixed(2)} (${stats.calls} calls)
+      text += `Savings vs Always-Opus:
 `;
-    });
-    text += `
-Savings vs Always-Opus:
-`;
-    text += `- Actual: $${savings.actualCost.toFixed(2)}
+      text += `- Actual: $${savings.actual_cost?.toFixed(2) || "0.00"}
 `;
-    text += `- Opus-only: $${savings.opusCost.toFixed(2)}
+      text += `- Opus-only: $${savings.opus_cost?.toFixed(2) || "0.00"}
 `;
-    text += `- Saved: $${savings.savings.toFixed(2)} (${savings.savingsPercent.toFixed(1)}%)
+      text += `- Saved: $${savings.savings?.toFixed(2) || "0.00"} (${savings.savings_percent?.toFixed(1) || "0"}%)
 `;
-    return { content: [{ type: "text", text }] };
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 async function main() {