@smartmemory/sdk-js 0.5.1

package/dist/core-Ds7Kn35C.js

@@ -0,0 +1,2476 @@
+var _ = (i) => {
+  throw TypeError(i);
+};
+var p = (i, e, t) => e.has(i) || _("Cannot " + t);
+var u = (i, e, t) => (p(i, e, "read from private field"), t ? t.call(i) : e.get(i)), g = (i, e, t) => e.has(i) ? _("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(i) : e.set(i, t), d = (i, e, t, r) => (p(i, e, "write to private field"), r ? r.call(i, t) : e.set(i, t), t), $ = (i, e, t) => (p(i, e, "access private method"), t);
+const b = {
+  access: "smart_memory_auth_token",
+  refresh: "smart_memory_refresh_token",
+  user: "smart_memory_user",
+  tenant: "smart_memory_tenant_id",
+  team: "smart_memory_team_id"
+}, m = {
+  access: ["access_token", "sm_token"],
+  refresh: ["refresh_token", "sm_refresh_token"],
+  user: ["sm_user"],
+  tenant: ["tenant_id", "workspace_id", "sm_workspace_id"],
+  team: ["team_id", "sm_team_id"]
+};
+class I {
+  /**
+   * @param {Object} options
+   * @param {'localStorage' | 'sessionStorage' | 'memory'} [options.storage='localStorage']
+   * @param {Object} [options.keys] - Custom storage key names
+   */
+  constructor({ storage: e = "localStorage", keys: t = {} } = {}) {
+    this.storageType = e, this.keys = { ...b, ...t }, this._memory = { access: null, refresh: null, user: null, tenant: null, team: null };
+  }
+  getAccessToken() {
+    return this.storageType === "memory" ? this._memory.access : this._getFromStorage(this.keys.access, m.access);
+  }
+  setAccessToken(e) {
+    if (this.storageType === "memory") {
+      this._memory.access = e;
+      return;
+    }
+    this._setInStorage(this.keys.access, e);
+  }
+  getRefreshToken() {
+    return this.storageType === "memory" ? this._memory.refresh : this._getFromStorage(this.keys.refresh, m.refresh);
+  }
+  setRefreshToken(e) {
+    if (this.storageType === "memory") {
+      this._memory.refresh = e;
+      return;
+    }
+    this._setInStorage(this.keys.refresh, e);
+  }
+  getUser() {
+    if (this.storageType === "memory") return this._memory.user;
+    const e = this._getFromStorage(this.keys.user, m.user);
+    if (!e) return null;
+    try {
+      return JSON.parse(e);
+    } catch {
+      return null;
+    }
+  }
+  setUser(e) {
+    if (this.storageType === "memory") {
+      this._memory.user = e;
+      return;
+    }
+    this._setInStorage(this.keys.user, e ? JSON.stringify(e) : null);
+  }
+  getTenantId() {
+    return this.storageType === "memory" ? this._memory.tenant : this._normalizeId(this._getFromStorage(this.keys.tenant, m.tenant));
+  }
+  setTenantId(e) {
+    const t = this._normalizeId(e);
+    if (this.storageType === "memory") {
+      this._memory.tenant = t;
+      return;
+    }
+    this._setInStorage(this.keys.tenant, t);
+  }
+  getTeamId() {
+    return this.storageType === "memory" ? this._memory.team : this._normalizeId(this._getFromStorage(this.keys.team, m.team));
+  }
+  setTeamId(e) {
+    const t = this._normalizeId(e);
+    if (this.storageType === "memory") {
+      this._memory.team = t;
+      return;
+    }
+    this._setInStorage(this.keys.team, t);
+  }
+  clearAll() {
+    if (this.storageType === "memory") {
+      this._memory = { access: null, refresh: null, user: null, tenant: null, team: null };
+      return;
+    }
+    for (const e of Object.values(this.keys))
+      try {
+        localStorage.removeItem(e), sessionStorage.removeItem(e);
+      } catch {
+      }
+    for (const e of Object.values(m))
+      for (const t of e)
+        try {
+          localStorage.removeItem(t), sessionStorage.removeItem(t);
+        } catch {
+        }
+  }
+  /** @private */
+  _getFromStorage(e, t = []) {
+    try {
+      const r = this.storageType === "localStorage" ? localStorage : sessionStorage, s = this.storageType === "localStorage" ? sessionStorage : localStorage, n = r.getItem(e) || s.getItem(e);
+      if (n != null) return n;
+      for (const a of t) {
+        const c = r.getItem(a) || s.getItem(a);
+        if (c != null) {
+          this._setInStorage(e, c);
+          try {
+            r.removeItem(a), s.removeItem(a);
+          } catch {
+          }
+          return c;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /** @private */
+  _setInStorage(e, t) {
+    try {
+      const r = this.storageType === "localStorage" ? localStorage : sessionStorage, s = this.storageType === "localStorage" ? sessionStorage : localStorage;
+      t != null ? (r.setItem(e, t), s.removeItem(e)) : (r.removeItem(e), s.removeItem(e));
+    } catch (r) {
+      console.error("Failed to write to storage:", r);
+    }
+  }
+  /** @private */
+  _normalizeId(e) {
+    if (e == null) return null;
+    const t = String(e).trim();
+    if (!t) return null;
+    const r = t.toLowerCase();
+    return r === "none" || r === "null" || r === "undefined" ? null : t;
+  }
+}
+var l, y, k;
+class T {
+  /**
+   * @param {Object} options
+   * @param {string} options.apiBaseUrl
+   * @param {string} options.refreshEndpoint
+   * @param {import('./TokenManager.js').TokenManager} options.tokenManager
+   * @param {boolean} [options.useCookieAuth=false]
+   * @param {function(string): void} options.onTokenRefreshed
+   * @param {function(): void} options.onRefreshFailed
+   */
+  constructor({ apiBaseUrl: e, refreshEndpoint: t, tokenManager: r, useCookieAuth: s = !1, onTokenRefreshed: n, onRefreshFailed: a }) {
+    g(this, y);
+    g(this, l, null);
+    this.apiBaseUrl = e, this.refreshEndpoint = t, this.tokenManager = r, this.useCookieAuth = s, this.onTokenRefreshed = n, this.onRefreshFailed = a;
+  }
+  async refresh() {
+    if (u(this, l))
+      return u(this, l);
+    d(this, l, $(this, y, k).call(this));
+    try {
+      return await u(this, l);
+    } finally {
+      d(this, l, null);
+    }
+  }
+}
+l = new WeakMap(), y = new WeakSet(), k = async function() {
+  const e = this.tokenManager.getRefreshToken();
+  if (!e && !this.useCookieAuth)
+    throw this.onRefreshFailed(), new Error("No refresh token");
+  const t = JSON.stringify(e ? { refresh_token: e } : {}), r = await fetch(`${this.apiBaseUrl}${this.refreshEndpoint}`, {
+    ...this.useCookieAuth ? { credentials: "include" } : {},
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: t
+  });
+  if (!r.ok)
+    throw this.onRefreshFailed(), new Error(`Refresh failed: ${r.status}`);
+  const s = await r.json();
+  return this.tokenManager.setAccessToken(s.access_token), s.refresh_token && this.tokenManager.setRefreshToken(s.refresh_token), this.onTokenRefreshed(s.access_token), s.access_token;
+};
+const f = "smart_memory_sso_redirect";
+class S {
+  /**
+   * @param {Object} options
+   * @param {string} options.webAppUrl - Web app URL for login redirect
+   * @param {string[]} [options.allowedHosts=[]] - Allowed redirect hostnames
+   * @param {import('./TokenManager.js').TokenManager} options.tokenManager
+   */
+  constructor({ webAppUrl: e, allowedHosts: t = [], tokenManager: r }) {
+    this.webAppUrl = e, this.allowedHosts = t, this.tokenManager = r;
+  }
+  getLoginUrl(e) {
+    const t = e || `${window.location.origin}/auth/callback`;
+    return `${this.webAppUrl}/login?redirect=${encodeURIComponent(t)}`;
+  }
+  isValidRedirectUrl(e) {
+    if (!this.allowedHosts.length) return !0;
+    try {
+      const t = new URL(e);
+      return this.allowedHosts.includes(t.hostname);
+    } catch {
+      return !1;
+    }
+  }
+  storeRedirect(e) {
+    try {
+      sessionStorage.setItem(f, e);
+    } catch (t) {
+      console.warn("Failed to store redirect URL:", t);
+    }
+  }
+  getAndClearRedirect() {
+    try {
+      const e = sessionStorage.getItem(f);
+      return sessionStorage.removeItem(f), e;
+    } catch {
+      return null;
+    }
+  }
+}
+class v {
+  constructor(e) {
+    this.mode = e.mode, this.apiBaseUrl = e.apiBaseUrl, this.endpoints = e.endpoints || {}, this.listeners = /* @__PURE__ */ new Set(), this.useCookieAuth = e.useCookieAuth ?? this.mode === "sso", this.apiKey = e.apiKey || null, this.apiKey && (this.mode = "apiKey"), this.tokenManager = new I({
+      storage: e.storage || "localStorage",
+      keys: e.tokenKeys
+    }), this.mode !== "apiKey" ? this.refreshManager = new T({
+      apiBaseUrl: this.apiBaseUrl,
+      refreshEndpoint: this.endpoints.refresh || "/auth/refresh",
+      tokenManager: this.tokenManager,
+      useCookieAuth: this.useCookieAuth,
+      onTokenRefreshed: (t) => {
+        var r;
+        this.currentToken = t, this.notifyListeners(), (r = e.onTokenRefresh) == null || r.call(e, t);
+      },
+      onRefreshFailed: () => {
+        this.clearLocalAuth();
+      }
+    }) : this.refreshManager = null, this.mode === "sso" && (this.ssoManager = new S({
+      webAppUrl: e.webAppUrl,
+      allowedHosts: e.allowedRedirectHosts || [],
+      tokenManager: this.tokenManager
+    })), this.mode === "apiKey" ? (this.currentUser = null, this.currentToken = this.apiKey) : (this.currentUser = this.tokenManager.getUser(), this.currentToken = this.tokenManager.getAccessToken());
+  }
+  isAuthenticated() {
+    return !!this.currentToken || this.useCookieAuth && !!this.currentUser;
+  }
+  getCurrentUser() {
+    return this.currentUser;
+  }
+  getCurrentToken() {
+    return this.currentToken;
+  }
+  getTenantId() {
+    return this.tokenManager.getTenantId();
+  }
+  hasRole(e) {
+    var t, r;
+    return ((r = (t = this.currentUser) == null ? void 0 : t.roles) == null ? void 0 : r.includes(e)) || !1;
+  }
+  getAuthHeaders(e = {}) {
+    const t = { ...e };
+    this.currentToken && (t.Authorization = this.currentToken.startsWith("Bearer ") ? this.currentToken : `Bearer ${this.currentToken}`);
+    const r = this.tokenManager.getTeamId();
+    return r && (t["X-Workspace-Id"] = r), t;
+  }
+  getRequestOptions(e = {}) {
+    return this.useCookieAuth ? { credentials: "include", ...e } : { ...e };
+  }
+  addListener(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  notifyListeners() {
+    const e = {
+      isAuthenticated: this.isAuthenticated(),
+      user: this.currentUser,
+      token: this.currentToken,
+      tenantId: this.tokenManager.getTenantId()
+    };
+    this.listeners.forEach((t) => {
+      try {
+        t(e);
+      } catch (r) {
+        console.error("Auth listener error:", r);
+      }
+    });
+  }
+  getLoginUrl(e) {
+    if (this.mode !== "sso")
+      throw new Error("getLoginUrl() only available in sso mode");
+    return this.ssoManager.getLoginUrl(e);
+  }
+  clearLocalAuth() {
+    if (this.mode === "apiKey") {
+      this.apiKey = null, this.currentToken = null, this.notifyListeners();
+      return;
+    }
+    this.tokenManager.clearAll(), this.currentUser = null, this.currentToken = null, this.notifyListeners();
+  }
+  async logout() {
+    if (this.mode === "apiKey") {
+      this.clearLocalAuth();
+      return;
+    }
+    if (this.endpoints.logout)
+      try {
+        await fetch(`${this.apiBaseUrl}${this.endpoints.logout}`, {
+          ...this.getRequestOptions(),
+          method: "POST",
+          headers: this.getAuthHeaders()
+        });
+      } catch (e) {
+        console.warn("Logout request failed:", e);
+      }
+    this.clearLocalAuth();
+  }
+  async refreshToken() {
+    if (this.mode === "apiKey")
+      return this.apiKey;
+    if (!this.refreshManager)
+      throw new Error("Token refresh not available in this mode");
+    const e = await this.refreshManager.refresh();
+    return this.currentToken = e, e;
+  }
+  async bootstrapSession() {
+    if (this.mode === "apiKey" || !this.useCookieAuth)
+      return !1;
+    try {
+      const e = `${this.apiBaseUrl}/auth/me`;
+      let t = await fetch(
+        e,
+        this.getRequestOptions({ method: "GET", headers: this.getAuthHeaders() })
+      ), r = !1;
+      if (!t.ok && (this.currentToken || this.tokenManager.getTeamId()) && (t = await fetch(
+        e,
+        this.getRequestOptions({ method: "GET", headers: {} })
+      ), r = t.ok), !t.ok && t.status === 401 && this.refreshManager)
+        try {
+          await this.refreshManager.refresh(), t = await fetch(
+            e,
+            this.getRequestOptions({ method: "GET", headers: this.getAuthHeaders() })
+          );
+        } catch {
+        }
+      if (!t.ok) return !1;
+      const s = await t.json();
+      this.currentUser = s, this.tokenManager.setUser(s);
+      const n = (s == null ? void 0 : s.default_team_id) || this.tokenManager.getTeamId() || null;
+      return n && (this.tokenManager.setTeamId(n), this.tokenManager.setTenantId((s == null ? void 0 : s.tenant_id) || n)), r && (this.tokenManager.setAccessToken(null), this.currentToken = null, s != null && s.default_team_id && this.tokenManager.setTeamId(s.default_team_id)), this.notifyListeners(), !0;
+    } catch {
+      return !1;
+    }
+  }
+  setTenantId(e) {
+    this.tokenManager.setTenantId(e), this.notifyListeners();
+  }
+}
+class h extends Error {
+  /**
+   * @param {string} message - Error message
+   * @param {number} [status=0] - HTTP status code (0 for network errors)
+   * @param {Object|null} [detail=null] - Error detail from API response
+   */
+  constructor(e, t = 0, r = null) {
+    super(e), this.name = "APIError", this.status = t, this.detail = r;
+  }
+}
+class A {
+  /**
+   * @param {import('../auth/AuthCore.js').AuthCore} authCore
+   * @param {{ fetchFn?: typeof globalThis.fetch }} [options]
+   */
+  constructor(e, { fetchFn: t } = {}) {
+    this.auth = e, this.baseURL = e.apiBaseUrl, this._customFetchFn = t || null;
+  }
+  get fetchFn() {
+    return this._customFetchFn || globalThis.fetch;
+  }
+  async request(e, t = {}) {
+    var a, c;
+    const r = `${this.baseURL}${e}`, s = {
+      "Content-Type": "application/json",
+      ...this.auth.getAuthHeaders(t.headers)
+    }, n = this.auth.getRequestOptions({ ...t, headers: s });
+    try {
+      let o = await this.fetchFn(r, n);
+      if (o.status === 401 && !t.__isRetry)
+        try {
+          await this.auth.refreshToken();
+          const w = {
+            "Content-Type": "application/json",
+            ...this.auth.getAuthHeaders(t.headers)
+          };
+          o = await this.fetchFn(
+            r,
+            this.auth.getRequestOptions({ ...n, headers: w, __isRetry: !0 })
+          );
+        } catch {
+        }
+      if (o.status === 401)
+        throw (c = (a = this.auth).clearLocalAuth) == null || c.call(a), new h("Authentication required", 401, "auth_expired");
+      if (o.status === 204)
+        return null;
+      if (!o.ok)
+        throw await this._handleError(o);
+      return await o.json();
+    } catch (o) {
+      throw o instanceof h ? o : new h(o.message, 0, "network_error");
+    }
+  }
+  async get(e, t = {}) {
+    return this.request(e, { ...t, method: "GET" });
+  }
+  async post(e, t, r = {}) {
+    return this.request(e, {
+      ...r,
+      method: "POST",
+      body: JSON.stringify(t)
+    });
+  }
+  async put(e, t, r = {}) {
+    return this.request(e, {
+      ...r,
+      method: "PUT",
+      body: JSON.stringify(t)
+    });
+  }
+  async patch(e, t, r = {}) {
+    return this.request(e, {
+      ...r,
+      method: "PATCH",
+      body: JSON.stringify(t)
+    });
+  }
+  async delete(e, t = {}) {
+    return this.request(e, { ...t, method: "DELETE" });
+  }
+  /** @private */
+  async _handleError(e) {
+    var s, n;
+    let t;
+    const r = (n = (s = e.headers) == null ? void 0 : s.get) == null ? void 0 : n.call(s, "content-type");
+    try {
+      r != null && r.includes("application/json") ? t = await e.json() : t = { message: await e.text() };
+    } catch {
+      t = { message: `HTTP ${e.status}` };
+    }
+    return new h(
+      t.detail || t.message || `HTTP ${e.status}`,
+      e.status,
+      t
+    );
+  }
+}
+class R {
+  constructor(e) {
+    this.api = e;
+  }
+  async create({ content: e, memoryType: t = "semantic", metadata: r = null, usePipeline: s = !0, profileName: n = null }) {
+    return this.api.post("/memory/add", {
+      content: e,
+      memory_type: t,
+      metadata: r,
+      use_pipeline: s,
+      profile_name: n
+    });
+  }
+  async get(e) {
+    const t = await this.api.get(`/memory/${e}`);
+    return { ...t, id: t.item_id || t.id };
+  }
+  /**
+   * Update a memory item (CORE-CRUD-UPDATE-1 contract).
+   *
+   * @param {string} id - Memory item ID
+   * @param {Object} updates - Update fields
+   * @param {string} [updates.content] - Convenience — replaces content
+   * @param {Object} [updates.metadata] - Convenience — deep-merges with existing metadata
+   * @param {Object} [updates.properties] - Advanced — direct node-property dict.
+   *   When provided, takes precedence over content/metadata conveniences.
+   * @param {'merge'|'replace'} [updates.write_mode] - Node-property write semantics.
+   *   'merge' (default) overlays new properties; 'replace' replaces all
+   *   (preserving memory_type and node_category).
+   */
+  async update(e, t) {
+    return this.api.patch(`/memory/${e}`, t);
+  }
+  async delete(e) {
+    return this.api.delete(`/memory/${e}`);
+  }
+  async list({ limit: e = 50, offset: t = 0, type: r = null } = {}) {
+    let s = `/memory/list?limit=${e}&offset=${t}`;
+    return r && (s += `&memory_type=${r}`), this.api.get(s);
+  }
+  async search(e, { topK: t = 5, enableHybrid: r = !0, memoryType: s = null } = {}) {
+    const n = { query: e, top_k: t, enable_hybrid: r };
+    return s && (n.memory_type = s), this.api.post("/memory/search", n);
+  }
+  async getWorkingContext(e, t, { k: r = 20, maxTokens: s = null, strategy: n = null } = {}) {
+    const a = {
+      session_id: e,
+      query: t,
+      k: r
+    };
+    return s != null && (a.max_tokens = s), n != null && (a.strategy = n), this.api.post("/memory/context", a);
+  }
+  async searchAdvanced(e, { algorithm: t = "query_traversal", maxResults: r = 15, useSSG: s = !0 } = {}) {
+    return this.api.post("/memory/search/advanced", {
+      query: e,
+      algorithm: t,
+      max_results: r,
+      use_ssg: s
+    });
+  }
+  async ingest(e, { profileName: t = null, extractorName: r = "llm", context: s = {} } = {}) {
+    return this.api.post("/memory/ingest", {
+      content: e,
+      profile_name: t,
+      extractor_name: r,
+      context: s
+    });
+  }
+  async getLineage(e) {
+    return this.api.get(`/memory/${e}/lineage`);
+  }
+  async getLinks(e) {
+    return this.api.get(`/memory/${e}/links`);
+  }
+  async searchByMetadata(e, t, { memoryType: r = null } = {}) {
+    const s = new URLSearchParams({ metadata_key: e, metadata_value: t });
+    return r && s.append("memory_type", r), this.api.get(`/memory/by-metadata?${s}`);
+  }
+  async getNeighbors(e) {
+    return this.api.get(`/memory/${e}/neighbors`);
+  }
+  async getSummary() {
+    return this.api.get("/memory/summary");
+  }
+  async ingestConversation(e, {
+    sessionBoundaries: t = null,
+    conversationId: r = null,
+    sessionDates: s = null,
+    turnsPerChunk: n = 15,
+    maxChunkChars: a = 12e3,
+    maxConcurrent: c = 4
+  } = {}) {
+    const o = { turns: e, turns_per_chunk: n, max_chunk_chars: a, max_concurrent: c };
+    return t && (o.session_boundaries = t), r && (o.conversation_id = r), s && (o.session_dates = s), this.api.post("/memory/ingest/conversation", o);
+  }
+  async ingestDocument(e, { title: t = null, source: r = null, chunkStrategy: s = null } = {}) {
+    const n = { content: e };
+    return t && (n.title = t), r && (n.source = r), s && (n.chunk_strategy = s), this.api.post("/memory/ingest/document", n);
+  }
+  async codeIndex(e, { repo: t = null, commit: r = null } = {}) {
+    const s = { path: e };
+    return t && (s.repo = t), r && (s.commit = r), this.api.post("/memory/code/index", s);
+  }
+  async codeSearch(e, { entityType: t = null, repo: r = null, limit: s = 20, semantic: n = !1 } = {}) {
+    const a = new URLSearchParams({ query: e, limit: s, semantic: n });
+    return t && a.append("entity_type", t), r && a.append("repo", r), this.api.get(`/memory/code/search?${a}`);
+  }
+  async codeContext(e, { repo: t = null } = {}) {
+    const r = new URLSearchParams({ entity_name: e });
+    return t && r.append("repo", t), this.api.get(`/memory/code/context?${r}`);
+  }
+  async codeDeadCode(e) {
+    return this.api.get(`/memory/code/dead-code?repo=${encodeURIComponent(e)}`);
+  }
+  async codeDependencies(e, { direction: t = "both", repo: r = null } = {}) {
+    const s = new URLSearchParams({ entity_name: e, direction: t });
+    return r && s.append("repo", r), this.api.get(`/memory/code/dependencies?${s}`);
+  }
+  async getPlan(e) {
+    return this.api.get(`/memory/plans/${e}`);
+  }
+  async updatePlanTask(e, { taskId: t, status: r }) {
+    return this.api.patch(`/memory/plans/${e}/task`, { task_id: t, status: r });
+  }
+  async completePlan(e, { graduate: t = !1 } = {}) {
+    return this.api.post(`/memory/plans/${e}/complete`, { graduate: t });
+  }
+  async failPlan(e, t) {
+    return this.api.post(`/memory/plans/${e}/fail`, { reason: t });
+  }
+  async link(e, t, r = "RELATED") {
+    return this.api.post("/memory/link", {
+      source_id: e,
+      target_id: t,
+      link_type: r
+    });
+  }
+  async enrich(e, t = []) {
+    return this.api.post(`/memory/${e}/enrich`, {
+      item_id: e,
+      routines: t
+    });
+  }
+  async personalize(e = {}, t = {}) {
+    return this.api.post("/memory/personalize", { traits: e, preferences: t });
+  }
+  async feedback(e, t = "semantic") {
+    return this.api.post("/memory/feedback", { feedback: e, memory_type: t });
+  }
+  async ground(e, t, r = null) {
+    return this.api.post(`/memory/${e}/ground`, {
+      item_id: e,
+      source_url: t,
+      validation: r
+    });
+  }
+  async clearAll(e = !1) {
+    return this.api.delete(`/memory/clear-all?nuclear=${e}`);
+  }
+  // --- Temporal ---
+  async getHistory(e, { startTime: t = null, endTime: r = null, limit: s = 100 } = {}) {
+    let n = `/memory/temporal/${e}/history?limit=${s}`;
+    return t && (n += `&start_time=${t}`), r && (n += `&end_time=${r}`), this.api.get(n);
+  }
+  async timeTravel(e, { query: t = null, limit: r = 100 } = {}) {
+    let s = `/memory/temporal/at/${e}?limit=${r}`;
+    return t && (s += `&query=${encodeURIComponent(t)}`), this.api.get(s);
+  }
+  async getItemAtTime(e, t) {
+    return this.api.get(`/memory/temporal/${e}/at/${t}`);
+  }
+  async getChanges(e, { since: t = null, until: r = null, changeType: s = null } = {}) {
+    let n = `/memory/temporal/${e}/changes`;
+    const a = [];
+    return t && a.push(`since=${t}`), r && a.push(`until=${r}`), s && a.push(`change_type=${s}`), a.length && (n += `?${a.join("&")}`), this.api.get(n);
+  }
+  async compareVersions(e, t, r) {
+    return this.api.post(`/memory/temporal/${e}/compare?v1=${t}&v2=${r}`);
+  }
+  async rollback(e, { toVersion: t = null, toTime: r = null } = {}) {
+    let s = `/memory/temporal/${e}/rollback`;
+    const n = [];
+    return t !== null && n.push(`to_version=${t}`), r && n.push(`to_time=${r}`), n.length && (s += `?${n.join("&")}`), this.api.post(s);
+  }
+  // --- Clustering ---
+  async runClustering(e = 0.1, t = !1) {
+    return this.api.post(`/memory/clustering/run?distance_threshold=${e}&dry_run=${t}`);
+  }
+  async getClusteringStats() {
+    return this.api.get("/memory/clustering/stats");
+  }
+}
+class U {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Create a new decision with provenance tracking.
+   * @param {Object} params
+   * @param {string} params.content
+   * @param {string} [params.decisionType='inference']
+   * @param {number} [params.confidence=0.8]
+   * @param {string} [params.sourceTraceId]
+   * @param {string} [params.sourceSessionId]
+   * @param {string[]} [params.evidenceIds]
+   * @param {string} [params.domain]
+   * @param {string[]} [params.tags]
+   */
+  async create({
+    content: e,
+    decisionType: t = "inference",
+    confidence: r = 0.8,
+    sourceTraceId: s = null,
+    sourceSessionId: n = null,
+    evidenceIds: a = null,
+    domain: c = null,
+    tags: o = null
+  }) {
+    return this.api.post("/memory/decisions/create", {
+      content: e,
+      decision_type: t,
+      confidence: r,
+      source_trace_id: s,
+      source_session_id: n,
+      evidence_ids: a,
+      domain: c,
+      tags: o
+    });
+  }
+  /**
+   * List active decisions with optional filters.
+   * @param {Object} [params] - Query parameters (domain, decision_type, min_confidence, limit)
+   */
+  async list(e = {}) {
+    const t = new URLSearchParams(e).toString();
+    return this.api.get(`/memory/decisions${t ? "?" + t : ""}`);
+  }
+  /**
+   * Search for active decisions related to a topic.
+   * @param {string} topic
+   * @param {number} [limit=20]
+   */
+  async search(e, t = 20) {
+    return this.api.get(`/memory/decisions/search?topic=${encodeURIComponent(e)}&limit=${t}`);
+  }
+  /**
+   * List pending decisions (awaiting more data via residuation).
+   * @param {number} [limit=50]
+   */
+  async listPending(e = 50) {
+    return this.api.get(`/memory/decisions/pending?limit=${e}`);
+  }
+  /**
+   * Retrieve a decision by ID.
+   * @param {string} decisionId
+   */
+  async get(e) {
+    return this.api.get(`/memory/decisions/${e}`);
+  }
+  /**
+   * Replace a decision with a new one, marking the old as superseded.
+   * @param {string} decisionId
+   * @param {Object} data
+   * @param {string} data.new_content
+   * @param {string} [data.new_decision_type='inference']
+   * @param {number} [data.new_confidence=0.8]
+   * @param {string} data.reason
+   */
+  async supersede(e, t = {}) {
+    return this.api.post(`/memory/decisions/${e}/supersede`, t);
+  }
+  /**
+   * Retract a decision (mark as no longer valid).
+   * @param {string} decisionId
+   * @param {string} reason
+   */
+  async retract(e, t) {
+    return this.api.post(`/memory/decisions/${e}/retract`, {
+      reason: t
+    });
+  }
+  /**
+   * Record supporting evidence for a decision.
+   * @param {string} decisionId
+   * @param {string} evidenceId
+   */
+  async reinforce(e, t) {
+    return this.api.post(`/memory/decisions/${e}/reinforce`, {
+      evidence_id: t
+    });
+  }
+  /**
+   * Record contradicting evidence against a decision.
+   * @param {string} decisionId
+   * @param {string} evidenceId
+   */
+  async contradict(e, t) {
+    return this.api.post(`/memory/decisions/${e}/contradict`, {
+      evidence_id: t
+    });
+  }
+  /**
+   * Get full provenance chain for a decision.
+   * @param {string} decisionId
+   */
+  async getProvenance(e) {
+    return this.api.get(`/memory/decisions/${e}/provenance`);
+  }
+  /**
+   * Trace causal chain from a decision.
+   * @param {string} decisionId
+   * @param {Object} [options]
+   * @param {string} [options.direction='both'] - causes|effects|both
+   * @param {number} [options.maxDepth=3]
+   */
+  async getCausalChain(e, { direction: t = "both", maxDepth: r = 3 } = {}) {
+    return this.api.get(`/memory/decisions/${e}/causal-chain?direction=${t}&max_depth=${r}`);
+  }
+  /**
+   * Find existing decisions that may conflict with this one.
+   * @param {string} decisionId
+   */
+  async findConflicts(e) {
+    return this.api.post(`/memory/decisions/${e}/conflicts`);
+  }
+  // --- Legacy reasoning proxies (kept for backward compatibility) ---
+  /**
+   * Build an auditable proof tree for a decision.
+   * @param {string} decisionId
+   * @param {number} [maxDepth=5]
+   */
+  async getProofTree(e, t = 5) {
+    return this.api.post("/memory/reasoning/proof", {
+      decision_id: e,
+      max_depth: t
+    });
+  }
+  /**
+   * Get multi-dimensional confidence score for a decision.
+   * @param {string} decisionId
+   */
+  async getFuzzyConfidence(e) {
+    return this.api.post("/memory/reasoning/fuzzy-confidence", {
+      decision_id: e
+    });
+  }
+}
+class C {
+  constructor(e) {
+    this.api = e;
+  }
+  async getNeighbors(e) {
+    return this.api.get(`/memory/${e}/neighbors`);
+  }
+  async addEdge(e, t, r, s = {}) {
+    return this.api.post("/memory/edge", {
+      source_id: e,
+      target_id: t,
+      relation_type: r,
+      properties: s
+    });
+  }
+  async getHealth() {
+    return this.api.get("/memory/graph/health");
+  }
+  async getInferenceRules() {
+    return this.api.get("/memory/validation/inference/rules");
+  }
+  async runInference(e = []) {
+    return this.api.post("/memory/validation/inference", {
+      rule_names: e
+    });
+  }
+  /**
+   * Find the shortest path between two graph nodes.
+   * @param {string} startId
+   * @param {string} endId
+   * @param {number} [maxHops=5]
+   */
+  async findShortestPath(e, t, r = 5) {
+    return this.api.get(`/memory/graph/path?start_id=${encodeURIComponent(e)}&end_id=${encodeURIComponent(t)}&max_hops=${r}`);
+  }
+  /**
+   * Fetch the full knowledge graph.
+   * @param {number} [limit] - Optional client hint; backend enforces hard cap.
+   */
+  async getFullGraph(e) {
+    return e == null ? this.api.get("/memory/graph/full") : this.api.get(`/memory/graph/full?limit=${encodeURIComponent(e)}`);
+  }
+  /**
+   * Fetch edges for multiple node IDs in bulk.
+   * @param {string[]} nodeIds
+   */
+  async getEdgesBulk(e) {
+    return this.api.post("/memory/graph/edges", { node_ids: e });
+  }
+  /**
+   * Get Wikipedia grounding status for an entity node.
+   * @param {string} nodeId
+   */
+  async getGroundingStatus(e) {
+    return this.api.get(`/memory/graph/nodes/${encodeURIComponent(e)}/grounding`);
+  }
+  /**
+   * Update an entity node's label or type. Triggers ontology self-learning.
+   * @param {string} nodeId
+   * @param {Object} updates - { label, entity_type }
+   */
+  async updateEntityNode(e, t) {
+    return this.api.patch(`/memory/graph/nodes/${encodeURIComponent(e)}`, t);
+  }
+  /**
+   * Remove Wikipedia grounding from an entity node.
+   * @param {string} nodeId
+   */
+  async removeGrounding(e) {
+    return this.api.delete(`/memory/graph/nodes/${encodeURIComponent(e)}/grounding`);
+  }
+  /**
+   * Delete an entity graph node and all its edges.
+   * @param {string} nodeId
+   */
+  async deleteEntityNode(e) {
+    return this.api.delete(`/memory/graph/nodes/${encodeURIComponent(e)}`);
+  }
+  /**
+   * Get links for a memory item.
+   * @param {string} itemId
+   */
+  async getLinks(e) {
+    return this.api.get(`/memory/${encodeURIComponent(e)}/links`);
+  }
+}
+class P {
+  constructor(e) {
+    this.api = e;
+  }
+  async list() {
+    return this.api.get("/memory/teams");
+  }
+  async create({ name: e, description: t = null, dataClassification: r = "internal", costCenter: s = null }) {
+    return this.api.post("/memory/teams", {
+      name: e,
+      description: t,
+      data_classification: r,
+      cost_center: s
+    });
+  }
+  async get(e) {
+    return this.api.get(`/memory/teams/${e}`);
+  }
+  async update(e, t) {
+    return this.api.patch(`/memory/teams/${e}`, t);
+  }
+  async delete(e) {
+    return this.api.delete(`/memory/teams/${e}`);
+  }
+  async getMembers(e) {
+    return this.api.get(`/memory/teams/${e}/members`);
+  }
+  async addMember(e, t, r = "member") {
+    return this.api.post(`/memory/teams/${e}/members`, {
+      user_id: t,
+      role: r
+    });
+  }
+  async updateMember(e, t, r) {
+    return this.api.patch(`/memory/teams/${e}/members/${t}`, { role: r });
+  }
+  async removeMember(e, t) {
+    return this.api.delete(`/memory/teams/${e}/members/${t}`);
+  }
+}
+class M {
+  constructor(e) {
+    this.api = e;
+  }
+  async list() {
+    return this.api.get("/memory/pipeline/profiles");
+  }
+  async get(e) {
+    return this.api.get(`/memory/pipeline/profiles/${e}`);
+  }
+  async getLLMKeys() {
+    return this.api.get("/auth/llm-keys");
+  }
+  async updateLLMKeys(e) {
+    return this.api.patch("/auth/llm-keys", e);
+  }
+}
+class L {
+  constructor(e) {
+    this.api = e;
+  }
+  async getCurrent() {
+    return this.api.get("/subscription/current");
+  }
+  async upgrade(e, t = null) {
+    return this.api.post("/subscription/upgrade", {
+      tier: e,
+      payment_method_id: t
+    });
+  }
+  async cancel(e = !1) {
+    return this.api.post(`/subscription/cancel?immediately=${e}`);
+  }
+  async createPortalSession() {
+    return this.api.post("/subscription/portal");
+  }
+  async createCheckoutSession(e, t = "monthly") {
+    return this.api.post("/subscription/checkout", {
+      tier: e,
+      billing_period: t
+    });
+  }
+}
+class z {
+  constructor(e) {
+    this.api = e;
+  }
+  async getCurrentUser() {
+    return this.api.get("/auth/me");
+  }
+  async createAPIKey(e, t, r = null) {
+    return this.api.post("/memory/api-keys", {
+      name: e,
+      scopes: t,
+      expires_in_days: r
+    });
+  }
+  async listAPIKeys() {
+    return this.api.get("/memory/api-keys");
+  }
+  async revokeAPIKey(e) {
+    return this.api.delete(`/memory/api-keys/${e}`);
+  }
+}
+class E {
+  constructor(e) {
+    this.api = e;
+  }
+  async list() {
+    return this.api.get("/memory/agents");
+  }
+  async create({ name: e, description: t = null, agentConfig: r = {}, roles: s = ["user"] }) {
+    return this.api.post("/memory/agents", {
+      name: e,
+      description: t,
+      agent_config: r,
+      roles: s
+    });
+  }
+  async get(e) {
+    return this.api.get(`/memory/agents/${e}`);
+  }
+  async delete(e) {
+    return this.api.delete(`/memory/agents/${e}`);
+  }
+  async getRecallProfile(e) {
+    return this.api.get(`/memory/agents/${e}/recall-profile`);
+  }
+  async setRecallProfile(e, t) {
+    return this.api.put(`/memory/agents/${e}/recall-profile`, { recall_profile: t });
+  }
+}
+class x {
+  constructor(e) {
+    this.api = e;
+  }
+  async getDashboard() {
+    return this.api.get("/usage/dashboard");
+  }
+  async getCurrent() {
+    return this.api.get("/usage/current");
+  }
+  async getTiers() {
+    return this.api.get("/usage/tiers");
+  }
+}
+class O {
+  constructor(e) {
+    this.api = e;
+  }
+  async getHealth() {
+    return this.api.get("/memory/health");
+  }
+  async getReflection() {
+    return this.api.get("/memory/reflect");
+  }
+  async getMaintenanceStatus() {
+    return this.api.get("/memory/maintenance/status");
+  }
+  async getPlugins() {
+    return this.api.get("/memory/plugins");
+  }
+}
+class q {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Get aggregated token usage history for the current workspace.
+   * @param {Object} params - Query parameters
+   * @param {string} [params.start_date] - ISO date string (inclusive)
+   * @param {string} [params.end_date] - ISO date string (inclusive)
+   * @param {string} [params.group_by] - Group by: "stage" | "profile" | "day"
+   * @param {number} [params.limit=100] - Max records (1-1000)
+   */
+  async getUsage(e = {}) {
+    const t = new URLSearchParams(e).toString();
+    return this.api.get(`/memory/token-usage${t ? "?" + t : ""}`);
+  }
+  /**
+   * Get real-time token usage: cache stats + last 10 pipeline runs.
+   */
+  async getCurrent() {
+    return this.api.get("/memory/token-usage/current");
+  }
+}
+class F {
+  constructor(e) {
+    this.api = e;
+  }
+  // === VERSION HISTORY ===
+  /**
+   * Get complete version history of a memory item.
+   * @param {string} itemId
+   * @param {Object} [options]
+   * @param {string} [options.startTime] - ISO start time
+   * @param {string} [options.endTime] - ISO end time
+   * @param {number} [options.limit=100]
+   */
+  async getHistory(e, { startTime: t = null, endTime: r = null, limit: s = 100 } = {}) {
+    let n = `/memory/temporal/${e}/history?limit=${s}`;
+    return t && (n += `&start_time=${t}`), r && (n += `&end_time=${r}`), this.api.get(n);
+  }
+  // === TIME-TRAVEL QUERIES ===
+  /**
+   * Time-travel query - get state at specific time.
+   * @param {string} timestamp - ISO timestamp
+   * @param {Object} [options]
+   * @param {string} [options.query]
+   * @param {number} [options.limit=100]
+   */
+  async timeTravel(e, { query: t = null, limit: r = 100 } = {}) {
+    let s = `/memory/temporal/at/${e}?limit=${r}`;
+    return t && (s += `&query=${encodeURIComponent(t)}`), this.api.get(s);
+  }
+  /**
+   * Get specific item as it existed at timestamp.
+   * @param {string} itemId
+   * @param {string} timestamp - ISO timestamp
+   */
+  async getItemAtTime(e, t) {
+    return this.api.get(`/memory/temporal/${e}/at/${t}`);
+  }
+  // === CHANGE TRACKING ===
+  /**
+   * Get all changes to an item in time range.
+   * @param {string} itemId
+   * @param {Object} [options]
+   * @param {string} [options.since]
+   * @param {string} [options.until]
+   * @param {string} [options.changeType]
+   */
+  async getChanges(e, { since: t = null, until: r = null, changeType: s = null } = {}) {
+    let n = `/memory/temporal/${e}/changes`;
+    const a = [];
+    return t && a.push(`since=${t}`), r && a.push(`until=${r}`), s && a.push(`change_type=${s}`), a.length && (n += `?${a.join("&")}`), this.api.get(n);
+  }
+  // === VERSION COMPARISON ===
+  /**
+   * Compare two versions of an item.
+   * @param {string} itemId
+   * @param {number} v1
+   * @param {number} v2
+   */
+  async compareVersions(e, t, r) {
+    return this.api.post(`/memory/temporal/${e}/compare?v1=${t}&v2=${r}`);
+  }
+  // === ROLLBACK ===
+  /**
+   * Rollback item to previous version or timestamp.
+   * @param {string} itemId
+   * @param {Object} [options]
+   * @param {number} [options.toVersion]
+   * @param {string} [options.toTime]
+   */
+  async rollback(e, { toVersion: t = null, toTime: r = null } = {}) {
+    let s = `/memory/temporal/${e}/rollback`;
+    const n = [];
+    return t !== null && n.push(`to_version=${t}`), r && n.push(`to_time=${r}`), n.length && (s += `?${n.join("&")}`), this.api.post(s);
+  }
+  // === AUDIT TRAIL ===
+  /**
+   * Get complete audit trail for an item.
+   * @param {string} itemId
+   * @param {Object} [options]
+   * @param {string} [options.changeType]
+   * @param {string} [options.userId]
+   * @param {string} [options.startTime]
+   * @param {string} [options.endTime]
+   */
+  async getAuditTrail(e, { changeType: t = null, userId: r = null, startTime: s = null, endTime: n = null } = {}) {
+    let a = `/memory/temporal/${e}/audit`;
+    const c = [];
+    return t && c.push(`change_type=${t}`), r && c.push(`user_id=${r}`), s && c.push(`start_time=${s}`), n && c.push(`end_time=${n}`), c.length && (a += `?${c.join("&")}`), this.api.get(a);
+  }
+  // === TEMPORAL SEARCH ===
+  /**
+   * Search memories that existed during time range.
+   * @param {string} query
+   * @param {string} startTime
+   * @param {string} endTime
+   * @param {number} [limit=100]
+   */
+  async searchDuringRange(e, t, r, s = 100) {
+    const n = new URLSearchParams({
+      query: e,
+      start_time: t,
+      end_time: r,
+      limit: String(s)
+    }).toString();
+    return this.api.get(`/memory/temporal/search/during?${n}`);
+  }
+  // === COMPLIANCE REPORTING ===
+  /**
+   * Generate compliance report (HIPAA, GDPR, SOC2).
+   * @param {string} startDate
+   * @param {string} endDate
+   * @param {Object} [options]
+   * @param {string} [options.reportType='HIPAA']
+   * @param {string[]} [options.itemIds]
+   */
+  async complianceReport(e, t, { reportType: r = "HIPAA", itemIds: s = null } = {}) {
+    let n = `/memory/temporal/compliance/report?start_date=${e}&end_date=${t}&report_type=${r}`;
+    if (s && s.length)
+      for (const a of s)
+        n += `&item_ids=${encodeURIComponent(a)}`;
+    return this.api.get(n);
+  }
+  // === TEMPORAL RELATIONSHIPS ===
+  /**
+   * Get history of a relationship.
+   * @param {string} relId
+   */
+  async getRelationshipHistory(e) {
+    return this.api.get(`/memory/temporal/relationships/${e}/history`);
+  }
+  /**
+   * Get all relationships that existed at specific time.
+   * @param {string} timestamp
+   * @param {number} [limit=100]
+   */
+  async getRelationshipsAtTime(e, t = 100) {
+    return this.api.get(`/memory/temporal/relationships/at/${e}?limit=${t}`);
+  }
+  /**
+   * Get valid time periods for a relationship.
+   * @param {string} relId
+   */
+  async getRelationshipValidPeriods(e) {
+    return this.api.get(`/memory/temporal/relationships/${e}/valid-periods`);
+  }
+}
+class H {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Run governance analysis.
+   * @param {Object} [options]
+   * @param {string} [options.query='*']
+   * @param {number} [options.topK=100]
+   * @param {Object[]} [options.memoryItems] - Direct items to analyze
+   */
+  async runAnalysis({ query: e = "*", topK: t = 100, memoryItems: r = [] } = {}) {
+    return this.api.post("/memory/governance/run-analysis", {
+      query: e,
+      top_k: t,
+      memory_items: r
+    });
+  }
+  /**
+   * List violations available for review.
+   * @param {Object} [options]
+   * @param {string} [options.severity] - Filter: low|medium|high|critical
+   * @param {boolean} [options.autoFixableOnly=false]
+   */
+  async listViolations({ severity: e = null, autoFixableOnly: t = !1 } = {}) {
+    const r = [];
+    e && r.push(`severity=${e}`), t && r.push("auto_fixable_only=true");
+    const s = r.length ? `?${r.join("&")}` : "";
+    return this.api.get(`/memory/governance/violations${s}`);
+  }
+  /**
+   * Get a specific violation by ID.
+   * @param {string} violationId
+   */
+  async getViolation(e) {
+    return this.api.get(`/memory/governance/violations/${e}`);
+  }
+  /**
+   * Apply a governance decision for a violation.
+   * @param {Object} params
+   * @param {string} params.violationId
+   * @param {string} [params.action='approve'] - approve|reject|evolve_ontology|fix_data|ignore|review_later
+   * @param {string} [params.rationale='']
+   * @param {string} [params.decidedBy='human']
+   */
+  async applyDecision({ violationId: e, action: t = "approve", rationale: r = "", decidedBy: s = "human" }) {
+    return this.api.post("/memory/governance/apply-decision", {
+      violation_id: e,
+      action: t,
+      rationale: r,
+      decided_by: s
+    });
+  }
+  /**
+   * Run auto-fix for high-confidence violations.
+   * @param {number} [confidenceThreshold=0.8]
+   */
+  async autoFix(e = 0.8) {
+    return this.api.post("/memory/governance/auto-fix", {
+      confidence_threshold: e
+    });
+  }
+  /**
+   * Get a summary of governance state.
+   */
+  async getSummary() {
+    return this.api.get("/memory/governance/summary");
+  }
+}
+class j {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Manually trigger memory evolution processes.
+   */
+  async trigger() {
+    return this.api.post("/memory/evolution/trigger");
+  }
+  /**
+   * Run a 'dream' phase: promote working memory to episodic/procedural.
+   */
+  async dream() {
+    return this.api.post("/memory/evolution/dream");
+  }
+  /**
+   * Get status of memory evolution processes.
+   */
+  async getStatus() {
+    return this.api.get("/memory/evolution/status");
+  }
+  /**
+   * Run opinion synthesis: detect patterns in episodic memories and form opinions.
+   */
+  async synthesizeOpinions() {
+    return this.api.post("/memory/evolution/synthesize/opinions");
+  }
+  /**
+   * Run observation synthesis: create entity summaries from scattered facts.
+   */
+  async synthesizeObservations() {
+    return this.api.post("/memory/evolution/synthesize/observations");
+  }
+  /**
+   * Run opinion reinforcement: update confidence scores based on new evidence.
+   */
+  async reinforceOpinions() {
+    return this.api.post("/memory/evolution/reinforce/opinions");
+  }
+}
+class K {
+  constructor(e) {
+    this.api = e;
+  }
+  // === ASSERTION CHALLENGING ===
+  /**
+   * Challenge an assertion against existing knowledge.
+   * @param {Object} params
+   * @param {string} params.assertion
+   * @param {string} [params.memoryType='semantic']
+   * @param {boolean} [params.useLlm=true]
+   */
+  async challenge({ assertion: e, memoryType: t = "semantic", useLlm: r = !0 }) {
+    return this.api.post("/memory/reasoning/challenge", {
+      assertion: e,
+      memory_type: t,
+      use_llm: r
+    });
+  }
+  /**
+   * Resolve a conflict between assertions.
+   * @param {Object} params
+   * @param {string} params.existingItemId
+   * @param {string} params.newFact
+   * @param {boolean} [params.autoResolve=true]
+   * @param {string} [params.strategy]
+   * @param {boolean} [params.useWikipedia=true]
+   * @param {boolean} [params.useLlm=true]
+   */
+  async resolve({ existingItemId: e, newFact: t, autoResolve: r = !0, strategy: s = null, useWikipedia: n = !0, useLlm: a = !0 }) {
+    return this.api.post("/memory/reasoning/resolve", {
+      existing_item_id: e,
+      new_fact: t,
+      auto_resolve: r,
+      strategy: s,
+      use_wikipedia: n,
+      use_llm: a
+    });
+  }
+  // === CONFLICT QUERIES ===
+  /**
+   * List memory items that have unresolved conflicts.
+   * @param {Object} [options]
+   * @param {boolean} [options.needsReview=true]
+   * @param {number} [options.limit=50]
+   */
+  async listConflicts({ needsReview: e = !0, limit: t = 50 } = {}) {
+    return this.api.get(`/memory/reasoning/conflicts?needs_review=${e}&limit=${t}`);
+  }
+  /**
+   * Get items with confidence below threshold.
+   * @param {Object} [options]
+   * @param {number} [options.threshold=0.5]
+   * @param {number} [options.limit=50]
+   */
+  async getLowConfidence({ threshold: e = 0.5, limit: t = 50 } = {}) {
+    return this.api.get(`/memory/reasoning/low-confidence?threshold=${e}&limit=${t}`);
+  }
+  /**
+   * Get confidence decay history for a specific item.
+   * @param {string} itemId
+   */
+  async getConfidenceHistory(e) {
+    return this.api.get(`/memory/reasoning/confidence-history/${e}`);
+  }
+  // === SYMBOLIC REASONING ===
+  /**
+   * Route a query through the symbolic/semantic router.
+   * @param {string} query
+   * @param {number} [topK=10]
+   */
+  async query(e, t = 10) {
+    return this.api.post("/memory/reasoning/query", {
+      query: e,
+      top_k: t
+    });
+  }
+  /**
+   * Build an auditable proof tree for a decision.
+   * @param {string} decisionId
+   * @param {number} [maxDepth=5]
+   */
+  async proof(e, t = 5) {
+    return this.api.post("/memory/reasoning/proof", {
+      decision_id: e,
+      max_depth: t
+    });
+  }
+  /**
+   * Get multi-dimensional confidence score for a decision.
+   * @param {string} decisionId
+   */
+  async fuzzyConfidence(e) {
+    return this.api.post("/memory/reasoning/fuzzy-confidence", {
+      decision_id: e
+    });
+  }
+}
+class B {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Extract reasoning traces from content.
+   * @param {Object} params
+   * @param {string} params.content
+   * @param {number} [params.minSteps=2]
+   * @param {number} [params.minQualityScore=0.4]
+   * @param {boolean} [params.useLlmDetection=true]
+   */
+  async extract({ content: e, minSteps: t = 2, minQualityScore: r = 0.4, useLlmDetection: s = !0 }) {
+    return this.api.post("/memory/reasoning/traces/extract", {
+      content: e,
+      min_steps: t,
+      min_quality_score: r,
+      use_llm_detection: s
+    });
+  }
+  /**
+   * Store a reasoning trace as a memory item.
+   * @param {Object} params
+   * @param {Object} params.trace - ReasoningTrace object
+   * @param {string[]} [params.artifactIds]
+   */
+  async store({ trace: e, artifactIds: t = null }) {
+    return this.api.post("/memory/reasoning/traces/store", {
+      trace: e,
+      artifact_ids: t
+    });
+  }
+  /**
+   * Query reasoning traces.
+   * @param {Object} params
+   * @param {string} params.query
+   * @param {string} [params.artifactId]
+   * @param {number} [params.limit=10]
+   */
+  async query({ query: e, artifactId: t = null, limit: r = 10 }) {
+    return this.api.post("/memory/reasoning/traces/query", {
+      query: e,
+      artifact_id: t,
+      limit: r
+    });
+  }
+  /**
+   * Get a specific reasoning trace by ID.
+   * @param {string} traceId
+   */
+  async get(e) {
+    return this.api.get(`/memory/reasoning/traces/${e}`);
+  }
+}
+class D {
+  constructor(e) {
+    this.api = e;
+  }
+  // === INFERENCE ===
+  /**
+   * Run ontology inference over provided raw text chunks.
+   * @param {Object} params
+   * @param {string} [params.registryId='default']
+   * @param {Array<{docId: string, text: string}>} params.rawChunks
+   * @param {Object} [params.params={}]
+   */
+  async runInference({ registryId: e = "default", rawChunks: t, params: r = {} }) {
+    return this.api.post("/memory/ontology/inference/run", {
+      registry_id: e,
+      raw_chunks: t.map((s) => ({ doc_id: s.docId, text: s.text })),
+      params: r
+    });
+  }
+  // === REGISTRY MANAGEMENT ===
+  /**
+   * List all ontology registries.
+   */
+  async listRegistries() {
+    return this.api.get("/memory/ontology/registries");
+  }
+  /**
+   * Create a new ontology registry.
+   * @param {Object} params
+   * @param {string} params.name
+   * @param {string} [params.description='']
+   * @param {string} [params.domain='general']
+   */
+  async createRegistry({ name: e, description: t = "", domain: r = "general" }) {
+    return this.api.post("/memory/ontology/registries", {
+      name: e,
+      description: t,
+      domain: r
+    });
+  }
+  /**
+   * Get a snapshot of a registry (current or specific version).
+   * @param {string} registryId
+   * @param {string} [version]
+   */
+  async getSnapshot(e, t = null) {
+    let r = `/memory/ontology/registry/${e}/snapshot`;
+    return t && (r += `?version=${encodeURIComponent(t)}`), this.api.get(r);
+  }
+  /**
+   * Apply a changeset to create a new version of the registry.
+   * @param {string} registryId
+   * @param {Object} params
+   * @param {string} [params.baseVersion='']
+   * @param {Object} params.changeset - OntologyIR changeset
+   * @param {string} [params.message='']
+   */
+  async applyChangeset(e, { baseVersion: t = "", changeset: r, message: s = "" }) {
+    return this.api.post(`/memory/ontology/registry/${e}/apply`, {
+      base_version: t,
+      changeset: r,
+      message: s
+    });
+  }
+  /**
+   * List snapshots for a registry.
+   * @param {string} registryId
+   * @param {number} [limit=50]
+   */
+  async listSnapshots(e, t = 50) {
+    return this.api.get(`/memory/ontology/registry/${e}/snapshots?limit=${t}`);
+  }
+  /**
+   * Get change history for a registry.
+   * @param {string} registryId
+   * @param {number} [limit=50]
+   */
+  async getChangelog(e, t = 50) {
+    return this.api.get(`/memory/ontology/registry/${e}/changelog?limit=${t}`);
+  }
+  /**
+   * Rollback registry to a previous version.
+   * @param {string} registryId
+   * @param {Object} params
+   * @param {string} [params.targetVersion='']
+   * @param {string} [params.message='']
+   */
+  async rollbackRegistry(e, { targetVersion: t = "", message: r = "" }) {
+    return this.api.post(`/memory/ontology/registry/${e}/rollback`, {
+      target_version: t,
+      message: r
+    });
+  }
+  /**
+   * Export a registry snapshot.
+   * @param {string} registryId
+   * @param {string} [version]
+   */
+  async exportRegistry(e, t = null) {
+    let r = `/memory/ontology/registry/${e}/export`;
+    return t && (r += `?version=${encodeURIComponent(t)}`), this.api.get(r);
+  }
+  /**
+   * Import data into a registry.
+   * @param {string} registryId
+   * @param {Object} params
+   * @param {Object} params.data - Complete ontology data to import
+   * @param {string} [params.message='']
+   */
+  async importRegistry(e, { data: t, message: r = "" }) {
+    return this.api.post(`/memory/ontology/registry/${e}/import`, {
+      data: t,
+      message: r
+    });
+  }
+  // === ENRICHMENT & GROUNDING ===
+  /**
+   * List available enrichment providers.
+   */
+  async listEnrichmentProviders() {
+    return this.api.get("/memory/ontology/enrichment/providers");
+  }
+  /**
+   * Run enrichment operation using specified provider.
+   * @param {Object} params
+   * @param {string} [params.provider='wikipedia']
+   * @param {string[]} params.entities
+   */
+  async runEnrichment({ provider: e = "wikipedia", entities: t }) {
+    return this.api.post("/memory/ontology/enrichment/run", {
+      provider: e,
+      entities: t
+    });
+  }
+  /**
+   * Run grounding operation using specified grounder.
+   * @param {Object} params
+   * @param {string} [params.grounder='wikipedia']
+   * @param {string} params.itemId
+   * @param {string[]} params.candidates
+   */
+  async runGrounding({ grounder: e = "wikipedia", itemId: t, candidates: r }) {
+    return this.api.post("/memory/ontology/grounding/run", {
+      grounder: e,
+      item_id: t,
+      candidates: r
+    });
+  }
+  // === TEMPLATES ===
+  /**
+   * List all available ontology templates.
+   */
+  async listTemplates() {
+    return this.api.get("/memory/ontology/templates");
+  }
+  /**
+   * Preview template details.
+   * @param {string} templateId
+   */
+  async getTemplate(e) {
+    return this.api.get(`/memory/ontology/templates/${e}`);
+  }
+  /**
+   * Clone a template into the workspace as an independent ontology.
+   * @param {Object} params
+   * @param {string} params.templateId
+   * @param {string} params.targetName
+   */
+  async cloneTemplate({ templateId: e, targetName: t }) {
+    return this.api.post("/memory/ontology/templates/clone", {
+      template_id: e,
+      target_name: t
+    });
+  }
+  /**
+   * Save an existing ontology registry as a custom template.
+   * @param {Object} params
+   * @param {string} params.registryId
+   * @param {string} params.name
+   * @param {string} [params.description='']
+   */
+  async saveAsTemplate({ registryId: e, name: t, description: r = "" }) {
+    return this.api.post("/memory/ontology/templates", {
+      registry_id: e,
+      name: t,
+      description: r
+    });
+  }
+  /**
+   * Delete a custom template.
+   * @param {string} templateId
+   */
+  async deleteTemplate(e) {
+    return this.api.delete(`/memory/ontology/templates/${e}`);
+  }
+  // === PATTERNS ===
+  /**
+   * List entity patterns with stats for the current workspace.
+   */
+  async listPatterns() {
+    return this.api.get("/memory/ontology/patterns");
+  }
+  /**
+   * Manually add an entity pattern.
+   * @param {Object} params
+   * @param {string} params.name
+   * @param {string} params.entityType
+   * @param {number} [params.confidence=0.9]
+   * @param {boolean} [params.isGlobal=false]
+   */
+  async createPattern({ name: e, entityType: t, confidence: r = 0.9, isGlobal: s = !1 }) {
+    return this.api.post("/memory/ontology/patterns", {
+      name: e,
+      entity_type: t,
+      confidence: r,
+      is_global: s
+    });
+  }
+  /**
+   * Delete an entity pattern by name.
+   * @param {string} patternName
+   * @param {string} entityType
+   */
+  async deletePattern(e, t) {
+    return this.api.delete(`/memory/ontology/patterns/${e}?entity_type=${encodeURIComponent(t)}`);
+  }
+  // === STATUS & IMPORT/EXPORT ===
+  /**
+   * Get ontology convergence metrics.
+   */
+  async getStatus() {
+    return this.api.get("/memory/ontology/status");
+  }
+  /**
+   * Import OntologyIR data to seed or migrate the ontology.
+   * @param {Object} data
+   */
+  async importOntology(e) {
+    return this.api.post("/memory/ontology/import", { data: e });
+  }
+  /**
+   * Export the full ontology as a portable dict.
+   */
+  async exportOntology() {
+    return this.api.get("/memory/ontology/export");
+  }
+  // === LAYER ENDPOINTS (ontology_layers.py) ===
+  /**
+   * Subscribe an overlay ontology to a base ontology.
+   * @param {string} registryId
+   * @param {Object} params
+   * @param {string} params.baseRegistryId
+   * @param {string} [params.pinnedVersion]
+   */
+  async subscribe(e, { baseRegistryId: t, pinnedVersion: r = null }) {
+    return this.api.post(`/memory/ontology/registry/${e}/subscribe`, {
+      base_registry_id: t,
+      pinned_version: r
+    });
+  }
+  /**
+   * Detach from base - flatten visible base types into overlay.
+   * @param {string} registryId
+   */
+  async unsubscribe(e) {
+    return this.api.delete(`/memory/ontology/registry/${e}/subscribe`);
+  }
+  /**
+   * Pin subscription to a specific base version.
+   * @param {string} registryId
+   * @param {string} version
+   */
+  async pinVersion(e, t) {
+    return this.api.put(`/memory/ontology/registry/${e}/subscribe/pin`, {
+      version: t
+    });
+  }
+  /**
+   * Unpin - follow latest base version.
+   * @param {string} registryId
+   */
+  async unpinVersion(e) {
+    return this.api.delete(`/memory/ontology/registry/${e}/subscribe/pin`);
+  }
+  /**
+   * Get provenance map and layer counts for an ontology.
+   * @param {string} registryId
+   */
+  async getLayers(e) {
+    return this.api.get(`/memory/ontology/registry/${e}/layers`);
+  }
+  /**
+   * Compute diff between base and overlay layers.
+   * @param {string} registryId
+   */
+  async getLayerDiff(e) {
+    return this.api.get(`/memory/ontology/registry/${e}/layer-diff`);
+  }
+  /**
+   * Hide a base entity type from the merged view.
+   * @param {string} registryId
+   * @param {string} typeName
+   */
+  async hideType(e, t) {
+    return this.api.post(`/memory/ontology/registry/${e}/subscribe/hidden`, {
+      type_name: t
+    });
+  }
+  /**
+   * Unhide a previously hidden base entity type.
+   * @param {string} registryId
+   * @param {string} typeName
+   */
+  async unhideType(e, t) {
+    return this.api.delete(`/memory/ontology/registry/${e}/subscribe/hidden/${t}`);
+  }
+  // === ONTOLOGY UPDATE (ontology_update.py) ===
+  /**
+   * Get the ontology update configuration for this workspace.
+   */
+  async getUpdateConfig() {
+    return this.api.get("/memory/ontology/updates/config");
+  }
+  /**
+   * Update the ontology update configuration.
+   * @param {Object} updates
+   * @param {boolean} [updates.enabled]
+   * @param {string} [updates.schedule] - hourly|daily|manual
+   * @param {number} [updates.batchSize]
+   * @param {string} [updates.model]
+   */
+  async updateConfig(e) {
+    const t = {};
+    return e.enabled !== void 0 && (t.enabled = e.enabled), e.schedule !== void 0 && (t.schedule = e.schedule), e.batchSize !== void 0 && (t.batch_size = e.batchSize), e.model !== void 0 && (t.model = e.model), this.api.patch("/memory/ontology/updates/config", t);
+  }
+  /**
+   * Trigger a batch ontology update run.
+   * @param {Object} [options]
+   * @param {number} [options.batchSize]
+   */
+  async triggerUpdate({ batchSize: e = null } = {}) {
+    const t = {};
+    return e !== null && (t.batch_size = e), this.api.post("/memory/ontology/updates/trigger", t);
+  }
+  /**
+   * Get the status of the latest batch run.
+   */
+  async getUpdateStatus() {
+    return this.api.get("/memory/ontology/updates/status");
+  }
+  /**
+   * Get paginated history of batch runs.
+   * @param {Object} [options]
+   * @param {number} [options.page=1]
+   * @param {number} [options.pageSize=10]
+   */
+  async getUpdateHistory({ page: e = 1, pageSize: t = 10 } = {}) {
+    return this.api.get(`/memory/ontology/updates/history?page=${e}&page_size=${t}`);
+  }
+  /**
+   * Get ontology update statistics for this workspace.
+   * @param {Object} [options]
+   * @param {boolean} [options.history=false]
+   */
+  async getUpdateStats({ history: e = !1 } = {}) {
+    return this.api.get(`/memory/ontology/updates/stats?history=${e}`);
+  }
+}
+class G {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Get analytics feature status and environment capabilities.
+   */
+  async getStatus() {
+    return this.api.get("/memory/analytics/status");
+  }
+  /**
+   * Run concept drift detection over the specified time window.
+   * @param {number} [timeWindowDays=30]
+   */
+  async detectDrift(e = 30) {
+    return this.api.get(`/memory/analytics/drift?time_window_days=${e}`);
+  }
+  /**
+   * Run bias detection with optional sentiment/topic analysis.
+   * @param {Object} [options]
+   * @param {string[]} [options.protectedAttributes]
+   * @param {boolean} [options.sentimentAnalysis]
+   * @param {boolean} [options.topicAnalysis]
+   */
+  async detectBias({ protectedAttributes: e = null, sentimentAnalysis: t = null, topicAnalysis: r = null } = {}) {
+    const s = {};
+    return e !== null && (s.protected_attributes = e), t !== null && (s.sentiment_analysis = t), r !== null && (s.topic_analysis = r), this.api.post("/memory/analytics/bias", s);
+  }
+}
+class N {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Get graph health metrics: orphan ratio, type distribution, provenance coverage.
+   */
+  async getHealth() {
+    return this.api.get("/memory/graph/health");
+  }
+  /**
+   * Validate a memory item against schema and semantic rules.
+   * @param {string} itemId
+   */
+  async validateItem(e) {
+    return this.api.post("/memory/validation/validate", {
+      item_id: e
+    });
+  }
+  /**
+   * Run inference engine to create inferred edges from rules.
+   * @param {Object} [options]
+   * @param {boolean} [options.dryRun=false]
+   */
+  async runInference({ dryRun: e = !1 } = {}) {
+    return this.api.post("/memory/validation/inference", {
+      dry_run: e
+    });
+  }
+  /**
+   * List available inference rules.
+   */
+  async getInferenceRules() {
+    return this.api.get("/memory/validation/inference/rules");
+  }
+}
+class V {
+  constructor(e) {
+    this.api = e;
+  }
+  // === STAGE EXECUTION ===
+  /**
+   * Run extraction pipeline stage.
+   * @param {Object} request - ExtractionRequest
+   */
+  async runExtraction(e) {
+    return this.api.post("/memory/pipeline/extraction", e);
+  }
+  /**
+   * Run storage pipeline stage.
+   * @param {Object} request - StorageRequest
+   */
+  async runStorage(e) {
+    return this.api.post("/memory/pipeline/storage", e);
+  }
+  /**
+   * Run linking pipeline stage.
+   * @param {Object} request - LinkingRequest
+   */
+  async runLinking(e) {
+    return this.api.post("/memory/pipeline/linking", e);
+  }
+  /**
+   * Run enrichment pipeline stage.
+   * @param {Object} request - EnrichmentRequest
+   */
+  async runEnrichment(e) {
+    return this.api.post("/memory/pipeline/enrichment", e);
+  }
+  /**
+   * Run grounding pipeline stage.
+   * @param {Object} request - GroundingRequest
+   */
+  async runGrounding(e) {
+    return this.api.post("/memory/pipeline/grounding", e);
+  }
+  // === STATE MANAGEMENT ===
+  /**
+   * Get pipeline state for a specific pipeline and optional run.
+   * @param {string} pipelineId
+   * @param {string} [runId]
+   */
+  async getState(e, t = null) {
+    let r = `/memory/pipeline/${e}/state`;
+    return t && (r += `?run_id=${encodeURIComponent(t)}`), this.api.get(r);
+  }
+  /**
+   * Reset a pipeline, clearing its state.
+   * @param {string} pipelineId
+   */
+  async reset(e) {
+    return this.api.delete(`/memory/pipeline/${e}`);
+  }
+  /**
+   * Clear all stage states for a specific pipeline run.
+   * @param {string} pipelineId
+   * @param {string} runId
+   */
+  async clearRun(e, t) {
+    return this.api.delete(`/memory/pipeline/${e}/run/${t}`);
+  }
+  // === CONFIG MANAGEMENT ===
+  /**
+   * List named pipeline configs for the current workspace.
+   */
+  async listConfigs() {
+    return this.api.get("/memory/pipeline/configs");
+  }
+  /**
+   * Save a named pipeline config.
+   * @param {Object} params
+   * @param {string} params.name
+   * @param {string} [params.description='']
+   * @param {Object} params.config
+   */
+  async createConfig({ name: e, description: t = "", config: r }) {
+    return this.api.post("/memory/pipeline/configs", {
+      name: e,
+      description: t,
+      config: r
+    });
+  }
+  /**
+   * Load a named pipeline config.
+   * @param {string} configName
+   */
+  async getConfig(e) {
+    return this.api.get(`/memory/pipeline/configs/${e}`);
+  }
+  /**
+   * Update an existing pipeline config.
+   * @param {string} configName
+   * @param {Object} params
+   * @param {string} [params.name='']
+   * @param {string} [params.description='']
+   * @param {Object} [params.config={}]
+   */
+  async updateConfig(e, { name: t = "", description: r = "", config: s = {} }) {
+    return this.api.patch(`/memory/pipeline/configs/${e}`, {
+      name: t,
+      description: r,
+      config: s
+    });
+  }
+  /**
+   * Delete a named pipeline config.
+   * @param {string} configName
+   */
+  async deleteConfig(e) {
+    return this.api.delete(`/memory/pipeline/configs/${e}`);
+  }
+}
+class J {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Persist a conversation artifact and return its URI and content hash.
+   * @param {Object} params
+   * @param {string} params.conversationId
+   * @param {Object} params.payload
+   * @param {Object} [params.metadata={}]
+   */
+  async store({ conversationId: e, payload: t, metadata: r = {} }) {
+    return this.api.post("/memory/archive/store", {
+      conversation_id: e,
+      payload: t,
+      metadata: r
+    });
+  }
+  /**
+   * Retrieve a previously stored archive artifact by URI.
+   * @param {string} archiveUri
+   */
+  async get(e) {
+    return this.api.get(`/memory/archive/${e}`);
+  }
+}
+class W {
+  constructor(e) {
+    this.api = e;
+  }
+  // === BIDIRECTIONAL LINKING ===
+  /**
+   * Get notes that link TO this note (backlinks).
+   * @param {string} noteId
+   */
+  async getBacklinks(e) {
+    return this.api.get(`/memory/zettel/${e}/backlinks`);
+  }
+  /**
+   * Get notes this note links TO (forward links).
+   * @param {string} noteId
+   */
+  async getForwardLinks(e) {
+    return this.api.get(`/memory/zettel/${e}/forward-links`);
+  }
+  /**
+   * Get all connections (backlinks + forward links).
+   * @param {string} noteId
+   */
+  async getConnections(e) {
+    return this.api.get(`/memory/zettel/${e}/connections`);
+  }
+  // === EMERGENT STRUCTURE ===
+  /**
+   * Detect knowledge clusters in your Zettelkasten.
+   * @param {Object} [options]
+   * @param {number} [options.minSize=3]
+   * @param {string} [options.algorithm='louvain']
+   */
+  async getClusters({ minSize: e = 3, algorithm: t = "louvain" } = {}) {
+    return this.api.get(`/memory/zettel/clusters?min_size=${e}&algorithm=${t}`);
+  }
+  /**
+   * Find hub notes (highly connected notes).
+   * @param {Object} [options]
+   * @param {number} [options.minConnections=5]
+   * @param {number} [options.limit=20]
+   */
+  async getHubs({ minConnections: e = 5, limit: t = 20 } = {}) {
+    return this.api.get(`/memory/zettel/hubs?min_connections=${e}&limit=${t}`);
+  }
+  /**
+   * Find bridge notes (notes connecting different clusters).
+   * @param {number} [limit=20]
+   */
+  async getBridges(e = 20) {
+    return this.api.get(`/memory/zettel/bridges?limit=${e}`);
+  }
+  // === SERENDIPITOUS DISCOVERY ===
+  /**
+   * Find unexpected connections (serendipitous discovery).
+   * @param {string} noteId
+   * @param {Object} [options]
+   * @param {number} [options.maxDistance=3]
+   * @param {number} [options.minSurprise=0.5]
+   */
+  async getDiscoveries(e, { maxDistance: t = 3, minSurprise: r = 0.5 } = {}) {
+    return this.api.get(`/memory/zettel/${e}/discoveries?max_distance=${t}&min_surprise=${r}`);
+  }
+  /**
+   * Find paths between two notes.
+   * @param {string} noteId
+   * @param {string} targetId
+   * @param {number} [maxPaths=5]
+   */
+  async getPath(e, t, r = 5) {
+    return this.api.get(`/memory/zettel/${e}/path/${t}?max_paths=${r}`);
+  }
+  // === WIKILINK SUPPORT ===
+  /**
+   * Parse [[wikilinks]] in content.
+   * @param {string} content
+   * @param {boolean} [autoCreate=true]
+   */
+  async parseWikilinks(e, t = !0) {
+    return this.api.post(`/memory/zettel/wikilink/parse?auto_create=${t}`, e);
+  }
+  /**
+   * Resolve a wikilink to a note.
+   * @param {string} link
+   */
+  async resolveWikilink(e) {
+    return this.api.get(`/memory/zettel/wikilink/resolve?link=${encodeURIComponent(e)}`);
+  }
+  // === GRAPH VISUALIZATION ===
+  /**
+   * Get subgraph around a note (for visualization).
+   * @param {string} noteId
+   * @param {Object} [options]
+   * @param {number} [options.depth=2]
+   * @param {boolean} [options.includeMetadata=true]
+   */
+  async getSubgraph(e, { depth: t = 2, includeMetadata: r = !0 } = {}) {
+    return this.api.get(`/memory/zettel/${e}/graph?depth=${t}&include_metadata=${r}`);
+  }
+  // === ADDITIONAL DISCOVERY ===
+  /**
+   * Detect emerging concepts from connection patterns.
+   * @param {number} [limit=20]
+   */
+  async detectConceptEmergence(e = 20) {
+    return this.api.get(`/memory/zettel/concept-emergence?limit=${e}`);
+  }
+  /**
+   * Suggest related notes for serendipitous discovery.
+   * @param {string} noteId
+   * @param {number} [count=5]
+   */
+  async suggestRelated(e, t = 5) {
+    return this.api.get(`/memory/zettel/${e}/suggestions?count=${t}`);
+  }
+  /**
+   * Perform random walk for serendipitous discovery.
+   * @param {string} noteId
+   * @param {number} [length=5]
+   */
+  async randomWalk(e, t = 5) {
+    return this.api.get(`/memory/zettel/${e}/random-walk?length=${t}`);
+  }
+  // === QUERY FEATURES ===
+  /**
+   * Find notes by tag.
+   * @param {string} tag
+   * @param {number} [limit=100]
+   */
+  async findByTag(e, t = 100) {
+    return this.api.get(`/memory/zettel/by-tag/${encodeURIComponent(e)}?limit=${t}`);
+  }
+  /**
+   * Find notes by property.
+   * @param {string} key
+   * @param {string} value
+   * @param {number} [limit=100]
+   */
+  async findByProperty(e, t, r = 100) {
+    return this.api.get(`/memory/zettel/by-property?key=${encodeURIComponent(e)}&value=${encodeURIComponent(t)}&limit=${r}`);
+  }
+  /**
+   * Find notes mentioning an entity.
+   * @param {string} entityId
+   * @param {number} [limit=100]
+   */
+  async findMentioning(e, t = 100) {
+    return this.api.get(`/memory/zettel/mentioning/${e}?limit=${t}`);
+  }
+  /**
+   * Query notes by dynamic relation type.
+   * @param {string} sourceId
+   * @param {string} relationType
+   * @param {number} [limit=100]
+   */
+  async queryByRelation(e, t, r = 100) {
+    return this.api.get(`/memory/zettel/by-relation/${e}/${t}?limit=${r}`);
+  }
+}
+class Y {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * List procedure match history for the current workspace.
+   * @param {Object} params - Query parameters
+   * @param {string} [params.start_date] - ISO date string (inclusive)
+   * @param {string} [params.end_date] - ISO date string (inclusive)
+   * @param {string} [params.procedure_id] - Filter by procedure ID
+   * @param {string} [params.feedback] - Filter by feedback: "success" | "failure" | "neutral"
+   * @param {number} [params.limit=100] - Max records (1-1000)
+   */
+  async list(e = {}) {
+    const t = Object.fromEntries(
+      Object.entries(e).filter(([, s]) => s != null)
+    ), r = new URLSearchParams(t).toString();
+    return this.api.get(`/memory/procedures/matches${r ? "?" + r : ""}`);
+  }
+  /**
+   * Submit feedback for a procedure match.
+   * @param {string} matchId - The match ID (uuid)
+   * @param {string} feedback - One of "success", "failure", "neutral"
+   * @param {string} [note] - Optional explanation
+   */
+  async submitFeedback(e, t, r = null) {
+    const s = { feedback: t };
+    return r && (s.note = r), this.api.post(`/memory/procedures/matches/${e}/feedback`, s);
+  }
+  /**
+   * Get aggregated procedure match statistics.
+   */
+  async getStats() {
+    return this.api.get("/memory/procedures/matches/stats");
+  }
+}
+class Z {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * List procedure promotion candidates detected from working memory patterns.
+   * @param {Object} params - Query parameters
+   * @param {number} [params.min_score=0.6] - Minimum recommendation score (0-1)
+   * @param {number} [params.min_cluster_size=3] - Minimum items in cluster
+   * @param {number} [params.days_back=30] - Days to look back
+   * @param {number} [params.limit=20] - Max candidates to return
+   * @returns {Promise<Object>} Response containing candidates array
+   */
+  async list(e = {}) {
+    const t = Object.fromEntries(
+      Object.entries(e).filter(([, s]) => s != null)
+    ), r = new URLSearchParams(t).toString();
+    return this.api.get(`/memory/procedures/candidates${r ? "?" + r : ""}`);
+  }
+  /**
+   * Promote a candidate cluster to a new procedure.
+   * @param {string} clusterId - The cluster ID from list()
+   * @param {Object} options - Promotion options
+   * @param {string} [options.name] - Name for the procedure (uses suggested_name if omitted)
+   * @param {string} [options.description] - Description for the procedure
+   * @param {string} [options.procedure_type='extraction'] - Type of procedure
+   * @param {string} [options.preferred_profile='quick_extract'] - Pipeline profile
+   * @param {boolean} [options.remove_working_items=false] - Remove source items after promotion
+   * @returns {Promise<Object>} Response with procedure_id and status
+   */
+  async promote(e, t = {}) {
+    const r = {
+      name: t.name ?? null,
+      description: t.description ?? null,
+      procedure_type: t.procedure_type ?? "extraction",
+      preferred_profile: t.preferred_profile ?? "quick_extract",
+      remove_working_items: t.remove_working_items ?? !1
+    };
+    return this.api.post(`/memory/procedures/candidates/${e}/promote`, r);
+  }
+  /**
+   * Dismiss a candidate cluster from future recommendations.
+   * @param {string} clusterId - The cluster ID to dismiss
+   * @returns {Promise<Object>} Response with status and message
+   */
+  async dismiss(e) {
+    return this.api.delete(`/memory/procedures/candidates/${e}/dismiss`);
+  }
+}
+class X {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * List drift events with optional filters.
+   * @param {Object} params
+   * @param {string} [params.procedure_id] - Filter by procedure
+   * @param {boolean} [params.resolved] - Filter by resolution status
+   * @param {boolean} [params.breaking_only] - Only breaking changes
+   * @param {string} [params.start_date] - ISO 8601 range start
+   * @param {string} [params.end_date] - ISO 8601 range end
+   * @param {number} [params.limit=100] - Max results (1-1000)
+   * @returns {Promise<{workspace_id: string, record_count: number, records: Object[]}>}
+   */
+  async list(e = {}) {
+    const t = Object.fromEntries(
+      Object.entries(e).filter(([, s]) => s != null)
+    ), r = new URLSearchParams(t).toString();
+    return this.api.get(`/memory/procedures/drift${r ? "?" + r : ""}`);
+  }
+  /**
+   * Get a single drift event with full change details.
+   * @param {string} eventId - The drift event ID
+   * @returns {Promise<Object>} DriftEventDetail
+   */
+  async get(e) {
+    return this.api.get(`/memory/procedures/drift/${e}`);
+  }
+  /**
+   * Mark a drift event as resolved.
+   * @param {string} eventId - The drift event ID
+   * @param {string} [note] - Optional resolution note (max 500 chars)
+   * @returns {Promise<{status: string, event_id: string, resolved: boolean}>}
+   */
+  async resolve(e, t = null) {
+    const r = {};
+    return t != null && (r.note = t), this.api.post(`/memory/procedures/drift/${e}/resolve`, r);
+  }
+  /**
+   * Trigger a drift sweep across all procedures in the workspace.
+   * @returns {Promise<{workspace_id: string, procedures_checked: number, drift_detected: number, events_created: number}>}
+   */
+  async sweep() {
+    return this.api.post("/memory/procedures/drift/sweep", {});
+  }
+  /**
+   * List schema snapshots for a procedure.
+   * @param {string} procedureId - The procedure ID
+   * @returns {Promise<{workspace_id: string, procedure_id: string, record_count: number, snapshots: Object[]}>}
+   */
+  async listSnapshots(e) {
+    return this.api.get(`/memory/procedures/schemas/${e}`);
+  }
+}
+class Q {
+  constructor(e) {
+    this.api = e;
+  }
+  /**
+   * Fire a manual snapshot for the current workspace.
+   * Throws on 409 lock_held — concurrent /generate from the same workspace.
+   * @param {Object} [params]
+   * @param {string} [params.windowStart] ISO 8601 datetime string
+   * @param {boolean} [params.includeMarkdown=true]
+   */
+  async generate({ windowStart: e = null, includeMarkdown: t = !0 } = {}) {
+    return this.api.post("/memory/summary/generate", {
+      window_start: e,
+      include_markdown: t
+    });
+  }
+  /** Most recent snapshot for the current workspace, or null on 404. */
+  async latest() {
+    try {
+      return await this.api.get("/memory/summary/latest");
+    } catch (e) {
+      if ((e == null ? void 0 : e.status) === 404) return null;
+      throw e;
+    }
+  }
+  /** Specific snapshot by id, or null on 404. */
+  async get(e) {
+    try {
+      return await this.api.get(`/memory/summary/${e}`);
+    } catch (t) {
+      if ((t == null ? void 0 : t.status) === 404) return null;
+      throw t;
+    }
+  }
+  /** Fast-path graph-only markdown for a snapshot. */
+  async getMarkdown(e) {
+    try {
+      return await this.api.get(`/memory/summary/${e}/markdown`);
+    } catch (t) {
+      if ((t == null ? void 0 : t.status) === 404) return null;
+      throw t;
+    }
+  }
+  /**
+   * List snapshots for the current workspace, newest first.
+   * @param {Object} [params]
+   * @param {boolean|null} [params.isHeartbeat]
+   * @param {number} [params.limit=20]
+   * @param {string} [params.before] ISO 8601 datetime
+   */
+  async list({ isHeartbeat: e = null, limit: t = 20, before: r = null } = {}) {
+    const s = { limit: t };
+    return e !== null && (s.is_heartbeat = e), r !== null && (s.before = r), this.api.get("/memory/summary/list", s);
+  }
+  /** SnapshotDelta between two snapshots. Returns null on 404. */
+  async delta({ from: e, to: t }) {
+    try {
+      return await this.api.get("/memory/summary/delta", {
+        from: e,
+        to: t
+      });
+    } catch (r) {
+      if ((r == null ? void 0 : r.status) === 404) return null;
+      throw r;
+    }
+  }
+  /** Admin-only delete. Throws on 403/404/500. */
+  async delete(e) {
+    return this.api.delete(`/memory/summary/${e}`);
+  }
+}
+class te {
+  constructor(e) {
+    this.auth = new v(e);
+    const t = new A(this.auth, { fetchFn: e.fetchFn });
+    this.memories = new R(t), this.decisions = new U(t), this.graph = new C(t), this.teams = new P(t), this.profiles = new M(t), this.subscriptions = new L(t), this.authAPI = new z(t), this.agents = new E(t), this.usage = new x(t), this.insights = new O(t), this.tokenUsage = new q(t), this.temporal = new F(t), this.governance = new H(t), this.evolution = new j(t), this.reasoning = new K(t), this.reasoningTraces = new B(t), this.ontology = new D(t), this.analytics = new G(t), this.validation = new N(t), this.pipeline = new V(t), this.archive = new J(t), this.zettelkasten = new W(t), this.procedureMatches = new Y(t), this.procedureCandidates = new Z(t), this.procedureDrift = new X(t), this.summaries = new Q(t);
+  }
+  setTeamId(e) {
+    this.auth.tokenManager.setTeamId(e), this.auth.notifyListeners();
+  }
+  getTeamId() {
+    return this.auth.tokenManager.getTeamId();
+  }
+}
+export {
+  h as A,
+  A as B,
+  U as D,
+  j as E,
+  H as G,
+  O as I,
+  R as M,
+  D as O,
+  V as P,
+  K as R,
+  te as S,
+  P as T,
+  x as U,
+  N as V,
+  W as Z,
+  E as a,
+  G as b,
+  J as c,
+  z as d,
+  v as e,
+  C as f,
+  Z as g,
+  Y as h,
+  M as i,
+  B as j,
+  L as k,
+  F as l,
+  I as m,
+  q as n,
+  T as o,
+  S as p
+};