@prismer/sdk 1.7.1 → 1.7.4

package/dist/index.mjs

@@ -196,10 +196,11 @@ var RealtimeWSClient = class extends TypedEmitter {
   joinConversation(conversationId) {
     this.sendRaw({ type: "conversation.join", payload: { conversationId } });
   }
-  sendMessage(conversationId, content, type = "text") {
+  sendMessage(conversationId, content, options) {
+    const opts = typeof options === "string" ? { type: options } : options;
     this.sendRaw({
       type: "message.send",
-      payload: { conversationId, content, type },
+      payload: { conversationId, content, type: opts?.type ?? "text", ...opts?.metadata ? { metadata: opts.metadata } : {}, ...opts?.parentId ? { parentId: opts.parentId } : {} },
       requestId: `msg-${++this.pingCounter}`
     });
   }
@@ -1206,6 +1207,28 @@ var ENVIRONMENTS = {
   production: "https://prismer.cloud"
 };
 
+// src/aip.ts
+import {
+  AIPIdentity
+} from "@prismer/aip-sdk";
+import {
+  publicKeyToDIDKey,
+  didKeyToPublicKey,
+  validateDIDKey
+} from "@prismer/aip-sdk";
+import {
+  buildCredential,
+  buildPresentation,
+  verifyCredential,
+  verifyPresentation
+} from "@prismer/aip-sdk";
+import {
+  buildDelegation,
+  buildEphemeralDelegation,
+  verifyDelegation,
+  verifyEphemeralDelegation
+} from "@prismer/aip-sdk";
+
 // src/storage.ts
 var MemoryStorage = class {
   constructor() {
@@ -2090,20 +2113,27 @@ var PBKDF2_ITERATIONS = 1e5;
 var SALT_LENGTH = 16;
 var IV_LENGTH = 12;
 var KEY_LENGTH = 256;
-var E2EEncryption = class {
+var _E2EEncryption = class _E2EEncryption {
   constructor() {
     this.masterKey = null;
     this.keyPair = null;
     this.sessionKeys = /* @__PURE__ */ new Map();
     // conversationId → AES key
     this.salt = null;
+    // ─── Pipeline Functions ──────────────────────────────────
+    this.messageCount = 0;
+    this.lastRotation = Date.now();
   }
   /**
    * Initialize encryption with user passphrase.
    * Derives a master key via PBKDF2 and generates an ECDH key pair.
+   *
+   * @param passphrase - User passphrase for master key derivation
+   * @param salt - Optional Base64-encoded salt. If omitted, a random 16-byte salt is generated.
+   *               Store the salt (via exportSalt()) so you can re-derive the same master key later.
    */
-  async init(passphrase) {
-    this.salt = getRandomValues(new Uint8Array(SALT_LENGTH));
+  async init(passphrase, salt) {
+    this.salt = salt ? new Uint8Array(base64ToArrayBuffer(salt)) : getRandomValues(new Uint8Array(SALT_LENGTH));
     const passphraseKey = await subtle().importKey(
       "raw",
       new TextEncoder().encode(passphrase),
@@ -2114,7 +2144,7 @@ var E2EEncryption = class {
     this.masterKey = await subtle().deriveKey(
       {
         name: "PBKDF2",
-        salt: this.salt,
+        salt: new Uint8Array(this.salt.buffer, this.salt.byteOffset, this.salt.byteLength).buffer,
         iterations: PBKDF2_ITERATIONS,
         hash: "SHA-256"
       },
@@ -2129,6 +2159,14 @@ var E2EEncryption = class {
       ["deriveKey"]
     );
   }
+  /**
+   * Export the salt as Base64 string for persistent storage.
+   * You must store this and pass it back to init() to re-derive the same master key.
+   */
+  exportSalt() {
+    if (!this.salt) throw new Error("E2E not initialized. Call init() first.");
+    return arrayBufferToBase64(this.salt.buffer);
+  }
   /**
    * Export public key for sharing with conversation peers.
    */
@@ -2241,8 +2279,93 @@ var E2EEncryption = class {
     this.keyPair = null;
     this.sessionKeys.clear();
     this.salt = null;
+    this.messageCount = 0;
+  }
+  /**
+   * High-level encrypt-for-send pipeline.
+   * Encrypts content, builds metadata, and handles key rotation.
+   *
+   * Returns { encryptedContent, metadata } ready to send.
+   */
+  async encryptForSend(conversationId, content) {
+    if (!this.hasSessionKey(conversationId)) {
+      throw new Error("No session key for this conversation. Call deriveSessionKey() first.");
+    }
+    const needsRotation = this.shouldRotateKey();
+    const encryptedContent = await this.encrypt(conversationId, content);
+    this.messageCount++;
+    return {
+      encryptedContent,
+      metadata: {
+        encrypted: true,
+        encryptionVersion: 1,
+        ...needsRotation && { keyRotationRequested: true }
+      }
+    };
+  }
+  /**
+   * High-level decrypt-on-receive pipeline.
+   * Decrypts content and validates metadata.
+   */
+  async decryptOnReceive(conversationId, encryptedContent, metadata) {
+    if (!this.hasSessionKey(conversationId)) {
+      throw new Error("No session key for this conversation. Call deriveSessionKey() first.");
+    }
+    return this.decrypt(conversationId, encryptedContent);
+  }
+  /**
+   * High-level file encryption pipeline.
+   */
+  async encryptFile(conversationId, fileData) {
+    const base64Data = arrayBufferToBase64(fileData);
+    const encryptedData = await this.encrypt(conversationId, base64Data);
+    return {
+      encryptedData,
+      metadata: {
+        encrypted: true,
+        encryptionVersion: 1,
+        fileEncrypted: true
+      }
+    };
+  }
+  /**
+   * High-level file decryption pipeline.
+   */
+  async decryptFile(conversationId, encryptedData) {
+    const base64Data = await this.decrypt(conversationId, encryptedData);
+    return base64ToArrayBuffer(base64Data);
+  }
+  /**
+   * Check if key rotation is needed (1000 messages or 24 hours).
+   */
+  shouldRotateKey() {
+    if (this.messageCount >= _E2EEncryption.KEY_ROTATION_THRESHOLD) {
+      return true;
+    }
+    if (Date.now() - this.lastRotation >= _E2EEncryption.KEY_ROTATION_INTERVAL_MS) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Perform key rotation: generate new ECDH keypair and reset counters.
+   * The caller is responsible for re-exchanging keys with peers.
+   */
+  async rotateKeys() {
+    this.keyPair = await subtle().generateKey(
+      { name: "ECDH", namedCurve: "P-256" },
+      false,
+      ["deriveKey"]
+    );
+    this.messageCount = 0;
+    this.lastRotation = Date.now();
+    this.sessionKeys.clear();
+    return this.exportPublicKey();
   }
 };
+_E2EEncryption.KEY_ROTATION_THRESHOLD = 1e3;
+_E2EEncryption.KEY_ROTATION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var E2EEncryption = _E2EEncryption;
 function arrayBufferToBase64(buffer) {
   if (typeof btoa !== "undefined") {
     const bytes = new Uint8Array(buffer);
@@ -2267,6 +2390,548 @@ function base64ToArrayBuffer(base64) {
   return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
 }
 
+// src/encryption-pipeline.ts
+async function encryptForSend(e2e, conversationId, content, metadata) {
+  if (!e2e.hasSessionKey(conversationId)) {
+    return { content, metadata: metadata ?? {} };
+  }
+  const ciphertext = await e2e.encrypt(conversationId, content);
+  return {
+    content: ciphertext,
+    metadata: { ...metadata, encrypted: true, encKeyId: `conv-${conversationId}` }
+  };
+}
+async function decryptOnReceive(e2e, conversationId, content, metadata) {
+  if (!metadata?.encrypted) {
+    return { content, decrypted: false };
+  }
+  if (!e2e.hasSessionKey(conversationId)) {
+    return { content, decrypted: false, error: "no_session_key" };
+  }
+  try {
+    const plain = await e2e.decrypt(conversationId, content);
+    return { content: plain, decrypted: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { content, decrypted: false, error: message };
+  }
+}
+async function encryptFile(e2e, conversationId, data) {
+  if (!e2e.hasSessionKey(conversationId)) return null;
+  const b64 = typeof Buffer !== "undefined" ? Buffer.from(data).toString("base64") : uint8ArrayToBase64(data);
+  const ciphertext = await e2e.encrypt(conversationId, b64);
+  return {
+    data: ciphertext,
+    metadata: { encrypted: true, encKeyId: `conv-${conversationId}` }
+  };
+}
+async function decryptFile(e2e, conversationId, ciphertext) {
+  if (!e2e.hasSessionKey(conversationId)) return null;
+  try {
+    const b64 = await e2e.decrypt(conversationId, ciphertext);
+    if (typeof Buffer !== "undefined") {
+      return new Uint8Array(Buffer.from(b64, "base64"));
+    }
+    return base64ToUint8Array(b64);
+  } catch {
+    return null;
+  }
+}
+async function encryptContext(e2e, content, contextId = "context-cache") {
+  if (!e2e.hasSessionKey(contextId)) return null;
+  const ciphertext = await e2e.encrypt(contextId, content);
+  return { content: ciphertext, encrypted: true };
+}
+async function decryptContext(e2e, ciphertext, contextId = "context-cache") {
+  if (!e2e.hasSessionKey(contextId)) return null;
+  try {
+    return await e2e.decrypt(contextId, ciphertext);
+  } catch {
+    return null;
+  }
+}
+async function decryptMessages(e2e, messages, conversationId) {
+  let decryptedCount = 0;
+  const errors = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const convId = conversationId ?? msg.conversationId;
+    if (!convId) continue;
+    const result = await decryptOnReceive(e2e, convId, msg.content, msg.metadata);
+    if (result.decrypted) {
+      msg.content = result.content;
+      if (msg.metadata) {
+        msg.metadata._decrypted = true;
+      }
+      decryptedCount++;
+    } else if (result.error) {
+      errors.push({ index: i, error: result.error });
+    }
+  }
+  return { decryptedCount, errors };
+}
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/evolution-cache.ts
+var EvolutionCache = class {
+  constructor() {
+    this._genes = /* @__PURE__ */ new Map();
+    this._edges = /* @__PURE__ */ new Map();
+    // key = signal_key
+    this._globalPrior = /* @__PURE__ */ new Map();
+    this._cursor = 0;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  get geneCount() {
+    return this._genes.size;
+  }
+  /** Load from a full snapshot */
+  loadSnapshot(snapshot) {
+    this._genes.clear();
+    this._edges.clear();
+    this._globalPrior.clear();
+    for (const gene of snapshot.genes) {
+      this._genes.set(gene.id, gene);
+    }
+    for (const edge of snapshot.edges) {
+      const list = this._edges.get(edge.signal_key) ?? [];
+      list.push(edge);
+      this._edges.set(edge.signal_key, list);
+    }
+    for (const [key, val] of Object.entries(snapshot.globalPrior)) {
+      this._globalPrior.set(key, val);
+    }
+    this._cursor = snapshot.cursor;
+  }
+  /** Apply incremental delta (alias: loadDelta) */
+  applyDelta(delta) {
+    const pulled = delta.pulled;
+    for (const gene of pulled.genes) {
+      this._genes.set(gene.id, gene);
+    }
+    for (const id of pulled.quarantines) {
+      this._genes.delete(id);
+    }
+    for (const edge of pulled.edges) {
+      const list = this._edges.get(edge.signal_key) ?? [];
+      const idx = list.findIndex((e) => e.gene_id === edge.gene_id);
+      if (idx >= 0) list[idx] = edge;
+      else list.push(edge);
+      this._edges.set(edge.signal_key, list);
+    }
+    for (const [key, val] of Object.entries(pulled.globalPrior)) {
+      this._globalPrior.set(key, val);
+    }
+    this._cursor = pulled.cursor;
+  }
+  /** Apply incremental delta (alias for applyDelta) */
+  loadDelta(delta) {
+    this.applyDelta(delta);
+  }
+  /** Select best gene locally using Thompson Sampling — pure CPU, <1ms */
+  selectGene(signals) {
+    if (this._genes.size === 0) {
+      return { action: "none", confidence: 0, reason: "no genes in cache", fromCache: true };
+    }
+    const signalKeys = signals.map((s) => s.type);
+    const candidates = [];
+    for (const gene of this._genes.values()) {
+      if (gene.visibility === "quarantined") continue;
+      const geneSignalTypes = (gene.signals_match || []).map(
+        (s) => typeof s === "string" ? s : s.type
+      );
+      if (geneSignalTypes.length === 0) continue;
+      const matchCount = signalKeys.filter((k) => geneSignalTypes.includes(k)).length;
+      const coverageScore = matchCount / geneSignalTypes.length;
+      if (coverageScore === 0) continue;
+      let alpha = gene.success_count + 1;
+      let beta = gene.failure_count + 1;
+      for (const key of signalKeys) {
+        const prior = this._globalPrior.get(key);
+        if (prior) {
+          alpha += 0.3 * prior.alpha;
+          beta += 0.3 * prior.beta;
+        }
+      }
+      const sampledScore = alpha / (alpha + beta);
+      const totalObs = gene.success_count + gene.failure_count;
+      if (totalObs >= 10 && gene.success_count / totalObs < 0.18) continue;
+      const rankScore = coverageScore * 0.4 + sampledScore * 0.6;
+      candidates.push({ gene, rankScore, coverageScore, sampledScore });
+    }
+    if (candidates.length === 0) {
+      return {
+        action: "create_suggested",
+        confidence: 0,
+        reason: "no matching genes for signals",
+        fromCache: true
+      };
+    }
+    candidates.sort((a, b) => b.rankScore - a.rankScore);
+    const best = candidates[0];
+    const alternatives = candidates.slice(1, 4).map((c) => ({
+      gene_id: c.gene.id,
+      confidence: Math.round(c.rankScore * 100) / 100,
+      title: c.gene.title
+    }));
+    return {
+      action: "apply_gene",
+      gene_id: best.gene.id,
+      gene: best.gene,
+      strategy: best.gene.strategy,
+      confidence: Math.round(best.rankScore * 100) / 100,
+      coverageScore: Math.round(best.coverageScore * 100) / 100,
+      alternatives,
+      reason: `local cache selection (${this._genes.size} genes)`,
+      fromCache: true
+    };
+  }
+};
+
+// src/signal-enrichment.ts
+var ERROR_PATTERNS = [
+  { pattern: /timeout|timed?\s*out|deadline\s*exceeded|context\s*deadline/i, type: "timeout" },
+  { pattern: /econnrefused|connection\s*refused/i, type: "connection_refused" },
+  { pattern: /enotfound|dns|getaddrinfo|resolve/i, type: "dns_error" },
+  { pattern: /rate\s*limit|too\s*many\s*requests|429/i, type: "rate_limit" },
+  { pattern: /401|unauthorized|unauthenticated|auth.*fail/i, type: "auth_error" },
+  { pattern: /403|forbidden|access\s*denied|permission/i, type: "permission_error" },
+  { pattern: /404|not\s*found/i, type: "not_found" },
+  { pattern: /5\d{2}|internal\s*server|server\s*error|502|503|504/i, type: "server_error" },
+  { pattern: /type\s*error|typeerror/i, type: "type_error" },
+  { pattern: /syntax\s*error|syntaxerror|unexpected\s*token/i, type: "syntax_error" },
+  { pattern: /reference\s*error|referenceerror|is\s*not\s*defined/i, type: "reference_error" },
+  { pattern: /out\s*of\s*memory|oom|heap|allocation\s*failed/i, type: "oom" },
+  { pattern: /crash|panic|segfault|sigsegv|sigabrt/i, type: "crash" },
+  { pattern: /quota|limit\s*exceeded|insufficient/i, type: "quota_exceeded" },
+  { pattern: /tls|ssl|certificate|cert\s*verify/i, type: "tls_error" },
+  { pattern: /deadlock|lock\s*timeout|lock\s*wait/i, type: "deadlock" }
+];
+function extractSignals(ctx) {
+  const tags = [];
+  if (ctx.error) {
+    let matched = false;
+    for (const { pattern, type } of ERROR_PATTERNS) {
+      if (pattern.test(ctx.error)) {
+        const tag = { type: `error:${type}` };
+        if (ctx.provider) tag.provider = ctx.provider;
+        if (ctx.stage) tag.stage = ctx.stage;
+        if (ctx.severity) tag.severity = ctx.severity;
+        tags.push(tag);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      const normalized = ctx.error.slice(0, 50).toLowerCase().replace(/[^a-z0-9_]/g, "_");
+      const tag = { type: `error:${normalized}` };
+      if (ctx.provider) tag.provider = ctx.provider;
+      if (ctx.stage) tag.stage = ctx.stage;
+      tags.push(tag);
+    }
+  }
+  if (ctx.taskStatus === "failed") tags.push({ type: "task.failed" });
+  if (ctx.taskStatus === "completed") tags.push({ type: "task.completed" });
+  if (ctx.taskCapability) {
+    tags.push({ type: `capability:${ctx.taskCapability}` });
+  }
+  if (ctx.tags) {
+    for (const tag of ctx.tags) {
+      tags.push({ type: tag });
+    }
+  }
+  return tags;
+}
+function createEnrichedExtractor(config) {
+  if (config.mode === "rules") {
+    return async (ctx) => extractSignals(ctx);
+  }
+  const { llmExtract, timeoutMs = 3e3 } = config;
+  if (!llmExtract) return async (ctx) => extractSignals(ctx);
+  return async (ctx) => {
+    try {
+      const result = await Promise.race([
+        llmExtract(ctx),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("llm_timeout")), timeoutMs)
+        )
+      ]);
+      return result;
+    } catch {
+      return extractSignals(ctx);
+    }
+  };
+}
+
+// src/evolution-runtime.ts
+var EvolutionRuntime = class {
+  constructor(client, config) {
+    this.client = client;
+    this.outbox = [];
+    this.started = false;
+    // Session tracking
+    this._sessions = [];
+    this._sessionCounter = 0;
+    this.config = {
+      syncIntervalMs: config?.syncIntervalMs ?? 6e4,
+      enrichment: config?.enrichment ?? { mode: "rules" },
+      scope: config?.scope ?? "global",
+      outboxMaxSize: config?.outboxMaxSize ?? 50,
+      outboxFlushMs: config?.outboxFlushMs ?? 5e3
+    };
+    this.scope = this.config.scope;
+    this.cache = new EvolutionCache();
+    this.enricher = config?.enrichment ? createEnrichedExtractor(config.enrichment) : async (ctx) => extractSignals(ctx);
+  }
+  // ─── Lifecycle ──────────────────────────────────────
+  /** Initialize: load snapshot + start sync + start outbox flush */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    try {
+      const snapshot = await this.client.getSyncSnapshot(0);
+      if (snapshot.data) {
+        this.cache.loadSnapshot(snapshot.data);
+      }
+    } catch {
+    }
+    if (this.config.syncIntervalMs > 0) {
+      this.syncTimer = setInterval(() => this.sync(), this.config.syncIntervalMs);
+    }
+    this.flushTimer = setInterval(() => this.flush(), this.config.outboxFlushMs);
+  }
+  /** Stop: clear timers + flush remaining outbox */
+  async stop() {
+    if (this.syncTimer) clearInterval(this.syncTimer);
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    await this.flush();
+    this.started = false;
+  }
+  // ─── High-Level API ─────────────────────────────────
+  /**
+   * Get a strategy recommendation for an error/context.
+   *
+   * Flow: extract signals → try local cache (<1ms) → fallback to server (~30ms)
+   *
+   * @param error - Error message or Error object
+   * @param context - Optional additional context (provider, stage, etc.)
+   */
+  async suggest(error, context) {
+    const errorStr = error instanceof Error ? error.message : error;
+    const ctx = {
+      error: errorStr,
+      ...context
+    };
+    const signals = await this.enricher(ctx);
+    if (signals.length === 0) {
+      return {
+        action: "none",
+        confidence: 0,
+        signals: [],
+        fromCache: false,
+        reason: "no signals extracted from error"
+      };
+    }
+    const buildSuggestion = (action, geneId, gene, strategy, confidence, fromCache, reason, alternatives) => {
+      this.lastSuggestedGeneId = geneId;
+      this._activeSession = {
+        id: `ses_${++this._sessionCounter}_${Date.now()}`,
+        suggestedAt: Date.now(),
+        suggestedGeneId: geneId,
+        signals,
+        adopted: false,
+        confidence,
+        fromCache
+      };
+      return {
+        action,
+        geneId,
+        gene,
+        strategy,
+        confidence,
+        signals,
+        fromCache,
+        reason,
+        alternatives
+      };
+    };
+    if (this.cache.geneCount > 0) {
+      const local = this.cache.selectGene(signals);
+      if (local.action === "apply_gene" && local.confidence > 0.3) {
+        return buildSuggestion(
+          local.action,
+          local.gene_id,
+          local.gene,
+          local.strategy,
+          local.confidence,
+          true,
+          local.reason,
+          local.alternatives
+        );
+      }
+    }
+    try {
+      const result = await this.client.analyze({
+        signals,
+        scope: this.scope
+      });
+      if (result.data) {
+        return buildSuggestion(
+          result.data.action,
+          result.data.gene_id,
+          result.data.gene,
+          result.data.strategy,
+          result.data.confidence ?? 0,
+          false,
+          result.data.reason,
+          result.data.alternatives
+        );
+      }
+    } catch {
+      const local = this.cache.selectGene(signals);
+      return buildSuggestion(
+        local.action,
+        local.gene_id,
+        local.gene,
+        local.strategy,
+        local.confidence,
+        true,
+        "server unreachable, using cache fallback",
+        local.alternatives
+      );
+    }
+    return {
+      action: "none",
+      confidence: 0,
+      signals,
+      fromCache: false,
+      reason: "no recommendation from server"
+    };
+  }
+  /**
+   * Record an outcome. Fire-and-forget — never blocks, never throws.
+   *
+   * @param error - The error that was encountered
+   * @param outcome - 'success' or 'failed'
+   * @param summary - One-line summary of what happened
+   * @param geneId - Gene that was used (auto-detected from last suggest() if omitted)
+   */
+  learned(error, outcome, summary, geneId, metadata) {
+    const errorStr = error instanceof Error ? error.message : error;
+    const ctx = { error: errorStr };
+    const signals = extractSignals(ctx);
+    const resolvedGeneId = geneId || this.lastSuggestedGeneId;
+    if (!resolvedGeneId) return;
+    if (this._activeSession) {
+      const session = this._activeSession;
+      session.usedGeneId = resolvedGeneId;
+      session.adopted = resolvedGeneId === session.suggestedGeneId;
+      session.completedAt = Date.now();
+      session.outcome = outcome;
+      session.durationMs = session.completedAt - session.suggestedAt;
+      this._sessions.push(session);
+      this._activeSession = void 0;
+    }
+    this.outbox.push({
+      geneId: resolvedGeneId,
+      signals,
+      outcome,
+      summary,
+      metadata,
+      timestamp: Date.now(),
+      sessionId: this._sessions[this._sessions.length - 1]?.id
+    });
+    if (this.outbox.length >= this.config.outboxMaxSize) {
+      this.flush().catch(() => {
+      });
+    }
+  }
+  // ─── Session Metrics ────────────────────────────────
+  /** Get all completed sessions. */
+  get sessions() {
+    return this._sessions;
+  }
+  /** Get aggregate metrics for benchmarking. */
+  getMetrics() {
+    const sessions = this._sessions;
+    const totalSuggestions = sessions.length;
+    const suggestionsWithGene = sessions.filter((s) => s.suggestedGeneId).length;
+    const totalLearned = sessions.filter((s) => s.completedAt).length;
+    const adoptedSessions = sessions.filter((s) => s.adopted && s.completedAt);
+    const adoptedCount = adoptedSessions.length;
+    const nonAdopted = sessions.filter((s) => !s.adopted && s.completedAt);
+    const durations = sessions.filter((s) => s.durationMs != null).map((s) => s.durationMs);
+    const avgDurationMs = durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0;
+    const adoptedSuccess = adoptedSessions.filter((s) => s.outcome === "success").length;
+    const nonAdoptedSuccess = nonAdopted.filter((s) => s.outcome === "success").length;
+    const cacheHits = sessions.filter((s) => s.fromCache).length;
+    return {
+      totalSuggestions,
+      suggestionsWithGene,
+      totalLearned,
+      adoptedCount,
+      geneUtilizationRate: suggestionsWithGene > 0 ? Math.round(adoptedCount / suggestionsWithGene * 100) / 100 : 0,
+      avgDurationMs,
+      adoptedSuccessRate: adoptedCount > 0 ? Math.round(adoptedSuccess / adoptedCount * 100) / 100 : 0,
+      nonAdoptedSuccessRate: nonAdopted.length > 0 ? Math.round(nonAdoptedSuccess / nonAdopted.length * 100) / 100 : 0,
+      cacheHitRate: totalSuggestions > 0 ? Math.round(cacheHits / totalSuggestions * 100) / 100 : 0
+    };
+  }
+  /** Reset session history. */
+  resetMetrics() {
+    this._sessions = [];
+  }
+  // ─── Internal ───────────────────────────────────────
+  /** Sync cache with server */
+  async sync() {
+    try {
+      const result = await this.client.sync({
+        pull: { since: this.cache.cursor },
+        scope: this.scope
+      });
+      if (result.data?.pulled) {
+        this.cache.applyDelta({ pulled: result.data.pulled });
+      }
+    } catch {
+    }
+  }
+  /** Flush outbox to server */
+  async flush() {
+    if (this.outbox.length === 0) return;
+    const batch = this.outbox.splice(0, this.config.outboxMaxSize);
+    const promises = batch.map(
+      (entry) => this.client.record({
+        gene_id: entry.geneId,
+        signals: entry.signals.map((s) => s.type),
+        outcome: entry.outcome,
+        summary: entry.summary,
+        score: entry.score,
+        metadata: entry.metadata,
+        scope: this.scope
+      }).catch(() => {
+        this.outbox.push(entry);
+      })
+    );
+    await Promise.allSettled(promises);
+  }
+};
+
 // src/index.ts
 var AccountClient = class {
   constructor(_r) {
@@ -2392,8 +3057,8 @@ var MessagesClient = class {
     return this._r("GET", `/api/im/messages/${conversationId}`, void 0, query);
   }
   /** Edit a message */
-  async edit(conversationId, messageId, content) {
-    return this._r("PATCH", `/api/im/messages/${conversationId}/${messageId}`, { content });
+  async edit(conversationId, messageId, content, options) {
+    return this._r("PATCH", `/api/im/messages/${conversationId}/${messageId}`, { content, ...options?.metadata ? { metadata: options.metadata } : {} });
   }
   /** Delete a message */
   async delete(conversationId, messageId) {
@@ -2480,6 +3145,560 @@ var WorkspaceClient = class {
     return this._r("GET", "/api/im/workspace/mentions/autocomplete", void 0, q);
   }
 };
+var TasksClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Create a new task */
+  async create(options) {
+    return this._r("POST", "/api/im/tasks", options);
+  }
+  /** List tasks with optional filters */
+  async list(options) {
+    const query = {};
+    if (options?.status) query.status = options.status;
+    if (options?.capability) query.capability = options.capability;
+    if (options?.assigneeId) query.assigneeId = options.assigneeId;
+    if (options?.creatorId) query.creatorId = options.creatorId;
+    if (options?.scheduleType) query.scheduleType = options.scheduleType;
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.cursor) query.cursor = options.cursor;
+    return this._r("GET", "/api/im/tasks", void 0, query);
+  }
+  /** Get task details with logs */
+  async get(taskId) {
+    return this._r("GET", `/api/im/tasks/${taskId}`);
+  }
+  /** Update a task */
+  async update(taskId, options) {
+    return this._r("PATCH", `/api/im/tasks/${taskId}`, options);
+  }
+  /** Claim a pending task */
+  async claim(taskId) {
+    return this._r("POST", `/api/im/tasks/${taskId}/claim`);
+  }
+  /** Report progress on a task */
+  async progress(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/progress`, options);
+  }
+  /** Complete a task with result */
+  async complete(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/complete`, options);
+  }
+  /** Fail a task with error */
+  async fail(taskId, error, metadata) {
+    return this._r("POST", `/api/im/tasks/${taskId}/fail`, { error, metadata });
+  }
+};
+var MemoryClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Create a memory file */
+  async createFile(options) {
+    return this._r("POST", "/api/im/memory/files", options);
+  }
+  /** List memory files */
+  async listFiles(options) {
+    const query = {};
+    if (options?.scope) query.scope = options.scope;
+    if (options?.path) query.path = options.path;
+    return this._r("GET", "/api/im/memory/files", void 0, query);
+  }
+  /** Get a memory file by ID */
+  async getFile(fileId) {
+    return this._r("GET", `/api/im/memory/files/${fileId}`);
+  }
+  /** Update a memory file (append, replace, or replace_section) */
+  async updateFile(fileId, options) {
+    return this._r("PATCH", `/api/im/memory/files/${fileId}`, options);
+  }
+  /** Delete a memory file */
+  async deleteFile(fileId) {
+    return this._r("DELETE", `/api/im/memory/files/${fileId}`);
+  }
+  /** Compact conversation messages into a summary */
+  async compact(options) {
+    return this._r("POST", "/api/im/memory/compact", options);
+  }
+  /** Get compaction summaries for a conversation */
+  async getCompaction(conversationId) {
+    return this._r("GET", `/api/im/memory/compact/${conversationId}`);
+  }
+  /** Load memory for session context */
+  async load(scope) {
+    const query = {};
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/memory/load", void 0, query);
+  }
+};
+var IdentityClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Get server public key */
+  async getServerKey() {
+    return this._r("GET", "/api/im/keys/server");
+  }
+  /** Register or rotate an identity key */
+  async registerKey(options) {
+    return this._r("PUT", "/api/im/keys/identity", options);
+  }
+  /** Get a user's identity key */
+  async getKey(userId) {
+    return this._r("GET", `/api/im/keys/identity/${userId}`);
+  }
+  /** Revoke own identity key */
+  async revokeKey() {
+    return this._r("POST", "/api/im/keys/identity/revoke");
+  }
+  /** Get key audit log for a user */
+  async getAuditLog(userId) {
+    return this._r("GET", `/api/im/keys/audit/${userId}`);
+  }
+  /** Verify key audit log integrity */
+  async verifyAuditLog(userId) {
+    return this._r("GET", `/api/im/keys/audit/${userId}/verify`);
+  }
+};
+var SecurityClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Get conversation security settings */
+  async getConversationSecurity(conversationId) {
+    return this._r("GET", `/api/im/conversations/${conversationId}/security`);
+  }
+  /** Update conversation security settings */
+  async setConversationSecurity(conversationId, options) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/security`, options);
+  }
+  /** Upload a public key for a conversation */
+  async uploadKey(conversationId, publicKey, algorithm) {
+    const body = { publicKey };
+    if (algorithm) body.algorithm = algorithm;
+    return this._r("POST", `/api/im/conversations/${conversationId}/keys`, body);
+  }
+  /** Get keys for a conversation */
+  async getKeys(conversationId) {
+    return this._r("GET", `/api/im/conversations/${conversationId}/keys`);
+  }
+  /** Revoke a key for a specific user in a conversation */
+  async revokeKey(conversationId, keyUserId) {
+    return this._r("DELETE", `/api/im/conversations/${conversationId}/keys/${keyUserId}`);
+  }
+};
+var EvolutionClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  // ── Public endpoints (no auth required) ──
+  /** Get evolution stats */
+  async getStats() {
+    return this._r("GET", "/api/im/evolution/public/stats");
+  }
+  /** Get hot/trending genes */
+  async getHotGenes(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/public/hot", void 0, query);
+  }
+  /** Browse published genes */
+  async browseGenes(options) {
+    const query = {};
+    if (options?.category) query.category = options.category;
+    if (options?.search) query.search = options.search;
+    if (options?.sort) query.sort = options.sort;
+    if (options?.page != null) query.page = String(options.page);
+    if (options?.limit != null) query.limit = String(options.limit);
+    return this._r("GET", "/api/im/evolution/public/genes", void 0, query);
+  }
+  /** Get a public gene by ID */
+  async getPublicGene(geneId) {
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}`);
+  }
+  /** Get capsules for a public gene */
+  async getGeneCapsules(geneId, limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}/capsules`, void 0, query);
+  }
+  /** Get gene lineage (parent + children) */
+  async getGeneLineage(geneId) {
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}/lineage`);
+  }
+  /** Get public evolution feed */
+  async getFeed(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/public/feed", void 0, query);
+  }
+  // ── Authenticated endpoints ──
+  /** Analyze signals and get gene recommendation */
+  async analyze(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/analyze", body, q);
+  }
+  /** Record an outcome (success/failure) for a gene */
+  async record(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/record", body, q);
+  }
+  /**
+   * One-step evolution: analyze context → get gene recommendation → auto-record outcome.
+   * Combines analyze() + record() into a single call for the common case.
+   *
+   * Usage:
+   *   const result = await client.evolution.evolve({
+   *     error: 'Connection timeout after 10s',
+   *     outcome: 'success',
+   *     score: 0.85,
+   *     summary: 'Fixed with exponential backoff',
+   *   });
+   */
+  async evolve(options) {
+    const { outcome, score, summary, strategy_used, scope, ...analyzeOpts } = options;
+    const analysis = await this.analyze({ ...analyzeOpts, ...scope ? { scope } : {} });
+    if (!analysis.ok || !analysis.data) {
+      return { ok: false, error: analysis.error };
+    }
+    const data = analysis.data;
+    const geneId = data.gene_id;
+    if (geneId && (data.action === "apply_gene" || data.action === "explore")) {
+      const recordResult = await this.record({
+        gene_id: geneId,
+        signals: data.signals || analyzeOpts.signals || [],
+        outcome,
+        score: score ?? (outcome === "success" ? 0.8 : 0.2),
+        summary: summary || `${outcome === "success" ? "Resolved" : "Failed to resolve"} using ${geneId}`,
+        strategy_used,
+        ...scope ? { scope } : {}
+      });
+      return {
+        ok: true,
+        data: {
+          analysis: data,
+          recorded: true,
+          edge_updated: recordResult.data?.edge_updated
+        }
+      };
+    }
+    return {
+      ok: true,
+      data: { analysis: data, recorded: false }
+    };
+  }
+  /** Trigger gene distillation */
+  async distill(dryRun) {
+    const query = {};
+    if (dryRun) query.dry_run = "true";
+    return this._r("POST", "/api/im/evolution/distill", void 0, query);
+  }
+  /** List own genes */
+  async listGenes(signals, scope) {
+    const query = {};
+    if (signals) query.signals = signals;
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/evolution/genes", void 0, query);
+  }
+  /** Create a new gene */
+  async createGene(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/genes", body, q);
+  }
+  /** Delete a gene */
+  async deleteGene(geneId) {
+    return this._r("DELETE", `/api/im/evolution/genes/${encodeURIComponent(geneId)}`);
+  }
+  /** Publish a gene. Pass skipCanary=true to bypass canary validation (MVP/admin). */
+  async publishGene(geneId, options) {
+    return this._r("POST", `/api/im/evolution/genes/${encodeURIComponent(geneId)}/publish`, options?.skipCanary ? { skipCanary: true } : void 0);
+  }
+  /** Import a published gene */
+  async importGene(geneId) {
+    return this._r("POST", "/api/im/evolution/genes/import", { gene_id: geneId });
+  }
+  /** Fork a gene with modifications */
+  async forkGene(options) {
+    return this._r("POST", "/api/im/evolution/genes/fork", options);
+  }
+  /** Get signal-gene edges */
+  async getEdges(options) {
+    const query = {};
+    if (options?.signalKey) query.signal_key = options.signalKey;
+    if (options?.geneId) query.gene_id = options.geneId;
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.scope) query.scope = options.scope;
+    return this._r("GET", "/api/im/evolution/edges", void 0, query);
+  }
+  /** Get agent personality profile */
+  async getPersonality(agentId) {
+    return this._r("GET", `/api/im/evolution/personality/${agentId}`);
+  }
+  /** Get own capsule history */
+  async getCapsules(options) {
+    const query = {};
+    if (options?.page != null) query.page = String(options.page);
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.scope) query.scope = options.scope;
+    return this._r("GET", "/api/im/evolution/capsules", void 0, query);
+  }
+  /** Get evolution report */
+  async getReport(agentId, scope) {
+    const query = {};
+    if (agentId) query.agent_id = agentId;
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/evolution/report", void 0, query);
+  }
+  /** List available evolution scopes */
+  async listScopes() {
+    return this._r("GET", "/api/im/evolution/scopes");
+  }
+  // ─── v0.3.1: Stories, Metrics, Skills ──────────────
+  /** Get recent evolution stories (for L1 narrative embedding) */
+  async getStories(options) {
+    const query = {};
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.since != null) query.since = String(options.since);
+    return this._r("GET", "/api/im/evolution/stories", void 0, query);
+  }
+  /** Get north-star metrics comparison (standard vs hypergraph) */
+  async getMetrics() {
+    return this._r("GET", "/api/im/evolution/metrics");
+  }
+  /** Trigger metrics collection snapshot */
+  async collectMetrics(windowHours) {
+    return this._r("POST", "/api/im/evolution/metrics/collect", { window_hours: windowHours ?? 1 });
+  }
+  /** Search skills catalog */
+  async searchSkills(options) {
+    const q = {};
+    if (options?.query) q.query = options.query;
+    if (options?.category) q.category = options.category;
+    if (options?.limit != null) q.limit = String(options.limit);
+    return this._r("GET", "/api/im/skills/search", void 0, q);
+  }
+  /** Get skill catalog stats */
+  async getSkillStats() {
+    return this._r("GET", "/api/im/skills/stats");
+  }
+  /** Install a skill — creates Gene + returns content + install guide */
+  async installSkill(slugOrId) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  }
+  /** Uninstall a skill */
+  async uninstallSkill(slugOrId) {
+    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  }
+  /** List installed skills for this agent */
+  async installedSkills() {
+    return this._r("GET", "/api/im/skills/installed");
+  }
+  /** Get full skill content (SKILL.md + package info) */
+  async getSkillContent(slugOrId) {
+    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}/content`);
+  }
+  /** Create/submit a community skill */
+  async createSkill(input) {
+    return this._r("POST", "/api/im/skills", input);
+  }
+  /** Star a skill (increment community rating) */
+  async starSkill(skillId) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(skillId)}/star`);
+  }
+  /**
+   * Install a skill and write SKILL.md to local filesystem.
+   * Combines cloud install + local file sync for Claude Code / OpenClaw / OpenCode.
+   * @param slugOrId - Skill slug or ID
+   * @param options - Local install options
+   */
+  async installSkillLocal(slugOrId, options) {
+    const result = await this.installSkill(slugOrId);
+    if (!result.ok || !result.data) return result;
+    let content = result.data.skill?.content || "";
+    if (!content) {
+      const contentResult = await this.getSkillContent(slugOrId);
+      content = contentResult.data?.content || "";
+    }
+    if (!content) {
+      return { ...result, data: { ...result.data, localPaths: [] } };
+    }
+    const rawSlug = result.data.skill?.slug || slugOrId;
+    const slug = rawSlug.replace(/[\/\\]/g, "").replace(/\.\./g, "");
+    if (!slug) {
+      return { ...result, data: { ...result.data, localPaths: [] } };
+    }
+    const localPaths = [];
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      const os = await import("os");
+      const home = os.homedir();
+      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path.join(home, ".claude", "plugins", "prismer");
+      const platformPaths = options?.project ? {
+        "claude-code": path.join(options.projectRoot || ".", ".claude", "skills", slug),
+        "openclaw": path.join(options.projectRoot || ".", "skills", slug),
+        "opencode": path.join(options.projectRoot || ".", ".opencode", "skills", slug),
+        "plugin": path.join(options.projectRoot || ".", ".claude", "plugins", "prismer", "skills", slug)
+      } : {
+        "claude-code": path.join(home, ".claude", "skills", slug),
+        "openclaw": path.join(home, ".openclaw", "skills", slug),
+        "opencode": path.join(home, ".config", "opencode", "skills", slug),
+        "plugin": path.join(pluginBase, "skills", slug)
+      };
+      const targets = options?.platforms || Object.keys(platformPaths);
+      for (const platform of targets) {
+        const dir = platformPaths[platform];
+        if (!dir) continue;
+        try {
+          fs.mkdirSync(dir, { recursive: true });
+          const filePath = path.join(dir, "SKILL.md");
+          fs.writeFileSync(filePath, content, "utf-8");
+          localPaths.push(filePath);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return { ...result, data: { ...result.data, localPaths } };
+  }
+  /**
+   * Uninstall a skill and remove local SKILL.md files.
+   */
+  async uninstallSkillLocal(slugOrId) {
+    const result = await this.uninstallSkill(slugOrId);
+    const removedPaths = [];
+    const slug = safeSlug(slugOrId);
+    if (!slug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      const os = await import("os");
+      const home = os.homedir();
+      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path.join(home, ".claude", "plugins", "prismer");
+      const dirs = [
+        path.join(home, ".claude", "skills", slug),
+        path.join(home, ".openclaw", "skills", slug),
+        path.join(home, ".config", "opencode", "skills", slug),
+        path.join(pluginBase, "skills", slug)
+      ];
+      for (const dir of dirs) {
+        try {
+          if (fs.existsSync(dir)) {
+            fs.rmSync(dir, { recursive: true });
+            removedPaths.push(dir);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+  }
+  /**
+   * Sync all installed skills to local filesystem.
+   */
+  async syncSkillsLocal(options) {
+    const installed = await this.installedSkills();
+    if (!installed.ok || !installed.data) return { synced: 0, failed: 0, paths: [] };
+    let synced = 0;
+    let failed = 0;
+    const paths = [];
+    for (const record of installed.data) {
+      const rawSlug = record.skill?.slug;
+      if (!rawSlug) {
+        failed++;
+        continue;
+      }
+      const slug = rawSlug.replace(/[\/\\]/g, "").replace(/\.\./g, "");
+      if (!slug) {
+        failed++;
+        continue;
+      }
+      try {
+        const contentResult = await this.getSkillContent(slug);
+        const content = contentResult.data?.content;
+        if (!content) {
+          failed++;
+          continue;
+        }
+        const fs = await import("fs");
+        const path = await import("path");
+        const os = await import("os");
+        const home = os.homedir();
+        const pluginBase = process.env.PRISMER_PLUGIN_DIR || path.join(home, ".claude", "plugins", "prismer");
+        const platformPaths = {
+          "claude-code": path.join(home, ".claude", "skills", slug),
+          "openclaw": path.join(home, ".openclaw", "skills", slug),
+          "opencode": path.join(home, ".config", "opencode", "skills", slug),
+          "plugin": path.join(pluginBase, "skills", slug)
+        };
+        const targets = options?.platforms || Object.keys(platformPaths);
+        for (const platform of targets) {
+          const dir = platformPaths[platform];
+          if (!dir) continue;
+          try {
+            fs.mkdirSync(dir, { recursive: true });
+            const filePath = path.join(dir, "SKILL.md");
+            fs.writeFileSync(filePath, content, "utf-8");
+            paths.push(filePath);
+          } catch {
+          }
+        }
+        synced++;
+      } catch {
+        failed++;
+      }
+    }
+    return { synced, failed, paths };
+  }
+  /** Export a Gene as a Skill */
+  async exportAsSkill(geneId, options) {
+    return this._r("POST", `/api/im/evolution/genes/${geneId}/export-skill`, options);
+  }
+  // ─── P0: Report, Achievements, Sync ──────────────
+  /** Submit a raw-context evolution report (auto-creates signals + gene match) */
+  async submitReport(options) {
+    return this._r("POST", "/api/im/evolution/report", {
+      raw_context: options.rawContext,
+      outcome: options.outcome,
+      task_context: options.taskContext,
+      task_error: options.taskError,
+      task_id: options.taskId,
+      metadata: options.metadata
+    });
+  }
+  /** Get status of a submitted report by traceId */
+  async getReportStatus(traceId) {
+    return this._r("GET", `/api/im/evolution/report/${traceId}`);
+  }
+  /** Get evolution achievements for the current agent */
+  async getAchievements() {
+    return this._r("GET", "/api/im/evolution/achievements");
+  }
+  /** Get a sync snapshot (global gene/edge state since a sequence number) */
+  async getSyncSnapshot(since) {
+    const query = { scope: "global" };
+    if (since != null) query.since = String(since);
+    return this._r("GET", "/api/im/evolution/sync/snapshot", void 0, query);
+  }
+  /** Bidirectional sync: push local outcomes and pull remote updates */
+  async sync(options) {
+    const body = {};
+    if (options?.pushOutcomes) body.push = { outcomes: options.pushOutcomes };
+    if (options?.pullSince != null) body.pull = { since: options.pullSince };
+    return this._r("POST", "/api/im/evolution/sync", body);
+  }
+};
+function safeSlug(input) {
+  return input.replace(/[\/\\]/g, "").replace(/\.\./g, "").replace(/\0/g, "");
+}
 function guessMimeType(fileName) {
   const ext = fileName.split(".").pop()?.toLowerCase() || "";
   const map = {
@@ -2718,6 +3937,11 @@ var IMClient = class {
     this.bindings = new BindingsClient(request);
     this.credits = new CreditsClient(request);
     this.workspace = new WorkspaceClient(request);
+    this.tasks = new TasksClient(request);
+    this.memory = new MemoryClient(request);
+    this.identity = new IdentityClient(request);
+    this.security = new SecurityClient(request);
+    this.evolution = new EvolutionClient(request);
     this.files = new FilesClient(request, wsBase, fetchFn, getAuthHeaders);
     this.realtime = new IMRealtimeClient(wsBase);
     this.offline = offlineManager ?? null;
@@ -2891,6 +4115,7 @@ function createClient(config) {
   return new PrismerClient(config);
 }
 export {
+  AIPIdentity,
   AccountClient,
   AttachmentQueue,
   BindingsClient,
@@ -2900,11 +4125,16 @@ export {
   DirectClient,
   E2EEncryption,
   ENVIRONMENTS,
+  EvolutionCache,
+  EvolutionClient,
+  EvolutionRuntime,
   FilesClient,
   GroupsClient,
   IMClient,
   IMRealtimeClient,
+  IdentityClient,
   IndexedDBStorage,
+  MemoryClient,
   MemoryStorage,
   MessagesClient,
   OfflineManager,
@@ -2912,8 +4142,21 @@ export {
   RealtimeSSEClient,
   RealtimeWSClient,
   SQLiteStorage,
+  SecurityClient,
   TabCoordinator,
+  TasksClient,
   WorkspaceClient,
   createClient,
-  index_default as default
+  createEnrichedExtractor,
+  decryptContext,
+  decryptFile,
+  decryptMessages,
+  decryptOnReceive,
+  index_default as default,
+  encryptContext,
+  encryptFile,
+  encryptForSend,
+  extractSignals,
+  guessMimeType,
+  safeSlug
 };