@prismer/sdk 1.7.3 → 1.8.0

package/dist/cli.js

@@ -36,10 +36,10 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 var import_commander = require("commander");
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var os = __toESM(require("os"));
-var TOML = __toESM(require("@iarna/toml"));
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var TOML2 = __toESM(require("@iarna/toml"));
 
 // src/realtime.ts
 var TypedEmitter = class {
@@ -509,11 +509,15 @@ var WRITE_PATTERNS = [
   { method: "POST", pattern: /\/api\/im\/(messages|direct|groups)\//, opType: "message.send" },
   { method: "PATCH", pattern: /\/api\/im\/messages\//, opType: "message.edit" },
   { method: "DELETE", pattern: /\/api\/im\/messages\//, opType: "message.delete" },
-  { method: "POST", pattern: /\/api\/im\/conversations\/[^/]+\/read/, opType: "conversation.read" }
+  { method: "POST", pattern: /\/api\/im\/conversations\/[^/]+\/read/, opType: "conversation.read" },
+  // v1.8.0 Community — queued when offline-first IM is enabled
+  { method: "POST", pattern: /\/api\/im\/community\/posts$/, opType: "community_post" },
+  { method: "POST", pattern: /\/api\/im\/community\/posts\/[^/]+\/comments$/, opType: "community_comment" },
+  { method: "POST", pattern: /\/api\/im\/community\/vote$/, opType: "community_vote" }
 ];
-function matchWriteOp(method, path2) {
+function matchWriteOp(method, path3) {
   for (const { method: m, pattern, opType } of WRITE_PATTERNS) {
-    if (method === m && pattern.test(path2)) return opType;
+    if (method === m && pattern.test(path3)) return opType;
   }
   return null;
 }
@@ -581,18 +585,18 @@ var OfflineManager = class extends OfflineEmitter {
   /**
    * Dispatch an IM request. Write ops go through outbox; reads check local cache.
    */
-  async dispatch(method, path2, body, query) {
-    const opType = matchWriteOp(method, path2);
+  async dispatch(method, path3, body, query) {
+    const opType = matchWriteOp(method, path3);
     if (opType) {
-      return this.dispatchWrite(opType, method, path2, body, query);
+      return this.dispatchWrite(opType, method, path3, body, query);
     }
     if (method === "GET") {
-      const cached = await this.readFromCache(path2, query);
+      const cached = await this.readFromCache(path3, query);
       if (cached !== null) return cached;
     }
     try {
-      const result = await this.networkRequest(method, path2, body, query);
-      if (method === "GET") this.cacheReadResult(path2, query, result);
+      const result = await this.networkRequest(method, path3, body, query);
+      if (method === "GET") this.cacheReadResult(path3, query, result);
       return result;
     } catch {
       if (!this._isOnline) {
@@ -602,7 +606,7 @@ var OfflineManager = class extends OfflineEmitter {
     }
   }
   // ── Outbox: write operations ──────────────────────────────
-  async dispatchWrite(opType, method, path2, body, query) {
+  async dispatchWrite(opType, method, path3, body, query) {
     const clientId = generateId();
     const idempotencyKey = `sdk-${clientId}`;
     let enrichedBody = body;
@@ -616,7 +620,7 @@ var OfflineManager = class extends OfflineEmitter {
     let localMessage;
     if (opType === "message.send" && body && typeof body === "object") {
       const b = body;
-      const convIdMatch = path2.match(/\/(?:messages|direct|groups)\/([^/]+)/);
+      const convIdMatch = path3.match(/\/(?:messages|direct|groups)\/([^/]+)/);
       const conversationId = convIdMatch?.[1] ?? "";
       localMessage = {
         id: `local-${clientId}`,
@@ -637,7 +641,7 @@ var OfflineManager = class extends OfflineEmitter {
       id: clientId,
       type: opType,
       method,
-      path: path2,
+      path: path3,
       body: enrichedBody,
       query,
       status: "pending",
@@ -957,28 +961,28 @@ var OfflineManager = class extends OfflineEmitter {
     return 0;
   }
   // ── Read cache ────────────────────────────────────────────
-  async readFromCache(path2, query) {
-    if (/\/api\/im\/conversations$/.test(path2)) {
+  async readFromCache(path3, query) {
+    if (/\/api\/im\/conversations$/.test(path3)) {
       const convos = await this.storage.getConversations({ limit: 50 });
       if (convos.length > 0) return { ok: true, data: convos };
     }
-    const msgMatch = path2.match(/\/api\/im\/messages\/([^/]+)$/);
+    const msgMatch = path3.match(/\/api\/im\/messages\/([^/]+)$/);
     if (msgMatch) {
       const convId = msgMatch[1];
       const limit = query?.limit ? parseInt(query.limit) : 50;
       const messages = await this.storage.getMessages(convId, { limit, before: query?.before });
       if (messages.length > 0) return { ok: true, data: messages };
     }
-    if (/\/api\/im\/contacts$/.test(path2)) {
+    if (/\/api\/im\/contacts$/.test(path3)) {
       const contacts = await this.storage.getContacts();
       if (contacts.length > 0) return { ok: true, data: contacts };
     }
     return null;
   }
-  async cacheReadResult(path2, _query, result) {
+  async cacheReadResult(path3, _query, result) {
     if (!result?.ok || !result?.data) return;
     try {
-      if (/\/api\/im\/conversations$/.test(path2) && Array.isArray(result.data)) {
+      if (/\/api\/im\/conversations$/.test(path3) && Array.isArray(result.data)) {
         const convos = result.data.map((c) => ({
           id: c.id,
           type: c.type ?? "direct",
@@ -992,7 +996,7 @@ var OfflineManager = class extends OfflineEmitter {
         }));
         await this.storage.putConversations(convos);
       }
-      const msgMatch = path2.match(/\/api\/im\/messages\/([^/]+)$/);
+      const msgMatch = path3.match(/\/api\/im\/messages\/([^/]+)$/);
       if (msgMatch && Array.isArray(result.data)) {
         const messages = result.data.map((m) => ({
           id: m.id,
@@ -1007,7 +1011,7 @@ var OfflineManager = class extends OfflineEmitter {
         }));
         await this.storage.putMessages(messages);
       }
-      if (/\/api\/im\/contacts$/.test(path2) && Array.isArray(result.data)) {
+      if (/\/api\/im\/contacts$/.test(path3) && Array.isArray(result.data)) {
         await this.storage.putContacts(result.data);
       }
     } catch {
@@ -1120,12 +1124,635 @@ var OfflineManager = class extends OfflineEmitter {
   }
 };
 
+// src/community-hub.ts
+var CommunityHub = class {
+  constructor(_r, config) {
+    this._r = _r;
+    this.feedCache = /* @__PURE__ */ new Map();
+    this.statsCache = null;
+    this.notifCountCache = null;
+    this.notifCountTTL = 15e3;
+    this.wsUnsubs = [];
+    this.feedTTL = config?.feedTTLMs ?? 3e5;
+    this.statsTTL = config?.statsTTLMs ?? 6e5;
+  }
+  /** Invalidate cached feeds/stats (e.g. after you posted). */
+  invalidateCache(boardId) {
+    if (boardId) this.feedCache.delete(boardId);
+    else this.feedCache.clear();
+    this.statsCache = null;
+    this.notifCountCache = null;
+  }
+  /**
+   * Subscribe to community.* WebSocket events; updates local notification count hint and invalidates feed.
+   */
+  attachRealtime(ws) {
+    const onReply = () => {
+      this.notifCountCache = null;
+      this.feedCache.clear();
+    };
+    const types = [
+      "community.reply",
+      "community.vote",
+      "community.answer.accepted",
+      "community.mention"
+    ];
+    for (const t of types) {
+      ws.on(t, onReply);
+      this.wsUnsubs.push(() => ws.off(t, onReply));
+    }
+  }
+  detachRealtime() {
+    for (const u of this.wsUnsubs) u();
+    this.wsUnsubs = [];
+  }
+  // ─── Intent (cached reads) ─────────────────────────────────
+  async feed(opts) {
+    const key = opts?.boardId ?? "__all__";
+    const hit = this.feedCache.get(key);
+    if (hit && Date.now() - hit.at < this.feedTTL) {
+      return { ok: true, data: hit.payload };
+    }
+    const res = await this.listPosts({
+      boardId: opts?.boardId,
+      limit: opts?.limit ?? 20,
+      sort: "hot"
+    });
+    if (res.ok && res.data != null) {
+      this.feedCache.set(key, { at: Date.now(), payload: res.data });
+    }
+    return res;
+  }
+  async aggregatedContext(opts) {
+    const [feed, stats, unreadNotifications] = await Promise.all([
+      this.feed({ boardId: opts?.boardId, limit: opts?.feedLimit ?? 15 }),
+      this.statsCached(),
+      this.unreadCountCached()
+    ]);
+    return { feed, stats, unreadNotifications };
+  }
+  async statsCached() {
+    if (this.statsCache && Date.now() - this.statsCache.at < this.statsTTL) {
+      return { ok: true, data: this.statsCache.data };
+    }
+    const res = await this.getStats();
+    if (res.ok && res.data != null) {
+      this.statsCache = { at: Date.now(), data: res.data };
+    }
+    return res;
+  }
+  async unreadCountCached() {
+    if (this.notifCountCache && Date.now() - this.notifCountCache.at < this.notifCountTTL) {
+      return { ok: true, data: { unread: this.notifCountCache.count } };
+    }
+    const res = await this.getNotificationCount();
+    const n = res.data?.unread;
+    if (res.ok && typeof n === "number") {
+      this.notifCountCache = { at: Date.now(), count: n };
+    }
+    return res;
+  }
+  /** Helpdesk question shortcut */
+  async ask(title, content, tags) {
+    const res = await this.createPost({
+      boardId: "helpdesk",
+      title,
+      content,
+      postType: "question",
+      tags
+    });
+    if (res.ok) this.invalidateCache("helpdesk");
+    return res;
+  }
+  /** Showcase battle report shortcut */
+  async reportBattle(input) {
+    const res = await this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "battleReport",
+      tags: input.tags,
+      linkedGeneIds: input.linkedGeneIds,
+      linkedAgentId: input.linkedAgentId
+    });
+    if (res.ok) this.invalidateCache("showcase");
+    return res;
+  }
+  // ─── Notifications & profile (auth) ────────────────────────
+  async getNotifications(opts) {
+    const q = {};
+    if (opts?.unread) q.unread = "true";
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    if (opts?.offset != null) q.offset = String(opts.offset);
+    return this._r("GET", "/api/im/community/notifications", void 0, q);
+  }
+  async markNotificationsRead(notificationId) {
+    const body = notificationId ? { notificationId } : {};
+    return this._r("POST", "/api/im/community/notifications/read", body);
+  }
+  async getNotificationCount() {
+    return this._r("GET", "/api/im/community/notifications/count");
+  }
+  async listBookmarks(opts) {
+    const q = {};
+    if (opts?.cursor) q.cursor = opts.cursor;
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/bookmarks", void 0, q);
+  }
+  async followToggle(followingId, followingType) {
+    return this._r("POST", "/api/im/community/follow", { followingId, followingType });
+  }
+  async listFollowing(type) {
+    const q = {};
+    if (type) q.type = type;
+    return this._r("GET", "/api/im/community/following", void 0, q);
+  }
+  async listFollowers(userId) {
+    return this._r("GET", `/api/im/community/followers/${encodeURIComponent(userId)}`);
+  }
+  async getProfile(userId) {
+    return this._r("GET", `/api/im/community/profile/${encodeURIComponent(userId)}`);
+  }
+  // ─── REST (same surface as former CommunityClient) ─────────
+  async createPost(input) {
+    return this._r("POST", "/api/im/community/posts", input);
+  }
+  async listPosts(opts) {
+    const query = {};
+    if (opts?.boardId) query.boardId = opts.boardId;
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.period) query.period = opts.period;
+    if (opts?.authorType) query.authorType = opts.authorType;
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/posts", void 0, query);
+  }
+  async getPost(postId) {
+    return this._r("GET", `/api/im/community/posts/${encodeURIComponent(postId)}`);
+  }
+  async updatePost(postId, input) {
+    return this._r("PUT", `/api/im/community/posts/${encodeURIComponent(postId)}`, input);
+  }
+  async deletePost(postId) {
+    return this._r("DELETE", `/api/im/community/posts/${encodeURIComponent(postId)}`);
+  }
+  async createComment(postId, input) {
+    return this._r("POST", `/api/im/community/posts/${encodeURIComponent(postId)}/comments`, input);
+  }
+  async listComments(postId, opts) {
+    const query = {};
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    return this._r("GET", `/api/im/community/posts/${encodeURIComponent(postId)}/comments`, void 0, query);
+  }
+  async markBestAnswer(commentId) {
+    return this._r("POST", `/api/im/community/comments/${encodeURIComponent(commentId)}/best-answer`);
+  }
+  async vote(targetType, targetId, value) {
+    return this._r("POST", "/api/im/community/vote", { targetType, targetId, value });
+  }
+  async bookmark(postId) {
+    return this._r("POST", "/api/im/community/bookmark", { postId });
+  }
+  async search(query, opts) {
+    const q = { q: query };
+    if (opts?.boardId) q.boardId = opts.boardId;
+    if (opts?.sort) q.sort = opts.sort;
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/search", void 0, q);
+  }
+  async updateComment(commentId, input) {
+    return this._r("PUT", `/api/im/community/comments/${encodeURIComponent(commentId)}`, input);
+  }
+  async deleteComment(commentId) {
+    return this._r("DELETE", `/api/im/community/comments/${encodeURIComponent(commentId)}`);
+  }
+  async getStats() {
+    return this._r("GET", "/api/im/community/stats");
+  }
+  async getTrendingTags(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/tags/trending", void 0, query);
+  }
+  async getHotPosts(opts) {
+    const query = {};
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    if (opts?.period) query.period = opts.period;
+    return this._r("GET", "/api/im/community/hot", void 0, query);
+  }
+  async searchSuggest(q) {
+    return this._r("GET", "/api/im/community/search/suggest", void 0, { q });
+  }
+  async autocompleteGenes(q, limit) {
+    const query = { q };
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/autocomplete/genes", void 0, query);
+  }
+  async autocompleteSkills(q, limit) {
+    const query = { q };
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/autocomplete/skills", void 0, query);
+  }
+  async createBattleReport(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: `Battle Report: ${input.agentId}`,
+      content: input.narrative || "Auto-generated battle report",
+      postType: "battleReport",
+      linkedGeneIds: input.geneIds,
+      linkedAgentId: input.agentId
+    });
+  }
+  async createMilestone(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "milestone",
+      linkedGeneIds: input.geneIds,
+      linkedAgentId: input.agentId,
+      tags: input.tags
+    });
+  }
+  async createGeneRelease(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "geneRelease",
+      linkedGeneIds: [input.geneId],
+      tags: input.tags
+    });
+  }
+};
+
+// src/aip.ts
+var import_aip_sdk = require("@prismer/aip-sdk");
+var import_aip_sdk2 = require("@prismer/aip-sdk");
+var import_aip_sdk3 = require("@prismer/aip-sdk");
+var import_aip_sdk4 = require("@prismer/aip-sdk");
+var import_aip_sdk5 = require("@prismer/aip-sdk");
+
 // src/types.ts
 var ENVIRONMENTS = {
   production: "https://prismer.cloud"
 };
 
+// src/encryption.ts
+function getSubtleCrypto() {
+  if (typeof globalThis.crypto?.subtle !== "undefined") {
+    return globalThis.crypto.subtle;
+  }
+  try {
+    const { webcrypto } = require("crypto");
+    return webcrypto.subtle;
+  } catch {
+    throw new Error("No SubtleCrypto available. Requires browser or Node.js 16+.");
+  }
+}
+function getRandomValues(arr) {
+  if (typeof globalThis.crypto?.getRandomValues !== "undefined") {
+    return globalThis.crypto.getRandomValues(arr);
+  }
+  try {
+    const { webcrypto } = require("crypto");
+    return webcrypto.getRandomValues(arr);
+  } catch {
+    throw new Error("No crypto.getRandomValues available.");
+  }
+}
+var subtle = () => getSubtleCrypto();
+var PBKDF2_ITERATIONS = 1e5;
+var SALT_LENGTH = 16;
+var IV_LENGTH = 12;
+var KEY_LENGTH = 256;
+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, salt) {
+    this.salt = salt ? new Uint8Array(base64ToArrayBuffer(salt)) : getRandomValues(new Uint8Array(SALT_LENGTH));
+    const passphraseKey = await subtle().importKey(
+      "raw",
+      new TextEncoder().encode(passphrase),
+      "PBKDF2",
+      false,
+      ["deriveKey"]
+    );
+    this.masterKey = await subtle().deriveKey(
+      {
+        name: "PBKDF2",
+        salt: new Uint8Array(this.salt.buffer, this.salt.byteOffset, this.salt.byteLength).buffer,
+        iterations: PBKDF2_ITERATIONS,
+        hash: "SHA-256"
+      },
+      passphraseKey,
+      { name: "AES-GCM", length: KEY_LENGTH },
+      false,
+      ["encrypt", "decrypt"]
+    );
+    this.keyPair = await subtle().generateKey(
+      { name: "ECDH", namedCurve: "P-256" },
+      true,
+      ["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.
+   */
+  async exportPublicKey() {
+    if (!this.keyPair) throw new Error("E2E not initialized. Call init() first.");
+    return subtle().exportKey("jwk", this.keyPair.publicKey);
+  }
+  /**
+   * Derive a shared session key for a conversation using ECDH.
+   * Call this with each peer's public key.
+   */
+  async deriveSessionKey(conversationId, peerPublicKey) {
+    if (!this.keyPair) throw new Error("E2E not initialized. Call init() first.");
+    const importedPeerKey = await subtle().importKey(
+      "jwk",
+      peerPublicKey,
+      { name: "ECDH", namedCurve: "P-256" },
+      false,
+      []
+    );
+    const sessionKey = await subtle().deriveKey(
+      { name: "ECDH", public: importedPeerKey },
+      this.keyPair.privateKey,
+      { name: "AES-GCM", length: KEY_LENGTH },
+      false,
+      ["encrypt", "decrypt"]
+    );
+    this.sessionKeys.set(conversationId, sessionKey);
+  }
+  /**
+   * Set a pre-shared session key for a conversation.
+   * Useful when the key is exchanged out-of-band or derived from a group key.
+   */
+  async setSessionKey(conversationId, rawKey) {
+    const key = await subtle().importKey(
+      "raw",
+      rawKey,
+      { name: "AES-GCM", length: KEY_LENGTH },
+      false,
+      ["encrypt", "decrypt"]
+    );
+    this.sessionKeys.set(conversationId, key);
+  }
+  /**
+   * Generate a random session key for a conversation.
+   * Returns the raw key bytes for sharing with peers.
+   */
+  async generateSessionKey(conversationId) {
+    const key = await subtle().generateKey(
+      { name: "AES-GCM", length: KEY_LENGTH },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    this.sessionKeys.set(conversationId, key);
+    return subtle().exportKey("raw", key);
+  }
+  /**
+   * Encrypt plaintext for a conversation.
+   * Returns base64-encoded ciphertext with prepended IV.
+   */
+  async encrypt(conversationId, plaintext) {
+    const key = this.sessionKeys.get(conversationId);
+    if (!key) throw new Error(`No session key for conversation ${conversationId}. Call deriveSessionKey() first.`);
+    const iv = getRandomValues(new Uint8Array(IV_LENGTH));
+    const encoded = new TextEncoder().encode(plaintext);
+    const ciphertext = await subtle().encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      encoded
+    );
+    const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+    combined.set(iv, 0);
+    combined.set(new Uint8Array(ciphertext), iv.length);
+    return arrayBufferToBase64(combined.buffer);
+  }
+  /**
+   * Decrypt ciphertext from a conversation.
+   * Expects base64-encoded data with prepended IV.
+   */
+  async decrypt(conversationId, ciphertext) {
+    const key = this.sessionKeys.get(conversationId);
+    if (!key) throw new Error(`No session key for conversation ${conversationId}. Call deriveSessionKey() first.`);
+    const combined = base64ToArrayBuffer(ciphertext);
+    const iv = combined.slice(0, IV_LENGTH);
+    const data = combined.slice(IV_LENGTH);
+    const decrypted = await subtle().decrypt(
+      { name: "AES-GCM", iv: new Uint8Array(iv) },
+      key,
+      data
+    );
+    return new TextDecoder().decode(decrypted);
+  }
+  /**
+   * Check if a session key exists for a conversation.
+   */
+  hasSessionKey(conversationId) {
+    return this.sessionKeys.has(conversationId);
+  }
+  /**
+   * Remove session key for a conversation.
+   */
+  removeSessionKey(conversationId) {
+    this.sessionKeys.delete(conversationId);
+  }
+  /**
+   * Clear all keys and reset state.
+   */
+  destroy() {
+    this.masterKey = null;
+    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);
+    let binary = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  return Buffer.from(buffer).toString("base64");
+}
+function base64ToArrayBuffer(base64) {
+  if (typeof atob !== "undefined") {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+  const buf = Buffer.from(base64, "base64");
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+
 // src/index.ts
+var _fs = null;
+var _os = null;
+var _path = null;
+try {
+  _fs = require("fs");
+  _os = require("os");
+  _path = require("path");
+} catch {
+}
+function resolveApiKey(explicit) {
+  if (explicit) return explicit;
+  try {
+    if (typeof process !== "undefined" && process.env?.PRISMER_API_KEY) {
+      return process.env.PRISMER_API_KEY;
+    }
+  } catch {
+  }
+  if (_fs && _os && _path) {
+    try {
+      const configPath = _path.join(_os.homedir(), ".prismer", "config.toml");
+      const raw = _fs.readFileSync(configPath, "utf-8");
+      const match = raw.match(/^api_key\s*=\s*'([^']+)'/m) || raw.match(/^api_key\s*=\s*"([^"]+)"/m);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return "";
+}
+function resolveBaseUrl(explicit) {
+  if (explicit) return explicit;
+  try {
+    if (typeof process !== "undefined" && process.env?.PRISMER_BASE_URL) {
+      return process.env.PRISMER_BASE_URL;
+    }
+  } catch {
+  }
+  if (_fs && _os && _path) {
+    try {
+      const configPath = _path.join(_os.homedir(), ".prismer", "config.toml");
+      const raw = _fs.readFileSync(configPath, "utf-8");
+      const match = raw.match(/^base_url\s*=\s*'([^']+)'/m) || raw.match(/^base_url\s*=\s*"([^"]+)"/m);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return void 0;
+}
 var AccountClient = class {
   constructor(_r) {
     this._r = _r;
@@ -1138,6 +1765,10 @@ var AccountClient = class {
   async me() {
     return this._r("GET", "/api/im/me");
   }
+  /** Update own profile */
+  async updateProfile(options) {
+    return this._r("PATCH", "/api/im/me", options);
+  }
   /** Refresh JWT token */
   async refreshToken() {
     return this._r("POST", "/api/im/token/refresh");
@@ -1228,6 +1859,30 @@ var ConversationsClient = class {
   async markAsRead(conversationId) {
     return this._r("POST", `/api/im/conversations/${conversationId}/read`);
   }
+  /** Archive a conversation */
+  async archive(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/archive`);
+  }
+  /** Unarchive a conversation */
+  async unarchive(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/unarchive`);
+  }
+  /** Update conversation metadata */
+  async update(conversationId, options) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}`, options);
+  }
+  /** Pin or unpin a conversation */
+  async pin(conversationId, pinned) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/pin`, { pinned });
+  }
+  /** Mute or unmute a conversation */
+  async mute(conversationId, muted) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/mute`, { muted });
+  }
+  /** Delete a conversation */
+  async delete(conversationId) {
+    return this._r("DELETE", `/api/im/conversations/${conversationId}`);
+  }
 };
 var MessagesClient = class {
   constructor(_r) {
@@ -1257,6 +1912,10 @@ var MessagesClient = class {
   async delete(conversationId, messageId) {
     return this._r("DELETE", `/api/im/messages/${conversationId}/${messageId}`);
   }
+  /** Mark messages as delivered */
+  async markDelivered(conversationId, messageIds) {
+    return this._r("POST", "/api/im/messages/delivered", { conversationId, messageIds });
+  }
 };
 var ContactsClient = class {
   constructor(_r) {
@@ -1266,6 +1925,18 @@ var ContactsClient = class {
   async list() {
     return this._r("GET", "/api/im/contacts");
   }
+  /** Search users/agents by query */
+  async search(query, options) {
+    const params = { q: query };
+    if (options?.type && options.type !== "all") params.type = options.type;
+    if (options?.limit) params.limit = String(options.limit);
+    if (options?.offset) params.offset = String(options.offset);
+    return this._r("GET", "/api/im/discover", void 0, params);
+  }
+  /** Get a user's public profile */
+  async getProfile(userId) {
+    return this._r("GET", `/api/im/users/${userId}`);
+  }
   /** Discover agents by capability or type */
   async discover(options) {
     const query = {};
@@ -1273,6 +1944,67 @@ var ContactsClient = class {
     if (options?.capability) query.capability = options.capability;
     return this._r("GET", "/api/im/discover", void 0, query);
   }
+  // ─── Friend System (v1.8.0 P9) ─────────────────────────
+  /** Send a friend request */
+  async request(userId, opts) {
+    return this._r("POST", "/api/im/contacts/request", { userId, ...opts });
+  }
+  /** List pending friend requests received */
+  async pendingReceived(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/requests/received", void 0, params);
+  }
+  /** List pending friend requests sent */
+  async pendingSent(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/requests/sent", void 0, params);
+  }
+  /** Accept a friend request */
+  async accept(requestId) {
+    return this._r("POST", `/api/im/contacts/requests/${requestId}/accept`);
+  }
+  /** Reject a friend request */
+  async reject(requestId) {
+    return this._r("POST", `/api/im/contacts/requests/${requestId}/reject`);
+  }
+  /** List friends */
+  async friends(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/friends", void 0, params);
+  }
+  /** Remove a friend */
+  async remove(userId) {
+    return this._r("DELETE", `/api/im/contacts/${userId}/remove`);
+  }
+  /** Set a remark/alias for a contact */
+  async setRemark(userId, remark) {
+    return this._r("PATCH", `/api/im/contacts/${userId}/remark`, { remark });
+  }
+  /** Block a user */
+  async block(userId) {
+    return this._r("POST", `/api/im/contacts/${userId}/block`, {});
+  }
+  /** Unblock a user */
+  async unblock(userId) {
+    return this._r("DELETE", `/api/im/contacts/${userId}/block`);
+  }
+  /** List blocked users */
+  async blocklist(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/blocked", void 0, params);
+  }
+  /** Get presence status for multiple users */
+  async getPresence(userIds) {
+    return this._r("POST", "/api/im/presence/batch", { userIds });
+  }
 };
 var BindingsClient = class {
   constructor(_r) {
@@ -1424,6 +2156,23 @@ var MemoryClient = class {
     if (scope) query.scope = scope;
     return this._r("GET", "/api/im/memory/load", void 0, query);
   }
+  /** Get memory-gene knowledge links for the authenticated user's memory files (v1.8.0) */
+  async getKnowledgeLinks() {
+    return this._r("GET", "/api/im/memory/links");
+  }
+};
+var KnowledgeLinkClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /**
+   * Get all knowledge links for a given entity.
+   * @param entityType - One of: memory, gene, capsule, signal
+   * @param entityId   - The entity ID
+   */
+  async getLinks(entityType, entityId) {
+    return this._r("GET", "/api/im/knowledge/links", void 0, { entityType, entityId });
+  }
 };
 var IdentityClient = class {
   constructor(_r) {
@@ -1526,6 +2275,62 @@ var EvolutionClient = class {
     if (limit != null) query.limit = String(limit);
     return this._r("GET", "/api/im/evolution/public/feed", void 0, query);
   }
+  // ── Leaderboard V2 (public, no auth required) ──
+  /** Get hero section global stats (total agents, genes, capsules, savings) */
+  async getLeaderboardHero() {
+    return this._r("GET", "/api/im/evolution/leaderboard/hero");
+  }
+  /** Get rising stars leaderboard */
+  async getLeaderboardRising(period, limit) {
+    const query = {};
+    if (period) query.period = period;
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/leaderboard/rising", void 0, query);
+  }
+  /** Get leaderboard summary stats (totalAgentsEvolving, totalGenesCreated, etc.) */
+  async getLeaderboardStats() {
+    return this._r("GET", "/api/im/evolution/leaderboard/stats");
+  }
+  /** Get agent improvement board */
+  async getLeaderboardAgents(period, domain) {
+    const query = {};
+    if (period) query.period = period;
+    if (domain) query.domain = domain;
+    return this._r("GET", "/api/im/evolution/leaderboard/agents", void 0, query);
+  }
+  /** Get gene impact board */
+  async getLeaderboardGenes(period, sort) {
+    const query = {};
+    if (period) query.period = period;
+    if (sort) query.sort = sort;
+    return this._r("GET", "/api/im/evolution/leaderboard/genes", void 0, query);
+  }
+  /** Get contributor board */
+  async getLeaderboardContributors(period) {
+    const query = {};
+    if (period) query.period = period;
+    return this._r("GET", "/api/im/evolution/leaderboard/contributors", void 0, query);
+  }
+  /** Get cross-environment comparison data */
+  async getLeaderboardComparison() {
+    return this._r("GET", "/api/im/evolution/leaderboard/comparison");
+  }
+  /** Get public profile page data for an agent or owner */
+  async getPublicProfile(entityId) {
+    return this._r("GET", `/api/im/evolution/profile/${encodeURIComponent(entityId)}`);
+  }
+  /** Render agent/creator card as PNG */
+  async renderCard(input) {
+    return this._r("POST", "/api/im/evolution/card/render", input);
+  }
+  /** Get benchmark data for profile FOMO section */
+  async getBenchmark() {
+    return this._r("GET", "/api/im/evolution/benchmark");
+  }
+  /** Get gene highlight capsules for profile page */
+  async getHighlights(geneId) {
+    return this._r("GET", `/api/im/evolution/highlights/${encodeURIComponent(geneId)}`);
+  }
   // ── Authenticated endpoints ──
   /** Analyze signals and get gene recommendation */
   async analyze(options) {
@@ -1607,11 +2412,11 @@ var EvolutionClient = class {
   }
   /** Delete a gene */
   async deleteGene(geneId) {
-    return this._r("DELETE", `/api/im/evolution/genes/${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/${geneId}/publish`, options?.skipCanary ? { skipCanary: true } : void 0);
+    return this._r("POST", `/api/im/evolution/genes/${encodeURIComponent(geneId)}/publish`, options?.skipCanary ? { skipCanary: true } : void 0);
   }
   /** Import a published gene */
   async importGene(geneId) {
@@ -1682,8 +2487,8 @@ var EvolutionClient = class {
     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`);
+  async installSkill(slugOrId, scope) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, scope ? { scope } : void 0);
   }
   /** Uninstall a skill */
   async uninstallSkill(slugOrId) {
@@ -1697,6 +2502,14 @@ var EvolutionClient = class {
   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.
@@ -1721,30 +2534,30 @@ var EvolutionClient = class {
     }
     const localPaths = [];
     try {
-      const fs2 = await import("fs");
-      const path2 = await import("path");
-      const os2 = await import("os");
-      const home = os2.homedir();
-      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path2.join(home, ".claude", "plugins", "prismer");
+      const fs3 = await import("fs");
+      const path3 = await import("path");
+      const os3 = await import("os");
+      const home = os3.homedir();
+      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path3.join(home, ".claude", "plugins", "prismer");
       const platformPaths = options?.project ? {
-        "claude-code": path2.join(options.projectRoot || ".", ".claude", "skills", slug),
-        "openclaw": path2.join(options.projectRoot || ".", "skills", slug),
-        "opencode": path2.join(options.projectRoot || ".", ".opencode", "skills", slug),
-        "plugin": path2.join(options.projectRoot || ".", ".claude", "plugins", "prismer", "skills", slug)
+        "claude-code": path3.join(options.projectRoot || ".", ".claude", "skills", slug),
+        "openclaw": path3.join(options.projectRoot || ".", "skills", slug),
+        "opencode": path3.join(options.projectRoot || ".", ".opencode", "skills", slug),
+        "plugin": path3.join(options.projectRoot || ".", ".claude", "plugins", "prismer", "skills", slug)
       } : {
-        "claude-code": path2.join(home, ".claude", "skills", slug),
-        "openclaw": path2.join(home, ".openclaw", "skills", slug),
-        "opencode": path2.join(home, ".config", "opencode", "skills", slug),
-        "plugin": path2.join(pluginBase, "skills", slug)
+        "claude-code": path3.join(home, ".claude", "skills", slug),
+        "openclaw": path3.join(home, ".openclaw", "skills", slug),
+        "opencode": path3.join(home, ".config", "opencode", "skills", slug),
+        "plugin": path3.join(pluginBase, "skills", slug)
       };
       const targets = options?.platforms || Object.keys(platformPaths);
       for (const platform of targets) {
         const dir = platformPaths[platform];
         if (!dir) continue;
         try {
-          fs2.mkdirSync(dir, { recursive: true });
-          const filePath = path2.join(dir, "SKILL.md");
-          fs2.writeFileSync(filePath, content, "utf-8");
+          fs3.mkdirSync(dir, { recursive: true });
+          const filePath = path3.join(dir, "SKILL.md");
+          fs3.writeFileSync(filePath, content, "utf-8");
           localPaths.push(filePath);
         } catch {
         }
@@ -1759,24 +2572,24 @@ var EvolutionClient = class {
   async uninstallSkillLocal(slugOrId) {
     const result = await this.uninstallSkill(slugOrId);
     const removedPaths = [];
-    const safeSlug = slugOrId.replace(/[\/\\]/g, "").replace(/\.\./g, "");
-    if (!safeSlug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    const slug = safeSlug(slugOrId);
+    if (!slug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
     try {
-      const fs2 = await import("fs");
-      const path2 = await import("path");
-      const os2 = await import("os");
-      const home = os2.homedir();
-      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path2.join(home, ".claude", "plugins", "prismer");
+      const fs3 = await import("fs");
+      const path3 = await import("path");
+      const os3 = await import("os");
+      const home = os3.homedir();
+      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path3.join(home, ".claude", "plugins", "prismer");
       const dirs = [
-        path2.join(home, ".claude", "skills", safeSlug),
-        path2.join(home, ".openclaw", "skills", safeSlug),
-        path2.join(home, ".config", "opencode", "skills", safeSlug),
-        path2.join(pluginBase, "skills", safeSlug)
+        path3.join(home, ".claude", "skills", slug),
+        path3.join(home, ".openclaw", "skills", slug),
+        path3.join(home, ".config", "opencode", "skills", slug),
+        path3.join(pluginBase, "skills", slug)
       ];
       for (const dir of dirs) {
         try {
-          if (fs2.existsSync(dir)) {
-            fs2.rmSync(dir, { recursive: true });
+          if (fs3.existsSync(dir)) {
+            fs3.rmSync(dir, { recursive: true });
             removedPaths.push(dir);
           }
         } catch {
@@ -1813,25 +2626,25 @@ var EvolutionClient = class {
           failed++;
           continue;
         }
-        const fs2 = await import("fs");
-        const path2 = await import("path");
-        const os2 = await import("os");
-        const home = os2.homedir();
-        const pluginBase = process.env.PRISMER_PLUGIN_DIR || path2.join(home, ".claude", "plugins", "prismer");
+        const fs3 = await import("fs");
+        const path3 = await import("path");
+        const os3 = await import("os");
+        const home = os3.homedir();
+        const pluginBase = process.env.PRISMER_PLUGIN_DIR || path3.join(home, ".claude", "plugins", "prismer");
         const platformPaths = {
-          "claude-code": path2.join(home, ".claude", "skills", slug),
-          "openclaw": path2.join(home, ".openclaw", "skills", slug),
-          "opencode": path2.join(home, ".config", "opencode", "skills", slug),
-          "plugin": path2.join(pluginBase, "skills", slug)
+          "claude-code": path3.join(home, ".claude", "skills", slug),
+          "openclaw": path3.join(home, ".openclaw", "skills", slug),
+          "opencode": path3.join(home, ".config", "opencode", "skills", slug),
+          "plugin": path3.join(pluginBase, "skills", slug)
         };
         const targets = options?.platforms || Object.keys(platformPaths);
         for (const platform of targets) {
           const dir = platformPaths[platform];
           if (!dir) continue;
           try {
-            fs2.mkdirSync(dir, { recursive: true });
-            const filePath = path2.join(dir, "SKILL.md");
-            fs2.writeFileSync(filePath, content, "utf-8");
+            fs3.mkdirSync(dir, { recursive: true });
+            const filePath = path3.join(dir, "SKILL.md");
+            fs3.writeFileSync(filePath, content, "utf-8");
             paths.push(filePath);
           } catch {
           }
@@ -1881,6 +2694,9 @@ var EvolutionClient = class {
     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 = {
@@ -1968,11 +2784,11 @@ var FilesClient = class {
     let bytes;
     let fileName;
     if (typeof input === "string") {
-      const fs2 = await import("fs");
-      const path2 = await import("path");
-      const buf = await fs2.promises.readFile(input);
+      const fs3 = await import("fs");
+      const path3 = await import("path");
+      const buf = await fs3.promises.readFile(input);
       bytes = new Uint8Array(buf);
-      fileName = opts?.fileName || path2.basename(input);
+      fileName = opts?.fileName || path3.basename(input);
     } else if (typeof Blob !== "undefined" && input instanceof Blob) {
       const ab = await input.arrayBuffer();
       bytes = new Uint8Array(ab);
@@ -2109,22 +2925,24 @@ var IMRealtimeClient = class {
   }
 };
 var IMClient = class {
-  constructor(request, wsBase, fetchFn, getAuthHeaders, offlineManager) {
-    this.account = new AccountClient(request);
-    this.direct = new DirectClient(request);
-    this.groups = new GroupsClient(request);
-    this.conversations = new ConversationsClient(request);
-    this.messages = new MessagesClient(request);
-    this.contacts = new ContactsClient(request);
-    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);
+  constructor(request2, wsBase, fetchFn, getAuthHeaders, offlineManager, communityHubConfig) {
+    this.account = new AccountClient(request2);
+    this.direct = new DirectClient(request2);
+    this.groups = new GroupsClient(request2);
+    this.conversations = new ConversationsClient(request2);
+    this.messages = new MessagesClient(request2);
+    this.contacts = new ContactsClient(request2);
+    this.bindings = new BindingsClient(request2);
+    this.credits = new CreditsClient(request2);
+    this.workspace = new WorkspaceClient(request2);
+    this.tasks = new TasksClient(request2);
+    this.memory = new MemoryClient(request2);
+    this.knowledge = new KnowledgeLinkClient(request2);
+    this.identity = new IdentityClient(request2);
+    this.security = new SecurityClient(request2);
+    this.evolution = new EvolutionClient(request2);
+    this.community = new CommunityHub(request2, communityHubConfig ?? void 0);
+    this.files = new FilesClient(request2, wsBase, fetchFn, getAuthHeaders);
     this.realtime = new IMRealtimeClient(wsBase);
     this.offline = offlineManager ?? null;
   }
@@ -2132,19 +2950,43 @@ var IMClient = class {
   async health() {
     return this.account["_r"]("GET", "/api/im/health");
   }
+  /** Get workspace superset view with slot filtering */
+  async getWorkspace(scope, slots, includeContent) {
+    const params = new URLSearchParams();
+    if (scope) params.set("scope", scope);
+    if (slots?.length) params.set("slots", slots.join(","));
+    if (includeContent) params.set("includeContent", "true");
+    return this.workspace["_r"]("GET", `/api/im/workspace/view?${params}`);
+  }
 };
 var PrismerClient = class {
   constructor(config = {}) {
     this._offlineManager = null;
-    if (config.apiKey && !config.apiKey.startsWith("sk-prismer-") && !config.apiKey.startsWith("eyJ")) {
+    /** AIP identity for auto-signing (v1.8.0 S1) */
+    this._identity = null;
+    this._identityReady = null;
+    const resolvedApiKey = resolveApiKey(config.apiKey);
+    if (resolvedApiKey && !resolvedApiKey.startsWith("sk-prismer-") && !resolvedApiKey.startsWith("eyJ")) {
       console.warn('Warning: API key should start with "sk-prismer-" (or "eyJ" for IM JWT)');
     }
-    this.apiKey = config.apiKey || "";
+    this.apiKey = resolvedApiKey;
     const envUrl = ENVIRONMENTS[config.environment || "production"];
-    this.baseUrl = (config.baseUrl || envUrl).replace(/\/$/, "");
+    this.baseUrl = (resolveBaseUrl(config.baseUrl) || envUrl).replace(/\/$/, "");
     this.timeout = config.timeout || 3e4;
     this.fetchFn = config.fetch || fetch;
     this.imAgent = config.imAgent;
+    if (config.identity) {
+      if (config.identity === "auto" && this.apiKey) {
+        this._identityReady = import_aip_sdk.AIPIdentity.fromApiKey(this.apiKey).then((id) => {
+          this._identity = id;
+        }).catch((err) => console.warn("[PrismerSDK] Identity init failed:", err));
+      } else if (typeof config.identity === "object" && config.identity.privateKey) {
+        const keyBytes = typeof Buffer !== "undefined" ? new Uint8Array(Buffer.from(config.identity.privateKey, "base64")) : new Uint8Array(atob(config.identity.privateKey).split("").map((c) => c.charCodeAt(0)));
+        this._identityReady = import_aip_sdk.AIPIdentity.fromPrivateKey(keyBytes).then((id) => {
+          this._identity = id;
+        }).catch((err) => console.warn("[PrismerSDK] Identity init failed:", err));
+      }
+    }
     if (config.offline) {
       this._offlineManager = new OfflineManager(
         config.offline.storage,
@@ -2155,15 +2997,61 @@ var PrismerClient = class {
         (err) => console.warn("[PrismerSDK] Offline storage init failed:", err)
       );
     }
-    const imRequest = this._offlineManager ? (m, p, b, q) => this._offlineManager.dispatch(m, p, b, q) : (m, p, b, q) => this._request(m, p, b, q);
+    let imRequest = this._offlineManager ? (m, p, b, q) => this._offlineManager.dispatch(m, p, b, q) : (m, p, b, q) => this._request(m, p, b, q);
+    if (config.identity) {
+      const baseRequest = imRequest;
+      imRequest = (method, path3, body, query) => {
+        if (method === "POST" && path3.includes("/messages") && body) {
+          const b = body;
+          if (!b.signature && !b.skipSigning) {
+            const ready = this._identityReady || Promise.resolve();
+            return ready.then(() => {
+              if (this._identity) {
+                return this._signAndSend(baseRequest, method, path3, b, query);
+              }
+              return baseRequest(method, path3, body, query);
+            });
+          }
+        }
+        return baseRequest(method, path3, body, query);
+      };
+    }
     this.im = new IMClient(
       imRequest,
       this.baseUrl,
       this.fetchFn,
       () => this._getAuthHeaders(),
-      this._offlineManager
+      this._offlineManager,
+      config.community ?? null
     );
   }
+  /** Wait for identity to be ready (useful for tests or explicit await) */
+  async ensureIdentity() {
+    if (this._identityReady) await this._identityReady;
+    return this._identity;
+  }
+  /** Auto-sign a message body and send (v1.8.0 S1) */
+  async _signAndSend(baseRequest, method, path3, body, query) {
+    if (this._identityReady) await this._identityReady;
+    if (!this._identity) return baseRequest(method, path3, body, query);
+    const content = body.content || "";
+    const contentHashBytes = new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content))
+    );
+    const contentHash = Array.from(contentHashBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const timestamp = Date.now();
+    const payload = `1|${this._identity.did}|${body.type || "text"}|${timestamp}|${contentHash}`;
+    const payloadBytes = new TextEncoder().encode(payload);
+    const signature = await this._identity.sign(payloadBytes);
+    return baseRequest(method, path3, {
+      ...body,
+      secVersion: 1,
+      senderDid: this._identity.did,
+      contentHash,
+      signature,
+      signedAt: timestamp
+    }, query);
+  }
   /** Build auth headers for raw HTTP requests (used by file upload) */
   _getAuthHeaders() {
     const headers = {};
@@ -2187,11 +3075,11 @@ var PrismerClient = class {
   // --------------------------------------------------------------------------
   // Internal request helper
   // --------------------------------------------------------------------------
-  async _request(method, path2, body, query, _isRetry) {
+  async _request(method, path3, body, query, _isRetry) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     try {
-      let url = `${this.baseUrl}${path2}`;
+      let url = `${this.baseUrl}${path3}`;
       if (query && Object.keys(query).length > 0) {
         url += "?" + new URLSearchParams(query).toString();
       }
@@ -2209,12 +3097,12 @@ var PrismerClient = class {
       }
       const response = await this.fetchFn(url, init);
       const data = await response.json();
-      if (response.status === 401 && this.apiKey.startsWith("eyJ") && !_isRetry && !path2.includes("/token/refresh")) {
+      if (response.status === 401 && this.apiKey.startsWith("eyJ") && !_isRetry && !path3.includes("/token/refresh")) {
         try {
           const refreshRes = await this._request("POST", "/api/im/token/refresh", void 0, void 0, true);
           if (refreshRes?.ok && refreshRes?.data?.token) {
             this.apiKey = refreshRes.data.token;
-            return this._request(method, path2, body, query, true);
+            return this._request(method, path3, body, query, true);
           }
         } catch {
         }
@@ -3285,49 +4173,95 @@ function register3(parent, getIMClient2, _getAPIClient) {
       handleError(err);
     }
   });
-  evolve.command("import <gene-id>").description("Import a published gene into your collection").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+  evolve.command("publish <gene-id>").description("Publish a private gene to the evolution network").option("--skip-canary", "skip canary phase and publish directly").option("--json", "output raw JSON response").action(async (geneId, opts) => {
     const client = getIMClient2();
     try {
-      const res = await client.im.evolution.importGene(geneId);
+      const res = await client.im.evolution.publishGene(geneId, { skipCanary: opts.skipCanary });
       if (opts.json) {
         process.stdout.write(JSON.stringify(res, null, 2) + "\n");
         return;
       }
-      printResult(res, `Gene imported: ${geneId}`);
+      printResult(res, `Gene ${geneId} published${opts.skipCanary ? " (skipped canary)" : " (canary phase)"}`);
     } catch (err) {
       handleError(err);
     }
   });
-  evolve.command("distill").description("Trigger gene distillation (consolidate learnings)").option("--dry-run", "preview distillation without applying changes").option("--json", "output raw JSON response").action(async (opts) => {
+  evolve.command("fork <gene-id>").description("Fork a public gene with optional modifications").option("--strategy <steps...>", "override strategy steps").option("--json", "output raw JSON response").action(async (geneId, opts) => {
     const client = getIMClient2();
     try {
-      const res = await client.im.evolution.distill(opts.dryRun);
+      const res = await client.im.evolution.forkGene({
+        gene_id: geneId,
+        modifications: opts.strategy ? { strategy: opts.strategy } : void 0
+      });
       if (opts.json) {
         process.stdout.write(JSON.stringify(res, null, 2) + "\n");
         return;
       }
       printResult(res);
       const data = res.data;
-      if (opts.dryRun) {
-        process.stdout.write("Dry-run distillation preview:\n");
-      } else {
-        process.stdout.write("Distillation triggered.\n");
-      }
-      if (data) {
-        for (const [key, val] of Object.entries(data)) {
-          process.stdout.write(`  ${key}: ${JSON.stringify(val)}
+      const newId = data?.id ?? data?.gene_id ?? "unknown";
+      process.stdout.write(`Forked gene ${geneId} \u2192 ${newId}
 `);
-        }
-      }
     } catch (err) {
       handleError(err);
     }
   });
-}
-
-// src/commands/task.ts
-function register4(parent, getIMClient2, _getAPIClient) {
-  const task = parent.command("task").description("Manage tasks in the task marketplace");
+  evolve.command("delete <gene-id>").description("Delete a gene you own").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.deleteGene(geneId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res, `Gene ${geneId} deleted`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("import <gene-id>").description("Import a published gene into your collection").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.importGene(geneId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res, `Gene imported: ${geneId}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("distill").description("Trigger gene distillation (consolidate learnings)").option("--dry-run", "preview distillation without applying changes").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.distill(opts.dryRun);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (opts.dryRun) {
+        process.stdout.write("Dry-run distillation preview:\n");
+      } else {
+        process.stdout.write("Distillation triggered.\n");
+      }
+      if (data) {
+        for (const [key, val] of Object.entries(data)) {
+          process.stdout.write(`  ${key}: ${JSON.stringify(val)}
+`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/task.ts
+function register4(parent, getIMClient2, _getAPIClient) {
+  const task = parent.command("task").description("Manage tasks in the task marketplace");
   task.command("create").description("Create a new task").requiredOption("--title <title>", "task title").option("--description <description>", "task description").option("--priority <priority>", "priority: low, normal, high, urgent").option("--capability <capability>", "required agent capability").option("--budget <budget>", "budget in credits", parseFloat).option("--json", "output raw JSON response").action(async (opts) => {
     const client = getIMClient2();
     try {
@@ -3840,7 +4774,7 @@ function printFileTable(files) {
   const idLen = Math.max(2, ...files.map((f) => f.id.length));
   const scopeLen = Math.max(5, ...files.map((f) => f.scope.length));
   const pathLen = Math.max(4, ...files.map((f) => f.path.length));
-  const row = (id, scope, path2) => `${id.padEnd(idLen)}  ${scope.padEnd(scopeLen)}  ${path2.padEnd(pathLen)}`;
+  const row = (id, scope, path3) => `${id.padEnd(idLen)}  ${scope.padEnd(scopeLen)}  ${path3.padEnd(pathLen)}`;
   process.stdout.write(row("ID", "SCOPE", "PATH") + "\n");
   process.stdout.write(`${"-".repeat(idLen)}  ${"-".repeat(scopeLen)}  ${"-".repeat(pathLen)}
 `);
@@ -4597,29 +5531,665 @@ function register9(parent, getIMClient2, _getAPIClient) {
   });
 }
 
+// src/commands/community.ts
+var import_node_fs = require("fs");
+function printJson(res, opts) {
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.ok) {
+    const errMsg = res.error && typeof res.error === "object" && "message" in res.error ? res.error.message : JSON.stringify(res.error);
+    console.error("Error:", errMsg || "Unknown");
+    process.exit(1);
+  }
+  console.log(typeof res.data === "string" ? res.data : JSON.stringify(res.data, null, 2));
+}
+function formatPostsMarkdown(data) {
+  const d = data;
+  const posts = d?.posts ?? [];
+  let t = "## Feed\n\n";
+  if (posts.length === 0) return t + "_Empty._\n";
+  for (const p of posts) {
+    t += `- **${String(p.title || "")}** (\`${String(p.id)}\`) \u2014 ${String(p.boardId || "")}
+`;
+  }
+  if (d?.nextCursor) t += `
+_Next cursor:_ \`${d.nextCursor}\`
+`;
+  return t;
+}
+function register10(parent, getIMClient2, _getAPIClient) {
+  const comm = parent.command("community").description("Evolution community forum \u2014 feed, ask, search, notify");
+  comm.command("feed").description("Browse posts (uses hub cache when fresh)").option("-b, --board <id>", "Board: showcase, genelab, helpdesk, ideas, changelog").option("-n, --limit <n>", "Max posts", "15").option("--json", "JSON output").action(async (opts) => {
+    const c = getIMClient2();
+    const res = await c.im.community.feed({
+      boardId: opts.board,
+      limit: parseInt(opts.limit || "15", 10)
+    });
+    if (opts.json) {
+      printJson(res, opts);
+      return;
+    }
+    if (!res.ok) {
+      printJson(res, { json: false });
+      return;
+    }
+    process.stdout.write(formatPostsMarkdown(res.data));
+  });
+  comm.command("ask").description("Post a helpdesk question").argument("<title>", "Title").argument("[body]", "Body (Markdown); omit if using --file").option("-f, --file <path>", "Read body from file").option("--tags <csv>", "Comma-separated tags").option("--json", "JSON output").action(async (title, body, opts) => {
+    const content = opts.file ? (0, import_node_fs.readFileSync)(opts.file, "utf8") : body || "(no body)";
+    const tags = opts.tags?.split(",").map((s) => s.trim()).filter(Boolean);
+    const c = getIMClient2();
+    const res = await c.im.community.ask(title, content, tags);
+    printJson(res, opts);
+  });
+  comm.command("search").description("Full-text community search").argument("<query>", "Search query").option("-b, --board <id>", "Limit to board").option("-n, --limit <n>", "Max hits", "8").option("--json", "JSON output").action(async (query, opts) => {
+    const c = getIMClient2();
+    const res = await c.im.community.search(query, {
+      boardId: opts.board,
+      limit: parseInt(opts.limit || "8", 10)
+    });
+    printJson(res, opts);
+  });
+  comm.command("check").description("List notifications; optionally mark all read").option("--unread-only", "Unread only").option("--mark-read", "Mark all read after listing").option("--json", "JSON output").action(async (opts) => {
+    const c = getIMClient2();
+    const list = await c.im.community.getNotifications({
+      unread: opts.unreadOnly,
+      limit: 50
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(list, null, 2));
+    } else if (list.ok && list.data) {
+      const payload = list.data;
+      console.log(`## Notifications (${payload.items?.length ?? 0})
+`);
+      console.log(JSON.stringify(list.data, null, 2));
+    } else {
+      printJson(list, { json: false });
+    }
+    if (opts.markRead) {
+      const mr = await c.im.community.markNotificationsRead();
+      if (opts.json) console.log(JSON.stringify(mr, null, 2));
+      else console.log("\nMarked read:", mr.ok ? "ok" : mr.error);
+    }
+  });
+  comm.command("report").description("Publish a showcase battle-report style post").requiredOption("-t, --title <t>", "Title").option("-c, --content <md>", "Body markdown").option("--genes <csv>", "Linked gene IDs").option("--agent <id>", "linkedAgentId").option("--json", "JSON output").action(async (opts) => {
+    const c = getIMClient2();
+    const geneIds = opts.genes?.split(",").map((s) => s.trim()).filter(Boolean);
+    const res = await c.im.community.reportBattle({
+      title: opts.title,
+      content: opts.content || "_Battle report_",
+      linkedGeneIds: geneIds,
+      linkedAgentId: opts.agent
+    });
+    printJson(res, opts);
+  });
+  comm.command("post").description("Create a post on any board").argument("<board>", "Board id").argument("<title>", "Title").option("-c, --content <md>", "Body", "").option("--tags <csv>", "Tags").option("--json", "JSON output").action(async (board, title, opts) => {
+    const tags = opts.tags?.split(",").map((s) => s.trim()).filter(Boolean);
+    const c = getIMClient2();
+    const res = await c.im.community.createPost({
+      boardId: board,
+      title,
+      content: opts.content || "",
+      tags
+    });
+    if (res.ok) c.im.community.invalidateCache(board);
+    printJson(res, opts);
+  });
+  comm.command("reply").description("Comment on a post").argument("<postId>", "Post ID").argument("<content>", "Comment (markdown)").option("--json", "JSON output").action(async (postId, content, opts) => {
+    const c = getIMClient2();
+    const res = await c.im.community.createComment(postId, { content });
+    printJson(res, opts);
+  });
+  comm.command("vote").description("Vote on post or comment").argument("<type>", "post | comment").argument("<id>", "Target id").argument("<value>", "up | down | cancel").option("--json", "JSON output").action(async (type, id, value, opts) => {
+    const tt = type === "comment" ? "comment" : "post";
+    let v = 0;
+    if (value === "up") v = 1;
+    else if (value === "down") v = -1;
+    const c = getIMClient2();
+    const res = await c.im.community.vote(tt, id, v);
+    printJson(res, opts);
+  });
+  const my = comm.command("my").description("Your bookmarks (auth)");
+  my.command("bookmarks").description("List bookmarked posts").option("--json", "JSON output").action(async (opts) => {
+    const c = getIMClient2();
+    const res = await c.im.community.listBookmarks({ limit: 30 });
+    printJson(res, opts);
+  });
+}
+
+// src/daemon.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_path = require("path");
+var os = __toESM(require("os"));
+var import_os = require("os");
+var http = __toESM(require("http"));
+var import_http = require("http");
+var import_child_process = require("child_process");
+var TOML = __toESM(require("@iarna/toml"));
+var CONFIG_DIR = path.join(os.homedir(), ".prismer");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.toml");
+var PID_PATH = path.join(CONFIG_DIR, "daemon.pid");
+var PORT_PATH = path.join(CONFIG_DIR, "daemon.port");
+var CACHE_DIR = path.join(CONFIG_DIR, "cache");
+var EVOLUTION_CACHE_PATH = path.join(CACHE_DIR, "evolution.json");
+var OUTBOX_PATH = path.join(CACHE_DIR, "outbox.json");
+var SYNC_INTERVAL_MS = 6e4;
+var FLUSH_INTERVAL_MS = 3e4;
+var API_TIMEOUT_MS = 1e4;
+var EVENTS_FILE = (0, import_path.join)(CACHE_DIR, "events.json");
+var MAX_EVENTS = 1e3;
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) return null;
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+    const parsed = TOML.parse(raw);
+    const apiKey = parsed?.default?.api_key || "";
+    const baseUrl = parsed?.default?.base_url || "https://prismer.cloud";
+    if (!apiKey) return null;
+    return { apiKey, baseUrl };
+  } catch {
+    return null;
+  }
+}
+function ensureCacheDir() {
+  if (!fs.existsSync(CACHE_DIR)) {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+function loadEvents() {
+  try {
+    return JSON.parse(fs.readFileSync(EVENTS_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function appendEvent(event) {
+  const events = loadEvents();
+  events.push(event);
+  if (events.length > MAX_EVENTS) events.splice(0, events.length - MAX_EVENTS);
+  fs.writeFileSync(EVENTS_FILE, JSON.stringify(events), { encoding: "utf-8", mode: 384 });
+}
+function emitSyncEvent(genesCount) {
+  if (genesCount > 0) {
+    appendEvent({
+      type: "evolution.sync",
+      source: "evolution",
+      priority: "low",
+      title: "Evolution sync complete",
+      body: `${genesCount} genes updated`,
+      timestamp: Date.now()
+    });
+  }
+}
+function readPid() {
+  if (!fs.existsSync(PID_PATH)) return null;
+  try {
+    const raw = fs.readFileSync(PID_PATH, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+function readPort() {
+  if (!fs.existsSync(PORT_PATH)) return null;
+  try {
+    const raw = fs.readFileSync(PORT_PATH, "utf-8").trim();
+    const port = parseInt(raw, 10);
+    return isNaN(port) ? null : port;
+  } catch {
+    return null;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writePid(pid) {
+  ensureCacheDir();
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(PID_PATH, String(pid), { encoding: "utf-8", mode: 384 });
+}
+function writePort(port) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(PORT_PATH, String(port), { encoding: "utf-8", mode: 384 });
+}
+function cleanupPidFiles() {
+  try {
+    if (fs.existsSync(PID_PATH)) fs.unlinkSync(PID_PATH);
+  } catch {
+  }
+  try {
+    if (fs.existsSync(PORT_PATH)) fs.unlinkSync(PORT_PATH);
+  } catch {
+  }
+}
+async function fetchWithTimeout(url, options, timeoutMs = API_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function runDaemonProcess() {
+  const cfg = loadConfig();
+  if (!cfg) {
+    process.stderr.write('[prismer-daemon] No config found. Run "prismer setup" first.\n');
+    process.exit(1);
+  }
+  ensureCacheDir();
+  let lastSync = 0;
+  let syncCount = 0;
+  let evolutionCursor = 0;
+  if (fs.existsSync(EVOLUTION_CACHE_PATH)) {
+    try {
+      const cached = JSON.parse(fs.readFileSync(EVOLUTION_CACHE_PATH, "utf-8"));
+      if (typeof cached?.cursor === "number") evolutionCursor = cached.cursor;
+    } catch {
+    }
+  }
+  const server = (0, import_http.createServer)((req, res) => {
+    if (req.method === "GET" && req.url === "/health") {
+      let outboxSize = 0;
+      if (fs.existsSync(OUTBOX_PATH)) {
+        try {
+          const entries = JSON.parse(fs.readFileSync(OUTBOX_PATH, "utf-8"));
+          if (Array.isArray(entries)) outboxSize = entries.length;
+        } catch {
+        }
+      }
+      const body = JSON.stringify({
+        pid: process.pid,
+        uptime: Math.floor(process.uptime()),
+        lastSync,
+        syncCount,
+        outboxSize
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(body);
+    } else if (req.method === "GET" && req.url === "/events") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      const events = loadEvents();
+      res.end(JSON.stringify(events.slice(-50)));
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(0, "127.0.0.1", () => {
+    const addr = server.address();
+    const port = addr.port;
+    writePid(process.pid);
+    writePort(port);
+    process.stdout.write(`[prismer-daemon] Started. PID=${process.pid} port=${port}
+`);
+  });
+  const shutdown = () => {
+    process.stdout.write("[prismer-daemon] Shutting down.\n");
+    cleanupPidFiles();
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  const doEvolutionSync = async () => {
+    try {
+      const res = await fetchWithTimeout(
+        `${cfg.baseUrl}/api/im/evolution/sync`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${cfg.apiKey}`
+          },
+          body: JSON.stringify({ pull: { since: evolutionCursor, scope: "global" } })
+        }
+      );
+      if (res.ok) {
+        const data = await res.json();
+        lastSync = Date.now();
+        syncCount++;
+        if (typeof data?.data?.cursor === "number") {
+          evolutionCursor = data.data.cursor;
+        } else if (typeof data?.cursor === "number") {
+          evolutionCursor = data.cursor;
+        }
+        ensureCacheDir();
+        const pulled = data?.data || data;
+        fs.writeFileSync(
+          EVOLUTION_CACHE_PATH,
+          JSON.stringify({ cursor: evolutionCursor, lastSync, data: pulled }, null, 2),
+          { encoding: "utf-8", mode: 384 }
+        );
+        emitSyncEvent(pulled?.genes?.length || 0);
+      }
+    } catch {
+    }
+  };
+  const doOutboxFlush = async () => {
+    if (!fs.existsSync(OUTBOX_PATH)) return;
+    let entries = [];
+    try {
+      entries = JSON.parse(fs.readFileSync(OUTBOX_PATH, "utf-8"));
+      if (!Array.isArray(entries) || entries.length === 0) return;
+    } catch {
+      return;
+    }
+    try {
+      const res = await fetchWithTimeout(
+        `${cfg.baseUrl}/api/im/evolution/sync`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${cfg.apiKey}`
+          },
+          body: JSON.stringify({
+            push: { outcomes: entries },
+            pull: { since: 0 }
+          })
+        }
+      );
+      if (res.ok) {
+        fs.writeFileSync(OUTBOX_PATH, "[]", { encoding: "utf-8", mode: 384 });
+      }
+    } catch {
+    }
+  };
+  await doEvolutionSync();
+  await doOutboxFlush();
+  const syncTimer = setInterval(doEvolutionSync, SYNC_INTERVAL_MS);
+  const flushTimer = setInterval(doOutboxFlush, FLUSH_INTERVAL_MS);
+  const originalShutdown = shutdown;
+  const fullShutdown = () => {
+    clearInterval(syncTimer);
+    clearInterval(flushTimer);
+    originalShutdown();
+  };
+  process.removeListener("SIGINT", shutdown);
+  process.removeListener("SIGTERM", shutdown);
+  process.on("SIGINT", fullShutdown);
+  process.on("SIGTERM", fullShutdown);
+}
+async function startDaemon() {
+  const existingPid = readPid();
+  if (existingPid !== null && isProcessRunning(existingPid)) {
+    const port = readPort();
+    console.log(`Daemon already running. PID=${existingPid}${port ? ` port=${port}` : ""}`);
+    return;
+  }
+  cleanupPidFiles();
+  const cfg = loadConfig();
+  if (!cfg) {
+    console.error('No API key found. Run "prismer setup" first.');
+    process.exit(1);
+  }
+  if (process.env["PRISMER_DAEMON"] === "1") {
+    await runDaemonProcess();
+    return;
+  }
+  const { spawn } = require("child_process");
+  const child = spawn(process.execPath, [process.argv[1], "daemon", "start"], {
+    env: { ...process.env, PRISMER_DAEMON: "1" },
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  let waited = 0;
+  while (waited < 3e3) {
+    await new Promise((r) => setTimeout(r, 100));
+    waited += 100;
+    const pid = readPid();
+    const port = readPort();
+    if (pid !== null && port !== null) {
+      console.log(`Daemon started. PID=${pid} port=${port}`);
+      return;
+    }
+  }
+  console.log("Daemon spawned (PID file not yet written \u2014 may take a moment).");
+}
+function stopDaemon() {
+  const pid = readPid();
+  if (pid === null || !isProcessRunning(pid)) {
+    console.log("Daemon: not running");
+    cleanupPidFiles();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`Daemon stopped (PID=${pid})`);
+    cleanupPidFiles();
+  } catch (err) {
+    console.error(`Failed to stop daemon: ${err.message}`);
+  }
+}
+function daemonStatus() {
+  const pid = readPid();
+  if (pid === null || !isProcessRunning(pid)) {
+    console.log("Daemon: not running");
+    cleanupPidFiles();
+    return;
+  }
+  const port = readPort();
+  if (!port) {
+    console.log(`Daemon: running (PID=${pid}, port unknown)`);
+    return;
+  }
+  const req = http.request(
+    { hostname: "127.0.0.1", port, path: "/health", method: "GET", timeout: 3e3 },
+    (res) => {
+      let body = "";
+      res.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      res.on("end", () => {
+        try {
+          const health = JSON.parse(body);
+          console.log(`Daemon: running`);
+          console.log(`  PID:        ${health.pid}`);
+          console.log(`  Uptime:     ${health.uptime}s`);
+          console.log(`  Last sync:  ${health.lastSync ? new Date(health.lastSync).toISOString() : "never"}`);
+          console.log(`  Sync count: ${health.syncCount}`);
+          console.log(`  Outbox:     ${health.outboxSize} entries`);
+          console.log(`  Port:       ${port}`);
+        } catch {
+          console.log(`Daemon: running (PID=${pid} port=${port})`);
+        }
+      });
+    }
+  );
+  req.on("error", () => {
+    console.log(`Daemon: running (PID=${pid} port=${port}, health check failed)`);
+  });
+  req.end();
+}
+function resolveNpxPath() {
+  try {
+    return (0, import_child_process.execSync)("which npx", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    for (const p of ["/usr/local/bin/npx", "/opt/homebrew/bin/npx", `${(0, import_os.homedir)()}/.nvm/current/bin/npx`]) {
+      try {
+        fs.accessSync(p);
+        return p;
+      } catch {
+      }
+    }
+    return "npx";
+  }
+}
+function installLaunchd() {
+  const plistPath = (0, import_path.join)((0, import_os.homedir)(), "Library", "LaunchAgents", "cloud.prismer.daemon.plist");
+  const npxPath = resolveNpxPath();
+  const nodePath = process.execPath;
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>cloud.prismer.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${npxPath}</string>
+    <string>@prismer/sdk</string>
+    <string>daemon</string>
+    <string>start</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PRISMER_DAEMON</key>
+    <string>1</string>
+    <key>PATH</key>
+    <string>${(0, import_path.dirname)(nodePath)}:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${(0, import_path.join)((0, import_os.homedir)(), ".prismer", "daemon.stdout.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${(0, import_path.join)((0, import_os.homedir)(), ".prismer", "daemon.stderr.log")}</string>
+</dict>
+</plist>`;
+  fs.mkdirSync((0, import_path.dirname)(plistPath), { recursive: true });
+  fs.writeFileSync(plistPath, plist, { mode: 384 });
+  try {
+    (0, import_child_process.execSync)(`launchctl load ${plistPath}`, { stdio: "pipe" });
+    console.log("[prismer] Daemon service installed and started (launchd)");
+    console.log(`  Plist: ${plistPath}`);
+  } catch {
+    console.log("[prismer] Plist written. Load manually: launchctl load " + plistPath);
+  }
+}
+function uninstallLaunchd() {
+  const plistPath = (0, import_path.join)((0, import_os.homedir)(), "Library", "LaunchAgents", "cloud.prismer.daemon.plist");
+  try {
+    (0, import_child_process.execSync)(`launchctl unload ${plistPath}`, { stdio: "pipe" });
+  } catch {
+  }
+  try {
+    fs.unlinkSync(plistPath);
+  } catch {
+  }
+  console.log("[prismer] Daemon service uninstalled (launchd)");
+}
+function installSystemd() {
+  const serviceDir = (0, import_path.join)((0, import_os.homedir)(), ".config", "systemd", "user");
+  const servicePath = (0, import_path.join)(serviceDir, "prismer-daemon.service");
+  const npxPath = resolveNpxPath();
+  const nodePath = process.execPath;
+  const unit = `[Unit]
+Description=Prismer Daemon \u2014 background evolution sync
+After=network-online.target
+
+[Service]
+Type=simple
+Environment=PRISMER_DAEMON=1
+Environment=PATH=${(0, import_path.dirname)(nodePath)}:/usr/local/bin:/usr/bin:/bin
+ExecStart=${npxPath} @prismer/sdk daemon start
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+  fs.mkdirSync(serviceDir, { recursive: true });
+  fs.writeFileSync(servicePath, unit, { mode: 420 });
+  try {
+    (0, import_child_process.execSync)("systemctl --user daemon-reload", { stdio: "pipe" });
+    (0, import_child_process.execSync)("systemctl --user enable prismer-daemon", { stdio: "pipe" });
+    (0, import_child_process.execSync)("systemctl --user start prismer-daemon", { stdio: "pipe" });
+    console.log("[prismer] Daemon service installed and started (systemd)");
+    console.log(`  Service: ${servicePath}`);
+  } catch {
+    console.log("[prismer] Service file written. Enable manually:");
+    console.log("  systemctl --user enable --now prismer-daemon");
+  }
+}
+function uninstallSystemd() {
+  try {
+    (0, import_child_process.execSync)("systemctl --user stop prismer-daemon", { stdio: "pipe" });
+  } catch {
+  }
+  try {
+    (0, import_child_process.execSync)("systemctl --user disable prismer-daemon", { stdio: "pipe" });
+  } catch {
+  }
+  const servicePath = (0, import_path.join)((0, import_os.homedir)(), ".config", "systemd", "user", "prismer-daemon.service");
+  try {
+    fs.unlinkSync(servicePath);
+  } catch {
+  }
+  try {
+    (0, import_child_process.execSync)("systemctl --user daemon-reload", { stdio: "pipe" });
+  } catch {
+  }
+  console.log("[prismer] Daemon service uninstalled (systemd)");
+}
+function installDaemonService() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    installLaunchd();
+  } else if (platform === "linux") {
+    installSystemd();
+  } else {
+    console.log(`Daemon auto-start not supported on ${platform}. Use: prismer daemon start`);
+  }
+}
+function uninstallDaemonService() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    uninstallLaunchd();
+  } else if (platform === "linux") {
+    uninstallSystemd();
+  } else {
+    console.log(`No daemon service to uninstall on ${platform}.`);
+  }
+}
+if (process.env["PRISMER_DAEMON"] === "1") {
+  runDaemonProcess().catch((err) => {
+    process.stderr.write(`[prismer-daemon] Fatal: ${err.message}
+`);
+    process.exit(1);
+  });
+}
+
 // src/cli.ts
 var cliVersion = "1.7.2";
 try {
-  const pkgPath = path.join(__dirname, "..", "package.json");
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  const pkgPath = path2.join(__dirname, "..", "package.json");
+  const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
   cliVersion = pkg.version || cliVersion;
 } catch {
 }
-var CONFIG_DIR = path.join(os.homedir(), ".prismer");
-var CONFIG_PATH = path.join(CONFIG_DIR, "config.toml");
+var CONFIG_DIR2 = path2.join(os2.homedir(), ".prismer");
+var CONFIG_PATH2 = path2.join(CONFIG_DIR2, "config.toml");
 function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!fs2.existsSync(CONFIG_DIR2)) {
+    fs2.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
 }
 function readConfig() {
-  if (!fs.existsSync(CONFIG_PATH)) return {};
-  const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
-  return TOML.parse(raw);
+  if (!fs2.existsSync(CONFIG_PATH2)) return {};
+  const raw = fs2.readFileSync(CONFIG_PATH2, "utf-8");
+  return TOML2.parse(raw);
 }
 function writeConfig(config) {
   ensureConfigDir();
-  fs.writeFileSync(CONFIG_PATH, TOML.stringify(config), "utf-8");
+  fs2.writeFileSync(CONFIG_PATH2, TOML2.stringify(config), { encoding: "utf-8", mode: 384 });
 }
 function setNestedValue(obj, dotPath, value) {
   const parts = dotPath.split(".");
@@ -4635,7 +6205,7 @@ function getIMClient() {
   const cfg = readConfig();
   const token = cfg?.auth?.im_token;
   if (!token) {
-    console.error('No IM token. Run "prismer register" first.');
+    console.error('No IM token. Run "prismer setup --agent" or "prismer register <username>" first.');
     process.exit(1);
   }
   const env = cfg?.default?.environment || "production";
@@ -4646,7 +6216,7 @@ function getAPIClient() {
   const cfg = readConfig();
   const apiKey = cfg?.default?.api_key;
   if (!apiKey) {
-    console.error('No API key. Run "prismer init <api-key>" first.');
+    console.error('No API key. Run "prismer setup" to sign in and get your key.');
     process.exit(1);
   }
   const env = cfg?.default?.environment || "production";
@@ -4655,20 +6225,196 @@ function getAPIClient() {
 }
 var program = new import_commander.Command();
 program.name("prismer").description("Prismer Cloud SDK CLI").version(cliVersion);
-program.command("init <api-key>").description("Store API key in ~/.prismer/config.toml").action((apiKey) => {
-  const config = readConfig();
+async function verifyAndSaveKey(config, apiKey) {
+  if (!apiKey) {
+    console.error("No key provided.");
+    process.exit(1);
+  }
+  if (!apiKey.startsWith("sk-prismer-")) {
+    console.error("Invalid key format. API keys start with sk-prismer-");
+    console.error("Get your key at: https://prismer.cloud/setup");
+    process.exit(1);
+  }
+  const baseUrl = config.default?.base_url || "https://prismer.cloud";
+  try {
+    const res = await fetch(`${baseUrl}/api/version`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (res.status === 401) {
+      console.error("API key is invalid or expired.");
+      console.error("Get a new key at: https://prismer.cloud/setup");
+      process.exit(1);
+    }
+    console.log("API key verified \u2713");
+  } catch (err) {
+    console.warn(`Could not verify key (${err.message}). Saving anyway.`);
+  }
   if (!config.default) config.default = {};
   config.default.api_key = apiKey;
   if (!config.default.environment) config.default.environment = "production";
-  if (config.default.base_url === void 0) config.default.base_url = "";
   writeConfig(config);
-  console.log("API key saved to ~/.prismer/config.toml");
+  console.log("");
+  console.log("Saved to ~/.prismer/config.toml");
+  console.log("You can now use: CLI commands, MCP tools, Claude Code plugin, and all SDKs.");
+  try {
+    installDaemonService();
+  } catch {
+    console.log("Daemon auto-start setup skipped. Run manually: prismer daemon install");
+  }
+}
+function openBrowser(url) {
+  const { execFile } = require("child_process");
+  if (process.platform === "darwin") {
+    execFile("open", [url], (err) => {
+      if (err) console.warn("Could not open browser. Please open the URL above manually.");
+    });
+  } else if (process.platform === "win32") {
+    execFile("cmd.exe", ["/c", "start", "", url], (err) => {
+      if (err) console.warn("Could not open browser. Please open the URL above manually.");
+    });
+  } else {
+    execFile("xdg-open", [url], (err) => {
+      if (err) console.warn("Could not open browser. Please open the URL above manually.");
+    });
+  }
+}
+async function runSetup(opts, apiKey) {
+  const config = readConfig();
+  if (!config.default) config.default = {};
+  const baseUrl = config.default.base_url || "https://prismer.cloud";
+  if (!opts.force && config.default.api_key?.startsWith("sk-prismer-")) {
+    const masked = config.default.api_key.slice(0, 12) + "..." + config.default.api_key.slice(-4);
+    console.log(`Already configured: ${masked}`);
+    console.log("");
+    console.log("To reconfigure, run: prismer setup --force");
+    console.log("To check status:     prismer status");
+    return;
+  }
+  if (apiKey) {
+    await verifyAndSaveKey(config, apiKey);
+    return;
+  }
+  if (opts.agent) {
+    if (!opts.force && config.auth?.im_token) {
+      console.log("Already registered as agent (IM token exists).");
+      console.log("For API key access, run: prismer setup");
+      return;
+    }
+    const username = `agent-${Date.now().toString(36)}`;
+    try {
+      const res = await fetch(`${baseUrl}/api/im/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ username, displayName: username, type: "agent" })
+      });
+      const data = await res.json();
+      if (!data.ok) throw new Error(data.error?.message || "Registration failed");
+      if (!config.auth) config.auth = {};
+      config.auth.im_token = data.data?.token;
+      config.auth.im_user_id = data.data?.imUserId || data.data?.userId;
+      config.auth.im_username = data.data?.username || username;
+      writeConfig(config);
+      console.log("Agent registered with free credits \u2713");
+      console.log(`  Username: ${config.auth.im_username}`);
+      console.log(`  User ID:  ${config.auth.im_user_id}`);
+      console.log("");
+      console.log("For full API access, sign in: prismer setup");
+    } catch (err) {
+      console.error(`Agent registration failed: ${err.message}`);
+      console.error("Try signing in instead: prismer setup");
+      process.exit(1);
+    }
+    return;
+  }
+  if (opts.manual) {
+    const setupUrl = `${baseUrl}/setup?utm_source=cli&utm_medium=manual`;
+    console.log("Opening browser to sign in...");
+    console.log(`  ${setupUrl}`);
+    console.log("");
+    openBrowser(setupUrl);
+    console.log("After signing in, copy the API key from the page and paste it below.");
+    console.log("");
+    const readline = require("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question("Paste your API key: ", (key) => {
+      rl.close();
+      verifyAndSaveKey(config, key.trim()).catch((err) => {
+        console.error(`Setup failed: ${err.message}`);
+        process.exit(1);
+      });
+    });
+    return;
+  }
+  const http2 = require("http");
+  const crypto2 = require("crypto");
+  const state = crypto2.randomBytes(16).toString("hex");
+  let resolved = false;
+  const server = http2.createServer((req, res) => {
+    const url = new URL(req.url, `http://localhost`);
+    if (url.pathname === "/callback") {
+      const key = url.searchParams.get("key");
+      const returnedState = url.searchParams.get("state");
+      res.writeHead(200, { "Content-Type": "text/html" });
+      if (!key || !returnedState || returnedState !== state) {
+        res.end('<html><head><meta name="referrer" content="no-referrer"></head><body style="font-family:system-ui;text-align:center;padding:60px"><h2>Setup failed</h2><p>Invalid or missing parameters. Please try again.</p></body></html>');
+        return;
+      }
+      if (!key.startsWith("sk-prismer-")) {
+        res.end('<html><head><meta name="referrer" content="no-referrer"></head><body style="font-family:system-ui;text-align:center;padding:60px"><h2>Invalid key</h2><p>The key format is unexpected. Please try again.</p></body></html>');
+        return;
+      }
+      res.end('<html><head><meta name="referrer" content="no-referrer"></head><body style="font-family:system-ui;text-align:center;padding:60px"><h2>Done!</h2><p>API key received. You can close this tab.</p></body></html>');
+      resolved = true;
+      verifyAndSaveKey(config, key).then(() => {
+        server.close();
+        process.exit(0);
+      }).catch((err) => {
+        console.error(`Setup failed: ${err.message}`);
+        server.close();
+        process.exit(1);
+      });
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(0, "127.0.0.1", () => {
+    const port = server.address().port;
+    const callbackUrl = `http://127.0.0.1:${port}/callback`;
+    const setupUrl = `${baseUrl}/setup?callback=${encodeURIComponent(callbackUrl)}&state=${state}&utm_source=cli&utm_medium=auto`;
+    console.log("Opening browser to sign in...");
+    console.log("");
+    openBrowser(setupUrl);
+    console.log("Waiting for authentication...");
+    console.log("(If the browser didn't open, visit this URL manually:)");
+    console.log(`  ${setupUrl}`);
+    console.log("");
+    setTimeout(() => {
+      if (!resolved) {
+        console.error("Timed out waiting for authentication (5 min).");
+        console.error("");
+        console.error("Alternatives:");
+        console.error("  prismer setup --manual    Paste key manually");
+        console.error("  prismer setup --agent     Register as agent (free credits, no browser)");
+        server.close();
+        process.exit(1);
+      }
+    }, 5 * 60 * 1e3);
+  });
+}
+program.command("setup [api-key]").description("Set up Prismer \u2014 sign in via browser, register as agent, or provide your API key").option("--manual", "Paste API key manually instead of browser auto-flow").option("--agent", "Register as agent with free credits (no browser, for CI/scripts)").option("--force", "Reconfigure even if already set up").action(async (apiKey, opts) => {
+  await runSetup(opts, apiKey);
+});
+program.command("init [api-key]").description('Alias for "prismer setup" (deprecated, use setup instead)').option("--manual", "Paste API key manually").option("--agent", "Register as agent with free credits").option("--force", "Reconfigure even if already set up").action(async (apiKey, opts) => {
+  console.log('Note: "prismer init" is deprecated. Use "prismer setup" instead.');
+  console.log("");
+  await runSetup(opts, apiKey);
 });
 program.command("register <username>").description("Register an IM identity and store the token").option("--type <type>", "Identity type: agent or human", "agent").option("--display-name <name>", "Display name").option("--agent-type <agentType>", "Agent type: assistant, specialist, orchestrator, tool, bot").option("--capabilities <caps>", "Comma-separated capabilities").option("--endpoint <url>", "Webhook endpoint URL").option("--webhook-secret <secret>", "Webhook HMAC secret").action(async (username, opts) => {
   const config = readConfig();
   const apiKey = config.default?.api_key;
   if (!apiKey) {
-    console.error('No API key. Run "prismer init <api-key>" first.');
+    console.error('No API key. Run "prismer setup" first.');
     process.exit(1);
   }
   const client = new PrismerClient({
@@ -4765,11 +6511,11 @@ program.command("status").description("Show current config and live info").actio
 });
 var configCmd = program.command("config").description("Manage config file");
 configCmd.command("show").description("Print config file").action(() => {
-  if (!fs.existsSync(CONFIG_PATH)) {
-    console.log('No config file. Run "prismer init <api-key>" to create one.');
+  if (!fs2.existsSync(CONFIG_PATH2)) {
+    console.log('No config file. Run "prismer setup" to create one.');
     return;
   }
-  console.log(fs.readFileSync(CONFIG_PATH, "utf-8"));
+  console.log(fs2.readFileSync(CONFIG_PATH2, "utf-8"));
 });
 configCmd.command("set <key> <value>").description("Set a config value (e.g. default.base_url)").action((key, value) => {
   const config = readConfig();
@@ -4810,6 +6556,7 @@ register6(program, getIMClient, getAPIClient);
 register7(program, getIMClient, getAPIClient);
 register8(program, getIMClient, getAPIClient);
 register9(program, getIMClient, getAPIClient);
+register10(program, getIMClient, getAPIClient);
 program.command("send").description("Send a direct message (shortcut for: im send)").argument("<user-id>", "Target user/agent ID").argument("<message>", "Message content").option("-t, --type <type>", "Message type: text, markdown, code, etc.", "text").option("--reply-to <id>", "Reply to a message ID").option("--json", "JSON output").action(async (userId, message, opts) => {
   const client = getIMClient();
   const sendOpts = {};
@@ -4972,6 +6719,28 @@ program.command("discover").description("Discover available agents (shortcut for
     console.log(`${(a.username || "").padEnd(20)}${(a.agentType || "").padEnd(14)}${(a.status || "").padEnd(10)}${a.displayName || ""}`);
   }
 });
+program.command("daemon <action>").description("Manage background sync daemon (start|stop|status|install|uninstall)").action(async (action) => {
+  switch (action) {
+    case "start":
+      await startDaemon();
+      break;
+    case "stop":
+      stopDaemon();
+      break;
+    case "status":
+      daemonStatus();
+      break;
+    case "install":
+      installDaemonService();
+      break;
+    case "uninstall":
+      uninstallDaemonService();
+      break;
+    default:
+      console.error(`Unknown daemon action: ${action}. Use: start, stop, status, install, uninstall`);
+      process.exit(1);
+  }
+});
 program.parse(process.argv);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {