@usewhisper/mcp-server 0.1.0 → 0.3.0

package/dist/server.js

@@ -1,1468 +1,629 @@
-#\!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+#!/usr/bin/env node
 
-// src/mcp/server.ts
+// ../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/db/index.ts
-import { drizzle } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
-
-// src/db/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  apiKeys: () => apiKeys,
-  chunkTypeEnum: () => chunkTypeEnum,
-  chunks: () => chunks,
-  connectorTypeEnum: () => connectorTypeEnum,
-  conversations: () => conversations,
-  documents: () => documents,
-  entities: () => entities,
-  memories: () => memories,
-  memoryTypeEnum: () => memoryTypeEnum,
-  messages: () => messages,
-  organizations: () => organizations,
-  projects: () => projects,
-  queryCache: () => queryCache,
-  relationTypeEnum: () => relationTypeEnum,
-  relations: () => relations,
-  sourceStatusEnum: () => sourceStatusEnum,
-  sources: () => sources,
-  usageEvents: () => usageEvents,
-  webhooks: () => webhooks
-});
-import {
-  pgTable,
-  uuid,
-  text,
-  timestamp,
-  integer,
-  boolean,
-  jsonb,
-  vector,
-  index,
-  uniqueIndex,
-  pgEnum,
-  real,
-  serial
-} from "drizzle-orm/pg-core";
-var connectorTypeEnum = pgEnum("connector_type", [
-  "github",
-  "gitlab",
-  "url",
-  "sitemap",
-  "text",
-  "pdf",
-  "api_spec",
-  "database",
-  "confluence",
-  "notion",
-  "slack",
-  "discord",
-  "arxiv",
-  "huggingface",
-  "npm_package",
-  "pypi_package",
-  "custom"
-]);
-var sourceStatusEnum = pgEnum("source_status", [
-  "pending",
-  "indexing",
-  "ready",
-  "failed",
-  "stale",
-  "syncing"
-]);
-var chunkTypeEnum = pgEnum("chunk_type", [
-  "code",
-  "function",
-  "class",
-  "documentation",
-  "api_spec",
-  "schema",
-  "config",
-  "text",
-  "comment",
-  "readme",
-  "research",
-  "conversation",
-  "dataset"
-]);
-var memoryTypeEnum = pgEnum("memory_type", [
-  "factual",
-  // structured facts: "user prefers TypeScript"
-  "episodic",
-  // past interaction summaries
-  "semantic",
-  // general knowledge
-  "procedural"
-  // how-to knowledge
-]);
-var relationTypeEnum = pgEnum("relation_type", [
-  "imports",
-  "exports",
-  "calls",
-  "implements",
-  "extends",
-  "references",
-  "depends_on",
-  "related_to",
-  "part_of",
-  "contradicts",
-  "supersedes"
-]);
-var organizations = pgTable(
-  "organizations",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    whisperOrgId: text("whisper_org_id").unique(),
-    // link to main Whisper org
-    name: text("name").notNull(),
-    plan: text("plan").default("free").notNull(),
-    // free, pro, enterprise
-    settings: jsonb("settings").$type().default({}),
-    usageLimits: jsonb("usage_limits").$type().default({
-      queriesPerDay: 1e3,
-      documentsTotal: 1e4,
-      sourcesTotal: 50,
-      storageBytes: 1073741824
-      // 1GB
-    }),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-  },
-  (t) => [
-    uniqueIndex("orgs_whisper_org_idx").on(t.whisperOrgId)
-  ]
-);
-var apiKeys = pgTable(
-  "api_keys",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    orgId: uuid("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-    name: text("name").notNull(),
-    keyHash: text("key_hash").notNull(),
-    keyPrefix: text("key_prefix").notNull(),
-    // "wctx_xxxx" for identification
-    scopes: jsonb("scopes").$type().default(["read", "write"]),
-    rateLimit: integer("rate_limit").default(100),
-    // requests per minute
-    lastUsedAt: timestamp("last_used_at"),
-    expiresAt: timestamp("expires_at"),
-    isActive: boolean("is_active").default(true).notNull(),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-  },
-  (t) => [
-    uniqueIndex("api_keys_hash_idx").on(t.keyHash),
-    index("api_keys_org_idx").on(t.orgId),
-    index("api_keys_prefix_idx").on(t.keyPrefix)
-  ]
-);
-var projects = pgTable(
-  "projects",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    orgId: uuid("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-    name: text("name").notNull(),
-    slug: text("slug").notNull(),
-    description: text("description"),
-    settings: jsonb("settings").$type().default({
-      embeddingModel: "text-embedding-3-small",
-      embeddingDimensions: 1536,
-      chunkSize: 1e3,
-      chunkOverlap: 200,
-      defaultTopK: 10,
-      defaultThreshold: 0.3
-    }),
-    isPublic: boolean("is_public").default(false).notNull(),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-  },
-  (t) => [
-    uniqueIndex("projects_org_slug_idx").on(t.orgId, t.slug),
-    index("projects_org_idx").on(t.orgId),
-    index("projects_public_idx").on(t.isPublic)
-  ]
-);
-var sources = pgTable(
-  "sources",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    connectorType: connectorTypeEnum("connector_type").notNull(),
-    name: text("name").notNull(),
-    config: jsonb("config").$type().default({}),
-    status: sourceStatusEnum("status").default("pending").notNull(),
-    syncSchedule: text("sync_schedule"),
-    // cron expression for auto-sync
-    lastSyncAt: timestamp("last_sync_at"),
-    lastSyncDurationMs: integer("last_sync_duration_ms"),
-    syncError: text("sync_error"),
-    documentCount: integer("document_count").default(0),
-    chunkCount: integer("chunk_count").default(0),
-    contentHash: text("content_hash"),
-    // for change detection
-    metadata: jsonb("metadata").$type().default({}),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("sources_project_idx").on(t.projectId),
-    index("sources_status_idx").on(t.status),
-    index("sources_type_idx").on(t.connectorType)
-  ]
-);
-var documents = pgTable(
-  "documents",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    sourceId: uuid("source_id").notNull().references(() => sources.id, { onDelete: "cascade" }),
-    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    externalId: text("external_id"),
-    title: text("title"),
-    content: text("content"),
-    contentHash: text("content_hash"),
-    url: text("url"),
-    language: text("language"),
-    // programming language or natural language
-    metadata: jsonb("metadata").$type().default({}),
-    tokenCount: integer("token_count").default(0),
-    isActive: boolean("is_active").default(true).notNull(),
-    lastIndexedAt: timestamp("last_indexed_at"),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("documents_source_idx").on(t.sourceId),
-    index("documents_project_idx").on(t.projectId),
-    uniqueIndex("documents_source_external_idx").on(t.sourceId, t.externalId),
-    index("documents_hash_idx").on(t.contentHash),
-    index("documents_active_idx").on(t.projectId, t.isActive)
-  ]
-);
-var chunks = pgTable(
-  "chunks",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
-    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    content: text("content").notNull(),
-    chunkType: chunkTypeEnum("chunk_type").default("text").notNull(),
-    chunkIndex: integer("chunk_index").default(0),
-    // Search
-    embedding: vector("embedding", { dimensions: 1536 }),
-    // Full-text search column (populated via trigger or app)
-    searchContent: text("search_content"),
-    // stripped/normalized for BM25
-    // Metadata
-    metadata: jsonb("metadata").$type().default({}),
-    tokenCount: integer("token_count").default(0),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("chunks_document_idx").on(t.documentId),
-    index("chunks_project_idx").on(t.projectId),
-    index("chunks_type_idx").on(t.chunkType),
-    index("chunks_project_type_idx").on(t.projectId, t.chunkType)
-  ]
-);
-var entities = pgTable(
-  "entities",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    name: text("name").notNull(),
-    entityType: text("entity_type").notNull(),
-    // function, class, module, concept, api_endpoint, etc.
-    description: text("description"),
-    metadata: jsonb("metadata").$type().default({}),
-    sourceChunkId: uuid("source_chunk_id").references(() => chunks.id, { onDelete: "set null" }),
-    embedding: vector("embedding", { dimensions: 1536 }),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("entities_project_idx").on(t.projectId),
-    index("entities_type_idx").on(t.projectId, t.entityType),
-    uniqueIndex("entities_project_name_type_idx").on(t.projectId, t.name, t.entityType)
-  ]
-);
-var relations = pgTable(
-  "relations",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    fromEntityId: uuid("from_entity_id").notNull().references(() => entities.id, { onDelete: "cascade" }),
-    toEntityId: uuid("to_entity_id").notNull().references(() => entities.id, { onDelete: "cascade" }),
-    relationType: relationTypeEnum("relation_type").notNull(),
-    weight: real("weight").default(1),
-    metadata: jsonb("metadata").$type().default({}),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("relations_project_idx").on(t.projectId),
-    index("relations_from_idx").on(t.fromEntityId),
-    index("relations_to_idx").on(t.toEntityId),
-    uniqueIndex("relations_unique_idx").on(t.fromEntityId, t.toEntityId, t.relationType)
-  ]
-);
-var memories = pgTable(
-  "memories",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    // Scoping
-    userId: text("user_id"),
-    // user-scoped memory
-    sessionId: text("session_id"),
-    // session-scoped memory
-    agentId: text("agent_id"),
-    // agent-scoped memory
-    // Memory content
-    memoryType: memoryTypeEnum("memory_type").default("factual").notNull(),
-    content: text("content").notNull(),
-    summary: text("summary"),
-    // LLM-generated summary
-    embedding: vector("embedding", { dimensions: 1536 }),
-    // Management
-    importance: real("importance").default(0.5),
-    // 0-1 how important is this
-    accessCount: integer("access_count").default(0),
-    lastAccessedAt: timestamp("last_accessed_at"),
-    expiresAt: timestamp("expires_at"),
-    // optional TTL
-    metadata: jsonb("metadata").$type().default({}),
-    isActive: boolean("is_active").default(true).notNull(),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("memories_project_idx").on(t.projectId),
-    index("memories_user_idx").on(t.projectId, t.userId),
-    index("memories_session_idx").on(t.projectId, t.sessionId),
-    index("memories_agent_idx").on(t.projectId, t.agentId),
-    index("memories_type_idx").on(t.projectId, t.memoryType),
-    index("memories_active_idx").on(t.projectId, t.isActive),
-    index("memories_expires_idx").on(t.expiresAt)
-  ]
-);
-var conversations = pgTable(
-  "conversations",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    sessionId: text("session_id"),
-    userId: text("user_id"),
-    agentId: text("agent_id"),
-    title: text("title"),
-    summary: text("summary"),
-    embedding: vector("embedding", { dimensions: 1536 }),
-    metadata: jsonb("metadata").$type().default({}),
-    messageCount: integer("message_count").default(0),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("conversations_project_idx").on(t.projectId),
-    index("conversations_session_idx").on(t.sessionId),
-    index("conversations_user_idx").on(t.userId)
-  ]
-);
-var messages = pgTable(
-  "messages",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    conversationId: uuid("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    role: text("role").notNull(),
-    // user, assistant, system, tool
-    content: text("content").notNull(),
-    metadata: jsonb("metadata").$type().default({}),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("messages_conversation_idx").on(t.conversationId),
-    index("messages_created_idx").on(t.conversationId, t.createdAt)
-  ]
-);
-var webhooks = pgTable(
-  "webhooks",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    orgId: uuid("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-    url: text("url").notNull(),
-    secret: text("secret").notNull(),
-    events: jsonb("events").$type().default([
-      "source.synced",
-      "document.indexed",
-      "memory.created"
-    ]),
-    isActive: boolean("is_active").default(true).notNull(),
-    lastDeliveredAt: timestamp("last_delivered_at"),
-    failureCount: integer("failure_count").default(0),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("webhooks_org_idx").on(t.orgId)
-  ]
-);
-var usageEvents = pgTable(
-  "usage_events",
-  {
-    id: serial("id").primaryKey(),
-    orgId: uuid("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-    projectId: uuid("project_id"),
-    eventType: text("event_type").notNull(),
-    // query, ingest, sync, memory_add, memory_search
-    source: text("source").default("api"),
-    // api, mcp, sdk, webhook
-    tokensUsed: integer("tokens_used").default(0),
-    embeddingTokens: integer("embedding_tokens").default(0),
-    latencyMs: integer("latency_ms"),
-    metadata: jsonb("metadata").$type().default({}),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-  },
-  (t) => [
-    index("usage_org_idx").on(t.orgId),
-    index("usage_project_idx").on(t.projectId),
-    index("usage_type_idx").on(t.eventType),
-    index("usage_created_idx").on(t.createdAt),
-    index("usage_org_created_idx").on(t.orgId, t.createdAt)
-  ]
-);
-var queryCache = pgTable(
-  "query_cache",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-    queryHash: text("query_hash").notNull(),
-    query: text("query").notNull(),
-    results: jsonb("results").$type().default([]),
-    hitCount: integer("hit_count").default(0),
-    expiresAt: timestamp("expires_at").notNull(),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-  },
-  (t) => [
-    uniqueIndex("cache_project_query_idx").on(t.projectId, t.queryHash),
-    index("cache_expires_idx").on(t.expiresAt)
-  ]
-);
-
-// src/db/index.ts
-var connectionString = process.env.DATABASE_URL;
-var client = postgres(connectionString, { max: 10 });
-var db = drizzle(client, { schema: schema_exports });
-
-// src/mcp/server.ts
-import { eq as eq3, and as and2, sql as sql2 } from "drizzle-orm";
-
-// src/engine/retriever.ts
-import { eq, sql, and, inArray, or, isNull, gt } from "drizzle-orm";
-
-// src/engine/embeddings.ts
-import OpenAI from "openai";
-var openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-async function embed(texts) {
-  const res = await openai.embeddings.create({
-    model: "text-embedding-3-small",
-    input: texts,
-    dimensions: 1536
-  });
-  return res.data.map((d) => d.embedding);
+// ../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 embedSingle(text2) {
-  const [embedding] = await embed([text2]);
-  return embedding;
+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));
 }
-
-// src/engine/compressor.ts
-import OpenAI2 from "openai";
-import { createHash } from "crypto";
-var openai2 = new OpenAI2({ apiKey: process.env.OPENAI_API_KEY });
-var deltaCache = /* @__PURE__ */ new Map();
-var DELTA_CACHE_TTL = 6e5;
-function hashContext(text2) {
-  return createHash("sha256").update(text2).digest("hex").slice(0, 16);
+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);
 }
-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"
+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
     };
   }
-  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);
+  withProject(project) {
+    return new _WhisperContext({
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      project,
+      orgId: this.orgId,
+      timeoutMs: this.timeoutMs,
+      retry: this.retryConfig
+    });
   }
-}
-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;
+  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;
   }
-  if (ratio < 2) {
-    return extractCompress(rawContext, originalTokens, maxTokens);
+  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;
   }
-  return summarizeCompress(rawContext, originalTokens, maxTokens);
-}
-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"
-    };
+  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`
+    });
+  }
+  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);
+  }
+  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`
+    });
   }
-  let prevCtx = previousCtx;
-  if (!prevCtx && previousHash) {
-    const cached = deltaCache.get(previousHash);
-    if (cached && Date.now() - cached.timestamp < DELTA_CACHE_TTL) {
-      prevCtx = cached.context;
+  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 };
   }
-  if (!prevCtx) {
-    return extractCompress(rawContext, originalTokens, maxTokens);
+  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
+          }
+        });
+        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));
+      }
+    }
+    throw lastError instanceof Error ? lastError : new WhisperError({ code: "REQUEST_FAILED", message: "Request failed" });
+  }
+  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;
   }
-  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 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);
     }
+    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+    return projects;
   }
-  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 getProject(id) {
+    const projectId = await this.resolveProjectId(id);
+    return this.request(`/v1/projects/${projectId}`);
   }
-  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 deleteProject(id) {
+    const projectId = await this.resolveProjectId(id);
+    return this.request(`/v1/projects/${projectId}`, { method: "DELETE" });
   }
-  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 openai2.chat.completions.create({
-      model: "gpt-4.1-nano",
-      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 addSource(projectId, params) {
+    const resolvedProjectId = await this.resolveProjectId(projectId);
+    return this.request(`/v1/projects/${resolvedProjectId}/sources`, {
+      method: "POST",
+      body: JSON.stringify(params)
     });
-    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);
+  async syncSource(sourceId) {
+    return this.request(`/v1/sources/${sourceId}/sync`, { method: "POST" });
   }
-  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 openai2.chat.completions.create({
-          model: "gpt-4.1-nano",
-          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
-        });
-        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);
-    }
-    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"
-    };
+  async ingest(projectId, documents) {
+    const resolvedProjectId = await this.resolveProjectId(projectId);
+    return this.request(`/v1/projects/${resolvedProjectId}/ingest`, {
+      method: "POST",
+      body: JSON.stringify({ documents })
+    });
   }
-}
-function estimateTokens(text2) {
-  return Math.ceil(text2.length / 4);
-}
-function truncateToTokens(text2, maxTokens) {
-  const maxChars = maxTokens * 4;
-  if (text2.length <= maxChars) return text2;
-  return text2.slice(0, maxChars) + "\n\n[...truncated]";
-}
-setInterval(() => {
-  const now = Date.now();
-  for (const [key, val] of deltaCache) {
-    if (now - val.timestamp > DELTA_CACHE_TTL) deltaCache.delete(key);
+  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" }
+      }
+    ]);
   }
-}, 6e4);
-
-// src/engine/retriever.ts
-import { createHash as createHash2 } from "crypto";
-import OpenAI3 from "openai";
-var openai3 = new OpenAI3({ 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) {
-      return {
-        results: cached,
-        context: packContext(cached, maxTokens),
-        meta: {
-          totalResults: cached.length,
-          latencyMs: Date.now() - startTime,
-          cacheHit: true,
-          tokensUsed: 0
+  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 };
+    });
   }
-  const queryEmbedding = await embedSingle(query);
-  let allResults = [];
-  const vectorResults = await vectorSearch(projectId, queryEmbedding, topK * 2, chunkTypes);
-  allResults.push(...vectorResults);
-  if (hybridSearch) {
-    const bm25Results = await fullTextSearch(projectId, query, topK * 2, chunkTypes);
-    allResults.push(...bm25Results);
+  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
+      })
+    }));
   }
-  if (includeMemories) {
-    const memoryResults = await memorySearch(projectId, queryEmbedding, {
-      userId,
-      sessionId,
-      agentId,
-      topK: Math.ceil(topK / 3)
+  async createApiKey(params) {
+    return this.request("/v1/keys", {
+      method: "POST",
+      body: JSON.stringify(params)
     });
-    allResults.push(...memoryResults);
   }
-  if (includeGraph) {
-    const graphResults = await graphSearch(projectId, queryEmbedding, {
-      depth: graphDepth,
-      topK: Math.ceil(topK / 3)
+  async listApiKeys() {
+    return this.request("/v1/keys");
+  }
+  async getUsage(days = 30) {
+    return this.request(`/v1/usage?days=${days}`);
+  }
+  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 })
+    }));
+  }
+  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(...graphResults);
+    return this.request(`/v1/memory/session/${params.session_id}?${query}`);
   }
-  allResults = deduplicateResults(allResults);
-  if (hybridSearch) {
-    allResults = reciprocalRankFusion(allResults, vectorWeight, bm25Weight);
+  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 }
+    });
+    return this.request(`/v1/memory/profile/${params.user_id}?${query}`);
   }
-  allResults = allResults.filter((r) => r.score >= threshold);
-  if (rerank && allResults.length > 0) {
-    const reranked = await rerankResults(query, allResults, rerankTopK || topK);
-    allResults = reranked;
+  async getMemoryVersions(memoryId) {
+    return this.request(`/v1/memory/${memoryId}/versions`);
   }
-  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 updateMemory(memoryId, params) {
+    return this.request(`/v1/memory/${memoryId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
     });
-    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 deleteMemory(memoryId) {
+    return this.request(`/v1/memory/${memoryId}`, { method: "DELETE" });
   }
-  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 conditions = [eq(chunks.projectId, projectId)];
-  if (chunkTypes && chunkTypes.length > 0) {
-    conditions.push(inArray(chunks.chunkType, chunkTypes));
+  async getMemoryRelations(memoryId) {
+    return this.request(`/v1/memory/${memoryId}/relations`);
   }
-  const results = await db.select({
-    id: chunks.id,
-    content: chunks.content,
-    chunkType: chunks.chunkType,
-    metadata: chunks.metadata,
-    documentId: chunks.documentId,
-    similarity: sql`1 - (${chunks.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`
-  }).from(chunks).where(and(...conditions)).orderBy(sql`${chunks.embedding} <=> ${JSON.stringify(queryEmbedding)}::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 conditions = [eq(chunks.projectId, projectId)];
-  if (chunkTypes && chunkTypes.length > 0) {
-    conditions.push(inArray(chunks.chunkType, chunkTypes));
+  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 })
+    });
   }
-  const results = await db.select({
-    id: chunks.id,
-    content: chunks.content,
-    chunkType: chunks.chunkType,
-    metadata: chunks.metadata,
-    documentId: chunks.documentId,
-    rank: sql`ts_rank(to_tsvector('english', coalesce(${chunks.searchContent}, ${chunks.content})), to_tsquery('english', ${tsQuery}))`
-  }).from(chunks).where(
-    and(
-      ...conditions,
-      sql`to_tsvector('english', coalesce(${chunks.searchContent}, ${chunks.content})) @@ to_tsquery('english', ${tsQuery})`
-    )
-  ).orderBy(sql`ts_rank(to_tsvector('english', coalesce(${chunks.searchContent}, ${chunks.content})), to_tsquery('english', ${tsQuery})) 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 conditions = [
-    eq(memories.projectId, projectId),
-    eq(memories.isActive, true),
-    or(isNull(memories.expiresAt), gt(memories.expiresAt, /* @__PURE__ */ new Date()))
-  ];
-  if (opts.userId) conditions.push(eq(memories.userId, opts.userId));
-  if (opts.sessionId) conditions.push(eq(memories.sessionId, opts.sessionId));
-  if (opts.agentId) conditions.push(eq(memories.agentId, opts.agentId));
-  const results = await db.select({
-    id: memories.id,
-    content: memories.content,
-    memoryType: memories.memoryType,
-    metadata: memories.metadata,
-    importance: memories.importance,
-    similarity: sql`1 - (${memories.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`
-  }).from(memories).where(and(...conditions)).orderBy(sql`${memories.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`).limit(opts.topK);
-  if (results.length > 0) {
-    const ids = results.map((r) => r.id);
-    await db.update(memories).set({
-      accessCount: sql`${memories.accessCount} + 1`,
-      lastAccessedAt: /* @__PURE__ */ new Date()
-    }).where(inArray(memories.id, ids));
+  async autosubscribe(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    return this.request("/v1/autosubscribe", {
+      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 relevantEntities = await db.select({
-    id: entities.id,
-    name: entities.name,
-    entityType: entities.entityType,
-    description: entities.description,
-    metadata: entities.metadata,
-    sourceChunkId: entities.sourceChunkId,
-    similarity: sql`1 - (${entities.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`
-  }).from(entities).where(eq(entities.projectId, projectId)).orderBy(sql`${entities.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`).limit(5);
-  if (relevantEntities.length === 0) return [];
-  const entityIds = relevantEntities.map((e) => e.id);
-  const relatedEntities = await db.select({
-    id: entities.id,
-    name: entities.name,
-    entityType: entities.entityType,
-    description: entities.description,
-    metadata: entities.metadata,
-    sourceChunkId: entities.sourceChunkId,
-    relationType: relations.relationType,
-    weight: relations.weight
-  }).from(relations).innerJoin(entities, eq(relations.toEntityId, entities.id)).where(
-    and(
-      eq(relations.projectId, projectId),
-      inArray(relations.fromEntityId, 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 db.select().from(chunks).where(inArray(chunks.id, chunkIds));
-  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,
-      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 openai3.chat.completions.create({
-      model: "gpt-4.1-nano",
-      messages: [{ role: "user", content: prompt }],
-      temperature: 0,
-      max_tokens: 200
+  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 text2 = res.choices[0]?.message?.content?.trim() || "";
-    const match = text2.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 loadSharedContext(shareId) {
+    return this.request(`/v1/context/shared/${shareId}`);
   }
-  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 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 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(text2) {
-  return Math.ceil(text2.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);
-  const chunkDocs = await db.select({
-    chunkId: chunks.id,
-    docTitle: documents.title,
-    sourceName: sources.name,
-    docId: documents.id,
-    sourceId: sources.id
-  }).from(chunks).innerJoin(documents, eq(chunks.documentId, documents.id)).innerJoin(sources, eq(documents.sourceId, sources.id)).where(inArray(chunks.id, 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;
-  });
-}
-function hashQuery(query) {
-  return createHash2("sha256").update(query.toLowerCase().trim()).digest("hex");
-}
-async function checkCache(projectId, query) {
-  const hash = hashQuery(query);
-  const [cached] = await db.select().from(queryCache).where(
-    and(
-      eq(queryCache.projectId, projectId),
-      eq(queryCache.queryHash, hash),
-      gt(queryCache.expiresAt, /* @__PURE__ */ new Date())
-    )
-  ).limit(1);
-  if (cached) {
-    await db.update(queryCache).set({ hitCount: sql`${queryCache.hitCount} + 1` }).where(eq(queryCache.id, cached.id));
-    return cached.results;
+  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 })
+    });
   }
-  return null;
-}
-async function setCache(projectId, query, results, ttlSeconds) {
-  const hash = hashQuery(query);
-  const expiresAt = new Date(Date.now() + ttlSeconds * 1e3);
-  await db.insert(queryCache).values({
-    projectId,
-    queryHash: hash,
-    query,
-    results,
-    expiresAt
-  }).onConflictDoUpdate({
-    target: [queryCache.projectId, queryCache.queryHash],
-    set: { results, expiresAt, hitCount: 0 }
-  });
-}
-
-// src/engine/ingest.ts
-import { eq as eq2 } from "drizzle-orm";
-
-// src/engine/chunker.ts
-var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".py",
-  ".java",
-  ".go",
-  ".rb",
-  ".php",
-  ".cs",
-  ".rs",
-  ".swift",
-  ".kt",
-  ".scala",
-  ".c",
-  ".cpp",
-  ".h",
-  ".hpp",
-  ".sol",
-  ".vy"
-]);
-var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".json",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".ini",
-  ".env",
-  ".xml"
-]);
-function detectChunkType(filePath, content) {
-  if (!filePath) return "text";
-  const ext = "." + filePath.split(".").pop()?.toLowerCase();
-  if (CODE_EXTENSIONS.has(ext)) return "code";
-  if (CONFIG_EXTENSIONS.has(ext)) return "config";
-  if (filePath.includes("schema") || filePath.includes("migration")) return "schema";
-  if (filePath.endsWith(".md") || filePath.endsWith(".mdx") || filePath.endsWith(".rst")) return "documentation";
-  if (filePath.includes("openapi") || filePath.includes("swagger")) return "api_spec";
-  return "text";
-}
-function chunkText(content, opts = {}) {
-  const { chunkSize = 1e3, chunkOverlap = 200, filePath, metadata = {} } = opts;
-  const chunkType = detectChunkType(filePath, content);
-  if (chunkType === "code") {
-    return chunkCode(content, { chunkSize, filePath, metadata });
+  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 chunkBySize(content, { chunkSize, chunkOverlap, chunkType, metadata });
-}
-function chunkCode(content, opts) {
-  const { chunkSize, filePath, metadata = {} } = opts;
-  const lines = content.split("\n");
-  const chunks2 = [];
-  const boundaries = [
-    /^(export\s+)?(async\s+)?function\s+/,
-    /^(export\s+)?(default\s+)?class\s+/,
-    /^(export\s+)?const\s+\w+\s*=\s*(async\s+)?\(/,
-    /^(export\s+)?const\s+\w+\s*=\s*\{/,
-    /^(export\s+)?interface\s+/,
-    /^(export\s+)?type\s+/,
-    /^(export\s+)?enum\s+/,
-    /^def\s+/,
-    // Python
-    /^class\s+/,
-    // Python/Java
-    /^func\s+/,
-    // Go
-    /^pub\s+(fn|struct|enum|impl)/
-    // Rust
-  ];
-  let currentChunk = [];
-  let currentStart = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trimStart();
-    const isBoundary = boundaries.some((b) => b.test(trimmed));
-    if (isBoundary && currentChunk.length > 0) {
-      const chunkContent = currentChunk.join("\n").trim();
-      if (chunkContent.length > 0) {
-        chunks2.push({
-          content: chunkContent,
-          chunkType: "code",
-          chunkIndex: chunks2.length,
-          metadata: {
-            ...metadata,
-            filePath,
-            startLine: currentStart + 1,
-            endLine: i
-          }
-        });
-      }
-      currentChunk = [lines[i]];
-      currentStart = i;
-    } else {
-      currentChunk.push(lines[i]);
-    }
-    if (currentChunk.join("\n").length > chunkSize * 1.5) {
-      const chunkContent = currentChunk.join("\n").trim();
-      if (chunkContent.length > 0) {
-        chunks2.push({
-          content: chunkContent,
-          chunkType: "code",
-          chunkIndex: chunks2.length,
-          metadata: {
-            ...metadata,
-            filePath,
-            startLine: currentStart + 1,
-            endLine: i + 1
-          }
-        });
-      }
-      currentChunk = [];
-      currentStart = i + 1;
-    }
+  async getImportanceStats(project) {
+    const resolvedProject = await this.resolveProjectId(this.getRequiredProject(project));
+    return this.request(`/v1/memory/decay/stats?project=${resolvedProject}`);
   }
-  if (currentChunk.length > 0) {
-    const chunkContent = currentChunk.join("\n").trim();
-    if (chunkContent.length > 0) {
-      chunks2.push({
-        content: chunkContent,
-        chunkType: "code",
-        chunkIndex: chunks2.length,
-        metadata: {
-          ...metadata,
-          filePath,
-          startLine: currentStart + 1,
-          endLine: lines.length
-        }
-      });
-    }
+  async getCacheStats() {
+    return this.request("/v1/cache/stats");
   }
-  return chunks2;
-}
-function chunkBySize(content, opts) {
-  const { chunkSize, chunkOverlap, chunkType, metadata = {} } = opts;
-  const chunks2 = [];
-  const paragraphs = content.split(/\n\n+/);
-  let current = "";
-  for (const para of paragraphs) {
-    if ((current + "\n\n" + para).length > chunkSize && current.length > 0) {
-      chunks2.push({
-        content: current.trim(),
-        chunkType,
-        chunkIndex: chunks2.length,
-        metadata
-      });
-      const words = current.split(/\s+/);
-      const overlapWords = words.slice(-Math.floor(chunkOverlap / 5));
-      current = overlapWords.join(" ") + "\n\n" + para;
-    } else {
-      current = current ? current + "\n\n" + para : para;
-    }
+  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 })
+    });
   }
-  if (current.trim().length > 0) {
-    chunks2.push({
-      content: current.trim(),
-      chunkType,
-      chunkIndex: chunks2.length,
-      metadata
+  async clearCache(params) {
+    return this.request("/v1/cache/clear", {
+      method: "DELETE",
+      body: JSON.stringify(params)
     });
   }
-  return chunks2;
-}
-
-// src/engine/extractor.ts
-import OpenAI4 from "openai";
-var openai4 = new OpenAI4({ apiKey: process.env.OPENAI_API_KEY });
-async function extractEntities(projectId, content, chunkType, metadata = {}, chunkId) {
-  if (content.length < 100) return { entities: 0, relations: 0 };
-  const isCode = ["code", "function", "class"].includes(chunkType);
-  const prompt = isCode ? `Analyze this code and extract entities and relationships.
-
-Entities: functions, classes, interfaces, types, modules, variables, constants, API endpoints, services.
-Relations: imports, exports, calls, implements, extends, depends_on, references, part_of.
-
-Code:
-\`\`\`
-${content.slice(0, 3e3)}
-\`\`\`
-
-Respond with JSON only:
-{
-  "entities": [{"name": "...", "type": "function|class|interface|module|constant|api_endpoint|service", "description": "one line"}],
-  "relations": [{"from": "name", "fromType": "type", "to": "name", "toType": "type", "relation": "imports|calls|extends|implements|depends_on|references|part_of"}]
-}` : `Analyze this text and extract key entities (concepts, people, tools, services, APIs, technologies) and their relationships.
-
-Text:
-${content.slice(0, 3e3)}
-
-Respond with JSON only:
-{
-  "entities": [{"name": "...", "type": "concept|tool|service|api|technology|person|organization", "description": "one line"}],
-  "relations": [{"from": "name", "fromType": "type", "to": "name", "toType": "type", "relation": "references|depends_on|related_to|part_of|supersedes"}]
-}`;
-  try {
-    const res = await openai4.chat.completions.create({
-      model: "gpt-4.1-nano",
-      messages: [{ role: "user", content: prompt }],
-      temperature: 0,
-      max_tokens: 1e3,
-      response_format: { type: "json_object" }
+  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 }
     });
-    const text2 = res.choices[0]?.message?.content?.trim() || "{}";
-    const parsed = JSON.parse(text2);
-    const extractedEntities = parsed.entities || [];
-    const extractedRelations = parsed.relations || [];
-    let entityCount = 0;
-    let relationCount = 0;
-    const entityMap = /* @__PURE__ */ new Map();
-    for (const ent of extractedEntities.slice(0, 20)) {
-      if (!ent.name || !ent.type) continue;
-      const embedding = await embedSingle(`${ent.type}: ${ent.name} - ${ent.description || ""}`);
-      const [entity] = await db.insert(entities).values({
-        projectId,
-        name: ent.name,
-        entityType: ent.type,
-        description: ent.description,
-        metadata: { ...metadata, autoExtracted: true },
-        sourceChunkId: chunkId,
-        embedding
-      }).onConflictDoUpdate({
-        target: [entities.projectId, entities.name, entities.entityType],
-        set: {
-          description: ent.description,
-          sourceChunkId: chunkId,
-          embedding,
-          updatedAt: /* @__PURE__ */ new Date()
-        }
-      }).returning();
-      entityMap.set(`${ent.name}:${ent.type}`, entity.id);
-      entityCount++;
-    }
-    for (const rel of extractedRelations.slice(0, 30)) {
-      if (!rel.from || !rel.to || !rel.relation) continue;
-      const fromId = entityMap.get(`${rel.from}:${rel.fromType}`);
-      const toId = entityMap.get(`${rel.to}:${rel.toType}`);
-      if (!fromId || !toId) continue;
-      const validRelations = [
-        "imports",
-        "exports",
-        "calls",
-        "implements",
-        "extends",
-        "references",
-        "depends_on",
-        "related_to",
-        "part_of",
-        "contradicts",
-        "supersedes"
-      ];
-      if (!validRelations.includes(rel.relation)) continue;
-      await db.insert(relations).values({
-        projectId,
-        fromEntityId: fromId,
-        toEntityId: toId,
-        relationType: rel.relation,
-        metadata: { autoExtracted: true }
-      }).onConflictDoUpdate({
-        target: [relations.fromEntityId, relations.toEntityId, relations.relationType],
-        set: { metadata: { autoExtracted: true } }
-      });
-      relationCount++;
-    }
-    return { entities: entityCount, relations: relationCount };
-  } catch {
-    return { entities: 0, relations: 0 };
+    return this.request(`/v1/cost/summary?${query}`);
   }
-}
-
-// src/engine/ingest.ts
-import { createHash as createHash3 } from "crypto";
-import PQueue from "p-queue";
-var queue = new PQueue({ concurrency: 3 });
-var ENABLE_AUTO_EXTRACTION = process.env.DISABLE_AUTO_EXTRACTION !== "true";
-async function ingestDocument(input) {
-  const { sourceId, projectId, externalId, title, content, metadata = {}, filePath } = input;
-  const contentHash = createHash3("sha256").update(content).digest("hex");
-  const [doc] = await db.insert(documents).values({
-    sourceId,
-    projectId,
-    externalId,
-    title,
-    content,
-    metadata,
-    contentHash
-  }).onConflictDoUpdate({
-    target: [documents.sourceId, documents.externalId],
-    set: { title, content, metadata, contentHash, updatedAt: /* @__PURE__ */ new Date() }
-  }).returning();
-  await db.delete(chunks).where(eq2(chunks.documentId, doc.id));
-  const textChunks = chunkText(content, {
-    filePath: filePath || externalId,
-    metadata: { ...metadata, title }
-  });
-  if (textChunks.length === 0) return doc;
-  const batchSize = 50;
-  const insertedChunkIds = [];
-  for (let i = 0; i < textChunks.length; i += batchSize) {
-    const batch = textChunks.slice(i, i + batchSize);
-    const embeddings = await embed(batch.map((c) => c.content));
-    const inserted = await db.insert(chunks).values(
-      batch.map((chunk, j) => ({
-        documentId: doc.id,
-        projectId,
-        content: chunk.content,
-        chunkType: chunk.chunkType,
-        chunkIndex: chunk.chunkIndex,
-        metadata: chunk.metadata,
-        embedding: embeddings[j],
-        tokenCount: Math.ceil(chunk.content.length / 4)
-      }))
-    ).returning({ id: chunks.id });
-    insertedChunkIds.push(...inserted.map((c) => c.id));
+  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}`);
   }
-  if (ENABLE_AUTO_EXTRACTION && !input.skipEntityExtraction) {
-    const chunksToExtract = textChunks.filter((c) => c.content.length > 200).slice(0, 5);
-    for (let i = 0; i < chunksToExtract.length; i++) {
-      const chunk = chunksToExtract[i];
-      const chunkId = insertedChunkIds[textChunks.indexOf(chunk)];
-      extractEntities(projectId, chunk.content, chunk.chunkType, metadata, chunkId).catch(() => {
-      });
-    }
+  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}`);
   }
-  const docCount = await db.select({ count: db.$count(documents, eq2(documents.sourceId, sourceId)) }).from(documents);
-  const chunkCount = await db.select({ count: db.$count(chunks, eq2(chunks.documentId, doc.id)) }).from(chunks);
-  await db.update(sources).set({
-    documentCount: Number(docCount[0]?.count || 0),
-    chunkCount: Number(chunkCount[0]?.count || 0),
-    lastSyncAt: /* @__PURE__ */ new Date(),
-    status: "ready",
-    updatedAt: /* @__PURE__ */ new Date()
-  }).where(eq2(sources.id, sourceId));
-  return doc;
-}
+  // 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 || "";
+// ../src/mcp/server.ts
+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 db.select().from(projects).where(
-    and2(
-      eq3(projects.orgId, ORG_ID),
-      sql2`(${projects.name} = ${name} OR ${projects.slug} = ${name})`
-    )
-  ).limit(1);
-  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"),
@@ -1473,89 +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 db.insert(memories).values({
-      projectId: proj.id,
-      content,
-      memoryType: memory_type,
-      userId: user_id,
-      sessionId: session_id,
-      agentId: agent_id,
-      importance,
-      embedding
-    }).returning();
-    return { content: [{ type: "text", text: `Memory stored (id: ${memory.id}, type: ${memory_type}).` }] };
+    try {
+      const result = await whisper.addMemory({
+        project,
+        content,
+        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);
-    const conditions = [
-      eq3(memories.projectId, proj.id),
-      eq3(memories.isActive, true),
-      sql2`(${memories.expiresAt} IS NULL OR ${memories.expiresAt} > NOW())`
-    ];
-    if (user_id) conditions.push(eq3(memories.userId, user_id));
-    if (session_id) conditions.push(eq3(memories.sessionId, session_id));
-    const results = await db.select({
-      id: memories.id,
-      content: memories.content,
-      memoryType: memories.memoryType,
-      importance: memories.importance,
-      similarity: sql2`1 - (${memories.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`
-    }).from(memories).where(and2(...conditions)).orderBy(sql2`${memories.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`).limit(top_k);
-    if (results.length === 0) return { content: [{ type: "text", text: "No memories found." }] };
-    const text2 = 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: text2 }] };
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 server.tool(
@@ -1563,80 +724,331 @@ server.tool(
   "List all available context projects.",
   {},
   async () => {
-    const projs = await db.select().from(projects).where(eq3(projects.orgId, ORG_ID));
-    const text2 = projs.length === 0 ? "No projects found." : projs.map((p) => `- ${p.name} (${p.slug})${p.description ? `: ${p.description}` : ""}`).join("\n");
-    return { content: [{ type: "text", text: text2 }] };
+    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 db.select().from(sources).where(eq3(sources.projectId, proj.id));
-    const text2 = 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: text2 }] };
+    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 db.select().from(sources).where(and2(eq3(sources.projectId, proj.id), eq3(sources.connectorType, "custom"), eq3(sources.name, "mcp-ingest"))).limit(1);
-    if (!directSource) {
-      [directSource] = await db.insert(sources).values({ projectId: proj.id, name: "mcp-ingest", connectorType: "custom", config: {}, status: "ready" }).returning();
+    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 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.",
+  "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"),
-    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")
+    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"),
+    question_date: z.string().optional().describe("ISO datetime for temporal grounding"),
+    memory_types: z.array(z.enum(["factual", "preference", "event", "relationship", "opinion", "goal", "instruction"])).optional(),
+    top_k: z.number().optional().default(10),
+    include_relations: z.boolean().optional().default(true).describe("Include related memories via knowledge graph")
   },
-  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 db.select().from(conversations).where(and2(eq3(conversations.projectId, proj.id), eq3(conversations.sessionId, session_id))).limit(1);
-    if (!conv) {
-      [conv] = await db.insert(conversations).values({ projectId: proj.id, sessionId: session_id, userId: user_id }).returning();
+  async ({ project, query, user_id, session_id, question_date, memory_types, top_k, include_relations }) => {
+    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"}]
+`;
+        line += `   ${r.content}
+`;
+        if (r.event_date) {
+          line += `   Event: ${new Date(r.event_date).toISOString().split("T")[0]}
+`;
+        }
+        return line;
+      }).join("\n");
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
     }
-    await db.insert(messages).values({ conversationId: conv.id, role, content });
-    await db.update(conversations).set({ messageCount: sql2`${conversations.messageCount} + 1`, updatedAt: /* @__PURE__ */ new Date() }).where(eq3(conversations.id, conv.id));
-    return { content: [{ type: "text", text: `Message added (session: ${session_id}).` }] };
   }
 );
 server.tool(
-  "get_conversation",
-  "Retrieve conversation history for a session.",
+  "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"),
-    limit: z.number().optional().default(50)
+    user_id: z.string().optional().describe("User identifier"),
+    messages: z.array(z.object({
+      role: z.string(),
+      content: z.string(),
+      timestamp: z.string()
+    })).describe("Array of conversation messages with timestamps")
+  },
+  async ({ project, session_id, user_id, messages }) => {
+    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().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 }) => {
+    try {
+      const results = await whisper.oracleSearch({
+        project,
+        query,
+        mode,
+        max_results,
+        max_steps
+      });
+      if (mode === "research" && results.answer) {
+        let text = `Answer: ${results.answer}
+
+Reasoning Steps:
+`;
+        if (results.steps) {
+          results.steps.forEach((step, i) => {
+            text += `${i + 1}. Query: ${step.query}
+   Reasoning: ${step.reasoning}
+   Results: ${step.results?.length || 0} items
+`;
+          });
+        }
+        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 }] };
+      }
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "autosubscribe_dependencies",
+  "Automatically index a project's dependencies (package.json, requirements.txt, etc.). Resolves docs URLs and indexes documentation.",
+  {
+    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"),
+    local_path: z.string().optional().describe("For local: path to dependency file"),
+    dependency_file: z.enum(["package.json", "requirements.txt", "Cargo.toml", "go.mod", "Gemfile"]).optional(),
+    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 }) => {
+    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
+- 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().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 }) => {
+    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.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().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 }) => {
+    try {
+      const result = await whisper.consolidateMemories({
+        project,
+        similarity_threshold,
+        dry_run
+      });
+      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 {
+        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}` }] };
+    }
+  }
+);
+server.tool(
+  "get_cost_summary",
+  "Get cost tracking summary showing spending by model and task. Includes savings vs always-Opus.",
+  {
+    project: z.string().optional().describe("Project name or slug (optional for org-wide)"),
+    days: z.number().optional().default(30).describe("Time period in days")
   },
-  async ({ project, session_id, limit }) => {
-    const proj = await resolveProject(project);
-    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
-    const [conv] = await db.select().from(conversations).where(and2(eq3(conversations.projectId, proj.id), eq3(conversations.sessionId, session_id))).limit(1);
-    if (!conv) return { content: [{ type: "text", text: "No conversation found for this session." }] };
-    const msgs = await db.select().from(messages).where(eq3(messages.conversationId, conv.id)).orderBy(messages.createdAt).limit(limit);
-    const text2 = msgs.map((m) => `[${m.role}]: ${m.content}`).join("\n\n");
-    return { content: [{ type: "text", text: text2 || "No messages yet." }] };
+  async ({ project, 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.actual_cost?.toFixed(2) || "0.00"}
+`;
+      text += `Total Requests: ${summary.total_requests || 0}
+
+`;
+      text += `Savings vs Always-Opus:
+`;
+      text += `- Actual: $${savings.actual_cost?.toFixed(2) || "0.00"}
+`;
+      text += `- Opus-only: $${savings.opus_cost?.toFixed(2) || "0.00"}
+`;
+      text += `- Saved: $${savings.savings?.toFixed(2) || "0.00"} (${savings.savings_percent?.toFixed(1) || "0"}%)
+`;
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
   }
 );
 async function main() {
@@ -1645,4 +1057,3 @@ async function main() {
   console.error("Whisper Context MCP server running on stdio");
 }
 main().catch(console.error);
-//# sourceMappingURL=server.js.map