@usewhisper/sdk 3.4.0 → 3.6.0

package/index.mjs

@@ -379,368 +379,83 @@ var RuntimeClient = class {
   }
 };
 
-// ../src/sdk/whisper-agent.ts
-var DEPRECATION_WARNINGS = /* @__PURE__ */ new Set();
-function warnDeprecatedOnce(key, message) {
-  if (DEPRECATION_WARNINGS.has(key)) return;
-  DEPRECATION_WARNINGS.add(key);
-  if (typeof console !== "undefined" && typeof console.warn === "function") {
-    console.warn(message);
+// ../src/sdk/core/cache.ts
+var SearchResponseCache = class {
+  ttlMs;
+  capacity;
+  byKey = /* @__PURE__ */ new Map();
+  scopeIndex = /* @__PURE__ */ new Map();
+  constructor(ttlMs = 7e3, capacity = 500) {
+    this.ttlMs = Math.max(1e3, ttlMs);
+    this.capacity = Math.max(10, capacity);
   }
-}
-var Whisper = class {
-  client;
-  options;
-  sessionId;
-  userId;
-  constructor(options) {
-    if (!options.apiKey) {
-      throw new Error("API key is required");
-    }
-    const clientConfig = {
-      apiKey: options.apiKey,
-      baseUrl: options.baseUrl,
-      project: options.project || "default"
-    };
-    if (options.timeoutMs) clientConfig.timeoutMs = options.timeoutMs;
-    if (options.retry) clientConfig.retry = options.retry;
-    this.client = new WhisperContext(clientConfig);
-    warnDeprecatedOnce(
-      "whisper_agent_wrapper",
-      "[Whisper SDK] Whisper wrapper is supported for v2 compatibility. Prefer WhisperClient for new integrations."
-    );
-    const finalRetry = options.retry || { maxAttempts: 3, baseDelayMs: 250, maxDelayMs: 2e3 };
-    this.options = {
-      apiKey: options.apiKey,
-      baseUrl: options.baseUrl || "https://context.usewhisper.dev",
-      project: options.project || "default",
-      timeoutMs: options.timeoutMs || 15e3,
-      retry: finalRetry,
-      contextLimit: options.contextLimit ?? 10,
-      memoryTypes: options.memoryTypes ?? ["factual", "preference", "event", "goal", "relationship", "opinion", "instruction"],
-      contextPrefix: options.contextPrefix ?? "Relevant context:",
-      autoExtract: options.autoExtract ?? true,
-      autoExtractMinConfidence: options.autoExtractMinConfidence ?? 0.65,
-      maxMemoriesPerCapture: options.maxMemoriesPerCapture ?? 5
-    };
+  makeScopeKey(project, userId, sessionId) {
+    return `${project}:${userId || "_"}:${sessionId || "_"}`;
   }
-  /**
-   * Set session ID for conversation tracking
-   */
-  session(sessionId) {
-    this.sessionId = sessionId;
-    return this;
+  makeKey(input) {
+    const normalized = {
+      project: input.project,
+      userId: input.userId || "",
+      sessionId: input.sessionId || "",
+      query: normalizeQuery(input.query),
+      topK: input.topK,
+      profile: input.profile,
+      includePending: input.includePending
+    };
+    return `search:${stableHash(JSON.stringify(normalized))}`;
   }
-  /**
-   * Set user ID for user-specific memories
-   */
-  user(userId) {
-    this.userId = userId;
-    return this;
+  get(key) {
+    const found = this.byKey.get(key);
+    if (!found) return null;
+    if (found.expiresAt <= Date.now()) {
+      this.deleteByKey(key);
+      return null;
+    }
+    found.touchedAt = Date.now();
+    return found.value;
   }
-  /**
-   * Get relevant context BEFORE your LLM call
-   * 
-   * @param query - What you want to know / user question
-   * @returns Context string and raw results
-   * 
-   * @example
-   * ```typescript
-   * const { context, results, count } = await whisper.getContext(
-   *   "What are user's preferences?",
-   *   { userId: "user-123" }
-   * );
-   * 
-   * // Results: [
-   * //   { content: "User prefers dark mode", type: "preference", score: 0.95 },
-   * //   { content: "Allergic to nuts", type: "factual", score: 0.89 }
-   * // ]
-   * ```
-   */
-  async getContext(query, options) {
-    const result = await this.client.query({
-      project: options?.project ?? this.options.project,
-      query,
-      top_k: options?.limit ?? this.options.contextLimit,
-      include_memories: true,
-      user_id: options?.userId ?? this.userId,
-      session_id: options?.sessionId ?? this.sessionId
+  set(key, scopeKey, value) {
+    this.byKey.set(key, {
+      value,
+      scopeKey,
+      touchedAt: Date.now(),
+      expiresAt: Date.now() + this.ttlMs
     });
-    const context = result.results.map((r, i) => `[${i + 1}] ${r.content}`).join("\n");
-    return {
-      context: context ? `${this.options.contextPrefix}
-${context}` : "",
-      results: result.results,
-      count: result.meta.total
-    };
+    if (!this.scopeIndex.has(scopeKey)) {
+      this.scopeIndex.set(scopeKey, /* @__PURE__ */ new Set());
+    }
+    this.scopeIndex.get(scopeKey).add(key);
+    this.evictIfNeeded();
   }
-  /**
-   * Remember what happened AFTER your LLM response
-   * 
-   * Fire-and-forget - doesn't block your response
-   * 
-   * @param content - What your LLM responded with
-   * @returns Promise that resolves when stored (or fails silently)
-   * 
-   * @example
-   * ```typescript
-   * const llmResponse = "I've set your theme to dark mode and removed nuts from recommendations.";
-   * 
-   * await whisper.remember(llmResponse, { userId: "user-123" });
-   * // → Auto-extracts: "theme set to dark mode", "nut allergy"
-   * // → Stored as preferences
-   * ```
-   */
-  async remember(content, options) {
-    if (!content || content.length < 5) {
-      return { success: false };
+  invalidateScope(scopeKey) {
+    const keys = this.scopeIndex.get(scopeKey);
+    if (!keys || keys.size === 0) {
+      return 0;
     }
-    try {
-      if (this.options.autoExtract) {
-        const extraction = await this.client.extractMemories({
-          project: options?.project ?? this.options.project,
-          message: content,
-          user_id: options?.userId ?? this.userId,
-          session_id: options?.sessionId ?? this.sessionId,
-          enable_pattern: true,
-          enable_inference: true,
-          min_confidence: this.options.autoExtractMinConfidence
-        });
-        const extractedMemories = (extraction.all || []).filter((m) => (m.confidence || 0) >= this.options.autoExtractMinConfidence).slice(0, this.options.maxMemoriesPerCapture);
-        if (extractedMemories.length > 0) {
-          const bulk = await this.client.addMemoriesBulk({
-            project: options?.project ?? this.options.project,
-            write_mode: "async",
-            memories: extractedMemories.map((m) => ({
-              content: m.content,
-              memory_type: m.memoryType,
-              user_id: options?.userId ?? this.userId,
-              session_id: options?.sessionId ?? this.sessionId,
-              importance: Math.max(0.5, Math.min(1, m.confidence || 0.7)),
-              confidence: m.confidence || 0.7,
-              entity_mentions: m.entityMentions || [],
-              event_date: m.eventDate || void 0,
-              metadata: {
-                extracted: true,
-                extraction_method: extraction.extractionMethod,
-                extraction_reasoning: m.reasoning,
-                inferred: Boolean(m.inferred)
-              }
-            }))
-          });
-          const memoryIds = this.extractMemoryIdsFromBulkResponse(bulk);
-          return {
-            success: true,
-            memoryId: memoryIds[0],
-            memoryIds: memoryIds.length > 0 ? memoryIds : void 0,
-            extracted: extractedMemories.length
-          };
-        }
-      }
-      const result = await this.client.addMemory({
-        project: options?.project ?? this.options.project,
-        content,
-        user_id: options?.userId ?? this.userId,
-        session_id: options?.sessionId ?? this.sessionId
-      });
-      return {
-        success: true,
-        memoryId: result?.id
-      };
-    } catch (error) {
-      console.error("[Whisper] Remember failed:", error);
-      return { success: false };
+    const toDelete = Array.from(keys);
+    for (const key of toDelete) {
+      this.deleteByKey(key);
     }
+    this.scopeIndex.delete(scopeKey);
+    return toDelete.length;
   }
-  /**
-   * Alias for remember() - same thing
-   */
-  async capture(content, options) {
-    return this.remember(content, options);
+  evictIfNeeded() {
+    if (this.byKey.size <= this.capacity) return;
+    const ordered = Array.from(this.byKey.entries()).sort((a, b) => a[1].touchedAt - b[1].touchedAt);
+    const removeCount = this.byKey.size - this.capacity;
+    for (let i = 0; i < removeCount; i += 1) {
+      this.deleteByKey(ordered[i][0]);
+    }
   }
-  /**
-   * Capture from multiple messages (e.g., full conversation)
-   */
-  async captureSession(messages, options) {
-    try {
-      const result = await this.client.ingestSession({
-        project: options?.project ?? this.options.project,
-        session_id: options?.sessionId ?? this.sessionId ?? "default",
-        user_id: options?.userId ?? this.userId,
-        messages: messages.filter((m) => m.role !== "system").map((m) => ({
-          role: m.role,
-          content: m.content,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }))
-      });
-      return {
-        success: true,
-        extracted: result?.memories_created ?? 0
-      };
-    } catch (error) {
-      const fallback = await this.fallbackCaptureViaAddMemory(messages, options);
-      if (fallback.success) {
-        return fallback;
-      }
-      console.error("[Whisper] Session capture failed:", error);
-      return { success: false, extracted: 0 };
-    }
-  }
-  /**
-   * Run a full agent turn with automatic memory read (before) + write (after).
-   */
-  async runTurn(params) {
-    const contextResult = await this.getContext(params.userMessage, {
-      userId: params.userId,
-      sessionId: params.sessionId,
-      project: params.project,
-      limit: params.limit
-    });
-    const prompt = contextResult.context ? `${contextResult.context}
-
-User: ${params.userMessage}` : params.userMessage;
-    const response = await params.generate(prompt);
-    const captureResult = await this.captureSession(
-      [
-        { role: "user", content: params.userMessage },
-        { role: "assistant", content: response }
-      ],
-      {
-        userId: params.userId,
-        sessionId: params.sessionId,
-        project: params.project
-      }
-    );
-    return {
-      response,
-      context: contextResult.context,
-      count: contextResult.count,
-      extracted: captureResult.extracted
-    };
-  }
-  /**
-   * Direct access to WhisperContext for advanced usage
-   */
-  raw() {
-    return this.client;
-  }
-  extractMemoryIdsFromBulkResponse(bulkResponse) {
-    const ids = [];
-    if (Array.isArray(bulkResponse?.memories)) {
-      for (const memory of bulkResponse.memories) {
-        if (memory?.id) ids.push(memory.id);
-      }
-    }
-    if (bulkResponse?.memory?.id) {
-      ids.push(bulkResponse.memory.id);
-    }
-    if (bulkResponse?.id) {
-      ids.push(bulkResponse.id);
-    }
-    return Array.from(new Set(ids));
-  }
-  async fallbackCaptureViaAddMemory(messages, options) {
-    const userMessages = messages.filter((m) => m.role === "user").map((m) => (m.content || "").trim()).filter((content) => content.length >= 5).slice(-2);
-    if (userMessages.length === 0) {
-      return { success: false, extracted: 0 };
-    }
-    let extracted = 0;
-    for (const content of userMessages) {
-      try {
-        await this.client.addMemory({
-          project: options?.project ?? this.options.project,
-          content,
-          memory_type: "factual",
-          user_id: options?.userId ?? this.userId,
-          session_id: options?.sessionId ?? this.sessionId,
-          allow_legacy_fallback: true
-        });
-        extracted += 1;
-      } catch {
-      }
-    }
-    return { success: extracted > 0, extracted };
-  }
-};
-var whisper_agent_default = Whisper;
-
-// ../src/sdk/core/cache.ts
-var SearchResponseCache = class {
-  ttlMs;
-  capacity;
-  byKey = /* @__PURE__ */ new Map();
-  scopeIndex = /* @__PURE__ */ new Map();
-  constructor(ttlMs = 7e3, capacity = 500) {
-    this.ttlMs = Math.max(1e3, ttlMs);
-    this.capacity = Math.max(10, capacity);
-  }
-  makeScopeKey(project, userId, sessionId) {
-    return `${project}:${userId || "_"}:${sessionId || "_"}`;
-  }
-  makeKey(input) {
-    const normalized = {
-      project: input.project,
-      userId: input.userId || "",
-      sessionId: input.sessionId || "",
-      query: normalizeQuery(input.query),
-      topK: input.topK,
-      profile: input.profile,
-      includePending: input.includePending
-    };
-    return `search:${stableHash(JSON.stringify(normalized))}`;
-  }
-  get(key) {
-    const found = this.byKey.get(key);
-    if (!found) return null;
-    if (found.expiresAt <= Date.now()) {
-      this.deleteByKey(key);
-      return null;
-    }
-    found.touchedAt = Date.now();
-    return found.value;
-  }
-  set(key, scopeKey, value) {
-    this.byKey.set(key, {
-      value,
-      scopeKey,
-      touchedAt: Date.now(),
-      expiresAt: Date.now() + this.ttlMs
-    });
-    if (!this.scopeIndex.has(scopeKey)) {
-      this.scopeIndex.set(scopeKey, /* @__PURE__ */ new Set());
-    }
-    this.scopeIndex.get(scopeKey).add(key);
-    this.evictIfNeeded();
-  }
-  invalidateScope(scopeKey) {
-    const keys = this.scopeIndex.get(scopeKey);
-    if (!keys || keys.size === 0) {
-      return 0;
-    }
-    const toDelete = Array.from(keys);
-    for (const key of toDelete) {
-      this.deleteByKey(key);
-    }
-    this.scopeIndex.delete(scopeKey);
-    return toDelete.length;
-  }
-  evictIfNeeded() {
-    if (this.byKey.size <= this.capacity) return;
-    const ordered = Array.from(this.byKey.entries()).sort((a, b) => a[1].touchedAt - b[1].touchedAt);
-    const removeCount = this.byKey.size - this.capacity;
-    for (let i = 0; i < removeCount; i += 1) {
-      this.deleteByKey(ordered[i][0]);
-    }
-  }
-  deleteByKey(key) {
-    const found = this.byKey.get(key);
-    if (!found) return;
-    this.byKey.delete(key);
-    const scopeKeys = this.scopeIndex.get(found.scopeKey);
-    if (!scopeKeys) return;
-    scopeKeys.delete(key);
-    if (scopeKeys.size === 0) {
-      this.scopeIndex.delete(found.scopeKey);
+  deleteByKey(key) {
+    const found = this.byKey.get(key);
+    if (!found) return;
+    this.byKey.delete(key);
+    const scopeKeys = this.scopeIndex.get(found.scopeKey);
+    if (!scopeKeys) return;
+    scopeKeys.delete(key);
+    if (scopeKeys.size === 0) {
+      this.scopeIndex.delete(found.scopeKey);
     }
   }
 };
@@ -1550,204 +1265,1252 @@ var AnalyticsModule = class {
   }
 };
 
-// ../src/sdk/whisper.ts
-var WhisperClient = class _WhisperClient {
-  constructor(config) {
-    this.config = config;
-    this.diagnosticsStore = new DiagnosticsStore(config.telemetry?.maxEntries || 1e3);
-    this.runtimeClient = new RuntimeClient(
-      {
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-        compatMode: config.compatMode || "fallback",
-        timeouts: config.timeouts,
-        retryPolicy: config.retryPolicy,
-        fetchImpl: config.fetch
+// ../src/sdk/agent-runtime.ts
+function detectBrowserStorage() {
+  const maybeStorage = globalThis.localStorage;
+  if (!maybeStorage || typeof maybeStorage !== "object") return null;
+  const candidate = maybeStorage;
+  if (typeof candidate.getItem !== "function" || typeof candidate.setItem !== "function") {
+    return null;
+  }
+  return {
+    getItem: candidate.getItem,
+    setItem: candidate.setItem
+  };
+}
+function createBindingStore(filePath) {
+  const storage = detectBrowserStorage();
+  if (storage) {
+    const key = "whisper_agent_runtime_bindings";
+    return {
+      async load() {
+        const raw = storage.getItem(key);
+        if (!raw) return {};
+        try {
+          const parsed = JSON.parse(raw);
+          return parsed && typeof parsed === "object" ? parsed : {};
+        } catch {
+          return {};
+        }
       },
-      this.diagnosticsStore
-    );
-    this.searchCache = new SearchResponseCache(
-      config.cache?.ttlMs ?? 7e3,
-      config.cache?.capacity ?? 500
+      async save(bindings) {
+        storage.setItem(key, JSON.stringify(bindings));
+      }
+    };
+  }
+  return {
+    async load() {
+      if (typeof process === "undefined") return {};
+      const fs = await import("fs/promises");
+      const path = filePath || `${process.env.USERPROFILE || process.env.HOME || "."}/.whisper/sdk/agent-bindings.json`;
+      try {
+        const raw = await fs.readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+      } catch {
+        return {};
+      }
+    },
+    async save(bindings) {
+      if (typeof process === "undefined") return;
+      const fs = await import("fs/promises");
+      const pathMod = await import("path");
+      const path = filePath || `${process.env.USERPROFILE || process.env.HOME || "."}/.whisper/sdk/agent-bindings.json`;
+      await fs.mkdir(pathMod.dirname(path), { recursive: true });
+      await fs.writeFile(path, JSON.stringify(bindings), "utf8");
+    }
+  };
+}
+function normalizeWorkspacePath(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  return trimmed.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function pathBase(value) {
+  const normalized = value.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  return parts[parts.length - 1] || normalized;
+}
+function defaultSalience(kind, success) {
+  if (kind === "decision" || kind === "constraint" || kind === "failure") return "high";
+  if (kind === "outcome" || kind === "task_update") return "medium";
+  if (kind === "tool_result" && success === false) return "high";
+  return "low";
+}
+function toMemoryType(kind) {
+  if (kind === "decision" || kind === "constraint") return "instruction";
+  return "event";
+}
+function summarizeLowSalience(events) {
+  const lines = events.slice(-10).map((event) => {
+    const fileSuffix = event.filePaths?.length ? ` [files: ${event.filePaths.join(", ")}]` : "";
+    const toolSuffix = event.toolName ? ` [tool: ${event.toolName}]` : "";
+    return `- ${event.kind}: ${event.summary}${fileSuffix}${toolSuffix}`;
+  });
+  return `Recent low-salience work:
+${lines.join("\n")}`;
+}
+function compactWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function withTimeout(promise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("timeout"));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timeout);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      }
     );
-    const queueStore = config.queue?.persistence === "storage" ? createStorageQueueStore() : config.queue?.persistence === "file" && config.queue.filePath ? createFileQueueStore(config.queue.filePath) : new InMemoryQueueStore();
-    this.writeQueue = new WriteQueue({
-      store: queueStore,
-      maxBatchSize: config.queue?.maxBatchSize ?? 50,
-      flushIntervalMs: config.queue?.flushIntervalMs ?? 100,
-      maxAttempts: config.queue?.maxAttempts ?? 2,
-      flushHandler: async (items) => {
-        if (items.length === 0) return;
-        const project = items[0].project;
-        const memories = items.map((item) => ({
-          ...item.payload,
-          user_id: item.payload.user_id ?? item.userId,
-          session_id: item.payload.session_id ?? item.sessionId,
-          metadata: {
-            ...item.payload.metadata || {},
-            event_id: item.eventId,
-            queued_at: item.createdAt
-          }
-        }));
-        try {
-          await this.runtimeClient.request({
-            endpoint: "/v1/memory/bulk",
-            method: "POST",
-            operation: "bulk",
-            body: {
-              project,
-              write_mode: "async",
-              memories
-            }
-          });
-        } catch (error) {
-          if (this.runtimeClient.getCompatMode() !== "fallback" || !(error instanceof RuntimeClientError) || error.status !== 404) {
-            throw error;
-          }
-          await Promise.all(
-            memories.map(async (memory) => {
-              try {
-                await this.runtimeClient.request({
-                  endpoint: "/v1/memory",
-                  method: "POST",
-                  operation: "writeAck",
-                  body: {
-                    project,
-                    ...memory,
-                    write_mode: "sync"
-                  }
-                });
-              } catch (fallbackError) {
-                if (this.runtimeClient.getCompatMode() !== "fallback" || !(fallbackError instanceof RuntimeClientError) || fallbackError.status !== 404) {
-                  throw fallbackError;
-                }
-                await this.runtimeClient.request({
-                  endpoint: "/v1/memories",
-                  method: "POST",
-                  operation: "writeAck",
-                  body: {
-                    project,
+  });
+}
+function extractTimestamp(metadata) {
+  const candidates = [
+    metadata?.updatedAt,
+    metadata?.createdAt,
+    metadata?.timestamp,
+    metadata?.event_date,
+    metadata?.eventDate
+  ];
+  for (const value of candidates) {
+    if (typeof value === "string") {
+      const parsed = Date.parse(value);
+      if (!Number.isNaN(parsed)) return parsed;
+    }
+  }
+  return 0;
+}
+function salienceBoost(metadata) {
+  const value = metadata?.salience;
+  if (value === "high") return 0.12;
+  if (value === "medium") return 0.06;
+  return 0;
+}
+var WhisperAgentRuntime = class {
+  constructor(args) {
+    this.args = args;
+    this.bindingStore = createBindingStore(args.options.bindingStorePath);
+    this.topK = args.options.topK ?? 6;
+    this.maxTokens = args.options.maxTokens ?? 4e3;
+    this.targetRetrievalMs = args.options.targetRetrievalMs ?? 2500;
+    this.hardRetrievalTimeoutMs = args.options.hardRetrievalTimeoutMs ?? 4e3;
+    this.recentWorkLimit = args.options.recentWorkLimit ?? 40;
+    this.baseContext = args.baseContext;
+    this.clientName = args.baseContext.clientName || "whisper-agent-runtime";
+  }
+  bindingStore;
+  topK;
+  maxTokens;
+  targetRetrievalMs;
+  hardRetrievalTimeoutMs;
+  recentWorkLimit;
+  baseContext;
+  clientName;
+  bindings = null;
+  touchedFiles = [];
+  recentWork = [];
+  bufferedLowSalience = [];
+  lastPreparedTurn = null;
+  mergedCount = 0;
+  droppedCount = 0;
+  lastScope = {};
+  async getBindings() {
+    if (!this.bindings) {
+      this.bindings = await this.bindingStore.load();
+    }
+    return this.bindings;
+  }
+  pushTouchedFiles(paths) {
+    if (!paths || paths.length === 0) return;
+    for (const path of paths) {
+      if (!path) continue;
+      this.touchedFiles = [...this.touchedFiles.filter((entry) => entry !== path), path].slice(-20);
+    }
+  }
+  pushWorkEvent(event) {
+    this.recentWork = [...this.recentWork, event].slice(-this.recentWorkLimit);
+  }
+  makeTaskFrameQuery(input) {
+    const task = compactWhitespace(input.taskSummary || "");
+    const salient = this.recentWork.filter((event) => event.salience === "high").slice(-3).map((event) => `${event.kind}: ${event.summary}`);
+    const files = [...input.touchedFiles || [], ...this.touchedFiles].slice(-3).map((file) => pathBase(file));
+    const parts = [
+      task ? `task ${task}` : "",
+      salient.length > 0 ? `recent ${salient.join(" ; ")}` : "",
+      files.length > 0 ? `files ${files.join(" ")}` : "",
+      input.toolContext ? `tool context ${compactWhitespace(input.toolContext)}` : ""
+    ].filter(Boolean);
+    if (parts.length === 0) return null;
+    return parts.join(" | ");
+  }
+  async resolveScope(overrides) {
+    const merged = {
+      ...this.baseContext,
+      ...overrides
+    };
+    const normalizedWorkspace = normalizeWorkspacePath(merged.workspacePath);
+    const bindings = await this.getBindings();
+    const workspaceProject = normalizedWorkspace ? bindings[normalizedWorkspace] : void 0;
+    const configuredProject = merged.project;
+    let projectRef = configuredProject;
+    let projectSource = overrides?.project ? "explicit" : "generated";
+    let warning;
+    if (workspaceProject) {
+      projectRef = workspaceProject;
+      projectSource = "workspace";
+      if (configuredProject && workspaceProject !== configuredProject) {
+        warning = `workspace mapping '${workspaceProject}' overrides configured project '${configuredProject}'`;
+      }
+    } else if (configuredProject) {
+      projectRef = configuredProject;
+      projectSource = overrides?.project ? "explicit" : "config";
+    }
+    const project = (await this.args.adapter.resolveProject(projectRef)).id;
+    if (normalizedWorkspace) {
+      bindings[normalizedWorkspace] = project;
+      await this.bindingStore.save(bindings);
+    }
+    const scope = {
+      ...merged,
+      project,
+      userId: merged.userId || `${this.clientName}-user`,
+      sessionId: merged.sessionId || `sess_${stableHash(`${this.clientName}_${normalizedWorkspace || "default"}`)}`
+    };
+    this.lastScope = {
+      project: scope.project,
+      userId: scope.userId,
+      sessionId: scope.sessionId,
+      source: projectSource,
+      warning
+    };
+    return { scope, projectSource, warning };
+  }
+  async runBranch(name, task) {
+    const startedAt = Date.now();
+    try {
+      const value = await withTimeout(task(), this.hardRetrievalTimeoutMs);
+      return {
+        name,
+        status: "ok",
+        durationMs: Date.now() - startedAt,
+        value
+      };
+    } catch (error) {
+      const durationMs = Date.now() - startedAt;
+      const reason = error instanceof Error ? error.message : String(error);
+      return {
+        name,
+        status: reason === "timeout" ? "timeout" : "error",
+        durationMs,
+        reason
+      };
+    }
+  }
+  contextItems(result, sourceQuery) {
+    return (result.results || []).map((item) => ({
+      id: item.id,
+      content: item.content,
+      type: "project",
+      score: item.score ?? 0,
+      sourceQuery,
+      metadata: item.metadata || {}
+    }));
+  }
+  memoryItems(result, sourceQuery) {
+    return (result.results || []).map((item, index) => ({
+      id: item.memory?.id || item.chunk?.id || `${sourceQuery}_memory_${index}`,
+      content: item.chunk?.content || item.memory?.content || "",
+      type: "memory",
+      score: item.similarity ?? 0,
+      sourceQuery,
+      metadata: {
+        ...item.chunk?.metadata || {},
+        ...item.memory?.temporal || {},
+        confidence: item.memory?.confidence
+      }
+    })).filter((item) => item.content);
+  }
+  rerank(items) {
+    const deduped = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const key = `${item.id}:${item.content.toLowerCase()}`;
+      const recency = extractTimestamp(item.metadata) > 0 ? 0.04 : 0;
+      const queryBonus = item.sourceQuery === "primary" ? 0.08 : item.sourceQuery === "task_frame" ? 0.04 : 0.03;
+      const next = {
+        ...item,
+        score: item.score + queryBonus + salienceBoost(item.metadata) + recency
+      };
+      const existing = deduped.get(key);
+      if (!existing || next.score > existing.score) {
+        deduped.set(key, next);
+      }
+    }
+    return [...deduped.values()].sort((left, right) => right.score - left.score);
+  }
+  buildContext(items) {
+    const maxChars = this.maxTokens * 4;
+    const lines = [];
+    let used = 0;
+    for (const item of items) {
+      const label = item.type === "memory" ? "memory" : "context";
+      const content = compactWhitespace(item.content);
+      if (!content) continue;
+      const line = `[${label}] ${content}`;
+      if (used + line.length > maxChars) break;
+      lines.push(line);
+      used += line.length;
+    }
+    if (lines.length === 0) return "";
+    return `Relevant context:
+${lines.join("\n")}`;
+  }
+  async bootstrap(context = {}) {
+    const { scope, warning } = await this.resolveScope(context);
+    const warnings = warning ? [warning] : [];
+    const startedAt = Date.now();
+    const branches = await Promise.all([
+      this.runBranch("session_recent", () => this.args.adapter.getSessionMemories({
+        project: scope.project,
+        session_id: scope.sessionId,
+        include_pending: true,
+        limit: 12
+      })),
+      this.runBranch("user_profile", () => scope.userId ? this.args.adapter.getUserProfile({
+        project: scope.project,
+        user_id: scope.userId,
+        include_pending: true,
+        memory_types: "preference,instruction,goal"
+      }) : Promise.resolve({ user_id: scope.userId, memories: [], count: 0 })),
+      this.runBranch("project_rules", () => this.args.adapter.query({
+        project: scope.project,
+        query: "project rules instructions constraints conventions open threads",
+        top_k: this.topK,
+        include_memories: false,
+        user_id: scope.userId,
+        session_id: scope.sessionId,
+        max_tokens: this.maxTokens,
+        compress: true,
+        compression_strategy: "adaptive"
+      }))
+    ]);
+    const items = [];
+    const branchStatus = {};
+    for (const branch of branches) {
+      branchStatus[branch.name] = branch.status;
+      if (branch.status !== "ok") {
+        if (branch.reason) warnings.push(`${branch.name}:${branch.reason}`);
+        continue;
+      }
+      if (branch.name === "project_rules") {
+        items.push(...this.contextItems(branch.value, "bootstrap"));
+        continue;
+      }
+      const records = branch.value.memories || [];
+      items.push(...records.map((memory, index) => ({
+        id: String(memory.id || `${branch.name}_${index}`),
+        content: String(memory.content || ""),
+        type: "memory",
+        score: 0.4,
+        sourceQuery: "bootstrap",
+        metadata: memory
+      })).filter((item) => item.content));
+    }
+    const ranked = this.rerank(items).slice(0, this.topK * 2);
+    const prepared = {
+      scope,
+      retrieval: {
+        primaryQuery: "bootstrap",
+        taskFrameQuery: null,
+        warnings,
+        degraded: warnings.length > 0,
+        degradedReason: warnings.length > 0 ? "partial_bootstrap" : void 0,
+        durationMs: Date.now() - startedAt,
+        targetBudgetMs: this.targetRetrievalMs,
+        hardTimeoutMs: this.hardRetrievalTimeoutMs,
+        branchStatus
+      },
+      context: this.buildContext(ranked),
+      items: ranked
+    };
+    this.lastPreparedTurn = prepared.retrieval;
+    return prepared;
+  }
+  async beforeTurn(input, context = {}) {
+    this.pushTouchedFiles(input.touchedFiles);
+    const { scope, warning } = await this.resolveScope(context);
+    const primaryQuery = compactWhitespace(input.userMessage);
+    const taskFrameQuery = this.makeTaskFrameQuery(input);
+    const warnings = warning ? [warning] : [];
+    const startedAt = Date.now();
+    const branches = await Promise.all([
+      this.runBranch("context_primary", () => this.args.adapter.query({
+        project: scope.project,
+        query: primaryQuery,
+        top_k: this.topK,
+        include_memories: false,
+        user_id: scope.userId,
+        session_id: scope.sessionId,
+        max_tokens: this.maxTokens,
+        compress: true,
+        compression_strategy: "adaptive"
+      })),
+      this.runBranch("memory_primary", () => this.args.adapter.searchMemories({
+        project: scope.project,
+        query: primaryQuery,
+        user_id: scope.userId,
+        session_id: scope.sessionId,
+        top_k: this.topK,
+        include_pending: true,
+        profile: "balanced"
+      })),
+      taskFrameQuery ? this.runBranch("context_task_frame", () => this.args.adapter.query({
+        project: scope.project,
+        query: taskFrameQuery,
+        top_k: this.topK,
+        include_memories: false,
+        user_id: scope.userId,
+        session_id: scope.sessionId,
+        max_tokens: this.maxTokens,
+        compress: true,
+        compression_strategy: "adaptive"
+      })) : Promise.resolve({
+        name: "context_task_frame",
+        status: "skipped",
+        durationMs: 0
+      }),
+      taskFrameQuery ? this.runBranch("memory_task_frame", () => this.args.adapter.searchMemories({
+        project: scope.project,
+        query: taskFrameQuery,
+        user_id: scope.userId,
+        session_id: scope.sessionId,
+        top_k: this.topK,
+        include_pending: true,
+        profile: "balanced"
+      })) : Promise.resolve({
+        name: "memory_task_frame",
+        status: "skipped",
+        durationMs: 0
+      })
+    ]);
+    const branchStatus = {};
+    const collected = [];
+    let okCount = 0;
+    for (const branch of branches) {
+      branchStatus[branch.name] = branch.status;
+      if (branch.status !== "ok") {
+        if (branch.status !== "skipped" && branch.reason) warnings.push(`${branch.name}:${branch.reason}`);
+        continue;
+      }
+      okCount += 1;
+      if (branch.name.startsWith("context")) {
+        collected.push(...this.contextItems(
+          branch.value,
+          branch.name.includes("task_frame") ? "task_frame" : "primary"
+        ));
+      } else {
+        collected.push(...this.memoryItems(
+          branch.value,
+          branch.name.includes("task_frame") ? "task_frame" : "primary"
+        ));
+      }
+    }
+    const ranked = this.rerank(collected).slice(0, this.topK * 2);
+    const prepared = {
+      scope,
+      retrieval: {
+        primaryQuery,
+        taskFrameQuery,
+        warnings,
+        degraded: okCount < branches.filter((branch) => branch.status !== "skipped").length,
+        degradedReason: okCount === 0 ? "all_retrieval_failed" : warnings.length > 0 ? "partial_retrieval_failed" : void 0,
+        durationMs: Date.now() - startedAt,
+        targetBudgetMs: this.targetRetrievalMs,
+        hardTimeoutMs: this.hardRetrievalTimeoutMs,
+        branchStatus
+      },
+      context: this.buildContext(ranked),
+      items: ranked
+    };
+    this.lastPreparedTurn = prepared.retrieval;
+    return prepared;
+  }
+  async recordWork(event, context = {}) {
+    const normalized = {
+      ...event,
+      salience: event.salience || defaultSalience(event.kind, event.success),
+      timestamp: event.timestamp || nowIso()
+    };
+    this.pushTouchedFiles(normalized.filePaths);
+    this.pushWorkEvent(normalized);
+    if (normalized.salience === "low") {
+      this.bufferedLowSalience = [...this.bufferedLowSalience, normalized].slice(-20);
+      return { success: true, buffered: true };
+    }
+    const { scope } = await this.resolveScope(context);
+    return this.args.adapter.addMemory({
+      project: scope.project,
+      user_id: scope.userId,
+      session_id: scope.sessionId,
+      content: `${normalized.kind}: ${normalized.summary}${normalized.details ? ` (${normalized.details})` : ""}`,
+      memory_type: toMemoryType(normalized.kind),
+      event_date: normalized.timestamp,
+      write_mode: "async",
+      metadata: {
+        runtime_auto: true,
+        client_name: this.clientName,
+        work_event_kind: normalized.kind,
+        salience: normalized.salience,
+        file_paths: normalized.filePaths || [],
+        tool_name: normalized.toolName,
+        success: normalized.success
+      }
+    });
+  }
+  async afterTurn(input, context = {}) {
+    this.pushTouchedFiles(input.touchedFiles);
+    const { scope } = await this.resolveScope(context);
+    const result = await this.args.adapter.ingestSession({
+      project: scope.project,
+      session_id: scope.sessionId,
+      user_id: scope.userId,
+      messages: [
+        { role: "user", content: input.userMessage, timestamp: nowIso() },
+        { role: "assistant", content: input.assistantMessage, timestamp: nowIso() }
+      ],
+      write_mode: "async"
+    });
+    this.mergedCount += result.memories_invalidated || 0;
+    return {
+      success: Boolean(result.success),
+      sessionIngested: true,
+      memoriesCreated: result.memories_created || 0,
+      relationsCreated: result.relations_created || 0,
+      invalidatedCount: result.memories_invalidated || 0,
+      mergedCount: result.memories_invalidated || 0,
+      droppedCount: 0,
+      warnings: result.errors || []
+    };
+  }
+  async flush(reason = "manual", context = {}) {
+    if (this.bufferedLowSalience.length > 0) {
+      const { scope } = await this.resolveScope(context);
+      const summary = summarizeLowSalience(this.bufferedLowSalience);
+      await this.args.adapter.addMemory({
+        project: scope.project,
+        user_id: scope.userId,
+        session_id: scope.sessionId,
+        content: summary,
+        memory_type: "event",
+        write_mode: "async",
+        metadata: {
+          runtime_auto: true,
+          client_name: this.clientName,
+          flush_reason: reason,
+          salience: "low",
+          summarized_count: this.bufferedLowSalience.length
+        }
+      });
+      this.bufferedLowSalience = [];
+    }
+    await this.args.adapter.flushQueue();
+    return this.status();
+  }
+  status() {
+    return {
+      clientName: this.clientName,
+      scope: this.lastScope,
+      queue: this.args.adapter.queueStatus(),
+      retrieval: this.lastPreparedTurn,
+      counters: {
+        mergedCount: this.mergedCount,
+        droppedCount: this.droppedCount,
+        bufferedLowSalience: this.bufferedLowSalience.length
+      }
+    };
+  }
+};
+
+// ../src/sdk/whisper.ts
+var PROJECT_CACHE_TTL_MS = 3e4;
+function isLikelyProjectId(projectRef) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(projectRef);
+}
+var WhisperClient = class _WhisperClient {
+  constructor(config) {
+    this.config = config;
+    this.diagnosticsStore = new DiagnosticsStore(config.telemetry?.maxEntries || 1e3);
+    this.runtimeClient = new RuntimeClient(
+      {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        compatMode: config.compatMode || "fallback",
+        timeouts: config.timeouts,
+        retryPolicy: config.retryPolicy,
+        fetchImpl: config.fetch
+      },
+      this.diagnosticsStore
+    );
+    this.searchCache = new SearchResponseCache(
+      config.cache?.ttlMs ?? 7e3,
+      config.cache?.capacity ?? 500
+    );
+    const queueStore = this.createQueueStore(config);
+    this.writeQueue = new WriteQueue({
+      store: queueStore,
+      maxBatchSize: config.queue?.maxBatchSize ?? 50,
+      flushIntervalMs: config.queue?.flushIntervalMs ?? 100,
+      maxAttempts: config.queue?.maxAttempts ?? 2,
+      flushHandler: async (items) => {
+        if (items.length === 0) return;
+        const project = items[0].project;
+        const memories = items.map((item) => ({
+          ...item.payload,
+          user_id: item.payload.user_id ?? item.userId,
+          session_id: item.payload.session_id ?? item.sessionId,
+          metadata: {
+            ...item.payload.metadata || {},
+            event_id: item.eventId,
+            queued_at: item.createdAt
+          }
+        }));
+        try {
+          await this.runtimeClient.request({
+            endpoint: "/v1/memory/bulk",
+            method: "POST",
+            operation: "bulk",
+            body: {
+              project,
+              write_mode: "async",
+              memories
+            }
+          });
+        } catch (error) {
+          if (this.runtimeClient.getCompatMode() !== "fallback" || !(error instanceof RuntimeClientError) || error.status !== 404) {
+            throw error;
+          }
+          await Promise.all(
+            memories.map(async (memory) => {
+              try {
+                await this.runtimeClient.request({
+                  endpoint: "/v1/memory",
+                  method: "POST",
+                  operation: "writeAck",
+                  body: {
+                    project,
+                    ...memory,
+                    write_mode: "sync"
+                  }
+                });
+              } catch (fallbackError) {
+                if (this.runtimeClient.getCompatMode() !== "fallback" || !(fallbackError instanceof RuntimeClientError) || fallbackError.status !== 404) {
+                  throw fallbackError;
+                }
+                await this.runtimeClient.request({
+                  endpoint: "/v1/memories",
+                  method: "POST",
+                  operation: "writeAck",
+                  body: {
+                    project,
                     ...memory,
                     memory_type: memory.memory_type === "event" ? "episodic" : memory.memory_type
                   }
                 });
               }
-            })
-          );
+            })
+          );
+        }
+      }
+    });
+    if (config.queue?.enabled !== false) {
+      void this.writeQueue.start();
+    }
+    this.memoryModule = new MemoryModule(
+      this.runtimeClient,
+      this.searchCache,
+      this.writeQueue,
+      {
+        defaultProject: config.project,
+        cacheEnabled: config.cache?.enabled !== false,
+        queueEnabled: config.queue?.enabled !== false
+      }
+    );
+    this.sessionModule = new SessionModule(this.memoryModule, config.project);
+    this.profileModule = new ProfileModule(this.memoryModule);
+    this.analyticsModule = new AnalyticsModule(this.diagnosticsStore, this.writeQueue);
+    this.diagnostics = {
+      getLast: (limit) => this.diagnosticsStore.getLast(limit),
+      subscribe: (fn) => this.diagnosticsStore.subscribe(fn),
+      snapshot: () => this.diagnosticsStore.snapshot()
+    };
+    this.queue = {
+      flush: () => this.writeQueue.flush(),
+      status: () => this.writeQueue.status()
+    };
+    this.memory = {
+      add: (params) => this.memoryModule.add(params),
+      addBulk: (params) => this.memoryModule.addBulk(params),
+      search: (params) => this.memoryModule.search(params),
+      get: (memoryId) => this.memoryModule.get(memoryId),
+      getUserProfile: (params) => this.memoryModule.getUserProfile(params),
+      getSessionMemories: (params) => this.memoryModule.getSessionMemories(params),
+      update: (memoryId, params) => this.memoryModule.update(memoryId, params),
+      delete: (memoryId) => this.memoryModule.delete(memoryId),
+      flag: (params) => this.memoryModule.flag(params)
+    };
+    this.session = {
+      start: (params) => this.sessionModule.start(params),
+      event: (params) => this.sessionModule.event(params),
+      suspend: (params) => this.sessionModule.suspend(params),
+      resume: (params) => this.sessionModule.resume(params),
+      end: (params) => this.sessionModule.end(params)
+    };
+    this.profile = {
+      getUserProfile: (params) => this.profileModule.getUserProfile(params),
+      getSessionMemories: (params) => this.profileModule.getSessionMemories(params)
+    };
+    this.analytics = {
+      diagnosticsSnapshot: () => this.analyticsModule.diagnosticsSnapshot(),
+      queueStatus: () => this.analyticsModule.queueStatus()
+    };
+  }
+  diagnostics;
+  queue;
+  memory;
+  session;
+  profile;
+  analytics;
+  runtimeClient;
+  diagnosticsStore;
+  searchCache;
+  writeQueue;
+  memoryModule;
+  sessionModule;
+  profileModule;
+  analyticsModule;
+  projectRefToId = /* @__PURE__ */ new Map();
+  projectCache = [];
+  projectCacheExpiresAt = 0;
+  static fromEnv(overrides = {}) {
+    const env = typeof process !== "undefined" ? process.env : {};
+    const apiKey = overrides.apiKey || env.WHISPER_API_KEY || env.USEWHISPER_API_KEY || env.API_KEY;
+    if (!apiKey) {
+      throw new Error("Missing API key. Set WHISPER_API_KEY / USEWHISPER_API_KEY / API_KEY.");
+    }
+    return new _WhisperClient({
+      apiKey,
+      baseUrl: overrides.baseUrl || env.WHISPER_BASE_URL || env.API_BASE_URL || "https://context.usewhisper.dev",
+      project: overrides.project || env.WHISPER_PROJECT || env.PROJECT,
+      ...overrides
+    });
+  }
+  createQueueStore(config) {
+    const persistence = config.queue?.persistence || this.defaultQueuePersistence();
+    if (persistence === "storage") {
+      return createStorageQueueStore();
+    }
+    if (persistence === "file") {
+      const filePath = config.queue?.filePath || this.defaultQueueFilePath();
+      if (filePath) {
+        return createFileQueueStore(filePath);
+      }
+    }
+    return new InMemoryQueueStore();
+  }
+  defaultQueuePersistence() {
+    const maybeWindow = globalThis.window;
+    if (maybeWindow && typeof maybeWindow === "object") {
+      const maybeStorage = globalThis.localStorage;
+      return maybeStorage && typeof maybeStorage === "object" ? "storage" : "memory";
+    }
+    return "file";
+  }
+  defaultQueueFilePath() {
+    if (typeof process === "undefined") return void 0;
+    const path = process.env.WHISPER_QUEUE_FILE_PATH;
+    if (path) return path;
+    const home = process.env.USERPROFILE || process.env.HOME;
+    if (!home) return void 0;
+    const normalizedHome = home.replace(/[\\\/]+$/, "");
+    return `${normalizedHome}/.whisper/sdk/queue.json`;
+  }
+  getRequiredProject(project) {
+    const resolved = project || this.config.project;
+    if (!resolved) {
+      throw new RuntimeClientError({
+        code: "MISSING_PROJECT",
+        message: "Project is required",
+        retryable: false
+      });
+    }
+    return resolved;
+  }
+  async refreshProjectCache(force = false) {
+    if (!force && Date.now() < this.projectCacheExpiresAt && this.projectCache.length > 0) {
+      return this.projectCache;
+    }
+    const response = await this.runtimeClient.request({
+      endpoint: "/v1/projects",
+      method: "GET",
+      operation: "get",
+      idempotent: true
+    });
+    this.projectRefToId.clear();
+    this.projectCache = response.data?.projects || [];
+    for (const project of this.projectCache) {
+      this.projectRefToId.set(project.id, project.id);
+      this.projectRefToId.set(project.slug, project.id);
+      this.projectRefToId.set(project.name, project.id);
+    }
+    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+    return this.projectCache;
+  }
+  async fetchResolvedProject(projectRef) {
+    try {
+      const response = await this.runtimeClient.request({
+        endpoint: `/v1/projects/resolve?project=${encodeURIComponent(projectRef)}`,
+        method: "GET",
+        operation: "get",
+        idempotent: true
+      });
+      return response.data?.resolved || null;
+    } catch (error) {
+      if (error instanceof RuntimeClientError && error.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async resolveProject(projectRef) {
+    const resolvedRef = this.getRequiredProject(projectRef);
+    const cachedProjects = await this.refreshProjectCache(false);
+    const cachedProject = cachedProjects.find(
+      (project) => project.id === resolvedRef || project.slug === resolvedRef || project.name === resolvedRef
+    );
+    if (cachedProject) {
+      return cachedProject;
+    }
+    const resolvedProject = await this.fetchResolvedProject(resolvedRef);
+    if (resolvedProject) {
+      this.projectRefToId.set(resolvedProject.id, resolvedProject.id);
+      this.projectRefToId.set(resolvedProject.slug, resolvedProject.id);
+      this.projectRefToId.set(resolvedProject.name, resolvedProject.id);
+      this.projectCache = [
+        ...this.projectCache.filter((project) => project.id !== resolvedProject.id),
+        resolvedProject
+      ];
+      this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+      return resolvedProject;
+    }
+    if (isLikelyProjectId(resolvedRef)) {
+      return {
+        id: resolvedRef,
+        orgId: "",
+        name: resolvedRef,
+        slug: resolvedRef,
+        createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+      };
+    }
+    throw new RuntimeClientError({
+      code: "PROJECT_NOT_FOUND",
+      message: `Project '${resolvedRef}' not found`,
+      retryable: false
+    });
+  }
+  async query(params) {
+    const project = (await this.resolveProject(params.project)).id;
+    const response = await this.runtimeClient.request({
+      endpoint: "/v1/context/query",
+      method: "POST",
+      operation: "search",
+      body: {
+        ...params,
+        project
+      },
+      idempotent: true
+    });
+    return response.data;
+  }
+  async ingestSession(params) {
+    const project = (await this.resolveProject(params.project)).id;
+    const response = await this.runtimeClient.request({
+      endpoint: "/v1/memory/ingest/session",
+      method: "POST",
+      operation: "session",
+      body: {
+        ...params,
+        project
+      }
+    });
+    return response.data;
+  }
+  createAgentRuntime(options = {}) {
+    const baseContext = {
+      workspacePath: options.workspacePath,
+      project: options.project || this.config.project,
+      userId: options.userId,
+      sessionId: options.sessionId,
+      traceId: options.traceId,
+      clientName: options.clientName
+    };
+    return new WhisperAgentRuntime({
+      baseContext,
+      options,
+      adapter: {
+        resolveProject: (project) => this.resolveProject(project),
+        query: (params) => this.query(params),
+        ingestSession: (params) => this.ingestSession(params),
+        getSessionMemories: (params) => this.memory.getSessionMemories(params),
+        getUserProfile: (params) => this.memory.getUserProfile(params),
+        searchMemories: (params) => this.memory.search(params),
+        addMemory: (params) => this.memory.add(params),
+        queueStatus: () => this.queue.status(),
+        flushQueue: () => this.queue.flush()
+      }
+    });
+  }
+  withRunContext(context) {
+    const base = this;
+    return {
+      memory: {
+        add: (params) => base.memory.add({
+          ...params,
+          project: params.project || context.project || base.config.project,
+          user_id: params.user_id || context.userId,
+          session_id: params.session_id || context.sessionId
+        }),
+        search: (params) => base.memory.search({
+          ...params,
+          project: params.project || context.project || base.config.project,
+          user_id: params.user_id || context.userId,
+          session_id: params.session_id || context.sessionId
+        })
+      },
+      session: {
+        event: (params) => base.session.event({
+          ...params,
+          sessionId: params.sessionId || context.sessionId || ""
+        })
+      },
+      queue: base.queue,
+      diagnostics: base.diagnostics
+    };
+  }
+  async shutdown() {
+    await this.writeQueue.stop();
+  }
+};
+var whisper_default = WhisperClient;
+
+// ../src/sdk/whisper-agent.ts
+var DEPRECATION_WARNINGS = /* @__PURE__ */ new Set();
+function warnDeprecatedOnce(key, message) {
+  if (DEPRECATION_WARNINGS.has(key)) return;
+  DEPRECATION_WARNINGS.add(key);
+  if (typeof console !== "undefined" && typeof console.warn === "function") {
+    console.warn(message);
+  }
+}
+var Whisper = class {
+  client;
+  runtimeClient;
+  options;
+  sessionId;
+  userId;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("API key is required");
+    }
+    const clientConfig = {
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl,
+      project: options.project || "default"
+    };
+    if (options.timeoutMs) clientConfig.timeoutMs = options.timeoutMs;
+    if (options.retry) clientConfig.retry = options.retry;
+    this.client = new WhisperContext(clientConfig);
+    this.runtimeClient = new WhisperClient({
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl,
+      project: options.project || "default"
+    });
+    warnDeprecatedOnce(
+      "whisper_agent_wrapper",
+      "[Whisper SDK] Whisper wrapper is supported for v2 compatibility. Prefer WhisperClient for new integrations."
+    );
+    const finalRetry = options.retry || { maxAttempts: 3, baseDelayMs: 250, maxDelayMs: 2e3 };
+    this.options = {
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl || "https://context.usewhisper.dev",
+      project: options.project || "default",
+      timeoutMs: options.timeoutMs || 15e3,
+      retry: finalRetry,
+      contextLimit: options.contextLimit ?? 10,
+      memoryTypes: options.memoryTypes ?? ["factual", "preference", "event", "goal", "relationship", "opinion", "instruction"],
+      contextPrefix: options.contextPrefix ?? "Relevant context:",
+      autoExtract: options.autoExtract ?? true,
+      autoExtractMinConfidence: options.autoExtractMinConfidence ?? 0.65,
+      maxMemoriesPerCapture: options.maxMemoriesPerCapture ?? 5
+    };
+  }
+  /**
+   * Set session ID for conversation tracking
+   */
+  session(sessionId) {
+    this.sessionId = sessionId;
+    return this;
+  }
+  /**
+   * Set user ID for user-specific memories
+   */
+  user(userId) {
+    this.userId = userId;
+    return this;
+  }
+  /**
+   * Get relevant context BEFORE your LLM call
+   * 
+   * @param query - What you want to know / user question
+   * @returns Context string and raw results
+   * 
+   * @example
+   * ```typescript
+   * const { context, results, count } = await whisper.getContext(
+   *   "What are user's preferences?",
+   *   { userId: "user-123" }
+   * );
+   * 
+   * // Results: [
+   * //   { content: "User prefers dark mode", type: "preference", score: 0.95 },
+   * //   { content: "Allergic to nuts", type: "factual", score: 0.89 }
+   * // ]
+   * ```
+   */
+  async getContext(query, options) {
+    const runtime = this.runtimeClient.createAgentRuntime({
+      project: options?.project ?? this.options.project,
+      userId: options?.userId ?? this.userId,
+      sessionId: options?.sessionId ?? this.sessionId,
+      topK: options?.limit ?? this.options.contextLimit,
+      clientName: "whisper-wrapper"
+    });
+    const prepared = await runtime.beforeTurn({
+      userMessage: query
+    });
+    const results = prepared.items.map((item, index) => ({
+      id: item.id || `runtime_${index}`,
+      content: item.content,
+      score: item.score,
+      metadata: item.metadata || {},
+      source: item.type === "memory" ? "memory" : "runtime",
+      document: item.sourceQuery,
+      type: item.type,
+      retrieval_source: item.type === "memory" ? "memory" : "runtime"
+    }));
+    const context = results.map((r, i) => `[${i + 1}] ${r.content}`).join("\n");
+    return {
+      context: context ? `${this.options.contextPrefix}
+${context}` : "",
+      results,
+      count: prepared.items.length
+    };
+  }
+  /**
+   * Remember what happened AFTER your LLM response
+   * 
+   * Fire-and-forget - doesn't block your response
+   * 
+   * @param content - What your LLM responded with
+   * @returns Promise that resolves when stored (or fails silently)
+   * 
+   * @example
+   * ```typescript
+   * const llmResponse = "I've set your theme to dark mode and removed nuts from recommendations.";
+   * 
+   * await whisper.remember(llmResponse, { userId: "user-123" });
+   * // → Auto-extracts: "theme set to dark mode", "nut allergy"
+   * // → Stored as preferences
+   * ```
+   */
+  async remember(content, options) {
+    if (!content || content.length < 5) {
+      return { success: false };
+    }
+    try {
+      if (this.options.autoExtract) {
+        const extraction = await this.client.extractMemories({
+          project: options?.project ?? this.options.project,
+          message: content,
+          user_id: options?.userId ?? this.userId,
+          session_id: options?.sessionId ?? this.sessionId,
+          enable_pattern: true,
+          enable_inference: true,
+          min_confidence: this.options.autoExtractMinConfidence
+        });
+        const extractedMemories = (extraction.all || []).filter((m) => (m.confidence || 0) >= this.options.autoExtractMinConfidence).slice(0, this.options.maxMemoriesPerCapture);
+        if (extractedMemories.length > 0) {
+          const bulk = await this.client.addMemoriesBulk({
+            project: options?.project ?? this.options.project,
+            write_mode: "async",
+            memories: extractedMemories.map((m) => ({
+              content: m.content,
+              memory_type: m.memoryType,
+              user_id: options?.userId ?? this.userId,
+              session_id: options?.sessionId ?? this.sessionId,
+              importance: Math.max(0.5, Math.min(1, m.confidence || 0.7)),
+              confidence: m.confidence || 0.7,
+              entity_mentions: m.entityMentions || [],
+              event_date: m.eventDate || void 0,
+              metadata: {
+                extracted: true,
+                extraction_method: extraction.extractionMethod,
+                extraction_reasoning: m.reasoning,
+                inferred: Boolean(m.inferred)
+              }
+            }))
+          });
+          const memoryIds = this.extractMemoryIdsFromBulkResponse(bulk);
+          return {
+            success: true,
+            memoryId: memoryIds[0],
+            memoryIds: memoryIds.length > 0 ? memoryIds : void 0,
+            extracted: extractedMemories.length
+          };
         }
       }
-    });
-    if (config.queue?.enabled !== false) {
-      void this.writeQueue.start();
+      const result = await this.client.addMemory({
+        project: options?.project ?? this.options.project,
+        content,
+        user_id: options?.userId ?? this.userId,
+        session_id: options?.sessionId ?? this.sessionId
+      });
+      return {
+        success: true,
+        memoryId: result?.id
+      };
+    } catch (error) {
+      console.error("[Whisper] Remember failed:", error);
+      return { success: false };
     }
-    this.memoryModule = new MemoryModule(
-      this.runtimeClient,
-      this.searchCache,
-      this.writeQueue,
+  }
+  /**
+   * Alias for remember() - same thing
+   */
+  async capture(content, options) {
+    return this.remember(content, options);
+  }
+  /**
+   * Capture from multiple messages (e.g., full conversation)
+   */
+  async captureSession(messages, options) {
+    try {
+      const filteredMessages = messages.filter((m) => m.role !== "system");
+      const runtime = this.runtimeClient.createAgentRuntime({
+        project: options?.project ?? this.options.project,
+        userId: options?.userId ?? this.userId,
+        sessionId: options?.sessionId ?? this.sessionId ?? "default",
+        clientName: "whisper-wrapper"
+      });
+      const result = await runtime.afterTurn({
+        userMessage: [...filteredMessages].reverse().find((m) => m.role === "user")?.content || "",
+        assistantMessage: [...filteredMessages].reverse().find((m) => m.role === "assistant")?.content || ""
+      });
+      return {
+        success: true,
+        extracted: result.memoriesCreated ?? 0
+      };
+    } catch (error) {
+      const fallback = await this.fallbackCaptureViaAddMemory(messages, options);
+      if (fallback.success) {
+        return fallback;
+      }
+      console.error("[Whisper] Session capture failed:", error);
+      return { success: false, extracted: 0 };
+    }
+  }
+  /**
+   * Run a full agent turn with automatic memory read (before) + write (after).
+   */
+  async runTurn(params) {
+    const contextResult = await this.getContext(params.userMessage, {
+      userId: params.userId,
+      sessionId: params.sessionId,
+      project: params.project,
+      limit: params.limit
+    });
+    const prompt = contextResult.context ? `${contextResult.context}
+
+User: ${params.userMessage}` : params.userMessage;
+    const response = await params.generate(prompt);
+    const captureResult = await this.captureSession(
+      [
+        { role: "user", content: params.userMessage },
+        { role: "assistant", content: response }
+      ],
       {
-        defaultProject: config.project,
-        cacheEnabled: config.cache?.enabled !== false,
-        queueEnabled: config.queue?.enabled !== false
+        userId: params.userId,
+        sessionId: params.sessionId,
+        project: params.project
       }
     );
-    this.sessionModule = new SessionModule(this.memoryModule, config.project);
-    this.profileModule = new ProfileModule(this.memoryModule);
-    this.analyticsModule = new AnalyticsModule(this.diagnosticsStore, this.writeQueue);
-    this.diagnostics = {
-      getLast: (limit) => this.diagnosticsStore.getLast(limit),
-      subscribe: (fn) => this.diagnosticsStore.subscribe(fn),
-      snapshot: () => this.diagnosticsStore.snapshot()
-    };
-    this.queue = {
-      flush: () => this.writeQueue.flush(),
-      status: () => this.writeQueue.status()
-    };
-    this.memory = {
-      add: (params) => this.memoryModule.add(params),
-      addBulk: (params) => this.memoryModule.addBulk(params),
-      search: (params) => this.memoryModule.search(params),
-      get: (memoryId) => this.memoryModule.get(memoryId),
-      getUserProfile: (params) => this.memoryModule.getUserProfile(params),
-      getSessionMemories: (params) => this.memoryModule.getSessionMemories(params),
-      update: (memoryId, params) => this.memoryModule.update(memoryId, params),
-      delete: (memoryId) => this.memoryModule.delete(memoryId),
-      flag: (params) => this.memoryModule.flag(params)
-    };
-    this.session = {
-      start: (params) => this.sessionModule.start(params),
-      event: (params) => this.sessionModule.event(params),
-      suspend: (params) => this.sessionModule.suspend(params),
-      resume: (params) => this.sessionModule.resume(params),
-      end: (params) => this.sessionModule.end(params)
-    };
-    this.profile = {
-      getUserProfile: (params) => this.profileModule.getUserProfile(params),
-      getSessionMemories: (params) => this.profileModule.getSessionMemories(params)
-    };
-    this.analytics = {
-      diagnosticsSnapshot: () => this.analyticsModule.diagnosticsSnapshot(),
-      queueStatus: () => this.analyticsModule.queueStatus()
+    return {
+      response,
+      context: contextResult.context,
+      count: contextResult.count,
+      extracted: captureResult.extracted
     };
   }
-  diagnostics;
-  queue;
-  memory;
-  session;
-  profile;
-  analytics;
-  runtimeClient;
-  diagnosticsStore;
-  searchCache;
-  writeQueue;
-  memoryModule;
-  sessionModule;
-  profileModule;
-  analyticsModule;
-  static fromEnv(overrides = {}) {
-    const env = typeof process !== "undefined" ? process.env : {};
-    const apiKey = overrides.apiKey || env.WHISPER_API_KEY || env.USEWHISPER_API_KEY || env.API_KEY;
-    if (!apiKey) {
-      throw new Error("Missing API key. Set WHISPER_API_KEY / USEWHISPER_API_KEY / API_KEY.");
-    }
-    return new _WhisperClient({
-      apiKey,
-      baseUrl: overrides.baseUrl || env.WHISPER_BASE_URL || env.API_BASE_URL || "https://context.usewhisper.dev",
-      project: overrides.project || env.WHISPER_PROJECT || env.PROJECT,
-      ...overrides
-    });
+  /**
+   * Direct access to WhisperContext for advanced usage
+   */
+  raw() {
+    return this.client;
   }
-  withRunContext(context) {
-    const base = this;
-    return {
-      memory: {
-        add: (params) => base.memory.add({
-          ...params,
-          project: params.project || context.project || base.config.project,
-          user_id: params.user_id || context.userId,
-          session_id: params.session_id || context.sessionId
-        }),
-        search: (params) => base.memory.search({
-          ...params,
-          project: params.project || context.project || base.config.project,
-          user_id: params.user_id || context.userId,
-          session_id: params.session_id || context.sessionId
-        })
-      },
-      session: {
-        event: (params) => base.session.event({
-          ...params,
-          sessionId: params.sessionId || context.sessionId || ""
-        })
-      },
-      queue: base.queue,
-      diagnostics: base.diagnostics
-    };
+  extractMemoryIdsFromBulkResponse(bulkResponse) {
+    const ids = [];
+    if (Array.isArray(bulkResponse?.memories)) {
+      for (const memory of bulkResponse.memories) {
+        if (memory?.id) ids.push(memory.id);
+      }
+    }
+    if (bulkResponse?.memory?.id) {
+      ids.push(bulkResponse.memory.id);
+    }
+    if (bulkResponse?.id) {
+      ids.push(bulkResponse.id);
+    }
+    return Array.from(new Set(ids));
   }
-  async shutdown() {
-    await this.writeQueue.stop();
+  async fallbackCaptureViaAddMemory(messages, options) {
+    const userMessages = messages.filter((m) => m.role === "user").map((m) => (m.content || "").trim()).filter((content) => content.length >= 5).slice(-2);
+    if (userMessages.length === 0) {
+      return { success: false, extracted: 0 };
+    }
+    let extracted = 0;
+    for (const content of userMessages) {
+      try {
+        await this.client.addMemory({
+          project: options?.project ?? this.options.project,
+          content,
+          memory_type: "factual",
+          user_id: options?.userId ?? this.userId,
+          session_id: options?.sessionId ?? this.sessionId,
+          allow_legacy_fallback: true
+        });
+        extracted += 1;
+      } catch {
+      }
+    }
+    return { success: extracted > 0, extracted };
   }
 };
-var whisper_default = WhisperClient;
+var whisper_agent_default = Whisper;
 
 // ../src/sdk/middleware.ts
 var WhisperAgentMiddleware = class {
@@ -2257,7 +3020,7 @@ 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;
+var PROJECT_CACHE_TTL_MS2 = 3e4;
 var DEPRECATION_WARNINGS2 = /* @__PURE__ */ new Set();
 function warnDeprecatedOnce2(key, message) {
   if (DEPRECATION_WARNINGS2.has(key)) return;
@@ -2266,7 +3029,7 @@ function warnDeprecatedOnce2(key, message) {
     console.warn(message);
   }
 }
-function isLikelyProjectId(projectRef) {
+function isLikelyProjectId2(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);
 }
 function normalizeBaseUrl2(url) {
@@ -2388,7 +3151,7 @@ var WhisperContext = class _WhisperContext {
         }
       }
     }
-    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS2;
     return this.projectCache;
   }
   async fetchResolvedProject(projectRef) {
@@ -2421,10 +3184,10 @@ var WhisperContext = class _WhisperContext {
         ...this.projectCache.filter((project) => project.id !== resolvedProject.id),
         resolvedProject
       ];
-      this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+      this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS2;
       return resolvedProject;
     }
-    if (isLikelyProjectId(resolvedRef)) {
+    if (isLikelyProjectId2(resolvedRef)) {
       return {
         id: resolvedRef,
         orgId: "",
@@ -2456,7 +3219,7 @@ var WhisperContext = class _WhisperContext {
         message: `Project reference '${projectRef}' matched multiple projects. Use project id instead.`
       });
     }
-    if (isLikelyProjectId(projectRef)) {
+    if (isLikelyProjectId2(projectRef)) {
       return projectRef;
     }
     const resolvedProject = await this.fetchResolvedProject(projectRef);
@@ -2468,7 +3231,7 @@ var WhisperContext = class _WhisperContext {
         ...this.projectCache.filter((project) => project.id !== resolvedProject.id),
         resolvedProject
       ];
-      this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+      this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS2;
       return resolvedProject.id;
     }
     throw new WhisperError({
@@ -2485,7 +3248,7 @@ var WhisperContext = class _WhisperContext {
         candidates.add(match.id);
         candidates.add(match.slug);
         candidates.add(match.name);
-      } else if (isLikelyProjectId(projectRef)) {
+      } else if (isLikelyProjectId2(projectRef)) {
         const byId = projects.find((p) => p.id === projectRef);
         if (byId) {
           candidates.add(byId.slug);
@@ -2646,7 +3409,7 @@ var WhisperContext = class _WhisperContext {
       ...this.projectCache.filter((p) => p.id !== project.id),
       project
     ];
-    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS2;
     return project;
   }
   async listProjects() {
@@ -2657,7 +3420,7 @@ var WhisperContext = class _WhisperContext {
       this.projectRefToId.set(p.slug, p.id);
       this.projectRefToId.set(p.name, p.id);
     }
-    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS;
+    this.projectCacheExpiresAt = Date.now() + PROJECT_CACHE_TTL_MS2;
     return projects;
   }
   async getProject(id) {